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

  value = 0;
  prof_list.1 = prof_list;
  if (prof_list.1 != 0B) goto <D.19972>; else goto <D.19973>;
  <D.19972>:
  prof_list.1 = prof_list;
  prof_list.1->events = events;
  <D.19973>:
  prof = prof_list;
  goto <D.19388>;
  <D.19387>:
  D.19974 = prof->events;
  value = D.19974 | value;
  prof = prof->next;
  <D.19388>:
  if (prof != 0B) goto <D.19387>; else goto <D.19389>;
  <D.19389>:
  mono_profiler_events = value;
}


mono_profiler_get_events ()
{
  MonoProfileFlags D.19975;

  D.19975 = mono_profiler_events;
  return D.19975;
}


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.19978>; else goto <D.19979>;
  <D.19978>:
  return;
  <D.19979>:
  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.19982>; else goto <D.19983>;
  <D.19982>:
  return;
  <D.19983>:
  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.19986>; else goto <D.19987>;
  <D.19986>:
  return;
  <D.19987>:
  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.19990>; else goto <D.19991>;
  <D.19990>:
  return;
  <D.19991>:
  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.19994>; else goto <D.19995>;
  <D.19994>:
  return;
  <D.19995>:
  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.19998>; else goto <D.19999>;
  <D.19998>:
  return;
  <D.19999>:
  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.20002>; else goto <D.20003>;
  <D.20002>:
  return;
  <D.20003>:
  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.20006>; else goto <D.20007>;
  <D.20006>:
  return;
  <D.20007>:
  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.20010>; else goto <D.20011>;
  <D.20010>:
  return;
  <D.20011>:
  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.20014>; else goto <D.20015>;
  <D.20014>:
  return;
  <D.20015>:
  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.20018>; else goto <D.20019>;
  <D.20018>:
  return;
  <D.20019>:
  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.20022>; else goto <D.20023>;
  <D.20022>:
  return;
  <D.20023>:
  if (call_chain_depth > 128) goto <D.20024>; else goto <D.20025>;
  <D.20024>:
  call_chain_depth = 128;
  <D.20025>:
  if (call_chain_strategy > 3) goto <D.20026>; else goto <D.20027>;
  <D.20026>:
  call_chain_strategy = 0;
  <D.20027>:
  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 (*<T1635>) (struct MonoProfiler *, int, mono_byte * *, void *) D.20032;
  int D.20034;

  prof_list.14 = prof_list;
  if (prof_list.14 != 0B) goto <D.20031>; else goto <D.20029>;
  <D.20031>:
  prof_list.14 = prof_list;
  D.20032 = prof_list.14->statistical_call_chain_cb;
  if (D.20032 != 0B) goto <D.20033>; else goto <D.20029>;
  <D.20033>:
  prof_list.14 = prof_list;
  D.20034 = prof_list.14->statistical_call_chain_depth;
  return D.20034;
  <D.20029>:
  D.20034 = 0;
  return D.20034;
}


mono_profiler_stat_get_call_chain_strategy ()
{
  struct ProfilerDesc * prof_list.15;
  void (*<T1635>) (struct MonoProfiler *, int, mono_byte * *, void *) D.20039;
  MonoProfilerCallChainStrategy D.20041;

  prof_list.15 = prof_list;
  if (prof_list.15 != 0B) goto <D.20038>; else goto <D.20036>;
  <D.20038>:
  prof_list.15 = prof_list;
  D.20039 = prof_list.15->statistical_call_chain_cb;
  if (D.20039 != 0B) goto <D.20040>; else goto <D.20036>;
  <D.20040>:
  prof_list.15 = prof_list;
  D.20041 = prof_list.15->statistical_call_chain_strategy;
  return D.20041;
  <D.20036>:
  D.20041 = 0;
  return D.20041;
}


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.20044>; else goto <D.20045>;
  <D.20044>:
  return;
  <D.20045>:
  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.20048>; else goto <D.20049>;
  <D.20048>:
  return;
  <D.20049>:
  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.20052>; else goto <D.20053>;
  <D.20052>:
  return;
  <D.20053>:
  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.20056>; else goto <D.20057>;
  <D.20056>:
  return;
  <D.20057>:
  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.20060>; else goto <D.20061>;
  <D.20060>:
  return;
  <D.20061>:
  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.20064>; else goto <D.20065>;
  <D.20064>:
  return;
  <D.20065>:
  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.20067;
  unsigned int D.20068;
  void (*<T15d9>) (struct MonoProfiler *, struct MonoMethod *) D.20071;
  struct MonoProfiler * D.20074;
  struct ProfilerDesc * prof;

  prof = prof_list;
  goto <D.19478>;
  <D.19477>:
  D.20067 = prof->events;
  D.20068 = D.20067 & 4096;
  if (D.20068 != 0) goto <D.20069>; else goto <D.20070>;
  <D.20069>:
  D.20071 = prof->method_enter;
  if (D.20071 != 0B) goto <D.20072>; else goto <D.20073>;
  <D.20072>:
  D.20071 = prof->method_enter;
  D.20074 = prof->profiler;
  D.20071 (D.20074, method);
  <D.20073>:
  <D.20070>:
  prof = prof->next;
  <D.19478>:
  if (prof != 0B) goto <D.19477>; else goto <D.19479>;
  <D.19479>:
}


mono_profiler_method_leave (struct MonoMethod * method)
{
  <unnamed type> D.20075;
  unsigned int D.20076;
  void (*<T15d9>) (struct MonoProfiler *, struct MonoMethod *) D.20079;
  struct MonoProfiler * D.20082;
  struct ProfilerDesc * prof;

  prof = prof_list;
  goto <D.19485>;
  <D.19484>:
  D.20075 = prof->events;
  D.20076 = D.20075 & 4096;
  if (D.20076 != 0) goto <D.20077>; else goto <D.20078>;
  <D.20077>:
  D.20079 = prof->method_leave;
  if (D.20079 != 0B) goto <D.20080>; else goto <D.20081>;
  <D.20080>:
  D.20079 = prof->method_leave;
  D.20082 = prof->profiler;
  D.20079 (D.20082, method);
  <D.20081>:
  <D.20078>:
  prof = prof->next;
  <D.19485>:
  if (prof != 0B) goto <D.19484>; else goto <D.19486>;
  <D.19486>:
}


mono_profiler_method_jit (struct MonoMethod * method)
{
  <unnamed type> D.20083;
  unsigned int D.20084;
  void (*<T15d9>) (struct MonoProfiler *, struct MonoMethod *) D.20087;
  struct MonoProfiler * D.20090;
  struct ProfilerDesc * prof;

  prof = prof_list;
  goto <D.19492>;
  <D.19491>:
  D.20083 = prof->events;
  D.20084 = D.20083 & 16;
  if (D.20084 != 0) goto <D.20085>; else goto <D.20086>;
  <D.20085>:
  D.20087 = prof->jit_start;
  if (D.20087 != 0B) goto <D.20088>; else goto <D.20089>;
  <D.20088>:
  D.20087 = prof->jit_start;
  D.20090 = prof->profiler;
  D.20087 (D.20090, method);
  <D.20089>:
  <D.20086>:
  prof = prof->next;
  <D.19492>:
  if (prof != 0B) goto <D.19491>; else goto <D.19493>;
  <D.19493>:
}


mono_profiler_method_end_jit (struct MonoMethod * method, struct MonoJitInfo * jinfo, int result)
{
  <unnamed type> D.20091;
  unsigned int D.20092;
  void (*<T1601>) (struct MonoProfiler *, struct MonoMethod *, int) D.20095;
  struct MonoProfiler * D.20098;
  void (*<T1606>) (struct MonoProfiler *, struct MonoMethod *, struct MonoJitInfo *, int) D.20099;
  struct ProfilerDesc * prof;

  prof = prof_list;
  goto <D.19501>;
  <D.19500>:
  D.20091 = prof->events;
  D.20092 = D.20091 & 16;
  if (D.20092 != 0) goto <D.20093>; else goto <D.20094>;
  <D.20093>:
  D.20095 = prof->jit_end;
  if (D.20095 != 0B) goto <D.20096>; else goto <D.20097>;
  <D.20096>:
  D.20095 = prof->jit_end;
  D.20098 = prof->profiler;
  D.20095 (D.20098, method, result);
  <D.20097>:
  D.20099 = prof->jit_end2;
  if (D.20099 != 0B) goto <D.20100>; else goto <D.20101>;
  <D.20100>:
  D.20099 = prof->jit_end2;
  D.20098 = prof->profiler;
  D.20099 (D.20098, method, jinfo, result);
  <D.20101>:
  <D.20094>:
  prof = prof->next;
  <D.19501>:
  if (prof != 0B) goto <D.19500>; else goto <D.19502>;
  <D.19502>:
}


mono_profiler_method_free (struct MonoMethod * method)
{
  <unnamed type> D.20102;
  unsigned int D.20103;
  void (*<T15d9>) (struct MonoProfiler *, struct MonoMethod *) D.20106;
  struct MonoProfiler * D.20109;
  struct ProfilerDesc * prof;

  prof = prof_list;
  goto <D.19508>;
  <D.19507>:
  D.20102 = prof->events;
  D.20103 = D.20102 & 65536;
  if (D.20103 != 0) goto <D.20104>; else goto <D.20105>;
  <D.20104>:
  D.20106 = prof->method_free;
  if (D.20106 != 0B) goto <D.20107>; else goto <D.20108>;
  <D.20107>:
  D.20106 = prof->method_free;
  D.20109 = prof->profiler;
  D.20106 (D.20109, method);
  <D.20108>:
  <D.20105>:
  prof = prof->next;
  <D.19508>:
  if (prof != 0B) goto <D.19507>; else goto <D.19509>;
  <D.19509>:
}


