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

  value = 0;
  prof_list.1 = prof_list;
  if (prof_list.1 != 0B) goto <D.17866>; else goto <D.17867>;
  <D.17866>:
  prof_list.1 = prof_list;
  prof_list.1->events = events;
  <D.17867>:
  prof = prof_list;
  goto <D.17347>;
  <D.17346>:
  D.17868 = prof->events;
  value = D.17868 | value;
  prof = prof->next;
  <D.17347>:
  if (prof != 0B) goto <D.17346>; else goto <D.17348>;
  <D.17348>:
  mono_profiler_events = value;
}


mono_profiler_get_events ()
{
  MonoProfileFlags D.17869;

  D.17869 = mono_profiler_events;
  return D.17869;
}


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.17872>; else goto <D.17873>;
  <D.17872>:
  return;
  <D.17873>:
  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.17876>; else goto <D.17877>;
  <D.17876>:
  return;
  <D.17877>:
  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.17880>; else goto <D.17881>;
  <D.17880>:
  return;
  <D.17881>:
  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.17884>; else goto <D.17885>;
  <D.17884>:
  return;
  <D.17885>:
  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.17888>; else goto <D.17889>;
  <D.17888>:
  return;
  <D.17889>:
  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.17892>; else goto <D.17893>;
  <D.17892>:
  return;
  <D.17893>:
  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.17896>; else goto <D.17897>;
  <D.17896>:
  return;
  <D.17897>:
  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.17900>; else goto <D.17901>;
  <D.17900>:
  return;
  <D.17901>:
  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.17904>; else goto <D.17905>;
  <D.17904>:
  return;
  <D.17905>:
  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.17908>; else goto <D.17909>;
  <D.17908>:
  return;
  <D.17909>:
  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.17912>; else goto <D.17913>;
  <D.17912>:
  return;
  <D.17913>:
  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.17916>; else goto <D.17917>;
  <D.17916>:
  return;
  <D.17917>:
  if (call_chain_depth > 128) goto <D.17918>; else goto <D.17919>;
  <D.17918>:
  call_chain_depth = 128;
  <D.17919>:
  if (call_chain_strategy > 3) goto <D.17920>; else goto <D.17921>;
  <D.17920>:
  call_chain_strategy = 0;
  <D.17921>:
  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;
}


__attribute__((visibility ("hidden")))
mono_profiler_stat_get_call_chain_depth ()
{
  struct ProfilerDesc * prof_list.14;
  void (*<Tcc1>) (struct MonoProfiler *, int, mono_byte * *, void *) D.17926;
  int D.17928;

  prof_list.14 = prof_list;
  if (prof_list.14 != 0B) goto <D.17925>; else goto <D.17923>;
  <D.17925>:
  prof_list.14 = prof_list;
  D.17926 = prof_list.14->statistical_call_chain_cb;
  if (D.17926 != 0B) goto <D.17927>; else goto <D.17923>;
  <D.17927>:
  prof_list.14 = prof_list;
  D.17928 = prof_list.14->statistical_call_chain_depth;
  return D.17928;
  <D.17923>:
  D.17928 = 0;
  return D.17928;
}


__attribute__((visibility ("hidden")))
mono_profiler_stat_get_call_chain_strategy ()
{
  struct ProfilerDesc * prof_list.15;
  void (*<Tcc1>) (struct MonoProfiler *, int, mono_byte * *, void *) D.17933;
  MonoProfilerCallChainStrategy D.17935;

  prof_list.15 = prof_list;
  if (prof_list.15 != 0B) goto <D.17932>; else goto <D.17930>;
  <D.17932>:
  prof_list.15 = prof_list;
  D.17933 = prof_list.15->statistical_call_chain_cb;
  if (D.17933 != 0B) goto <D.17934>; else goto <D.17930>;
  <D.17934>:
  prof_list.15 = prof_list;
  D.17935 = prof_list.15->statistical_call_chain_strategy;
  return D.17935;
  <D.17930>:
  D.17935 = 0;
  return D.17935;
}


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.17938>; else goto <D.17939>;
  <D.17938>:
  return;
  <D.17939>:
  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.17942>; else goto <D.17943>;
  <D.17942>:
  return;
  <D.17943>:
  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.17946>; else goto <D.17947>;
  <D.17946>:
  return;
  <D.17947>:
  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.17950>; else goto <D.17951>;
  <D.17950>:
  return;
  <D.17951>:
  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.17954>; else goto <D.17955>;
  <D.17954>:
  return;
  <D.17955>:
  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.17958>; else goto <D.17959>;
  <D.17958>:
  return;
  <D.17959>:
  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;
}


__attribute__((visibility ("hidden")))
mono_profiler_method_enter (struct MonoMethod * method)
{
  <unnamed type> D.17961;
  unsigned int D.17962;
  void (*<Tc65>) (struct MonoProfiler *, struct MonoMethod *) D.17965;
  struct MonoProfiler * D.17968;
  struct ProfilerDesc * prof;

  prof = prof_list;
  goto <D.17437>;
  <D.17436>:
  D.17961 = prof->events;
  D.17962 = D.17961 & 4096;
  if (D.17962 != 0) goto <D.17963>; else goto <D.17964>;
  <D.17963>:
  D.17965 = prof->method_enter;
  if (D.17965 != 0B) goto <D.17966>; else goto <D.17967>;
  <D.17966>:
  D.17965 = prof->method_enter;
  D.17968 = prof->profiler;
  D.17965 (D.17968, method);
  <D.17967>:
  <D.17964>:
  prof = prof->next;
  <D.17437>:
  if (prof != 0B) goto <D.17436>; else goto <D.17438>;
  <D.17438>:
}


__attribute__((visibility ("hidden")))
mono_profiler_method_leave (struct MonoMethod * method)
{
  <unnamed type> D.17969;
  unsigned int D.17970;
  void (*<Tc65>) (struct MonoProfiler *, struct MonoMethod *) D.17973;
  struct MonoProfiler * D.17976;
  struct ProfilerDesc * prof;

  prof = prof_list;
  goto <D.17444>;
  <D.17443>:
  D.17969 = prof->events;
  D.17970 = D.17969 & 4096;
  if (D.17970 != 0) goto <D.17971>; else goto <D.17972>;
  <D.17971>:
  D.17973 = prof->method_leave;
  if (D.17973 != 0B) goto <D.17974>; else goto <D.17975>;
  <D.17974>:
  D.17973 = prof->method_leave;
  D.17976 = prof->profiler;
  D.17973 (D.17976, method);
  <D.17975>:
  <D.17972>:
  prof = prof->next;
  <D.17444>:
  if (prof != 0B) goto <D.17443>; else goto <D.17445>;
  <D.17445>:
}


__attribute__((visibility ("hidden")))
mono_profiler_method_jit (struct MonoMethod * method)
{
  <unnamed type> D.17977;
  unsigned int D.17978;
  void (*<Tc65>) (struct MonoProfiler *, struct MonoMethod *) D.17981;
  struct MonoProfiler * D.17984;
  struct ProfilerDesc * prof;

  prof = prof_list;
  goto <D.17451>;
  <D.17450>:
  D.17977 = prof->events;
  D.17978 = D.17977 & 16;
  if (D.17978 != 0) goto <D.17979>; else goto <D.17980>;
  <D.17979>:
  D.17981 = prof->jit_start;
  if (D.17981 != 0B) goto <D.17982>; else goto <D.17983>;
  <D.17982>:
  D.17981 = prof->jit_start;
  D.17984 = prof->profiler;
  D.17981 (D.17984, method);
  <D.17983>:
  <D.17980>:
  prof = prof->next;
  <D.17451>:
  if (prof != 0B) goto <D.17450>; else goto <D.17452>;
  <D.17452>:
}


__attribute__((visibility ("hidden")))
mono_profiler_method_end_jit (struct MonoMethod * method, struct MonoJitInfo * jinfo, int result)
{
  <unnamed type> D.17985;
  unsigned int D.17986;
  void (*<Tc8d>) (struct MonoProfiler *, struct MonoMethod *, int) D.17989;
  struct MonoProfiler * D.17992;
  void (*<Tc92>) (struct MonoProfiler *, struct MonoMethod *, struct MonoJitInfo *, int) D.17993;
  struct ProfilerDesc * prof;

  prof = prof_list;
  goto <D.17460>;
  <D.17459>:
  D.17985 = prof->events;
  D.17986 = D.17985 & 16;
  if (D.17986 != 0) goto <D.17987>; else goto <D.17988>;
  <D.17987>:
  D.17989 = prof->jit_end;
  if (D.17989 != 0B) goto <D.17990>; else goto <D.17991>;
  <D.17990>:
  D.17989 = prof->jit_end;
  D.17992 = prof->profiler;
  D.17989 (D.17992, method, result);
  <D.17991>:
  D.17993 = prof->jit_end2;
  if (D.17993 != 0B) goto <D.17994>; else goto <D.17995>;
  <D.17994>:
  D.17993 = prof->jit_end2;
  D.17992 = prof->profiler;
  D.17993 (D.17992, method, jinfo, result);
  <D.17995>:
  <D.17988>:
  prof = prof->next;
  <D.17460>:
  if (prof != 0B) goto <D.17459>; else goto <D.17461>;
  <D.17461>:
}


