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

  desc = monoeg_malloc0 (408);
  prof_list.0 = prof_list;
  if (prof_list.0 == 0B) goto <D.17782>; else goto <D.17783>;
  <D.17782>:
  InitializeCriticalSection (&profiler_coverage_mutex);
  <D.17783>:
  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.17787;
  struct ProfilerDesc * prof;
  MonoProfileFlags value;

  value = 0;
  prof_list.1 = prof_list;
  if (prof_list.1 != 0B) goto <D.17785>; else goto <D.17786>;
  <D.17785>:
  prof_list.1 = prof_list;
  prof_list.1->events = events;
  <D.17786>:
  prof = prof_list;
  goto <D.17203>;
  <D.17202>:
  D.17787 = prof->events;
  value = D.17787 | value;
  prof = prof->next;
  <D.17203>:
  if (prof != 0B) goto <D.17202>; else goto <D.17204>;
  <D.17204>:
  mono_profiler_events = value;
}


mono_profiler_get_events ()
{
  MonoProfileFlags D.17788;

  D.17788 = mono_profiler_events;
  return D.17788;
}


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.17791>; else goto <D.17792>;
  <D.17791>:
  return;
  <D.17792>:
  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.17795>; else goto <D.17796>;
  <D.17795>:
  return;
  <D.17796>:
  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.17799>; else goto <D.17800>;
  <D.17799>:
  return;
  <D.17800>:
  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.17803>; else goto <D.17804>;
  <D.17803>:
  return;
  <D.17804>:
  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.17807>; else goto <D.17808>;
  <D.17807>:
  return;
  <D.17808>:
  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.17811>; else goto <D.17812>;
  <D.17811>:
  return;
  <D.17812>:
  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.17815>; else goto <D.17816>;
  <D.17815>:
  return;
  <D.17816>:
  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.17819>; else goto <D.17820>;
  <D.17819>:
  return;
  <D.17820>:
  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.17823>; else goto <D.17824>;
  <D.17823>:
  return;
  <D.17824>:
  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.17827>; else goto <D.17828>;
  <D.17827>:
  return;
  <D.17828>:
  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.17831>; else goto <D.17832>;
  <D.17831>:
  return;
  <D.17832>:
  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.17835>; else goto <D.17836>;
  <D.17835>:
  return;
  <D.17836>:
  if (call_chain_depth > 128) goto <D.17837>; else goto <D.17838>;
  <D.17837>:
  call_chain_depth = 128;
  <D.17838>:
  if (call_chain_strategy > 3) goto <D.17839>; else goto <D.17840>;
  <D.17839>:
  call_chain_strategy = 0;
  <D.17840>:
  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 (*<Tc51>) (struct MonoProfiler *, int, mono_byte * *, void *) D.17845;
  int D.17847;

  prof_list.14 = prof_list;
  if (prof_list.14 != 0B) goto <D.17844>; else goto <D.17842>;
  <D.17844>:
  prof_list.14 = prof_list;
  D.17845 = prof_list.14->statistical_call_chain_cb;
  if (D.17845 != 0B) goto <D.17846>; else goto <D.17842>;
  <D.17846>:
  prof_list.14 = prof_list;
  D.17847 = prof_list.14->statistical_call_chain_depth;
  return D.17847;
  <D.17842>:
  D.17847 = 0;
  return D.17847;
}


mono_profiler_stat_get_call_chain_strategy ()
{
  struct ProfilerDesc * prof_list.15;
  void (*<Tc51>) (struct MonoProfiler *, int, mono_byte * *, void *) D.17852;
  MonoProfilerCallChainStrategy D.17854;

  prof_list.15 = prof_list;
  if (prof_list.15 != 0B) goto <D.17851>; else goto <D.17849>;
  <D.17851>:
  prof_list.15 = prof_list;
  D.17852 = prof_list.15->statistical_call_chain_cb;
  if (D.17852 != 0B) goto <D.17853>; else goto <D.17849>;
  <D.17853>:
  prof_list.15 = prof_list;
  D.17854 = prof_list.15->statistical_call_chain_strategy;
  return D.17854;
  <D.17849>:
  D.17854 = 0;
  return D.17854;
}


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.17857>; else goto <D.17858>;
  <D.17857>:
  return;
  <D.17858>:
  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.17861>; else goto <D.17862>;
  <D.17861>:
  return;
  <D.17862>:
  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.17865>; else goto <D.17866>;
  <D.17865>:
  return;
  <D.17866>:
  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.17869>; else goto <D.17870>;
  <D.17869>:
  return;
  <D.17870>:
  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.17873>; else goto <D.17874>;
  <D.17873>:
  return;
  <D.17874>:
  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.17877>; else goto <D.17878>;
  <D.17877>:
  return;
  <D.17878>:
  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.17880;
  unsigned int D.17881;
  void (*<Tbf5>) (struct MonoProfiler *, struct MonoMethod *) D.17884;
  struct MonoProfiler * D.17887;
  struct ProfilerDesc * prof;

  prof = prof_list;
  goto <D.17293>;
  <D.17292>:
  D.17880 = prof->events;
  D.17881 = D.17880 & 4096;
  if (D.17881 != 0) goto <D.17882>; else goto <D.17883>;
  <D.17882>:
  D.17884 = prof->method_enter;
  if (D.17884 != 0B) goto <D.17885>; else goto <D.17886>;
  <D.17885>:
  D.17884 = prof->method_enter;
  D.17887 = prof->profiler;
  D.17884 (D.17887, method);
  <D.17886>:
  <D.17883>:
  prof = prof->next;
  <D.17293>:
  if (prof != 0B) goto <D.17292>; else goto <D.17294>;
  <D.17294>:
}


mono_profiler_method_leave (struct MonoMethod * method)
{
  <unnamed type> D.17888;
  unsigned int D.17889;
  void (*<Tbf5>) (struct MonoProfiler *, struct MonoMethod *) D.17892;
  struct MonoProfiler * D.17895;
  struct ProfilerDesc * prof;

  prof = prof_list;
  goto <D.17300>;
  <D.17299>:
  D.17888 = prof->events;
  D.17889 = D.17888 & 4096;
  if (D.17889 != 0) goto <D.17890>; else goto <D.17891>;
  <D.17890>:
  D.17892 = prof->method_leave;
  if (D.17892 != 0B) goto <D.17893>; else goto <D.17894>;
  <D.17893>:
  D.17892 = prof->method_leave;
  D.17895 = prof->profiler;
  D.17892 (D.17895, method);
  <D.17894>:
  <D.17891>:
  prof = prof->next;
  <D.17300>:
  if (prof != 0B) goto <D.17299>; else goto <D.17301>;
  <D.17301>:
}


mono_profiler_method_jit (struct MonoMethod * method)
{
  <unnamed type> D.17896;
  unsigned int D.17897;
  void (*<Tbf5>) (struct MonoProfiler *, struct MonoMethod *) D.17900;
  struct MonoProfiler * D.17903;
  struct ProfilerDesc * prof;

  prof = prof_list;
  goto <D.17307>;
  <D.17306>:
  D.17896 = prof->events;
  D.17897 = D.17896 & 16;
  if (D.17897 != 0) goto <D.17898>; else goto <D.17899>;
  <D.17898>:
  D.17900 = prof->jit_start;
  if (D.17900 != 0B) goto <D.17901>; else goto <D.17902>;
  <D.17901>:
  D.17900 = prof->jit_start;
  D.17903 = prof->profiler;
  D.17900 (D.17903, method);
  <D.17902>:
  <D.17899>:
  prof = prof->next;
  <D.17307>:
  if (prof != 0B) goto <D.17306>; else goto <D.17308>;
  <D.17308>:
}


mono_profiler_method_end_jit (struct MonoMethod * method, struct MonoJitInfo * jinfo, int result)
{
  <unnamed type> D.17904;
  unsigned int D.17905;
  void (*<Tc1d>) (struct MonoProfiler *, struct MonoMethod *, int) D.17908;
  struct MonoProfiler * D.17911;
  void (*<Tc22>) (struct MonoProfiler *, struct MonoMethod *, struct MonoJitInfo *, int) D.17912;
  struct ProfilerDesc * prof;

  prof = prof_list;
  goto <D.17316>;
  <D.17315>:
  D.17904 = prof->events;
  D.17905 = D.17904 & 16;
  if (D.17905 != 0) goto <D.17906>; else goto <D.17907>;
  <D.17906>:
  D.17908 = prof->jit_end;
  if (D.17908 != 0B) goto <D.17909>; else goto <D.17910>;
  <D.17909>:
  D.17908 = prof->jit_end;
  D.17911 = prof->profiler;
  D.17908 (D.17911, method, result);
  <D.17910>:
  D.17912 = prof->jit_end2;
  if (D.17912 != 0B) goto <D.17913>; else goto <D.17914>;
  <D.17913>:
  D.17912 = prof->jit_end2;
  D.17911 = prof->profiler;
  D.17912 (D.17911, method, jinfo, result);
  <D.17914>:
  <D.17907>:
  prof = prof->next;
  <D.17316>:
  if (prof != 0B) goto <D.17315>; else goto <D.17317>;
  <D.17317>:
}


mono_profiler_method_free (struct MonoMethod * method)
{
  <unnamed type> D.17915;
  unsigned int D.17916;
  void (*<Tbf5>) (struct MonoProfiler *, struct MonoMethod *) D.17919;
  struct MonoProfiler * D.17922;
  struct ProfilerDesc * prof;

  prof = prof_list;
  goto <D.17323>;
  <D.17322>:
  D.17915 = prof->events;
  D.17916 = D.17915 & 65536;
  if (D.17916 != 0) goto <D.17917>; else goto <D.17918>;
  <D.17917>:
  D.17919 = prof->method_free;
  if (D.17919 != 0B) goto <D.17920>; else goto <D.17921>;
  <D.17920>:
  D.17919 = prof->method_free;
  D.17922 = prof->profiler;
  D.17919 (D.17922, method);
  <D.17921>:
  <D.17918>:
  prof = prof->next;
  <D.17323>:
  if (prof != 0B) goto <D.17322>; else goto <D.17324>;
  <D.17324>:
}