mono_profiler_method_start_invoke (struct MonoMethod * method)
{
  <unnamed type> D.20110;
  unsigned int D.20111;
  void (*<T15d9>) (struct MonoProfiler *, struct MonoMethod *) D.20114;
  struct MonoProfiler * D.20117;
  struct ProfilerDesc * prof;

  prof = prof_list;
  goto <D.19515>;
  <D.19514>:
  D.20110 = prof->events;
  D.20111 = D.20110 & 65536;
  if (D.20111 != 0) goto <D.20112>; else goto <D.20113>;
  <D.20112>:
  D.20114 = prof->method_start_invoke;
  if (D.20114 != 0B) goto <D.20115>; else goto <D.20116>;
  <D.20115>:
  D.20114 = prof->method_start_invoke;
  D.20117 = prof->profiler;
  D.20114 (D.20117, method);
  <D.20116>:
  <D.20113>:
  prof = prof->next;
  <D.19515>:
  if (prof != 0B) goto <D.19514>; else goto <D.19516>;
  <D.19516>:
}


mono_profiler_method_end_invoke (struct MonoMethod * method)
{
  <unnamed type> D.20118;
  unsigned int D.20119;
  void (*<T15d9>) (struct MonoProfiler *, struct MonoMethod *) D.20122;
  struct MonoProfiler * D.20125;
  struct ProfilerDesc * prof;

  prof = prof_list;
  goto <D.19522>;
  <D.19521>:
  D.20118 = prof->events;
  D.20119 = D.20118 & 65536;
  if (D.20119 != 0) goto <D.20120>; else goto <D.20121>;
  <D.20120>:
  D.20122 = prof->method_end_invoke;
  if (D.20122 != 0B) goto <D.20123>; else goto <D.20124>;
  <D.20123>:
  D.20122 = prof->method_end_invoke;
  D.20125 = prof->profiler;
  D.20122 (D.20125, method);
  <D.20124>:
  <D.20121>:
  prof = prof->next;
  <D.19522>:
  if (prof != 0B) goto <D.19521>; else goto <D.19523>;
  <D.19523>:
}


mono_profiler_code_transition (struct MonoMethod * method, int result)
{
  <unnamed type> D.20126;
  unsigned int D.20127;
  void (*<T1601>) (struct MonoProfiler *, struct MonoMethod *, int) D.20130;
  struct MonoProfiler * D.20133;
  struct ProfilerDesc * prof;

  prof = prof_list;
  goto <D.19530>;
  <D.19529>:
  D.20126 = prof->events;
  D.20127 = D.20126 & 2048;
  if (D.20127 != 0) goto <D.20128>; else goto <D.20129>;
  <D.20128>:
  D.20130 = prof->man_unman_transition;
  if (D.20130 != 0B) goto <D.20131>; else goto <D.20132>;
  <D.20131>:
  D.20130 = prof->man_unman_transition;
  D.20133 = prof->profiler;
  D.20130 (D.20133, method, result);
  <D.20132>:
  <D.20129>:
  prof = prof->next;
  <D.19530>:
  if (prof != 0B) goto <D.19529>; else goto <D.19531>;
  <D.19531>:
}


mono_profiler_allocation (struct MonoObject * obj, struct MonoClass * klass)
{
  <unnamed type> D.20134;
  unsigned int D.20135;
  void (*<T1629>) (struct MonoProfiler *, struct MonoObject *, struct MonoClass *) D.20138;
  struct MonoProfiler * D.20141;
  struct ProfilerDesc * prof;

  prof = prof_list;
  goto <D.19538>;
  <D.19537>:
  D.20134 = prof->events;
  D.20135 = D.20134 & 128;
  if (D.20135 != 0) goto <D.20136>; else goto <D.20137>;
  <D.20136>:
  D.20138 = prof->allocation_cb;
  if (D.20138 != 0B) goto <D.20139>; else goto <D.20140>;
  <D.20139>:
  D.20138 = prof->allocation_cb;
  D.20141 = prof->profiler;
  D.20138 (D.20141, obj, klass);
  <D.20140>:
  <D.20137>:
  prof = prof->next;
  <D.19538>:
  if (prof != 0B) goto <D.19537>; else goto <D.19539>;
  <D.19539>:
}


mono_profiler_monitor_event (struct MonoObject * obj, MonoProfilerMonitorEvent event)
{
  <unnamed type> D.20142;
  unsigned int D.20143;
  void (*<T15ed>) (struct MonoProfiler *, struct MonoObject *, MonoProfilerMonitorEvent) D.20146;
  struct MonoProfiler * D.20149;
  struct ProfilerDesc * prof;

  prof = prof_list;
  goto <D.19546>;
  <D.19545>:
  D.20142 = prof->events;
  D.20143 = D.20142 & 131072;
  if (D.20143 != 0) goto <D.20144>; else goto <D.20145>;
  <D.20144>:
  D.20146 = prof->monitor_event_cb;
  if (D.20146 != 0B) goto <D.20147>; else goto <D.20148>;
  <D.20147>:
  D.20146 = prof->monitor_event_cb;
  D.20149 = prof->profiler;
  D.20146 (D.20149, obj, event);
  <D.20148>:
  <D.20145>:
  prof = prof->next;
  <D.19546>:
  if (prof != 0B) goto <D.19545>; else goto <D.19547>;
  <D.19547>:
}


mono_profiler_stat_hit (guchar * ip, void * context)
{
  <unnamed type> D.20150;
  unsigned int D.20151;
  void (*<T162f>) (struct MonoProfiler *, mono_byte *, void *) D.20154;
  struct MonoProfiler * D.20157;
  struct ProfilerDesc * prof;

  prof = prof_list;
  goto <D.19554>;
  <D.19553>:
  D.20150 = prof->events;
  D.20151 = D.20150 & 32768;
  if (D.20151 != 0) goto <D.20152>; else goto <D.20153>;
  <D.20152>:
  D.20154 = prof->statistical_cb;
  if (D.20154 != 0B) goto <D.20155>; else goto <D.20156>;
  <D.20155>:
  D.20154 = prof->statistical_cb;
  D.20157 = prof->profiler;
  D.20154 (D.20157, ip, context);
  <D.20156>:
  <D.20153>:
  prof = prof->next;
  <D.19554>:
  if (prof != 0B) goto <D.19553>; else goto <D.19555>;
  <D.19555>:
}


mono_profiler_stat_call_chain (int call_chain_depth, guchar * * ips, void * context)
{
  <unnamed type> D.20158;
  unsigned int D.20159;
  void (*<T1635>) (struct MonoProfiler *, int, mono_byte * *, void *) D.20162;
  struct MonoProfiler * D.20165;
  struct ProfilerDesc * prof;

  prof = prof_list;
  goto <D.19563>;
  <D.19562>:
  D.20158 = prof->events;
  D.20159 = D.20158 & 32768;
  if (D.20159 != 0) goto <D.20160>; else goto <D.20161>;
  <D.20160>:
  D.20162 = prof->statistical_call_chain_cb;
  if (D.20162 != 0B) goto <D.20163>; else goto <D.20164>;
  <D.20163>:
  D.20162 = prof->statistical_call_chain_cb;
  D.20165 = prof->profiler;
  D.20162 (D.20165, call_chain_depth, ips, context);
  <D.20164>:
  <D.20161>:
  prof = prof->next;
  <D.19563>:
  if (prof != 0B) goto <D.19562>; else goto <D.19564>;
  <D.19564>:
}


mono_profiler_exception_thrown (struct MonoObject * exception)
{
  <unnamed type> D.20166;
  unsigned int D.20167;
  void (*<T15f2>) (struct MonoProfiler *, struct MonoObject *) D.20170;
  struct MonoProfiler * D.20173;
  struct ProfilerDesc * prof;

  prof = prof_list;
  goto <D.19570>;
  <D.19569>:
  D.20166 = prof->events;
  D.20167 = D.20166 & 64;
  if (D.20167 != 0) goto <D.20168>; else goto <D.20169>;
  <D.20168>:
  D.20170 = prof->exception_throw_cb;
  if (D.20170 != 0B) goto <D.20171>; else goto <D.20172>;
  <D.20171>:
  D.20170 = prof->exception_throw_cb;
  D.20173 = prof->profiler;
  D.20170 (D.20173, exception);
  <D.20172>:
  <D.20169>:
  prof = prof->next;
  <D.19570>:
  if (prof != 0B) goto <D.19569>; else goto <D.19571>;
  <D.19571>:
}


mono_profiler_exception_method_leave (struct MonoMethod * method)
{
  <unnamed type> D.20174;
  unsigned int D.20175;
  void (*<T15d9>) (struct MonoProfiler *, struct MonoMethod *) D.20178;
  struct MonoProfiler * D.20181;
  struct ProfilerDesc * prof;

  prof = prof_list;
  goto <D.19577>;
  <D.19576>:
  D.20174 = prof->events;
  D.20175 = D.20174 & 64;
  if (D.20175 != 0) goto <D.20176>; else goto <D.20177>;
  <D.20176>:
  D.20178 = prof->exception_method_leave_cb;
  if (D.20178 != 0B) goto <D.20179>; else goto <D.20180>;
  <D.20179>:
  D.20178 = prof->exception_method_leave_cb;
  D.20181 = prof->profiler;
  D.20178 (D.20181, method);
  <D.20180>:
  <D.20177>:
  prof = prof->next;
  <D.19577>:
  if (prof != 0B) goto <D.19576>; else goto <D.19578>;
  <D.19578>:
}