__attribute__((visibility ("hidden")))
mono_profiler_method_free (struct MonoMethod * method)
{
  <unnamed type> D.17996;
  unsigned int D.17997;
  void (*<Tc65>) (struct MonoProfiler *, struct MonoMethod *) D.18000;
  struct MonoProfiler * D.18003;
  struct ProfilerDesc * prof;

  prof = prof_list;
  goto <D.17467>;
  <D.17466>:
  D.17996 = prof->events;
  D.17997 = D.17996 & 65536;
  if (D.17997 != 0) goto <D.17998>; else goto <D.17999>;
  <D.17998>:
  D.18000 = prof->method_free;
  if (D.18000 != 0B) goto <D.18001>; else goto <D.18002>;
  <D.18001>:
  D.18000 = prof->method_free;
  D.18003 = prof->profiler;
  D.18000 (D.18003, method);
  <D.18002>:
  <D.17999>:
  prof = prof->next;
  <D.17467>:
  if (prof != 0B) goto <D.17466>; else goto <D.17468>;
  <D.17468>:
}


__attribute__((visibility ("hidden")))
mono_profiler_method_start_invoke (struct MonoMethod * method)
{
  <unnamed type> D.18004;
  unsigned int D.18005;
  void (*<Tc65>) (struct MonoProfiler *, struct MonoMethod *) D.18008;
  struct MonoProfiler * D.18011;
  struct ProfilerDesc * prof;

  prof = prof_list;
  goto <D.17474>;
  <D.17473>:
  D.18004 = prof->events;
  D.18005 = D.18004 & 65536;
  if (D.18005 != 0) goto <D.18006>; else goto <D.18007>;
  <D.18006>:
  D.18008 = prof->method_start_invoke;
  if (D.18008 != 0B) goto <D.18009>; else goto <D.18010>;
  <D.18009>:
  D.18008 = prof->method_start_invoke;
  D.18011 = prof->profiler;
  D.18008 (D.18011, method);
  <D.18010>:
  <D.18007>:
  prof = prof->next;
  <D.17474>:
  if (prof != 0B) goto <D.17473>; else goto <D.17475>;
  <D.17475>:
}


__attribute__((visibility ("hidden")))
mono_profiler_method_end_invoke (struct MonoMethod * method)
{
  <unnamed type> D.18012;
  unsigned int D.18013;
  void (*<Tc65>) (struct MonoProfiler *, struct MonoMethod *) D.18016;
  struct MonoProfiler * D.18019;
  struct ProfilerDesc * prof;

  prof = prof_list;
  goto <D.17481>;
  <D.17480>:
  D.18012 = prof->events;
  D.18013 = D.18012 & 65536;
  if (D.18013 != 0) goto <D.18014>; else goto <D.18015>;
  <D.18014>:
  D.18016 = prof->method_end_invoke;
  if (D.18016 != 0B) goto <D.18017>; else goto <D.18018>;
  <D.18017>:
  D.18016 = prof->method_end_invoke;
  D.18019 = prof->profiler;
  D.18016 (D.18019, method);
  <D.18018>:
  <D.18015>:
  prof = prof->next;
  <D.17481>:
  if (prof != 0B) goto <D.17480>; else goto <D.17482>;
  <D.17482>:
}


__attribute__((visibility ("hidden")))
mono_profiler_code_transition (struct MonoMethod * method, int result)
{
  <unnamed type> D.18020;
  unsigned int D.18021;
  void (*<Tc8d>) (struct MonoProfiler *, struct MonoMethod *, int) D.18024;
  struct MonoProfiler * D.18027;
  struct ProfilerDesc * prof;

  prof = prof_list;
  goto <D.17489>;
  <D.17488>:
  D.18020 = prof->events;
  D.18021 = D.18020 & 2048;
  if (D.18021 != 0) goto <D.18022>; else goto <D.18023>;
  <D.18022>:
  D.18024 = prof->man_unman_transition;
  if (D.18024 != 0B) goto <D.18025>; else goto <D.18026>;
  <D.18025>:
  D.18024 = prof->man_unman_transition;
  D.18027 = prof->profiler;
  D.18024 (D.18027, method, result);
  <D.18026>:
  <D.18023>:
  prof = prof->next;
  <D.17489>:
  if (prof != 0B) goto <D.17488>; else goto <D.17490>;
  <D.17490>:
}


__attribute__((visibility ("hidden")))
mono_profiler_allocation (struct MonoObject * obj, struct MonoClass * klass)
{
  <unnamed type> D.18028;
  unsigned int D.18029;
  void (*<Tcb5>) (struct MonoProfiler *, struct MonoObject *, struct MonoClass *) D.18032;
  struct MonoProfiler * D.18035;
  struct ProfilerDesc * prof;

  prof = prof_list;
  goto <D.17497>;
  <D.17496>:
  D.18028 = prof->events;
  D.18029 = D.18028 & 128;
  if (D.18029 != 0) goto <D.18030>; else goto <D.18031>;
  <D.18030>:
  D.18032 = prof->allocation_cb;
  if (D.18032 != 0B) goto <D.18033>; else goto <D.18034>;
  <D.18033>:
  D.18032 = prof->allocation_cb;
  D.18035 = prof->profiler;
  D.18032 (D.18035, obj, klass);
  <D.18034>:
  <D.18031>:
  prof = prof->next;
  <D.17497>:
  if (prof != 0B) goto <D.17496>; else goto <D.17498>;
  <D.17498>:
}


__attribute__((visibility ("hidden")))
mono_profiler_monitor_event (struct MonoObject * obj, MonoProfilerMonitorEvent event)
{
  <unnamed type> D.18036;
  unsigned int D.18037;
  void (*<Tc79>) (struct MonoProfiler *, struct MonoObject *, MonoProfilerMonitorEvent) D.18040;
  struct MonoProfiler * D.18043;
  struct ProfilerDesc * prof;

  prof = prof_list;
  goto <D.17505>;
  <D.17504>:
  D.18036 = prof->events;
  D.18037 = D.18036 & 131072;
  if (D.18037 != 0) goto <D.18038>; else goto <D.18039>;
  <D.18038>:
  D.18040 = prof->monitor_event_cb;
  if (D.18040 != 0B) goto <D.18041>; else goto <D.18042>;
  <D.18041>:
  D.18040 = prof->monitor_event_cb;
  D.18043 = prof->profiler;
  D.18040 (D.18043, obj, event);
  <D.18042>:
  <D.18039>:
  prof = prof->next;
  <D.17505>:
  if (prof != 0B) goto <D.17504>; else goto <D.17506>;
  <D.17506>:
}


__attribute__((visibility ("hidden")))
mono_profiler_stat_hit (guchar * ip, void * context)
{
  <unnamed type> D.18044;
  unsigned int D.18045;
  void (*<Tcbb>) (struct MonoProfiler *, mono_byte *, void *) D.18048;
  struct MonoProfiler * D.18051;
  struct ProfilerDesc * prof;

  prof = prof_list;
  goto <D.17513>;
  <D.17512>:
  D.18044 = prof->events;
  D.18045 = D.18044 & 32768;
  if (D.18045 != 0) goto <D.18046>; else goto <D.18047>;
  <D.18046>:
  D.18048 = prof->statistical_cb;
  if (D.18048 != 0B) goto <D.18049>; else goto <D.18050>;
  <D.18049>:
  D.18048 = prof->statistical_cb;
  D.18051 = prof->profiler;
  D.18048 (D.18051, ip, context);
  <D.18050>:
  <D.18047>:
  prof = prof->next;
  <D.17513>:
  if (prof != 0B) goto <D.17512>; else goto <D.17514>;
  <D.17514>:
}