mono_profiler_method_start_invoke (struct MonoMethod * method)
{
  <unnamed type> D.17923;
  unsigned int D.17924;
  void (*<Tbf5>) (struct MonoProfiler *, struct MonoMethod *) D.17927;
  struct MonoProfiler * D.17930;
  struct ProfilerDesc * prof;

  prof = prof_list;
  goto <D.17330>;
  <D.17329>:
  D.17923 = prof->events;
  D.17924 = D.17923 & 65536;
  if (D.17924 != 0) goto <D.17925>; else goto <D.17926>;
  <D.17925>:
  D.17927 = prof->method_start_invoke;
  if (D.17927 != 0B) goto <D.17928>; else goto <D.17929>;
  <D.17928>:
  D.17927 = prof->method_start_invoke;
  D.17930 = prof->profiler;
  D.17927 (D.17930, method);
  <D.17929>:
  <D.17926>:
  prof = prof->next;
  <D.17330>:
  if (prof != 0B) goto <D.17329>; else goto <D.17331>;
  <D.17331>:
}


mono_profiler_method_end_invoke (struct MonoMethod * method)
{
  <unnamed type> D.17931;
  unsigned int D.17932;
  void (*<Tbf5>) (struct MonoProfiler *, struct MonoMethod *) D.17935;
  struct MonoProfiler * D.17938;
  struct ProfilerDesc * prof;

  prof = prof_list;
  goto <D.17337>;
  <D.17336>:
  D.17931 = prof->events;
  D.17932 = D.17931 & 65536;
  if (D.17932 != 0) goto <D.17933>; else goto <D.17934>;
  <D.17933>:
  D.17935 = prof->method_end_invoke;
  if (D.17935 != 0B) goto <D.17936>; else goto <D.17937>;
  <D.17936>:
  D.17935 = prof->method_end_invoke;
  D.17938 = prof->profiler;
  D.17935 (D.17938, method);
  <D.17937>:
  <D.17934>:
  prof = prof->next;
  <D.17337>:
  if (prof != 0B) goto <D.17336>; else goto <D.17338>;
  <D.17338>:
}


mono_profiler_code_transition (struct MonoMethod * method, int result)
{
  <unnamed type> D.17939;
  unsigned int D.17940;
  void (*<Tc1d>) (struct MonoProfiler *, struct MonoMethod *, int) D.17943;
  struct MonoProfiler * D.17946;
  struct ProfilerDesc * prof;

  prof = prof_list;
  goto <D.17345>;
  <D.17344>:
  D.17939 = prof->events;
  D.17940 = D.17939 & 2048;
  if (D.17940 != 0) goto <D.17941>; else goto <D.17942>;
  <D.17941>:
  D.17943 = prof->man_unman_transition;
  if (D.17943 != 0B) goto <D.17944>; else goto <D.17945>;
  <D.17944>:
  D.17943 = prof->man_unman_transition;
  D.17946 = prof->profiler;
  D.17943 (D.17946, method, result);
  <D.17945>:
  <D.17942>:
  prof = prof->next;
  <D.17345>:
  if (prof != 0B) goto <D.17344>; else goto <D.17346>;
  <D.17346>:
}


mono_profiler_allocation (struct MonoObject * obj, struct MonoClass * klass)
{
  <unnamed type> D.17947;
  unsigned int D.17948;
  void (*<Tc45>) (struct MonoProfiler *, struct MonoObject *, struct MonoClass *) D.17951;
  struct MonoProfiler * D.17954;
  struct ProfilerDesc * prof;

  prof = prof_list;
  goto <D.17353>;
  <D.17352>:
  D.17947 = prof->events;
  D.17948 = D.17947 & 128;
  if (D.17948 != 0) goto <D.17949>; else goto <D.17950>;
  <D.17949>:
  D.17951 = prof->allocation_cb;
  if (D.17951 != 0B) goto <D.17952>; else goto <D.17953>;
  <D.17952>:
  D.17951 = prof->allocation_cb;
  D.17954 = prof->profiler;
  D.17951 (D.17954, obj, klass);
  <D.17953>:
  <D.17950>:
  prof = prof->next;
  <D.17353>:
  if (prof != 0B) goto <D.17352>; else goto <D.17354>;
  <D.17354>:
}


mono_profiler_monitor_event (struct MonoObject * obj, MonoProfilerMonitorEvent event)
{
  <unnamed type> D.17955;
  unsigned int D.17956;
  void (*<Tc09>) (struct MonoProfiler *, struct MonoObject *, MonoProfilerMonitorEvent) D.17959;
  struct MonoProfiler * D.17962;
  struct ProfilerDesc * prof;

  prof = prof_list;
  goto <D.17361>;
  <D.17360>:
  D.17955 = prof->events;
  D.17956 = D.17955 & 131072;
  if (D.17956 != 0) goto <D.17957>; else goto <D.17958>;
  <D.17957>:
  D.17959 = prof->monitor_event_cb;
  if (D.17959 != 0B) goto <D.17960>; else goto <D.17961>;
  <D.17960>:
  D.17959 = prof->monitor_event_cb;
  D.17962 = prof->profiler;
  D.17959 (D.17962, obj, event);
  <D.17961>:
  <D.17958>:
  prof = prof->next;
  <D.17361>:
  if (prof != 0B) goto <D.17360>; else goto <D.17362>;
  <D.17362>:
}


mono_profiler_stat_hit (guchar * ip, void * context)
{
  <unnamed type> D.17963;
  unsigned int D.17964;
  void (*<Tc4b>) (struct MonoProfiler *, mono_byte *, void *) D.17967;
  struct MonoProfiler * D.17970;
  struct ProfilerDesc * prof;

  prof = prof_list;
  goto <D.17369>;
  <D.17368>:
  D.17963 = prof->events;
  D.17964 = D.17963 & 32768;
  if (D.17964 != 0) goto <D.17965>; else goto <D.17966>;
  <D.17965>:
  D.17967 = prof->statistical_cb;
  if (D.17967 != 0B) goto <D.17968>; else goto <D.17969>;
  <D.17968>:
  D.17967 = prof->statistical_cb;
  D.17970 = prof->profiler;
  D.17967 (D.17970, ip, context);
  <D.17969>:
  <D.17966>:
  prof = prof->next;
  <D.17369>:
  if (prof != 0B) goto <D.17368>; else goto <D.17370>;
  <D.17370>:
}


mono_profiler_stat_call_chain (int call_chain_depth, guchar * * ips, void * context)
{
  <unnamed type> D.17971;
  unsigned int D.17972;
  void (*<Tc51>) (struct MonoProfiler *, int, mono_byte * *, void *) D.17975;
  struct MonoProfiler * D.17978;
  struct ProfilerDesc * prof;

  prof = prof_list;
  goto <D.17378>;
  <D.17377>:
  D.17971 = prof->events;
  D.17972 = D.17971 & 32768;
  if (D.17972 != 0) goto <D.17973>; else goto <D.17974>;
  <D.17973>:
  D.17975 = prof->statistical_call_chain_cb;
  if (D.17975 != 0B) goto <D.17976>; else goto <D.17977>;
  <D.17976>:
  D.17975 = prof->statistical_call_chain_cb;
  D.17978 = prof->profiler;
  D.17975 (D.17978, call_chain_depth, ips, context);
  <D.17977>:
  <D.17974>:
  prof = prof->next;
  <D.17378>:
  if (prof != 0B) goto <D.17377>; else goto <D.17379>;
  <D.17379>:
}


mono_profiler_exception_thrown (struct MonoObject * exception)
{
  <unnamed type> D.17979;
  unsigned int D.17980;
  void (*<Tc0e>) (struct MonoProfiler *, struct MonoObject *) D.17983;
  struct MonoProfiler * D.17986;
  struct ProfilerDesc * prof;

  prof = prof_list;
  goto <D.17385>;
  <D.17384>:
  D.17979 = prof->events;
  D.17980 = D.17979 & 64;
  if (D.17980 != 0) goto <D.17981>; else goto <D.17982>;
  <D.17981>:
  D.17983 = prof->exception_throw_cb;
  if (D.17983 != 0B) goto <D.17984>; else goto <D.17985>;
  <D.17984>:
  D.17983 = prof->exception_throw_cb;
  D.17986 = prof->profiler;
  D.17983 (D.17986, exception);
  <D.17985>:
  <D.17982>:
  prof = prof->next;
  <D.17385>:
  if (prof != 0B) goto <D.17384>; else goto <D.17386>;
  <D.17386>:
}


mono_profiler_exception_method_leave (struct MonoMethod * method)
{
  <unnamed type> D.17987;
  unsigned int D.17988;
  void (*<Tbf5>) (struct MonoProfiler *, struct MonoMethod *) D.17991;
  struct MonoProfiler * D.17994;
  struct ProfilerDesc * prof;

  prof = prof_list;
  goto <D.17392>;
  <D.17391>:
  D.17987 = prof->events;
  D.17988 = D.17987 & 64;
  if (D.17988 != 0) goto <D.17989>; else goto <D.17990>;
  <D.17989>:
  D.17991 = prof->exception_method_leave_cb;
  if (D.17991 != 0B) goto <D.17992>; else goto <D.17993>;
  <D.17992>:
  D.17991 = prof->exception_method_leave_cb;
  D.17994 = prof->profiler;
  D.17991 (D.17994, method);
  <D.17993>:
  <D.17990>:
  prof = prof->next;
  <D.17392>:
  if (prof != 0B) goto <D.17391>; else goto <D.17393>;
  <D.17393>:
}


mono_profiler_exception_clause_handler (struct MonoMethod * method, int clause_type, int clause_num)
{
  <unnamed type> D.17995;
  unsigned int D.17996;
  void (*<Tc13>) (struct MonoProfiler *, struct MonoMethod *, int, int) D.17999;
  struct MonoProfiler * D.18002;
  struct ProfilerDesc * prof;

  prof = prof_list;
  goto <D.17401>;
  <D.17400>:
  D.17995 = prof->events;
  D.17996 = D.17995 & 64;
  if (D.17996 != 0) goto <D.17997>; else goto <D.17998>;
  <D.17997>:
  D.17999 = prof->exception_clause_cb;
  if (D.17999 != 0B) goto <D.18000>; else goto <D.18001>;
  <D.18000>:
  D.17999 = prof->exception_clause_cb;
  D.18002 = prof->profiler;
  D.17999 (D.18002, method, clause_type, clause_num);
  <D.18001>:
  <D.17998>:
  prof = prof->next;
  <D.17401>:
  if (prof != 0B) goto <D.17400>; else goto <D.17402>;
  <D.17402>:
}


