mono_profiler_install (struct MonoProfiler * prof, void (*MonoProfileFunc) (struct MonoProfiler *) callback)
{
  struct ProfilerDesc * prof_list.0;
  struct ProfilerDesc * desc;

  desc = monoeg_malloc0 (208);
  prof_list.0 = prof_list;
  if (prof_list.0 == 0B) goto <D.17418>; else goto <D.17419>;
  <D.17418>:
  InitializeCriticalSection (&profiler_coverage_mutex);
  <D.17419>:
  desc->profiler = prof;
  desc->shutdown_callback = callback;
  prof_list.0 = prof_list;
  desc->next = prof_list.0;
  prof_list = desc;
}


mono_profiler_set_events (MonoProfileFlags events)
{
  struct ProfilerDesc * prof_list.1;
  <unnamed type> D.17423;
  struct ProfilerDesc * prof;
  MonoProfileFlags value;

  value = 0;
  prof_list.1 = prof_list;
  if (prof_list.1 != 0B) goto <D.17421>; else goto <D.17422>;
  <D.17421>:
  prof_list.1 = prof_list;
  prof_list.1->events = events;
  <D.17422>:
  prof = prof_list;
  goto <D.16839>;
  <D.16838>:
  D.17423 = prof->events;
  value = D.17423 | value;
  prof = prof->next;
  <D.16839>:
  if (prof != 0B) goto <D.16838>; else goto <D.16840>;
  <D.16840>:
  mono_profiler_events = value;
}


mono_profiler_get_events ()
{
  MonoProfileFlags D.17424;

  D.17424 = mono_profiler_events;
  return D.17424;
}


mono_profiler_install_enter_leave (void (*MonoProfileMethodFunc) (struct MonoProfiler *, struct MonoMethod *) enter, void (*MonoProfileMethodFunc) (struct MonoProfiler *, struct MonoMethod *) fleave)
{
  struct ProfilerDesc * prof_list.2;

  prof_list.2 = prof_list;
  if (prof_list.2 == 0B) goto <D.17427>; else goto <D.17428>;
  <D.17427>:
  return;
  <D.17428>:
  prof_list.2 = prof_list;
  prof_list.2->method_enter = enter;
  prof_list.2 = prof_list;
  prof_list.2->method_leave = fleave;
}


mono_profiler_install_jit_compile (void (*MonoProfileMethodFunc) (struct MonoProfiler *, struct MonoMethod *) start, void (*MonoProfileMethodResult) (struct MonoProfiler *, struct MonoMethod *, int) end)
{
  struct ProfilerDesc * prof_list.3;

  prof_list.3 = prof_list;
  if (prof_list.3 == 0B) goto <D.17431>; else goto <D.17432>;
  <D.17431>:
  return;
  <D.17432>:
  prof_list.3 = prof_list;
  prof_list.3->jit_start = start;
  prof_list.3 = prof_list;
  prof_list.3->jit_end = end;
}


mono_profiler_install_jit_end (void (*MonoProfileJitResult) (struct MonoProfiler *, struct MonoMethod *, struct MonoJitInfo *, int) end)
{
  struct ProfilerDesc * prof_list.4;

  prof_list.4 = prof_list;
  if (prof_list.4 == 0B) goto <D.17435>; else goto <D.17436>;
  <D.17435>:
  return;
  <D.17436>:
  prof_list.4 = prof_list;
  prof_list.4->jit_end2 = end;
}


mono_profiler_install_method_free (void (*MonoProfileMethodFunc) (struct MonoProfiler *, struct MonoMethod *) callback)
{
  struct ProfilerDesc * prof_list.5;

  prof_list.5 = prof_list;
  if (prof_list.5 == 0B) goto <D.17439>; else goto <D.17440>;
  <D.17439>:
  return;
  <D.17440>:
  prof_list.5 = prof_list;
  prof_list.5->method_free = callback;
}


mono_profiler_install_method_invoke (void (*MonoProfileMethodFunc) (struct MonoProfiler *, struct MonoMethod *) start, void (*MonoProfileMethodFunc) (struct MonoProfiler *, struct MonoMethod *) end)
{
  struct ProfilerDesc * prof_list.6;

  prof_list.6 = prof_list;
  if (prof_list.6 == 0B) goto <D.17443>; else goto <D.17444>;
  <D.17443>:
  return;
  <D.17444>:
  prof_list.6 = prof_list;
  prof_list.6->method_start_invoke = start;
  prof_list.6 = prof_list;
  prof_list.6->method_end_invoke = end;
}


mono_profiler_install_thread (void (*MonoProfileThreadFunc) (struct MonoProfiler *, uintptr_t) start, void (*MonoProfileThreadFunc) (struct MonoProfiler *, uintptr_t) end)
{
  struct ProfilerDesc * prof_list.7;

  prof_list.7 = prof_list;
  if (prof_list.7 == 0B) goto <D.17447>; else goto <D.17448>;
  <D.17447>:
  return;
  <D.17448>:
  prof_list.7 = prof_list;
  prof_list.7->thread_start = start;
  prof_list.7 = prof_list;
  prof_list.7->thread_end = end;
}


mono_profiler_install_thread_name (void (*MonoProfileThreadNameFunc) (struct MonoProfiler *, uintptr_t, const char *) thread_name_cb)
{
  struct ProfilerDesc * prof_list.8;

  prof_list.8 = prof_list;
  if (prof_list.8 == 0B) goto <D.17451>; else goto <D.17452>;
  <D.17451>:
  return;
  <D.17452>:
  prof_list.8 = prof_list;
  prof_list.8->thread_name = thread_name_cb;
}


mono_profiler_install_transition (void (*MonoProfileMethodResult) (struct MonoProfiler *, struct MonoMethod *, int) callback)
{
  struct ProfilerDesc * prof_list.9;

  prof_list.9 = prof_list;
  if (prof_list.9 == 0B) goto <D.17455>; else goto <D.17456>;
  <D.17455>:
  return;
  <D.17456>:
  prof_list.9 = prof_list;
  prof_list.9->man_unman_transition = callback;
}


mono_profiler_install_allocation (void (*MonoProfileAllocFunc) (struct MonoProfiler *, struct MonoObject *, struct MonoClass *) callback)
{
  struct ProfilerDesc * prof_list.10;

  prof_list.10 = prof_list;
  if (prof_list.10 == 0B) goto <D.17459>; else goto <D.17460>;
  <D.17459>:
  return;
  <D.17460>:
  prof_list.10 = prof_list;
  prof_list.10->allocation_cb = callback;
}


mono_profiler_install_monitor (void (*MonoProfileMonitorFunc) (struct MonoProfiler *, struct MonoObject *, MonoProfilerMonitorEvent) callback)
{
  struct ProfilerDesc * prof_list.11;

  prof_list.11 = prof_list;
  if (prof_list.11 == 0B) goto <D.17463>; else goto <D.17464>;
  <D.17463>:
  return;
  <D.17464>:
  prof_list.11 = prof_list;
  prof_list.11->monitor_event_cb = callback;
}


mono_profiler_install_statistical (void (*MonoProfileStatFunc) (struct MonoProfiler *, mono_byte *, void *) callback)
{
  struct ProfilerDesc * prof_list.12;

  prof_list.12 = prof_list;
  if (prof_list.12 == 0B) goto <D.17467>; else goto <D.17468>;
  <D.17467>:
  return;
  <D.17468>:
  prof_list.12 = prof_list;
  prof_list.12->statistical_cb = callback;
}


mono_profiler_install_statistical_call_chain (void (*MonoProfileStatCallChainFunc) (struct MonoProfiler *, int, mono_byte * *, void *) callback, int call_chain_depth, MonoProfilerCallChainStrategy call_chain_strategy)
{
  struct ProfilerDesc * prof_list.13;

  prof_list.13 = prof_list;
  if (prof_list.13 == 0B) goto <D.17471>; else goto <D.17472>;
  <D.17471>:
  return;
  <D.17472>:
  if (call_chain_depth > 128) goto <D.17473>; else goto <D.17474>;
  <D.17473>:
  call_chain_depth = 128;
  <D.17474>:
  if (call_chain_strategy > 3) goto <D.17475>; else goto <D.17476>;
  <D.17475>:
  call_chain_strategy = 0;
  <D.17476>:
  prof_list.13 = prof_list;
  prof_list.13->statistical_call_chain_cb = callback;
  prof_list.13 = prof_list;
  prof_list.13->statistical_call_chain_depth = call_chain_depth;
  prof_list.13 = prof_list;
  prof_list.13->statistical_call_chain_strategy = call_chain_strategy;
}


mono_profiler_stat_get_call_chain_depth ()
{
  struct ProfilerDesc * prof_list.14;
  void (*<Tb99>) (struct MonoProfiler *, int, mono_byte * *, void *) D.17481;
  int D.17483;

  prof_list.14 = prof_list;
  if (prof_list.14 != 0B) goto <D.17480>; else goto <D.17478>;
  <D.17480>:
  prof_list.14 = prof_list;
  D.17481 = prof_list.14->statistical_call_chain_cb;
  if (D.17481 != 0B) goto <D.17482>; else goto <D.17478>;
  <D.17482>:
  prof_list.14 = prof_list;
  D.17483 = prof_list.14->statistical_call_chain_depth;
  return D.17483;
  <D.17478>:
  D.17483 = 0;
  return D.17483;
}


mono_profiler_stat_get_call_chain_strategy ()
{
  struct ProfilerDesc * prof_list.15;
  void (*<Tb99>) (struct MonoProfiler *, int, mono_byte * *, void *) D.17488;
  MonoProfilerCallChainStrategy D.17490;

  prof_list.15 = prof_list;
  if (prof_list.15 != 0B) goto <D.17487>; else goto <D.17485>;
  <D.17487>:
  prof_list.15 = prof_list;
  D.17488 = prof_list.15->statistical_call_chain_cb;
  if (D.17488 != 0B) goto <D.17489>; else goto <D.17485>;
  <D.17489>:
  prof_list.15 = prof_list;
  D.17490 = prof_list.15->statistical_call_chain_strategy;
  return D.17490;
  <D.17485>:
  D.17490 = 0;
  return D.17490;
}


mono_profiler_install_exception (void (*MonoProfileExceptionFunc) (struct MonoProfiler *, struct MonoObject *) throw_callback, void (*MonoProfileMethodFunc) (struct MonoProfiler *, struct MonoMethod *) exc_method_leave, void (*MonoProfileExceptionClauseFunc) (struct MonoProfiler *, struct MonoMethod *, int, int) clause_callback)
{
  struct ProfilerDesc * prof_list.16;

  prof_list.16 = prof_list;
  if (prof_list.16 == 0B) goto <D.17493>; else goto <D.17494>;
  <D.17493>:
  return;
  <D.17494>:
  prof_list.16 = prof_list;
  prof_list.16->exception_throw_cb = throw_callback;
  prof_list.16 = prof_list;
  prof_list.16->exception_method_leave_cb = exc_method_leave;
  prof_list.16 = prof_list;
  prof_list.16->exception_clause_cb = clause_callback;
}


mono_profiler_install_coverage_filter (mono_bool (*MonoProfileCoverageFilterFunc) (struct MonoProfiler *, struct MonoMethod *) callback)
{
  struct ProfilerDesc * prof_list.17;

  prof_list.17 = prof_list;
  if (prof_list.17 == 0B) goto <D.17497>; else goto <D.17498>;
  <D.17497>:
  return;
  <D.17498>:
  prof_list.17 = prof_list;
  prof_list.17->coverage_filter_cb = callback;
}


mono_profiler_install_appdomain (void (*MonoProfileAppDomainFunc) (struct MonoProfiler *, struct MonoDomain *) start_load, void (*MonoProfileAppDomainResult) (struct MonoProfiler *, struct MonoDomain *, int) end_load, void (*MonoProfileAppDomainFunc) (struct MonoProfiler *, struct MonoDomain *) start_unload, void (*MonoProfileAppDomainFunc) (struct MonoProfiler *, struct MonoDomain *) end_unload)
{
  struct ProfilerDesc * prof_list.18;

  prof_list.18 = prof_list;
  if (prof_list.18 == 0B) goto <D.17501>; else goto <D.17502>;
  <D.17501>:
  return;
  <D.17502>:
  prof_list.18 = prof_list;
  prof_list.18->domain_start_load = start_load;
  prof_list.18 = prof_list;
  prof_list.18->domain_end_load = end_load;
  prof_list.18 = prof_list;
  prof_list.18->domain_start_unload = start_unload;
  prof_list.18 = prof_list;
  prof_list.18->domain_end_unload = end_unload;
}


