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

  value = 0;
  prof_list.1 = prof_list;
  if (prof_list.1 != 0B) goto <D.18315>; else goto <D.18316>;
  <D.18315>:
  prof_list.1 = prof_list;
  prof_list.1->events = events;
  <D.18316>:
  prof = prof_list;
  goto <D.17733>;
  <D.17732>:
  D.18317 = prof->events;
  value = D.18317 | value;
  prof = prof->next;
  <D.17733>:
  if (prof != 0B) goto <D.17732>; else goto <D.17734>;
  <D.17734>:
  mono_profiler_events = value;
}


mono_profiler_get_events ()
{
  MonoProfileFlags D.18318;

  D.18318 = mono_profiler_events;
  return D.18318;
}


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.18321>; else goto <D.18322>;
  <D.18321>:
  return;
  <D.18322>:
  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.18325>; else goto <D.18326>;
  <D.18325>:
  return;
  <D.18326>:
  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.18329>; else goto <D.18330>;
  <D.18329>:
  return;
  <D.18330>:
  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.18333>; else goto <D.18334>;
  <D.18333>:
  return;
  <D.18334>:
  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.18337>; else goto <D.18338>;
  <D.18337>:
  return;
  <D.18338>:
  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.18341>; else goto <D.18342>;
  <D.18341>:
  return;
  <D.18342>:
  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.18345>; else goto <D.18346>;
  <D.18345>:
  return;
  <D.18346>:
  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.18349>; else goto <D.18350>;
  <D.18349>:
  return;
  <D.18350>:
  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.18353>; else goto <D.18354>;
  <D.18353>:
  return;
  <D.18354>:
  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.18357>; else goto <D.18358>;
  <D.18357>:
  return;
  <D.18358>:
  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.18361>; else goto <D.18362>;
  <D.18361>:
  return;
  <D.18362>:
  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.18365>; else goto <D.18366>;
  <D.18365>:
  return;
  <D.18366>:
  if (call_chain_depth > 128) goto <D.18367>; else goto <D.18368>;
  <D.18367>:
  call_chain_depth = 128;
  <D.18368>:
  if (call_chain_strategy > 3) goto <D.18369>; else goto <D.18370>;
  <D.18369>:
  call_chain_strategy = 0;
  <D.18370>:
  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 (*<Tc6a>) (struct MonoProfiler *, int, mono_byte * *, void *) D.18375;
  int D.18377;

  prof_list.14 = prof_list;
  if (prof_list.14 != 0B) goto <D.18374>; else goto <D.18372>;
  <D.18374>:
  prof_list.14 = prof_list;
  D.18375 = prof_list.14->statistical_call_chain_cb;
  if (D.18375 != 0B) goto <D.18376>; else goto <D.18372>;
  <D.18376>:
  prof_list.14 = prof_list;
  D.18377 = prof_list.14->statistical_call_chain_depth;
  return D.18377;
  <D.18372>:
  D.18377 = 0;
  return D.18377;
}


mono_profiler_stat_get_call_chain_strategy ()
{
  struct ProfilerDesc * prof_list.15;
  void (*<Tc6a>) (struct MonoProfiler *, int, mono_byte * *, void *) D.18382;
  MonoProfilerCallChainStrategy D.18384;

  prof_list.15 = prof_list;
  if (prof_list.15 != 0B) goto <D.18381>; else goto <D.18379>;
  <D.18381>:
  prof_list.15 = prof_list;
  D.18382 = prof_list.15->statistical_call_chain_cb;
  if (D.18382 != 0B) goto <D.18383>; else goto <D.18379>;
  <D.18383>:
  prof_list.15 = prof_list;
  D.18384 = prof_list.15->statistical_call_chain_strategy;
  return D.18384;
  <D.18379>:
  D.18384 = 0;
  return D.18384;
}


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.18387>; else goto <D.18388>;
  <D.18387>:
  return;
  <D.18388>:
  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.18391>; else goto <D.18392>;
  <D.18391>:
  return;
  <D.18392>:
  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.18395>; else goto <D.18396>;
  <D.18395>:
  return;
  <D.18396>:
  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.18399>; else goto <D.18400>;
  <D.18399>:
  return;
  <D.18400>:
  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.18403>; else goto <D.18404>;
  <D.18403>:
  return;
  <D.18404>:
  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.18407>; else goto <D.18408>;
  <D.18407>:
  return;
  <D.18408>:
  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.18410;
  unsigned int D.18411;
  void (*<Tc0e>) (struct MonoProfiler *, struct MonoMethod *) D.18414;
  struct MonoProfiler * D.18417;
  struct ProfilerDesc * prof;

  prof = prof_list;
  goto <D.17823>;
  <D.17822>:
  D.18410 = prof->events;
  D.18411 = D.18410 & 4096;
  if (D.18411 != 0) goto <D.18412>; else goto <D.18413>;
  <D.18412>:
  D.18414 = prof->method_enter;
  if (D.18414 != 0B) goto <D.18415>; else goto <D.18416>;
  <D.18415>:
  D.18414 = prof->method_enter;
  D.18417 = prof->profiler;
  D.18414 (D.18417, method);
  <D.18416>:
  <D.18413>:
  prof = prof->next;
  <D.17823>:
  if (prof != 0B) goto <D.17822>; else goto <D.17824>;
  <D.17824>:
}


mono_profiler_method_leave (struct MonoMethod * method)
{
  <unnamed type> D.18418;
  unsigned int D.18419;
  void (*<Tc0e>) (struct MonoProfiler *, struct MonoMethod *) D.18422;
  struct MonoProfiler * D.18425;
  struct ProfilerDesc * prof;

  prof = prof_list;
  goto <D.17830>;
  <D.17829>:
  D.18418 = prof->events;
  D.18419 = D.18418 & 4096;
  if (D.18419 != 0) goto <D.18420>; else goto <D.18421>;
  <D.18420>:
  D.18422 = prof->method_leave;
  if (D.18422 != 0B) goto <D.18423>; else goto <D.18424>;
  <D.18423>:
  D.18422 = prof->method_leave;
  D.18425 = prof->profiler;
  D.18422 (D.18425, method);
  <D.18424>:
  <D.18421>:
  prof = prof->next;
  <D.17830>:
  if (prof != 0B) goto <D.17829>; else goto <D.17831>;
  <D.17831>:
}


mono_profiler_method_jit (struct MonoMethod * method)
{
  <unnamed type> D.18426;
  unsigned int D.18427;
  void (*<Tc0e>) (struct MonoProfiler *, struct MonoMethod *) D.18430;
  struct MonoProfiler * D.18433;
  struct ProfilerDesc * prof;

  prof = prof_list;
  goto <D.17837>;
  <D.17836>:
  D.18426 = prof->events;
  D.18427 = D.18426 & 16;
  if (D.18427 != 0) goto <D.18428>; else goto <D.18429>;
  <D.18428>:
  D.18430 = prof->jit_start;
  if (D.18430 != 0B) goto <D.18431>; else goto <D.18432>;
  <D.18431>:
  D.18430 = prof->jit_start;
  D.18433 = prof->profiler;
  D.18430 (D.18433, method);
  <D.18432>:
  <D.18429>:
  prof = prof->next;
  <D.17837>:
  if (prof != 0B) goto <D.17836>; else goto <D.17838>;
  <D.17838>:
}


mono_profiler_method_end_jit (struct MonoMethod * method, struct MonoJitInfo * jinfo, int result)
{
  <unnamed type> D.18434;
  unsigned int D.18435;
  void (*<Tc36>) (struct MonoProfiler *, struct MonoMethod *, int) D.18438;
  struct MonoProfiler * D.18441;
  void (*<Tc3b>) (struct MonoProfiler *, struct MonoMethod *, struct MonoJitInfo *, int) D.18442;
  struct ProfilerDesc * prof;

  prof = prof_list;
  goto <D.17846>;
  <D.17845>:
  D.18434 = prof->events;
  D.18435 = D.18434 & 16;
  if (D.18435 != 0) goto <D.18436>; else goto <D.18437>;
  <D.18436>:
  D.18438 = prof->jit_end;
  if (D.18438 != 0B) goto <D.18439>; else goto <D.18440>;
  <D.18439>:
  D.18438 = prof->jit_end;
  D.18441 = prof->profiler;
  D.18438 (D.18441, method, result);
  <D.18440>:
  D.18442 = prof->jit_end2;
  if (D.18442 != 0B) goto <D.18443>; else goto <D.18444>;
  <D.18443>:
  D.18442 = prof->jit_end2;
  D.18441 = prof->profiler;
  D.18442 (D.18441, method, jinfo, result);
  <D.18444>:
  <D.18437>:
  prof = prof->next;
  <D.17846>:
  if (prof != 0B) goto <D.17845>; else goto <D.17847>;
  <D.17847>:
}


mono_profiler_method_free (struct MonoMethod * method)
{
  <unnamed type> D.18445;
  unsigned int D.18446;
  void (*<Tc0e>) (struct MonoProfiler *, struct MonoMethod *) D.18449;
  struct MonoProfiler * D.18452;
  struct ProfilerDesc * prof;

  prof = prof_list;
  goto <D.17853>;
  <D.17852>:
  D.18445 = prof->events;
  D.18446 = D.18445 & 65536;
  if (D.18446 != 0) goto <D.18447>; else goto <D.18448>;
  <D.18447>:
  D.18449 = prof->method_free;
  if (D.18449 != 0B) goto <D.18450>; else goto <D.18451>;
  <D.18450>:
  D.18449 = prof->method_free;
  D.18452 = prof->profiler;
  D.18449 (D.18452, method);
  <D.18451>:
  <D.18448>:
  prof = prof->next;
  <D.17853>:
  if (prof != 0B) goto <D.17852>; else goto <D.17854>;
  <D.17854>:
}