mono_profiler_thread_start (gsize tid)
{
  <unnamed type> D.18003;
  unsigned int D.18004;
  void (*<Tc3b>) (struct MonoProfiler *, uintptr_t) D.18007;
  struct MonoProfiler * D.18010;
  struct ProfilerDesc * prof;

  prof = prof_list;
  goto <D.17408>;
  <D.17407>:
  D.18003 = prof->events;
  D.18004 = D.18003 & 512;
  if (D.18004 != 0) goto <D.18005>; else goto <D.18006>;
  <D.18005>:
  D.18007 = prof->thread_start;
  if (D.18007 != 0B) goto <D.18008>; else goto <D.18009>;
  <D.18008>:
  D.18007 = prof->thread_start;
  D.18010 = prof->profiler;
  D.18007 (D.18010, tid);
  <D.18009>:
  <D.18006>:
  prof = prof->next;
  <D.17408>:
  if (prof != 0B) goto <D.17407>; else goto <D.17409>;
  <D.17409>:
}


mono_profiler_thread_end (gsize tid)
{
  <unnamed type> D.18011;
  unsigned int D.18012;
  void (*<Tc3b>) (struct MonoProfiler *, uintptr_t) D.18015;
  struct MonoProfiler * D.18018;
  struct ProfilerDesc * prof;

  prof = prof_list;
  goto <D.17415>;
  <D.17414>:
  D.18011 = prof->events;
  D.18012 = D.18011 & 512;
  if (D.18012 != 0) goto <D.18013>; else goto <D.18014>;
  <D.18013>:
  D.18015 = prof->thread_end;
  if (D.18015 != 0B) goto <D.18016>; else goto <D.18017>;
  <D.18016>:
  D.18015 = prof->thread_end;
  D.18018 = prof->profiler;
  D.18015 (D.18018, tid);
  <D.18017>:
  <D.18014>:
  prof = prof->next;
  <D.17415>:
  if (prof != 0B) goto <D.17414>; else goto <D.17416>;
  <D.17416>:
}


mono_profiler_thread_name (gsize tid, const char * name)
{
  <unnamed type> D.18019;
  unsigned int D.18020;
  void (*<Tc40>) (struct MonoProfiler *, uintptr_t, const char *) D.18023;
  struct MonoProfiler * D.18026;
  struct ProfilerDesc * prof;

  prof = prof_list;
  goto <D.17423>;
  <D.17422>:
  D.18019 = prof->events;
  D.18020 = D.18019 & 512;
  if (D.18020 != 0) goto <D.18021>; else goto <D.18022>;
  <D.18021>:
  D.18023 = prof->thread_name;
  if (D.18023 != 0B) goto <D.18024>; else goto <D.18025>;
  <D.18024>:
  D.18023 = prof->thread_name;
  D.18026 = prof->profiler;
  D.18023 (D.18026, tid, name);
  <D.18025>:
  <D.18022>:
  prof = prof->next;
  <D.17423>:
  if (prof != 0B) goto <D.17422>; else goto <D.17424>;
  <D.17424>:
}


mono_profiler_assembly_event (struct MonoAssembly * assembly, int code)
{
  <unnamed type> D.18027;
  unsigned int D.18028;
  void (*<Tc04>) (struct MonoProfiler *, struct MonoAssembly *) D.18031;
  struct MonoProfiler * D.18034;
  void (*<Tc04>) (struct MonoProfiler *, struct MonoAssembly *) D.18035;
  void (*<Tc04>) (struct MonoProfiler *, struct MonoAssembly *) D.18038;
  struct ProfilerDesc * prof;

  prof = prof_list;
  goto <D.17437>;
  <D.17436>:
  D.18027 = prof->events;
  D.18028 = D.18027 & 2;
  if (D.18028 == 0) goto <D.18029>; else goto <D.18030>;
  <D.18029>:
  // predicted unlikely by continue predictor.
  goto <D.17430>;
  <D.18030>:
  switch (code) <default: <D.17435>, case 0: <D.17431>, case 2: <D.17433>, case 3: <D.17434>>
  <D.17431>:
  D.18031 = prof->assembly_start_load;
  if (D.18031 != 0B) goto <D.18032>; else goto <D.18033>;
  <D.18032>:
  D.18031 = prof->assembly_start_load;
  D.18034 = prof->profiler;
  D.18031 (D.18034, assembly);
  <D.18033>:
  goto <D.17432>;
  <D.17433>:
  D.18035 = prof->assembly_start_unload;
  if (D.18035 != 0B) goto <D.18036>; else goto <D.18037>;
  <D.18036>:
  D.18035 = prof->assembly_start_unload;
  D.18034 = prof->profiler;
  D.18035 (D.18034, assembly);
  <D.18037>:
  goto <D.17432>;
  <D.17434>:
  D.18038 = prof->assembly_end_unload;
  if (D.18038 != 0B) goto <D.18039>; else goto <D.18040>;
  <D.18039>:
  D.18038 = prof->assembly_end_unload;
  D.18034 = prof->profiler;
  D.18038 (D.18034, assembly);
  <D.18040>:
  goto <D.17432>;
  <D.17435>:
  monoeg_assertion_message ("* Assertion: should not be reached at %s:%d\n", "profiler.c", 588);
  <D.17432>:
  <D.17430>:
  prof = prof->next;
  <D.17437>:
  if (prof != 0B) goto <D.17436>; else goto <D.17438>;
  <D.17438>:
}


mono_profiler_assembly_loaded (struct MonoAssembly * assembly, int result)
{
  <unnamed type> D.18041;
  unsigned int D.18042;
  void (*<Tc31>) (struct MonoProfiler *, struct MonoAssembly *, int) D.18045;
  struct MonoProfiler * D.18048;
  struct ProfilerDesc * prof;

  prof = prof_list;
  goto <D.17445>;
  <D.17444>:
  D.18041 = prof->events;
  D.18042 = D.18041 & 2;
  if (D.18042 != 0) goto <D.18043>; else goto <D.18044>;
  <D.18043>:
  D.18045 = prof->assembly_end_load;
  if (D.18045 != 0B) goto <D.18046>; else goto <D.18047>;
  <D.18046>:
  D.18045 = prof->assembly_end_load;
  D.18048 = prof->profiler;
  D.18045 (D.18048, assembly, result);
  <D.18047>:
  <D.18044>:
  prof = prof->next;
  <D.17445>:
  if (prof != 0B) goto <D.17444>; else goto <D.17446>;
  <D.17446>:
}


mono_profiler_iomap (char * report, const char * pathname, const char * new_pathname)
{
  <unnamed type> D.18049;
  unsigned int D.18050;
  void (*<Tc6f>) (struct MonoProfiler *, const char *, const char *, const char *) D.18053;
  struct MonoProfiler * D.18056;
  struct ProfilerDesc * prof;

  prof = prof_list;
  goto <D.17454>;
  <D.17453>:
  D.18049 = prof->events;
  D.18050 = D.18049 & 262144;
  if (D.18050 != 0) goto <D.18051>; else goto <D.18052>;
  <D.18051>:
  D.18053 = prof->iomap_cb;
  if (D.18053 != 0B) goto <D.18054>; else goto <D.18055>;
  <D.18054>:
  D.18053 = prof->iomap_cb;
  D.18056 = prof->profiler;
  D.18053 (D.18056, report, pathname, new_pathname);
  <D.18055>:
  <D.18052>:
  prof = prof->next;
  <D.17454>:
  if (prof != 0B) goto <D.17453>; else goto <D.17455>;
  <D.17455>:
}


mono_profiler_module_event (struct MonoImage * module, int code)
{
  <unnamed type> D.18057;
  unsigned int D.18058;
  void (*<Tbff>) (struct MonoProfiler *, struct MonoImage *) D.18061;
  struct MonoProfiler * D.18064;
  void (*<Tbff>) (struct MonoProfiler *, struct MonoImage *) D.18065;
  void (*<Tbff>) (struct MonoProfiler *, struct MonoImage *) D.18068;
  struct ProfilerDesc * prof;

  prof = prof_list;
  goto <D.17468>;
  <D.17467>:
  D.18057 = prof->events;
  D.18058 = D.18057 & 4;
  if (D.18058 == 0) goto <D.18059>; else goto <D.18060>;
  <D.18059>:
  // predicted unlikely by continue predictor.
  goto <D.17461>;
  <D.18060>:
  switch (code) <default: <D.17466>, case 0: <D.17462>, case 2: <D.17464>, case 3: <D.17465>>
  <D.17462>:
  D.18061 = prof->module_start_load;
  if (D.18061 != 0B) goto <D.18062>; else goto <D.18063>;
  <D.18062>:
  D.18061 = prof->module_start_load;
  D.18064 = prof->profiler;
  D.18061 (D.18064, module);
  <D.18063>:
  goto <D.17463>;
  <D.17464>:
  D.18065 = prof->module_start_unload;
  if (D.18065 != 0B) goto <D.18066>; else goto <D.18067>;
  <D.18066>:
  D.18065 = prof->module_start_unload;
  D.18064 = prof->profiler;
  D.18065 (D.18064, module);
  <D.18067>:
  goto <D.17463>;
  <D.17465>:
  D.18068 = prof->module_end_unload;
  if (D.18068 != 0B) goto <D.18069>; else goto <D.18070>;
  <D.18069>:
  D.18068 = prof->module_end_unload;
  D.18064 = prof->profiler;
  D.18068 (D.18064, module);
  <D.18070>:
  goto <D.17463>;
  <D.17466>:
  monoeg_assertion_message ("* Assertion: should not be reached at %s:%d\n", "profiler.c", 634);
  <D.17463>:
  <D.17461>:
  prof = prof->next;
  <D.17468>:
  if (prof != 0B) goto <D.17467>; else goto <D.17469>;
  <D.17469>:
}