mono_profiler_install_assembly (void (*MonoProfileAssemblyFunc) (struct MonoProfiler *, struct MonoAssembly *) start_load, void (*MonoProfileAssemblyResult) (struct MonoProfiler *, struct MonoAssembly *, int) end_load, void (*MonoProfileAssemblyFunc) (struct MonoProfiler *, struct MonoAssembly *) start_unload, void (*MonoProfileAssemblyFunc) (struct MonoProfiler *, struct MonoAssembly *) end_unload)
{
  struct ProfilerDesc * prof_list.19;

  prof_list.19 = prof_list;
  if (prof_list.19 == 0B) goto <D.17505>; else goto <D.17506>;
  <D.17505>:
  return;
  <D.17506>:
  prof_list.19 = prof_list;
  prof_list.19->assembly_start_load = start_load;
  prof_list.19 = prof_list;
  prof_list.19->assembly_end_load = end_load;
  prof_list.19 = prof_list;
  prof_list.19->assembly_start_unload = start_unload;
  prof_list.19 = prof_list;
  prof_list.19->assembly_end_unload = end_unload;
}


mono_profiler_install_module (void (*MonoProfileModuleFunc) (struct MonoProfiler *, struct MonoImage *) start_load, void (*MonoProfileModuleResult) (struct MonoProfiler *, struct MonoImage *, int) end_load, void (*MonoProfileModuleFunc) (struct MonoProfiler *, struct MonoImage *) start_unload, void (*MonoProfileModuleFunc) (struct MonoProfiler *, struct MonoImage *) end_unload)
{
  struct ProfilerDesc * prof_list.20;

  prof_list.20 = prof_list;
  if (prof_list.20 == 0B) goto <D.17509>; else goto <D.17510>;
  <D.17509>:
  return;
  <D.17510>:
  prof_list.20 = prof_list;
  prof_list.20->module_start_load = start_load;
  prof_list.20 = prof_list;
  prof_list.20->module_end_load = end_load;
  prof_list.20 = prof_list;
  prof_list.20->module_start_unload = start_unload;
  prof_list.20 = prof_list;
  prof_list.20->module_end_unload = end_unload;
}


mono_profiler_install_class (void (*MonoProfileClassFunc) (struct MonoProfiler *, struct MonoClass *) start_load, void (*MonoProfileClassResult) (struct MonoProfiler *, struct MonoClass *, int) end_load, void (*MonoProfileClassFunc) (struct MonoProfiler *, struct MonoClass *) start_unload, void (*MonoProfileClassFunc) (struct MonoProfiler *, struct MonoClass *) end_unload)
{
  struct ProfilerDesc * prof_list.21;

  prof_list.21 = prof_list;
  if (prof_list.21 == 0B) goto <D.17513>; else goto <D.17514>;
  <D.17513>:
  return;
  <D.17514>:
  prof_list.21 = prof_list;
  prof_list.21->class_start_load = start_load;
  prof_list.21 = prof_list;
  prof_list.21->class_end_load = end_load;
  prof_list.21 = prof_list;
  prof_list.21->class_start_unload = start_unload;
  prof_list.21 = prof_list;
  prof_list.21->class_end_unload = end_unload;
}


mono_profiler_method_enter (struct MonoMethod * method)
{
  <unnamed type> D.17516;
  unsigned int D.17517;
  void (*<Tb3d>) (struct MonoProfiler *, struct MonoMethod *) D.17520;
  struct MonoProfiler * D.17523;
  struct ProfilerDesc * prof;

  prof = prof_list;
  goto <D.16929>;
  <D.16928>:
  D.17516 = prof->events;
  D.17517 = D.17516 & 4096;
  if (D.17517 != 0) goto <D.17518>; else goto <D.17519>;
  <D.17518>:
  D.17520 = prof->method_enter;
  if (D.17520 != 0B) goto <D.17521>; else goto <D.17522>;
  <D.17521>:
  D.17520 = prof->method_enter;
  D.17523 = prof->profiler;
  D.17520 (D.17523, method);
  <D.17522>:
  <D.17519>:
  prof = prof->next;
  <D.16929>:
  if (prof != 0B) goto <D.16928>; else goto <D.16930>;
  <D.16930>:
}


mono_profiler_method_leave (struct MonoMethod * method)
{
  <unnamed type> D.17524;
  unsigned int D.17525;
  void (*<Tb3d>) (struct MonoProfiler *, struct MonoMethod *) D.17528;
  struct MonoProfiler * D.17531;
  struct ProfilerDesc * prof;

  prof = prof_list;
  goto <D.16936>;
  <D.16935>:
  D.17524 = prof->events;
  D.17525 = D.17524 & 4096;
  if (D.17525 != 0) goto <D.17526>; else goto <D.17527>;
  <D.17526>:
  D.17528 = prof->method_leave;
  if (D.17528 != 0B) goto <D.17529>; else goto <D.17530>;
  <D.17529>:
  D.17528 = prof->method_leave;
  D.17531 = prof->profiler;
  D.17528 (D.17531, method);
  <D.17530>:
  <D.17527>:
  prof = prof->next;
  <D.16936>:
  if (prof != 0B) goto <D.16935>; else goto <D.16937>;
  <D.16937>:
}


mono_profiler_method_jit (struct MonoMethod * method)
{
  <unnamed type> D.17532;
  unsigned int D.17533;
  void (*<Tb3d>) (struct MonoProfiler *, struct MonoMethod *) D.17536;
  struct MonoProfiler * D.17539;
  struct ProfilerDesc * prof;

  prof = prof_list;
  goto <D.16943>;
  <D.16942>:
  D.17532 = prof->events;
  D.17533 = D.17532 & 16;
  if (D.17533 != 0) goto <D.17534>; else goto <D.17535>;
  <D.17534>:
  D.17536 = prof->jit_start;
  if (D.17536 != 0B) goto <D.17537>; else goto <D.17538>;
  <D.17537>:
  D.17536 = prof->jit_start;
  D.17539 = prof->profiler;
  D.17536 (D.17539, method);
  <D.17538>:
  <D.17535>:
  prof = prof->next;
  <D.16943>:
  if (prof != 0B) goto <D.16942>; else goto <D.16944>;
  <D.16944>:
}


mono_profiler_method_end_jit (struct MonoMethod * method, struct MonoJitInfo * jinfo, int result)
{
  <unnamed type> D.17540;
  unsigned int D.17541;
  void (*<Tb65>) (struct MonoProfiler *, struct MonoMethod *, int) D.17544;
  struct MonoProfiler * D.17547;
  void (*<Tb6a>) (struct MonoProfiler *, struct MonoMethod *, struct MonoJitInfo *, int) D.17548;
  struct ProfilerDesc * prof;

  prof = prof_list;
  goto <D.16952>;
  <D.16951>:
  D.17540 = prof->events;
  D.17541 = D.17540 & 16;
  if (D.17541 != 0) goto <D.17542>; else goto <D.17543>;
  <D.17542>:
  D.17544 = prof->jit_end;
  if (D.17544 != 0B) goto <D.17545>; else goto <D.17546>;
  <D.17545>:
  D.17544 = prof->jit_end;
  D.17547 = prof->profiler;
  D.17544 (D.17547, method, result);
  <D.17546>:
  D.17548 = prof->jit_end2;
  if (D.17548 != 0B) goto <D.17549>; else goto <D.17550>;
  <D.17549>:
  D.17548 = prof->jit_end2;
  D.17547 = prof->profiler;
  D.17548 (D.17547, method, jinfo, result);
  <D.17550>:
  <D.17543>:
  prof = prof->next;
  <D.16952>:
  if (prof != 0B) goto <D.16951>; else goto <D.16953>;
  <D.16953>:
}


mono_profiler_method_free (struct MonoMethod * method)
{
  <unnamed type> D.17551;
  unsigned int D.17552;
  void (*<Tb3d>) (struct MonoProfiler *, struct MonoMethod *) D.17555;
  struct MonoProfiler * D.17558;
  struct ProfilerDesc * prof;

  prof = prof_list;
  goto <D.16959>;
  <D.16958>:
  D.17551 = prof->events;
  D.17552 = D.17551 & 65536;
  if (D.17552 != 0) goto <D.17553>; else goto <D.17554>;
  <D.17553>:
  D.17555 = prof->method_free;
  if (D.17555 != 0B) goto <D.17556>; else goto <D.17557>;
  <D.17556>:
  D.17555 = prof->method_free;
  D.17558 = prof->profiler;
  D.17555 (D.17558, method);
  <D.17557>:
  <D.17554>:
  prof = prof->next;
  <D.16959>:
  if (prof != 0B) goto <D.16958>; else goto <D.16960>;
  <D.16960>:
}


mono_profiler_method_start_invoke (struct MonoMethod * method)
{
  <unnamed type> D.17559;
  unsigned int D.17560;
  void (*<Tb3d>) (struct MonoProfiler *, struct MonoMethod *) D.17563;
  struct MonoProfiler * D.17566;
  struct ProfilerDesc * prof;

  prof = prof_list;
  goto <D.16966>;
  <D.16965>:
  D.17559 = prof->events;
  D.17560 = D.17559 & 65536;
  if (D.17560 != 0) goto <D.17561>; else goto <D.17562>;
  <D.17561>:
  D.17563 = prof->method_start_invoke;
  if (D.17563 != 0B) goto <D.17564>; else goto <D.17565>;
  <D.17564>:
  D.17563 = prof->method_start_invoke;
  D.17566 = prof->profiler;
  D.17563 (D.17566, method);
  <D.17565>:
  <D.17562>:
  prof = prof->next;
  <D.16966>:
  if (prof != 0B) goto <D.16965>; else goto <D.16967>;
  <D.16967>:
}


mono_profiler_method_end_invoke (struct MonoMethod * method)
{
  <unnamed type> D.17567;
  unsigned int D.17568;
  void (*<Tb3d>) (struct MonoProfiler *, struct MonoMethod *) D.17571;
  struct MonoProfiler * D.17574;
  struct ProfilerDesc * prof;

  prof = prof_list;
  goto <D.16973>;
  <D.16972>:
  D.17567 = prof->events;
  D.17568 = D.17567 & 65536;
  if (D.17568 != 0) goto <D.17569>; else goto <D.17570>;
  <D.17569>:
  D.17571 = prof->method_end_invoke;
  if (D.17571 != 0B) goto <D.17572>; else goto <D.17573>;
  <D.17572>:
  D.17571 = prof->method_end_invoke;
  D.17574 = prof->profiler;
  D.17571 (D.17574, method);
  <D.17573>:
  <D.17570>:
  prof = prof->next;
  <D.16973>:
  if (prof != 0B) goto <D.16972>; else goto <D.16974>;
  <D.16974>:
}


mono_profiler_code_transition (struct MonoMethod * method, int result)
{
  <unnamed type> D.17575;
  unsigned int D.17576;
  void (*<Tb65>) (struct MonoProfiler *, struct MonoMethod *, int) D.17579;
  struct MonoProfiler * D.17582;
  struct ProfilerDesc * prof;

  prof = prof_list;
  goto <D.16981>;
  <D.16980>:
  D.17575 = prof->events;
  D.17576 = D.17575 & 2048;
  if (D.17576 != 0) goto <D.17577>; else goto <D.17578>;
  <D.17577>:
  D.17579 = prof->man_unman_transition;
  if (D.17579 != 0B) goto <D.17580>; else goto <D.17581>;
  <D.17580>:
  D.17579 = prof->man_unman_transition;
  D.17582 = prof->profiler;
  D.17579 (D.17582, method, result);
  <D.17581>:
  <D.17578>:
  prof = prof->next;
  <D.16981>:
  if (prof != 0B) goto <D.16980>; else goto <D.16982>;
  <D.16982>:
}