mono_profiler_method_start_invoke (struct MonoMethod * method)
{
  <unnamed type> D.18453;
  unsigned int D.18454;
  void (*<Tc0e>) (struct MonoProfiler *, struct MonoMethod *) D.18457;
  struct MonoProfiler * D.18460;
  struct ProfilerDesc * prof;

  prof = prof_list;
  goto <D.17860>;
  <D.17859>:
  D.18453 = prof->events;
  D.18454 = D.18453 & 65536;
  if (D.18454 != 0) goto <D.18455>; else goto <D.18456>;
  <D.18455>:
  D.18457 = prof->method_start_invoke;
  if (D.18457 != 0B) goto <D.18458>; else goto <D.18459>;
  <D.18458>:
  D.18457 = prof->method_start_invoke;
  D.18460 = prof->profiler;
  D.18457 (D.18460, method);
  <D.18459>:
  <D.18456>:
  prof = prof->next;
  <D.17860>:
  if (prof != 0B) goto <D.17859>; else goto <D.17861>;
  <D.17861>:
}


mono_profiler_method_end_invoke (struct MonoMethod * method)
{
  <unnamed type> D.18461;
  unsigned int D.18462;
  void (*<Tc0e>) (struct MonoProfiler *, struct MonoMethod *) D.18465;
  struct MonoProfiler * D.18468;
  struct ProfilerDesc * prof;

  prof = prof_list;
  goto <D.17867>;
  <D.17866>:
  D.18461 = prof->events;
  D.18462 = D.18461 & 65536;
  if (D.18462 != 0) goto <D.18463>; else goto <D.18464>;
  <D.18463>:
  D.18465 = prof->method_end_invoke;
  if (D.18465 != 0B) goto <D.18466>; else goto <D.18467>;
  <D.18466>:
  D.18465 = prof->method_end_invoke;
  D.18468 = prof->profiler;
  D.18465 (D.18468, method);
  <D.18467>:
  <D.18464>:
  prof = prof->next;
  <D.17867>:
  if (prof != 0B) goto <D.17866>; else goto <D.17868>;
  <D.17868>:
}


mono_profiler_code_transition (struct MonoMethod * method, int result)
{
  <unnamed type> D.18469;
  unsigned int D.18470;
  void (*<Tc36>) (struct MonoProfiler *, struct MonoMethod *, int) D.18473;
  struct MonoProfiler * D.18476;
  struct ProfilerDesc * prof;

  prof = prof_list;
  goto <D.17875>;
  <D.17874>:
  D.18469 = prof->events;
  D.18470 = D.18469 & 2048;
  if (D.18470 != 0) goto <D.18471>; else goto <D.18472>;
  <D.18471>:
  D.18473 = prof->man_unman_transition;
  if (D.18473 != 0B) goto <D.18474>; else goto <D.18475>;
  <D.18474>:
  D.18473 = prof->man_unman_transition;
  D.18476 = prof->profiler;
  D.18473 (D.18476, method, result);
  <D.18475>:
  <D.18472>:
  prof = prof->next;
  <D.17875>:
  if (prof != 0B) goto <D.17874>; else goto <D.17876>;
  <D.17876>:
}


mono_profiler_allocation (struct MonoObject * obj, struct MonoClass * klass)
{
  <unnamed type> D.18477;
  unsigned int D.18478;
  void (*<Tc5e>) (struct MonoProfiler *, struct MonoObject *, struct MonoClass *) D.18481;
  struct MonoProfiler * D.18484;
  struct ProfilerDesc * prof;

  prof = prof_list;
  goto <D.17883>;
  <D.17882>:
  D.18477 = prof->events;
  D.18478 = D.18477 & 128;
  if (D.18478 != 0) goto <D.18479>; else goto <D.18480>;
  <D.18479>:
  D.18481 = prof->allocation_cb;
  if (D.18481 != 0B) goto <D.18482>; else goto <D.18483>;
  <D.18482>:
  D.18481 = prof->allocation_cb;
  D.18484 = prof->profiler;
  D.18481 (D.18484, obj, klass);
  <D.18483>:
  <D.18480>:
  prof = prof->next;
  <D.17883>:
  if (prof != 0B) goto <D.17882>; else goto <D.17884>;
  <D.17884>:
}


mono_profiler_monitor_event (struct MonoObject * obj, MonoProfilerMonitorEvent event)
{
  <unnamed type> D.18485;
  unsigned int D.18486;
  void (*<Tc22>) (struct MonoProfiler *, struct MonoObject *, MonoProfilerMonitorEvent) D.18489;
  struct MonoProfiler * D.18492;
  struct ProfilerDesc * prof;

  prof = prof_list;
  goto <D.17891>;
  <D.17890>:
  D.18485 = prof->events;
  D.18486 = D.18485 & 131072;
  if (D.18486 != 0) goto <D.18487>; else goto <D.18488>;
  <D.18487>:
  D.18489 = prof->monitor_event_cb;
  if (D.18489 != 0B) goto <D.18490>; else goto <D.18491>;
  <D.18490>:
  D.18489 = prof->monitor_event_cb;
  D.18492 = prof->profiler;
  D.18489 (D.18492, obj, event);
  <D.18491>:
  <D.18488>:
  prof = prof->next;
  <D.17891>:
  if (prof != 0B) goto <D.17890>; else goto <D.17892>;
  <D.17892>:
}


mono_profiler_stat_hit (guchar * ip, void * context)
{
  <unnamed type> D.18493;
  unsigned int D.18494;
  void (*<Tc64>) (struct MonoProfiler *, mono_byte *, void *) D.18497;
  struct MonoProfiler * D.18500;
  struct ProfilerDesc * prof;

  prof = prof_list;
  goto <D.17899>;
  <D.17898>:
  D.18493 = prof->events;
  D.18494 = D.18493 & 32768;
  if (D.18494 != 0) goto <D.18495>; else goto <D.18496>;
  <D.18495>:
  D.18497 = prof->statistical_cb;
  if (D.18497 != 0B) goto <D.18498>; else goto <D.18499>;
  <D.18498>:
  D.18497 = prof->statistical_cb;
  D.18500 = prof->profiler;
  D.18497 (D.18500, ip, context);
  <D.18499>:
  <D.18496>:
  prof = prof->next;
  <D.17899>:
  if (prof != 0B) goto <D.17898>; else goto <D.17900>;
  <D.17900>:
}


mono_profiler_stat_call_chain (int call_chain_depth, guchar * * ips, void * context)
{
  <unnamed type> D.18501;
  unsigned int D.18502;
  void (*<Tc6a>) (struct MonoProfiler *, int, mono_byte * *, void *) D.18505;
  struct MonoProfiler * D.18508;
  struct ProfilerDesc * prof;

  prof = prof_list;
  goto <D.17908>;
  <D.17907>:
  D.18501 = prof->events;
  D.18502 = D.18501 & 32768;
  if (D.18502 != 0) goto <D.18503>; else goto <D.18504>;
  <D.18503>:
  D.18505 = prof->statistical_call_chain_cb;
  if (D.18505 != 0B) goto <D.18506>; else goto <D.18507>;
  <D.18506>:
  D.18505 = prof->statistical_call_chain_cb;
  D.18508 = prof->profiler;
  D.18505 (D.18508, call_chain_depth, ips, context);
  <D.18507>:
  <D.18504>:
  prof = prof->next;
  <D.17908>:
  if (prof != 0B) goto <D.17907>; else goto <D.17909>;
  <D.17909>:
}


mono_profiler_exception_thrown (struct MonoObject * exception)
{
  <unnamed type> D.18509;
  unsigned int D.18510;
  void (*<Tc27>) (struct MonoProfiler *, struct MonoObject *) D.18513;
  struct MonoProfiler * D.18516;
  struct ProfilerDesc * prof;

  prof = prof_list;
  goto <D.17915>;
  <D.17914>:
  D.18509 = prof->events;
  D.18510 = D.18509 & 64;
  if (D.18510 != 0) goto <D.18511>; else goto <D.18512>;
  <D.18511>:
  D.18513 = prof->exception_throw_cb;
  if (D.18513 != 0B) goto <D.18514>; else goto <D.18515>;
  <D.18514>:
  D.18513 = prof->exception_throw_cb;
  D.18516 = prof->profiler;
  D.18513 (D.18516, exception);
  <D.18515>:
  <D.18512>:
  prof = prof->next;
  <D.17915>:
  if (prof != 0B) goto <D.17914>; else goto <D.17916>;
  <D.17916>:
}


mono_profiler_exception_method_leave (struct MonoMethod * method)
{
  <unnamed type> D.18517;
  unsigned int D.18518;
  void (*<Tc0e>) (struct MonoProfiler *, struct MonoMethod *) D.18521;
  struct MonoProfiler * D.18524;
  struct ProfilerDesc * prof;

  prof = prof_list;
  goto <D.17922>;
  <D.17921>:
  D.18517 = prof->events;
  D.18518 = D.18517 & 64;
  if (D.18518 != 0) goto <D.18519>; else goto <D.18520>;
  <D.18519>:
  D.18521 = prof->exception_method_leave_cb;
  if (D.18521 != 0B) goto <D.18522>; else goto <D.18523>;
  <D.18522>:
  D.18521 = prof->exception_method_leave_cb;
  D.18524 = prof->profiler;
  D.18521 (D.18524, method);
  <D.18523>:
  <D.18520>:
  prof = prof->next;
  <D.17922>:
  if (prof != 0B) goto <D.17921>; else goto <D.17923>;
  <D.17923>:
}