mono_profiler_module_loaded (struct MonoImage * module, int result)
{
  <unnamed type> D.18071;
  unsigned int D.18072;
  void (*<Tc2c>) (struct MonoProfiler *, struct MonoImage *, int) D.18075;
  struct MonoProfiler * D.18078;
  struct ProfilerDesc * prof;

  prof = prof_list;
  goto <D.17476>;
  <D.17475>:
  D.18071 = prof->events;
  D.18072 = D.18071 & 4;
  if (D.18072 != 0) goto <D.18073>; else goto <D.18074>;
  <D.18073>:
  D.18075 = prof->module_end_load;
  if (D.18075 != 0B) goto <D.18076>; else goto <D.18077>;
  <D.18076>:
  D.18075 = prof->module_end_load;
  D.18078 = prof->profiler;
  D.18075 (D.18078, module, result);
  <D.18077>:
  <D.18074>:
  prof = prof->next;
  <D.17476>:
  if (prof != 0B) goto <D.17475>; else goto <D.17477>;
  <D.17477>:
}


mono_profiler_class_event (struct MonoClass * klass, int code)
{
  <unnamed type> D.18079;
  unsigned int D.18080;
  void (*<Tbfa>) (struct MonoProfiler *, struct MonoClass *) D.18083;
  struct MonoProfiler * D.18086;
  void (*<Tbfa>) (struct MonoProfiler *, struct MonoClass *) D.18087;
  void (*<Tbfa>) (struct MonoProfiler *, struct MonoClass *) D.18090;
  struct ProfilerDesc * prof;

  prof = prof_list;
  goto <D.17490>;
  <D.17489>:
  D.18079 = prof->events;
  D.18080 = D.18079 & 8;
  if (D.18080 == 0) goto <D.18081>; else goto <D.18082>;
  <D.18081>:
  // predicted unlikely by continue predictor.
  goto <D.17483>;
  <D.18082>:
  switch (code) <default: <D.17488>, case 0: <D.17484>, case 2: <D.17486>, case 3: <D.17487>>
  <D.17484>:
  D.18083 = prof->class_start_load;
  if (D.18083 != 0B) goto <D.18084>; else goto <D.18085>;
  <D.18084>:
  D.18083 = prof->class_start_load;
  D.18086 = prof->profiler;
  D.18083 (D.18086, klass);
  <D.18085>:
  goto <D.17485>;
  <D.17486>:
  D.18087 = prof->class_start_unload;
  if (D.18087 != 0B) goto <D.18088>; else goto <D.18089>;
  <D.18088>:
  D.18087 = prof->class_start_unload;
  D.18086 = prof->profiler;
  D.18087 (D.18086, klass);
  <D.18089>:
  goto <D.17485>;
  <D.17487>:
  D.18090 = prof->class_end_unload;
  if (D.18090 != 0B) goto <D.18091>; else goto <D.18092>;
  <D.18091>:
  D.18090 = prof->class_end_unload;
  D.18086 = prof->profiler;
  D.18090 (D.18086, klass);
  <D.18092>:
  goto <D.17485>;
  <D.17488>:
  monoeg_assertion_message ("* Assertion: should not be reached at %s:%d\n", "profiler.c", 671);
  <D.17485>:
  <D.17483>:
  prof = prof->next;
  <D.17490>:
  if (prof != 0B) goto <D.17489>; else goto <D.17491>;
  <D.17491>:
}


mono_profiler_class_loaded (struct MonoClass * klass, int result)
{
  <unnamed type> D.18093;
  unsigned int D.18094;
  void (*<Tc27>) (struct MonoProfiler *, struct MonoClass *, int) D.18097;
  struct MonoProfiler * D.18100;
  struct ProfilerDesc * prof;

  prof = prof_list;
  goto <D.17498>;
  <D.17497>:
  D.18093 = prof->events;
  D.18094 = D.18093 & 8;
  if (D.18094 != 0) goto <D.18095>; else goto <D.18096>;
  <D.18095>:
  D.18097 = prof->class_end_load;
  if (D.18097 != 0B) goto <D.18098>; else goto <D.18099>;
  <D.18098>:
  D.18097 = prof->class_end_load;
  D.18100 = prof->profiler;
  D.18097 (D.18100, klass, result);
  <D.18099>:
  <D.18096>:
  prof = prof->next;
  <D.17498>:
  if (prof != 0B) goto <D.17497>; else goto <D.17499>;
  <D.17499>:
}


mono_profiler_appdomain_event (struct MonoDomain * domain, int code)
{
  <unnamed type> D.18101;
  unsigned int D.18102;
  void (*<Tbf0>) (struct MonoProfiler *, struct MonoDomain *) D.18105;
  struct MonoProfiler * D.18108;
  void (*<Tbf0>) (struct MonoProfiler *, struct MonoDomain *) D.18109;
  void (*<Tbf0>) (struct MonoProfiler *, struct MonoDomain *) D.18112;
  struct ProfilerDesc * prof;

  prof = prof_list;
  goto <D.17512>;
  <D.17511>:
  D.18101 = prof->events;
  D.18102 = D.18101 & 1;
  if (D.18102 == 0) goto <D.18103>; else goto <D.18104>;
  <D.18103>:
  // predicted unlikely by continue predictor.
  goto <D.17505>;
  <D.18104>:
  switch (code) <default: <D.17510>, case 0: <D.17506>, case 2: <D.17508>, case 3: <D.17509>>
  <D.17506>:
  D.18105 = prof->domain_start_load;
  if (D.18105 != 0B) goto <D.18106>; else goto <D.18107>;
  <D.18106>:
  D.18105 = prof->domain_start_load;
  D.18108 = prof->profiler;
  D.18105 (D.18108, domain);
  <D.18107>:
  goto <D.17507>;
  <D.17508>:
  D.18109 = prof->domain_start_unload;
  if (D.18109 != 0B) goto <D.18110>; else goto <D.18111>;
  <D.18110>:
  D.18109 = prof->domain_start_unload;
  D.18108 = prof->profiler;
  D.18109 (D.18108, domain);
  <D.18111>:
  goto <D.17507>;
  <D.17509>:
  D.18112 = prof->domain_end_unload;
  if (D.18112 != 0B) goto <D.18113>; else goto <D.18114>;
  <D.18113>:
  D.18112 = prof->domain_end_unload;
  D.18108 = prof->profiler;
  D.18112 (D.18108, domain);
  <D.18114>:
  goto <D.17507>;
  <D.17510>:
  monoeg_assertion_message ("* Assertion: should not be reached at %s:%d\n", "profiler.c", 708);
  <D.17507>:
  <D.17505>:
  prof = prof->next;
  <D.17512>:
  if (prof != 0B) goto <D.17511>; else goto <D.17513>;
  <D.17513>:
}


mono_profiler_appdomain_loaded (struct MonoDomain * domain, int result)
{
  <unnamed type> D.18115;
  unsigned int D.18116;
  void (*<Tc18>) (struct MonoProfiler *, struct MonoDomain *, int) D.18119;
  struct MonoProfiler * D.18122;
  struct ProfilerDesc * prof;

  prof = prof_list;
  goto <D.17520>;
  <D.17519>:
  D.18115 = prof->events;
  D.18116 = D.18115 & 1;
  if (D.18116 != 0) goto <D.18117>; else goto <D.18118>;
  <D.18117>:
  D.18119 = prof->domain_end_load;
  if (D.18119 != 0B) goto <D.18120>; else goto <D.18121>;
  <D.18120>:
  D.18119 = prof->domain_end_load;
  D.18122 = prof->profiler;
  D.18119 (D.18122, domain, result);
  <D.18121>:
  <D.18118>:
  prof = prof->next;
  <D.17520>:
  if (prof != 0B) goto <D.17519>; else goto <D.17521>;
  <D.17521>:
}


mono_profiler_shutdown ()
{
  void (*<Tbeb>) (struct MonoProfiler *) D.18123;
  struct MonoProfiler * D.18126;
  struct ProfilerDesc * prof;

  prof = prof_list;
  goto <D.17527>;
  <D.17526>:
  D.18123 = prof->shutdown_callback;
  if (D.18123 != 0B) goto <D.18124>; else goto <D.18125>;
  <D.18124>:
  D.18123 = prof->shutdown_callback;
  D.18126 = prof->profiler;
  D.18123 (D.18126);
  <D.18125>:
  prof = prof->next;
  <D.17527>:
  if (prof != 0B) goto <D.17526>; else goto <D.17528>;
  <D.17528>:
  mono_profiler_set_events (0);
}


mono_profiler_gc_heap_resize (gint64 new_size)
{
  <unnamed type> D.18127;
  unsigned int D.18128;
  void (*<Tc60>) (struct MonoProfiler *, int64_t) D.18131;
  struct MonoProfiler * D.18134;
  struct ProfilerDesc * prof;

  prof = prof_list;
  goto <D.17534>;
  <D.17533>:
  D.18127 = prof->events;
  D.18128 = D.18127 & 256;
  if (D.18128 != 0) goto <D.18129>; else goto <D.18130>;
  <D.18129>:
  D.18131 = prof->gc_heap_resize;
  if (D.18131 != 0B) goto <D.18132>; else goto <D.18133>;
  <D.18132>:
  D.18131 = prof->gc_heap_resize;
  D.18134 = prof->profiler;
  D.18131 (D.18134, new_size);
  <D.18133>:
  <D.18130>:
  prof = prof->next;
  <D.17534>:
  if (prof != 0B) goto <D.17533>; else goto <D.17535>;
  <D.17535>:
}