mono_profiler_allocation (struct MonoObject * obj, struct MonoClass * klass)
{
  <unnamed type> D.17583;
  unsigned int D.17584;
  void (*<Tb8d>) (struct MonoProfiler *, struct MonoObject *, struct MonoClass *) D.17587;
  struct MonoProfiler * D.17590;
  struct ProfilerDesc * prof;

  prof = prof_list;
  goto <D.16989>;
  <D.16988>:
  D.17583 = prof->events;
  D.17584 = D.17583 & 128;
  if (D.17584 != 0) goto <D.17585>; else goto <D.17586>;
  <D.17585>:
  D.17587 = prof->allocation_cb;
  if (D.17587 != 0B) goto <D.17588>; else goto <D.17589>;
  <D.17588>:
  D.17587 = prof->allocation_cb;
  D.17590 = prof->profiler;
  D.17587 (D.17590, obj, klass);
  <D.17589>:
  <D.17586>:
  prof = prof->next;
  <D.16989>:
  if (prof != 0B) goto <D.16988>; else goto <D.16990>;
  <D.16990>:
}


mono_profiler_monitor_event (struct MonoObject * obj, MonoProfilerMonitorEvent event)
{
  <unnamed type> D.17591;
  unsigned int D.17592;
  void (*<Tb51>) (struct MonoProfiler *, struct MonoObject *, MonoProfilerMonitorEvent) D.17595;
  struct MonoProfiler * D.17598;
  struct ProfilerDesc * prof;

  prof = prof_list;
  goto <D.16997>;
  <D.16996>:
  D.17591 = prof->events;
  D.17592 = D.17591 & 131072;
  if (D.17592 != 0) goto <D.17593>; else goto <D.17594>;
  <D.17593>:
  D.17595 = prof->monitor_event_cb;
  if (D.17595 != 0B) goto <D.17596>; else goto <D.17597>;
  <D.17596>:
  D.17595 = prof->monitor_event_cb;
  D.17598 = prof->profiler;
  D.17595 (D.17598, obj, event);
  <D.17597>:
  <D.17594>:
  prof = prof->next;
  <D.16997>:
  if (prof != 0B) goto <D.16996>; else goto <D.16998>;
  <D.16998>:
}


mono_profiler_stat_hit (guchar * ip, void * context)
{
  <unnamed type> D.17599;
  unsigned int D.17600;
  void (*<Tb93>) (struct MonoProfiler *, mono_byte *, void *) D.17603;
  struct MonoProfiler * D.17606;
  struct ProfilerDesc * prof;

  prof = prof_list;
  goto <D.17005>;
  <D.17004>:
  D.17599 = prof->events;
  D.17600 = D.17599 & 32768;
  if (D.17600 != 0) goto <D.17601>; else goto <D.17602>;
  <D.17601>:
  D.17603 = prof->statistical_cb;
  if (D.17603 != 0B) goto <D.17604>; else goto <D.17605>;
  <D.17604>:
  D.17603 = prof->statistical_cb;
  D.17606 = prof->profiler;
  D.17603 (D.17606, ip, context);
  <D.17605>:
  <D.17602>:
  prof = prof->next;
  <D.17005>:
  if (prof != 0B) goto <D.17004>; else goto <D.17006>;
  <D.17006>:
}


mono_profiler_stat_call_chain (int call_chain_depth, guchar * * ips, void * context)
{
  <unnamed type> D.17607;
  unsigned int D.17608;
  void (*<Tb99>) (struct MonoProfiler *, int, mono_byte * *, void *) D.17611;
  struct MonoProfiler * D.17614;
  struct ProfilerDesc * prof;

  prof = prof_list;
  goto <D.17014>;
  <D.17013>:
  D.17607 = prof->events;
  D.17608 = D.17607 & 32768;
  if (D.17608 != 0) goto <D.17609>; else goto <D.17610>;
  <D.17609>:
  D.17611 = prof->statistical_call_chain_cb;
  if (D.17611 != 0B) goto <D.17612>; else goto <D.17613>;
  <D.17612>:
  D.17611 = prof->statistical_call_chain_cb;
  D.17614 = prof->profiler;
  D.17611 (D.17614, call_chain_depth, ips, context);
  <D.17613>:
  <D.17610>:
  prof = prof->next;
  <D.17014>:
  if (prof != 0B) goto <D.17013>; else goto <D.17015>;
  <D.17015>:
}


mono_profiler_exception_thrown (struct MonoObject * exception)
{
  <unnamed type> D.17615;
  unsigned int D.17616;
  void (*<Tb56>) (struct MonoProfiler *, struct MonoObject *) D.17619;
  struct MonoProfiler * D.17622;
  struct ProfilerDesc * prof;

  prof = prof_list;
  goto <D.17021>;
  <D.17020>:
  D.17615 = prof->events;
  D.17616 = D.17615 & 64;
  if (D.17616 != 0) goto <D.17617>; else goto <D.17618>;
  <D.17617>:
  D.17619 = prof->exception_throw_cb;
  if (D.17619 != 0B) goto <D.17620>; else goto <D.17621>;
  <D.17620>:
  D.17619 = prof->exception_throw_cb;
  D.17622 = prof->profiler;
  D.17619 (D.17622, exception);
  <D.17621>:
  <D.17618>:
  prof = prof->next;
  <D.17021>:
  if (prof != 0B) goto <D.17020>; else goto <D.17022>;
  <D.17022>:
}


mono_profiler_exception_method_leave (struct MonoMethod * method)
{
  <unnamed type> D.17623;
  unsigned int D.17624;
  void (*<Tb3d>) (struct MonoProfiler *, struct MonoMethod *) D.17627;
  struct MonoProfiler * D.17630;
  struct ProfilerDesc * prof;

  prof = prof_list;
  goto <D.17028>;
  <D.17027>:
  D.17623 = prof->events;
  D.17624 = D.17623 & 64;
  if (D.17624 != 0) goto <D.17625>; else goto <D.17626>;
  <D.17625>:
  D.17627 = prof->exception_method_leave_cb;
  if (D.17627 != 0B) goto <D.17628>; else goto <D.17629>;
  <D.17628>:
  D.17627 = prof->exception_method_leave_cb;
  D.17630 = prof->profiler;
  D.17627 (D.17630, method);
  <D.17629>:
  <D.17626>:
  prof = prof->next;
  <D.17028>:
  if (prof != 0B) goto <D.17027>; else goto <D.17029>;
  <D.17029>:
}


mono_profiler_exception_clause_handler (struct MonoMethod * method, int clause_type, int clause_num)
{
  <unnamed type> D.17631;
  unsigned int D.17632;
  void (*<Tb5b>) (struct MonoProfiler *, struct MonoMethod *, int, int) D.17635;
  struct MonoProfiler * D.17638;
  struct ProfilerDesc * prof;

  prof = prof_list;
  goto <D.17037>;
  <D.17036>:
  D.17631 = prof->events;
  D.17632 = D.17631 & 64;
  if (D.17632 != 0) goto <D.17633>; else goto <D.17634>;
  <D.17633>:
  D.17635 = prof->exception_clause_cb;
  if (D.17635 != 0B) goto <D.17636>; else goto <D.17637>;
  <D.17636>:
  D.17635 = prof->exception_clause_cb;
  D.17638 = prof->profiler;
  D.17635 (D.17638, method, clause_type, clause_num);
  <D.17637>:
  <D.17634>:
  prof = prof->next;
  <D.17037>:
  if (prof != 0B) goto <D.17036>; else goto <D.17038>;
  <D.17038>:
}


mono_profiler_thread_start (gsize tid)
{
  <unnamed type> D.17639;
  unsigned int D.17640;
  void (*<Tb83>) (struct MonoProfiler *, uintptr_t) D.17643;
  struct MonoProfiler * D.17646;
  struct ProfilerDesc * prof;

  prof = prof_list;
  goto <D.17044>;
  <D.17043>:
  D.17639 = prof->events;
  D.17640 = D.17639 & 512;
  if (D.17640 != 0) goto <D.17641>; else goto <D.17642>;
  <D.17641>:
  D.17643 = prof->thread_start;
  if (D.17643 != 0B) goto <D.17644>; else goto <D.17645>;
  <D.17644>:
  D.17643 = prof->thread_start;
  D.17646 = prof->profiler;
  D.17643 (D.17646, tid);
  <D.17645>:
  <D.17642>:
  prof = prof->next;
  <D.17044>:
  if (prof != 0B) goto <D.17043>; else goto <D.17045>;
  <D.17045>:
}


mono_profiler_thread_end (gsize tid)
{
  <unnamed type> D.17647;
  unsigned int D.17648;
  void (*<Tb83>) (struct MonoProfiler *, uintptr_t) D.17651;
  struct MonoProfiler * D.17654;
  struct ProfilerDesc * prof;

  prof = prof_list;
  goto <D.17051>;
  <D.17050>:
  D.17647 = prof->events;
  D.17648 = D.17647 & 512;
  if (D.17648 != 0) goto <D.17649>; else goto <D.17650>;
  <D.17649>:
  D.17651 = prof->thread_end;
  if (D.17651 != 0B) goto <D.17652>; else goto <D.17653>;
  <D.17652>:
  D.17651 = prof->thread_end;
  D.17654 = prof->profiler;
  D.17651 (D.17654, tid);
  <D.17653>:
  <D.17650>:
  prof = prof->next;
  <D.17051>:
  if (prof != 0B) goto <D.17050>; else goto <D.17052>;
  <D.17052>:
}


mono_profiler_thread_name (gsize tid, const char * name)
{
  <unnamed type> D.17655;
  unsigned int D.17656;
  void (*<Tb88>) (struct MonoProfiler *, uintptr_t, const char *) D.17659;
  struct MonoProfiler * D.17662;
  struct ProfilerDesc * prof;

  prof = prof_list;
  goto <D.17059>;
  <D.17058>:
  D.17655 = prof->events;
  D.17656 = D.17655 & 512;
  if (D.17656 != 0) goto <D.17657>; else goto <D.17658>;
  <D.17657>:
  D.17659 = prof->thread_name;
  if (D.17659 != 0B) goto <D.17660>; else goto <D.17661>;
  <D.17660>:
  D.17659 = prof->thread_name;
  D.17662 = prof->profiler;
  D.17659 (D.17662, tid, name);
  <D.17661>:
  <D.17658>:
  prof = prof->next;
  <D.17059>:
  if (prof != 0B) goto <D.17058>; else goto <D.17060>;
  <D.17060>:
}


mono_profiler_assembly_event (struct MonoAssembly * assembly, int code)
{
  <unnamed type> D.17663;
  unsigned int D.17664;
  void (*<Tb4c>) (struct MonoProfiler *, struct MonoAssembly *) D.17667;
  struct MonoProfiler * D.17670;
  void (*<Tb4c>) (struct MonoProfiler *, struct MonoAssembly *) D.17671;
  void (*<Tb4c>) (struct MonoProfiler *, struct MonoAssembly *) D.17674;
  struct ProfilerDesc * prof;

  prof = prof_list;
  goto <D.17073>;
  <D.17072>:
  D.17663 = prof->events;
  D.17664 = D.17663 & 2;
  if (D.17664 == 0) goto <D.17665>; else goto <D.17666>;
  <D.17665>:
  // predicted unlikely by continue predictor.
  goto <D.17066>;
  <D.17666>:
  switch (code) <default: <D.17071>, case 0: <D.17067>, case 2: <D.17069>, case 3: <D.17070>>
  <D.17067>:
  D.17667 = prof->assembly_start_load;
  if (D.17667 != 0B) goto <D.17668>; else goto <D.17669>;
  <D.17668>:
  D.17667 = prof->assembly_start_load;
  D.17670 = prof->profiler;
  D.17667 (D.17670, assembly);
  <D.17669>:
  goto <D.17068>;
  <D.17069>:
  D.17671 = prof->assembly_start_unload;
  if (D.17671 != 0B) goto <D.17672>; else goto <D.17673>;
  <D.17672>:
  D.17671 = prof->assembly_start_unload;
  D.17670 = prof->profiler;
  D.17671 (D.17670, assembly);
  <D.17673>:
  goto <D.17068>;
  <D.17070>:
  D.17674 = prof->assembly_end_unload;
  if (D.17674 != 0B) goto <D.17675>; else goto <D.17676>;
  <D.17675>:
  D.17674 = prof->assembly_end_unload;
  D.17670 = prof->profiler;
  D.17674 (D.17670, assembly);
  <D.17676>:
  goto <D.17068>;
  <D.17071>:
  monoeg_assertion_message ("* Assertion: should not be reached at %s:%d\n", "profiler.c", 588);
  <D.17068>:
  <D.17066>:
  prof = prof->next;
  <D.17073>:
  if (prof != 0B) goto <D.17072>; else goto <D.17074>;
  <D.17074>:
}