mono_profiler_exception_clause_handler (struct MonoMethod * method, int clause_type, int clause_num)
{
  <unnamed type> D.20182;
  unsigned int D.20183;
  void (*<T15f7>) (struct MonoProfiler *, struct MonoMethod *, int, int) D.20186;
  struct MonoProfiler * D.20189;
  struct ProfilerDesc * prof;

  prof = prof_list;
  goto <D.19586>;
  <D.19585>:
  D.20182 = prof->events;
  D.20183 = D.20182 & 64;
  if (D.20183 != 0) goto <D.20184>; else goto <D.20185>;
  <D.20184>:
  D.20186 = prof->exception_clause_cb;
  if (D.20186 != 0B) goto <D.20187>; else goto <D.20188>;
  <D.20187>:
  D.20186 = prof->exception_clause_cb;
  D.20189 = prof->profiler;
  D.20186 (D.20189, method, clause_type, clause_num);
  <D.20188>:
  <D.20185>:
  prof = prof->next;
  <D.19586>:
  if (prof != 0B) goto <D.19585>; else goto <D.19587>;
  <D.19587>:
}


mono_profiler_thread_start (gsize tid)
{
  <unnamed type> D.20190;
  unsigned int D.20191;
  void (*<T161f>) (struct MonoProfiler *, uintptr_t) D.20194;
  struct MonoProfiler * D.20197;
  struct ProfilerDesc * prof;

  prof = prof_list;
  goto <D.19593>;
  <D.19592>:
  D.20190 = prof->events;
  D.20191 = D.20190 & 512;
  if (D.20191 != 0) goto <D.20192>; else goto <D.20193>;
  <D.20192>:
  D.20194 = prof->thread_start;
  if (D.20194 != 0B) goto <D.20195>; else goto <D.20196>;
  <D.20195>:
  D.20194 = prof->thread_start;
  D.20197 = prof->profiler;
  D.20194 (D.20197, tid);
  <D.20196>:
  <D.20193>:
  prof = prof->next;
  <D.19593>:
  if (prof != 0B) goto <D.19592>; else goto <D.19594>;
  <D.19594>:
}


mono_profiler_thread_end (gsize tid)
{
  <unnamed type> D.20198;
  unsigned int D.20199;
  void (*<T161f>) (struct MonoProfiler *, uintptr_t) D.20202;
  struct MonoProfiler * D.20205;
  struct ProfilerDesc * prof;

  prof = prof_list;
  goto <D.19600>;
  <D.19599>:
  D.20198 = prof->events;
  D.20199 = D.20198 & 512;
  if (D.20199 != 0) goto <D.20200>; else goto <D.20201>;
  <D.20200>:
  D.20202 = prof->thread_end;
  if (D.20202 != 0B) goto <D.20203>; else goto <D.20204>;
  <D.20203>:
  D.20202 = prof->thread_end;
  D.20205 = prof->profiler;
  D.20202 (D.20205, tid);
  <D.20204>:
  <D.20201>:
  prof = prof->next;
  <D.19600>:
  if (prof != 0B) goto <D.19599>; else goto <D.19601>;
  <D.19601>:
}


mono_profiler_thread_name (gsize tid, const char * name)
{
  <unnamed type> D.20206;
  unsigned int D.20207;
  void (*<T1624>) (struct MonoProfiler *, uintptr_t, const char *) D.20210;
  struct MonoProfiler * D.20213;
  struct ProfilerDesc * prof;

  prof = prof_list;
  goto <D.19608>;
  <D.19607>:
  D.20206 = prof->events;
  D.20207 = D.20206 & 512;
  if (D.20207 != 0) goto <D.20208>; else goto <D.20209>;
  <D.20208>:
  D.20210 = prof->thread_name;
  if (D.20210 != 0B) goto <D.20211>; else goto <D.20212>;
  <D.20211>:
  D.20210 = prof->thread_name;
  D.20213 = prof->profiler;
  D.20210 (D.20213, tid, name);
  <D.20212>:
  <D.20209>:
  prof = prof->next;
  <D.19608>:
  if (prof != 0B) goto <D.19607>; else goto <D.19609>;
  <D.19609>:
}


mono_profiler_assembly_event (struct MonoAssembly * assembly, int code)
{
  <unnamed type> D.20214;
  unsigned int D.20215;
  void (*<T15e8>) (struct MonoProfiler *, struct MonoAssembly *) D.20218;
  struct MonoProfiler * D.20221;
  void (*<T15e8>) (struct MonoProfiler *, struct MonoAssembly *) D.20222;
  void (*<T15e8>) (struct MonoProfiler *, struct MonoAssembly *) D.20225;
  struct ProfilerDesc * prof;

  prof = prof_list;
  goto <D.19622>;
  <D.19621>:
  D.20214 = prof->events;
  D.20215 = D.20214 & 2;
  if (D.20215 == 0) goto <D.20216>; else goto <D.20217>;
  <D.20216>:
  // predicted unlikely by continue predictor.
  goto <D.19615>;
  <D.20217>:
  switch (code) <default: <D.19620>, case 0: <D.19616>, case 2: <D.19618>, case 3: <D.19619>>
  <D.19616>:
  D.20218 = prof->assembly_start_load;
  if (D.20218 != 0B) goto <D.20219>; else goto <D.20220>;
  <D.20219>:
  D.20218 = prof->assembly_start_load;
  D.20221 = prof->profiler;
  D.20218 (D.20221, assembly);
  <D.20220>:
  goto <D.19617>;
  <D.19618>:
  D.20222 = prof->assembly_start_unload;
  if (D.20222 != 0B) goto <D.20223>; else goto <D.20224>;
  <D.20223>:
  D.20222 = prof->assembly_start_unload;
  D.20221 = prof->profiler;
  D.20222 (D.20221, assembly);
  <D.20224>:
  goto <D.19617>;
  <D.19619>:
  D.20225 = prof->assembly_end_unload;
  if (D.20225 != 0B) goto <D.20226>; else goto <D.20227>;
  <D.20226>:
  D.20225 = prof->assembly_end_unload;
  D.20221 = prof->profiler;
  D.20225 (D.20221, assembly);
  <D.20227>:
  goto <D.19617>;
  <D.19620>:
  monoeg_assertion_message ("* Assertion: should not be reached at %s:%d\n", "profiler.c", 588);
  <D.19617>:
  <D.19615>:
  prof = prof->next;
  <D.19622>:
  if (prof != 0B) goto <D.19621>; else goto <D.19623>;
  <D.19623>:
}


mono_profiler_assembly_loaded (struct MonoAssembly * assembly, int result)
{
  <unnamed type> D.20228;
  unsigned int D.20229;
  void (*<T1615>) (struct MonoProfiler *, struct MonoAssembly *, int) D.20232;
  struct MonoProfiler * D.20235;
  struct ProfilerDesc * prof;

  prof = prof_list;
  goto <D.19630>;
  <D.19629>:
  D.20228 = prof->events;
  D.20229 = D.20228 & 2;
  if (D.20229 != 0) goto <D.20230>; else goto <D.20231>;
  <D.20230>:
  D.20232 = prof->assembly_end_load;
  if (D.20232 != 0B) goto <D.20233>; else goto <D.20234>;
  <D.20233>:
  D.20232 = prof->assembly_end_load;
  D.20235 = prof->profiler;
  D.20232 (D.20235, assembly, result);
  <D.20234>:
  <D.20231>:
  prof = prof->next;
  <D.19630>:
  if (prof != 0B) goto <D.19629>; else goto <D.19631>;
  <D.19631>:
}


mono_profiler_iomap (char * report, const char * pathname, const char * new_pathname)
{
  <unnamed type> D.20236;
  unsigned int D.20237;
  void (*<T1653>) (struct MonoProfiler *, const char *, const char *, const char *) D.20240;
  struct MonoProfiler * D.20243;
  struct ProfilerDesc * prof;

  prof = prof_list;
  goto <D.19639>;
  <D.19638>:
  D.20236 = prof->events;
  D.20237 = D.20236 & 262144;
  if (D.20237 != 0) goto <D.20238>; else goto <D.20239>;
  <D.20238>:
  D.20240 = prof->iomap_cb;
  if (D.20240 != 0B) goto <D.20241>; else goto <D.20242>;
  <D.20241>:
  D.20240 = prof->iomap_cb;
  D.20243 = prof->profiler;
  D.20240 (D.20243, report, pathname, new_pathname);
  <D.20242>:
  <D.20239>:
  prof = prof->next;
  <D.19639>:
  if (prof != 0B) goto <D.19638>; else goto <D.19640>;
  <D.19640>:
}


mono_profiler_module_event (struct MonoImage * module, int code)
{
  <unnamed type> D.20244;
  unsigned int D.20245;
  void (*<T15e3>) (struct MonoProfiler *, struct MonoImage *) D.20248;
  struct MonoProfiler * D.20251;
  void (*<T15e3>) (struct MonoProfiler *, struct MonoImage *) D.20252;
  void (*<T15e3>) (struct MonoProfiler *, struct MonoImage *) D.20255;
  struct ProfilerDesc * prof;

  prof = prof_list;
  goto <D.19653>;
  <D.19652>:
  D.20244 = prof->events;
  D.20245 = D.20244 & 4;
  if (D.20245 == 0) goto <D.20246>; else goto <D.20247>;
  <D.20246>:
  // predicted unlikely by continue predictor.
  goto <D.19646>;
  <D.20247>:
  switch (code) <default: <D.19651>, case 0: <D.19647>, case 2: <D.19649>, case 3: <D.19650>>
  <D.19647>:
  D.20248 = prof->module_start_load;
  if (D.20248 != 0B) goto <D.20249>; else goto <D.20250>;
  <D.20249>:
  D.20248 = prof->module_start_load;
  D.20251 = prof->profiler;
  D.20248 (D.20251, module);
  <D.20250>:
  goto <D.19648>;
  <D.19649>:
  D.20252 = prof->module_start_unload;
  if (D.20252 != 0B) goto <D.20253>; else goto <D.20254>;
  <D.20253>:
  D.20252 = prof->module_start_unload;
  D.20251 = prof->profiler;
  D.20252 (D.20251, module);
  <D.20254>:
  goto <D.19648>;
  <D.19650>:
  D.20255 = prof->module_end_unload;
  if (D.20255 != 0B) goto <D.20256>; else goto <D.20257>;
  <D.20256>:
  D.20255 = prof->module_end_unload;
  D.20251 = prof->profiler;
  D.20255 (D.20251, module);
  <D.20257>:
  goto <D.19648>;
  <D.19651>:
  monoeg_assertion_message ("* Assertion: should not be reached at %s:%d\n", "profiler.c", 634);
  <D.19648>:
  <D.19646>:
  prof = prof->next;
  <D.19653>:
  if (prof != 0B) goto <D.19652>; else goto <D.19654>;
  <D.19654>:
}