__attribute__((visibility ("hidden")))
mono_profiler_stat_call_chain (int call_chain_depth, guchar * * ips, void * context)
{
  <unnamed type> D.18052;
  unsigned int D.18053;
  void (*<Tcc1>) (struct MonoProfiler *, int, mono_byte * *, void *) D.18056;
  struct MonoProfiler * D.18059;
  struct ProfilerDesc * prof;

  prof = prof_list;
  goto <D.17522>;
  <D.17521>:
  D.18052 = prof->events;
  D.18053 = D.18052 & 32768;
  if (D.18053 != 0) goto <D.18054>; else goto <D.18055>;
  <D.18054>:
  D.18056 = prof->statistical_call_chain_cb;
  if (D.18056 != 0B) goto <D.18057>; else goto <D.18058>;
  <D.18057>:
  D.18056 = prof->statistical_call_chain_cb;
  D.18059 = prof->profiler;
  D.18056 (D.18059, call_chain_depth, ips, context);
  <D.18058>:
  <D.18055>:
  prof = prof->next;
  <D.17522>:
  if (prof != 0B) goto <D.17521>; else goto <D.17523>;
  <D.17523>:
}


__attribute__((visibility ("hidden")))
mono_profiler_exception_thrown (struct MonoObject * exception)
{
  <unnamed type> D.18060;
  unsigned int D.18061;
  void (*<Tc7e>) (struct MonoProfiler *, struct MonoObject *) D.18064;
  struct MonoProfiler * D.18067;
  struct ProfilerDesc * prof;

  prof = prof_list;
  goto <D.17529>;
  <D.17528>:
  D.18060 = prof->events;
  D.18061 = D.18060 & 64;
  if (D.18061 != 0) goto <D.18062>; else goto <D.18063>;
  <D.18062>:
  D.18064 = prof->exception_throw_cb;
  if (D.18064 != 0B) goto <D.18065>; else goto <D.18066>;
  <D.18065>:
  D.18064 = prof->exception_throw_cb;
  D.18067 = prof->profiler;
  D.18064 (D.18067, exception);
  <D.18066>:
  <D.18063>:
  prof = prof->next;
  <D.17529>:
  if (prof != 0B) goto <D.17528>; else goto <D.17530>;
  <D.17530>:
}


__attribute__((visibility ("hidden")))
mono_profiler_exception_method_leave (struct MonoMethod * method)
{
  <unnamed type> D.18068;
  unsigned int D.18069;
  void (*<Tc65>) (struct MonoProfiler *, struct MonoMethod *) D.18072;
  struct MonoProfiler * D.18075;
  struct ProfilerDesc * prof;

  prof = prof_list;
  goto <D.17536>;
  <D.17535>:
  D.18068 = prof->events;
  D.18069 = D.18068 & 64;
  if (D.18069 != 0) goto <D.18070>; else goto <D.18071>;
  <D.18070>:
  D.18072 = prof->exception_method_leave_cb;
  if (D.18072 != 0B) goto <D.18073>; else goto <D.18074>;
  <D.18073>:
  D.18072 = prof->exception_method_leave_cb;
  D.18075 = prof->profiler;
  D.18072 (D.18075, method);
  <D.18074>:
  <D.18071>:
  prof = prof->next;
  <D.17536>:
  if (prof != 0B) goto <D.17535>; else goto <D.17537>;
  <D.17537>:
}


__attribute__((visibility ("hidden")))
mono_profiler_exception_clause_handler (struct MonoMethod * method, int clause_type, int clause_num)
{
  <unnamed type> D.18076;
  unsigned int D.18077;
  void (*<Tc83>) (struct MonoProfiler *, struct MonoMethod *, int, int) D.18080;
  struct MonoProfiler * D.18083;
  struct ProfilerDesc * prof;

  prof = prof_list;
  goto <D.17545>;
  <D.17544>:
  D.18076 = prof->events;
  D.18077 = D.18076 & 64;
  if (D.18077 != 0) goto <D.18078>; else goto <D.18079>;
  <D.18078>:
  D.18080 = prof->exception_clause_cb;
  if (D.18080 != 0B) goto <D.18081>; else goto <D.18082>;
  <D.18081>:
  D.18080 = prof->exception_clause_cb;
  D.18083 = prof->profiler;
  D.18080 (D.18083, method, clause_type, clause_num);
  <D.18082>:
  <D.18079>:
  prof = prof->next;
  <D.17545>:
  if (prof != 0B) goto <D.17544>; else goto <D.17546>;
  <D.17546>:
}


__attribute__((visibility ("hidden")))
mono_profiler_thread_start (gsize tid)
{
  <unnamed type> D.18084;
  unsigned int D.18085;
  void (*<Tcab>) (struct MonoProfiler *, uintptr_t) D.18088;
  struct MonoProfiler * D.18091;
  struct ProfilerDesc * prof;

  prof = prof_list;
  goto <D.17552>;
  <D.17551>:
  D.18084 = prof->events;
  D.18085 = D.18084 & 512;
  if (D.18085 != 0) goto <D.18086>; else goto <D.18087>;
  <D.18086>:
  D.18088 = prof->thread_start;
  if (D.18088 != 0B) goto <D.18089>; else goto <D.18090>;
  <D.18089>:
  D.18088 = prof->thread_start;
  D.18091 = prof->profiler;
  D.18088 (D.18091, tid);
  <D.18090>:
  <D.18087>:
  prof = prof->next;
  <D.17552>:
  if (prof != 0B) goto <D.17551>; else goto <D.17553>;
  <D.17553>:
}


__attribute__((visibility ("hidden")))
mono_profiler_thread_end (gsize tid)
{
  <unnamed type> D.18092;
  unsigned int D.18093;
  void (*<Tcab>) (struct MonoProfiler *, uintptr_t) D.18096;
  struct MonoProfiler * D.18099;
  struct ProfilerDesc * prof;

  prof = prof_list;
  goto <D.17559>;
  <D.17558>:
  D.18092 = prof->events;
  D.18093 = D.18092 & 512;
  if (D.18093 != 0) goto <D.18094>; else goto <D.18095>;
  <D.18094>:
  D.18096 = prof->thread_end;
  if (D.18096 != 0B) goto <D.18097>; else goto <D.18098>;
  <D.18097>:
  D.18096 = prof->thread_end;
  D.18099 = prof->profiler;
  D.18096 (D.18099, tid);
  <D.18098>:
  <D.18095>:
  prof = prof->next;
  <D.17559>:
  if (prof != 0B) goto <D.17558>; else goto <D.17560>;
  <D.17560>:
}


__attribute__((visibility ("hidden")))
mono_profiler_thread_name (gsize tid, const char * name)
{
  <unnamed type> D.18100;
  unsigned int D.18101;
  void (*<Tcb0>) (struct MonoProfiler *, uintptr_t, const char *) D.18104;
  struct MonoProfiler * D.18107;
  struct ProfilerDesc * prof;

  prof = prof_list;
  goto <D.17567>;
  <D.17566>:
  D.18100 = prof->events;
  D.18101 = D.18100 & 512;
  if (D.18101 != 0) goto <D.18102>; else goto <D.18103>;
  <D.18102>:
  D.18104 = prof->thread_name;
  if (D.18104 != 0B) goto <D.18105>; else goto <D.18106>;
  <D.18105>:
  D.18104 = prof->thread_name;
  D.18107 = prof->profiler;
  D.18104 (D.18107, tid, name);
  <D.18106>:
  <D.18103>:
  prof = prof->next;
  <D.17567>:
  if (prof != 0B) goto <D.17566>; else goto <D.17568>;
  <D.17568>:
}


__attribute__((visibility ("hidden")))
mono_profiler_assembly_event (struct MonoAssembly * assembly, int code)
{
  <unnamed type> D.18108;
  unsigned int D.18109;
  void (*<Tc74>) (struct MonoProfiler *, struct MonoAssembly *) D.18112;
  struct MonoProfiler * D.18115;
  void (*<Tc74>) (struct MonoProfiler *, struct MonoAssembly *) D.18116;
  void (*<Tc74>) (struct MonoProfiler *, struct MonoAssembly *) D.18119;
  struct ProfilerDesc * prof;

  prof = prof_list;
  goto <D.17581>;
  <D.17580>:
  D.18108 = prof->events;
  D.18109 = D.18108 & 2;
  if (D.18109 == 0) goto <D.18110>; else goto <D.18111>;
  <D.18110>:
  // predicted unlikely by continue predictor.
  goto <D.17574>;
  <D.18111>:
  switch (code) <default: <D.17579>, case 0: <D.17575>, case 2: <D.17577>, case 3: <D.17578>>
  <D.17575>:
  D.18112 = prof->assembly_start_load;
  if (D.18112 != 0B) goto <D.18113>; else goto <D.18114>;
  <D.18113>:
  D.18112 = prof->assembly_start_load;
  D.18115 = prof->profiler;
  D.18112 (D.18115, assembly);
  <D.18114>:
  goto <D.17576>;
  <D.17577>:
  D.18116 = prof->assembly_start_unload;
  if (D.18116 != 0B) goto <D.18117>; else goto <D.18118>;
  <D.18117>:
  D.18116 = prof->assembly_start_unload;
  D.18115 = prof->profiler;
  D.18116 (D.18115, assembly);
  <D.18118>:
  goto <D.17576>;
  <D.17578>:
  D.18119 = prof->assembly_end_unload;
  if (D.18119 != 0B) goto <D.18120>; else goto <D.18121>;
  <D.18120>:
  D.18119 = prof->assembly_end_unload;
  D.18115 = prof->profiler;
  D.18119 (D.18115, assembly);
  <D.18121>:
  goto <D.17576>;
  <D.17579>:
  monoeg_assertion_message ("* Assertion: should not be reached at %s:%d\n", "profiler.c", 588);
  <D.17576>:
  <D.17574>:
  prof = prof->next;
  <D.17581>:
  if (prof != 0B) goto <D.17580>; else goto <D.17582>;
  <D.17582>:
}