mono_profiler_assembly_loaded (struct MonoAssembly * assembly, int result)
{
  <unnamed type> D.17677;
  unsigned int D.17678;
  void (*<Tb79>) (struct MonoProfiler *, struct MonoAssembly *, int) D.17681;
  struct MonoProfiler * D.17684;
  struct ProfilerDesc * prof;

  prof = prof_list;
  goto <D.17081>;
  <D.17080>:
  D.17677 = prof->events;
  D.17678 = D.17677 & 2;
  if (D.17678 != 0) goto <D.17679>; else goto <D.17680>;
  <D.17679>:
  D.17681 = prof->assembly_end_load;
  if (D.17681 != 0B) goto <D.17682>; else goto <D.17683>;
  <D.17682>:
  D.17681 = prof->assembly_end_load;
  D.17684 = prof->profiler;
  D.17681 (D.17684, assembly, result);
  <D.17683>:
  <D.17680>:
  prof = prof->next;
  <D.17081>:
  if (prof != 0B) goto <D.17080>; else goto <D.17082>;
  <D.17082>:
}


mono_profiler_iomap (char * report, const char * pathname, const char * new_pathname)
{
  <unnamed type> D.17685;
  unsigned int D.17686;
  void (*<Tbb7>) (struct MonoProfiler *, const char *, const char *, const char *) D.17689;
  struct MonoProfiler * D.17692;
  struct ProfilerDesc * prof;

  prof = prof_list;
  goto <D.17090>;
  <D.17089>:
  D.17685 = prof->events;
  D.17686 = D.17685 & 262144;
  if (D.17686 != 0) goto <D.17687>; else goto <D.17688>;
  <D.17687>:
  D.17689 = prof->iomap_cb;
  if (D.17689 != 0B) goto <D.17690>; else goto <D.17691>;
  <D.17690>:
  D.17689 = prof->iomap_cb;
  D.17692 = prof->profiler;
  D.17689 (D.17692, report, pathname, new_pathname);
  <D.17691>:
  <D.17688>:
  prof = prof->next;
  <D.17090>:
  if (prof != 0B) goto <D.17089>; else goto <D.17091>;
  <D.17091>:
}


mono_profiler_module_event (struct MonoImage * module, int code)
{
  <unnamed type> D.17693;
  unsigned int D.17694;
  void (*<Tb47>) (struct MonoProfiler *, struct MonoImage *) D.17697;
  struct MonoProfiler * D.17700;
  void (*<Tb47>) (struct MonoProfiler *, struct MonoImage *) D.17701;
  void (*<Tb47>) (struct MonoProfiler *, struct MonoImage *) D.17704;
  struct ProfilerDesc * prof;

  prof = prof_list;
  goto <D.17104>;
  <D.17103>:
  D.17693 = prof->events;
  D.17694 = D.17693 & 4;
  if (D.17694 == 0) goto <D.17695>; else goto <D.17696>;
  <D.17695>:
  // predicted unlikely by continue predictor.
  goto <D.17097>;
  <D.17696>:
  switch (code) <default: <D.17102>, case 0: <D.17098>, case 2: <D.17100>, case 3: <D.17101>>
  <D.17098>:
  D.17697 = prof->module_start_load;
  if (D.17697 != 0B) goto <D.17698>; else goto <D.17699>;
  <D.17698>:
  D.17697 = prof->module_start_load;
  D.17700 = prof->profiler;
  D.17697 (D.17700, module);
  <D.17699>:
  goto <D.17099>;
  <D.17100>:
  D.17701 = prof->module_start_unload;
  if (D.17701 != 0B) goto <D.17702>; else goto <D.17703>;
  <D.17702>:
  D.17701 = prof->module_start_unload;
  D.17700 = prof->profiler;
  D.17701 (D.17700, module);
  <D.17703>:
  goto <D.17099>;
  <D.17101>:
  D.17704 = prof->module_end_unload;
  if (D.17704 != 0B) goto <D.17705>; else goto <D.17706>;
  <D.17705>:
  D.17704 = prof->module_end_unload;
  D.17700 = prof->profiler;
  D.17704 (D.17700, module);
  <D.17706>:
  goto <D.17099>;
  <D.17102>:
  monoeg_assertion_message ("* Assertion: should not be reached at %s:%d\n", "profiler.c", 634);
  <D.17099>:
  <D.17097>:
  prof = prof->next;
  <D.17104>:
  if (prof != 0B) goto <D.17103>; else goto <D.17105>;
  <D.17105>:
}


mono_profiler_module_loaded (struct MonoImage * module, int result)
{
  <unnamed type> D.17707;
  unsigned int D.17708;
  void (*<Tb74>) (struct MonoProfiler *, struct MonoImage *, int) D.17711;
  struct MonoProfiler * D.17714;
  struct ProfilerDesc * prof;

  prof = prof_list;
  goto <D.17112>;
  <D.17111>:
  D.17707 = prof->events;
  D.17708 = D.17707 & 4;
  if (D.17708 != 0) goto <D.17709>; else goto <D.17710>;
  <D.17709>:
  D.17711 = prof->module_end_load;
  if (D.17711 != 0B) goto <D.17712>; else goto <D.17713>;
  <D.17712>:
  D.17711 = prof->module_end_load;
  D.17714 = prof->profiler;
  D.17711 (D.17714, module, result);
  <D.17713>:
  <D.17710>:
  prof = prof->next;
  <D.17112>:
  if (prof != 0B) goto <D.17111>; else goto <D.17113>;
  <D.17113>:
}


mono_profiler_class_event (struct MonoClass * klass, int code)
{
  <unnamed type> D.17715;
  unsigned int D.17716;
  void (*<Tb42>) (struct MonoProfiler *, struct MonoClass *) D.17719;
  struct MonoProfiler * D.17722;
  void (*<Tb42>) (struct MonoProfiler *, struct MonoClass *) D.17723;
  void (*<Tb42>) (struct MonoProfiler *, struct MonoClass *) D.17726;
  struct ProfilerDesc * prof;

  prof = prof_list;
  goto <D.17126>;
  <D.17125>:
  D.17715 = prof->events;
  D.17716 = D.17715 & 8;
  if (D.17716 == 0) goto <D.17717>; else goto <D.17718>;
  <D.17717>:
  // predicted unlikely by continue predictor.
  goto <D.17119>;
  <D.17718>:
  switch (code) <default: <D.17124>, case 0: <D.17120>, case 2: <D.17122>, case 3: <D.17123>>
  <D.17120>:
  D.17719 = prof->class_start_load;
  if (D.17719 != 0B) goto <D.17720>; else goto <D.17721>;
  <D.17720>:
  D.17719 = prof->class_start_load;
  D.17722 = prof->profiler;
  D.17719 (D.17722, klass);
  <D.17721>:
  goto <D.17121>;
  <D.17122>:
  D.17723 = prof->class_start_unload;
  if (D.17723 != 0B) goto <D.17724>; else goto <D.17725>;
  <D.17724>:
  D.17723 = prof->class_start_unload;
  D.17722 = prof->profiler;
  D.17723 (D.17722, klass);
  <D.17725>:
  goto <D.17121>;
  <D.17123>:
  D.17726 = prof->class_end_unload;
  if (D.17726 != 0B) goto <D.17727>; else goto <D.17728>;
  <D.17727>:
  D.17726 = prof->class_end_unload;
  D.17722 = prof->profiler;
  D.17726 (D.17722, klass);
  <D.17728>:
  goto <D.17121>;
  <D.17124>:
  monoeg_assertion_message ("* Assertion: should not be reached at %s:%d\n", "profiler.c", 671);
  <D.17121>:
  <D.17119>:
  prof = prof->next;
  <D.17126>:
  if (prof != 0B) goto <D.17125>; else goto <D.17127>;
  <D.17127>:
}


mono_profiler_class_loaded (struct MonoClass * klass, int result)
{
  <unnamed type> D.17729;
  unsigned int D.17730;
  void (*<Tb6f>) (struct MonoProfiler *, struct MonoClass *, int) D.17733;
  struct MonoProfiler * D.17736;
  struct ProfilerDesc * prof;

  prof = prof_list;
  goto <D.17134>;
  <D.17133>:
  D.17729 = prof->events;
  D.17730 = D.17729 & 8;
  if (D.17730 != 0) goto <D.17731>; else goto <D.17732>;
  <D.17731>:
  D.17733 = prof->class_end_load;
  if (D.17733 != 0B) goto <D.17734>; else goto <D.17735>;
  <D.17734>:
  D.17733 = prof->class_end_load;
  D.17736 = prof->profiler;
  D.17733 (D.17736, klass, result);
  <D.17735>:
  <D.17732>:
  prof = prof->next;
  <D.17134>:
  if (prof != 0B) goto <D.17133>; else goto <D.17135>;
  <D.17135>:
}


mono_profiler_appdomain_event (struct MonoDomain * domain, int code)
{
  <unnamed type> D.17737;
  unsigned int D.17738;
  void (*<Tb38>) (struct MonoProfiler *, struct MonoDomain *) D.17741;
  struct MonoProfiler * D.17744;
  void (*<Tb38>) (struct MonoProfiler *, struct MonoDomain *) D.17745;
  void (*<Tb38>) (struct MonoProfiler *, struct MonoDomain *) D.17748;
  struct ProfilerDesc * prof;

  prof = prof_list;
  goto <D.17148>;
  <D.17147>:
  D.17737 = prof->events;
  D.17738 = D.17737 & 1;
  if (D.17738 == 0) goto <D.17739>; else goto <D.17740>;
  <D.17739>:
  // predicted unlikely by continue predictor.
  goto <D.17141>;
  <D.17740>:
  switch (code) <default: <D.17146>, case 0: <D.17142>, case 2: <D.17144>, case 3: <D.17145>>
  <D.17142>:
  D.17741 = prof->domain_start_load;
  if (D.17741 != 0B) goto <D.17742>; else goto <D.17743>;
  <D.17742>:
  D.17741 = prof->domain_start_load;
  D.17744 = prof->profiler;
  D.17741 (D.17744, domain);
  <D.17743>:
  goto <D.17143>;
  <D.17144>:
  D.17745 = prof->domain_start_unload;
  if (D.17745 != 0B) goto <D.17746>; else goto <D.17747>;
  <D.17746>:
  D.17745 = prof->domain_start_unload;
  D.17744 = prof->profiler;
  D.17745 (D.17744, domain);
  <D.17747>:
  goto <D.17143>;
  <D.17145>:
  D.17748 = prof->domain_end_unload;
  if (D.17748 != 0B) goto <D.17749>; else goto <D.17750>;
  <D.17749>:
  D.17748 = prof->domain_end_unload;
  D.17744 = prof->profiler;
  D.17748 (D.17744, domain);
  <D.17750>:
  goto <D.17143>;
  <D.17146>:
  monoeg_assertion_message ("* Assertion: should not be reached at %s:%d\n", "profiler.c", 708);
  <D.17143>:
  <D.17141>:
  prof = prof->next;
  <D.17148>:
  if (prof != 0B) goto <D.17147>; else goto <D.17149>;
  <D.17149>:
}


mono_profiler_appdomain_loaded (struct MonoDomain * domain, int result)
{
  <unnamed type> D.17751;
  unsigned int D.17752;
  void (*<Tb60>) (struct MonoProfiler *, struct MonoDomain *, int) D.17755;
  struct MonoProfiler * D.17758;
  struct ProfilerDesc * prof;

  prof = prof_list;
  goto <D.17156>;
  <D.17155>:
  D.17751 = prof->events;
  D.17752 = D.17751 & 1;
  if (D.17752 != 0) goto <D.17753>; else goto <D.17754>;
  <D.17753>:
  D.17755 = prof->domain_end_load;
  if (D.17755 != 0B) goto <D.17756>; else goto <D.17757>;
  <D.17756>:
  D.17755 = prof->domain_end_load;
  D.17758 = prof->profiler;
  D.17755 (D.17758, domain, result);
  <D.17757>:
  <D.17754>:
  prof = prof->next;
  <D.17156>:
  if (prof != 0B) goto <D.17155>; else goto <D.17157>;
  <D.17157>:
}