mono_profiler_module_loaded (struct MonoImage * module, int result)
{
  <unnamed type> D.20258;
  unsigned int D.20259;
  void (*<T1610>) (struct MonoProfiler *, struct MonoImage *, int) D.20262;
  struct MonoProfiler * D.20265;
  struct ProfilerDesc * prof;

  prof = prof_list;
  goto <D.19661>;
  <D.19660>:
  D.20258 = prof->events;
  D.20259 = D.20258 & 4;
  if (D.20259 != 0) goto <D.20260>; else goto <D.20261>;
  <D.20260>:
  D.20262 = prof->module_end_load;
  if (D.20262 != 0B) goto <D.20263>; else goto <D.20264>;
  <D.20263>:
  D.20262 = prof->module_end_load;
  D.20265 = prof->profiler;
  D.20262 (D.20265, module, result);
  <D.20264>:
  <D.20261>:
  prof = prof->next;
  <D.19661>:
  if (prof != 0B) goto <D.19660>; else goto <D.19662>;
  <D.19662>:
}


mono_profiler_class_event (struct MonoClass * klass, int code)
{
  <unnamed type> D.20266;
  unsigned int D.20267;
  void (*<T15de>) (struct MonoProfiler *, struct MonoClass *) D.20270;
  struct MonoProfiler * D.20273;
  void (*<T15de>) (struct MonoProfiler *, struct MonoClass *) D.20274;
  void (*<T15de>) (struct MonoProfiler *, struct MonoClass *) D.20277;
  struct ProfilerDesc * prof;

  prof = prof_list;
  goto <D.19675>;
  <D.19674>:
  D.20266 = prof->events;
  D.20267 = D.20266 & 8;
  if (D.20267 == 0) goto <D.20268>; else goto <D.20269>;
  <D.20268>:
  // predicted unlikely by continue predictor.
  goto <D.19668>;
  <D.20269>:
  switch (code) <default: <D.19673>, case 0: <D.19669>, case 2: <D.19671>, case 3: <D.19672>>
  <D.19669>:
  D.20270 = prof->class_start_load;
  if (D.20270 != 0B) goto <D.20271>; else goto <D.20272>;
  <D.20271>:
  D.20270 = prof->class_start_load;
  D.20273 = prof->profiler;
  D.20270 (D.20273, klass);
  <D.20272>:
  goto <D.19670>;
  <D.19671>:
  D.20274 = prof->class_start_unload;
  if (D.20274 != 0B) goto <D.20275>; else goto <D.20276>;
  <D.20275>:
  D.20274 = prof->class_start_unload;
  D.20273 = prof->profiler;
  D.20274 (D.20273, klass);
  <D.20276>:
  goto <D.19670>;
  <D.19672>:
  D.20277 = prof->class_end_unload;
  if (D.20277 != 0B) goto <D.20278>; else goto <D.20279>;
  <D.20278>:
  D.20277 = prof->class_end_unload;
  D.20273 = prof->profiler;
  D.20277 (D.20273, klass);
  <D.20279>:
  goto <D.19670>;
  <D.19673>:
  monoeg_assertion_message ("* Assertion: should not be reached at %s:%d\n", "profiler.c", 671);
  <D.19670>:
  <D.19668>:
  prof = prof->next;
  <D.19675>:
  if (prof != 0B) goto <D.19674>; else goto <D.19676>;
  <D.19676>:
}


mono_profiler_class_loaded (struct MonoClass * klass, int result)
{
  <unnamed type> D.20280;
  unsigned int D.20281;
  void (*<T160b>) (struct MonoProfiler *, struct MonoClass *, int) D.20284;
  struct MonoProfiler * D.20287;
  struct ProfilerDesc * prof;

  prof = prof_list;
  goto <D.19683>;
  <D.19682>:
  D.20280 = prof->events;
  D.20281 = D.20280 & 8;
  if (D.20281 != 0) goto <D.20282>; else goto <D.20283>;
  <D.20282>:
  D.20284 = prof->class_end_load;
  if (D.20284 != 0B) goto <D.20285>; else goto <D.20286>;
  <D.20285>:
  D.20284 = prof->class_end_load;
  D.20287 = prof->profiler;
  D.20284 (D.20287, klass, result);
  <D.20286>:
  <D.20283>:
  prof = prof->next;
  <D.19683>:
  if (prof != 0B) goto <D.19682>; else goto <D.19684>;
  <D.19684>:
}


mono_profiler_appdomain_event (struct MonoDomain * domain, int code)
{
  <unnamed type> D.20288;
  unsigned int D.20289;
  void (*<T15d4>) (struct MonoProfiler *, struct MonoDomain *) D.20292;
  struct MonoProfiler * D.20295;
  void (*<T15d4>) (struct MonoProfiler *, struct MonoDomain *) D.20296;
  void (*<T15d4>) (struct MonoProfiler *, struct MonoDomain *) D.20299;
  struct ProfilerDesc * prof;

  prof = prof_list;
  goto <D.19697>;
  <D.19696>:
  D.20288 = prof->events;
  D.20289 = D.20288 & 1;
  if (D.20289 == 0) goto <D.20290>; else goto <D.20291>;
  <D.20290>:
  // predicted unlikely by continue predictor.
  goto <D.19690>;
  <D.20291>:
  switch (code) <default: <D.19695>, case 0: <D.19691>, case 2: <D.19693>, case 3: <D.19694>>
  <D.19691>:
  D.20292 = prof->domain_start_load;
  if (D.20292 != 0B) goto <D.20293>; else goto <D.20294>;
  <D.20293>:
  D.20292 = prof->domain_start_load;
  D.20295 = prof->profiler;
  D.20292 (D.20295, domain);
  <D.20294>:
  goto <D.19692>;
  <D.19693>:
  D.20296 = prof->domain_start_unload;
  if (D.20296 != 0B) goto <D.20297>; else goto <D.20298>;
  <D.20297>:
  D.20296 = prof->domain_start_unload;
  D.20295 = prof->profiler;
  D.20296 (D.20295, domain);
  <D.20298>:
  goto <D.19692>;
  <D.19694>:
  D.20299 = prof->domain_end_unload;
  if (D.20299 != 0B) goto <D.20300>; else goto <D.20301>;
  <D.20300>:
  D.20299 = prof->domain_end_unload;
  D.20295 = prof->profiler;
  D.20299 (D.20295, domain);
  <D.20301>:
  goto <D.19692>;
  <D.19695>:
  monoeg_assertion_message ("* Assertion: should not be reached at %s:%d\n", "profiler.c", 708);
  <D.19692>:
  <D.19690>:
  prof = prof->next;
  <D.19697>:
  if (prof != 0B) goto <D.19696>; else goto <D.19698>;
  <D.19698>:
}


mono_profiler_appdomain_loaded (struct MonoDomain * domain, int result)
{
  <unnamed type> D.20302;
  unsigned int D.20303;
  void (*<T15fc>) (struct MonoProfiler *, struct MonoDomain *, int) D.20306;
  struct MonoProfiler * D.20309;
  struct ProfilerDesc * prof;

  prof = prof_list;
  goto <D.19705>;
  <D.19704>:
  D.20302 = prof->events;
  D.20303 = D.20302 & 1;
  if (D.20303 != 0) goto <D.20304>; else goto <D.20305>;
  <D.20304>:
  D.20306 = prof->domain_end_load;
  if (D.20306 != 0B) goto <D.20307>; else goto <D.20308>;
  <D.20307>:
  D.20306 = prof->domain_end_load;
  D.20309 = prof->profiler;
  D.20306 (D.20309, domain, result);
  <D.20308>:
  <D.20305>:
  prof = prof->next;
  <D.19705>:
  if (prof != 0B) goto <D.19704>; else goto <D.19706>;
  <D.19706>:
}


mono_profiler_shutdown ()
{
  void (*<T15cf>) (struct MonoProfiler *) D.20310;
  struct MonoProfiler * D.20313;
  struct ProfilerDesc * prof;

  prof = prof_list;
  goto <D.19712>;
  <D.19711>:
  D.20310 = prof->shutdown_callback;
  if (D.20310 != 0B) goto <D.20311>; else goto <D.20312>;
  <D.20311>:
  D.20310 = prof->shutdown_callback;
  D.20313 = prof->profiler;
  D.20310 (D.20313);
  <D.20312>:
  prof = prof->next;
  <D.19712>:
  if (prof != 0B) goto <D.19711>; else goto <D.19713>;
  <D.19713>:
  mono_profiler_set_events (0);
}


mono_profiler_gc_heap_resize (gint64 new_size)
{
  <unnamed type> D.20314;
  unsigned int D.20315;
  void (*<T1644>) (struct MonoProfiler *, int64_t) D.20318;
  struct MonoProfiler * D.20321;
  struct ProfilerDesc * prof;

  prof = prof_list;
  goto <D.19719>;
  <D.19718>:
  D.20314 = prof->events;
  D.20315 = D.20314 & 256;
  if (D.20315 != 0) goto <D.20316>; else goto <D.20317>;
  <D.20316>:
  D.20318 = prof->gc_heap_resize;
  if (D.20318 != 0B) goto <D.20319>; else goto <D.20320>;
  <D.20319>:
  D.20318 = prof->gc_heap_resize;
  D.20321 = prof->profiler;
  D.20318 (D.20321, new_size);
  <D.20320>:
  <D.20317>:
  prof = prof->next;
  <D.19719>:
  if (prof != 0B) goto <D.19718>; else goto <D.19720>;
  <D.19720>:
}