mono_profiler_gc_event (MonoGCEvent event, int generation)
{
  <unnamed type> D.18135;
  unsigned int D.18136;
  void (*<Tc56>) (struct MonoProfiler *, MonoGCEvent, int) D.18139;
  struct MonoProfiler * D.18142;
  struct ProfilerDesc * prof;

  prof = prof_list;
  goto <D.17542>;
  <D.17541>:
  D.18135 = prof->events;
  D.18136 = D.18135 & 256;
  if (D.18136 != 0) goto <D.18137>; else goto <D.18138>;
  <D.18137>:
  D.18139 = prof->gc_event;
  if (D.18139 != 0B) goto <D.18140>; else goto <D.18141>;
  <D.18140>:
  D.18139 = prof->gc_event;
  D.18142 = prof->profiler;
  D.18139 (D.18142, event, generation);
  <D.18141>:
  <D.18138>:
  prof = prof->next;
  <D.17542>:
  if (prof != 0B) goto <D.17541>; else goto <D.17543>;
  <D.17543>:
}


mono_profiler_gc_moves (void * * objects, int num)
{
  <unnamed type> D.18143;
  unsigned int D.18144;
  void (*<Tc5b>) (struct MonoProfiler *, void * *, int) D.18147;
  struct MonoProfiler * D.18150;
  struct ProfilerDesc * prof;

  prof = prof_list;
  goto <D.17550>;
  <D.17549>:
  D.18143 = prof->events;
  D.18144 = D.18143 & 524288;
  if (D.18144 != 0) goto <D.18145>; else goto <D.18146>;
  <D.18145>:
  D.18147 = prof->gc_moves;
  if (D.18147 != 0B) goto <D.18148>; else goto <D.18149>;
  <D.18148>:
  D.18147 = prof->gc_moves;
  D.18150 = prof->profiler;
  D.18147 (D.18150, objects, num);
  <D.18149>:
  <D.18146>:
  prof = prof->next;
  <D.17550>:
  if (prof != 0B) goto <D.17549>; else goto <D.17551>;
  <D.17551>:
}


mono_profiler_gc_handle (int op, int type, uintptr_t handle, struct MonoObject * obj)
{
  <unnamed type> D.18151;
  unsigned int D.18152;
  void (*<Tc65>) (struct MonoProfiler *, int, int, uintptr_t, struct MonoObject *) D.18155;
  struct MonoProfiler * D.18158;
  struct ProfilerDesc * prof;

  prof = prof_list;
  goto <D.17560>;
  <D.17559>:
  D.18151 = prof->events;
  D.18152 = D.18151 & 1048576;
  if (D.18152 != 0) goto <D.18153>; else goto <D.18154>;
  <D.18153>:
  D.18155 = prof->gc_handle;
  if (D.18155 != 0B) goto <D.18156>; else goto <D.18157>;
  <D.18156>:
  D.18155 = prof->gc_handle;
  D.18158 = prof->profiler;
  D.18155 (D.18158, op, type, handle, obj);
  <D.18157>:
  <D.18154>:
  prof = prof->next;
  <D.17560>:
  if (prof != 0B) goto <D.17559>; else goto <D.17561>;
  <D.17561>:
}


mono_profiler_gc_roots (int num, void * * objects, int * root_types, uintptr_t * extra_info)
{
  <unnamed type> D.18159;
  unsigned int D.18160;
  void (*<Tc6a>) (struct MonoProfiler *, int, void * *, int *, uintptr_t *) D.18163;
  struct MonoProfiler * D.18166;
  struct ProfilerDesc * prof;

  prof = prof_list;
  goto <D.17570>;
  <D.17569>:
  D.18159 = prof->events;
  D.18160 = D.18159 & 1048576;
  if (D.18160 != 0) goto <D.18161>; else goto <D.18162>;
  <D.18161>:
  D.18163 = prof->gc_roots;
  if (D.18163 != 0B) goto <D.18164>; else goto <D.18165>;
  <D.18164>:
  D.18163 = prof->gc_roots;
  D.18166 = prof->profiler;
  D.18163 (D.18166, num, objects, root_types, extra_info);
  <D.18165>:
  <D.18162>:
  prof = prof->next;
  <D.17570>:
  if (prof != 0B) goto <D.17569>; else goto <D.17571>;
  <D.17571>:
}


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.18168>; else goto <D.18169>;
  <D.18168>:
  return;
  <D.18169>:
  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.18172>; else goto <D.18173>;
  <D.18172>:
  return;
  <D.18173>:
  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.18176>; else goto <D.18177>;
  <D.18176>:
  return;
  <D.18177>:
  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.18180>; else goto <D.18181>;
  <D.18180>:
  return;
  <D.18181>:
  prof_list.25 = prof_list;
  prof_list.25->runtime_initialized_event = runtime_initialized_callback;
}


mono_profiler_runtime_initialized ()
{
  void (*<Tbeb>) (struct MonoProfiler *) D.18183;
  struct MonoProfiler * D.18186;
  struct ProfilerDesc * prof;

  prof = prof_list;
  goto <D.17591>;
  <D.17590>:
  D.18183 = prof->runtime_initialized_event;
  if (D.18183 != 0B) goto <D.18184>; else goto <D.18185>;
  <D.18184>:
  D.18183 = prof->runtime_initialized_event;
  D.18186 = prof->profiler;
  D.18183 (D.18186);
  <D.18185>:
  prof = prof->next;
  <D.17591>:
  if (prof != 0B) goto <D.17590>; else goto <D.17592>;
  <D.17592>:
}


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


mono_profiler_code_chunk_new (void * chunk, int size)
{
  void (*<Tc82>) (struct MonoProfiler *, void *, int) D.18191;
  struct MonoProfiler * D.18194;
  struct ProfilerDesc * prof;

  prof = prof_list;
  goto <D.17602>;
  <D.17601>:
  D.18191 = prof->code_chunk_new;
  if (D.18191 != 0B) goto <D.18192>; else goto <D.18193>;
  <D.18192>:
  D.18191 = prof->code_chunk_new;
  D.18194 = prof->profiler;
  D.18191 (D.18194, chunk, size);
  <D.18193>:
  prof = prof->next;
  <D.17602>:
  if (prof != 0B) goto <D.17601>; else goto <D.17603>;
  <D.17603>:
}


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


mono_profiler_code_chunk_destroy (void * chunk)
{
  void (*<Tc87>) (struct MonoProfiler *, void *) D.18199;
  struct MonoProfiler * D.18202;
  struct ProfilerDesc * prof;

  prof = prof_list;
  goto <D.17612>;
  <D.17611>:
  D.18199 = prof->code_chunk_destroy;
  if (D.18199 != 0B) goto <D.18200>; else goto <D.18201>;
  <D.18200>:
  D.18199 = prof->code_chunk_destroy;
  D.18202 = prof->profiler;
  D.18199 (D.18202, chunk);
  <D.18201>:
  prof = prof->next;
  <D.17612>:
  if (prof != 0B) goto <D.17611>; else goto <D.17613>;
  <D.17613>:
}


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.18204>; else goto <D.18205>;
  <D.18204>:
  return;
  <D.18205>:
  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.18208>; else goto <D.18209>;
  <D.18208>:
  return;
  <D.18209>:
  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 (*<Tc8c>) (struct MonoProfiler *, void *, int, MonoProfilerCodeBufferType, void *) D.18211;
  struct MonoProfiler * D.18214;
  struct ProfilerDesc * prof;

  prof = prof_list;
  goto <D.17628>;
  <D.17627>:
  D.18211 = prof->code_buffer_new;
  if (D.18211 != 0B) goto <D.18212>; else goto <D.18213>;
  <D.18212>:
  D.18211 = prof->code_buffer_new;
  D.18214 = prof->profiler;
  D.18211 (D.18214, buffer, size, type, data);
  <D.18213>:
  prof = prof->next;
  <D.17628>:
  if (prof != 0B) goto <D.17627>; else goto <D.17629>;
  <D.17629>:
}


mono_profiler_coverage_alloc (struct MonoMethod * method, int entries)
{
  mono_bool (*<Tc74>) (struct MonoProfiler *, struct MonoMethod *) D.18215;
  struct MonoProfiler * D.18218;
  int D.18219;
  struct MonoProfileCoverageInfo * D.18224;
  _Bool D.18227;
  long int D.18228;
  long int D.18229;
  struct GHashTable * coverage_hash.30;
  struct GHashTable * coverage_hash.31;
  long unsigned int D.18236;
  long unsigned int D.18237;
  long unsigned int D.18238;
  _Bool D.18241;
  long int D.18242;
  long int D.18243;
  struct MonoProfileCoverageInfo * res;
  int instrument;
  struct ProfilerDesc * prof;

  instrument = 0;
  prof = prof_list;
  goto <D.17639>;
  <D.17638>:
  D.18215 = prof->coverage_filter_cb;
  if (D.18215 != 0B) goto <D.18216>; else goto <D.18217>;
  <D.18216>:
  D.18215 = prof->coverage_filter_cb;
  D.18218 = prof->profiler;
  D.18219 = D.18215 (D.18218, method);
  if (D.18219 != 0) goto <D.18220>; else goto <D.18221>;
  <D.18220>:
  instrument = 1;
  <D.18221>:
  <D.18217>:
  prof = prof->next;
  <D.17639>:
  if (prof != 0B) goto <D.17638>; else goto <D.17640>;
  <D.17640>:
  if (instrument == 0) goto <D.18222>; else goto <D.18223>;
  <D.18222>:
  D.18224 = 0B;
  return D.18224;
  <D.18223>:
  {
    int ret;

    ret = pthread_mutex_lock (&profiler_coverage_mutex.mutex);
    if (ret != 0) goto <D.18225>; else goto <D.18226>;
    <D.18225>:
    monoeg_g_log (0B, 16, "Bad call to mono_mutex_lock result %d", ret);
    <D.18226>:
    D.18227 = ret != 0;
    D.18228 = (long int) D.18227;
    D.18229 = __builtin_expect (D.18228, 0);
    if (D.18229 != 0) goto <D.18230>; else goto <D.18231>;
    <D.18230>:
    monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "profiler.c", 933, "ret == 0");
    <D.18231>:
  }
  coverage_hash.30 = coverage_hash;
  if (coverage_hash.30 == 0B) goto <D.18233>; else goto <D.18234>;
  <D.18233>:
  coverage_hash.31 = monoeg_g_hash_table_new (0B, 0B);
  coverage_hash = coverage_hash.31;
  <D.18234>:
  D.18236 = (long unsigned int) entries;
  D.18237 = D.18236 * 16;
  D.18238 = D.18237 + 24;
  res = monoeg_malloc0 (D.18238);
  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.18239>; else goto <D.18240>;
    <D.18239>:
    monoeg_g_log (0B, 16, "Bad call to mono_mutex_unlock result %d", ret);
    <D.18240>:
    D.18241 = ret != 0;
    D.18242 = (long int) D.18241;
    D.18243 = __builtin_expect (D.18242, 0);
    if (D.18243 != 0) goto <D.18244>; else goto <D.18245>;
    <D.18244>:
    monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "profiler.c", 942, "ret == 0");
    <D.18245>:
  }
  D.18224 = res;
  return D.18224;
}


