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.17384>; else goto <D.17385>;
  <D.17384>:
  InitializeCriticalSection (&profiler_coverage_mutex);
  <D.17385>:
  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.17389;
  struct ProfilerDesc * prof;
  MonoProfileFlags value;

  value = 0;
  prof_list.1 = prof_list;
  if (prof_list.1 != 0B) goto <D.17387>; else goto <D.17388>;
  <D.17387>:
  prof_list.1 = prof_list;
  prof_list.1->events = events;
  <D.17388>:
  prof = prof_list;
  goto <D.16805>;
  <D.16804>:
  D.17389 = prof->events;
  value = D.17389 | value;
  prof = prof->next;
  <D.16805>:
  if (prof != 0B) goto <D.16804>; else goto <D.16806>;
  <D.16806>:
  mono_profiler_events = value;
}


mono_profiler_get_events ()
{
  MonoProfileFlags D.17390;

  D.17390 = mono_profiler_events;
  return D.17390;
}


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.17393>; else goto <D.17394>;
  <D.17393>:
  return;
  <D.17394>:
  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.17397>; else goto <D.17398>;
  <D.17397>:
  return;
  <D.17398>:
  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.17401>; else goto <D.17402>;
  <D.17401>:
  return;
  <D.17402>:
  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.17405>; else goto <D.17406>;
  <D.17405>:
  return;
  <D.17406>:
  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.17409>; else goto <D.17410>;
  <D.17409>:
  return;
  <D.17410>:
  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.17413>; else goto <D.17414>;
  <D.17413>:
  return;
  <D.17414>:
  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.17417>; else goto <D.17418>;
  <D.17417>:
  return;
  <D.17418>:
  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.17421>; else goto <D.17422>;
  <D.17421>:
  return;
  <D.17422>:
  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.17425>; else goto <D.17426>;
  <D.17425>:
  return;
  <D.17426>:
  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.17429>; else goto <D.17430>;
  <D.17429>:
  return;
  <D.17430>:
  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.17433>; else goto <D.17434>;
  <D.17433>:
  return;
  <D.17434>:
  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.17437>; else goto <D.17438>;
  <D.17437>:
  return;
  <D.17438>:
  if (call_chain_depth > 128) goto <D.17439>; else goto <D.17440>;
  <D.17439>:
  call_chain_depth = 128;
  <D.17440>:
  if (call_chain_strategy > 3) goto <D.17441>; else goto <D.17442>;
  <D.17441>:
  call_chain_strategy = 0;
  <D.17442>:
  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 (*<Tb89>) (struct MonoProfiler *, int, mono_byte * *, void *) D.17447;
  int D.17449;

  prof_list.14 = prof_list;
  if (prof_list.14 != 0B) goto <D.17446>; else goto <D.17444>;
  <D.17446>:
  prof_list.14 = prof_list;
  D.17447 = prof_list.14->statistical_call_chain_cb;
  if (D.17447 != 0B) goto <D.17448>; else goto <D.17444>;
  <D.17448>:
  prof_list.14 = prof_list;
  D.17449 = prof_list.14->statistical_call_chain_depth;
  return D.17449;
  <D.17444>:
  D.17449 = 0;
  return D.17449;
}


mono_profiler_stat_get_call_chain_strategy ()
{
  struct ProfilerDesc * prof_list.15;
  void (*<Tb89>) (struct MonoProfiler *, int, mono_byte * *, void *) D.17454;
  MonoProfilerCallChainStrategy D.17456;

  prof_list.15 = prof_list;
  if (prof_list.15 != 0B) goto <D.17453>; else goto <D.17451>;
  <D.17453>:
  prof_list.15 = prof_list;
  D.17454 = prof_list.15->statistical_call_chain_cb;
  if (D.17454 != 0B) goto <D.17455>; else goto <D.17451>;
  <D.17455>:
  prof_list.15 = prof_list;
  D.17456 = prof_list.15->statistical_call_chain_strategy;
  return D.17456;
  <D.17451>:
  D.17456 = 0;
  return D.17456;
}


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.17459>; else goto <D.17460>;
  <D.17459>:
  return;
  <D.17460>:
  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.17463>; else goto <D.17464>;
  <D.17463>:
  return;
  <D.17464>:
  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.17467>; else goto <D.17468>;
  <D.17467>:
  return;
  <D.17468>:
  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.17471>; else goto <D.17472>;
  <D.17471>:
  return;
  <D.17472>:
  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.17475>; else goto <D.17476>;
  <D.17475>:
  return;
  <D.17476>:
  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.17479>; else goto <D.17480>;
  <D.17479>:
  return;
  <D.17480>:
  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.17482;
  unsigned int D.17483;
  void (*<Tb2d>) (struct MonoProfiler *, struct MonoMethod *) D.17486;
  struct MonoProfiler * D.17489;
  struct ProfilerDesc * prof;

  prof = prof_list;
  goto <D.16895>;
  <D.16894>:
  D.17482 = prof->events;
  D.17483 = D.17482 & 4096;
  if (D.17483 != 0) goto <D.17484>; else goto <D.17485>;
  <D.17484>:
  D.17486 = prof->method_enter;
  if (D.17486 != 0B) goto <D.17487>; else goto <D.17488>;
  <D.17487>:
  D.17486 = prof->method_enter;
  D.17489 = prof->profiler;
  D.17486 (D.17489, method);
  <D.17488>:
  <D.17485>:
  prof = prof->next;
  <D.16895>:
  if (prof != 0B) goto <D.16894>; else goto <D.16896>;
  <D.16896>:
}


mono_profiler_method_leave (struct MonoMethod * method)
{
  <unnamed type> D.17490;
  unsigned int D.17491;
  void (*<Tb2d>) (struct MonoProfiler *, struct MonoMethod *) D.17494;
  struct MonoProfiler * D.17497;
  struct ProfilerDesc * prof;

  prof = prof_list;
  goto <D.16902>;
  <D.16901>:
  D.17490 = prof->events;
  D.17491 = D.17490 & 4096;
  if (D.17491 != 0) goto <D.17492>; else goto <D.17493>;
  <D.17492>:
  D.17494 = prof->method_leave;
  if (D.17494 != 0B) goto <D.17495>; else goto <D.17496>;
  <D.17495>:
  D.17494 = prof->method_leave;
  D.17497 = prof->profiler;
  D.17494 (D.17497, method);
  <D.17496>:
  <D.17493>:
  prof = prof->next;
  <D.16902>:
  if (prof != 0B) goto <D.16901>; else goto <D.16903>;
  <D.16903>:
}


mono_profiler_method_jit (struct MonoMethod * method)
{
  <unnamed type> D.17498;
  unsigned int D.17499;
  void (*<Tb2d>) (struct MonoProfiler *, struct MonoMethod *) D.17502;
  struct MonoProfiler * D.17505;
  struct ProfilerDesc * prof;

  prof = prof_list;
  goto <D.16909>;
  <D.16908>:
  D.17498 = prof->events;
  D.17499 = D.17498 & 16;
  if (D.17499 != 0) goto <D.17500>; else goto <D.17501>;
  <D.17500>:
  D.17502 = prof->jit_start;
  if (D.17502 != 0B) goto <D.17503>; else goto <D.17504>;
  <D.17503>:
  D.17502 = prof->jit_start;
  D.17505 = prof->profiler;
  D.17502 (D.17505, method);
  <D.17504>:
  <D.17501>:
  prof = prof->next;
  <D.16909>:
  if (prof != 0B) goto <D.16908>; else goto <D.16910>;
  <D.16910>:
}


mono_profiler_method_end_jit (struct MonoMethod * method, struct MonoJitInfo * jinfo, int result)
{
  <unnamed type> D.17506;
  unsigned int D.17507;
  void (*<Tb55>) (struct MonoProfiler *, struct MonoMethod *, int) D.17510;
  struct MonoProfiler * D.17513;
  void (*<Tb5a>) (struct MonoProfiler *, struct MonoMethod *, struct MonoJitInfo *, int) D.17514;
  struct ProfilerDesc * prof;

  prof = prof_list;
  goto <D.16918>;
  <D.16917>:
  D.17506 = prof->events;
  D.17507 = D.17506 & 16;
  if (D.17507 != 0) goto <D.17508>; else goto <D.17509>;
  <D.17508>:
  D.17510 = prof->jit_end;
  if (D.17510 != 0B) goto <D.17511>; else goto <D.17512>;
  <D.17511>:
  D.17510 = prof->jit_end;
  D.17513 = prof->profiler;
  D.17510 (D.17513, method, result);
  <D.17512>:
  D.17514 = prof->jit_end2;
  if (D.17514 != 0B) goto <D.17515>; else goto <D.17516>;
  <D.17515>:
  D.17514 = prof->jit_end2;
  D.17513 = prof->profiler;
  D.17514 (D.17513, method, jinfo, result);
  <D.17516>:
  <D.17509>:
  prof = prof->next;
  <D.16918>:
  if (prof != 0B) goto <D.16917>; else goto <D.16919>;
  <D.16919>:
}


mono_profiler_method_free (struct MonoMethod * method)
{
  <unnamed type> D.17517;
  unsigned int D.17518;
  void (*<Tb2d>) (struct MonoProfiler *, struct MonoMethod *) D.17521;
  struct MonoProfiler * D.17524;
  struct ProfilerDesc * prof;

  prof = prof_list;
  goto <D.16925>;
  <D.16924>:
  D.17517 = prof->events;
  D.17518 = D.17517 & 65536;
  if (D.17518 != 0) goto <D.17519>; else goto <D.17520>;
  <D.17519>:
  D.17521 = prof->method_free;
  if (D.17521 != 0B) goto <D.17522>; else goto <D.17523>;
  <D.17522>:
  D.17521 = prof->method_free;
  D.17524 = prof->profiler;
  D.17521 (D.17524, method);
  <D.17523>:
  <D.17520>:
  prof = prof->next;
  <D.16925>:
  if (prof != 0B) goto <D.16924>; else goto <D.16926>;
  <D.16926>:
}