mono_profiler_exception_clause_handler (struct MonoMethod * method, int clause_type, int clause_num)
{
  <unnamed type> D.18525;
  unsigned int D.18526;
  void (*<Tc2c>) (struct MonoProfiler *, struct MonoMethod *, int, int) D.18529;
  struct MonoProfiler * D.18532;
  struct ProfilerDesc * prof;

  prof = prof_list;
  goto <D.17931>;
  <D.17930>:
  D.18525 = prof->events;
  D.18526 = D.18525 & 64;
  if (D.18526 != 0) goto <D.18527>; else goto <D.18528>;
  <D.18527>:
  D.18529 = prof->exception_clause_cb;
  if (D.18529 != 0B) goto <D.18530>; else goto <D.18531>;
  <D.18530>:
  D.18529 = prof->exception_clause_cb;
  D.18532 = prof->profiler;
  D.18529 (D.18532, method, clause_type, clause_num);
  <D.18531>:
  <D.18528>:
  prof = prof->next;
  <D.17931>:
  if (prof != 0B) goto <D.17930>; else goto <D.17932>;
  <D.17932>:
}


mono_profiler_thread_start (gsize tid)
{
  <unnamed type> D.18533;
  unsigned int D.18534;
  void (*<Tc54>) (struct MonoProfiler *, uintptr_t) D.18537;
  struct MonoProfiler * D.18540;
  struct ProfilerDesc * prof;

  prof = prof_list;
  goto <D.17938>;
  <D.17937>:
  D.18533 = prof->events;
  D.18534 = D.18533 & 512;
  if (D.18534 != 0) goto <D.18535>; else goto <D.18536>;
  <D.18535>:
  D.18537 = prof->thread_start;
  if (D.18537 != 0B) goto <D.18538>; else goto <D.18539>;
  <D.18538>:
  D.18537 = prof->thread_start;
  D.18540 = prof->profiler;
  D.18537 (D.18540, tid);
  <D.18539>:
  <D.18536>:
  prof = prof->next;
  <D.17938>:
  if (prof != 0B) goto <D.17937>; else goto <D.17939>;
  <D.17939>:
}


mono_profiler_thread_end (gsize tid)
{
  <unnamed type> D.18541;
  unsigned int D.18542;
  void (*<Tc54>) (struct MonoProfiler *, uintptr_t) D.18545;
  struct MonoProfiler * D.18548;
  struct ProfilerDesc * prof;

  prof = prof_list;
  goto <D.17945>;
  <D.17944>:
  D.18541 = prof->events;
  D.18542 = D.18541 & 512;
  if (D.18542 != 0) goto <D.18543>; else goto <D.18544>;
  <D.18543>:
  D.18545 = prof->thread_end;
  if (D.18545 != 0B) goto <D.18546>; else goto <D.18547>;
  <D.18546>:
  D.18545 = prof->thread_end;
  D.18548 = prof->profiler;
  D.18545 (D.18548, tid);
  <D.18547>:
  <D.18544>:
  prof = prof->next;
  <D.17945>:
  if (prof != 0B) goto <D.17944>; else goto <D.17946>;
  <D.17946>:
}


mono_profiler_thread_name (gsize tid, const char * name)
{
  <unnamed type> D.18549;
  unsigned int D.18550;
  void (*<Tc59>) (struct MonoProfiler *, uintptr_t, const char *) D.18553;
  struct MonoProfiler * D.18556;
  struct ProfilerDesc * prof;

  prof = prof_list;
  goto <D.17953>;
  <D.17952>:
  D.18549 = prof->events;
  D.18550 = D.18549 & 512;
  if (D.18550 != 0) goto <D.18551>; else goto <D.18552>;
  <D.18551>:
  D.18553 = prof->thread_name;
  if (D.18553 != 0B) goto <D.18554>; else goto <D.18555>;
  <D.18554>:
  D.18553 = prof->thread_name;
  D.18556 = prof->profiler;
  D.18553 (D.18556, tid, name);
  <D.18555>:
  <D.18552>:
  prof = prof->next;
  <D.17953>:
  if (prof != 0B) goto <D.17952>; else goto <D.17954>;
  <D.17954>:
}


mono_profiler_assembly_event (struct MonoAssembly * assembly, int code)
{
  <unnamed type> D.18557;
  unsigned int D.18558;
  void (*<Tc1d>) (struct MonoProfiler *, struct MonoAssembly *) D.18561;
  struct MonoProfiler * D.18564;
  void (*<Tc1d>) (struct MonoProfiler *, struct MonoAssembly *) D.18565;
  void (*<Tc1d>) (struct MonoProfiler *, struct MonoAssembly *) D.18568;
  struct ProfilerDesc * prof;

  prof = prof_list;
  goto <D.17967>;
  <D.17966>:
  D.18557 = prof->events;
  D.18558 = D.18557 & 2;
  if (D.18558 == 0) goto <D.18559>; else goto <D.18560>;
  <D.18559>:
  // predicted unlikely by continue predictor.
  goto <D.17960>;
  <D.18560>:
  switch (code) <default: <D.17965>, case 0: <D.17961>, case 2: <D.17963>, case 3: <D.17964>>
  <D.17961>:
  D.18561 = prof->assembly_start_load;
  if (D.18561 != 0B) goto <D.18562>; else goto <D.18563>;
  <D.18562>:
  D.18561 = prof->assembly_start_load;
  D.18564 = prof->profiler;
  D.18561 (D.18564, assembly);
  <D.18563>:
  goto <D.17962>;
  <D.17963>:
  D.18565 = prof->assembly_start_unload;
  if (D.18565 != 0B) goto <D.18566>; else goto <D.18567>;
  <D.18566>:
  D.18565 = prof->assembly_start_unload;
  D.18564 = prof->profiler;
  D.18565 (D.18564, assembly);
  <D.18567>:
  goto <D.17962>;
  <D.17964>:
  D.18568 = prof->assembly_end_unload;
  if (D.18568 != 0B) goto <D.18569>; else goto <D.18570>;
  <D.18569>:
  D.18568 = prof->assembly_end_unload;
  D.18564 = prof->profiler;
  D.18568 (D.18564, assembly);
  <D.18570>:
  goto <D.17962>;
  <D.17965>:
  monoeg_assertion_message ("* Assertion: should not be reached at %s:%d\n", "profiler.c", 588);
  <D.17962>:
  <D.17960>:
  prof = prof->next;
  <D.17967>:
  if (prof != 0B) goto <D.17966>; else goto <D.17968>;
  <D.17968>:
}


mono_profiler_assembly_loaded (struct MonoAssembly * assembly, int result)
{
  <unnamed type> D.18571;
  unsigned int D.18572;
  void (*<Tc4a>) (struct MonoProfiler *, struct MonoAssembly *, int) D.18575;
  struct MonoProfiler * D.18578;
  struct ProfilerDesc * prof;

  prof = prof_list;
  goto <D.17975>;
  <D.17974>:
  D.18571 = prof->events;
  D.18572 = D.18571 & 2;
  if (D.18572 != 0) goto <D.18573>; else goto <D.18574>;
  <D.18573>:
  D.18575 = prof->assembly_end_load;
  if (D.18575 != 0B) goto <D.18576>; else goto <D.18577>;
  <D.18576>:
  D.18575 = prof->assembly_end_load;
  D.18578 = prof->profiler;
  D.18575 (D.18578, assembly, result);
  <D.18577>:
  <D.18574>:
  prof = prof->next;
  <D.17975>:
  if (prof != 0B) goto <D.17974>; else goto <D.17976>;
  <D.17976>:
}


mono_profiler_iomap (char * report, const char * pathname, const char * new_pathname)
{
  <unnamed type> D.18579;
  unsigned int D.18580;
  void (*<Tc88>) (struct MonoProfiler *, const char *, const char *, const char *) D.18583;
  struct MonoProfiler * D.18586;
  struct ProfilerDesc * prof;

  prof = prof_list;
  goto <D.17984>;
  <D.17983>:
  D.18579 = prof->events;
  D.18580 = D.18579 & 262144;
  if (D.18580 != 0) goto <D.18581>; else goto <D.18582>;
  <D.18581>:
  D.18583 = prof->iomap_cb;
  if (D.18583 != 0B) goto <D.18584>; else goto <D.18585>;
  <D.18584>:
  D.18583 = prof->iomap_cb;
  D.18586 = prof->profiler;
  D.18583 (D.18586, report, pathname, new_pathname);
  <D.18585>:
  <D.18582>:
  prof = prof->next;
  <D.17984>:
  if (prof != 0B) goto <D.17983>; else goto <D.17985>;
  <D.17985>:
}


mono_profiler_module_event (struct MonoImage * module, int code)
{
  <unnamed type> D.18587;
  unsigned int D.18588;
  void (*<Tc18>) (struct MonoProfiler *, struct MonoImage *) D.18591;
  struct MonoProfiler * D.18594;
  void (*<Tc18>) (struct MonoProfiler *, struct MonoImage *) D.18595;
  void (*<Tc18>) (struct MonoProfiler *, struct MonoImage *) D.18598;
  struct ProfilerDesc * prof;

  prof = prof_list;
  goto <D.17998>;
  <D.17997>:
  D.18587 = prof->events;
  D.18588 = D.18587 & 4;
  if (D.18588 == 0) goto <D.18589>; else goto <D.18590>;
  <D.18589>:
  // predicted unlikely by continue predictor.
  goto <D.17991>;
  <D.18590>:
  switch (code) <default: <D.17996>, case 0: <D.17992>, case 2: <D.17994>, case 3: <D.17995>>
  <D.17992>:
  D.18591 = prof->module_start_load;
  if (D.18591 != 0B) goto <D.18592>; else goto <D.18593>;
  <D.18592>:
  D.18591 = prof->module_start_load;
  D.18594 = prof->profiler;
  D.18591 (D.18594, module);
  <D.18593>:
  goto <D.17993>;
  <D.17994>:
  D.18595 = prof->module_start_unload;
  if (D.18595 != 0B) goto <D.18596>; else goto <D.18597>;
  <D.18596>:
  D.18595 = prof->module_start_unload;
  D.18594 = prof->profiler;
  D.18595 (D.18594, module);
  <D.18597>:
  goto <D.17993>;
  <D.17995>:
  D.18598 = prof->module_end_unload;
  if (D.18598 != 0B) goto <D.18599>; else goto <D.18600>;
  <D.18599>:
  D.18598 = prof->module_end_unload;
  D.18594 = prof->profiler;
  D.18598 (D.18594, module);
  <D.18600>:
  goto <D.17993>;
  <D.17996>:
  monoeg_assertion_message ("* Assertion: should not be reached at %s:%d\n", "profiler.c", 634);
  <D.17993>:
  <D.17991>:
  prof = prof->next;
  <D.17998>:
  if (prof != 0B) goto <D.17997>; else goto <D.17999>;
  <D.17999>:
}