mono_profiler_coverage_free (struct MonoMethod * method)
{
  _Bool D.18249;
  long int D.18250;
  long int D.18251;
  struct GHashTable * coverage_hash.32;
  _Bool D.18259;
  long int D.18260;
  long int D.18261;
  _Bool D.18268;
  long int D.18269;
  long int D.18270;
  struct MonoProfileCoverageInfo * info;

  {
    int ret;

    ret = pthread_mutex_lock (&profiler_coverage_mutex.mutex);
    if (ret != 0) goto <D.18247>; else goto <D.18248>;
    <D.18247>:
    monoeg_g_log (0B, 16, "Bad call to mono_mutex_lock result %d", ret);
    <D.18248>:
    D.18249 = ret != 0;
    D.18250 = (long int) D.18249;
    D.18251 = __builtin_expect (D.18250, 0);
    if (D.18251 != 0) goto <D.18252>; else goto <D.18253>;
    <D.18252>:
    monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "profiler.c", 953, "ret == 0");
    <D.18253>:
  }
  coverage_hash.32 = coverage_hash;
  if (coverage_hash.32 == 0B) goto <D.18255>; else goto <D.18256>;
  <D.18255>:
  {
    int ret;

    ret = pthread_mutex_unlock (&profiler_coverage_mutex.mutex);
    if (ret != 0) goto <D.18257>; else goto <D.18258>;
    <D.18257>:
    monoeg_g_log (0B, 16, "Bad call to mono_mutex_unlock result %d", ret);
    <D.18258>:
    D.18259 = ret != 0;
    D.18260 = (long int) D.18259;
    D.18261 = __builtin_expect (D.18260, 0);
    if (D.18261 != 0) goto <D.18262>; else goto <D.18263>;
    <D.18262>:
    monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "profiler.c", 955, "ret == 0");
    <D.18263>:
  }
  return;
  <D.18256>:
  coverage_hash.32 = coverage_hash;
  info = monoeg_g_hash_table_lookup (coverage_hash.32, method);
  if (info != 0B) goto <D.18264>; else goto <D.18265>;
  <D.18264>:
  monoeg_g_free (info);
  coverage_hash.32 = coverage_hash;
  monoeg_g_hash_table_remove (coverage_hash.32, method);
  <D.18265>:
  {
    int ret;

    ret = pthread_mutex_unlock (&profiler_coverage_mutex.mutex);
    if (ret != 0) goto <D.18266>; else goto <D.18267>;
    <D.18266>:
    monoeg_g_log (0B, 16, "Bad call to mono_mutex_unlock result %d", ret);
    <D.18267>:
    D.18268 = ret != 0;
    D.18269 = (long int) D.18268;
    D.18270 = __builtin_expect (D.18269, 0);
    if (D.18270 != 0) goto <D.18271>; else goto <D.18272>;
    <D.18271>:
    monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "profiler.c", 964, "ret == 0");
    <D.18272>:
  }
}


mono_profiler_coverage_get (struct MonoProfiler * prof, struct MonoMethod * method, void (*MonoProfileCoverageFunc) (struct MonoProfiler *, const struct MonoProfileCoverageEntry *) func)
{
  _Bool D.18276;
  long int D.18277;
  long int D.18278;
  struct GHashTable * coverage_hash.33;
  _Bool D.18284;
  long int D.18285;
  long int D.18286;
  unsigned int code_size.34;
  sizetype D.18292;
  _Bool D.18293;
  _Bool D.18294;
  _Bool D.18295;
  long int cil_code.35;
  long int start.36;
  long int D.18302;
  int D.18303;
  int D.18304;
  unsigned int offset.37;
  unsigned int D.18310;
  int D.18311;
  unsigned int D.18312;
  int D.18313;
  char * D.18314;
  int D.18315;
  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.18274>; else goto <D.18275>;
        <D.18274>:
        monoeg_g_log (0B, 16, "Bad call to mono_mutex_lock result %d", ret);
        <D.18275>:
        D.18276 = ret != 0;
        D.18277 = (long int) D.18276;
        D.18278 = __builtin_expect (D.18277, 0);
        if (D.18278 != 0) goto <D.18279>; else goto <D.18280>;
        <D.18279>:
        monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "profiler.c", 990, "ret == 0");
        <D.18280>:
      }
      coverage_hash.33 = coverage_hash;
      info = monoeg_g_hash_table_lookup (coverage_hash.33, method);
      {
        int ret;

        ret = pthread_mutex_unlock (&profiler_coverage_mutex.mutex);
        if (ret != 0) goto <D.18282>; else goto <D.18283>;
        <D.18282>:
        monoeg_g_log (0B, 16, "Bad call to mono_mutex_unlock result %d", ret);
        <D.18283>:
        D.18284 = ret != 0;
        D.18285 = (long int) D.18284;
        D.18286 = __builtin_expect (D.18285, 0);
        if (D.18286 != 0) goto <D.18287>; else goto <D.18288>;
        <D.18287>:
        monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "profiler.c", 992, "ret == 0");
        <D.18288>:
      }
      if (info == 0B) goto <D.18289>; else goto <D.18290>;
      <D.18289>:
      return;
      <D.18290>:
      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.34 = code_size;
      D.18292 = (sizetype) code_size.34;
      end = start + D.18292;
      i = 0;
      goto <D.17670>;
      <D.17669>:
      cil_code = info->data[i].cil_code;
      D.18293 = cil_code != 0B;
      D.18294 = cil_code >= start;
      D.18295 = D.18293 & D.18294;
      if (D.18295 != 0) goto <D.18296>; else goto <D.18297>;
      <D.18296>:
      if (cil_code < end) goto <D.18298>; else goto <D.18299>;
      <D.18298>:
      {
        char * fname;

        fname = 0B;
        cil_code.35 = (long int) cil_code;
        start.36 = (long int) start;
        D.18302 = cil_code.35 - start.36;
        offset = (int) D.18302;
        entry.iloffset = offset;
        entry.method = method;
        D.18303 = info->data[i].count;
        entry.counter = D.18303;
        entry.col = 1;
        D.18304 = entry.col;
        entry.line = D.18304;
        entry.filename = 0B;
        if (debug_minfo != 0B) goto <D.18305>; else goto <D.18306>;
        <D.18305>:
        {
          struct MonoDebugSourceLocation * location;

          offset.37 = (unsigned int) offset;
          location = mono_debug_symfile_lookup_location (debug_minfo, offset.37);
          if (location != 0B) goto <D.18308>; else goto <D.18309>;
          <D.18308>:
          D.18310 = location->row;
          D.18311 = (int) D.18310;
          entry.line = D.18311;
          D.18312 = location->column;
          D.18313 = (int) D.18312;
          entry.col = D.18313;
          D.18314 = location->source_file;
          fname = monoeg_strdup (D.18314);
          entry.filename = fname;
          mono_debug_free_source_location (location);
          <D.18309>:
        }
        <D.18306>:
        func (prof, &entry);
        monoeg_g_free (fname);
      }
      <D.18299>:
      <D.18297>:
      i = i + 1;
      <D.17670>:
      D.18315 = info->entries;
      if (D.18315 > i) goto <D.17669>; else goto <D.17671>;
      <D.17671>:
      mono_metadata_free_mh (header);
    }
  finally
    {
      code_size = {CLOBBER};
      entry = {CLOBBER};
    }
}


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

  if (str != 0B) goto <D.18319>; else goto <D.18320>;
  <D.18319>:
  D.18321 = __strdup (str);
  return D.18321;
  <D.18320>:
  D.18321 = 0B;
  return D.18321;
}