mono_profiler_method_start_invoke (struct MonoMethod * method)
{
  <unnamed type> D.17525;
  unsigned int D.17526;
  void (*<Tb2d>) (struct MonoProfiler *, struct MonoMethod *) D.17529;
  struct MonoProfiler * D.17532;
  struct ProfilerDesc * prof;

  prof = prof_list;
  goto <D.16932>;
  <D.16931>:
  D.17525 = prof->events;
  D.17526 = D.17525 & 65536;
  if (D.17526 != 0) goto <D.17527>; else goto <D.17528>;
  <D.17527>:
  D.17529 = prof->method_start_invoke;
  if (D.17529 != 0B) goto <D.17530>; else goto <D.17531>;
  <D.17530>:
  D.17529 = prof->method_start_invoke;
  D.17532 = prof->profiler;
  D.17529 (D.17532, method);
  <D.17531>:
  <D.17528>:
  prof = prof->next;
  <D.16932>:
  if (prof != 0B) goto <D.16931>; else goto <D.16933>;
  <D.16933>:
}


mono_profiler_method_end_invoke (struct MonoMethod * method)
{
  <unnamed type> D.17533;
  unsigned int D.17534;
  void (*<Tb2d>) (struct MonoProfiler *, struct MonoMethod *) D.17537;
  struct MonoProfiler * D.17540;
  struct ProfilerDesc * prof;

  prof = prof_list;
  goto <D.16939>;
  <D.16938>:
  D.17533 = prof->events;
  D.17534 = D.17533 & 65536;
  if (D.17534 != 0) goto <D.17535>; else goto <D.17536>;
  <D.17535>:
  D.17537 = prof->method_end_invoke;
  if (D.17537 != 0B) goto <D.17538>; else goto <D.17539>;
  <D.17538>:
  D.17537 = prof->method_end_invoke;
  D.17540 = prof->profiler;
  D.17537 (D.17540, method);
  <D.17539>:
  <D.17536>:
  prof = prof->next;
  <D.16939>:
  if (prof != 0B) goto <D.16938>; else goto <D.16940>;
  <D.16940>:
}


mono_profiler_code_transition (struct MonoMethod * method, int result)
{
  <unnamed type> D.17541;
  unsigned int D.17542;
  void (*<Tb55>) (struct MonoProfiler *, struct MonoMethod *, int) D.17545;
  struct MonoProfiler * D.17548;
  struct ProfilerDesc * prof;

  prof = prof_list;
  goto <D.16947>;
  <D.16946>:
  D.17541 = prof->events;
  D.17542 = D.17541 & 2048;
  if (D.17542 != 0) goto <D.17543>; else goto <D.17544>;
  <D.17543>:
  D.17545 = prof->man_unman_transition;
  if (D.17545 != 0B) goto <D.17546>; else goto <D.17547>;
  <D.17546>:
  D.17545 = prof->man_unman_transition;
  D.17548 = prof->profiler;
  D.17545 (D.17548, method, result);
  <D.17547>:
  <D.17544>:
  prof = prof->next;
  <D.16947>:
  if (prof != 0B) goto <D.16946>; else goto <D.16948>;
  <D.16948>:
}


mono_profiler_allocation (struct MonoObject * obj, struct MonoClass * klass)
{
  <unnamed type> D.17549;
  unsigned int D.17550;
  void (*<Tb7d>) (struct MonoProfiler *, struct MonoObject *, struct MonoClass *) D.17553;
  struct MonoProfiler * D.17556;
  struct ProfilerDesc * prof;

  prof = prof_list;
  goto <D.16955>;
  <D.16954>:
  D.17549 = prof->events;
  D.17550 = D.17549 & 128;
  if (D.17550 != 0) goto <D.17551>; else goto <D.17552>;
  <D.17551>:
  D.17553 = prof->allocation_cb;
  if (D.17553 != 0B) goto <D.17554>; else goto <D.17555>;
  <D.17554>:
  D.17553 = prof->allocation_cb;
  D.17556 = prof->profiler;
  D.17553 (D.17556, obj, klass);
  <D.17555>:
  <D.17552>:
  prof = prof->next;
  <D.16955>:
  if (prof != 0B) goto <D.16954>; else goto <D.16956>;
  <D.16956>:
}


mono_profiler_monitor_event (struct MonoObject * obj, MonoProfilerMonitorEvent event)
{
  <unnamed type> D.17557;
  unsigned int D.17558;
  void (*<Tb41>) (struct MonoProfiler *, struct MonoObject *, MonoProfilerMonitorEvent) D.17561;
  struct MonoProfiler * D.17564;
  struct ProfilerDesc * prof;

  prof = prof_list;
  goto <D.16963>;
  <D.16962>:
  D.17557 = prof->events;
  D.17558 = D.17557 & 131072;
  if (D.17558 != 0) goto <D.17559>; else goto <D.17560>;
  <D.17559>:
  D.17561 = prof->monitor_event_cb;
  if (D.17561 != 0B) goto <D.17562>; else goto <D.17563>;
  <D.17562>:
  D.17561 = prof->monitor_event_cb;
  D.17564 = prof->profiler;
  D.17561 (D.17564, obj, event);
  <D.17563>:
  <D.17560>:
  prof = prof->next;
  <D.16963>:
  if (prof != 0B) goto <D.16962>; else goto <D.16964>;
  <D.16964>:
}


mono_profiler_stat_hit (guchar * ip, void * context)
{
  <unnamed type> D.17565;
  unsigned int D.17566;
  void (*<Tb83>) (struct MonoProfiler *, mono_byte *, void *) D.17569;
  struct MonoProfiler * D.17572;
  struct ProfilerDesc * prof;

  prof = prof_list;
  goto <D.16971>;
  <D.16970>:
  D.17565 = prof->events;
  D.17566 = D.17565 & 32768;
  if (D.17566 != 0) goto <D.17567>; else goto <D.17568>;
  <D.17567>:
  D.17569 = prof->statistical_cb;
  if (D.17569 != 0B) goto <D.17570>; else goto <D.17571>;
  <D.17570>:
  D.17569 = prof->statistical_cb;
  D.17572 = prof->profiler;
  D.17569 (D.17572, ip, context);
  <D.17571>:
  <D.17568>:
  prof = prof->next;
  <D.16971>:
  if (prof != 0B) goto <D.16970>; else goto <D.16972>;
  <D.16972>:
}


mono_profiler_stat_call_chain (int call_chain_depth, guchar * * ips, void * context)
{
  <unnamed type> D.17573;
  unsigned int D.17574;
  void (*<Tb89>) (struct MonoProfiler *, int, mono_byte * *, void *) D.17577;
  struct MonoProfiler * D.17580;
  struct ProfilerDesc * prof;

  prof = prof_list;
  goto <D.16980>;
  <D.16979>:
  D.17573 = prof->events;
  D.17574 = D.17573 & 32768;
  if (D.17574 != 0) goto <D.17575>; else goto <D.17576>;
  <D.17575>:
  D.17577 = prof->statistical_call_chain_cb;
  if (D.17577 != 0B) goto <D.17578>; else goto <D.17579>;
  <D.17578>:
  D.17577 = prof->statistical_call_chain_cb;
  D.17580 = prof->profiler;
  D.17577 (D.17580, call_chain_depth, ips, context);
  <D.17579>:
  <D.17576>:
  prof = prof->next;
  <D.16980>:
  if (prof != 0B) goto <D.16979>; else goto <D.16981>;
  <D.16981>:
}


mono_profiler_exception_thrown (struct MonoObject * exception)
{
  <unnamed type> D.17581;
  unsigned int D.17582;
  void (*<Tb46>) (struct MonoProfiler *, struct MonoObject *) D.17585;
  struct MonoProfiler * D.17588;
  struct ProfilerDesc * prof;

  prof = prof_list;
  goto <D.16987>;
  <D.16986>:
  D.17581 = prof->events;
  D.17582 = D.17581 & 64;
  if (D.17582 != 0) goto <D.17583>; else goto <D.17584>;
  <D.17583>:
  D.17585 = prof->exception_throw_cb;
  if (D.17585 != 0B) goto <D.17586>; else goto <D.17587>;
  <D.17586>:
  D.17585 = prof->exception_throw_cb;
  D.17588 = prof->profiler;
  D.17585 (D.17588, exception);
  <D.17587>:
  <D.17584>:
  prof = prof->next;
  <D.16987>:
  if (prof != 0B) goto <D.16986>; else goto <D.16988>;
  <D.16988>:
}


mono_profiler_exception_method_leave (struct MonoMethod * method)
{
  <unnamed type> D.17589;
  unsigned int D.17590;
  void (*<Tb2d>) (struct MonoProfiler *, struct MonoMethod *) D.17593;
  struct MonoProfiler * D.17596;
  struct ProfilerDesc * prof;

  prof = prof_list;
  goto <D.16994>;
  <D.16993>:
  D.17589 = prof->events;
  D.17590 = D.17589 & 64;
  if (D.17590 != 0) goto <D.17591>; else goto <D.17592>;
  <D.17591>:
  D.17593 = prof->exception_method_leave_cb;
  if (D.17593 != 0B) goto <D.17594>; else goto <D.17595>;
  <D.17594>:
  D.17593 = prof->exception_method_leave_cb;
  D.17596 = prof->profiler;
  D.17593 (D.17596, method);
  <D.17595>:
  <D.17592>:
  prof = prof->next;
  <D.16994>:
  if (prof != 0B) goto <D.16993>; else goto <D.16995>;
  <D.16995>:
}