mono_profiler_shutdown ()
{
  void (*<Tb33>) (struct MonoProfiler *) D.17759;
  struct MonoProfiler * D.17762;
  struct ProfilerDesc * prof;

  prof = prof_list;
  goto <D.17163>;
  <D.17162>:
  D.17759 = prof->shutdown_callback;
  if (D.17759 != 0B) goto <D.17760>; else goto <D.17761>;
  <D.17760>:
  D.17759 = prof->shutdown_callback;
  D.17762 = prof->profiler;
  D.17759 (D.17762);
  <D.17761>:
  prof = prof->next;
  <D.17163>:
  if (prof != 0B) goto <D.17162>; else goto <D.17164>;
  <D.17164>:
  mono_profiler_set_events (0);
}


mono_profiler_gc_heap_resize (gint64 new_size)
{
  <unnamed type> D.17763;
  unsigned int D.17764;
  void (*<Tba8>) (struct MonoProfiler *, int64_t) D.17767;
  struct MonoProfiler * D.17770;
  struct ProfilerDesc * prof;

  prof = prof_list;
  goto <D.17170>;
  <D.17169>:
  D.17763 = prof->events;
  D.17764 = D.17763 & 256;
  if (D.17764 != 0) goto <D.17765>; else goto <D.17766>;
  <D.17765>:
  D.17767 = prof->gc_heap_resize;
  if (D.17767 != 0B) goto <D.17768>; else goto <D.17769>;
  <D.17768>:
  D.17767 = prof->gc_heap_resize;
  D.17770 = prof->profiler;
  D.17767 (D.17770, new_size);
  <D.17769>:
  <D.17766>:
  prof = prof->next;
  <D.17170>:
  if (prof != 0B) goto <D.17169>; else goto <D.17171>;
  <D.17171>:
}


mono_profiler_gc_event (MonoGCEvent event, int generation)
{
  <unnamed type> D.17771;
  unsigned int D.17772;
  void (*<Tb9e>) (struct MonoProfiler *, MonoGCEvent, int) D.17775;
  struct MonoProfiler * D.17778;
  struct ProfilerDesc * prof;

  prof = prof_list;
  goto <D.17178>;
  <D.17177>:
  D.17771 = prof->events;
  D.17772 = D.17771 & 256;
  if (D.17772 != 0) goto <D.17773>; else goto <D.17774>;
  <D.17773>:
  D.17775 = prof->gc_event;
  if (D.17775 != 0B) goto <D.17776>; else goto <D.17777>;
  <D.17776>:
  D.17775 = prof->gc_event;
  D.17778 = prof->profiler;
  D.17775 (D.17778, event, generation);
  <D.17777>:
  <D.17774>:
  prof = prof->next;
  <D.17178>:
  if (prof != 0B) goto <D.17177>; else goto <D.17179>;
  <D.17179>:
}


mono_profiler_gc_moves (void * * objects, int num)
{
  <unnamed type> D.17779;
  unsigned int D.17780;
  void (*<Tba3>) (struct MonoProfiler *, void * *, int) D.17783;
  struct MonoProfiler * D.17786;
  struct ProfilerDesc * prof;

  prof = prof_list;
  goto <D.17186>;
  <D.17185>:
  D.17779 = prof->events;
  D.17780 = D.17779 & 524288;
  if (D.17780 != 0) goto <D.17781>; else goto <D.17782>;
  <D.17781>:
  D.17783 = prof->gc_moves;
  if (D.17783 != 0B) goto <D.17784>; else goto <D.17785>;
  <D.17784>:
  D.17783 = prof->gc_moves;
  D.17786 = prof->profiler;
  D.17783 (D.17786, objects, num);
  <D.17785>:
  <D.17782>:
  prof = prof->next;
  <D.17186>:
  if (prof != 0B) goto <D.17185>; else goto <D.17187>;
  <D.17187>:
}


mono_profiler_gc_handle (int op, int type, uintptr_t handle, struct MonoObject * obj)
{
  <unnamed type> D.17787;
  unsigned int D.17788;
  void (*<Tbad>) (struct MonoProfiler *, int, int, uintptr_t, struct MonoObject *) D.17791;
  struct MonoProfiler * D.17794;
  struct ProfilerDesc * prof;

  prof = prof_list;
  goto <D.17196>;
  <D.17195>:
  D.17787 = prof->events;
  D.17788 = D.17787 & 1048576;
  if (D.17788 != 0) goto <D.17789>; else goto <D.17790>;
  <D.17789>:
  D.17791 = prof->gc_handle;
  if (D.17791 != 0B) goto <D.17792>; else goto <D.17793>;
  <D.17792>:
  D.17791 = prof->gc_handle;
  D.17794 = prof->profiler;
  D.17791 (D.17794, op, type, handle, obj);
  <D.17793>:
  <D.17790>:
  prof = prof->next;
  <D.17196>:
  if (prof != 0B) goto <D.17195>; else goto <D.17197>;
  <D.17197>:
}


mono_profiler_gc_roots (int num, void * * objects, int * root_types, uintptr_t * extra_info)
{
  <unnamed type> D.17795;
  unsigned int D.17796;
  void (*<Tbb2>) (struct MonoProfiler *, int, void * *, int *, uintptr_t *) D.17799;
  struct MonoProfiler * D.17802;
  struct ProfilerDesc * prof;

  prof = prof_list;
  goto <D.17206>;
  <D.17205>:
  D.17795 = prof->events;
  D.17796 = D.17795 & 1048576;
  if (D.17796 != 0) goto <D.17797>; else goto <D.17798>;
  <D.17797>:
  D.17799 = prof->gc_roots;
  if (D.17799 != 0B) goto <D.17800>; else goto <D.17801>;
  <D.17800>:
  D.17799 = prof->gc_roots;
  D.17802 = prof->profiler;
  D.17799 (D.17802, num, objects, root_types, extra_info);
  <D.17801>:
  <D.17798>:
  prof = prof->next;
  <D.17206>:
  if (prof != 0B) goto <D.17205>; else goto <D.17207>;
  <D.17207>:
}


mono_profiler_install_gc (void (*MonoProfileGCFunc) (struct MonoProfiler *, MonoGCEvent, int) callback, void (*MonoProfileGCResizeFunc) (struct MonoProfiler *, int64_t) heap_resize_callback)
{
  struct ProfilerDesc * prof_list.22;

  mono_gc_enable_events ();
  prof_list.22 = prof_list;
  if (prof_list.22 == 0B) goto <D.17804>; else goto <D.17805>;
  <D.17804>:
  return;
  <D.17805>:
  prof_list.22 = prof_list;
  prof_list.22->gc_event = callback;
  prof_list.22 = prof_list;
  prof_list.22->gc_heap_resize = heap_resize_callback;
}


mono_profiler_install_gc_moves (void (*MonoProfileGCMoveFunc) (struct MonoProfiler *, void * *, int) callback)
{
  struct ProfilerDesc * prof_list.23;

  prof_list.23 = prof_list;
  if (prof_list.23 == 0B) goto <D.17808>; else goto <D.17809>;
  <D.17808>:
  return;
  <D.17809>:
  prof_list.23 = prof_list;
  prof_list.23->gc_moves = callback;
}


mono_profiler_install_gc_roots (void (*MonoProfileGCHandleFunc) (struct MonoProfiler *, int, int, uintptr_t, struct MonoObject *) handle_callback, void (*MonoProfileGCRootFunc) (struct MonoProfiler *, int, void * *, int *, uintptr_t *) roots_callback)
{
  struct ProfilerDesc * prof_list.24;

  prof_list.24 = prof_list;
  if (prof_list.24 == 0B) goto <D.17812>; else goto <D.17813>;
  <D.17812>:
  return;
  <D.17813>:
  prof_list.24 = prof_list;
  prof_list.24->gc_handle = handle_callback;
  prof_list.24 = prof_list;
  prof_list.24->gc_roots = roots_callback;
}


mono_profiler_install_runtime_initialized (void (*MonoProfileFunc) (struct MonoProfiler *) runtime_initialized_callback)
{
  struct ProfilerDesc * prof_list.25;

  prof_list.25 = prof_list;
  if (prof_list.25 == 0B) goto <D.17816>; else goto <D.17817>;
  <D.17816>:
  return;
  <D.17817>:
  prof_list.25 = prof_list;
  prof_list.25->runtime_initialized_event = runtime_initialized_callback;
}


mono_profiler_runtime_initialized ()
{
  void (*<Tb33>) (struct MonoProfiler *) D.17819;
  struct MonoProfiler * D.17822;
  struct ProfilerDesc * prof;

  prof = prof_list;
  goto <D.17227>;
  <D.17226>:
  D.17819 = prof->runtime_initialized_event;
  if (D.17819 != 0B) goto <D.17820>; else goto <D.17821>;
  <D.17820>:
  D.17819 = prof->runtime_initialized_event;
  D.17822 = prof->profiler;
  D.17819 (D.17822);
  <D.17821>:
  prof = prof->next;
  <D.17227>:
  if (prof != 0B) goto <D.17226>; else goto <D.17228>;
  <D.17228>:
}


mono_profiler_install_code_chunk_new (void (*MonoProfilerCodeChunkNew) (struct MonoProfiler *, void *, int) callback)
{
  struct ProfilerDesc * prof_list.26;

  prof_list.26 = prof_list;
  if (prof_list.26 == 0B) goto <D.17824>; else goto <D.17825>;
  <D.17824>:
  return;
  <D.17825>:
  prof_list.26 = prof_list;
  prof_list.26->code_chunk_new = callback;
}


mono_profiler_code_chunk_new (void * chunk, int size)
{
  void (*<Tbca>) (struct MonoProfiler *, void *, int) D.17827;
  struct MonoProfiler * D.17830;
  struct ProfilerDesc * prof;

  prof = prof_list;
  goto <D.17238>;
  <D.17237>:
  D.17827 = prof->code_chunk_new;
  if (D.17827 != 0B) goto <D.17828>; else goto <D.17829>;
  <D.17828>:
  D.17827 = prof->code_chunk_new;
  D.17830 = prof->profiler;
  D.17827 (D.17830, chunk, size);
  <D.17829>:
  prof = prof->next;
  <D.17238>:
  if (prof != 0B) goto <D.17237>; else goto <D.17239>;
  <D.17239>:
}


mono_profiler_install_code_chunk_destroy (void (*MonoProfilerCodeChunkDestroy) (struct MonoProfiler *, void *) callback)
{
  struct ProfilerDesc * prof_list.27;

  prof_list.27 = prof_list;
  if (prof_list.27 == 0B) goto <D.17832>; else goto <D.17833>;
  <D.17832>:
  return;
  <D.17833>:
  prof_list.27 = prof_list;
  prof_list.27->code_chunk_destroy = callback;
}


mono_profiler_code_chunk_destroy (void * chunk)
{
  void (*<Tbcf>) (struct MonoProfiler *, void *) D.17835;
  struct MonoProfiler * D.17838;
  struct ProfilerDesc * prof;

  prof = prof_list;
  goto <D.17248>;
  <D.17247>:
  D.17835 = prof->code_chunk_destroy;
  if (D.17835 != 0B) goto <D.17836>; else goto <D.17837>;
  <D.17836>:
  D.17835 = prof->code_chunk_destroy;
  D.17838 = prof->profiler;
  D.17835 (D.17838, chunk);
  <D.17837>:
  prof = prof->next;
  <D.17248>:
  if (prof != 0B) goto <D.17247>; else goto <D.17249>;
  <D.17249>:
}


mono_profiler_install_code_buffer_new (void (*MonoProfilerCodeBufferNew) (struct MonoProfiler *, void *, int, MonoProfilerCodeBufferType, void *) callback)
{
  struct ProfilerDesc * prof_list.28;

  prof_list.28 = prof_list;
  if (prof_list.28 == 0B) goto <D.17840>; else goto <D.17841>;
  <D.17840>:
  return;
  <D.17841>:
  prof_list.28 = prof_list;
  prof_list.28->code_buffer_new = callback;
}


mono_profiler_install_iomap (void (*MonoProfileIomapFunc) (struct MonoProfiler *, const char *, const char *, const char *) callback)
{
  struct ProfilerDesc * prof_list.29;

  prof_list.29 = prof_list;
  if (prof_list.29 == 0B) goto <D.17844>; else goto <D.17845>;
  <D.17844>:
  return;
  <D.17845>:
  prof_list.29 = prof_list;
  prof_list.29->iomap_cb = callback;
}