mono_profiler_module_loaded (struct MonoImage * module, int result)
{
  <unnamed type> D.18601;
  unsigned int D.18602;
  void (*<Tc45>) (struct MonoProfiler *, struct MonoImage *, int) D.18605;
  struct MonoProfiler * D.18608;
  struct ProfilerDesc * prof;

  prof = prof_list;
  goto <D.18006>;
  <D.18005>:
  D.18601 = prof->events;
  D.18602 = D.18601 & 4;
  if (D.18602 != 0) goto <D.18603>; else goto <D.18604>;
  <D.18603>:
  D.18605 = prof->module_end_load;
  if (D.18605 != 0B) goto <D.18606>; else goto <D.18607>;
  <D.18606>:
  D.18605 = prof->module_end_load;
  D.18608 = prof->profiler;
  D.18605 (D.18608, module, result);
  <D.18607>:
  <D.18604>:
  prof = prof->next;
  <D.18006>:
  if (prof != 0B) goto <D.18005>; else goto <D.18007>;
  <D.18007>:
}


mono_profiler_class_event (struct MonoClass * klass, int code)
{
  <unnamed type> D.18609;
  unsigned int D.18610;
  void (*<Tc13>) (struct MonoProfiler *, struct MonoClass *) D.18613;
  struct MonoProfiler * D.18616;
  void (*<Tc13>) (struct MonoProfiler *, struct MonoClass *) D.18617;
  void (*<Tc13>) (struct MonoProfiler *, struct MonoClass *) D.18620;
  struct ProfilerDesc * prof;

  prof = prof_list;
  goto <D.18020>;
  <D.18019>:
  D.18609 = prof->events;
  D.18610 = D.18609 & 8;
  if (D.18610 == 0) goto <D.18611>; else goto <D.18612>;
  <D.18611>:
  // predicted unlikely by continue predictor.
  goto <D.18013>;
  <D.18612>:
  switch (code) <default: <D.18018>, case 0: <D.18014>, case 2: <D.18016>, case 3: <D.18017>>
  <D.18014>:
  D.18613 = prof->class_start_load;
  if (D.18613 != 0B) goto <D.18614>; else goto <D.18615>;
  <D.18614>:
  D.18613 = prof->class_start_load;
  D.18616 = prof->profiler;
  D.18613 (D.18616, klass);
  <D.18615>:
  goto <D.18015>;
  <D.18016>:
  D.18617 = prof->class_start_unload;
  if (D.18617 != 0B) goto <D.18618>; else goto <D.18619>;
  <D.18618>:
  D.18617 = prof->class_start_unload;
  D.18616 = prof->profiler;
  D.18617 (D.18616, klass);
  <D.18619>:
  goto <D.18015>;
  <D.18017>:
  D.18620 = prof->class_end_unload;
  if (D.18620 != 0B) goto <D.18621>; else goto <D.18622>;
  <D.18621>:
  D.18620 = prof->class_end_unload;
  D.18616 = prof->profiler;
  D.18620 (D.18616, klass);
  <D.18622>:
  goto <D.18015>;
  <D.18018>:
  monoeg_assertion_message ("* Assertion: should not be reached at %s:%d\n", "profiler.c", 671);
  <D.18015>:
  <D.18013>:
  prof = prof->next;
  <D.18020>:
  if (prof != 0B) goto <D.18019>; else goto <D.18021>;
  <D.18021>:
}


mono_profiler_class_loaded (struct MonoClass * klass, int result)
{
  <unnamed type> D.18623;
  unsigned int D.18624;
  void (*<Tc40>) (struct MonoProfiler *, struct MonoClass *, int) D.18627;
  struct MonoProfiler * D.18630;
  struct ProfilerDesc * prof;

  prof = prof_list;
  goto <D.18028>;
  <D.18027>:
  D.18623 = prof->events;
  D.18624 = D.18623 & 8;
  if (D.18624 != 0) goto <D.18625>; else goto <D.18626>;
  <D.18625>:
  D.18627 = prof->class_end_load;
  if (D.18627 != 0B) goto <D.18628>; else goto <D.18629>;
  <D.18628>:
  D.18627 = prof->class_end_load;
  D.18630 = prof->profiler;
  D.18627 (D.18630, klass, result);
  <D.18629>:
  <D.18626>:
  prof = prof->next;
  <D.18028>:
  if (prof != 0B) goto <D.18027>; else goto <D.18029>;
  <D.18029>:
}


mono_profiler_appdomain_event (struct MonoDomain * domain, int code)
{
  <unnamed type> D.18631;
  unsigned int D.18632;
  void (*<Tc09>) (struct MonoProfiler *, struct MonoDomain *) D.18635;
  struct MonoProfiler * D.18638;
  void (*<Tc09>) (struct MonoProfiler *, struct MonoDomain *) D.18639;
  void (*<Tc09>) (struct MonoProfiler *, struct MonoDomain *) D.18642;
  struct ProfilerDesc * prof;

  prof = prof_list;
  goto <D.18042>;
  <D.18041>:
  D.18631 = prof->events;
  D.18632 = D.18631 & 1;
  if (D.18632 == 0) goto <D.18633>; else goto <D.18634>;
  <D.18633>:
  // predicted unlikely by continue predictor.
  goto <D.18035>;
  <D.18634>:
  switch (code) <default: <D.18040>, case 0: <D.18036>, case 2: <D.18038>, case 3: <D.18039>>
  <D.18036>:
  D.18635 = prof->domain_start_load;
  if (D.18635 != 0B) goto <D.18636>; else goto <D.18637>;
  <D.18636>:
  D.18635 = prof->domain_start_load;
  D.18638 = prof->profiler;
  D.18635 (D.18638, domain);
  <D.18637>:
  goto <D.18037>;
  <D.18038>:
  D.18639 = prof->domain_start_unload;
  if (D.18639 != 0B) goto <D.18640>; else goto <D.18641>;
  <D.18640>:
  D.18639 = prof->domain_start_unload;
  D.18638 = prof->profiler;
  D.18639 (D.18638, domain);
  <D.18641>:
  goto <D.18037>;
  <D.18039>:
  D.18642 = prof->domain_end_unload;
  if (D.18642 != 0B) goto <D.18643>; else goto <D.18644>;
  <D.18643>:
  D.18642 = prof->domain_end_unload;
  D.18638 = prof->profiler;
  D.18642 (D.18638, domain);
  <D.18644>:
  goto <D.18037>;
  <D.18040>:
  monoeg_assertion_message ("* Assertion: should not be reached at %s:%d\n", "profiler.c", 708);
  <D.18037>:
  <D.18035>:
  prof = prof->next;
  <D.18042>:
  if (prof != 0B) goto <D.18041>; else goto <D.18043>;
  <D.18043>:
}


mono_profiler_appdomain_loaded (struct MonoDomain * domain, int result)
{
  <unnamed type> D.18645;
  unsigned int D.18646;
  void (*<Tc31>) (struct MonoProfiler *, struct MonoDomain *, int) D.18649;
  struct MonoProfiler * D.18652;
  struct ProfilerDesc * prof;

  prof = prof_list;
  goto <D.18050>;
  <D.18049>:
  D.18645 = prof->events;
  D.18646 = D.18645 & 1;
  if (D.18646 != 0) goto <D.18647>; else goto <D.18648>;
  <D.18647>:
  D.18649 = prof->domain_end_load;
  if (D.18649 != 0B) goto <D.18650>; else goto <D.18651>;
  <D.18650>:
  D.18649 = prof->domain_end_load;
  D.18652 = prof->profiler;
  D.18649 (D.18652, domain, result);
  <D.18651>:
  <D.18648>:
  prof = prof->next;
  <D.18050>:
  if (prof != 0B) goto <D.18049>; else goto <D.18051>;
  <D.18051>:
}


mono_profiler_shutdown ()
{
  void (*<Tc04>) (struct MonoProfiler *) D.18653;
  struct MonoProfiler * D.18656;
  struct ProfilerDesc * prof;

  prof = prof_list;
  goto <D.18057>;
  <D.18056>:
  D.18653 = prof->shutdown_callback;
  if (D.18653 != 0B) goto <D.18654>; else goto <D.18655>;
  <D.18654>:
  D.18653 = prof->shutdown_callback;
  D.18656 = prof->profiler;
  D.18653 (D.18656);
  <D.18655>:
  prof = prof->next;
  <D.18057>:
  if (prof != 0B) goto <D.18056>; else goto <D.18058>;
  <D.18058>:
  mono_profiler_set_events (0);
}