mono_profiler_exception_clause_handler (struct MonoMethod * method, int clause_type, int clause_num)
{
  <unnamed type> D.17597;
  unsigned int D.17598;
  void (*<Tb4b>) (struct MonoProfiler *, struct MonoMethod *, int, int) D.17601;
  struct MonoProfiler * D.17604;
  struct ProfilerDesc * prof;

  prof = prof_list;
  goto <D.17003>;
  <D.17002>:
  D.17597 = prof->events;
  D.17598 = D.17597 & 64;
  if (D.17598 != 0) goto <D.17599>; else goto <D.17600>;
  <D.17599>:
  D.17601 = prof->exception_clause_cb;
  if (D.17601 != 0B) goto <D.17602>; else goto <D.17603>;
  <D.17602>:
  D.17601 = prof->exception_clause_cb;
  D.17604 = prof->profiler;
  D.17601 (D.17604, method, clause_type, clause_num);
  <D.17603>:
  <D.17600>:
  prof = prof->next;
  <D.17003>:
  if (prof != 0B) goto <D.17002>; else goto <D.17004>;
  <D.17004>:
}


mono_profiler_thread_start (gsize tid)
{
  <unnamed type> D.17605;
  unsigned int D.17606;
  void (*<Tb73>) (struct MonoProfiler *, uintptr_t) D.17609;
  struct MonoProfiler * D.17612;
  struct ProfilerDesc * prof;

  prof = prof_list;
  goto <D.17010>;
  <D.17009>:
  D.17605 = prof->events;
  D.17606 = D.17605 & 512;
  if (D.17606 != 0) goto <D.17607>; else goto <D.17608>;
  <D.17607>:
  D.17609 = prof->thread_start;
  if (D.17609 != 0B) goto <D.17610>; else goto <D.17611>;
  <D.17610>:
  D.17609 = prof->thread_start;
  D.17612 = prof->profiler;
  D.17609 (D.17612, tid);
  <D.17611>:
  <D.17608>:
  prof = prof->next;
  <D.17010>:
  if (prof != 0B) goto <D.17009>; else goto <D.17011>;
  <D.17011>:
}


mono_profiler_thread_end (gsize tid)
{
  <unnamed type> D.17613;
  unsigned int D.17614;
  void (*<Tb73>) (struct MonoProfiler *, uintptr_t) D.17617;
  struct MonoProfiler * D.17620;
  struct ProfilerDesc * prof;

  prof = prof_list;
  goto <D.17017>;
  <D.17016>:
  D.17613 = prof->events;
  D.17614 = D.17613 & 512;
  if (D.17614 != 0) goto <D.17615>; else goto <D.17616>;
  <D.17615>:
  D.17617 = prof->thread_end;
  if (D.17617 != 0B) goto <D.17618>; else goto <D.17619>;
  <D.17618>:
  D.17617 = prof->thread_end;
  D.17620 = prof->profiler;
  D.17617 (D.17620, tid);
  <D.17619>:
  <D.17616>:
  prof = prof->next;
  <D.17017>:
  if (prof != 0B) goto <D.17016>; else goto <D.17018>;
  <D.17018>:
}


mono_profiler_thread_name (gsize tid, const char * name)
{
  <unnamed type> D.17621;
  unsigned int D.17622;
  void (*<Tb78>) (struct MonoProfiler *, uintptr_t, const char *) D.17625;
  struct MonoProfiler * D.17628;
  struct ProfilerDesc * prof;

  prof = prof_list;
  goto <D.17025>;
  <D.17024>:
  D.17621 = prof->events;
  D.17622 = D.17621 & 512;
  if (D.17622 != 0) goto <D.17623>; else goto <D.17624>;
  <D.17623>:
  D.17625 = prof->thread_name;
  if (D.17625 != 0B) goto <D.17626>; else goto <D.17627>;
  <D.17626>:
  D.17625 = prof->thread_name;
  D.17628 = prof->profiler;
  D.17625 (D.17628, tid, name);
  <D.17627>:
  <D.17624>:
  prof = prof->next;
  <D.17025>:
  if (prof != 0B) goto <D.17024>; else goto <D.17026>;
  <D.17026>:
}


mono_profiler_assembly_event (struct MonoAssembly * assembly, int code)
{
  <unnamed type> D.17629;
  unsigned int D.17630;
  void (*<Tb3c>) (struct MonoProfiler *, struct MonoAssembly *) D.17633;
  struct MonoProfiler * D.17636;
  void (*<Tb3c>) (struct MonoProfiler *, struct MonoAssembly *) D.17637;
  void (*<Tb3c>) (struct MonoProfiler *, struct MonoAssembly *) D.17640;
  struct ProfilerDesc * prof;

  prof = prof_list;
  goto <D.17039>;
  <D.17038>:
  D.17629 = prof->events;
  D.17630 = D.17629 & 2;
  if (D.17630 == 0) goto <D.17631>; else goto <D.17632>;
  <D.17631>:
  // predicted unlikely by continue predictor.
  goto <D.17032>;
  <D.17632>:
  switch (code) <default: <D.17037>, case 0: <D.17033>, case 2: <D.17035>, case 3: <D.17036>>
  <D.17033>:
  D.17633 = prof->assembly_start_load;
  if (D.17633 != 0B) goto <D.17634>; else goto <D.17635>;
  <D.17634>:
  D.17633 = prof->assembly_start_load;
  D.17636 = prof->profiler;
  D.17633 (D.17636, assembly);
  <D.17635>:
  goto <D.17034>;
  <D.17035>:
  D.17637 = prof->assembly_start_unload;
  if (D.17637 != 0B) goto <D.17638>; else goto <D.17639>;
  <D.17638>:
  D.17637 = prof->assembly_start_unload;
  D.17636 = prof->profiler;
  D.17637 (D.17636, assembly);
  <D.17639>:
  goto <D.17034>;
  <D.17036>:
  D.17640 = prof->assembly_end_unload;
  if (D.17640 != 0B) goto <D.17641>; else goto <D.17642>;
  <D.17641>:
  D.17640 = prof->assembly_end_unload;
  D.17636 = prof->profiler;
  D.17640 (D.17636, assembly);
  <D.17642>:
  goto <D.17034>;
  <D.17037>:
  monoeg_assertion_message ("* Assertion: should not be reached at %s:%d\n", "profiler.c", 588);
  <D.17034>:
  <D.17032>:
  prof = prof->next;
  <D.17039>:
  if (prof != 0B) goto <D.17038>; else goto <D.17040>;
  <D.17040>:
}


mono_profiler_assembly_loaded (struct MonoAssembly * assembly, int result)
{
  <unnamed type> D.17643;
  unsigned int D.17644;
  void (*<Tb69>) (struct MonoProfiler *, struct MonoAssembly *, int) D.17647;
  struct MonoProfiler * D.17650;
  struct ProfilerDesc * prof;

  prof = prof_list;
  goto <D.17047>;
  <D.17046>:
  D.17643 = prof->events;
  D.17644 = D.17643 & 2;
  if (D.17644 != 0) goto <D.17645>; else goto <D.17646>;
  <D.17645>:
  D.17647 = prof->assembly_end_load;
  if (D.17647 != 0B) goto <D.17648>; else goto <D.17649>;
  <D.17648>:
  D.17647 = prof->assembly_end_load;
  D.17650 = prof->profiler;
  D.17647 (D.17650, assembly, result);
  <D.17649>:
  <D.17646>:
  prof = prof->next;
  <D.17047>:
  if (prof != 0B) goto <D.17046>; else goto <D.17048>;
  <D.17048>:
}


mono_profiler_iomap (char * report, const char * pathname, const char * new_pathname)
{
  <unnamed type> D.17651;
  unsigned int D.17652;
  void (*<Tba7>) (struct MonoProfiler *, const char *, const char *, const char *) D.17655;
  struct MonoProfiler * D.17658;
  struct ProfilerDesc * prof;

  prof = prof_list;
  goto <D.17056>;
  <D.17055>:
  D.17651 = prof->events;
  D.17652 = D.17651 & 262144;
  if (D.17652 != 0) goto <D.17653>; else goto <D.17654>;
  <D.17653>:
  D.17655 = prof->iomap_cb;
  if (D.17655 != 0B) goto <D.17656>; else goto <D.17657>;
  <D.17656>:
  D.17655 = prof->iomap_cb;
  D.17658 = prof->profiler;
  D.17655 (D.17658, report, pathname, new_pathname);
  <D.17657>:
  <D.17654>:
  prof = prof->next;
  <D.17056>:
  if (prof != 0B) goto <D.17055>; else goto <D.17057>;
  <D.17057>:
}