mono_profiler_gc_event (MonoGCEvent event, int generation)
{
  <unnamed type> D.20322;
  unsigned int D.20323;
  void (*<T163a>) (struct MonoProfiler *, MonoGCEvent, int) D.20326;
  struct MonoProfiler * D.20329;
  struct ProfilerDesc * prof;

  prof = prof_list;
  goto <D.19727>;
  <D.19726>:
  D.20322 = prof->events;
  D.20323 = D.20322 & 256;
  if (D.20323 != 0) goto <D.20324>; else goto <D.20325>;
  <D.20324>:
  D.20326 = prof->gc_event;
  if (D.20326 != 0B) goto <D.20327>; else goto <D.20328>;
  <D.20327>:
  D.20326 = prof->gc_event;
  D.20329 = prof->profiler;
  D.20326 (D.20329, event, generation);
  <D.20328>:
  <D.20325>:
  prof = prof->next;
  <D.19727>:
  if (prof != 0B) goto <D.19726>; else goto <D.19728>;
  <D.19728>:
}


mono_profiler_gc_moves (void * * objects, int num)
{
  <unnamed type> D.20330;
  unsigned int D.20331;
  void (*<T163f>) (struct MonoProfiler *, void * *, int) D.20334;
  struct MonoProfiler * D.20337;
  struct ProfilerDesc * prof;

  prof = prof_list;
  goto <D.19735>;
  <D.19734>:
  D.20330 = prof->events;
  D.20331 = D.20330 & 524288;
  if (D.20331 != 0) goto <D.20332>; else goto <D.20333>;
  <D.20332>:
  D.20334 = prof->gc_moves;
  if (D.20334 != 0B) goto <D.20335>; else goto <D.20336>;
  <D.20335>:
  D.20334 = prof->gc_moves;
  D.20337 = prof->profiler;
  D.20334 (D.20337, objects, num);
  <D.20336>:
  <D.20333>:
  prof = prof->next;
  <D.19735>:
  if (prof != 0B) goto <D.19734>; else goto <D.19736>;
  <D.19736>:
}


mono_profiler_gc_handle (int op, int type, uintptr_t handle, struct MonoObject * obj)
{
  <unnamed type> D.20338;
  unsigned int D.20339;
  void (*<T1649>) (struct MonoProfiler *, int, int, uintptr_t, struct MonoObject *) D.20342;
  struct MonoProfiler * D.20345;
  struct ProfilerDesc * prof;

  prof = prof_list;
  goto <D.19745>;
  <D.19744>:
  D.20338 = prof->events;
  D.20339 = D.20338 & 1048576;
  if (D.20339 != 0) goto <D.20340>; else goto <D.20341>;
  <D.20340>:
  D.20342 = prof->gc_handle;
  if (D.20342 != 0B) goto <D.20343>; else goto <D.20344>;
  <D.20343>:
  D.20342 = prof->gc_handle;
  D.20345 = prof->profiler;
  D.20342 (D.20345, op, type, handle, obj);
  <D.20344>:
  <D.20341>:
  prof = prof->next;
  <D.19745>:
  if (prof != 0B) goto <D.19744>; else goto <D.19746>;
  <D.19746>:
}


mono_profiler_gc_roots (int num, void * * objects, int * root_types, uintptr_t * extra_info)
{
  <unnamed type> D.20346;
  unsigned int D.20347;
  void (*<T164e>) (struct MonoProfiler *, int, void * *, int *, uintptr_t *) D.20350;
  struct MonoProfiler * D.20353;
  struct ProfilerDesc * prof;

  prof = prof_list;
  goto <D.19755>;
  <D.19754>:
  D.20346 = prof->events;
  D.20347 = D.20346 & 1048576;
  if (D.20347 != 0) goto <D.20348>; else goto <D.20349>;
  <D.20348>:
  D.20350 = prof->gc_roots;
  if (D.20350 != 0B) goto <D.20351>; else goto <D.20352>;
  <D.20351>:
  D.20350 = prof->gc_roots;
  D.20353 = prof->profiler;
  D.20350 (D.20353, num, objects, root_types, extra_info);
  <D.20352>:
  <D.20349>:
  prof = prof->next;
  <D.19755>:
  if (prof != 0B) goto <D.19754>; else goto <D.19756>;
  <D.19756>:
}


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.20355>; else goto <D.20356>;
  <D.20355>:
  return;
  <D.20356>:
  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.20359>; else goto <D.20360>;
  <D.20359>:
  return;
  <D.20360>:
  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.20363>; else goto <D.20364>;
  <D.20363>:
  return;
  <D.20364>:
  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.20367>; else goto <D.20368>;
  <D.20367>:
  return;
  <D.20368>:
  prof_list.25 = prof_list;
  prof_list.25->runtime_initialized_event = runtime_initialized_callback;
}


mono_profiler_runtime_initialized ()
{
  void (*<T15cf>) (struct MonoProfiler *) D.20370;
  struct MonoProfiler * D.20373;
  struct ProfilerDesc * prof;

  prof = prof_list;
  goto <D.19776>;
  <D.19775>:
  D.20370 = prof->runtime_initialized_event;
  if (D.20370 != 0B) goto <D.20371>; else goto <D.20372>;
  <D.20371>:
  D.20370 = prof->runtime_initialized_event;
  D.20373 = prof->profiler;
  D.20370 (D.20373);
  <D.20372>:
  prof = prof->next;
  <D.19776>:
  if (prof != 0B) goto <D.19775>; else goto <D.19777>;
  <D.19777>:
}


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


mono_profiler_code_chunk_new (void * chunk, int size)
{
  void (*<T1666>) (struct MonoProfiler *, void *, int) D.20378;
  struct MonoProfiler * D.20381;
  struct ProfilerDesc * prof;

  prof = prof_list;
  goto <D.19787>;
  <D.19786>:
  D.20378 = prof->code_chunk_new;
  if (D.20378 != 0B) goto <D.20379>; else goto <D.20380>;
  <D.20379>:
  D.20378 = prof->code_chunk_new;
  D.20381 = prof->profiler;
  D.20378 (D.20381, chunk, size);
  <D.20380>:
  prof = prof->next;
  <D.19787>:
  if (prof != 0B) goto <D.19786>; else goto <D.19788>;
  <D.19788>:
}


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


mono_profiler_code_chunk_destroy (void * chunk)
{
  void (*<T166b>) (struct MonoProfiler *, void *) D.20386;
  struct MonoProfiler * D.20389;
  struct ProfilerDesc * prof;

  prof = prof_list;
  goto <D.19797>;
  <D.19796>:
  D.20386 = prof->code_chunk_destroy;
  if (D.20386 != 0B) goto <D.20387>; else goto <D.20388>;
  <D.20387>:
  D.20386 = prof->code_chunk_destroy;
  D.20389 = prof->profiler;
  D.20386 (D.20389, chunk);
  <D.20388>:
  prof = prof->next;
  <D.19797>:
  if (prof != 0B) goto <D.19796>; else goto <D.19798>;
  <D.19798>:
}


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.20391>; else goto <D.20392>;
  <D.20391>:
  return;
  <D.20392>:
  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.20395>; else goto <D.20396>;
  <D.20395>:
  return;
  <D.20396>:
  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 (*<T1670>) (struct MonoProfiler *, void *, int, MonoProfilerCodeBufferType, void *) D.20398;
  struct MonoProfiler * D.20401;
  struct ProfilerDesc * prof;

  prof = prof_list;
  goto <D.19813>;
  <D.19812>:
  D.20398 = prof->code_buffer_new;
  if (D.20398 != 0B) goto <D.20399>; else goto <D.20400>;
  <D.20399>:
  D.20398 = prof->code_buffer_new;
  D.20401 = prof->profiler;
  D.20398 (D.20401, buffer, size, type, data);
  <D.20400>:
  prof = prof->next;
  <D.19813>:
  if (prof != 0B) goto <D.19812>; else goto <D.19814>;
  <D.19814>:
}


mono_profiler_coverage_alloc (struct MonoMethod * method, int entries)
{
  mono_bool (*<T1658>) (struct MonoProfiler *, struct MonoMethod *) D.20402;
  struct MonoProfiler * D.20405;
  int D.20406;
  struct MonoProfileCoverageInfo * D.20411;
  _Bool D.20414;
  long int D.20415;
  long int D.20416;
  struct GHashTable * coverage_hash.30;
  struct GHashTable * coverage_hash.31;
  unsigned int entries.32;
  unsigned int D.20424;
  unsigned int D.20425;
  _Bool D.20428;
  long int D.20429;
  long int D.20430;
  struct MonoProfileCoverageInfo * res;
  int instrument;
  struct ProfilerDesc * prof;

  instrument = 0;
  prof = prof_list;
  goto <D.19824>;
  <D.19823>:
  D.20402 = prof->coverage_filter_cb;
  if (D.20402 != 0B) goto <D.20403>; else goto <D.20404>;
  <D.20403>:
  D.20402 = prof->coverage_filter_cb;
  D.20405 = prof->profiler;
  D.20406 = D.20402 (D.20405, method);
  if (D.20406 != 0) goto <D.20407>; else goto <D.20408>;
  <D.20407>:
  instrument = 1;
  <D.20408>:
  <D.20404>:
  prof = prof->next;
  <D.19824>:
  if (prof != 0B) goto <D.19823>; else goto <D.19825>;
  <D.19825>:
  if (instrument == 0) goto <D.20409>; else goto <D.20410>;
  <D.20409>:
  D.20411 = 0B;
  return D.20411;
  <D.20410>:
  {
    int ret;

    ret = pthread_mutex_lock (&profiler_coverage_mutex.mutex);
    if (ret != 0) goto <D.20412>; else goto <D.20413>;
    <D.20412>:
    monoeg_g_log (0B, 16, "Bad call to mono_mutex_lock result %d", ret);
    <D.20413>:
    D.20414 = ret != 0;
    D.20415 = (long int) D.20414;
    D.20416 = __builtin_expect (D.20415, 0);
    if (D.20416 != 0) goto <D.20417>; else goto <D.20418>;
    <D.20417>:
    monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "profiler.c", 933, "ret == 0");
    <D.20418>:
  }
  coverage_hash.30 = coverage_hash;
  if (coverage_hash.30 == 0B) goto <D.20420>; else goto <D.20421>;
  <D.20420>:
  coverage_hash.31 = monoeg_g_hash_table_new (0B, 0B);
  coverage_hash = coverage_hash.31;
  <D.20421>:
  entries.32 = (unsigned int) entries;
  D.20424 = entries.32 * 8;
  D.20425 = D.20424 + 12;
  res = monoeg_malloc0 (D.20425);
  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.20426>; else goto <D.20427>;
    <D.20426>:
    monoeg_g_log (0B, 16, "Bad call to mono_mutex_unlock result %d", ret);
    <D.20427>:
    D.20428 = ret != 0;
    D.20429 = (long int) D.20428;
    D.20430 = __builtin_expect (D.20429, 0);
    if (D.20430 != 0) goto <D.20431>; else goto <D.20432>;
    <D.20431>:
    monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "profiler.c", 942, "ret == 0");
    <D.20432>:
  }
  D.20411 = res;
  return D.20411;
}