mono_profiler_code_buffer_new (void * buffer, int size, MonoProfilerCodeBufferType type, void * data)
{
  void (*<Tbd4>) (struct MonoProfiler *, void *, int, MonoProfilerCodeBufferType, void *) D.17847;
  struct MonoProfiler * D.17850;
  struct ProfilerDesc * prof;

  prof = prof_list;
  goto <D.17264>;
  <D.17263>:
  D.17847 = prof->code_buffer_new;
  if (D.17847 != 0B) goto <D.17848>; else goto <D.17849>;
  <D.17848>:
  D.17847 = prof->code_buffer_new;
  D.17850 = prof->profiler;
  D.17847 (D.17850, buffer, size, type, data);
  <D.17849>:
  prof = prof->next;
  <D.17264>:
  if (prof != 0B) goto <D.17263>; else goto <D.17265>;
  <D.17265>:
}


mono_profiler_coverage_alloc (struct MonoMethod * method, int entries)
{
  mono_bool (*<Tbbc>) (struct MonoProfiler *, struct MonoMethod *) D.17851;
  struct MonoProfiler * D.17854;
  int D.17855;
  struct MonoProfileCoverageInfo * D.17860;
  _Bool D.17863;
  long int D.17864;
  long int D.17865;
  struct GHashTable * coverage_hash.30;
  struct GHashTable * coverage_hash.31;
  unsigned int entries.32;
  unsigned int D.17873;
  unsigned int D.17874;
  _Bool D.17877;
  long int D.17878;
  long int D.17879;
  struct MonoProfileCoverageInfo * res;
  int instrument;
  struct ProfilerDesc * prof;

  instrument = 0;
  prof = prof_list;
  goto <D.17275>;
  <D.17274>:
  D.17851 = prof->coverage_filter_cb;
  if (D.17851 != 0B) goto <D.17852>; else goto <D.17853>;
  <D.17852>:
  D.17851 = prof->coverage_filter_cb;
  D.17854 = prof->profiler;
  D.17855 = D.17851 (D.17854, method);
  if (D.17855 != 0) goto <D.17856>; else goto <D.17857>;
  <D.17856>:
  instrument = 1;
  <D.17857>:
  <D.17853>:
  prof = prof->next;
  <D.17275>:
  if (prof != 0B) goto <D.17274>; else goto <D.17276>;
  <D.17276>:
  if (instrument == 0) goto <D.17858>; else goto <D.17859>;
  <D.17858>:
  D.17860 = 0B;
  return D.17860;
  <D.17859>:
  {
    int ret;

    ret = pthread_mutex_lock (&profiler_coverage_mutex.mutex);
    if (ret != 0) goto <D.17861>; else goto <D.17862>;
    <D.17861>:
    monoeg_g_log (0B, 16, "Bad call to mono_mutex_lock result %d", ret);
    <D.17862>:
    D.17863 = ret != 0;
    D.17864 = (long int) D.17863;
    D.17865 = __builtin_expect (D.17864, 0);
    if (D.17865 != 0) goto <D.17866>; else goto <D.17867>;
    <D.17866>:
    monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "profiler.c", 933, "ret == 0");
    <D.17867>:
  }
  coverage_hash.30 = coverage_hash;
  if (coverage_hash.30 == 0B) goto <D.17869>; else goto <D.17870>;
  <D.17869>:
  coverage_hash.31 = monoeg_g_hash_table_new (0B, 0B);
  coverage_hash = coverage_hash.31;
  <D.17870>:
  entries.32 = (unsigned int) entries;
  D.17873 = entries.32 * 8;
  D.17874 = D.17873 + 12;
  res = monoeg_malloc0 (D.17874);
  res->entries = entries;
  coverage_hash.30 = coverage_hash;
  monoeg_g_hash_table_insert_replace (coverage_hash.30, method, res, 0);
  {
    int ret;

    ret = pthread_mutex_unlock (&profiler_coverage_mutex.mutex);
    if (ret != 0) goto <D.17875>; else goto <D.17876>;
    <D.17875>:
    monoeg_g_log (0B, 16, "Bad call to mono_mutex_unlock result %d", ret);
    <D.17876>:
    D.17877 = ret != 0;
    D.17878 = (long int) D.17877;
    D.17879 = __builtin_expect (D.17878, 0);
    if (D.17879 != 0) goto <D.17880>; else goto <D.17881>;
    <D.17880>:
    monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "profiler.c", 942, "ret == 0");
    <D.17881>:
  }
  D.17860 = res;
  return D.17860;
}


mono_profiler_coverage_free (struct MonoMethod * method)
{
  _Bool D.17885;
  long int D.17886;
  long int D.17887;
  struct GHashTable * coverage_hash.33;
  _Bool D.17895;
  long int D.17896;
  long int D.17897;
  _Bool D.17904;
  long int D.17905;
  long int D.17906;
  struct MonoProfileCoverageInfo * info;

  {
    int ret;

    ret = pthread_mutex_lock (&profiler_coverage_mutex.mutex);
    if (ret != 0) goto <D.17883>; else goto <D.17884>;
    <D.17883>:
    monoeg_g_log (0B, 16, "Bad call to mono_mutex_lock result %d", ret);
    <D.17884>:
    D.17885 = ret != 0;
    D.17886 = (long int) D.17885;
    D.17887 = __builtin_expect (D.17886, 0);
    if (D.17887 != 0) goto <D.17888>; else goto <D.17889>;
    <D.17888>:
    monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "profiler.c", 953, "ret == 0");
    <D.17889>:
  }
  coverage_hash.33 = coverage_hash;
  if (coverage_hash.33 == 0B) goto <D.17891>; else goto <D.17892>;
  <D.17891>:
  {
    int ret;

    ret = pthread_mutex_unlock (&profiler_coverage_mutex.mutex);
    if (ret != 0) goto <D.17893>; else goto <D.17894>;
    <D.17893>:
    monoeg_g_log (0B, 16, "Bad call to mono_mutex_unlock result %d", ret);
    <D.17894>:
    D.17895 = ret != 0;
    D.17896 = (long int) D.17895;
    D.17897 = __builtin_expect (D.17896, 0);
    if (D.17897 != 0) goto <D.17898>; else goto <D.17899>;
    <D.17898>:
    monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "profiler.c", 955, "ret == 0");
    <D.17899>:
  }
  return;
  <D.17892>:
  coverage_hash.33 = coverage_hash;
  info = monoeg_g_hash_table_lookup (coverage_hash.33, method);
  if (info != 0B) goto <D.17900>; else goto <D.17901>;
  <D.17900>:
  monoeg_g_free (info);
  coverage_hash.33 = coverage_hash;
  monoeg_g_hash_table_remove (coverage_hash.33, method);
  <D.17901>:
  {
    int ret;

    ret = pthread_mutex_unlock (&profiler_coverage_mutex.mutex);
    if (ret != 0) goto <D.17902>; else goto <D.17903>;
    <D.17902>:
    monoeg_g_log (0B, 16, "Bad call to mono_mutex_unlock result %d", ret);
    <D.17903>:
    D.17904 = ret != 0;
    D.17905 = (long int) D.17904;
    D.17906 = __builtin_expect (D.17905, 0);
    if (D.17906 != 0) goto <D.17907>; else goto <D.17908>;
    <D.17907>:
    monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "profiler.c", 964, "ret == 0");
    <D.17908>:
  }
}


mono_profiler_coverage_get (struct MonoProfiler * prof, struct MonoMethod * method, void (*MonoProfileCoverageFunc) (struct MonoProfiler *, const struct MonoProfileCoverageEntry *) func)
{
  _Bool D.17912;
  long int D.17913;
  long int D.17914;
  struct GHashTable * coverage_hash.34;
  _Bool D.17920;
  long int D.17921;
  long int D.17922;
  unsigned int code_size.35;
  _Bool D.17928;
  _Bool D.17929;
  _Bool D.17930;
  int cil_code.36;
  int start.37;
  int D.17937;
  int D.17938;
  unsigned int offset.38;
  unsigned int D.17944;
  int D.17945;
  unsigned int D.17946;
  int D.17947;
  char * D.17948;
  int D.17949;
  struct MonoProfileCoverageInfo * info;
  int i;
  int offset;
  guint32 code_size;
  const unsigned char * start;
  const unsigned char * end;
  const unsigned char * cil_code;
  struct MonoMethodHeader * header;
  struct MonoProfileCoverageEntry entry;
  struct MonoDebugMethodInfo * debug_minfo;

  try
    {
      {
        int ret;

        ret = pthread_mutex_lock (&profiler_coverage_mutex.mutex);
        if (ret != 0) goto <D.17910>; else goto <D.17911>;
        <D.17910>:
        monoeg_g_log (0B, 16, "Bad call to mono_mutex_lock result %d", ret);
        <D.17911>:
        D.17912 = ret != 0;
        D.17913 = (long int) D.17912;
        D.17914 = __builtin_expect (D.17913, 0);
        if (D.17914 != 0) goto <D.17915>; else goto <D.17916>;
        <D.17915>:
        monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "profiler.c", 990, "ret == 0");
        <D.17916>:
      }
      coverage_hash.34 = coverage_hash;
      info = monoeg_g_hash_table_lookup (coverage_hash.34, method);
      {
        int ret;

        ret = pthread_mutex_unlock (&profiler_coverage_mutex.mutex);
        if (ret != 0) goto <D.17918>; else goto <D.17919>;
        <D.17918>:
        monoeg_g_log (0B, 16, "Bad call to mono_mutex_unlock result %d", ret);
        <D.17919>:
        D.17920 = ret != 0;
        D.17921 = (long int) D.17920;
        D.17922 = __builtin_expect (D.17921, 0);
        if (D.17922 != 0) goto <D.17923>; else goto <D.17924>;
        <D.17923>:
        monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "profiler.c", 992, "ret == 0");
        <D.17924>:
      }
      if (info == 0B) goto <D.17925>; else goto <D.17926>;
      <D.17925>:
      return;
      <D.17926>:
      header = mono_method_get_header (method);
      start = mono_method_header_get_code (header, &code_size, 0B);
      debug_minfo = mono_debug_lookup_method (method);
      code_size.35 = code_size;
      end = start + code_size.35;
      i = 0;
      goto <D.17306>;
      <D.17305>:
      cil_code = info->data[i].cil_code;
      D.17928 = cil_code != 0B;
      D.17929 = cil_code >= start;
      D.17930 = D.17928 & D.17929;
      if (D.17930 != 0) goto <D.17931>; else goto <D.17932>;
      <D.17931>:
      if (cil_code < end) goto <D.17933>; else goto <D.17934>;
      <D.17933>:
      {
        char * fname;

        fname = 0B;
        cil_code.36 = (int) cil_code;
        start.37 = (int) start;
        offset = cil_code.36 - start.37;
        entry.iloffset = offset;
        entry.method = method;
        D.17937 = info->data[i].count;
        entry.counter = D.17937;
        entry.col = 1;
        D.17938 = entry.col;
        entry.line = D.17938;
        entry.filename = 0B;
        if (debug_minfo != 0B) goto <D.17939>; else goto <D.17940>;
        <D.17939>:
        {
          struct MonoDebugSourceLocation * location;

          offset.38 = (unsigned int) offset;
          location = mono_debug_symfile_lookup_location (debug_minfo, offset.38);
          if (location != 0B) goto <D.17942>; else goto <D.17943>;
          <D.17942>:
          D.17944 = location->row;
          D.17945 = (int) D.17944;
          entry.line = D.17945;
          D.17946 = location->column;
          D.17947 = (int) D.17946;
          entry.col = D.17947;
          D.17948 = location->source_file;
          fname = monoeg_strdup (D.17948);
          entry.filename = fname;
          mono_debug_free_source_location (location);
          <D.17943>:
        }
        <D.17940>:
        func (prof, &entry);
        monoeg_g_free (fname);
      }
      <D.17934>:
      <D.17932>:
      i = i + 1;
      <D.17306>:
      D.17949 = info->entries;
      if (D.17949 > i) goto <D.17305>; else goto <D.17307>;
      <D.17307>:
      mono_metadata_free_mh (header);
    }
  finally
    {
      code_size = {CLOBBER};
      entry = {CLOBBER};
    }
}