mono_profiler_gc_heap_resize (gint64 new_size)
{
  <unnamed type> D.18657;
  unsigned int D.18658;
  void (*<Tc79>) (struct MonoProfiler *, int64_t) D.18661;
  struct MonoProfiler * D.18664;
  struct ProfilerDesc * prof;

  prof = prof_list;
  goto <D.18064>;
  <D.18063>:
  D.18657 = prof->events;
  D.18658 = D.18657 & 256;
  if (D.18658 != 0) goto <D.18659>; else goto <D.18660>;
  <D.18659>:
  D.18661 = prof->gc_heap_resize;
  if (D.18661 != 0B) goto <D.18662>; else goto <D.18663>;
  <D.18662>:
  D.18661 = prof->gc_heap_resize;
  D.18664 = prof->profiler;
  D.18661 (D.18664, new_size);
  <D.18663>:
  <D.18660>:
  prof = prof->next;
  <D.18064>:
  if (prof != 0B) goto <D.18063>; else goto <D.18065>;
  <D.18065>:
}


mono_profiler_gc_event (MonoGCEvent event, int generation)
{
  <unnamed type> D.18665;
  unsigned int D.18666;
  void (*<Tc6f>) (struct MonoProfiler *, MonoGCEvent, int) D.18669;
  struct MonoProfiler * D.18672;
  struct ProfilerDesc * prof;

  prof = prof_list;
  goto <D.18072>;
  <D.18071>:
  D.18665 = prof->events;
  D.18666 = D.18665 & 256;
  if (D.18666 != 0) goto <D.18667>; else goto <D.18668>;
  <D.18667>:
  D.18669 = prof->gc_event;
  if (D.18669 != 0B) goto <D.18670>; else goto <D.18671>;
  <D.18670>:
  D.18669 = prof->gc_event;
  D.18672 = prof->profiler;
  D.18669 (D.18672, event, generation);
  <D.18671>:
  <D.18668>:
  prof = prof->next;
  <D.18072>:
  if (prof != 0B) goto <D.18071>; else goto <D.18073>;
  <D.18073>:
}


mono_profiler_gc_moves (void * * objects, int num)
{
  <unnamed type> D.18673;
  unsigned int D.18674;
  void (*<Tc74>) (struct MonoProfiler *, void * *, int) D.18677;
  struct MonoProfiler * D.18680;
  struct ProfilerDesc * prof;

  prof = prof_list;
  goto <D.18080>;
  <D.18079>:
  D.18673 = prof->events;
  D.18674 = D.18673 & 524288;
  if (D.18674 != 0) goto <D.18675>; else goto <D.18676>;
  <D.18675>:
  D.18677 = prof->gc_moves;
  if (D.18677 != 0B) goto <D.18678>; else goto <D.18679>;
  <D.18678>:
  D.18677 = prof->gc_moves;
  D.18680 = prof->profiler;
  D.18677 (D.18680, objects, num);
  <D.18679>:
  <D.18676>:
  prof = prof->next;
  <D.18080>:
  if (prof != 0B) goto <D.18079>; else goto <D.18081>;
  <D.18081>:
}


mono_profiler_gc_handle (int op, int type, uintptr_t handle, struct MonoObject * obj)
{
  <unnamed type> D.18681;
  unsigned int D.18682;
  void (*<Tc7e>) (struct MonoProfiler *, int, int, uintptr_t, struct MonoObject *) D.18685;
  struct MonoProfiler * D.18688;
  struct ProfilerDesc * prof;

  prof = prof_list;
  goto <D.18090>;
  <D.18089>:
  D.18681 = prof->events;
  D.18682 = D.18681 & 1048576;
  if (D.18682 != 0) goto <D.18683>; else goto <D.18684>;
  <D.18683>:
  D.18685 = prof->gc_handle;
  if (D.18685 != 0B) goto <D.18686>; else goto <D.18687>;
  <D.18686>:
  D.18685 = prof->gc_handle;
  D.18688 = prof->profiler;
  D.18685 (D.18688, op, type, handle, obj);
  <D.18687>:
  <D.18684>:
  prof = prof->next;
  <D.18090>:
  if (prof != 0B) goto <D.18089>; else goto <D.18091>;
  <D.18091>:
}


mono_profiler_gc_roots (int num, void * * objects, int * root_types, uintptr_t * extra_info)
{
  <unnamed type> D.18689;
  unsigned int D.18690;
  void (*<Tc83>) (struct MonoProfiler *, int, void * *, int *, uintptr_t *) D.18693;
  struct MonoProfiler * D.18696;
  struct ProfilerDesc * prof;

  prof = prof_list;
  goto <D.18100>;
  <D.18099>:
  D.18689 = prof->events;
  D.18690 = D.18689 & 1048576;
  if (D.18690 != 0) goto <D.18691>; else goto <D.18692>;
  <D.18691>:
  D.18693 = prof->gc_roots;
  if (D.18693 != 0B) goto <D.18694>; else goto <D.18695>;
  <D.18694>:
  D.18693 = prof->gc_roots;
  D.18696 = prof->profiler;
  D.18693 (D.18696, num, objects, root_types, extra_info);
  <D.18695>:
  <D.18692>:
  prof = prof->next;
  <D.18100>:
  if (prof != 0B) goto <D.18099>; else goto <D.18101>;
  <D.18101>:
}


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.18698>; else goto <D.18699>;
  <D.18698>:
  return;
  <D.18699>:
  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.18702>; else goto <D.18703>;
  <D.18702>:
  return;
  <D.18703>:
  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.18706>; else goto <D.18707>;
  <D.18706>:
  return;
  <D.18707>:
  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.18710>; else goto <D.18711>;
  <D.18710>:
  return;
  <D.18711>:
  prof_list.25 = prof_list;
  prof_list.25->runtime_initialized_event = runtime_initialized_callback;
}


mono_profiler_runtime_initialized ()
{
  void (*<Tc04>) (struct MonoProfiler *) D.18713;
  struct MonoProfiler * D.18716;
  struct ProfilerDesc * prof;

  prof = prof_list;
  goto <D.18121>;
  <D.18120>:
  D.18713 = prof->runtime_initialized_event;
  if (D.18713 != 0B) goto <D.18714>; else goto <D.18715>;
  <D.18714>:
  D.18713 = prof->runtime_initialized_event;
  D.18716 = prof->profiler;
  D.18713 (D.18716);
  <D.18715>:
  prof = prof->next;
  <D.18121>:
  if (prof != 0B) goto <D.18120>; else goto <D.18122>;
  <D.18122>:
}


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


mono_profiler_code_chunk_new (void * chunk, int size)
{
  void (*<Tc9b>) (struct MonoProfiler *, void *, int) D.18721;
  struct MonoProfiler * D.18724;
  struct ProfilerDesc * prof;

  prof = prof_list;
  goto <D.18132>;
  <D.18131>:
  D.18721 = prof->code_chunk_new;
  if (D.18721 != 0B) goto <D.18722>; else goto <D.18723>;
  <D.18722>:
  D.18721 = prof->code_chunk_new;
  D.18724 = prof->profiler;
  D.18721 (D.18724, chunk, size);
  <D.18723>:
  prof = prof->next;
  <D.18132>:
  if (prof != 0B) goto <D.18131>; else goto <D.18133>;
  <D.18133>:
}


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


mono_profiler_code_chunk_destroy (void * chunk)
{
  void (*<Tca0>) (struct MonoProfiler *, void *) D.18729;
  struct MonoProfiler * D.18732;
  struct ProfilerDesc * prof;

  prof = prof_list;
  goto <D.18142>;
  <D.18141>:
  D.18729 = prof->code_chunk_destroy;
  if (D.18729 != 0B) goto <D.18730>; else goto <D.18731>;
  <D.18730>:
  D.18729 = prof->code_chunk_destroy;
  D.18732 = prof->profiler;
  D.18729 (D.18732, chunk);
  <D.18731>:
  prof = prof->next;
  <D.18142>:
  if (prof != 0B) goto <D.18141>; else goto <D.18143>;
  <D.18143>:
}


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.18734>; else goto <D.18735>;
  <D.18734>:
  return;
  <D.18735>:
  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.18738>; else goto <D.18739>;
  <D.18738>:
  return;
  <D.18739>:
  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 (*<Tca5>) (struct MonoProfiler *, void *, int, MonoProfilerCodeBufferType, void *) D.18741;
  struct MonoProfiler * D.18744;
  struct ProfilerDesc * prof;

  prof = prof_list;
  goto <D.18158>;
  <D.18157>:
  D.18741 = prof->code_buffer_new;
  if (D.18741 != 0B) goto <D.18742>; else goto <D.18743>;
  <D.18742>:
  D.18741 = prof->code_buffer_new;
  D.18744 = prof->profiler;
  D.18741 (D.18744, buffer, size, type, data);
  <D.18743>:
  prof = prof->next;
  <D.18158>:
  if (prof != 0B) goto <D.18157>; else goto <D.18159>;
  <D.18159>:
}