__attribute__((visibility ("hidden")))
mono_profiler_assembly_loaded (struct MonoAssembly * assembly, int result)
{
  <unnamed type> D.18122;
  unsigned int D.18123;
  void (*<Tca1>) (struct MonoProfiler *, struct MonoAssembly *, int) D.18126;
  struct MonoProfiler * D.18129;
  struct ProfilerDesc * prof;

  prof = prof_list;
  goto <D.17589>;
  <D.17588>:
  D.18122 = prof->events;
  D.18123 = D.18122 & 2;
  if (D.18123 != 0) goto <D.18124>; else goto <D.18125>;
  <D.18124>:
  D.18126 = prof->assembly_end_load;
  if (D.18126 != 0B) goto <D.18127>; else goto <D.18128>;
  <D.18127>:
  D.18126 = prof->assembly_end_load;
  D.18129 = prof->profiler;
  D.18126 (D.18129, assembly, result);
  <D.18128>:
  <D.18125>:
  prof = prof->next;
  <D.17589>:
  if (prof != 0B) goto <D.17588>; else goto <D.17590>;
  <D.17590>:
}


__attribute__((visibility ("hidden")))
mono_profiler_iomap (char * report, const char * pathname, const char * new_pathname)
{
  <unnamed type> D.18130;
  unsigned int D.18131;
  void (*<Tcdf>) (struct MonoProfiler *, const char *, const char *, const char *) D.18134;
  struct MonoProfiler * D.18137;
  struct ProfilerDesc * prof;

  prof = prof_list;
  goto <D.17598>;
  <D.17597>:
  D.18130 = prof->events;
  D.18131 = D.18130 & 262144;
  if (D.18131 != 0) goto <D.18132>; else goto <D.18133>;
  <D.18132>:
  D.18134 = prof->iomap_cb;
  if (D.18134 != 0B) goto <D.18135>; else goto <D.18136>;
  <D.18135>:
  D.18134 = prof->iomap_cb;
  D.18137 = prof->profiler;
  D.18134 (D.18137, report, pathname, new_pathname);
  <D.18136>:
  <D.18133>:
  prof = prof->next;
  <D.17598>:
  if (prof != 0B) goto <D.17597>; else goto <D.17599>;
  <D.17599>:
}


__attribute__((visibility ("hidden")))
mono_profiler_module_event (struct MonoImage * module, int code)
{
  <unnamed type> D.18138;
  unsigned int D.18139;
  void (*<Tc6f>) (struct MonoProfiler *, struct MonoImage *) D.18142;
  struct MonoProfiler * D.18145;
  void (*<Tc6f>) (struct MonoProfiler *, struct MonoImage *) D.18146;
  void (*<Tc6f>) (struct MonoProfiler *, struct MonoImage *) D.18149;
  struct ProfilerDesc * prof;

  prof = prof_list;
  goto <D.17612>;
  <D.17611>:
  D.18138 = prof->events;
  D.18139 = D.18138 & 4;
  if (D.18139 == 0) goto <D.18140>; else goto <D.18141>;
  <D.18140>:
  // predicted unlikely by continue predictor.
  goto <D.17605>;
  <D.18141>:
  switch (code) <default: <D.17610>, case 0: <D.17606>, case 2: <D.17608>, case 3: <D.17609>>
  <D.17606>:
  D.18142 = prof->module_start_load;
  if (D.18142 != 0B) goto <D.18143>; else goto <D.18144>;
  <D.18143>:
  D.18142 = prof->module_start_load;
  D.18145 = prof->profiler;
  D.18142 (D.18145, module);
  <D.18144>:
  goto <D.17607>;
  <D.17608>:
  D.18146 = prof->module_start_unload;
  if (D.18146 != 0B) goto <D.18147>; else goto <D.18148>;
  <D.18147>:
  D.18146 = prof->module_start_unload;
  D.18145 = prof->profiler;
  D.18146 (D.18145, module);
  <D.18148>:
  goto <D.17607>;
  <D.17609>:
  D.18149 = prof->module_end_unload;
  if (D.18149 != 0B) goto <D.18150>; else goto <D.18151>;
  <D.18150>:
  D.18149 = prof->module_end_unload;
  D.18145 = prof->profiler;
  D.18149 (D.18145, module);
  <D.18151>:
  goto <D.17607>;
  <D.17610>:
  monoeg_assertion_message ("* Assertion: should not be reached at %s:%d\n", "profiler.c", 634);
  <D.17607>:
  <D.17605>:
  prof = prof->next;
  <D.17612>:
  if (prof != 0B) goto <D.17611>; else goto <D.17613>;
  <D.17613>:
}


__attribute__((visibility ("hidden")))
mono_profiler_module_loaded (struct MonoImage * module, int result)
{
  <unnamed type> D.18152;
  unsigned int D.18153;
  void (*<Tc9c>) (struct MonoProfiler *, struct MonoImage *, int) D.18156;
  struct MonoProfiler * D.18159;
  struct ProfilerDesc * prof;

  prof = prof_list;
  goto <D.17620>;
  <D.17619>:
  D.18152 = prof->events;
  D.18153 = D.18152 & 4;
  if (D.18153 != 0) goto <D.18154>; else goto <D.18155>;
  <D.18154>:
  D.18156 = prof->module_end_load;
  if (D.18156 != 0B) goto <D.18157>; else goto <D.18158>;
  <D.18157>:
  D.18156 = prof->module_end_load;
  D.18159 = prof->profiler;
  D.18156 (D.18159, module, result);
  <D.18158>:
  <D.18155>:
  prof = prof->next;
  <D.17620>:
  if (prof != 0B) goto <D.17619>; else goto <D.17621>;
  <D.17621>:
}


__attribute__((visibility ("hidden")))
mono_profiler_class_event (struct MonoClass * klass, int code)
{
  <unnamed type> D.18160;
  unsigned int D.18161;
  void (*<Tc6a>) (struct MonoProfiler *, struct MonoClass *) D.18164;
  struct MonoProfiler * D.18167;
  void (*<Tc6a>) (struct MonoProfiler *, struct MonoClass *) D.18168;
  void (*<Tc6a>) (struct MonoProfiler *, struct MonoClass *) D.18171;
  struct ProfilerDesc * prof;

  prof = prof_list;
  goto <D.17634>;
  <D.17633>:
  D.18160 = prof->events;
  D.18161 = D.18160 & 8;
  if (D.18161 == 0) goto <D.18162>; else goto <D.18163>;
  <D.18162>:
  // predicted unlikely by continue predictor.
  goto <D.17627>;
  <D.18163>:
  switch (code) <default: <D.17632>, case 0: <D.17628>, case 2: <D.17630>, case 3: <D.17631>>
  <D.17628>:
  D.18164 = prof->class_start_load;
  if (D.18164 != 0B) goto <D.18165>; else goto <D.18166>;
  <D.18165>:
  D.18164 = prof->class_start_load;
  D.18167 = prof->profiler;
  D.18164 (D.18167, klass);
  <D.18166>:
  goto <D.17629>;
  <D.17630>:
  D.18168 = prof->class_start_unload;
  if (D.18168 != 0B) goto <D.18169>; else goto <D.18170>;
  <D.18169>:
  D.18168 = prof->class_start_unload;
  D.18167 = prof->profiler;
  D.18168 (D.18167, klass);
  <D.18170>:
  goto <D.17629>;
  <D.17631>:
  D.18171 = prof->class_end_unload;
  if (D.18171 != 0B) goto <D.18172>; else goto <D.18173>;
  <D.18172>:
  D.18171 = prof->class_end_unload;
  D.18167 = prof->profiler;
  D.18171 (D.18167, klass);
  <D.18173>:
  goto <D.17629>;
  <D.17632>:
  monoeg_assertion_message ("* Assertion: should not be reached at %s:%d\n", "profiler.c", 671);
  <D.17629>:
  <D.17627>:
  prof = prof->next;
  <D.17634>:
  if (prof != 0B) goto <D.17633>; else goto <D.17635>;
  <D.17635>:
}