mono_profiler_module_event (struct MonoImage * module, int code)
{
  <unnamed type> D.17659;
  unsigned int D.17660;
  void (*<Tb37>) (struct MonoProfiler *, struct MonoImage *) D.17663;
  struct MonoProfiler * D.17666;
  void (*<Tb37>) (struct MonoProfiler *, struct MonoImage *) D.17667;
  void (*<Tb37>) (struct MonoProfiler *, struct MonoImage *) D.17670;
  struct ProfilerDesc * prof;

  prof = prof_list;
  goto <D.17070>;
  <D.17069>:
  D.17659 = prof->events;
  D.17660 = D.17659 & 4;
  if (D.17660 == 0) goto <D.17661>; else goto <D.17662>;
  <D.17661>:
  // predicted unlikely by continue predictor.
  goto <D.17063>;
  <D.17662>:
  switch (code) <default: <D.17068>, case 0: <D.17064>, case 2: <D.17066>, case 3: <D.17067>>
  <D.17064>:
  D.17663 = prof->module_start_load;
  if (D.17663 != 0B) goto <D.17664>; else goto <D.17665>;
  <D.17664>:
  D.17663 = prof->module_start_load;
  D.17666 = prof->profiler;
  D.17663 (D.17666, module);
  <D.17665>:
  goto <D.17065>;
  <D.17066>:
  D.17667 = prof->module_start_unload;
  if (D.17667 != 0B) goto <D.17668>; else goto <D.17669>;
  <D.17668>:
  D.17667 = prof->module_start_unload;
  D.17666 = prof->profiler;
  D.17667 (D.17666, module);
  <D.17669>:
  goto <D.17065>;
  <D.17067>:
  D.17670 = prof->module_end_unload;
  if (D.17670 != 0B) goto <D.17671>; else goto <D.17672>;
  <D.17671>:
  D.17670 = prof->module_end_unload;
  D.17666 = prof->profiler;
  D.17670 (D.17666, module);
  <D.17672>:
  goto <D.17065>;
  <D.17068>:
  monoeg_assertion_message ("* Assertion: should not be reached at %s:%d\n", "profiler.c", 634);
  <D.17065>:
  <D.17063>:
  prof = prof->next;
  <D.17070>:
  if (prof != 0B) goto <D.17069>; else goto <D.17071>;
  <D.17071>:
}


mono_profiler_module_loaded (struct MonoImage * module, int result)
{
  <unnamed type> D.17673;
  unsigned int D.17674;
  void (*<Tb64>) (struct MonoProfiler *, struct MonoImage *, int) D.17677;
  struct MonoProfiler * D.17680;
  struct ProfilerDesc * prof;

  prof = prof_list;
  goto <D.17078>;
  <D.17077>:
  D.17673 = prof->events;
  D.17674 = D.17673 & 4;
  if (D.17674 != 0) goto <D.17675>; else goto <D.17676>;
  <D.17675>:
  D.17677 = prof->module_end_load;
  if (D.17677 != 0B) goto <D.17678>; else goto <D.17679>;
  <D.17678>:
  D.17677 = prof->module_end_load;
  D.17680 = prof->profiler;
  D.17677 (D.17680, module, result);
  <D.17679>:
  <D.17676>:
  prof = prof->next;
  <D.17078>:
  if (prof != 0B) goto <D.17077>; else goto <D.17079>;
  <D.17079>:
}


mono_profiler_class_event (struct MonoClass * klass, int code)
{
  <unnamed type> D.17681;
  unsigned int D.17682;
  void (*<Tb32>) (struct MonoProfiler *, struct MonoClass *) D.17685;
  struct MonoProfiler * D.17688;
  void (*<Tb32>) (struct MonoProfiler *, struct MonoClass *) D.17689;
  void (*<Tb32>) (struct MonoProfiler *, struct MonoClass *) D.17692;
  struct ProfilerDesc * prof;

  prof = prof_list;
  goto <D.17092>;
  <D.17091>:
  D.17681 = prof->events;
  D.17682 = D.17681 & 8;
  if (D.17682 == 0) goto <D.17683>; else goto <D.17684>;
  <D.17683>:
  // predicted unlikely by continue predictor.
  goto <D.17085>;
  <D.17684>:
  switch (code) <default: <D.17090>, case 0: <D.17086>, case 2: <D.17088>, case 3: <D.17089>>
  <D.17086>:
  D.17685 = prof->class_start_load;
  if (D.17685 != 0B) goto <D.17686>; else goto <D.17687>;
  <D.17686>:
  D.17685 = prof->class_start_load;
  D.17688 = prof->profiler;
  D.17685 (D.17688, klass);
  <D.17687>:
  goto <D.17087>;
  <D.17088>:
  D.17689 = prof->class_start_unload;
  if (D.17689 != 0B) goto <D.17690>; else goto <D.17691>;
  <D.17690>:
  D.17689 = prof->class_start_unload;
  D.17688 = prof->profiler;
  D.17689 (D.17688, klass);
  <D.17691>:
  goto <D.17087>;
  <D.17089>:
  D.17692 = prof->class_end_unload;
  if (D.17692 != 0B) goto <D.17693>; else goto <D.17694>;
  <D.17693>:
  D.17692 = prof->class_end_unload;
  D.17688 = prof->profiler;
  D.17692 (D.17688, klass);
  <D.17694>:
  goto <D.17087>;
  <D.17090>:
  monoeg_assertion_message ("* Assertion: should not be reached at %s:%d\n", "profiler.c", 671);
  <D.17087>:
  <D.17085>:
  prof = prof->next;
  <D.17092>:
  if (prof != 0B) goto <D.17091>; else goto <D.17093>;
  <D.17093>:
}


mono_profiler_class_loaded (struct MonoClass * klass, int result)
{
  <unnamed type> D.17695;
  unsigned int D.17696;
  void (*<Tb5f>) (struct MonoProfiler *, struct MonoClass *, int) D.17699;
  struct MonoProfiler * D.17702;
  struct ProfilerDesc * prof;

  prof = prof_list;
  goto <D.17100>;
  <D.17099>:
  D.17695 = prof->events;
  D.17696 = D.17695 & 8;
  if (D.17696 != 0) goto <D.17697>; else goto <D.17698>;
  <D.17697>:
  D.17699 = prof->class_end_load;
  if (D.17699 != 0B) goto <D.17700>; else goto <D.17701>;
  <D.17700>:
  D.17699 = prof->class_end_load;
  D.17702 = prof->profiler;
  D.17699 (D.17702, klass, result);
  <D.17701>:
  <D.17698>:
  prof = prof->next;
  <D.17100>:
  if (prof != 0B) goto <D.17099>; else goto <D.17101>;
  <D.17101>:
}


mono_profiler_appdomain_event (struct MonoDomain * domain, int code)
{
  <unnamed type> D.17703;
  unsigned int D.17704;
  void (*<Tb28>) (struct MonoProfiler *, struct MonoDomain *) D.17707;
  struct MonoProfiler * D.17710;
  void (*<Tb28>) (struct MonoProfiler *, struct MonoDomain *) D.17711;
  void (*<Tb28>) (struct MonoProfiler *, struct MonoDomain *) D.17714;
  struct ProfilerDesc * prof;

  prof = prof_list;
  goto <D.17114>;
  <D.17113>:
  D.17703 = prof->events;
  D.17704 = D.17703 & 1;
  if (D.17704 == 0) goto <D.17705>; else goto <D.17706>;
  <D.17705>:
  // predicted unlikely by continue predictor.
  goto <D.17107>;
  <D.17706>:
  switch (code) <default: <D.17112>, case 0: <D.17108>, case 2: <D.17110>, case 3: <D.17111>>
  <D.17108>:
  D.17707 = prof->domain_start_load;
  if (D.17707 != 0B) goto <D.17708>; else goto <D.17709>;
  <D.17708>:
  D.17707 = prof->domain_start_load;
  D.17710 = prof->profiler;
  D.17707 (D.17710, domain);
  <D.17709>:
  goto <D.17109>;
  <D.17110>:
  D.17711 = prof->domain_start_unload;
  if (D.17711 != 0B) goto <D.17712>; else goto <D.17713>;
  <D.17712>:
  D.17711 = prof->domain_start_unload;
  D.17710 = prof->profiler;
  D.17711 (D.17710, domain);
  <D.17713>:
  goto <D.17109>;
  <D.17111>:
  D.17714 = prof->domain_end_unload;
  if (D.17714 != 0B) goto <D.17715>; else goto <D.17716>;
  <D.17715>:
  D.17714 = prof->domain_end_unload;
  D.17710 = prof->profiler;
  D.17714 (D.17710, domain);
  <D.17716>:
  goto <D.17109>;
  <D.17112>:
  monoeg_assertion_message ("* Assertion: should not be reached at %s:%d\n", "profiler.c", 708);
  <D.17109>:
  <D.17107>:
  prof = prof->next;
  <D.17114>:
  if (prof != 0B) goto <D.17113>; else goto <D.17115>;
  <D.17115>:
}


mono_profiler_appdomain_loaded (struct MonoDomain * domain, int result)
{
  <unnamed type> D.17717;
  unsigned int D.17718;
  void (*<Tb50>) (struct MonoProfiler *, struct MonoDomain *, int) D.17721;
  struct MonoProfiler * D.17724;
  struct ProfilerDesc * prof;

  prof = prof_list;
  goto <D.17122>;
  <D.17121>:
  D.17717 = prof->events;
  D.17718 = D.17717 & 1;
  if (D.17718 != 0) goto <D.17719>; else goto <D.17720>;
  <D.17719>:
  D.17721 = prof->domain_end_load;
  if (D.17721 != 0B) goto <D.17722>; else goto <D.17723>;
  <D.17722>:
  D.17721 = prof->domain_end_load;
  D.17724 = prof->profiler;
  D.17721 (D.17724, domain, result);
  <D.17723>:
  <D.17720>:
  prof = prof->next;
  <D.17122>:
  if (prof != 0B) goto <D.17121>; else goto <D.17123>;
  <D.17123>:
}