mono_profiler_coverage_alloc (struct MonoMethod * method, int entries)
{
  mono_bool (*<Tc8d>) (struct MonoProfiler *, struct MonoMethod *) D.18745;
  struct MonoProfiler * D.18748;
  int D.18749;
  struct MonoProfileCoverageInfo * D.18754;
  _Bool D.18757;
  long int D.18758;
  long int D.18759;
  struct GHashTable * coverage_hash.30;
  struct GHashTable * coverage_hash.31;
  long unsigned int D.18766;
  long unsigned int D.18767;
  long unsigned int D.18768;
  _Bool D.18771;
  long int D.18772;
  long int D.18773;
  struct MonoProfileCoverageInfo * res;
  int instrument;
  struct ProfilerDesc * prof;

  instrument = 0;
  prof = prof_list;
  goto <D.18169>;
  <D.18168>:
  D.18745 = prof->coverage_filter_cb;
  if (D.18745 != 0B) goto <D.18746>; else goto <D.18747>;
  <D.18746>:
  D.18745 = prof->coverage_filter_cb;
  D.18748 = prof->profiler;
  D.18749 = D.18745 (D.18748, method);
  if (D.18749 != 0) goto <D.18750>; else goto <D.18751>;
  <D.18750>:
  instrument = 1;
  <D.18751>:
  <D.18747>:
  prof = prof->next;
  <D.18169>:
  if (prof != 0B) goto <D.18168>; else goto <D.18170>;
  <D.18170>:
  if (instrument == 0) goto <D.18752>; else goto <D.18753>;
  <D.18752>:
  D.18754 = 0B;
  return D.18754;
  <D.18753>:
  {
    int ret;

    ret = pthread_mutex_lock (&profiler_coverage_mutex.mutex);
    if (ret != 0) goto <D.18755>; else goto <D.18756>;
    <D.18755>:
    monoeg_g_log (0B, 16, "Bad call to mono_mutex_lock result %d", ret);
    <D.18756>:
    D.18757 = ret != 0;
    D.18758 = (long int) D.18757;
    D.18759 = __builtin_expect (D.18758, 0);
    if (D.18759 != 0) goto <D.18760>; else goto <D.18761>;
    <D.18760>:
    monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "profiler.c", 933, "ret == 0");
    <D.18761>:
  }
  coverage_hash.30 = coverage_hash;
  if (coverage_hash.30 == 0B) goto <D.18763>; else goto <D.18764>;
  <D.18763>:
  coverage_hash.31 = monoeg_g_hash_table_new (0B, 0B);
  coverage_hash = coverage_hash.31;
  <D.18764>:
  D.18766 = (long unsigned int) entries;
  D.18767 = D.18766 * 16;
  D.18768 = D.18767 + 24;
  res = monoeg_malloc0 (D.18768);
  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.18769>; else goto <D.18770>;
    <D.18769>:
    monoeg_g_log (0B, 16, "Bad call to mono_mutex_unlock result %d", ret);
    <D.18770>:
    D.18771 = ret != 0;
    D.18772 = (long int) D.18771;
    D.18773 = __builtin_expect (D.18772, 0);
    if (D.18773 != 0) goto <D.18774>; else goto <D.18775>;
    <D.18774>:
    monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "profiler.c", 942, "ret == 0");
    <D.18775>:
  }
  D.18754 = res;
  return D.18754;
}


mono_profiler_coverage_free (struct MonoMethod * method)
{
  _Bool D.18779;
  long int D.18780;
  long int D.18781;
  struct GHashTable * coverage_hash.32;
  _Bool D.18789;
  long int D.18790;
  long int D.18791;
  _Bool D.18798;
  long int D.18799;
  long int D.18800;
  struct MonoProfileCoverageInfo * info;

  {
    int ret;

    ret = pthread_mutex_lock (&profiler_coverage_mutex.mutex);
    if (ret != 0) goto <D.18777>; else goto <D.18778>;
    <D.18777>:
    monoeg_g_log (0B, 16, "Bad call to mono_mutex_lock result %d", ret);
    <D.18778>:
    D.18779 = ret != 0;
    D.18780 = (long int) D.18779;
    D.18781 = __builtin_expect (D.18780, 0);
    if (D.18781 != 0) goto <D.18782>; else goto <D.18783>;
    <D.18782>:
    monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "profiler.c", 953, "ret == 0");
    <D.18783>:
  }
  coverage_hash.32 = coverage_hash;
  if (coverage_hash.32 == 0B) goto <D.18785>; else goto <D.18786>;
  <D.18785>:
  {
    int ret;

    ret = pthread_mutex_unlock (&profiler_coverage_mutex.mutex);
    if (ret != 0) goto <D.18787>; else goto <D.18788>;
    <D.18787>:
    monoeg_g_log (0B, 16, "Bad call to mono_mutex_unlock result %d", ret);
    <D.18788>:
    D.18789 = ret != 0;
    D.18790 = (long int) D.18789;
    D.18791 = __builtin_expect (D.18790, 0);
    if (D.18791 != 0) goto <D.18792>; else goto <D.18793>;
    <D.18792>:
    monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "profiler.c", 955, "ret == 0");
    <D.18793>:
  }
  return;
  <D.18786>:
  coverage_hash.32 = coverage_hash;
  info = monoeg_g_hash_table_lookup (coverage_hash.32, method);
  if (info != 0B) goto <D.18794>; else goto <D.18795>;
  <D.18794>:
  monoeg_g_free (info);
  coverage_hash.32 = coverage_hash;
  monoeg_g_hash_table_remove (coverage_hash.32, method);
  <D.18795>:
  {
    int ret;

    ret = pthread_mutex_unlock (&profiler_coverage_mutex.mutex);
    if (ret != 0) goto <D.18796>; else goto <D.18797>;
    <D.18796>:
    monoeg_g_log (0B, 16, "Bad call to mono_mutex_unlock result %d", ret);
    <D.18797>:
    D.18798 = ret != 0;
    D.18799 = (long int) D.18798;
    D.18800 = __builtin_expect (D.18799, 0);
    if (D.18800 != 0) goto <D.18801>; else goto <D.18802>;
    <D.18801>:
    monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "profiler.c", 964, "ret == 0");
    <D.18802>:
  }
}


mono_profiler_coverage_get (struct MonoProfiler * prof, struct MonoMethod * method, void (*MonoProfileCoverageFunc) (struct MonoProfiler *, const struct MonoProfileCoverageEntry *) func)
{
  _Bool D.18806;
  long int D.18807;
  long int D.18808;
  struct GHashTable * coverage_hash.33;
  _Bool D.18814;
  long int D.18815;
  long int D.18816;
  unsigned int code_size.34;
  sizetype D.18822;
  long int cil_code.35;
  long int start.36;
  long int D.18831;
  int D.18832;
  int D.18833;
  unsigned int offset.37;
  unsigned int D.18839;
  int D.18840;
  unsigned int D.18841;
  int D.18842;
  char * D.18843;
  int D.18844;
  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.18804>; else goto <D.18805>;
        <D.18804>:
        monoeg_g_log (0B, 16, "Bad call to mono_mutex_lock result %d", ret);
        <D.18805>:
        D.18806 = ret != 0;
        D.18807 = (long int) D.18806;
        D.18808 = __builtin_expect (D.18807, 0);
        if (D.18808 != 0) goto <D.18809>; else goto <D.18810>;
        <D.18809>:
        monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "profiler.c", 990, "ret == 0");
        <D.18810>:
      }
      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.18812>; else goto <D.18813>;
        <D.18812>:
        monoeg_g_log (0B, 16, "Bad call to mono_mutex_unlock result %d", ret);
        <D.18813>:
        D.18814 = ret != 0;
        D.18815 = (long int) D.18814;
        D.18816 = __builtin_expect (D.18815, 0);
        if (D.18816 != 0) goto <D.18817>; else goto <D.18818>;
        <D.18817>:
        monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "profiler.c", 992, "ret == 0");
        <D.18818>:
      }
      if (info == 0B) goto <D.18819>; else goto <D.18820>;
      <D.18819>:
      return;
      <D.18820>:
      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.18822 = (sizetype) code_size.34;
      end = start + D.18822;
      i = 0;
      goto <D.18200>;
      <D.18199>:
      cil_code = info->data[i].cil_code;
      if (cil_code != 0B) goto <D.18823>; else goto <D.18824>;
      <D.18823>:
      if (cil_code >= start) goto <D.18825>; else goto <D.18826>;
      <D.18825>:
      if (cil_code < end) goto <D.18827>; else goto <D.18828>;
      <D.18827>:
      {
        char * fname;

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

          offset.37 = (unsigned int) offset;
          location = mono_debug_symfile_lookup_location (debug_minfo, offset.37);
          if (location != 0B) goto <D.18837>; else goto <D.18838>;
          <D.18837>:
          D.18839 = location->row;
          D.18840 = (int) D.18839;
          entry.line = D.18840;
          D.18841 = location->column;
          D.18842 = (int) D.18841;
          entry.col = D.18842;
          D.18843 = location->source_file;
          fname = monoeg_strdup (D.18843);
          entry.filename = fname;
          mono_debug_free_source_location (location);
          <D.18838>:
        }
        <D.18835>:
        func (prof, &entry);
        monoeg_g_free (fname);
      }
      <D.18828>:
      <D.18826>:
      <D.18824>:
      i = i + 1;
      <D.18200>:
      D.18844 = info->entries;
      if (D.18844 > i) goto <D.18199>; else goto <D.18201>;
      <D.18201>:
      mono_metadata_free_mh (header);
    }
  finally
    {
      code_size = {CLOBBER};
      entry = {CLOBBER};
    }
}


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

  if (str != 0B) goto <D.18848>; else goto <D.18849>;
  <D.18848>:
  D.18850 = __strdup (str);
  return D.18850;
  <D.18849>:
  D.18850 = 0B;
  return D.18850;
}