__attribute__((visibility ("hidden")))
mono_profiler_class_loaded (struct MonoClass * klass, int result)
{
  <unnamed type> D.18174;
  unsigned int D.18175;
  void (*<Tc97>) (struct MonoProfiler *, struct MonoClass *, int) D.18178;
  struct MonoProfiler * D.18181;
  struct ProfilerDesc * prof;

  prof = prof_list;
  goto <D.17642>;
  <D.17641>:
  D.18174 = prof->events;
  D.18175 = D.18174 & 8;
  if (D.18175 != 0) goto <D.18176>; else goto <D.18177>;
  <D.18176>:
  D.18178 = prof->class_end_load;
  if (D.18178 != 0B) goto <D.18179>; else goto <D.18180>;
  <D.18179>:
  D.18178 = prof->class_end_load;
  D.18181 = prof->profiler;
  D.18178 (D.18181, klass, result);
  <D.18180>:
  <D.18177>:
  prof = prof->next;
  <D.17642>:
  if (prof != 0B) goto <D.17641>; else goto <D.17643>;
  <D.17643>:
}


__attribute__((visibility ("hidden")))
mono_profiler_appdomain_event (struct MonoDomain * domain, int code)
{
  <unnamed type> D.18182;
  unsigned int D.18183;
  void (*<Tc60>) (struct MonoProfiler *, struct MonoDomain *) D.18186;
  struct MonoProfiler * D.18189;
  void (*<Tc60>) (struct MonoProfiler *, struct MonoDomain *) D.18190;
  void (*<Tc60>) (struct MonoProfiler *, struct MonoDomain *) D.18193;
  struct ProfilerDesc * prof;

  prof = prof_list;
  goto <D.17656>;
  <D.17655>:
  D.18182 = prof->events;
  D.18183 = D.18182 & 1;
  if (D.18183 == 0) goto <D.18184>; else goto <D.18185>;
  <D.18184>:
  // predicted unlikely by continue predictor.
  goto <D.17649>;
  <D.18185>:
  switch (code) <default: <D.17654>, case 0: <D.17650>, case 2: <D.17652>, case 3: <D.17653>>
  <D.17650>:
  D.18186 = prof->domain_start_load;
  if (D.18186 != 0B) goto <D.18187>; else goto <D.18188>;
  <D.18187>:
  D.18186 = prof->domain_start_load;
  D.18189 = prof->profiler;
  D.18186 (D.18189, domain);
  <D.18188>:
  goto <D.17651>;
  <D.17652>:
  D.18190 = prof->domain_start_unload;
  if (D.18190 != 0B) goto <D.18191>; else goto <D.18192>;
  <D.18191>:
  D.18190 = prof->domain_start_unload;
  D.18189 = prof->profiler;
  D.18190 (D.18189, domain);
  <D.18192>:
  goto <D.17651>;
  <D.17653>:
  D.18193 = prof->domain_end_unload;
  if (D.18193 != 0B) goto <D.18194>; else goto <D.18195>;
  <D.18194>:
  D.18193 = prof->domain_end_unload;
  D.18189 = prof->profiler;
  D.18193 (D.18189, domain);
  <D.18195>:
  goto <D.17651>;
  <D.17654>:
  monoeg_assertion_message ("* Assertion: should not be reached at %s:%d\n", "profiler.c", 708);
  <D.17651>:
  <D.17649>:
  prof = prof->next;
  <D.17656>:
  if (prof != 0B) goto <D.17655>; else goto <D.17657>;
  <D.17657>:
}


__attribute__((visibility ("hidden")))
mono_profiler_appdomain_loaded (struct MonoDomain * domain, int result)
{
  <unnamed type> D.18196;
  unsigned int D.18197;
  void (*<Tc88>) (struct MonoProfiler *, struct MonoDomain *, int) D.18200;
  struct MonoProfiler * D.18203;
  struct ProfilerDesc * prof;

  prof = prof_list;
  goto <D.17664>;
  <D.17663>:
  D.18196 = prof->events;
  D.18197 = D.18196 & 1;
  if (D.18197 != 0) goto <D.18198>; else goto <D.18199>;
  <D.18198>:
  D.18200 = prof->domain_end_load;
  if (D.18200 != 0B) goto <D.18201>; else goto <D.18202>;
  <D.18201>:
  D.18200 = prof->domain_end_load;
  D.18203 = prof->profiler;
  D.18200 (D.18203, domain, result);
  <D.18202>:
  <D.18199>:
  prof = prof->next;
  <D.17664>:
  if (prof != 0B) goto <D.17663>; else goto <D.17665>;
  <D.17665>:
}


__attribute__((visibility ("hidden")))
mono_profiler_shutdown ()
{
  void (*<Tc5b>) (struct MonoProfiler *) D.18204;
  struct MonoProfiler * D.18207;
  struct ProfilerDesc * prof;

  prof = prof_list;
  goto <D.17671>;
  <D.17670>:
  D.18204 = prof->shutdown_callback;
  if (D.18204 != 0B) goto <D.18205>; else goto <D.18206>;
  <D.18205>:
  D.18204 = prof->shutdown_callback;
  D.18207 = prof->profiler;
  D.18204 (D.18207);
  <D.18206>:
  prof = prof->next;
  <D.17671>:
  if (prof != 0B) goto <D.17670>; else goto <D.17672>;
  <D.17672>:
  mono_profiler_set_events (0);
}


__attribute__((visibility ("hidden")))
mono_profiler_gc_heap_resize (gint64 new_size)
{
  <unnamed type> D.18208;
  unsigned int D.18209;
  void (*<Tcd0>) (struct MonoProfiler *, int64_t) D.18212;
  struct MonoProfiler * D.18215;
  struct ProfilerDesc * prof;

  prof = prof_list;
  goto <D.17678>;
  <D.17677>:
  D.18208 = prof->events;
  D.18209 = D.18208 & 256;
  if (D.18209 != 0) goto <D.18210>; else goto <D.18211>;
  <D.18210>:
  D.18212 = prof->gc_heap_resize;
  if (D.18212 != 0B) goto <D.18213>; else goto <D.18214>;
  <D.18213>:
  D.18212 = prof->gc_heap_resize;
  D.18215 = prof->profiler;
  D.18212 (D.18215, new_size);
  <D.18214>:
  <D.18211>:
  prof = prof->next;
  <D.17678>:
  if (prof != 0B) goto <D.17677>; else goto <D.17679>;
  <D.17679>:
}


__attribute__((visibility ("hidden")))
mono_profiler_gc_event (MonoGCEvent event, int generation)
{
  <unnamed type> D.18216;
  unsigned int D.18217;
  void (*<Tcc6>) (struct MonoProfiler *, MonoGCEvent, int) D.18220;
  struct MonoProfiler * D.18223;
  struct ProfilerDesc * prof;

  prof = prof_list;
  goto <D.17686>;
  <D.17685>:
  D.18216 = prof->events;
  D.18217 = D.18216 & 256;
  if (D.18217 != 0) goto <D.18218>; else goto <D.18219>;
  <D.18218>:
  D.18220 = prof->gc_event;
  if (D.18220 != 0B) goto <D.18221>; else goto <D.18222>;
  <D.18221>:
  D.18220 = prof->gc_event;
  D.18223 = prof->profiler;
  D.18220 (D.18223, event, generation);
  <D.18222>:
  <D.18219>:
  prof = prof->next;
  <D.17686>:
  if (prof != 0B) goto <D.17685>; else goto <D.17687>;
  <D.17687>:
}


__attribute__((visibility ("hidden")))
mono_profiler_gc_moves (void * * objects, int num)
{
  <unnamed type> D.18224;
  unsigned int D.18225;
  void (*<Tccb>) (struct MonoProfiler *, void * *, int) D.18228;
  struct MonoProfiler * D.18231;
  struct ProfilerDesc * prof;

  prof = prof_list;
  goto <D.17694>;
  <D.17693>:
  D.18224 = prof->events;
  D.18225 = D.18224 & 524288;
  if (D.18225 != 0) goto <D.18226>; else goto <D.18227>;
  <D.18226>:
  D.18228 = prof->gc_moves;
  if (D.18228 != 0B) goto <D.18229>; else goto <D.18230>;
  <D.18229>:
  D.18228 = prof->gc_moves;
  D.18231 = prof->profiler;
  D.18228 (D.18231, objects, num);
  <D.18230>:
  <D.18227>:
  prof = prof->next;
  <D.17694>:
  if (prof != 0B) goto <D.17693>; else goto <D.17695>;
  <D.17695>:
}