mono_profiler_shutdown ()
{
  void (*<Tb23>) (struct MonoProfiler *) D.17725;
  struct MonoProfiler * D.17728;
  struct ProfilerDesc * prof;

  prof = prof_list;
  goto <D.17129>;
  <D.17128>:
  D.17725 = prof->shutdown_callback;
  if (D.17725 != 0B) goto <D.17726>; else goto <D.17727>;
  <D.17726>:
  D.17725 = prof->shutdown_callback;
  D.17728 = prof->profiler;
  D.17725 (D.17728);
  <D.17727>:
  prof = prof->next;
  <D.17129>:
  if (prof != 0B) goto <D.17128>; else goto <D.17130>;
  <D.17130>:
  mono_profiler_set_events (0);
}


mono_profiler_gc_heap_resize (gint64 new_size)
{
  <unnamed type> D.17729;
  unsigned int D.17730;
  void (*<Tb98>) (struct MonoProfiler *, int64_t) D.17733;
  struct MonoProfiler * D.17736;
  struct ProfilerDesc * prof;

  prof = prof_list;
  goto <D.17136>;
  <D.17135>:
  D.17729 = prof->events;
  D.17730 = D.17729 & 256;
  if (D.17730 != 0) goto <D.17731>; else goto <D.17732>;
  <D.17731>:
  D.17733 = prof->gc_heap_resize;
  if (D.17733 != 0B) goto <D.17734>; else goto <D.17735>;
  <D.17734>:
  D.17733 = prof->gc_heap_resize;
  D.17736 = prof->profiler;
  D.17733 (D.17736, new_size);
  <D.17735>:
  <D.17732>:
  prof = prof->next;
  <D.17136>:
  if (prof != 0B) goto <D.17135>; else goto <D.17137>;
  <D.17137>:
}


mono_profiler_gc_event (MonoGCEvent event, int generation)
{
  <unnamed type> D.17737;
  unsigned int D.17738;
  void (*<Tb8e>) (struct MonoProfiler *, MonoGCEvent, int) D.17741;
  struct MonoProfiler * D.17744;
  struct ProfilerDesc * prof;

  prof = prof_list;
  goto <D.17144>;
  <D.17143>:
  D.17737 = prof->events;
  D.17738 = D.17737 & 256;
  if (D.17738 != 0) goto <D.17739>; else goto <D.17740>;
  <D.17739>:
  D.17741 = prof->gc_event;
  if (D.17741 != 0B) goto <D.17742>; else goto <D.17743>;
  <D.17742>:
  D.17741 = prof->gc_event;
  D.17744 = prof->profiler;
  D.17741 (D.17744, event, generation);
  <D.17743>:
  <D.17740>:
  prof = prof->next;
  <D.17144>:
  if (prof != 0B) goto <D.17143>; else goto <D.17145>;
  <D.17145>:
}


mono_profiler_gc_moves (void * * objects, int num)
{
  <unnamed type> D.17745;
  unsigned int D.17746;
  void (*<Tb93>) (struct MonoProfiler *, void * *, int) D.17749;
  struct MonoProfiler * D.17752;
  struct ProfilerDesc * prof;

  prof = prof_list;
  goto <D.17152>;
  <D.17151>:
  D.17745 = prof->events;
  D.17746 = D.17745 & 524288;
  if (D.17746 != 0) goto <D.17747>; else goto <D.17748>;
  <D.17747>:
  D.17749 = prof->gc_moves;
  if (D.17749 != 0B) goto <D.17750>; else goto <D.17751>;
  <D.17750>:
  D.17749 = prof->gc_moves;
  D.17752 = prof->profiler;
  D.17749 (D.17752, objects, num);
  <D.17751>:
  <D.17748>:
  prof = prof->next;
  <D.17152>:
  if (prof != 0B) goto <D.17151>; else goto <D.17153>;
  <D.17153>:
}


mono_profiler_gc_handle (int op, int type, uintptr_t handle, struct MonoObject * obj)
{
  <unnamed type> D.17753;
  unsigned int D.17754;
  void (*<Tb9d>) (struct MonoProfiler *, int, int, uintptr_t, struct MonoObject *) D.17757;
  struct MonoProfiler * D.17760;
  struct ProfilerDesc * prof;

  prof = prof_list;
  goto <D.17162>;
  <D.17161>:
  D.17753 = prof->events;
  D.17754 = D.17753 & 1048576;
  if (D.17754 != 0) goto <D.17755>; else goto <D.17756>;
  <D.17755>:
  D.17757 = prof->gc_handle;
  if (D.17757 != 0B) goto <D.17758>; else goto <D.17759>;
  <D.17758>:
  D.17757 = prof->gc_handle;
  D.17760 = prof->profiler;
  D.17757 (D.17760, op, type, handle, obj);
  <D.17759>:
  <D.17756>:
  prof = prof->next;
  <D.17162>:
  if (prof != 0B) goto <D.17161>; else goto <D.17163>;
  <D.17163>:
}


mono_profiler_gc_roots (int num, void * * objects, int * root_types, uintptr_t * extra_info)
{
  <unnamed type> D.17761;
  unsigned int D.17762;
  void (*<Tba2>) (struct MonoProfiler *, int, void * *, int *, uintptr_t *) D.17765;
  struct MonoProfiler * D.17768;
  struct ProfilerDesc * prof;

  prof = prof_list;
  goto <D.17172>;
  <D.17171>:
  D.17761 = prof->events;
  D.17762 = D.17761 & 1048576;
  if (D.17762 != 0) goto <D.17763>; else goto <D.17764>;
  <D.17763>:
  D.17765 = prof->gc_roots;
  if (D.17765 != 0B) goto <D.17766>; else goto <D.17767>;
  <D.17766>:
  D.17765 = prof->gc_roots;
  D.17768 = prof->profiler;
  D.17765 (D.17768, num, objects, root_types, extra_info);
  <D.17767>:
  <D.17764>:
  prof = prof->next;
  <D.17172>:
  if (prof != 0B) goto <D.17171>; else goto <D.17173>;
  <D.17173>:
}


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.17770>; else goto <D.17771>;
  <D.17770>:
  return;
  <D.17771>:
  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.17774>; else goto <D.17775>;
  <D.17774>:
  return;
  <D.17775>:
  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.17778>; else goto <D.17779>;
  <D.17778>:
  return;
  <D.17779>:
  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.17782>; else goto <D.17783>;
  <D.17782>:
  return;
  <D.17783>:
  prof_list.25 = prof_list;
  prof_list.25->runtime_initialized_event = runtime_initialized_callback;
}


mono_profiler_runtime_initialized ()
{
  void (*<Tb23>) (struct MonoProfiler *) D.17785;
  struct MonoProfiler * D.17788;
  struct ProfilerDesc * prof;

  prof = prof_list;
  goto <D.17193>;
  <D.17192>:
  D.17785 = prof->runtime_initialized_event;
  if (D.17785 != 0B) goto <D.17786>; else goto <D.17787>;
  <D.17786>:
  D.17785 = prof->runtime_initialized_event;
  D.17788 = prof->profiler;
  D.17785 (D.17788);
  <D.17787>:
  prof = prof->next;
  <D.17193>:
  if (prof != 0B) goto <D.17192>; else goto <D.17194>;
  <D.17194>:
}


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.17790>; else goto <D.17791>;
  <D.17790>:
  return;
  <D.17791>:
  prof_list.26 = prof_list;
  prof_list.26->code_chunk_new = callback;
}


mono_profiler_code_chunk_new (void * chunk, int size)
{
  void (*<Tbba>) (struct MonoProfiler *, void *, int) D.17793;
  struct MonoProfiler * D.17796;
  struct ProfilerDesc * prof;

  prof = prof_list;
  goto <D.17204>;
  <D.17203>:
  D.17793 = prof->code_chunk_new;
  if (D.17793 != 0B) goto <D.17794>; else goto <D.17795>;
  <D.17794>:
  D.17793 = prof->code_chunk_new;
  D.17796 = prof->profiler;
  D.17793 (D.17796, chunk, size);
  <D.17795>:
  prof = prof->next;
  <D.17204>:
  if (prof != 0B) goto <D.17203>; else goto <D.17205>;
  <D.17205>:
}


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.17798>; else goto <D.17799>;
  <D.17798>:
  return;
  <D.17799>:
  prof_list.27 = prof_list;
  prof_list.27->code_chunk_destroy = callback;
}


mono_profiler_code_chunk_destroy (void * chunk)
{
  void (*<Tbbf>) (struct MonoProfiler *, void *) D.17801;
  struct MonoProfiler * D.17804;
  struct ProfilerDesc * prof;

  prof = prof_list;
  goto <D.17214>;
  <D.17213>:
  D.17801 = prof->code_chunk_destroy;
  if (D.17801 != 0B) goto <D.17802>; else goto <D.17803>;
  <D.17802>:
  D.17801 = prof->code_chunk_destroy;
  D.17804 = prof->profiler;
  D.17801 (D.17804, chunk);
  <D.17803>:
  prof = prof->next;
  <D.17214>:
  if (prof != 0B) goto <D.17213>; else goto <D.17215>;
  <D.17215>:
}


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.17806>; else goto <D.17807>;
  <D.17806>:
  return;
  <D.17807>:
  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.17810>; else goto <D.17811>;
  <D.17810>:
  return;
  <D.17811>:
  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 (*<Tbc4>) (struct MonoProfiler *, void *, int, MonoProfilerCodeBufferType, void *) D.17813;
  struct MonoProfiler * D.17816;
  struct ProfilerDesc * prof;

  prof = prof_list;
  goto <D.17230>;
  <D.17229>:
  D.17813 = prof->code_buffer_new;
  if (D.17813 != 0B) goto <D.17814>; else goto <D.17815>;
  <D.17814>:
  D.17813 = prof->code_buffer_new;
  D.17816 = prof->profiler;
  D.17813 (D.17816, buffer, size, type, data);
  <D.17815>:
  prof = prof->next;
  <D.17230>:
  if (prof != 0B) goto <D.17229>; else goto <D.17231>;
  <D.17231>:
}