monoeg_strdup (const gchar * str)
{
  gchar * D.17955;

  if (str != 0B) goto <D.17953>; else goto <D.17954>;
  <D.17953>:
  D.17955 = __strdup (str);
  return D.17955;
  <D.17954>:
  D.17955 = 0B;
  return D.17955;
}


mono_profiler_load (const char * desc)
{
  int D.17349;
  int iftmp.39;
  int D.17345;
  const char[8] * D.17963;
  unsigned char D.17964;
  int D.17965;
  unsigned char D.17966;
  int D.17967;
  _Bool D.17968;
  _Bool D.17969;
  _Bool D.17970;
  const unsigned char * D.17973;
  unsigned char D.17974;
  int D.17975;
  const unsigned char * D.17976;
  unsigned char D.17977;
  int D.17978;
  _Bool D.17979;
  _Bool D.17980;
  const unsigned char * D.17983;
  unsigned char D.17984;
  int D.17985;
  const unsigned char * D.17986;
  unsigned char D.17987;
  int D.17988;
  _Bool D.17989;
  _Bool D.17990;
  const unsigned char * D.17993;
  unsigned char D.17994;
  int D.17995;
  const unsigned char * D.17996;
  unsigned char D.17997;
  int D.17998;
  int D.18000;
  const gchar * D.18003;
  int D.17371;
  int iftmp.40;
  int D.17370;
  const char[5] * D.18007;
  unsigned char D.18008;
  int D.18009;
  unsigned char D.18010;
  int D.18011;
  _Bool D.18012;
  _Bool D.18013;
  _Bool D.18014;
  const unsigned char * D.18017;
  unsigned char D.18018;
  int D.18019;
  const unsigned char * D.18020;
  unsigned char D.18021;
  int D.18022;
  _Bool D.18023;
  _Bool D.18024;
  const unsigned char * D.18027;
  unsigned char D.18028;
  int D.18029;
  const unsigned char * D.18030;
  unsigned char D.18031;
  int D.18032;
  _Bool D.18033;
  _Bool D.18034;
  const unsigned char * D.18037;
  unsigned char D.18038;
  int D.18039;
  const unsigned char * D.18040;
  unsigned char D.18041;
  int D.18042;
  int D.17380;
  int iftmp.41;
  int D.17379;
  const char[6] * D.18050;
  unsigned char D.18051;
  int D.18052;
  unsigned char D.18053;
  int D.18054;
  _Bool D.18055;
  _Bool D.18056;
  _Bool D.18057;
  const unsigned char * D.18060;
  unsigned char D.18061;
  int D.18062;
  const unsigned char * D.18063;
  unsigned char D.18064;
  int D.18065;
  _Bool D.18066;
  _Bool D.18067;
  const unsigned char * D.18070;
  unsigned char D.18071;
  int D.18072;
  const unsigned char * D.18073;
  unsigned char D.18074;
  int D.18075;
  _Bool D.18076;
  _Bool D.18077;
  const unsigned char * D.18080;
  unsigned char D.18081;
  int D.18082;
  const unsigned char * D.18083;
  unsigned char D.18084;
  int D.18085;
  int D.17389;
  int iftmp.42;
  int D.17388;
  const char[5] * D.18093;
  unsigned char D.18094;
  int D.18095;
  unsigned char D.18096;
  int D.18097;
  _Bool D.18098;
  _Bool D.18099;
  _Bool D.18100;
  const unsigned char * D.18103;
  unsigned char D.18104;
  int D.18105;
  const unsigned char * D.18106;
  unsigned char D.18107;
  int D.18108;
  _Bool D.18109;
  _Bool D.18110;
  const unsigned char * D.18113;
  unsigned char D.18114;
  int D.18115;
  const unsigned char * D.18116;
  unsigned char D.18117;
  int D.18118;
  _Bool D.18119;
  _Bool D.18120;
  const unsigned char * D.18123;
  unsigned char D.18124;
  int D.18125;
  const unsigned char * D.18126;
  unsigned char D.18127;
  int D.18128;
  int D.17398;
  int iftmp.43;
  int D.17397;
  const char[4] * D.18136;
  unsigned char D.18137;
  int D.18138;
  unsigned char D.18139;
  int D.18140;
  _Bool D.18141;
  _Bool D.18142;
  _Bool D.18143;
  const unsigned char * D.18146;
  unsigned char D.18147;
  int D.18148;
  const unsigned char * D.18149;
  unsigned char D.18150;
  int D.18151;
  _Bool D.18152;
  _Bool D.18153;
  const unsigned char * D.18156;
  unsigned char D.18157;
  int D.18158;
  const unsigned char * D.18159;
  unsigned char D.18160;
  int D.18161;
  _Bool D.18162;
  _Bool D.18163;
  const unsigned char * D.18166;
  unsigned char D.18167;
  int D.18168;
  const unsigned char * D.18169;
  unsigned char D.18170;
  int D.18171;
  int D.18175;
  const char * D.18178;
  struct _IO_FILE * stderr.44;
  gchar * D.18182;
  int col.45;
  int desc.46;
  int D.18187;
  int D.18188;
  unsigned int D.18189;
  sizetype D.18190;
  char * D.18191;
  int D.18193;
  int D.18196;
  const char * D.18199;
  char * cdesc;

  cdesc = 0B;
  mono_gc_base_init ();
  if (desc == 0B) goto <D.17957>; else goto <D.17959>;
  <D.17959>:
  {
    size_t __s1_len;
    size_t __s2_len;

    __s1_len = 7;
    if (__s1_len <= 3) goto <D.17961>; else goto <D.17962>;
    <D.17961>:
    {
      const unsigned char * __s2;
      int __result;

      __s2 = desc;
      D.17963 = "default";
      D.17964 = MEM[(const unsigned char *)D.17963];
      D.17965 = (int) D.17964;
      D.17966 = *__s2;
      D.17967 = (int) D.17966;
      __result = D.17965 - D.17967;
      {
        D.17968 = __s1_len != 0;
        D.17969 = __result == 0;
        D.17970 = D.17968 & D.17969;
        if (D.17970 != 0) goto <D.17971>; else goto <D.17972>;
        <D.17971>:
        D.17973 = &MEM[(void *)"default" + 1B];
        D.17974 = *D.17973;
        D.17975 = (int) D.17974;
        D.17976 = __s2 + 1;
        D.17977 = *D.17976;
        D.17978 = (int) D.17977;
        __result = D.17975 - D.17978;
        D.17979 = __s1_len > 1;
        D.17969 = __result == 0;
        D.17980 = D.17979 & D.17969;
        if (D.17980 != 0) goto <D.17981>; else goto <D.17982>;
        <D.17981>:
        D.17983 = &MEM[(void *)"default" + 2B];
        D.17984 = *D.17983;
        D.17985 = (int) D.17984;
        D.17986 = __s2 + 2;
        D.17987 = *D.17986;
        D.17988 = (int) D.17987;
        __result = D.17985 - D.17988;
        D.17989 = __s1_len > 2;
        D.17969 = __result == 0;
        D.17990 = D.17989 & D.17969;
        if (D.17990 != 0) goto <D.17991>; else goto <D.17992>;
        <D.17991>:
        D.17993 = &MEM[(void *)"default" + 3B];
        D.17994 = *D.17993;
        D.17995 = (int) D.17994;
        D.17996 = __s2 + 3;
        D.17997 = *D.17996;
        D.17998 = (int) D.17997;
        __result = D.17995 - D.17998;
        <D.17992>:
        <D.17982>:
        <D.17972>:
      }
      D.17345 = __result;
    }
    iftmp.39 = D.17345;
    goto <D.17999>;
    <D.17962>:
    iftmp.39 = __builtin_strcmp ("default", desc);
    <D.17999>:
    D.17349 = iftmp.39;
  }
  if (D.17349 == 0) goto <D.17957>; else goto <D.17958>;
  <D.17957>:
  desc = "log:report";
  <D.17958>:
  D.18000 = strncmp (desc, "default:", 8);
  if (D.18000 == 0) goto <D.18001>; else goto <D.18002>;
  <D.18001>:
  {
    gchar * * args;
    gchar * * ptr;
    struct GString * str;

    str = monoeg_g_string_new ("log:report");
    D.18003 = desc + 8;
    args = monoeg_g_strsplit (D.18003, ",", -1);
    ptr = args;
    goto <D.17410>;
    <D.17409>:
    {
      const char * arg;

      arg = *ptr;
      {
        size_t __s1_len;
        size_t __s2_len;

        __s2_len = 4;
        if (__s2_len <= 3) goto <D.18005>; else goto <D.18006>;
        <D.18005>:
        {
          const unsigned char * __s2;
          int __result;

          __s2 = arg;
          D.18007 = "time";
          D.18008 = MEM[(const unsigned char *)D.18007];
          D.18009 = (int) D.18008;
          D.18010 = *__s2;
          D.18011 = (int) D.18010;
          __result = D.18009 - D.18011;
          {
            D.18012 = __s2_len != 0;
            D.18013 = __result == 0;
            D.18014 = D.18012 & D.18013;
            if (D.18014 != 0) goto <D.18015>; else goto <D.18016>;
            <D.18015>:
            D.18017 = &MEM[(void *)"time" + 1B];
            D.18018 = *D.18017;
            D.18019 = (int) D.18018;
            D.18020 = __s2 + 1;
            D.18021 = *D.18020;
            D.18022 = (int) D.18021;
            __result = D.18019 - D.18022;
            D.18023 = __s2_len > 1;
            D.18013 = __result == 0;
            D.18024 = D.18023 & D.18013;
            if (D.18024 != 0) goto <D.18025>; else goto <D.18026>;
            <D.18025>:
            D.18027 = &MEM[(void *)"time" + 2B];
            D.18028 = *D.18027;
            D.18029 = (int) D.18028;
            D.18030 = __s2 + 2;
            D.18031 = *D.18030;
            D.18032 = (int) D.18031;
            __result = D.18029 - D.18032;
            D.18033 = __s2_len > 2;
            D.18013 = __result == 0;
            D.18034 = D.18033 & D.18013;
            if (D.18034 != 0) goto <D.18035>; else goto <D.18036>;
            <D.18035>:
            D.18037 = &MEM[(void *)"time" + 3B];
            D.18038 = *D.18037;
            D.18039 = (int) D.18038;
            D.18040 = __s2 + 3;
            D.18041 = *D.18040;
            D.18042 = (int) D.18041;
            __result = D.18039 - D.18042;
            <D.18036>:
            <D.18026>:
            <D.18016>:
          }
          D.17370 = __result;
        }
        iftmp.40 = -D.17370;
        goto <D.18043>;
        <D.18006>:
        iftmp.40 = __builtin_strcmp (arg, "time");
        <D.18043>:
        D.17371 = iftmp.40;
      }
      if (D.17371 == 0) goto <D.18044>; else goto <D.18045>;
      <D.18044>:
      monoeg_g_string_append (str, ",calls");
      goto <D.18046>;
      <D.18045>:
      {
        size_t __s1_len;
        size_t __s2_len;

        __s2_len = 5;
        if (__s2_len <= 3) goto <D.18048>; else goto <D.18049>;
        <D.18048>:
        {
          const unsigned char * __s2;
          int __result;

          __s2 = arg;
          D.18050 = "alloc";
          D.18051 = MEM[(const unsigned char *)D.18050];
          D.18052 = (int) D.18051;
          D.18053 = *__s2;
          D.18054 = (int) D.18053;
          __result = D.18052 - D.18054;
          {
            D.18055 = __s2_len != 0;
            D.18056 = __result == 0;
            D.18057 = D.18055 & D.18056;
            if (D.18057 != 0) goto <D.18058>; else goto <D.18059>;
            <D.18058>:
            D.18060 = &MEM[(void *)"alloc" + 1B];
            D.18061 = *D.18060;
            D.18062 = (int) D.18061;
            D.18063 = __s2 + 1;
            D.18064 = *D.18063;
            D.18065 = (int) D.18064;
            __result = D.18062 - D.18065;
            D.18066 = __s2_len > 1;
            D.18056 = __result == 0;
            D.18067 = D.18066 & D.18056;
            if (D.18067 != 0) goto <D.18068>; else goto <D.18069>;
            <D.18068>:
            D.18070 = &MEM[(void *)"alloc" + 2B];
            D.18071 = *D.18070;
            D.18072 = (int) D.18071;
            D.18073 = __s2 + 2;
            D.18074 = *D.18073;
            D.18075 = (int) D.18074;
            __result = D.18072 - D.18075;
            D.18076 = __s2_len > 2;
            D.18056 = __result == 0;
            D.18077 = D.18076 & D.18056;
            if (D.18077 != 0) goto <D.18078>; else goto <D.18079>;
            <D.18078>:
            D.18080 = &MEM[(void *)"alloc" + 3B];
            D.18081 = *D.18080;
            D.18082 = (int) D.18081;
            D.18083 = __s2 + 3;
            D.18084 = *D.18083;
            D.18085 = (int) D.18084;
            __result = D.18082 - D.18085;
            <D.18079>:
            <D.18069>:
            <D.18059>:
          }
          D.17379 = __result;
        }
        iftmp.41 = -D.17379;
        goto <D.18086>;
        <D.18049>:
        iftmp.41 = __builtin_strcmp (arg, "alloc");
        <D.18086>:
        D.17380 = iftmp.41;
      }
      if (D.17380 == 0) goto <D.18087>; else goto <D.18088>;
      <D.18087>:
      monoeg_g_string_append (str, ",alloc");
      goto <D.18089>;
      <D.18088>:
      {
        size_t __s1_len;
        size_t __s2_len;

        __s2_len = 4;
        if (__s2_len <= 3) goto <D.18091>; else goto <D.18092>;
        <D.18091>:
        {
          const unsigned char * __s2;
          int __result;

          __s2 = arg;
          D.18093 = "stat";
          D.18094 = MEM[(const unsigned char *)D.18093];
          D.18095 = (int) D.18094;
          D.18096 = *__s2;
          D.18097 = (int) D.18096;
          __result = D.18095 - D.18097;
          {
            D.18098 = __s2_len != 0;
            D.18099 = __result == 0;
            D.18100 = D.18098 & D.18099;
            if (D.18100 != 0) goto <D.18101>; else goto <D.18102>;
            <D.18101>:
            D.18103 = &MEM[(void *)"stat" + 1B];
            D.18104 = *D.18103;
            D.18105 = (int) D.18104;
            D.18106 = __s2 + 1;
            D.18107 = *D.18106;
            D.18108 = (int) D.18107;
            __result = D.18105 - D.18108;
            D.18109 = __s2_len > 1;
            D.18099 = __result == 0;
            D.18110 = D.18109 & D.18099;
            if (D.18110 != 0) goto <D.18111>; else goto <D.18112>;
            <D.18111>:
            D.18113 = &MEM[(void *)"stat" + 2B];
            D.18114 = *D.18113;
            D.18115 = (int) D.18114;
            D.18116 = __s2 + 2;
            D.18117 = *D.18116;
            D.18118 = (int) D.18117;
            __result = D.18115 - D.18118;
            D.18119 = __s2_len > 2;
            D.18099 = __result == 0;
            D.18120 = D.18119 & D.18099;
            if (D.18120 != 0) goto <D.18121>; else goto <D.18122>;
            <D.18121>:
            D.18123 = &MEM[(void *)"stat" + 3B];
            D.18124 = *D.18123;
            D.18125 = (int) D.18124;
            D.18126 = __s2 + 3;
            D.18127 = *D.18126;
            D.18128 = (int) D.18127;
            __result = D.18125 - D.18128;
            <D.18122>:
            <D.18112>:
            <D.18102>:
          }
          D.17388 = __result;
        }
        iftmp.42 = -D.17388;
        goto <D.18129>;
        <D.18092>:
        iftmp.42 = __builtin_strcmp (arg, "stat");
        <D.18129>:
        D.17389 = iftmp.42;
      }
      if (D.17389 == 0) goto <D.18130>; else goto <D.18131>;
      <D.18130>:
      monoeg_g_string_append (str, ",sample");
      goto <D.18132>;
      <D.18131>:
      {
        size_t __s1_len;
        size_t __s2_len;

        __s2_len = 3;
        if (__s2_len <= 3) goto <D.18134>; else goto <D.18135>;
        <D.18134>:
        {
          const unsigned char * __s2;
          int __result;

          __s2 = arg;
          D.18136 = "jit";
          D.18137 = MEM[(const unsigned char *)D.18136];
          D.18138 = (int) D.18137;
          D.18139 = *__s2;
          D.18140 = (int) D.18139;
          __result = D.18138 - D.18140;
          {
            D.18141 = __s2_len != 0;
            D.18142 = __result == 0;
            D.18143 = D.18141 & D.18142;
            if (D.18143 != 0) goto <D.18144>; else goto <D.18145>;
            <D.18144>:
            D.18146 = &MEM[(void *)"jit" + 1B];
            D.18147 = *D.18146;
            D.18148 = (int) D.18147;
            D.18149 = __s2 + 1;
            D.18150 = *D.18149;
            D.18151 = (int) D.18150;
            __result = D.18148 - D.18151;
            D.18152 = __s2_len > 1;
            D.18142 = __result == 0;
            D.18153 = D.18152 & D.18142;
            if (D.18153 != 0) goto <D.18154>; else goto <D.18155>;
            <D.18154>:
            D.18156 = &MEM[(void *)"jit" + 2B];
            D.18157 = *D.18156;
            D.18158 = (int) D.18157;
            D.18159 = __s2 + 2;
            D.18160 = *D.18159;
            D.18161 = (int) D.18160;
            __result = D.18158 - D.18161;
            D.18162 = __s2_len > 2;
            D.18142 = __result == 0;
            D.18163 = D.18162 & D.18142;
            if (D.18163 != 0) goto <D.18164>; else goto <D.18165>;
            <D.18164>:
            D.18166 = &MEM[(void *)"jit" + 3B];
            D.18167 = *D.18166;
            D.18168 = (int) D.18167;
            D.18169 = __s2 + 3;
            D.18170 = *D.18169;
            D.18171 = (int) D.18170;
            __result = D.18168 - D.18171;
            <D.18165>:
            <D.18155>:
            <D.18145>:
          }
          D.17397 = __result;
        }
        iftmp.43 = -D.17397;
        goto <D.18172>;
        <D.18135>:
        iftmp.43 = __builtin_strcmp (arg, "jit");
        <D.18172>:
        D.17398 = iftmp.43;
      }
      if (D.17398 == 0) goto <D.18173>; else goto <D.18174>;
      <D.18173>:
      // predicted unlikely by continue predictor.
      goto <D.17399>;
      <D.18174>:
      D.18175 = strncmp (arg, "file=", 5);
      if (D.18175 == 0) goto <D.18176>; else goto <D.18177>;
      <D.18176>:
      D.18178 = arg + 5;
      monoeg_g_string_append_printf (str, ",output=%s", D.18178);
      goto <D.18179>;
      <D.18177>:
      stderr.44 = stderr;
      fprintf (stderr.44, "profiler : Unknown argument \'%s\'.\n", arg);
      return;
      <D.18179>:
      <D.18132>:
      <D.18089>:
      <D.18046>:
    }
    <D.17399>:
    ptr = ptr + 4;
    <D.17410>:
    if (ptr != 0B) goto <D.18181>; else goto <D.17411>;
    <D.18181>:
    D.18182 = *ptr;
    if (D.18182 != 0B) goto <D.17409>; else goto <D.17411>;
    <D.17411>:
    cdesc = monoeg_g_string_free (str, 0);
    desc = cdesc;
  }
  <D.18002>:
  {
    const char * col;
    char * libname;
    char * mname;
    gboolean res;

    col = __builtin_strchr (desc, 58);
    res = 0;
    if (col != 0B) goto <D.18183>; else goto <D.18184>;
    <D.18183>:
    col.45 = (int) col;
    desc.46 = (int) desc;
    D.18187 = col.45 - desc.46;
    D.18188 = D.18187 + 1;
    D.18189 = (unsigned int) D.18188;
    mname = monoeg_g_memdup (desc, D.18189);
    col.45 = (int) col;
    desc.46 = (int) desc;
    D.18187 = col.45 - desc.46;
    D.18190 = (sizetype) D.18187;
    D.18191 = mname + D.18190;
    *D.18191 = 0;
    goto <D.18192>;
    <D.18184>:
    mname = monoeg_strdup (desc);
    <D.18192>:
    D.18193 = load_embedded_profiler (desc, mname);
    if (D.18193 == 0) goto <D.18194>; else goto <D.18195>;
    <D.18194>:
    libname = monoeg_g_strdup_printf ("mono-profiler-%s", mname);
    D.18196 = load_profiler_from_directory (0B, libname, desc);
    if (D.18196 == 0) goto <D.18197>; else goto <D.18198>;
    <D.18197>:
    res = 0;
    D.18199 = mono_assembly_getrootdir ();
    res = load_profiler_from_directory (D.18199, libname, desc);
    if (res == 0) goto <D.18200>; else goto <D.18201>;
    <D.18200>:
    monoeg_g_log (0B, 16, "The \'%s\' profiler wasn\'t found in the main executable nor could it be loaded from \'%s\'.", mname, libname);
    <D.18201>:
    <D.18198>:
    monoeg_g_free (libname);
    <D.18195>:
    monoeg_g_free (mname);
  }
  monoeg_g_free (cdesc);
}