__attribute__((visibility ("hidden")))
mono_profiler_gc_handle (int op, int type, uintptr_t handle, struct MonoObject * obj)
{
  <unnamed type> D.18232;
  unsigned int D.18233;
  void (*<Tcd5>) (struct MonoProfiler *, int, int, uintptr_t, struct MonoObject *) D.18236;
  struct MonoProfiler * D.18239;
  struct ProfilerDesc * prof;

  prof = prof_list;
  goto <D.17704>;
  <D.17703>:
  D.18232 = prof->events;
  D.18233 = D.18232 & 1048576;
  if (D.18233 != 0) goto <D.18234>; else goto <D.18235>;
  <D.18234>:
  D.18236 = prof->gc_handle;
  if (D.18236 != 0B) goto <D.18237>; else goto <D.18238>;
  <D.18237>:
  D.18236 = prof->gc_handle;
  D.18239 = prof->profiler;
  D.18236 (D.18239, op, type, handle, obj);
  <D.18238>:
  <D.18235>:
  prof = prof->next;
  <D.17704>:
  if (prof != 0B) goto <D.17703>; else goto <D.17705>;
  <D.17705>:
}


__attribute__((visibility ("hidden")))
mono_profiler_gc_roots (int num, void * * objects, int * root_types, uintptr_t * extra_info)
{
  <unnamed type> D.18240;
  unsigned int D.18241;
  void (*<Tcda>) (struct MonoProfiler *, int, void * *, int *, uintptr_t *) D.18244;
  struct MonoProfiler * D.18247;
  struct ProfilerDesc * prof;

  prof = prof_list;
  goto <D.17714>;
  <D.17713>:
  D.18240 = prof->events;
  D.18241 = D.18240 & 1048576;
  if (D.18241 != 0) goto <D.18242>; else goto <D.18243>;
  <D.18242>:
  D.18244 = prof->gc_roots;
  if (D.18244 != 0B) goto <D.18245>; else goto <D.18246>;
  <D.18245>:
  D.18244 = prof->gc_roots;
  D.18247 = prof->profiler;
  D.18244 (D.18247, num, objects, root_types, extra_info);
  <D.18246>:
  <D.18243>:
  prof = prof->next;
  <D.17714>:
  if (prof != 0B) goto <D.17713>; else goto <D.17715>;
  <D.17715>:
}


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.18249>; else goto <D.18250>;
  <D.18249>:
  return;
  <D.18250>:
  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.18253>; else goto <D.18254>;
  <D.18253>:
  return;
  <D.18254>:
  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.18257>; else goto <D.18258>;
  <D.18257>:
  return;
  <D.18258>:
  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.18261>; else goto <D.18262>;
  <D.18261>:
  return;
  <D.18262>:
  prof_list.25 = prof_list;
  prof_list.25->runtime_initialized_event = runtime_initialized_callback;
}


__attribute__((visibility ("hidden")))
mono_profiler_runtime_initialized ()
{
  void (*<Tc5b>) (struct MonoProfiler *) D.18264;
  struct MonoProfiler * D.18267;
  struct ProfilerDesc * prof;

  prof = prof_list;
  goto <D.17735>;
  <D.17734>:
  D.18264 = prof->runtime_initialized_event;
  if (D.18264 != 0B) goto <D.18265>; else goto <D.18266>;
  <D.18265>:
  D.18264 = prof->runtime_initialized_event;
  D.18267 = prof->profiler;
  D.18264 (D.18267);
  <D.18266>:
  prof = prof->next;
  <D.17735>:
  if (prof != 0B) goto <D.17734>; else goto <D.17736>;
  <D.17736>:
}


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


__attribute__((visibility ("hidden")))
mono_profiler_code_chunk_new (void * chunk, int size)
{
  void (*<Tcf2>) (struct MonoProfiler *, void *, int) D.18272;
  struct MonoProfiler * D.18275;
  struct ProfilerDesc * prof;

  prof = prof_list;
  goto <D.17746>;
  <D.17745>:
  D.18272 = prof->code_chunk_new;
  if (D.18272 != 0B) goto <D.18273>; else goto <D.18274>;
  <D.18273>:
  D.18272 = prof->code_chunk_new;
  D.18275 = prof->profiler;
  D.18272 (D.18275, chunk, size);
  <D.18274>:
  prof = prof->next;
  <D.17746>:
  if (prof != 0B) goto <D.17745>; else goto <D.17747>;
  <D.17747>:
}


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


__attribute__((visibility ("hidden")))
mono_profiler_code_chunk_destroy (void * chunk)
{
  void (*<Tcf7>) (struct MonoProfiler *, void *) D.18280;
  struct MonoProfiler * D.18283;
  struct ProfilerDesc * prof;

  prof = prof_list;
  goto <D.17756>;
  <D.17755>:
  D.18280 = prof->code_chunk_destroy;
  if (D.18280 != 0B) goto <D.18281>; else goto <D.18282>;
  <D.18281>:
  D.18280 = prof->code_chunk_destroy;
  D.18283 = prof->profiler;
  D.18280 (D.18283, chunk);
  <D.18282>:
  prof = prof->next;
  <D.17756>:
  if (prof != 0B) goto <D.17755>; else goto <D.17757>;
  <D.17757>:
}


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.18285>; else goto <D.18286>;
  <D.18285>:
  return;
  <D.18286>:
  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.18289>; else goto <D.18290>;
  <D.18289>:
  return;
  <D.18290>:
  prof_list.29 = prof_list;
  prof_list.29->iomap_cb = callback;
}


__attribute__((visibility ("hidden")))
mono_profiler_code_buffer_new (void * buffer, int size, MonoProfilerCodeBufferType type, void * data)
{
  void (*<Tcfc>) (struct MonoProfiler *, void *, int, MonoProfilerCodeBufferType, void *) D.18292;
  struct MonoProfiler * D.18295;
  struct ProfilerDesc * prof;

  prof = prof_list;
  goto <D.17772>;
  <D.17771>:
  D.18292 = prof->code_buffer_new;
  if (D.18292 != 0B) goto <D.18293>; else goto <D.18294>;
  <D.18293>:
  D.18292 = prof->code_buffer_new;
  D.18295 = prof->profiler;
  D.18292 (D.18295, buffer, size, type, data);
  <D.18294>:
  prof = prof->next;
  <D.17772>:
  if (prof != 0B) goto <D.17771>; else goto <D.17773>;
  <D.17773>:
}


__attribute__((visibility ("hidden")))
mono_profiler_coverage_alloc (struct MonoMethod * method, int entries)
{
  mono_bool (*<Tce4>) (struct MonoProfiler *, struct MonoMethod *) D.18296;
  struct MonoProfiler * D.18299;
  int D.18300;
  struct MonoProfileCoverageInfo * D.18305;
  _Bool D.18308;
  long int D.18309;
  long int D.18310;
  struct GHashTable * coverage_hash.30;
  struct GHashTable * D.18316;
  long unsigned int D.18317;
  long unsigned int D.18318;
  long unsigned int D.18319;
  _Bool D.18322;
  long int D.18323;
  long int D.18324;
  struct MonoProfileCoverageInfo * res;
  int instrument;
  struct ProfilerDesc * prof;

  instrument = 0;
  prof = prof_list;
  goto <D.17783>;
  <D.17782>:
  D.18296 = prof->coverage_filter_cb;
  if (D.18296 != 0B) goto <D.18297>; else goto <D.18298>;
  <D.18297>:
  D.18296 = prof->coverage_filter_cb;
  D.18299 = prof->profiler;
  D.18300 = D.18296 (D.18299, method);
  if (D.18300 != 0) goto <D.18301>; else goto <D.18302>;
  <D.18301>:
  instrument = 1;
  <D.18302>:
  <D.18298>:
  prof = prof->next;
  <D.17783>:
  if (prof != 0B) goto <D.17782>; else goto <D.17784>;
  <D.17784>:
  if (instrument == 0) goto <D.18303>; else goto <D.18304>;
  <D.18303>:
  D.18305 = 0B;
  return D.18305;
  <D.18304>:
  {
    int ret;

    ret = pthread_mutex_lock (&profiler_coverage_mutex.mutex);
    if (ret != 0) goto <D.18306>; else goto <D.18307>;
    <D.18306>:
    monoeg_g_log (0B, 16, "Bad call to mono_mutex_lock result %d", ret);
    <D.18307>:
    D.18308 = ret != 0;
    D.18309 = (long int) D.18308;
    D.18310 = __builtin_expect (D.18309, 0);
    if (D.18310 != 0) goto <D.18311>; else goto <D.18312>;
    <D.18311>:
    monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "profiler.c", 933, "ret == 0");
    <D.18312>:
  }
  coverage_hash.30 = coverage_hash;
  if (coverage_hash.30 == 0B) goto <D.18314>; else goto <D.18315>;
  <D.18314>:
  D.18316 = monoeg_g_hash_table_new (0B, 0B);
  coverage_hash = D.18316;
  <D.18315>:
  D.18317 = (long unsigned int) entries;
  D.18318 = D.18317 * 16;
  D.18319 = D.18318 + 24;
  res = monoeg_malloc0 (D.18319);
  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.18320>; else goto <D.18321>;
    <D.18320>:
    monoeg_g_log (0B, 16, "Bad call to mono_mutex_unlock result %d", ret);
    <D.18321>:
    D.18322 = ret != 0;
    D.18323 = (long int) D.18322;
    D.18324 = __builtin_expect (D.18323, 0);
    if (D.18324 != 0) goto <D.18325>; else goto <D.18326>;
    <D.18325>:
    monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "profiler.c", 942, "ret == 0");
    <D.18326>:
  }
  D.18305 = res;
  return D.18305;
}