mono_profiler_coverage_alloc (struct MonoMethod * method, int entries)
{
  mono_bool (*<Tbac>) (struct MonoProfiler *, struct MonoMethod *) D.17817;
  struct MonoProfiler * D.17820;
  int D.17821;
  struct MonoProfileCoverageInfo * D.17826;
  _Bool D.17829;
  long int D.17830;
  long int D.17831;
  struct GHashTable * coverage_hash.30;
  struct GHashTable * coverage_hash.31;
  unsigned int entries.32;
  unsigned int D.17839;
  unsigned int D.17840;
  _Bool D.17843;
  long int D.17844;
  long int D.17845;
  struct MonoProfileCoverageInfo * res;
  int instrument;
  struct ProfilerDesc * prof;

  instrument = 0;
  prof = prof_list;
  goto <D.17241>;
  <D.17240>:
  D.17817 = prof->coverage_filter_cb;
  if (D.17817 != 0B) goto <D.17818>; else goto <D.17819>;
  <D.17818>:
  D.17817 = prof->coverage_filter_cb;
  D.17820 = prof->profiler;
  D.17821 = D.17817 (D.17820, method);
  if (D.17821 != 0) goto <D.17822>; else goto <D.17823>;
  <D.17822>:
  instrument = 1;
  <D.17823>:
  <D.17819>:
  prof = prof->next;
  <D.17241>:
  if (prof != 0B) goto <D.17240>; else goto <D.17242>;
  <D.17242>:
  if (instrument == 0) goto <D.17824>; else goto <D.17825>;
  <D.17824>:
  D.17826 = 0B;
  return D.17826;
  <D.17825>:
  {
    int ret;

    ret = pthread_mutex_lock (&profiler_coverage_mutex.mutex);
    if (ret != 0) goto <D.17827>; else goto <D.17828>;
    <D.17827>:
    monoeg_g_log (0B, 16, "Bad call to mono_mutex_lock result %d", ret);
    <D.17828>:
    D.17829 = ret != 0;
    D.17830 = (long int) D.17829;
    D.17831 = __builtin_expect (D.17830, 0);
    if (D.17831 != 0) goto <D.17832>; else goto <D.17833>;
    <D.17832>:
    monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "profiler.c", 933, "ret == 0");
    <D.17833>:
  }
  coverage_hash.30 = coverage_hash;
  if (coverage_hash.30 == 0B) goto <D.17835>; else goto <D.17836>;
  <D.17835>:
  coverage_hash.31 = monoeg_g_hash_table_new (0B, 0B);
  coverage_hash = coverage_hash.31;
  <D.17836>:
  entries.32 = (unsigned int) entries;
  D.17839 = entries.32 * 8;
  D.17840 = D.17839 + 12;
  res = monoeg_malloc0 (D.17840);
  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.17841>; else goto <D.17842>;
    <D.17841>:
    monoeg_g_log (0B, 16, "Bad call to mono_mutex_unlock result %d", ret);
    <D.17842>:
    D.17843 = ret != 0;
    D.17844 = (long int) D.17843;
    D.17845 = __builtin_expect (D.17844, 0);
    if (D.17845 != 0) goto <D.17846>; else goto <D.17847>;
    <D.17846>:
    monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "profiler.c", 942, "ret == 0");
    <D.17847>:
  }
  D.17826 = res;
  return D.17826;
}


mono_profiler_coverage_free (struct MonoMethod * method)
{
  _Bool D.17851;
  long int D.17852;
  long int D.17853;
  struct GHashTable * coverage_hash.33;
  _Bool D.17861;
  long int D.17862;
  long int D.17863;
  _Bool D.17870;
  long int D.17871;
  long int D.17872;
  struct MonoProfileCoverageInfo * info;

  {
    int ret;

    ret = pthread_mutex_lock (&profiler_coverage_mutex.mutex);
    if (ret != 0) goto <D.17849>; else goto <D.17850>;
    <D.17849>:
    monoeg_g_log (0B, 16, "Bad call to mono_mutex_lock result %d", ret);
    <D.17850>:
    D.17851 = ret != 0;
    D.17852 = (long int) D.17851;
    D.17853 = __builtin_expect (D.17852, 0);
    if (D.17853 != 0) goto <D.17854>; else goto <D.17855>;
    <D.17854>:
    monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "profiler.c", 953, "ret == 0");
    <D.17855>:
  }
  coverage_hash.33 = coverage_hash;
  if (coverage_hash.33 == 0B) goto <D.17857>; else goto <D.17858>;
  <D.17857>:
  {
    int ret;

    ret = pthread_mutex_unlock (&profiler_coverage_mutex.mutex);
    if (ret != 0) goto <D.17859>; else goto <D.17860>;
    <D.17859>:
    monoeg_g_log (0B, 16, "Bad call to mono_mutex_unlock result %d", ret);
    <D.17860>:
    D.17861 = ret != 0;
    D.17862 = (long int) D.17861;
    D.17863 = __builtin_expect (D.17862, 0);
    if (D.17863 != 0) goto <D.17864>; else goto <D.17865>;
    <D.17864>:
    monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "profiler.c", 955, "ret == 0");
    <D.17865>:
  }
  return;
  <D.17858>:
  coverage_hash.33 = coverage_hash;
  info = monoeg_g_hash_table_lookup (coverage_hash.33, method);
  if (info != 0B) goto <D.17866>; else goto <D.17867>;
  <D.17866>:
  monoeg_g_free (info);
  coverage_hash.33 = coverage_hash;
  monoeg_g_hash_table_remove (coverage_hash.33, method);
  <D.17867>:
  {
    int ret;

    ret = pthread_mutex_unlock (&profiler_coverage_mutex.mutex);
    if (ret != 0) goto <D.17868>; else goto <D.17869>;
    <D.17868>:
    monoeg_g_log (0B, 16, "Bad call to mono_mutex_unlock result %d", ret);
    <D.17869>:
    D.17870 = ret != 0;
    D.17871 = (long int) D.17870;
    D.17872 = __builtin_expect (D.17871, 0);
    if (D.17872 != 0) goto <D.17873>; else goto <D.17874>;
    <D.17873>:
    monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "profiler.c", 964, "ret == 0");
    <D.17874>:
  }
}


mono_profiler_coverage_get (struct MonoProfiler * prof, struct MonoMethod * method, void (*MonoProfileCoverageFunc) (struct MonoProfiler *, const struct MonoProfileCoverageEntry *) func)
{
  _Bool D.17878;
  long int D.17879;
  long int D.17880;
  struct GHashTable * coverage_hash.34;
  _Bool D.17886;
  long int D.17887;
  long int D.17888;
  unsigned int code_size.35;
  int cil_code.36;
  int start.37;
  int D.17902;
  int D.17903;
  unsigned int offset.38;
  unsigned int D.17909;
  int D.17910;
  unsigned int D.17911;
  int D.17912;
  char * D.17913;
  int D.17914;
  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.17876>; else goto <D.17877>;
        <D.17876>:
        monoeg_g_log (0B, 16, "Bad call to mono_mutex_lock result %d", ret);
        <D.17877>:
        D.17878 = ret != 0;
        D.17879 = (long int) D.17878;
        D.17880 = __builtin_expect (D.17879, 0);
        if (D.17880 != 0) goto <D.17881>; else goto <D.17882>;
        <D.17881>:
        monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "profiler.c", 990, "ret == 0");
        <D.17882>:
      }
      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.17884>; else goto <D.17885>;
        <D.17884>:
        monoeg_g_log (0B, 16, "Bad call to mono_mutex_unlock result %d", ret);
        <D.17885>:
        D.17886 = ret != 0;
        D.17887 = (long int) D.17886;
        D.17888 = __builtin_expect (D.17887, 0);
        if (D.17888 != 0) goto <D.17889>; else goto <D.17890>;
        <D.17889>:
        monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "profiler.c", 992, "ret == 0");
        <D.17890>:
      }
      if (info == 0B) goto <D.17891>; else goto <D.17892>;
      <D.17891>:
      return;
      <D.17892>:
      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.17272>;
      <D.17271>:
      cil_code = info->data[i].cil_code;
      if (cil_code != 0B) goto <D.17894>; else goto <D.17895>;
      <D.17894>:
      if (cil_code >= start) goto <D.17896>; else goto <D.17897>;
      <D.17896>:
      if (cil_code < end) goto <D.17898>; else goto <D.17899>;
      <D.17898>:
      {
        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.17902 = info->data[i].count;
        entry.counter = D.17902;
        entry.col = 1;
        D.17903 = entry.col;
        entry.line = D.17903;
        entry.filename = 0B;
        if (debug_minfo != 0B) goto <D.17904>; else goto <D.17905>;
        <D.17904>:
        {
          struct MonoDebugSourceLocation * location;

          offset.38 = (unsigned int) offset;
          location = mono_debug_symfile_lookup_location (debug_minfo, offset.38);
          if (location != 0B) goto <D.17907>; else goto <D.17908>;
          <D.17907>:
          D.17909 = location->row;
          D.17910 = (int) D.17909;
          entry.line = D.17910;
          D.17911 = location->column;
          D.17912 = (int) D.17911;
          entry.col = D.17912;
          D.17913 = location->source_file;
          fname = monoeg_strdup (D.17913);
          entry.filename = fname;
          mono_debug_free_source_location (location);
          <D.17908>:
        }
        <D.17905>:
        func (prof, &entry);
        monoeg_g_free (fname);
      }
      <D.17899>:
      <D.17897>:
      <D.17895>:
      i = i + 1;
      <D.17272>:
      D.17914 = info->entries;
      if (D.17914 > i) goto <D.17271>; else goto <D.17273>;
      <D.17273>:
      mono_metadata_free_mh (header);
    }
  finally
    {
      code_size = {CLOBBER};
      entry = {CLOBBER};
    }
}


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

  if (str != 0B) goto <D.17918>; else goto <D.17919>;
  <D.17918>:
  D.17920 = __strdup (str);
  return D.17920;
  <D.17919>:
  D.17920 = 0B;
  return D.17920;
}