mono_profiler_load (const char * desc)
{
  int D.17713;
  int iftmp.38;
  int D.17709;
  const char[8] * D.18329;
  unsigned char D.18330;
  int D.18331;
  unsigned char D.18332;
  int D.18333;
  _Bool D.18334;
  _Bool D.18335;
  _Bool D.18336;
  const unsigned char * D.18339;
  unsigned char D.18340;
  int D.18341;
  const unsigned char * D.18342;
  unsigned char D.18343;
  int D.18344;
  _Bool D.18345;
  _Bool D.18346;
  const unsigned char * D.18349;
  unsigned char D.18350;
  int D.18351;
  const unsigned char * D.18352;
  unsigned char D.18353;
  int D.18354;
  _Bool D.18355;
  _Bool D.18356;
  const unsigned char * D.18359;
  unsigned char D.18360;
  int D.18361;
  const unsigned char * D.18362;
  unsigned char D.18363;
  int D.18364;
  int D.18366;
  const gchar * D.18369;
  int D.17735;
  int iftmp.39;
  int D.17734;
  const char[5] * D.18373;
  unsigned char D.18374;
  int D.18375;
  unsigned char D.18376;
  int D.18377;
  _Bool D.18378;
  _Bool D.18379;
  _Bool D.18380;
  const unsigned char * D.18383;
  unsigned char D.18384;
  int D.18385;
  const unsigned char * D.18386;
  unsigned char D.18387;
  int D.18388;
  _Bool D.18389;
  _Bool D.18390;
  const unsigned char * D.18393;
  unsigned char D.18394;
  int D.18395;
  const unsigned char * D.18396;
  unsigned char D.18397;
  int D.18398;
  _Bool D.18399;
  _Bool D.18400;
  const unsigned char * D.18403;
  unsigned char D.18404;
  int D.18405;
  const unsigned char * D.18406;
  unsigned char D.18407;
  int D.18408;
  int D.17744;
  int iftmp.40;
  int D.17743;
  const char[6] * D.18416;
  unsigned char D.18417;
  int D.18418;
  unsigned char D.18419;
  int D.18420;
  _Bool D.18421;
  _Bool D.18422;
  _Bool D.18423;
  const unsigned char * D.18426;
  unsigned char D.18427;
  int D.18428;
  const unsigned char * D.18429;
  unsigned char D.18430;
  int D.18431;
  _Bool D.18432;
  _Bool D.18433;
  const unsigned char * D.18436;
  unsigned char D.18437;
  int D.18438;
  const unsigned char * D.18439;
  unsigned char D.18440;
  int D.18441;
  _Bool D.18442;
  _Bool D.18443;
  const unsigned char * D.18446;
  unsigned char D.18447;
  int D.18448;
  const unsigned char * D.18449;
  unsigned char D.18450;
  int D.18451;
  int D.17753;
  int iftmp.41;
  int D.17752;
  const char[5] * D.18459;
  unsigned char D.18460;
  int D.18461;
  unsigned char D.18462;
  int D.18463;
  _Bool D.18464;
  _Bool D.18465;
  _Bool D.18466;
  const unsigned char * D.18469;
  unsigned char D.18470;
  int D.18471;
  const unsigned char * D.18472;
  unsigned char D.18473;
  int D.18474;
  _Bool D.18475;
  _Bool D.18476;
  const unsigned char * D.18479;
  unsigned char D.18480;
  int D.18481;
  const unsigned char * D.18482;
  unsigned char D.18483;
  int D.18484;
  _Bool D.18485;
  _Bool D.18486;
  const unsigned char * D.18489;
  unsigned char D.18490;
  int D.18491;
  const unsigned char * D.18492;
  unsigned char D.18493;
  int D.18494;
  int D.17762;
  int iftmp.42;
  int D.17761;
  const char[4] * D.18502;
  unsigned char D.18503;
  int D.18504;
  unsigned char D.18505;
  int D.18506;
  _Bool D.18507;
  _Bool D.18508;
  _Bool D.18509;
  const unsigned char * D.18512;
  unsigned char D.18513;
  int D.18514;
  const unsigned char * D.18515;
  unsigned char D.18516;
  int D.18517;
  _Bool D.18518;
  _Bool D.18519;
  const unsigned char * D.18522;
  unsigned char D.18523;
  int D.18524;
  const unsigned char * D.18525;
  unsigned char D.18526;
  int D.18527;
  _Bool D.18528;
  _Bool D.18529;
  const unsigned char * D.18532;
  unsigned char D.18533;
  int D.18534;
  const unsigned char * D.18535;
  unsigned char D.18536;
  int D.18537;
  int D.18541;
  const char * D.18544;
  struct _IO_FILE * stderr.43;
  gchar * D.18548;
  long int col.44;
  long int desc.45;
  long int D.18553;
  unsigned int D.18554;
  unsigned int D.18555;
  sizetype D.18556;
  char * D.18557;
  int D.18559;
  int D.18562;
  const char * D.18565;
  char * cdesc;

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

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

      __s2 = desc;
      D.18329 = "default";
      D.18330 = MEM[(const unsigned char *)D.18329];
      D.18331 = (int) D.18330;
      D.18332 = *__s2;
      D.18333 = (int) D.18332;
      __result = D.18331 - D.18333;
      {
        D.18334 = __s1_len != 0;
        D.18335 = __result == 0;
        D.18336 = D.18334 & D.18335;
        if (D.18336 != 0) goto <D.18337>; else goto <D.18338>;
        <D.18337>:
        D.18339 = &MEM[(void *)"default" + 1B];
        D.18340 = *D.18339;
        D.18341 = (int) D.18340;
        D.18342 = __s2 + 1;
        D.18343 = *D.18342;
        D.18344 = (int) D.18343;
        __result = D.18341 - D.18344;
        D.18345 = __s1_len > 1;
        D.18335 = __result == 0;
        D.18346 = D.18345 & D.18335;
        if (D.18346 != 0) goto <D.18347>; else goto <D.18348>;
        <D.18347>:
        D.18349 = &MEM[(void *)"default" + 2B];
        D.18350 = *D.18349;
        D.18351 = (int) D.18350;
        D.18352 = __s2 + 2;
        D.18353 = *D.18352;
        D.18354 = (int) D.18353;
        __result = D.18351 - D.18354;
        D.18355 = __s1_len > 2;
        D.18335 = __result == 0;
        D.18356 = D.18355 & D.18335;
        if (D.18356 != 0) goto <D.18357>; else goto <D.18358>;
        <D.18357>:
        D.18359 = &MEM[(void *)"default" + 3B];
        D.18360 = *D.18359;
        D.18361 = (int) D.18360;
        D.18362 = __s2 + 3;
        D.18363 = *D.18362;
        D.18364 = (int) D.18363;
        __result = D.18361 - D.18364;
        <D.18358>:
        <D.18348>:
        <D.18338>:
      }
      D.17709 = __result;
    }
    iftmp.38 = D.17709;
    goto <D.18365>;
    <D.18328>:
    iftmp.38 = __builtin_strcmp ("default", desc);
    <D.18365>:
    D.17713 = iftmp.38;
  }
  if (D.17713 == 0) goto <D.18323>; else goto <D.18324>;
  <D.18323>:
  desc = "log:report";
  <D.18324>:
  D.18366 = strncmp (desc, "default:", 8);
  if (D.18366 == 0) goto <D.18367>; else goto <D.18368>;
  <D.18367>:
  {
    gchar * * args;
    gchar * * ptr;
    struct GString * str;

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

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

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

          __s2 = arg;
          D.18373 = "time";
          D.18374 = MEM[(const unsigned char *)D.18373];
          D.18375 = (int) D.18374;
          D.18376 = *__s2;
          D.18377 = (int) D.18376;
          __result = D.18375 - D.18377;
          {
            D.18378 = __s2_len != 0;
            D.18379 = __result == 0;
            D.18380 = D.18378 & D.18379;
            if (D.18380 != 0) goto <D.18381>; else goto <D.18382>;
            <D.18381>:
            D.18383 = &MEM[(void *)"time" + 1B];
            D.18384 = *D.18383;
            D.18385 = (int) D.18384;
            D.18386 = __s2 + 1;
            D.18387 = *D.18386;
            D.18388 = (int) D.18387;
            __result = D.18385 - D.18388;
            D.18389 = __s2_len > 1;
            D.18379 = __result == 0;
            D.18390 = D.18389 & D.18379;
            if (D.18390 != 0) goto <D.18391>; else goto <D.18392>;
            <D.18391>:
            D.18393 = &MEM[(void *)"time" + 2B];
            D.18394 = *D.18393;
            D.18395 = (int) D.18394;
            D.18396 = __s2 + 2;
            D.18397 = *D.18396;
            D.18398 = (int) D.18397;
            __result = D.18395 - D.18398;
            D.18399 = __s2_len > 2;
            D.18379 = __result == 0;
            D.18400 = D.18399 & D.18379;
            if (D.18400 != 0) goto <D.18401>; else goto <D.18402>;
            <D.18401>:
            D.18403 = &MEM[(void *)"time" + 3B];
            D.18404 = *D.18403;
            D.18405 = (int) D.18404;
            D.18406 = __s2 + 3;
            D.18407 = *D.18406;
            D.18408 = (int) D.18407;
            __result = D.18405 - D.18408;
            <D.18402>:
            <D.18392>:
            <D.18382>:
          }
          D.17734 = __result;
        }
        iftmp.39 = -D.17734;
        goto <D.18409>;
        <D.18372>:
        iftmp.39 = __builtin_strcmp (arg, "time");
        <D.18409>:
        D.17735 = iftmp.39;
      }
      if (D.17735 == 0) goto <D.18410>; else goto <D.18411>;
      <D.18410>:
      monoeg_g_string_append (str, ",calls");
      goto <D.18412>;
      <D.18411>:
      {
        size_t __s1_len;
        size_t __s2_len;

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

          __s2 = arg;
          D.18416 = "alloc";
          D.18417 = MEM[(const unsigned char *)D.18416];
          D.18418 = (int) D.18417;
          D.18419 = *__s2;
          D.18420 = (int) D.18419;
          __result = D.18418 - D.18420;
          {
            D.18421 = __s2_len != 0;
            D.18422 = __result == 0;
            D.18423 = D.18421 & D.18422;
            if (D.18423 != 0) goto <D.18424>; else goto <D.18425>;
            <D.18424>:
            D.18426 = &MEM[(void *)"alloc" + 1B];
            D.18427 = *D.18426;
            D.18428 = (int) D.18427;
            D.18429 = __s2 + 1;
            D.18430 = *D.18429;
            D.18431 = (int) D.18430;
            __result = D.18428 - D.18431;
            D.18432 = __s2_len > 1;
            D.18422 = __result == 0;
            D.18433 = D.18432 & D.18422;
            if (D.18433 != 0) goto <D.18434>; else goto <D.18435>;
            <D.18434>:
            D.18436 = &MEM[(void *)"alloc" + 2B];
            D.18437 = *D.18436;
            D.18438 = (int) D.18437;
            D.18439 = __s2 + 2;
            D.18440 = *D.18439;
            D.18441 = (int) D.18440;
            __result = D.18438 - D.18441;
            D.18442 = __s2_len > 2;
            D.18422 = __result == 0;
            D.18443 = D.18442 & D.18422;
            if (D.18443 != 0) goto <D.18444>; else goto <D.18445>;
            <D.18444>:
            D.18446 = &MEM[(void *)"alloc" + 3B];
            D.18447 = *D.18446;
            D.18448 = (int) D.18447;
            D.18449 = __s2 + 3;
            D.18450 = *D.18449;
            D.18451 = (int) D.18450;
            __result = D.18448 - D.18451;
            <D.18445>:
            <D.18435>:
            <D.18425>:
          }
          D.17743 = __result;
        }
        iftmp.40 = -D.17743;
        goto <D.18452>;
        <D.18415>:
        iftmp.40 = __builtin_strcmp (arg, "alloc");
        <D.18452>:
        D.17744 = iftmp.40;
      }
      if (D.17744 == 0) goto <D.18453>; else goto <D.18454>;
      <D.18453>:
      monoeg_g_string_append (str, ",alloc");
      goto <D.18455>;
      <D.18454>:
      {
        size_t __s1_len;
        size_t __s2_len;

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

          __s2 = arg;
          D.18459 = "stat";
          D.18460 = MEM[(const unsigned char *)D.18459];
          D.18461 = (int) D.18460;
          D.18462 = *__s2;
          D.18463 = (int) D.18462;
          __result = D.18461 - D.18463;
          {
            D.18464 = __s2_len != 0;
            D.18465 = __result == 0;
            D.18466 = D.18464 & D.18465;
            if (D.18466 != 0) goto <D.18467>; else goto <D.18468>;
            <D.18467>:
            D.18469 = &MEM[(void *)"stat" + 1B];
            D.18470 = *D.18469;
            D.18471 = (int) D.18470;
            D.18472 = __s2 + 1;
            D.18473 = *D.18472;
            D.18474 = (int) D.18473;
            __result = D.18471 - D.18474;
            D.18475 = __s2_len > 1;
            D.18465 = __result == 0;
            D.18476 = D.18475 & D.18465;
            if (D.18476 != 0) goto <D.18477>; else goto <D.18478>;
            <D.18477>:
            D.18479 = &MEM[(void *)"stat" + 2B];
            D.18480 = *D.18479;
            D.18481 = (int) D.18480;
            D.18482 = __s2 + 2;
            D.18483 = *D.18482;
            D.18484 = (int) D.18483;
            __result = D.18481 - D.18484;
            D.18485 = __s2_len > 2;
            D.18465 = __result == 0;
            D.18486 = D.18485 & D.18465;
            if (D.18486 != 0) goto <D.18487>; else goto <D.18488>;
            <D.18487>:
            D.18489 = &MEM[(void *)"stat" + 3B];
            D.18490 = *D.18489;
            D.18491 = (int) D.18490;
            D.18492 = __s2 + 3;
            D.18493 = *D.18492;
            D.18494 = (int) D.18493;
            __result = D.18491 - D.18494;
            <D.18488>:
            <D.18478>:
            <D.18468>:
          }
          D.17752 = __result;
        }
        iftmp.41 = -D.17752;
        goto <D.18495>;
        <D.18458>:
        iftmp.41 = __builtin_strcmp (arg, "stat");
        <D.18495>:
        D.17753 = iftmp.41;
      }
      if (D.17753 == 0) goto <D.18496>; else goto <D.18497>;
      <D.18496>:
      monoeg_g_string_append (str, ",sample");
      goto <D.18498>;
      <D.18497>:
      {
        size_t __s1_len;
        size_t __s2_len;

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

          __s2 = arg;
          D.18502 = "jit";
          D.18503 = MEM[(const unsigned char *)D.18502];
          D.18504 = (int) D.18503;
          D.18505 = *__s2;
          D.18506 = (int) D.18505;
          __result = D.18504 - D.18506;
          {
            D.18507 = __s2_len != 0;
            D.18508 = __result == 0;
            D.18509 = D.18507 & D.18508;
            if (D.18509 != 0) goto <D.18510>; else goto <D.18511>;
            <D.18510>:
            D.18512 = &MEM[(void *)"jit" + 1B];
            D.18513 = *D.18512;
            D.18514 = (int) D.18513;
            D.18515 = __s2 + 1;
            D.18516 = *D.18515;
            D.18517 = (int) D.18516;
            __result = D.18514 - D.18517;
            D.18518 = __s2_len > 1;
            D.18508 = __result == 0;
            D.18519 = D.18518 & D.18508;
            if (D.18519 != 0) goto <D.18520>; else goto <D.18521>;
            <D.18520>:
            D.18522 = &MEM[(void *)"jit" + 2B];
            D.18523 = *D.18522;
            D.18524 = (int) D.18523;
            D.18525 = __s2 + 2;
            D.18526 = *D.18525;
            D.18527 = (int) D.18526;
            __result = D.18524 - D.18527;
            D.18528 = __s2_len > 2;
            D.18508 = __result == 0;
            D.18529 = D.18528 & D.18508;
            if (D.18529 != 0) goto <D.18530>; else goto <D.18531>;
            <D.18530>:
            D.18532 = &MEM[(void *)"jit" + 3B];
            D.18533 = *D.18532;
            D.18534 = (int) D.18533;
            D.18535 = __s2 + 3;
            D.18536 = *D.18535;
            D.18537 = (int) D.18536;
            __result = D.18534 - D.18537;
            <D.18531>:
            <D.18521>:
            <D.18511>:
          }
          D.17761 = __result;
        }
        iftmp.42 = -D.17761;
        goto <D.18538>;
        <D.18501>:
        iftmp.42 = __builtin_strcmp (arg, "jit");
        <D.18538>:
        D.17762 = iftmp.42;
      }
      if (D.17762 == 0) goto <D.18539>; else goto <D.18540>;
      <D.18539>:
      // predicted unlikely by continue predictor.
      goto <D.17763>;
      <D.18540>:
      D.18541 = strncmp (arg, "file=", 5);
      if (D.18541 == 0) goto <D.18542>; else goto <D.18543>;
      <D.18542>:
      D.18544 = arg + 5;
      monoeg_g_string_append_printf (str, ",output=%s", D.18544);
      goto <D.18545>;
      <D.18543>:
      stderr.43 = stderr;
      fprintf (stderr.43, "profiler : Unknown argument \'%s\'.\n", arg);
      return;
      <D.18545>:
      <D.18498>:
      <D.18455>:
      <D.18412>:
    }
    <D.17763>:
    ptr = ptr + 8;
    <D.17774>:
    if (ptr != 0B) goto <D.18547>; else goto <D.17775>;
    <D.18547>:
    D.18548 = *ptr;
    if (D.18548 != 0B) goto <D.17773>; else goto <D.17775>;
    <D.17775>:
    cdesc = monoeg_g_string_free (str, 0);
    desc = cdesc;
  }
  <D.18368>:
  {
    const char * col;
    char * libname;
    char * mname;
    gboolean res;

    col = __builtin_strchr (desc, 58);
    res = 0;
    if (col != 0B) goto <D.18549>; else goto <D.18550>;
    <D.18549>:
    col.44 = (long int) col;
    desc.45 = (long int) desc;
    D.18553 = col.44 - desc.45;
    D.18554 = (unsigned int) D.18553;
    D.18555 = D.18554 + 1;
    mname = monoeg_g_memdup (desc, D.18555);
    col.44 = (long int) col;
    desc.45 = (long int) desc;
    D.18553 = col.44 - desc.45;
    D.18556 = (sizetype) D.18553;
    D.18557 = mname + D.18556;
    *D.18557 = 0;
    goto <D.18558>;
    <D.18550>:
    mname = monoeg_strdup (desc);
    <D.18558>:
    D.18559 = load_embedded_profiler (desc, mname);
    if (D.18559 == 0) goto <D.18560>; else goto <D.18561>;
    <D.18560>:
    libname = monoeg_g_strdup_printf ("mono-profiler-%s", mname);
    D.18562 = load_profiler_from_directory (0B, libname, desc);
    if (D.18562 == 0) goto <D.18563>; else goto <D.18564>;
    <D.18563>:
    res = 0;
    D.18565 = mono_assembly_getrootdir ();
    res = load_profiler_from_directory (D.18565, libname, desc);
    if (res == 0) goto <D.18566>; else goto <D.18567>;
    <D.18566>:
    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.18567>:
    <D.18564>:
    monoeg_g_free (libname);
    <D.18561>:
    monoeg_g_free (mname);
  }
  monoeg_g_free (cdesc);
}


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

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