mono_profiler_coverage_free (struct MonoMethod * method)
{
  _Bool D.20436;
  long int D.20437;
  long int D.20438;
  struct GHashTable * coverage_hash.33;
  _Bool D.20446;
  long int D.20447;
  long int D.20448;
  _Bool D.20455;
  long int D.20456;
  long int D.20457;
  struct MonoProfileCoverageInfo * info;

  {
    int ret;

    ret = pthread_mutex_lock (&profiler_coverage_mutex.mutex);
    if (ret != 0) goto <D.20434>; else goto <D.20435>;
    <D.20434>:
    monoeg_g_log (0B, 16, "Bad call to mono_mutex_lock result %d", ret);
    <D.20435>:
    D.20436 = ret != 0;
    D.20437 = (long int) D.20436;
    D.20438 = __builtin_expect (D.20437, 0);
    if (D.20438 != 0) goto <D.20439>; else goto <D.20440>;
    <D.20439>:
    monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "profiler.c", 953, "ret == 0");
    <D.20440>:
  }
  coverage_hash.33 = coverage_hash;
  if (coverage_hash.33 == 0B) goto <D.20442>; else goto <D.20443>;
  <D.20442>:
  {
    int ret;

    ret = pthread_mutex_unlock (&profiler_coverage_mutex.mutex);
    if (ret != 0) goto <D.20444>; else goto <D.20445>;
    <D.20444>:
    monoeg_g_log (0B, 16, "Bad call to mono_mutex_unlock result %d", ret);
    <D.20445>:
    D.20446 = ret != 0;
    D.20447 = (long int) D.20446;
    D.20448 = __builtin_expect (D.20447, 0);
    if (D.20448 != 0) goto <D.20449>; else goto <D.20450>;
    <D.20449>:
    monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "profiler.c", 955, "ret == 0");
    <D.20450>:
  }
  return;
  <D.20443>:
  coverage_hash.33 = coverage_hash;
  info = monoeg_g_hash_table_lookup (coverage_hash.33, method);
  if (info != 0B) goto <D.20451>; else goto <D.20452>;
  <D.20451>:
  monoeg_g_free (info);
  coverage_hash.33 = coverage_hash;
  monoeg_g_hash_table_remove (coverage_hash.33, method);
  <D.20452>:
  {
    int ret;

    ret = pthread_mutex_unlock (&profiler_coverage_mutex.mutex);
    if (ret != 0) goto <D.20453>; else goto <D.20454>;
    <D.20453>:
    monoeg_g_log (0B, 16, "Bad call to mono_mutex_unlock result %d", ret);
    <D.20454>:
    D.20455 = ret != 0;
    D.20456 = (long int) D.20455;
    D.20457 = __builtin_expect (D.20456, 0);
    if (D.20457 != 0) goto <D.20458>; else goto <D.20459>;
    <D.20458>:
    monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "profiler.c", 964, "ret == 0");
    <D.20459>:
  }
}


mono_profiler_coverage_get (struct MonoProfiler * prof, struct MonoMethod * method, void (*MonoProfileCoverageFunc) (struct MonoProfiler *, const struct MonoProfileCoverageEntry *) func)
{
  _Bool D.20463;
  long int D.20464;
  long int D.20465;
  struct GHashTable * coverage_hash.34;
  _Bool D.20471;
  long int D.20472;
  long int D.20473;
  unsigned int code_size.35;
  _Bool D.20479;
  _Bool D.20480;
  _Bool D.20481;
  int cil_code.36;
  int start.37;
  int D.20488;
  int D.20489;
  unsigned int offset.38;
  unsigned int D.20495;
  int D.20496;
  unsigned int D.20497;
  int D.20498;
  char * D.20499;
  int D.20500;
  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.20461>; else goto <D.20462>;
        <D.20461>:
        monoeg_g_log (0B, 16, "Bad call to mono_mutex_lock result %d", ret);
        <D.20462>:
        D.20463 = ret != 0;
        D.20464 = (long int) D.20463;
        D.20465 = __builtin_expect (D.20464, 0);
        if (D.20465 != 0) goto <D.20466>; else goto <D.20467>;
        <D.20466>:
        monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "profiler.c", 990, "ret == 0");
        <D.20467>:
      }
      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.20469>; else goto <D.20470>;
        <D.20469>:
        monoeg_g_log (0B, 16, "Bad call to mono_mutex_unlock result %d", ret);
        <D.20470>:
        D.20471 = ret != 0;
        D.20472 = (long int) D.20471;
        D.20473 = __builtin_expect (D.20472, 0);
        if (D.20473 != 0) goto <D.20474>; else goto <D.20475>;
        <D.20474>:
        monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "profiler.c", 992, "ret == 0");
        <D.20475>:
      }
      if (info == 0B) goto <D.20476>; else goto <D.20477>;
      <D.20476>:
      return;
      <D.20477>:
      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.19855>;
      <D.19854>:
      cil_code = info->data[i].cil_code;
      D.20479 = cil_code != 0B;
      D.20480 = cil_code >= start;
      D.20481 = D.20479 & D.20480;
      if (D.20481 != 0) goto <D.20482>; else goto <D.20483>;
      <D.20482>:
      if (cil_code < end) goto <D.20484>; else goto <D.20485>;
      <D.20484>:
      {
        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.20488 = info->data[i].count;
        entry.counter = D.20488;
        entry.col = 1;
        D.20489 = entry.col;
        entry.line = D.20489;
        entry.filename = 0B;
        if (debug_minfo != 0B) goto <D.20490>; else goto <D.20491>;
        <D.20490>:
        {
          struct MonoDebugSourceLocation * location;

          offset.38 = (unsigned int) offset;
          location = mono_debug_symfile_lookup_location (debug_minfo, offset.38);
          if (location != 0B) goto <D.20493>; else goto <D.20494>;
          <D.20493>:
          D.20495 = location->row;
          D.20496 = (int) D.20495;
          entry.line = D.20496;
          D.20497 = location->column;
          D.20498 = (int) D.20497;
          entry.col = D.20498;
          D.20499 = location->source_file;
          fname = monoeg_strdup (D.20499);
          entry.filename = fname;
          mono_debug_free_source_location (location);
          <D.20494>:
        }
        <D.20491>:
        func (prof, &entry);
        monoeg_g_free (fname);
      }
      <D.20485>:
      <D.20483>:
      i = i + 1;
      <D.19855>:
      D.20500 = info->entries;
      if (D.20500 > i) goto <D.19854>; else goto <D.19856>;
      <D.19856>:
      mono_metadata_free_mh (header);
    }
  finally
    {
      code_size = {CLOBBER};
      entry = {CLOBBER};
    }
}


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

  if (str != 0B) goto <D.20504>; else goto <D.20505>;
  <D.20504>:
  D.20506 = __strdup (str);
  return D.20506;
  <D.20505>:
  D.20506 = 0B;
  return D.20506;
}