mono_profiler_load (const char * desc)
{
  int D.17315;
  int iftmp.39;
  int D.17311;
  const char[8] * D.17928;
  unsigned char D.17929;
  int D.17930;
  unsigned char D.17931;
  int D.17932;
  const unsigned char * D.17937;
  unsigned char D.17938;
  int D.17939;
  const unsigned char * D.17940;
  unsigned char D.17941;
  int D.17942;
  const unsigned char * D.17947;
  unsigned char D.17948;
  int D.17949;
  const unsigned char * D.17950;
  unsigned char D.17951;
  int D.17952;
  const unsigned char * D.17957;
  unsigned char D.17958;
  int D.17959;
  const unsigned char * D.17960;
  unsigned char D.17961;
  int D.17962;
  int D.17964;
  const gchar * D.17967;
  int D.17337;
  int iftmp.40;
  int D.17336;
  const char[5] * D.17971;
  unsigned char D.17972;
  int D.17973;
  unsigned char D.17974;
  int D.17975;
  const unsigned char * D.17980;
  unsigned char D.17981;
  int D.17982;
  const unsigned char * D.17983;
  unsigned char D.17984;
  int D.17985;
  const unsigned char * D.17990;
  unsigned char D.17991;
  int D.17992;
  const unsigned char * D.17993;
  unsigned char D.17994;
  int D.17995;
  const unsigned char * D.18000;
  unsigned char D.18001;
  int D.18002;
  const unsigned char * D.18003;
  unsigned char D.18004;
  int D.18005;
  int D.17346;
  int iftmp.41;
  int D.17345;
  const char[6] * D.18013;
  unsigned char D.18014;
  int D.18015;
  unsigned char D.18016;
  int D.18017;
  const unsigned char * D.18022;
  unsigned char D.18023;
  int D.18024;
  const unsigned char * D.18025;
  unsigned char D.18026;
  int D.18027;
  const unsigned char * D.18032;
  unsigned char D.18033;
  int D.18034;
  const unsigned char * D.18035;
  unsigned char D.18036;
  int D.18037;
  const unsigned char * D.18042;
  unsigned char D.18043;
  int D.18044;
  const unsigned char * D.18045;
  unsigned char D.18046;
  int D.18047;
  int D.17355;
  int iftmp.42;
  int D.17354;
  const char[5] * D.18055;
  unsigned char D.18056;
  int D.18057;
  unsigned char D.18058;
  int D.18059;
  const unsigned char * D.18064;
  unsigned char D.18065;
  int D.18066;
  const unsigned char * D.18067;
  unsigned char D.18068;
  int D.18069;
  const unsigned char * D.18074;
  unsigned char D.18075;
  int D.18076;
  const unsigned char * D.18077;
  unsigned char D.18078;
  int D.18079;
  const unsigned char * D.18084;
  unsigned char D.18085;
  int D.18086;
  const unsigned char * D.18087;
  unsigned char D.18088;
  int D.18089;
  int D.17364;
  int iftmp.43;
  int D.17363;
  const char[4] * D.18097;
  unsigned char D.18098;
  int D.18099;
  unsigned char D.18100;
  int D.18101;
  const unsigned char * D.18106;
  unsigned char D.18107;
  int D.18108;
  const unsigned char * D.18109;
  unsigned char D.18110;
  int D.18111;
  const unsigned char * D.18116;
  unsigned char D.18117;
  int D.18118;
  const unsigned char * D.18119;
  unsigned char D.18120;
  int D.18121;
  const unsigned char * D.18126;
  unsigned char D.18127;
  int D.18128;
  const unsigned char * D.18129;
  unsigned char D.18130;
  int D.18131;
  int D.18135;
  const char * D.18138;
  struct _IO_FILE * stderr.44;
  gchar * D.18142;
  int col.45;
  int desc.46;
  int D.18147;
  int D.18148;
  unsigned int D.18149;
  sizetype D.18150;
  char * D.18151;
  int D.18153;
  int D.18156;
  const char * D.18159;
  char * cdesc;

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

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

      __s2 = desc;
      D.17928 = "default";
      D.17929 = MEM[(const unsigned char *)D.17928];
      D.17930 = (int) D.17929;
      D.17931 = *__s2;
      D.17932 = (int) D.17931;
      __result = D.17930 - D.17932;
      {
        if (__s1_len != 0) goto <D.17933>; else goto <D.17934>;
        <D.17933>:
        if (__result == 0) goto <D.17935>; else goto <D.17936>;
        <D.17935>:
        D.17937 = &MEM[(void *)"default" + 1B];
        D.17938 = *D.17937;
        D.17939 = (int) D.17938;
        D.17940 = __s2 + 1;
        D.17941 = *D.17940;
        D.17942 = (int) D.17941;
        __result = D.17939 - D.17942;
        if (__s1_len > 1) goto <D.17943>; else goto <D.17944>;
        <D.17943>:
        if (__result == 0) goto <D.17945>; else goto <D.17946>;
        <D.17945>:
        D.17947 = &MEM[(void *)"default" + 2B];
        D.17948 = *D.17947;
        D.17949 = (int) D.17948;
        D.17950 = __s2 + 2;
        D.17951 = *D.17950;
        D.17952 = (int) D.17951;
        __result = D.17949 - D.17952;
        if (__s1_len > 2) goto <D.17953>; else goto <D.17954>;
        <D.17953>:
        if (__result == 0) goto <D.17955>; else goto <D.17956>;
        <D.17955>:
        D.17957 = &MEM[(void *)"default" + 3B];
        D.17958 = *D.17957;
        D.17959 = (int) D.17958;
        D.17960 = __s2 + 3;
        D.17961 = *D.17960;
        D.17962 = (int) D.17961;
        __result = D.17959 - D.17962;
        <D.17956>:
        <D.17954>:
        <D.17946>:
        <D.17944>:
        <D.17936>:
        <D.17934>:
      }
      D.17311 = __result;
    }
    iftmp.39 = D.17311;
    goto <D.17963>;
    <D.17927>:
    iftmp.39 = __builtin_strcmp ("default", desc);
    <D.17963>:
    D.17315 = iftmp.39;
  }
  if (D.17315 == 0) goto <D.17922>; else goto <D.17923>;
  <D.17922>:
  desc = "log:report";
  <D.17923>:
  D.17964 = strncmp (desc, "default:", 8);
  if (D.17964 == 0) goto <D.17965>; else goto <D.17966>;
  <D.17965>:
  {
    gchar * * args;
    gchar * * ptr;
    struct GString * str;

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

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

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

          __s2 = arg;
          D.17971 = "time";
          D.17972 = MEM[(const unsigned char *)D.17971];
          D.17973 = (int) D.17972;
          D.17974 = *__s2;
          D.17975 = (int) D.17974;
          __result = D.17973 - D.17975;
          {
            if (__s2_len != 0) goto <D.17976>; else goto <D.17977>;
            <D.17976>:
            if (__result == 0) goto <D.17978>; else goto <D.17979>;
            <D.17978>:
            D.17980 = &MEM[(void *)"time" + 1B];
            D.17981 = *D.17980;
            D.17982 = (int) D.17981;
            D.17983 = __s2 + 1;
            D.17984 = *D.17983;
            D.17985 = (int) D.17984;
            __result = D.17982 - D.17985;
            if (__s2_len > 1) goto <D.17986>; else goto <D.17987>;
            <D.17986>:
            if (__result == 0) goto <D.17988>; else goto <D.17989>;
            <D.17988>:
            D.17990 = &MEM[(void *)"time" + 2B];
            D.17991 = *D.17990;
            D.17992 = (int) D.17991;
            D.17993 = __s2 + 2;
            D.17994 = *D.17993;
            D.17995 = (int) D.17994;
            __result = D.17992 - D.17995;
            if (__s2_len > 2) goto <D.17996>; else goto <D.17997>;
            <D.17996>:
            if (__result == 0) goto <D.17998>; else goto <D.17999>;
            <D.17998>:
            D.18000 = &MEM[(void *)"time" + 3B];
            D.18001 = *D.18000;
            D.18002 = (int) D.18001;
            D.18003 = __s2 + 3;
            D.18004 = *D.18003;
            D.18005 = (int) D.18004;
            __result = D.18002 - D.18005;
            <D.17999>:
            <D.17997>:
            <D.17989>:
            <D.17987>:
            <D.17979>:
            <D.17977>:
          }
          D.17336 = __result;
        }
        iftmp.40 = -D.17336;
        goto <D.18006>;
        <D.17970>:
        iftmp.40 = __builtin_strcmp (arg, "time");
        <D.18006>:
        D.17337 = iftmp.40;
      }
      if (D.17337 == 0) goto <D.18007>; else goto <D.18008>;
      <D.18007>:
      monoeg_g_string_append (str, ",calls");
      goto <D.18009>;
      <D.18008>:
      {
        size_t __s1_len;
        size_t __s2_len;

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

          __s2 = arg;
          D.18013 = "alloc";
          D.18014 = MEM[(const unsigned char *)D.18013];
          D.18015 = (int) D.18014;
          D.18016 = *__s2;
          D.18017 = (int) D.18016;
          __result = D.18015 - D.18017;
          {
            if (__s2_len != 0) goto <D.18018>; else goto <D.18019>;
            <D.18018>:
            if (__result == 0) goto <D.18020>; else goto <D.18021>;
            <D.18020>:
            D.18022 = &MEM[(void *)"alloc" + 1B];
            D.18023 = *D.18022;
            D.18024 = (int) D.18023;
            D.18025 = __s2 + 1;
            D.18026 = *D.18025;
            D.18027 = (int) D.18026;
            __result = D.18024 - D.18027;
            if (__s2_len > 1) goto <D.18028>; else goto <D.18029>;
            <D.18028>:
            if (__result == 0) goto <D.18030>; else goto <D.18031>;
            <D.18030>:
            D.18032 = &MEM[(void *)"alloc" + 2B];
            D.18033 = *D.18032;
            D.18034 = (int) D.18033;
            D.18035 = __s2 + 2;
            D.18036 = *D.18035;
            D.18037 = (int) D.18036;
            __result = D.18034 - D.18037;
            if (__s2_len > 2) goto <D.18038>; else goto <D.18039>;
            <D.18038>:
            if (__result == 0) goto <D.18040>; else goto <D.18041>;
            <D.18040>:
            D.18042 = &MEM[(void *)"alloc" + 3B];
            D.18043 = *D.18042;
            D.18044 = (int) D.18043;
            D.18045 = __s2 + 3;
            D.18046 = *D.18045;
            D.18047 = (int) D.18046;
            __result = D.18044 - D.18047;
            <D.18041>:
            <D.18039>:
            <D.18031>:
            <D.18029>:
            <D.18021>:
            <D.18019>:
          }
          D.17345 = __result;
        }
        iftmp.41 = -D.17345;
        goto <D.18048>;
        <D.18012>:
        iftmp.41 = __builtin_strcmp (arg, "alloc");
        <D.18048>:
        D.17346 = iftmp.41;
      }
      if (D.17346 == 0) goto <D.18049>; else goto <D.18050>;
      <D.18049>:
      monoeg_g_string_append (str, ",alloc");
      goto <D.18051>;
      <D.18050>:
      {
        size_t __s1_len;
        size_t __s2_len;

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

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

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

          __s2 = arg;
          D.18097 = "jit";
          D.18098 = MEM[(const unsigned char *)D.18097];
          D.18099 = (int) D.18098;
          D.18100 = *__s2;
          D.18101 = (int) D.18100;
          __result = D.18099 - D.18101;
          {
            if (__s2_len != 0) goto <D.18102>; else goto <D.18103>;
            <D.18102>:
            if (__result == 0) goto <D.18104>; else goto <D.18105>;
            <D.18104>:
            D.18106 = &MEM[(void *)"jit" + 1B];
            D.18107 = *D.18106;
            D.18108 = (int) D.18107;
            D.18109 = __s2 + 1;
            D.18110 = *D.18109;
            D.18111 = (int) D.18110;
            __result = D.18108 - D.18111;
            if (__s2_len > 1) goto <D.18112>; else goto <D.18113>;
            <D.18112>:
            if (__result == 0) goto <D.18114>; else goto <D.18115>;
            <D.18114>:
            D.18116 = &MEM[(void *)"jit" + 2B];
            D.18117 = *D.18116;
            D.18118 = (int) D.18117;
            D.18119 = __s2 + 2;
            D.18120 = *D.18119;
            D.18121 = (int) D.18120;
            __result = D.18118 - D.18121;
            if (__s2_len > 2) goto <D.18122>; else goto <D.18123>;
            <D.18122>:
            if (__result == 0) goto <D.18124>; else goto <D.18125>;
            <D.18124>:
            D.18126 = &MEM[(void *)"jit" + 3B];
            D.18127 = *D.18126;
            D.18128 = (int) D.18127;
            D.18129 = __s2 + 3;
            D.18130 = *D.18129;
            D.18131 = (int) D.18130;
            __result = D.18128 - D.18131;
            <D.18125>:
            <D.18123>:
            <D.18115>:
            <D.18113>:
            <D.18105>:
            <D.18103>:
          }
          D.17363 = __result;
        }
        iftmp.43 = -D.17363;
        goto <D.18132>;
        <D.18096>:
        iftmp.43 = __builtin_strcmp (arg, "jit");
        <D.18132>:
        D.17364 = iftmp.43;
      }
      if (D.17364 == 0) goto <D.18133>; else goto <D.18134>;
      <D.18133>:
      // predicted unlikely by continue predictor.
      goto <D.17365>;
      <D.18134>:
      D.18135 = strncmp (arg, "file=", 5);
      if (D.18135 == 0) goto <D.18136>; else goto <D.18137>;
      <D.18136>:
      D.18138 = arg + 5;
      monoeg_g_string_append_printf (str, ",output=%s", D.18138);
      goto <D.18139>;
      <D.18137>:
      stderr.44 = stderr;
      fprintf (stderr.44, "profiler : Unknown argument \'%s\'.\n", arg);
      return;
      <D.18139>:
      <D.18093>:
      <D.18051>:
      <D.18009>:
    }
    <D.17365>:
    ptr = ptr + 4;
    <D.17376>:
    if (ptr != 0B) goto <D.18141>; else goto <D.17377>;
    <D.18141>:
    D.18142 = *ptr;
    if (D.18142 != 0B) goto <D.17375>; else goto <D.17377>;
    <D.17377>:
    cdesc = monoeg_g_string_free (str, 0);
    desc = cdesc;
  }
  <D.17966>:
  {
    const char * col;
    char * libname;
    char * mname;
    gboolean res;

    col = __builtin_strchr (desc, 58);
    res = 0;
    if (col != 0B) goto <D.18143>; else goto <D.18144>;
    <D.18143>:
    col.45 = (int) col;
    desc.46 = (int) desc;
    D.18147 = col.45 - desc.46;
    D.18148 = D.18147 + 1;
    D.18149 = (unsigned int) D.18148;
    mname = monoeg_g_memdup (desc, D.18149);
    col.45 = (int) col;
    desc.46 = (int) desc;
    D.18147 = col.45 - desc.46;
    D.18150 = (sizetype) D.18147;
    D.18151 = mname + D.18150;
    *D.18151 = 0;
    goto <D.18152>;
    <D.18144>:
    mname = monoeg_strdup (desc);
    <D.18152>:
    D.18153 = load_embedded_profiler (desc, mname);
    if (D.18153 == 0) goto <D.18154>; else goto <D.18155>;
    <D.18154>:
    libname = monoeg_g_strdup_printf ("mono-profiler-%s", mname);
    D.18156 = load_profiler_from_directory (0B, libname, desc);
    if (D.18156 == 0) goto <D.18157>; else goto <D.18158>;
    <D.18157>:
    res = 0;
    D.18159 = mono_assembly_getrootdir ();
    res = load_profiler_from_directory (D.18159, libname, desc);
    if (res == 0) goto <D.18160>; else goto <D.18161>;
    <D.18160>:
    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.18161>:
    <D.18158>:
    monoeg_g_free (libname);
    <D.18155>:
    monoeg_g_free (mname);
  }
  monoeg_g_free (cdesc);
}


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

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