load_embedded_profiler (const char * desc, const char * name)
{
  char * err.46;
  gboolean D.18574;
  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.18571>; else goto <D.18572>;
      <D.18571>:
      err.46 = err;
      monoeg_g_log (0B, 16, "Could not open main executable (%s)", err.46);
      err.46 = err;
      monoeg_g_free (err.46);
      D.18574 = 0;
      return D.18574;
      <D.18572>:
      symbol = monoeg_g_strdup_printf ("mono_profiler_startup_%s", name);
      result = load_profiler (pmodule, desc, symbol);
      monoeg_g_free (symbol);
      D.18574 = result;
      return D.18574;
    }
  finally
    {
      err = {CLOBBER};
    }
}


load_profiler (struct MonoDl * pmodule, const char * desc, const char * symbol)
{
  gboolean D.18579;
  void (*<T2d7f>) (const char *) func.47;
  char * err;
  void (*ProfilerInitializer) (const char *) func;

  try
    {
      if (pmodule == 0B) goto <D.18577>; else goto <D.18578>;
      <D.18577>:
      D.18579 = 0;
      return D.18579;
      <D.18578>:
      err = mono_dl_symbol (pmodule, symbol, &func);
      if (err != 0B) goto <D.18580>; else goto <D.18581>;
      <D.18580>:
      monoeg_g_free (err);
      D.18579 = 0;
      return D.18579;
      <D.18581>:
      func.47 = func;
      func.47 (desc);
      D.18579 = 1;
      return D.18579;
    }
  finally
    {
      func = {CLOBBER};
    }
}


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

  try
    {
      pmodule = 0B;
      iter = 0B;
      err = 0B;
      goto <D.17699>;
      <D.17698>:
      pmodule = mono_dl_open (path, 1, &err);
      monoeg_g_free (path);
      err.48 = err;
      monoeg_g_free (err.48);
      if (pmodule != 0B) goto <D.18586>; else goto <D.18587>;
      <D.18586>:
      D.18588 = load_profiler (pmodule, desc, "mono_profiler_startup");
      return D.18588;
      <D.18587>:
      <D.17699>:
      path = mono_dl_build_path (directory, libname, &iter);
      if (path != 0B) goto <D.17698>; else goto <D.17700>;
      <D.17700>:
      D.18588 = 0;
      return D.18588;
    }
  finally
    {
      err = {CLOBBER};
      iter = {CLOBBER};
    }
}