__attribute__((visibility ("hidden")))
mono_profiler_coverage_free (struct MonoMethod * method)
{
  _Bool D.18330;
  long int D.18331;
  long int D.18332;
  struct GHashTable * coverage_hash.31;
  _Bool D.18340;
  long int D.18341;
  long int D.18342;
  _Bool D.18349;
  long int D.18350;
  long int D.18351;
  struct MonoProfileCoverageInfo * info;

  {
    int ret;

    ret = pthread_mutex_lock (&profiler_coverage_mutex.mutex);
    if (ret != 0) goto <D.18328>; else goto <D.18329>;
    <D.18328>:
    monoeg_g_log (0B, 16, "Bad call to mono_mutex_lock result %d", ret);
    <D.18329>:
    D.18330 = ret != 0;
    D.18331 = (long int) D.18330;
    D.18332 = __builtin_expect (D.18331, 0);
    if (D.18332 != 0) goto <D.18333>; else goto <D.18334>;
    <D.18333>:
    monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "profiler.c", 953, "ret == 0");
    <D.18334>:
  }
  coverage_hash.31 = coverage_hash;
  if (coverage_hash.31 == 0B) goto <D.18336>; else goto <D.18337>;
  <D.18336>:
  {
    int ret;

    ret = pthread_mutex_unlock (&profiler_coverage_mutex.mutex);
    if (ret != 0) goto <D.18338>; else goto <D.18339>;
    <D.18338>:
    monoeg_g_log (0B, 16, "Bad call to mono_mutex_unlock result %d", ret);
    <D.18339>:
    D.18340 = ret != 0;
    D.18341 = (long int) D.18340;
    D.18342 = __builtin_expect (D.18341, 0);
    if (D.18342 != 0) goto <D.18343>; else goto <D.18344>;
    <D.18343>:
    monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "profiler.c", 955, "ret == 0");
    <D.18344>:
  }
  return;
  <D.18337>:
  coverage_hash.31 = coverage_hash;
  info = monoeg_g_hash_table_lookup (coverage_hash.31, method);
  if (info != 0B) goto <D.18345>; else goto <D.18346>;
  <D.18345>:
  monoeg_g_free (info);
  coverage_hash.31 = coverage_hash;
  monoeg_g_hash_table_remove (coverage_hash.31, method);
  <D.18346>:
  {
    int ret;

    ret = pthread_mutex_unlock (&profiler_coverage_mutex.mutex);
    if (ret != 0) goto <D.18347>; else goto <D.18348>;
    <D.18347>:
    monoeg_g_log (0B, 16, "Bad call to mono_mutex_unlock result %d", ret);
    <D.18348>:
    D.18349 = ret != 0;
    D.18350 = (long int) D.18349;
    D.18351 = __builtin_expect (D.18350, 0);
    if (D.18351 != 0) goto <D.18352>; else goto <D.18353>;
    <D.18352>:
    monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "profiler.c", 964, "ret == 0");
    <D.18353>:
  }
}


mono_profiler_coverage_get (struct MonoProfiler * prof, struct MonoMethod * method, void (*MonoProfileCoverageFunc) (struct MonoProfiler *, const struct MonoProfileCoverageEntry *) func)
{
  _Bool D.18357;
  long int D.18358;
  long int D.18359;
  struct GHashTable * coverage_hash.32;
  _Bool D.18365;
  long int D.18366;
  long int D.18367;
  unsigned int code_size.33;
  sizetype D.18373;
  long int cil_code.34;
  long int start.35;
  long int D.18382;
  int D.18383;
  int D.18384;
  unsigned int offset.36;
  unsigned int D.18390;
  int D.18391;
  unsigned int D.18392;
  int D.18393;
  char * D.18394;
  int D.18395;
  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.18355>; else goto <D.18356>;
        <D.18355>:
        monoeg_g_log (0B, 16, "Bad call to mono_mutex_lock result %d", ret);
        <D.18356>:
        D.18357 = ret != 0;
        D.18358 = (long int) D.18357;
        D.18359 = __builtin_expect (D.18358, 0);
        if (D.18359 != 0) goto <D.18360>; else goto <D.18361>;
        <D.18360>:
        monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "profiler.c", 990, "ret == 0");
        <D.18361>:
      }
      coverage_hash.32 = coverage_hash;
      info = monoeg_g_hash_table_lookup (coverage_hash.32, method);
      {
        int ret;

        ret = pthread_mutex_unlock (&profiler_coverage_mutex.mutex);
        if (ret != 0) goto <D.18363>; else goto <D.18364>;
        <D.18363>:
        monoeg_g_log (0B, 16, "Bad call to mono_mutex_unlock result %d", ret);
        <D.18364>:
        D.18365 = ret != 0;
        D.18366 = (long int) D.18365;
        D.18367 = __builtin_expect (D.18366, 0);
        if (D.18367 != 0) goto <D.18368>; else goto <D.18369>;
        <D.18368>:
        monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "profiler.c", 992, "ret == 0");
        <D.18369>:
      }
      if (info == 0B) goto <D.18370>; else goto <D.18371>;
      <D.18370>:
      return;
      <D.18371>:
      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.33 = code_size;
      D.18373 = (sizetype) code_size.33;
      end = start + D.18373;
      i = 0;
      goto <D.17814>;
      <D.17813>:
      cil_code = info->data[i].cil_code;
      if (cil_code != 0B) goto <D.18374>; else goto <D.18375>;
      <D.18374>:
      if (cil_code >= start) goto <D.18376>; else goto <D.18377>;
      <D.18376>:
      if (cil_code < end) goto <D.18378>; else goto <D.18379>;
      <D.18378>:
      {
        char * fname;

        fname = 0B;
        cil_code.34 = (long int) cil_code;
        start.35 = (long int) start;
        D.18382 = cil_code.34 - start.35;
        offset = (int) D.18382;
        entry.iloffset = offset;
        entry.method = method;
        D.18383 = info->data[i].count;
        entry.counter = D.18383;
        entry.col = 1;
        D.18384 = entry.col;
        entry.line = D.18384;
        entry.filename = 0B;
        if (debug_minfo != 0B) goto <D.18385>; else goto <D.18386>;
        <D.18385>:
        {
          struct MonoDebugSourceLocation * location;

          offset.36 = (unsigned int) offset;
          location = mono_debug_symfile_lookup_location (debug_minfo, offset.36);
          if (location != 0B) goto <D.18388>; else goto <D.18389>;
          <D.18388>:
          D.18390 = location->row;
          D.18391 = (int) D.18390;
          entry.line = D.18391;
          D.18392 = location->column;
          D.18393 = (int) D.18392;
          entry.col = D.18393;
          D.18394 = location->source_file;
          fname = monoeg_strdup (D.18394);
          entry.filename = fname;
          mono_debug_free_source_location (location);
          <D.18389>:
        }
        <D.18386>:
        func (prof, &entry);
        monoeg_g_free (fname);
      }
      <D.18379>:
      <D.18377>:
      <D.18375>:
      i = i + 1;
      <D.17814>:
      D.18395 = info->entries;
      if (D.18395 > i) goto <D.17813>; else goto <D.17815>;
      <D.17815>:
      mono_metadata_free_mh (header);
    }
  finally
    {
      code_size = {CLOBBER};
      entry = {CLOBBER};
    }
}


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

  if (str != 0B) goto <D.18399>; else goto <D.18400>;
  <D.18399>:
  D.18401 = __strdup (str);
  return D.18401;
  <D.18400>:
  D.18401 = 0B;
  return D.18401;
}