mono_profiler_load (const char * desc)
{
  int D.18243;
  int iftmp.38;
  int D.18239;
  const char[8] * D.18858;
  unsigned char D.18859;
  int D.18860;
  unsigned char D.18861;
  int D.18862;
  const unsigned char * D.18867;
  unsigned char D.18868;
  int D.18869;
  const unsigned char * D.18870;
  unsigned char D.18871;
  int D.18872;
  const unsigned char * D.18877;
  unsigned char D.18878;
  int D.18879;
  const unsigned char * D.18880;
  unsigned char D.18881;
  int D.18882;
  const unsigned char * D.18887;
  unsigned char D.18888;
  int D.18889;
  const unsigned char * D.18890;
  unsigned char D.18891;
  int D.18892;
  int D.18894;
  const gchar * D.18897;
  int D.18265;
  int iftmp.39;
  int D.18264;
  const char[5] * D.18901;
  unsigned char D.18902;
  int D.18903;
  unsigned char D.18904;
  int D.18905;
  const unsigned char * D.18910;
  unsigned char D.18911;
  int D.18912;
  const unsigned char * D.18913;
  unsigned char D.18914;
  int D.18915;
  const unsigned char * D.18920;
  unsigned char D.18921;
  int D.18922;
  const unsigned char * D.18923;
  unsigned char D.18924;
  int D.18925;
  const unsigned char * D.18930;
  unsigned char D.18931;
  int D.18932;
  const unsigned char * D.18933;
  unsigned char D.18934;
  int D.18935;
  int D.18274;
  int iftmp.40;
  int D.18273;
  const char[6] * D.18943;
  unsigned char D.18944;
  int D.18945;
  unsigned char D.18946;
  int D.18947;
  const unsigned char * D.18952;
  unsigned char D.18953;
  int D.18954;
  const unsigned char * D.18955;
  unsigned char D.18956;
  int D.18957;
  const unsigned char * D.18962;
  unsigned char D.18963;
  int D.18964;
  const unsigned char * D.18965;
  unsigned char D.18966;
  int D.18967;
  const unsigned char * D.18972;
  unsigned char D.18973;
  int D.18974;
  const unsigned char * D.18975;
  unsigned char D.18976;
  int D.18977;
  int D.18283;
  int iftmp.41;
  int D.18282;
  const char[5] * D.18985;
  unsigned char D.18986;
  int D.18987;
  unsigned char D.18988;
  int D.18989;
  const unsigned char * D.18994;
  unsigned char D.18995;
  int D.18996;
  const unsigned char * D.18997;
  unsigned char D.18998;
  int D.18999;
  const unsigned char * D.19004;
  unsigned char D.19005;
  int D.19006;
  const unsigned char * D.19007;
  unsigned char D.19008;
  int D.19009;
  const unsigned char * D.19014;
  unsigned char D.19015;
  int D.19016;
  const unsigned char * D.19017;
  unsigned char D.19018;
  int D.19019;
  int D.18292;
  int iftmp.42;
  int D.18291;
  const char[4] * D.19027;
  unsigned char D.19028;
  int D.19029;
  unsigned char D.19030;
  int D.19031;
  const unsigned char * D.19036;
  unsigned char D.19037;
  int D.19038;
  const unsigned char * D.19039;
  unsigned char D.19040;
  int D.19041;
  const unsigned char * D.19046;
  unsigned char D.19047;
  int D.19048;
  const unsigned char * D.19049;
  unsigned char D.19050;
  int D.19051;
  const unsigned char * D.19056;
  unsigned char D.19057;
  int D.19058;
  const unsigned char * D.19059;
  unsigned char D.19060;
  int D.19061;
  int D.19065;
  const char * D.19068;
  struct _IO_FILE * stderr.43;
  gchar * D.19072;
  long int col.44;
  long int desc.45;
  long int D.19077;
  unsigned int D.19078;
  unsigned int D.19079;
  sizetype D.19080;
  char * D.19081;
  int D.19083;
  int D.19086;
  const char * D.19089;
  char * cdesc;

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

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

      __s2 = desc;
      D.18858 = "default";
      D.18859 = MEM[(const unsigned char *)D.18858];
      D.18860 = (int) D.18859;
      D.18861 = *__s2;
      D.18862 = (int) D.18861;
      __result = D.18860 - D.18862;
      {
        if (__s1_len != 0) goto <D.18863>; else goto <D.18864>;
        <D.18863>:
        if (__result == 0) goto <D.18865>; else goto <D.18866>;
        <D.18865>:
        D.18867 = &MEM[(void *)"default" + 1B];
        D.18868 = *D.18867;
        D.18869 = (int) D.18868;
        D.18870 = __s2 + 1;
        D.18871 = *D.18870;
        D.18872 = (int) D.18871;
        __result = D.18869 - D.18872;
        if (__s1_len > 1) goto <D.18873>; else goto <D.18874>;
        <D.18873>:
        if (__result == 0) goto <D.18875>; else goto <D.18876>;
        <D.18875>:
        D.18877 = &MEM[(void *)"default" + 2B];
        D.18878 = *D.18877;
        D.18879 = (int) D.18878;
        D.18880 = __s2 + 2;
        D.18881 = *D.18880;
        D.18882 = (int) D.18881;
        __result = D.18879 - D.18882;
        if (__s1_len > 2) goto <D.18883>; else goto <D.18884>;
        <D.18883>:
        if (__result == 0) goto <D.18885>; else goto <D.18886>;
        <D.18885>:
        D.18887 = &MEM[(void *)"default" + 3B];
        D.18888 = *D.18887;
        D.18889 = (int) D.18888;
        D.18890 = __s2 + 3;
        D.18891 = *D.18890;
        D.18892 = (int) D.18891;
        __result = D.18889 - D.18892;
        <D.18886>:
        <D.18884>:
        <D.18876>:
        <D.18874>:
        <D.18866>:
        <D.18864>:
      }
      D.18239 = __result;
    }
    iftmp.38 = D.18239;
    goto <D.18893>;
    <D.18857>:
    iftmp.38 = __builtin_strcmp ("default", desc);
    <D.18893>:
    D.18243 = iftmp.38;
  }
  if (D.18243 == 0) goto <D.18852>; else goto <D.18853>;
  <D.18852>:
  desc = "log:report";
  <D.18853>:
  D.18894 = strncmp (desc, "default:", 8);
  if (D.18894 == 0) goto <D.18895>; else goto <D.18896>;
  <D.18895>:
  {
    gchar * * args;
    gchar * * ptr;
    struct GString * str;

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

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

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

          __s2 = arg;
          D.18901 = "time";
          D.18902 = MEM[(const unsigned char *)D.18901];
          D.18903 = (int) D.18902;
          D.18904 = *__s2;
          D.18905 = (int) D.18904;
          __result = D.18903 - D.18905;
          {
            if (__s2_len != 0) goto <D.18906>; else goto <D.18907>;
            <D.18906>:
            if (__result == 0) goto <D.18908>; else goto <D.18909>;
            <D.18908>:
            D.18910 = &MEM[(void *)"time" + 1B];
            D.18911 = *D.18910;
            D.18912 = (int) D.18911;
            D.18913 = __s2 + 1;
            D.18914 = *D.18913;
            D.18915 = (int) D.18914;
            __result = D.18912 - D.18915;
            if (__s2_len > 1) goto <D.18916>; else goto <D.18917>;
            <D.18916>:
            if (__result == 0) goto <D.18918>; else goto <D.18919>;
            <D.18918>:
            D.18920 = &MEM[(void *)"time" + 2B];
            D.18921 = *D.18920;
            D.18922 = (int) D.18921;
            D.18923 = __s2 + 2;
            D.18924 = *D.18923;
            D.18925 = (int) D.18924;
            __result = D.18922 - D.18925;
            if (__s2_len > 2) goto <D.18926>; else goto <D.18927>;
            <D.18926>:
            if (__result == 0) goto <D.18928>; else goto <D.18929>;
            <D.18928>:
            D.18930 = &MEM[(void *)"time" + 3B];
            D.18931 = *D.18930;
            D.18932 = (int) D.18931;
            D.18933 = __s2 + 3;
            D.18934 = *D.18933;
            D.18935 = (int) D.18934;
            __result = D.18932 - D.18935;
            <D.18929>:
            <D.18927>:
            <D.18919>:
            <D.18917>:
            <D.18909>:
            <D.18907>:
          }
          D.18264 = __result;
        }
        iftmp.39 = -D.18264;
        goto <D.18936>;
        <D.18900>:
        iftmp.39 = __builtin_strcmp (arg, "time");
        <D.18936>:
        D.18265 = iftmp.39;
      }
      if (D.18265 == 0) goto <D.18937>; else goto <D.18938>;
      <D.18937>:
      monoeg_g_string_append (str, ",calls");
      goto <D.18939>;
      <D.18938>:
      {
        size_t __s1_len;
        size_t __s2_len;

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

          __s2 = arg;
          D.18943 = "alloc";
          D.18944 = MEM[(const unsigned char *)D.18943];
          D.18945 = (int) D.18944;
          D.18946 = *__s2;
          D.18947 = (int) D.18946;
          __result = D.18945 - D.18947;
          {
            if (__s2_len != 0) goto <D.18948>; else goto <D.18949>;
            <D.18948>:
            if (__result == 0) goto <D.18950>; else goto <D.18951>;
            <D.18950>:
            D.18952 = &MEM[(void *)"alloc" + 1B];
            D.18953 = *D.18952;
            D.18954 = (int) D.18953;
            D.18955 = __s2 + 1;
            D.18956 = *D.18955;
            D.18957 = (int) D.18956;
            __result = D.18954 - D.18957;
            if (__s2_len > 1) goto <D.18958>; else goto <D.18959>;
            <D.18958>:
            if (__result == 0) goto <D.18960>; else goto <D.18961>;
            <D.18960>:
            D.18962 = &MEM[(void *)"alloc" + 2B];
            D.18963 = *D.18962;
            D.18964 = (int) D.18963;
            D.18965 = __s2 + 2;
            D.18966 = *D.18965;
            D.18967 = (int) D.18966;
            __result = D.18964 - D.18967;
            if (__s2_len > 2) goto <D.18968>; else goto <D.18969>;
            <D.18968>:
            if (__result == 0) goto <D.18970>; else goto <D.18971>;
            <D.18970>:
            D.18972 = &MEM[(void *)"alloc" + 3B];
            D.18973 = *D.18972;
            D.18974 = (int) D.18973;
            D.18975 = __s2 + 3;
            D.18976 = *D.18975;
            D.18977 = (int) D.18976;
            __result = D.18974 - D.18977;
            <D.18971>:
            <D.18969>:
            <D.18961>:
            <D.18959>:
            <D.18951>:
            <D.18949>:
          }
          D.18273 = __result;
        }
        iftmp.40 = -D.18273;
        goto <D.18978>;
        <D.18942>:
        iftmp.40 = __builtin_strcmp (arg, "alloc");
        <D.18978>:
        D.18274 = iftmp.40;
      }
      if (D.18274 == 0) goto <D.18979>; else goto <D.18980>;
      <D.18979>:
      monoeg_g_string_append (str, ",alloc");
      goto <D.18981>;
      <D.18980>:
      {
        size_t __s1_len;
        size_t __s2_len;

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

          __s2 = arg;
          D.18985 = "stat";
          D.18986 = MEM[(const unsigned char *)D.18985];
          D.18987 = (int) D.18986;
          D.18988 = *__s2;
          D.18989 = (int) D.18988;
          __result = D.18987 - D.18989;
          {
            if (__s2_len != 0) goto <D.18990>; else goto <D.18991>;
            <D.18990>:
            if (__result == 0) goto <D.18992>; else goto <D.18993>;
            <D.18992>:
            D.18994 = &MEM[(void *)"stat" + 1B];
            D.18995 = *D.18994;
            D.18996 = (int) D.18995;
            D.18997 = __s2 + 1;
            D.18998 = *D.18997;
            D.18999 = (int) D.18998;
            __result = D.18996 - D.18999;
            if (__s2_len > 1) goto <D.19000>; else goto <D.19001>;
            <D.19000>:
            if (__result == 0) goto <D.19002>; else goto <D.19003>;
            <D.19002>:
            D.19004 = &MEM[(void *)"stat" + 2B];
            D.19005 = *D.19004;
            D.19006 = (int) D.19005;
            D.19007 = __s2 + 2;
            D.19008 = *D.19007;
            D.19009 = (int) D.19008;
            __result = D.19006 - D.19009;
            if (__s2_len > 2) goto <D.19010>; else goto <D.19011>;
            <D.19010>:
            if (__result == 0) goto <D.19012>; else goto <D.19013>;
            <D.19012>:
            D.19014 = &MEM[(void *)"stat" + 3B];
            D.19015 = *D.19014;
            D.19016 = (int) D.19015;
            D.19017 = __s2 + 3;
            D.19018 = *D.19017;
            D.19019 = (int) D.19018;
            __result = D.19016 - D.19019;
            <D.19013>:
            <D.19011>:
            <D.19003>:
            <D.19001>:
            <D.18993>:
            <D.18991>:
          }
          D.18282 = __result;
        }
        iftmp.41 = -D.18282;
        goto <D.19020>;
        <D.18984>:
        iftmp.41 = __builtin_strcmp (arg, "stat");
        <D.19020>:
        D.18283 = iftmp.41;
      }
      if (D.18283 == 0) goto <D.19021>; else goto <D.19022>;
      <D.19021>:
      monoeg_g_string_append (str, ",sample");
      goto <D.19023>;
      <D.19022>:
      {
        size_t __s1_len;
        size_t __s2_len;

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

          __s2 = arg;
          D.19027 = "jit";
          D.19028 = MEM[(const unsigned char *)D.19027];
          D.19029 = (int) D.19028;
          D.19030 = *__s2;
          D.19031 = (int) D.19030;
          __result = D.19029 - D.19031;
          {
            if (__s2_len != 0) goto <D.19032>; else goto <D.19033>;
            <D.19032>:
            if (__result == 0) goto <D.19034>; else goto <D.19035>;
            <D.19034>:
            D.19036 = &MEM[(void *)"jit" + 1B];
            D.19037 = *D.19036;
            D.19038 = (int) D.19037;
            D.19039 = __s2 + 1;
            D.19040 = *D.19039;
            D.19041 = (int) D.19040;
            __result = D.19038 - D.19041;
            if (__s2_len > 1) goto <D.19042>; else goto <D.19043>;
            <D.19042>:
            if (__result == 0) goto <D.19044>; else goto <D.19045>;
            <D.19044>:
            D.19046 = &MEM[(void *)"jit" + 2B];
            D.19047 = *D.19046;
            D.19048 = (int) D.19047;
            D.19049 = __s2 + 2;
            D.19050 = *D.19049;
            D.19051 = (int) D.19050;
            __result = D.19048 - D.19051;
            if (__s2_len > 2) goto <D.19052>; else goto <D.19053>;
            <D.19052>:
            if (__result == 0) goto <D.19054>; else goto <D.19055>;
            <D.19054>:
            D.19056 = &MEM[(void *)"jit" + 3B];
            D.19057 = *D.19056;
            D.19058 = (int) D.19057;
            D.19059 = __s2 + 3;
            D.19060 = *D.19059;
            D.19061 = (int) D.19060;
            __result = D.19058 - D.19061;
            <D.19055>:
            <D.19053>:
            <D.19045>:
            <D.19043>:
            <D.19035>:
            <D.19033>:
          }
          D.18291 = __result;
        }
        iftmp.42 = -D.18291;
        goto <D.19062>;
        <D.19026>:
        iftmp.42 = __builtin_strcmp (arg, "jit");
        <D.19062>:
        D.18292 = iftmp.42;
      }
      if (D.18292 == 0) goto <D.19063>; else goto <D.19064>;
      <D.19063>:
      // predicted unlikely by continue predictor.
      goto <D.18293>;
      <D.19064>:
      D.19065 = strncmp (arg, "file=", 5);
      if (D.19065 == 0) goto <D.19066>; else goto <D.19067>;
      <D.19066>:
      D.19068 = arg + 5;
      monoeg_g_string_append_printf (str, ",output=%s", D.19068);
      goto <D.19069>;
      <D.19067>:
      stderr.43 = stderr;
      fprintf (stderr.43, "profiler : Unknown argument \'%s\'.\n", arg);
      return;
      <D.19069>:
      <D.19023>:
      <D.18981>:
      <D.18939>:
    }
    <D.18293>:
    ptr = ptr + 8;
    <D.18304>:
    if (ptr != 0B) goto <D.19071>; else goto <D.18305>;
    <D.19071>:
    D.19072 = *ptr;
    if (D.19072 != 0B) goto <D.18303>; else goto <D.18305>;
    <D.18305>:
    cdesc = monoeg_g_string_free (str, 0);
    desc = cdesc;
  }
  <D.18896>:
  {
    const char * col;
    char * libname;
    char * mname;
    gboolean res;

    col = __builtin_strchr (desc, 58);
    res = 0;
    if (col != 0B) goto <D.19073>; else goto <D.19074>;
    <D.19073>:
    col.44 = (long int) col;
    desc.45 = (long int) desc;
    D.19077 = col.44 - desc.45;
    D.19078 = (unsigned int) D.19077;
    D.19079 = D.19078 + 1;
    mname = monoeg_g_memdup (desc, D.19079);
    col.44 = (long int) col;
    desc.45 = (long int) desc;
    D.19077 = col.44 - desc.45;
    D.19080 = (sizetype) D.19077;
    D.19081 = mname + D.19080;
    *D.19081 = 0;
    goto <D.19082>;
    <D.19074>:
    mname = monoeg_strdup (desc);
    <D.19082>:
    D.19083 = load_embedded_profiler (desc, mname);
    if (D.19083 == 0) goto <D.19084>; else goto <D.19085>;
    <D.19084>:
    libname = monoeg_g_strdup_printf ("mono-profiler-%s", mname);
    D.19086 = load_profiler_from_directory (0B, libname, desc);
    if (D.19086 == 0) goto <D.19087>; else goto <D.19088>;
    <D.19087>:
    res = 0;
    D.19089 = mono_assembly_getrootdir ();
    res = load_profiler_from_directory (D.19089, libname, desc);
    if (res == 0) goto <D.19090>; else goto <D.19091>;
    <D.19090>:
    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.19091>:
    <D.19088>:
    monoeg_g_free (libname);
    <D.19085>:
    monoeg_g_free (mname);
  }
  monoeg_g_free (cdesc);
}


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

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


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


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

  try
    {
      if (pmodule == 0B) goto <D.19101>; else goto <D.19102>;
      <D.19101>:
      D.19103 = 0;
      return D.19103;
      <D.19102>:
      err = mono_dl_symbol (pmodule, symbol, &func);
      if (err != 0B) goto <D.19104>; else goto <D.19105>;
      <D.19104>:
      monoeg_g_free (err);
      D.19103 = 0;
      return D.19103;
      <D.19105>:
      func.47 = func;
      func.47 (desc);
      D.19103 = 1;
      return D.19103;
    }
  finally
    {
      func = {CLOBBER};
    }
}


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

  try
    {
      pmodule = 0B;
      iter = 0B;
      err = 0B;
      goto <D.18229>;
      <D.18228>:
      pmodule = mono_dl_open (path, 1, &err);
      monoeg_g_free (path);
      err.48 = err;
      monoeg_g_free (err.48);
      if (pmodule != 0B) goto <D.19110>; else goto <D.19111>;
      <D.19110>:
      D.19112 = load_profiler (pmodule, desc, "mono_profiler_startup");
      return D.19112;
      <D.19111>:
      <D.18229>:
      path = mono_dl_build_path (directory, libname, &iter);
      if (path != 0B) goto <D.18228>; else goto <D.18230>;
      <D.18230>:
      D.19112 = 0;
      return D.19112;
    }
  finally
    {
      err = {CLOBBER};
      iter = {CLOBBER};
    }
}