load_embedded_profiler (const char * desc, const char * name)
{
  char * err.47;
  gboolean D.18168;
  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.18165>; else goto <D.18166>;
      <D.18165>:
      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.18168 = 0;
      return D.18168;
      <D.18166>:
      symbol = monoeg_g_strdup_printf ("mono_profiler_startup_%s", name);
      result = load_profiler (pmodule, desc, symbol);
      monoeg_g_free (symbol);
      D.18168 = result;
      return D.18168;
    }
  finally
    {
      err = {CLOBBER};
    }
}


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

  try
    {
      if (pmodule == 0B) goto <D.18171>; else goto <D.18172>;
      <D.18171>:
      D.18173 = 0;
      return D.18173;
      <D.18172>:
      err = mono_dl_symbol (pmodule, symbol, &func);
      if (err != 0B) goto <D.18174>; else goto <D.18175>;
      <D.18174>:
      monoeg_g_free (err);
      D.18173 = 0;
      return D.18173;
      <D.18175>:
      func.48 = func;
      func.48 (desc);
      D.18173 = 1;
      return D.18173;
    }
  finally
    {
      func = {CLOBBER};
    }
}


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

  try
    {
      pmodule = 0B;
      iter = 0B;
      err = 0B;
      goto <D.17301>;
      <D.17300>:
      pmodule = mono_dl_open (path, 1, &err);
      monoeg_g_free (path);
      err.49 = err;
      monoeg_g_free (err.49);
      if (pmodule != 0B) goto <D.18180>; else goto <D.18181>;
      <D.18180>:
      D.18182 = load_profiler (pmodule, desc, "mono_profiler_startup");
      return D.18182;
      <D.18181>:
      <D.17301>:
      path = mono_dl_build_path (directory, libname, &iter);
      if (path != 0B) goto <D.17300>; else goto <D.17302>;
      <D.17302>:
      D.18182 = 0;
      return D.18182;
    }
  finally
    {
      err = {CLOBBER};
      iter = {CLOBBER};
    }
}