mono_profiler_load (const char * desc)
{
  int D.18406;
  _Bool iftmp.37;
  long unsigned int D.18408;
  int D.18411;
  int D.18413;
  const char * D.18416;
  int D.18417;
  int D.18421;
  int D.18425;
  int D.18429;
  _Bool iftmp.38;
  long unsigned int D.18433;
  int D.18436;
  int D.18438;
  const char * D.18441;
  struct _IO_FILE * stderr.39;
  gchar * D.18445;
  long int col.40;
  long int desc.41;
  long int D.18450;
  unsigned int D.18451;
  unsigned int D.18452;
  sizetype D.18453;
  char * D.18454;
  int D.18456;
  int D.18459;
  const char * D.18462;
  char * cdesc;

  cdesc = 0B;
  mono_gc_base_init ();
  if (desc == 0B) goto <D.18403>; else goto <D.18405>;
  <D.18405>:
  D.18406 = strcmp ("default", desc);
  if (D.18406 == 0) goto <D.18403>; else goto <D.18404>;
  <D.18403>:
  desc = "log:report";
  <D.18404>:
  D.18408 = __strlen_g ("default:");
  if (D.18408 <= 7) goto <D.18409>; else goto <D.18410>;
  <D.18409>:
  D.18411 = strcmp (desc, "default:");
  iftmp.37 = D.18411 == 0;
  goto <D.18412>;
  <D.18410>:
  D.18413 = strncmp (desc, "default:", 8);
  iftmp.37 = D.18413 == 0;
  <D.18412>:
  if (iftmp.37 != 0) goto <D.18414>; else goto <D.18415>;
  <D.18414>:
  {
    gchar * * args;
    gchar * * ptr;
    struct GString * str;

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

      arg = *ptr;
      D.18417 = strcmp (arg, "time");
      if (D.18417 == 0) goto <D.18418>; else goto <D.18419>;
      <D.18418>:
      monoeg_g_string_append (str, ",calls");
      goto <D.18420>;
      <D.18419>:
      D.18421 = strcmp (arg, "alloc");
      if (D.18421 == 0) goto <D.18422>; else goto <D.18423>;
      <D.18422>:
      monoeg_g_string_append (str, ",alloc");
      goto <D.18424>;
      <D.18423>:
      D.18425 = strcmp (arg, "stat");
      if (D.18425 == 0) goto <D.18426>; else goto <D.18427>;
      <D.18426>:
      monoeg_g_string_append (str, ",sample");
      goto <D.18428>;
      <D.18427>:
      D.18429 = strcmp (arg, "jit");
      if (D.18429 == 0) goto <D.18430>; else goto <D.18431>;
      <D.18430>:
      // predicted unlikely by continue predictor.
      goto <D.17853>;
      <D.18431>:
      D.18433 = __strlen_g ("file=");
      if (D.18433 <= 4) goto <D.18434>; else goto <D.18435>;
      <D.18434>:
      D.18436 = strcmp (arg, "file=");
      iftmp.38 = D.18436 == 0;
      goto <D.18437>;
      <D.18435>:
      D.18438 = strncmp (arg, "file=", 5);
      iftmp.38 = D.18438 == 0;
      <D.18437>:
      if (iftmp.38 != 0) goto <D.18439>; else goto <D.18440>;
      <D.18439>:
      D.18441 = arg + 5;
      monoeg_g_string_append_printf (str, ",output=%s", D.18441);
      goto <D.18442>;
      <D.18440>:
      stderr.39 = stderr;
      fprintf (stderr.39, "profiler : Unknown argument \'%s\'.\n", arg);
      return;
      <D.18442>:
      <D.18428>:
      <D.18424>:
      <D.18420>:
    }
    <D.17853>:
    ptr = ptr + 8;
    <D.17855>:
    if (ptr != 0B) goto <D.18444>; else goto <D.17856>;
    <D.18444>:
    D.18445 = *ptr;
    if (D.18445 != 0B) goto <D.17854>; else goto <D.17856>;
    <D.17856>:
    cdesc = monoeg_g_string_free (str, 0);
    desc = cdesc;
  }
  <D.18415>:
  {
    const char * col;
    char * libname;
    char * mname;
    gboolean res;

    col = __builtin_strchr (desc, 58);
    res = 0;
    if (col != 0B) goto <D.18446>; else goto <D.18447>;
    <D.18446>:
    col.40 = (long int) col;
    desc.41 = (long int) desc;
    D.18450 = col.40 - desc.41;
    D.18451 = (unsigned int) D.18450;
    D.18452 = D.18451 + 1;
    mname = monoeg_g_memdup (desc, D.18452);
    col.40 = (long int) col;
    desc.41 = (long int) desc;
    D.18450 = col.40 - desc.41;
    D.18453 = (sizetype) D.18450;
    D.18454 = mname + D.18453;
    *D.18454 = 0;
    goto <D.18455>;
    <D.18447>:
    mname = monoeg_strdup (desc);
    <D.18455>:
    D.18456 = load_embedded_profiler (desc, mname);
    if (D.18456 == 0) goto <D.18457>; else goto <D.18458>;
    <D.18457>:
    libname = monoeg_g_strdup_printf ("mono-profiler-%s", mname);
    D.18459 = load_profiler_from_directory (0B, libname, desc);
    if (D.18459 == 0) goto <D.18460>; else goto <D.18461>;
    <D.18460>:
    res = 0;
    D.18462 = mono_assembly_getrootdir ();
    res = load_profiler_from_directory (D.18462, libname, desc);
    if (res == 0) goto <D.18463>; else goto <D.18464>;
    <D.18463>:
    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.18464>:
    <D.18461>:
    monoeg_g_free (libname);
    <D.18458>:
    monoeg_g_free (mname);
  }
  monoeg_g_free (cdesc);
}


__attribute__((__gnu_inline__))
__strlen_g (const char * __str)
{
  size_t D.18466;
  long int __ptr.42;
  long int __str.43;
  long int D.18469;
  char * __ptr;
  char * __tmp;

  __ptr = 0B;
  __tmp = __str;
  __asm__ __volatile__("   la    0,0
0: srst  %0,%1
   jo    0b
" : "=&a" __ptr, "=&a" __tmp : "0" __ptr, "1" __tmp : "0", "memory", "cc");
  __ptr.42 = (long int) __ptr;
  __str.43 = (long int) __str;
  D.18469 = __ptr.42 - __str.43;
  D.18466 = (size_t) D.18469;
  return D.18466;
}


__attribute__((__gnu_inline__, nothrow, leaf, pure))
strcmp (const char * __s1, const char * __s2)
{
  int iftmp.44;
  int iftmp.45;
  int D.18479;
  char * __p1;
  char * __p2;
  int __ret;

  __p1 = __s1;
  __p2 = __s2;
  __asm__ __volatile__("   slr   0,0
0: clst  %1,%2
   jo    0b
   ipm   %0
   srl   %0,28" : "=d" __ret, "=&a" __p1, "=&a" __p2 : "1" __p1, "2" __p2 : "0", "memory", "cc");
  if (__ret != 0) goto <D.18472>; else goto <D.18473>;
  <D.18472>:
  if (__ret == 1) goto <D.18475>; else goto <D.18476>;
  <D.18475>:
  iftmp.45 = -1;
  goto <D.18477>;
  <D.18476>:
  iftmp.45 = 1;
  <D.18477>:
  iftmp.44 = iftmp.45;
  goto <D.18478>;
  <D.18473>:
  iftmp.44 = 0;
  <D.18478>:
  __ret = iftmp.44;
  D.18479 = __ret;
  return D.18479;
}


__attribute__((__artificial__, __gnu_inline__, __always_inline__))
fprintf (struct FILE * restrict __stream, const char * restrict __fmt)
{
  int D.18481;

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


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


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

  try
    {
      if (pmodule == 0B) goto <D.18489>; else goto <D.18490>;
      <D.18489>:
      D.18491 = 0;
      return D.18491;
      <D.18490>:
      err = mono_dl_symbol (pmodule, symbol, &func);
      if (err != 0B) goto <D.18492>; else goto <D.18493>;
      <D.18492>:
      monoeg_g_free (err);
      D.18491 = 0;
      return D.18491;
      <D.18493>:
      func.47 = func;
      func.47 (desc);
      D.18491 = 1;
      return D.18491;
    }
  finally
    {
      func = {CLOBBER};
    }
}


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

  try
    {
      pmodule = 0B;
      iter = 0B;
      err = 0B;
      goto <D.17843>;
      <D.17842>:
      pmodule = mono_dl_open (path, 1, &err);
      monoeg_g_free (path);
      err.48 = err;
      monoeg_g_free (err.48);
      if (pmodule != 0B) goto <D.18498>; else goto <D.18499>;
      <D.18498>:
      D.18500 = load_profiler (pmodule, desc, "mono_profiler_startup");
      return D.18500;
      <D.18499>:
      <D.17843>:
      path = mono_dl_build_path (directory, libname, &iter);
      if (path != 0B) goto <D.17842>; else goto <D.17844>;
      <D.17844>:
      D.18500 = 0;
      return D.18500;
    }
  finally
    {
      err = {CLOBBER};
      iter = {CLOBBER};
    }
}