mono_profiler_load (const char * desc)
{
  int D.19898;
  int iftmp.39;
  int D.19894;
  const char[8] * D.20514;
  unsigned char D.20515;
  int D.20516;
  unsigned char D.20517;
  int D.20518;
  _Bool D.20519;
  _Bool D.20520;
  _Bool D.20521;
  const unsigned char * D.20524;
  unsigned char D.20525;
  int D.20526;
  const unsigned char * D.20527;
  unsigned char D.20528;
  int D.20529;
  _Bool D.20530;
  _Bool D.20531;
  const unsigned char * D.20534;
  unsigned char D.20535;
  int D.20536;
  const unsigned char * D.20537;
  unsigned char D.20538;
  int D.20539;
  _Bool D.20540;
  _Bool D.20541;
  const unsigned char * D.20544;
  unsigned char D.20545;
  int D.20546;
  const unsigned char * D.20547;
  unsigned char D.20548;
  int D.20549;
  int D.20551;
  const gchar * D.20554;
  int D.19920;
  int iftmp.40;
  int D.19919;
  const char[5] * D.20558;
  unsigned char D.20559;
  int D.20560;
  unsigned char D.20561;
  int D.20562;
  _Bool D.20563;
  _Bool D.20564;
  _Bool D.20565;
  const unsigned char * D.20568;
  unsigned char D.20569;
  int D.20570;
  const unsigned char * D.20571;
  unsigned char D.20572;
  int D.20573;
  _Bool D.20574;
  _Bool D.20575;
  const unsigned char * D.20578;
  unsigned char D.20579;
  int D.20580;
  const unsigned char * D.20581;
  unsigned char D.20582;
  int D.20583;
  _Bool D.20584;
  _Bool D.20585;
  const unsigned char * D.20588;
  unsigned char D.20589;
  int D.20590;
  const unsigned char * D.20591;
  unsigned char D.20592;
  int D.20593;
  int D.19929;
  int iftmp.41;
  int D.19928;
  const char[6] * D.20601;
  unsigned char D.20602;
  int D.20603;
  unsigned char D.20604;
  int D.20605;
  _Bool D.20606;
  _Bool D.20607;
  _Bool D.20608;
  const unsigned char * D.20611;
  unsigned char D.20612;
  int D.20613;
  const unsigned char * D.20614;
  unsigned char D.20615;
  int D.20616;
  _Bool D.20617;
  _Bool D.20618;
  const unsigned char * D.20621;
  unsigned char D.20622;
  int D.20623;
  const unsigned char * D.20624;
  unsigned char D.20625;
  int D.20626;
  _Bool D.20627;
  _Bool D.20628;
  const unsigned char * D.20631;
  unsigned char D.20632;
  int D.20633;
  const unsigned char * D.20634;
  unsigned char D.20635;
  int D.20636;
  int D.19938;
  int iftmp.42;
  int D.19937;
  const char[5] * D.20644;
  unsigned char D.20645;
  int D.20646;
  unsigned char D.20647;
  int D.20648;
  _Bool D.20649;
  _Bool D.20650;
  _Bool D.20651;
  const unsigned char * D.20654;
  unsigned char D.20655;
  int D.20656;
  const unsigned char * D.20657;
  unsigned char D.20658;
  int D.20659;
  _Bool D.20660;
  _Bool D.20661;
  const unsigned char * D.20664;
  unsigned char D.20665;
  int D.20666;
  const unsigned char * D.20667;
  unsigned char D.20668;
  int D.20669;
  _Bool D.20670;
  _Bool D.20671;
  const unsigned char * D.20674;
  unsigned char D.20675;
  int D.20676;
  const unsigned char * D.20677;
  unsigned char D.20678;
  int D.20679;
  int D.19947;
  int iftmp.43;
  int D.19946;
  const char[4] * D.20687;
  unsigned char D.20688;
  int D.20689;
  unsigned char D.20690;
  int D.20691;
  _Bool D.20692;
  _Bool D.20693;
  _Bool D.20694;
  const unsigned char * D.20697;
  unsigned char D.20698;
  int D.20699;
  const unsigned char * D.20700;
  unsigned char D.20701;
  int D.20702;
  _Bool D.20703;
  _Bool D.20704;
  const unsigned char * D.20707;
  unsigned char D.20708;
  int D.20709;
  const unsigned char * D.20710;
  unsigned char D.20711;
  int D.20712;
  _Bool D.20713;
  _Bool D.20714;
  const unsigned char * D.20717;
  unsigned char D.20718;
  int D.20719;
  const unsigned char * D.20720;
  unsigned char D.20721;
  int D.20722;
  int D.20726;
  const char * D.20729;
  struct _IO_FILE * stderr.44;
  gchar * D.20733;
  int col.45;
  int desc.46;
  int D.20738;
  int D.20739;
  unsigned int D.20740;
  sizetype D.20741;
  char * D.20742;
  int D.20744;
  int D.20747;
  const char * D.20750;
  char * cdesc;

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

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

      __s2 = desc;
      D.20514 = "default";
      D.20515 = MEM[(const unsigned char *)D.20514];
      D.20516 = (int) D.20515;
      D.20517 = *__s2;
      D.20518 = (int) D.20517;
      __result = D.20516 - D.20518;
      {
        D.20519 = __s1_len != 0;
        D.20520 = __result == 0;
        D.20521 = D.20519 & D.20520;
        if (D.20521 != 0) goto <D.20522>; else goto <D.20523>;
        <D.20522>:
        D.20524 = &MEM[(void *)"default" + 1B];
        D.20525 = *D.20524;
        D.20526 = (int) D.20525;
        D.20527 = __s2 + 1;
        D.20528 = *D.20527;
        D.20529 = (int) D.20528;
        __result = D.20526 - D.20529;
        D.20530 = __s1_len > 1;
        D.20520 = __result == 0;
        D.20531 = D.20530 & D.20520;
        if (D.20531 != 0) goto <D.20532>; else goto <D.20533>;
        <D.20532>:
        D.20534 = &MEM[(void *)"default" + 2B];
        D.20535 = *D.20534;
        D.20536 = (int) D.20535;
        D.20537 = __s2 + 2;
        D.20538 = *D.20537;
        D.20539 = (int) D.20538;
        __result = D.20536 - D.20539;
        D.20540 = __s1_len > 2;
        D.20520 = __result == 0;
        D.20541 = D.20540 & D.20520;
        if (D.20541 != 0) goto <D.20542>; else goto <D.20543>;
        <D.20542>:
        D.20544 = &MEM[(void *)"default" + 3B];
        D.20545 = *D.20544;
        D.20546 = (int) D.20545;
        D.20547 = __s2 + 3;
        D.20548 = *D.20547;
        D.20549 = (int) D.20548;
        __result = D.20546 - D.20549;
        <D.20543>:
        <D.20533>:
        <D.20523>:
      }
      D.19894 = __result;
    }
    iftmp.39 = D.19894;
    goto <D.20550>;
    <D.20513>:
    iftmp.39 = __builtin_strcmp ("default", desc);
    <D.20550>:
    D.19898 = iftmp.39;
  }
  if (D.19898 == 0) goto <D.20508>; else goto <D.20509>;
  <D.20508>:
  desc = "log:report";
  <D.20509>:
  D.20551 = strncmp (desc, "default:", 8);
  if (D.20551 == 0) goto <D.20552>; else goto <D.20553>;
  <D.20552>:
  {
    gchar * * args;
    gchar * * ptr;
    struct GString * str;

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

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

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

          __s2 = arg;
          D.20558 = "time";
          D.20559 = MEM[(const unsigned char *)D.20558];
          D.20560 = (int) D.20559;
          D.20561 = *__s2;
          D.20562 = (int) D.20561;
          __result = D.20560 - D.20562;
          {
            D.20563 = __s2_len != 0;
            D.20564 = __result == 0;
            D.20565 = D.20563 & D.20564;
            if (D.20565 != 0) goto <D.20566>; else goto <D.20567>;
            <D.20566>:
            D.20568 = &MEM[(void *)"time" + 1B];
            D.20569 = *D.20568;
            D.20570 = (int) D.20569;
            D.20571 = __s2 + 1;
            D.20572 = *D.20571;
            D.20573 = (int) D.20572;
            __result = D.20570 - D.20573;
            D.20574 = __s2_len > 1;
            D.20564 = __result == 0;
            D.20575 = D.20574 & D.20564;
            if (D.20575 != 0) goto <D.20576>; else goto <D.20577>;
            <D.20576>:
            D.20578 = &MEM[(void *)"time" + 2B];
            D.20579 = *D.20578;
            D.20580 = (int) D.20579;
            D.20581 = __s2 + 2;
            D.20582 = *D.20581;
            D.20583 = (int) D.20582;
            __result = D.20580 - D.20583;
            D.20584 = __s2_len > 2;
            D.20564 = __result == 0;
            D.20585 = D.20584 & D.20564;
            if (D.20585 != 0) goto <D.20586>; else goto <D.20587>;
            <D.20586>:
            D.20588 = &MEM[(void *)"time" + 3B];
            D.20589 = *D.20588;
            D.20590 = (int) D.20589;
            D.20591 = __s2 + 3;
            D.20592 = *D.20591;
            D.20593 = (int) D.20592;
            __result = D.20590 - D.20593;
            <D.20587>:
            <D.20577>:
            <D.20567>:
          }
          D.19919 = __result;
        }
        iftmp.40 = -D.19919;
        goto <D.20594>;
        <D.20557>:
        iftmp.40 = __builtin_strcmp (arg, "time");
        <D.20594>:
        D.19920 = iftmp.40;
      }
      if (D.19920 == 0) goto <D.20595>; else goto <D.20596>;
      <D.20595>:
      monoeg_g_string_append (str, ",calls");
      goto <D.20597>;
      <D.20596>:
      {
        size_t __s1_len;
        size_t __s2_len;

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

          __s2 = arg;
          D.20601 = "alloc";
          D.20602 = MEM[(const unsigned char *)D.20601];
          D.20603 = (int) D.20602;
          D.20604 = *__s2;
          D.20605 = (int) D.20604;
          __result = D.20603 - D.20605;
          {
            D.20606 = __s2_len != 0;
            D.20607 = __result == 0;
            D.20608 = D.20606 & D.20607;
            if (D.20608 != 0) goto <D.20609>; else goto <D.20610>;
            <D.20609>:
            D.20611 = &MEM[(void *)"alloc" + 1B];
            D.20612 = *D.20611;
            D.20613 = (int) D.20612;
            D.20614 = __s2 + 1;
            D.20615 = *D.20614;
            D.20616 = (int) D.20615;
            __result = D.20613 - D.20616;
            D.20617 = __s2_len > 1;
            D.20607 = __result == 0;
            D.20618 = D.20617 & D.20607;
            if (D.20618 != 0) goto <D.20619>; else goto <D.20620>;
            <D.20619>:
            D.20621 = &MEM[(void *)"alloc" + 2B];
            D.20622 = *D.20621;
            D.20623 = (int) D.20622;
            D.20624 = __s2 + 2;
            D.20625 = *D.20624;
            D.20626 = (int) D.20625;
            __result = D.20623 - D.20626;
            D.20627 = __s2_len > 2;
            D.20607 = __result == 0;
            D.20628 = D.20627 & D.20607;
            if (D.20628 != 0) goto <D.20629>; else goto <D.20630>;
            <D.20629>:
            D.20631 = &MEM[(void *)"alloc" + 3B];
            D.20632 = *D.20631;
            D.20633 = (int) D.20632;
            D.20634 = __s2 + 3;
            D.20635 = *D.20634;
            D.20636 = (int) D.20635;
            __result = D.20633 - D.20636;
            <D.20630>:
            <D.20620>:
            <D.20610>:
          }
          D.19928 = __result;
        }
        iftmp.41 = -D.19928;
        goto <D.20637>;
        <D.20600>:
        iftmp.41 = __builtin_strcmp (arg, "alloc");
        <D.20637>:
        D.19929 = iftmp.41;
      }
      if (D.19929 == 0) goto <D.20638>; else goto <D.20639>;
      <D.20638>:
      monoeg_g_string_append (str, ",alloc");
      goto <D.20640>;
      <D.20639>:
      {
        size_t __s1_len;
        size_t __s2_len;

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

          __s2 = arg;
          D.20644 = "stat";
          D.20645 = MEM[(const unsigned char *)D.20644];
          D.20646 = (int) D.20645;
          D.20647 = *__s2;
          D.20648 = (int) D.20647;
          __result = D.20646 - D.20648;
          {
            D.20649 = __s2_len != 0;
            D.20650 = __result == 0;
            D.20651 = D.20649 & D.20650;
            if (D.20651 != 0) goto <D.20652>; else goto <D.20653>;
            <D.20652>:
            D.20654 = &MEM[(void *)"stat" + 1B];
            D.20655 = *D.20654;
            D.20656 = (int) D.20655;
            D.20657 = __s2 + 1;
            D.20658 = *D.20657;
            D.20659 = (int) D.20658;
            __result = D.20656 - D.20659;
            D.20660 = __s2_len > 1;
            D.20650 = __result == 0;
            D.20661 = D.20660 & D.20650;
            if (D.20661 != 0) goto <D.20662>; else goto <D.20663>;
            <D.20662>:
            D.20664 = &MEM[(void *)"stat" + 2B];
            D.20665 = *D.20664;
            D.20666 = (int) D.20665;
            D.20667 = __s2 + 2;
            D.20668 = *D.20667;
            D.20669 = (int) D.20668;
            __result = D.20666 - D.20669;
            D.20670 = __s2_len > 2;
            D.20650 = __result == 0;
            D.20671 = D.20670 & D.20650;
            if (D.20671 != 0) goto <D.20672>; else goto <D.20673>;
            <D.20672>:
            D.20674 = &MEM[(void *)"stat" + 3B];
            D.20675 = *D.20674;
            D.20676 = (int) D.20675;
            D.20677 = __s2 + 3;
            D.20678 = *D.20677;
            D.20679 = (int) D.20678;
            __result = D.20676 - D.20679;
            <D.20673>:
            <D.20663>:
            <D.20653>:
          }
          D.19937 = __result;
        }
        iftmp.42 = -D.19937;
        goto <D.20680>;
        <D.20643>:
        iftmp.42 = __builtin_strcmp (arg, "stat");
        <D.20680>:
        D.19938 = iftmp.42;
      }
      if (D.19938 == 0) goto <D.20681>; else goto <D.20682>;
      <D.20681>:
      monoeg_g_string_append (str, ",sample");
      goto <D.20683>;
      <D.20682>:
      {
        size_t __s1_len;
        size_t __s2_len;

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

          __s2 = arg;
          D.20687 = "jit";
          D.20688 = MEM[(const unsigned char *)D.20687];
          D.20689 = (int) D.20688;
          D.20690 = *__s2;
          D.20691 = (int) D.20690;
          __result = D.20689 - D.20691;
          {
            D.20692 = __s2_len != 0;
            D.20693 = __result == 0;
            D.20694 = D.20692 & D.20693;
            if (D.20694 != 0) goto <D.20695>; else goto <D.20696>;
            <D.20695>:
            D.20697 = &MEM[(void *)"jit" + 1B];
            D.20698 = *D.20697;
            D.20699 = (int) D.20698;
            D.20700 = __s2 + 1;
            D.20701 = *D.20700;
            D.20702 = (int) D.20701;
            __result = D.20699 - D.20702;
            D.20703 = __s2_len > 1;
            D.20693 = __result == 0;
            D.20704 = D.20703 & D.20693;
            if (D.20704 != 0) goto <D.20705>; else goto <D.20706>;
            <D.20705>:
            D.20707 = &MEM[(void *)"jit" + 2B];
            D.20708 = *D.20707;
            D.20709 = (int) D.20708;
            D.20710 = __s2 + 2;
            D.20711 = *D.20710;
            D.20712 = (int) D.20711;
            __result = D.20709 - D.20712;
            D.20713 = __s2_len > 2;
            D.20693 = __result == 0;
            D.20714 = D.20713 & D.20693;
            if (D.20714 != 0) goto <D.20715>; else goto <D.20716>;
            <D.20715>:
            D.20717 = &MEM[(void *)"jit" + 3B];
            D.20718 = *D.20717;
            D.20719 = (int) D.20718;
            D.20720 = __s2 + 3;
            D.20721 = *D.20720;
            D.20722 = (int) D.20721;
            __result = D.20719 - D.20722;
            <D.20716>:
            <D.20706>:
            <D.20696>:
          }
          D.19946 = __result;
        }
        iftmp.43 = -D.19946;
        goto <D.20723>;
        <D.20686>:
        iftmp.43 = __builtin_strcmp (arg, "jit");
        <D.20723>:
        D.19947 = iftmp.43;
      }
      if (D.19947 == 0) goto <D.20724>; else goto <D.20725>;
      <D.20724>:
      // predicted unlikely by continue predictor.
      goto <D.19948>;
      <D.20725>:
      D.20726 = strncmp (arg, "file=", 5);
      if (D.20726 == 0) goto <D.20727>; else goto <D.20728>;
      <D.20727>:
      D.20729 = arg + 5;
      monoeg_g_string_append_printf (str, ",output=%s", D.20729);
      goto <D.20730>;
      <D.20728>:
      stderr.44 = stderr;
      fprintf (stderr.44, "profiler : Unknown argument \'%s\'.\n", arg);
      return;
      <D.20730>:
      <D.20683>:
      <D.20640>:
      <D.20597>:
    }
    <D.19948>:
    ptr = ptr + 4;
    <D.19959>:
    if (ptr != 0B) goto <D.20732>; else goto <D.19960>;
    <D.20732>:
    D.20733 = *ptr;
    if (D.20733 != 0B) goto <D.19958>; else goto <D.19960>;
    <D.19960>:
    cdesc = monoeg_g_string_free (str, 0);
    desc = cdesc;
  }
  <D.20553>:
  {
    const char * col;
    char * libname;
    char * mname;
    gboolean res;

    col = __builtin_strchr (desc, 58);
    res = 0;
    if (col != 0B) goto <D.20734>; else goto <D.20735>;
    <D.20734>:
    col.45 = (int) col;
    desc.46 = (int) desc;
    D.20738 = col.45 - desc.46;
    D.20739 = D.20738 + 1;
    D.20740 = (unsigned int) D.20739;
    mname = monoeg_g_memdup (desc, D.20740);
    col.45 = (int) col;
    desc.46 = (int) desc;
    D.20738 = col.45 - desc.46;
    D.20741 = (sizetype) D.20738;
    D.20742 = mname + D.20741;
    *D.20742 = 0;
    goto <D.20743>;
    <D.20735>:
    mname = monoeg_strdup (desc);
    <D.20743>:
    D.20744 = load_embedded_profiler (desc, mname);
    if (D.20744 == 0) goto <D.20745>; else goto <D.20746>;
    <D.20745>:
    libname = monoeg_g_strdup_printf ("mono-profiler-%s", mname);
    D.20747 = load_profiler_from_directory (0B, libname, desc);
    if (D.20747 == 0) goto <D.20748>; else goto <D.20749>;
    <D.20748>:
    res = 0;
    D.20750 = mono_assembly_getrootdir ();
    res = load_profiler_from_directory (D.20750, libname, desc);
    if (res == 0) goto <D.20751>; else goto <D.20752>;
    <D.20751>:
    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.20752>:
    <D.20749>:
    monoeg_g_free (libname);
    <D.20746>:
    monoeg_g_free (mname);
  }
  monoeg_g_free (cdesc);
}


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

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


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


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

  try
    {
      if (pmodule == 0B) goto <D.20762>; else goto <D.20763>;
      <D.20762>:
      D.20764 = 0;
      return D.20764;
      <D.20763>:
      err = mono_dl_symbol (pmodule, symbol, &func);
      if (err != 0B) goto <D.20765>; else goto <D.20766>;
      <D.20765>:
      monoeg_g_free (err);
      D.20764 = 0;
      return D.20764;
      <D.20766>:
      func.48 = func;
      func.48 (desc);
      D.20764 = 1;
      return D.20764;
    }
  finally
    {
      func = {CLOBBER};
    }
}


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

  try
    {
      pmodule = 0B;
      iter = 0B;
      err = 0B;
      goto <D.19884>;
      <D.19883>:
      pmodule = mono_dl_open (path, 1, &err);
      monoeg_g_free (path);
      err.49 = err;
      monoeg_g_free (err.49);
      if (pmodule != 0B) goto <D.20771>; else goto <D.20772>;
      <D.20771>:
      D.20773 = load_profiler (pmodule, desc, "mono_profiler_startup");
      return D.20773;
      <D.20772>:
      <D.19884>:
      path = mono_dl_build_path (directory, libname, &iter);
      if (path != 0B) goto <D.19883>; else goto <D.19885>;
      <D.19885>:
      D.20773 = 0;
      return D.20773;
    }
  finally
    {
      err = {CLOBBER};
      iter = {CLOBBER};
    }
}