fprintf (struct FILE * restrict __stream, const char * restrict __fmt)
{
  int D.18203;

  D.18203 = __fprintf_chk (__stream, 1, __fmt, __builtin_va_arg_pack ());
  return D.18203;
}


load_embedded_profiler (const char * desc, const char * name)
{
  char * err.47;
  gboolean D.18208;
  char * err;
  char * symbol;
  struct MonoDl * pmodule;
  gboolean result;

  try
    {
      err = 0B;
      pmodule = 0B;
      pmodule = mono_dl_open (0B, 1, &err);
      if (pmodule == 0B) goto <D.18205>; else goto <D.18206>;
      <D.18205>:
      err.47 = err;
      monoeg_g_log (0B, 16, "Could not open main executable (%s)", err.47);
      err.47 = err;
      monoeg_g_free (err.47);
      D.18208 = 0;
      return D.18208;
      <D.18206>:
      symbol = monoeg_g_strdup_printf ("mono_profiler_startup_%s", name);
      result = load_profiler (pmodule, desc, symbol);
      monoeg_g_free (symbol);
      D.18208 = result;
      return D.18208;
    }
  finally
    {
      err = {CLOBBER};
    }
}


load_profiler (struct MonoDl * pmodule, const char * desc, const char * symbol)
{
  gboolean D.18213;
  void (*<T2cd2>) (const char *) func.48;
  char * err;
  void (*ProfilerInitializer) (const char *) func;

  try
    {
      if (pmodule == 0B) goto <D.18211>; else goto <D.18212>;
      <D.18211>:
      D.18213 = 0;
      return D.18213;
      <D.18212>:
      err = mono_dl_symbol (pmodule, symbol, &func);
      if (err != 0B) goto <D.18214>; else goto <D.18215>;
      <D.18214>:
      monoeg_g_free (err);
      D.18213 = 0;
      return D.18213;
      <D.18215>:
      func.48 = func;
      func.48 (desc);
      D.18213 = 1;
      return D.18213;
    }
  finally
    {
      func = {CLOBBER};
    }
}


load_profiler_from_directory (const char * directory, const char * libname, const char * desc)
{
  char * err.49;
  gboolean D.18222;
  struct MonoDl * pmodule;
  char * path;
  char * err;
  void * iter;

  try
    {
      pmodule = 0B;
      iter = 0B;
      err = 0B;
      goto <D.17335>;
      <D.17334>:
      pmodule = mono_dl_open (path, 1, &err);
      monoeg_g_free (path);
      err.49 = err;
      monoeg_g_free (err.49);
      if (pmodule != 0B) goto <D.18220>; else goto <D.18221>;
      <D.18220>:
      D.18222 = load_profiler (pmodule, desc, "mono_profiler_startup");
      return D.18222;
      <D.18221>:
      <D.17335>:
      path = mono_dl_build_path (directory, libname, &iter);
      if (path != 0B) goto <D.17334>; else goto <D.17336>;
      <D.17336>:
      D.18222 = 0;
      return D.18222;
    }
  finally
    {
      err = {CLOBBER};
      iter = {CLOBBER};
    }
}