mono_debug_init (MonoDebugFormat format)
{
  int mono_debug_initialized.0;
  _Bool D.16806;
  long int D.16807;
  long int D.16808;
  void * mono_symbol_table.1;
  struct MonoSymbolTable * mono_symbol_table.2;
  struct GHashTable * mono_debug_handles.3;
  struct GHashTable * data_table_hash.4;
  struct MonoDebugDataTable * D.16817;

  mono_debug_initialized.0 = mono_debug_initialized;
  D.16806 = mono_debug_initialized.0 != 0;
  D.16807 = (long int) D.16806;
  D.16808 = __builtin_expect (D.16807, 0);
  if (D.16808 != 0) goto <D.16809>; else goto <D.16810>;
  <D.16809>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "mono-debug.c", 228, "!mono_debug_initialized");
  <D.16810>:
  if (format == 2) goto <D.16811>; else goto <D.16812>;
  <D.16811>:
  monoeg_g_log (0B, 4, "The mdb debugger is no longer supported.");
  <D.16470>:
  goto <D.16470>;
  <D.16812>:
  mono_debug_initialized = 1;
  mono_debug_format = format;
  mono_gc_base_init ();
  mono_debugger_initialize ();
  mono_debugger_lock ();
  mono_symbol_table.1 = monoeg_malloc0 (32);
  mono_symbol_table = mono_symbol_table.1;
  mono_symbol_table.2 = mono_symbol_table;
  mono_symbol_table.2->magic = 8862914395094897703;
  mono_symbol_table.2 = mono_symbol_table;
  mono_symbol_table.2->version = 81;
  mono_symbol_table.2 = mono_symbol_table;
  mono_symbol_table.2->total_size = 32;
  mono_debug_handles.3 = monoeg_g_hash_table_new_full (0B, 0B, 0B, free_debug_handle);
  mono_debug_handles = mono_debug_handles.3;
  data_table_hash.4 = monoeg_g_hash_table_new_full (0B, 0B, 0B, free_data_table);
  data_table_hash = data_table_hash.4;
  mono_debugger_class_init_func = mono_debug_add_type;
  mono_install_assembly_load_hook (mono_debug_add_assembly, 0B);
  mono_symbol_table.2 = mono_symbol_table;
  D.16817 = create_data_table (0B);
  mono_symbol_table.2->global_data_table = D.16817;
  mono_debugger_unlock ();
}


mono_debug_add_assembly (struct MonoAssembly * assembly, void * user_data)
{
  struct MonoDebugHandle * handle;
  struct MonoImage * image;

  mono_debugger_lock ();
  image = mono_assembly_get_image (assembly);
  handle = open_symfile_from_bundle (image);
  if (handle == 0B) goto <D.16818>; else goto <D.16819>;
  <D.16818>:
  mono_debug_open_image (image, 0B, 0);
  <D.16819>:
  mono_debugger_unlock ();
}


open_symfile_from_bundle (struct MonoImage * image)
{
  int D.16796;
  const char * D.16820;
  const char * D.16821;
  struct MonoDebugHandle * D.16824;
  int D.16825;
  const mono_byte * D.16826;
  struct BundledSymfile * bsymfile;

  bsymfile = bundled_symfiles;
  goto <D.16799>;
  <D.16798>:
  {
    size_t __s1_len;
    size_t __s2_len;

    D.16820 = image->module_name;
    D.16821 = bsymfile->aname;
    D.16796 = __builtin_strcmp (D.16821, D.16820);
  }
  if (D.16796 != 0) goto <D.16822>; else goto <D.16823>;
  <D.16822>:
  // predicted unlikely by continue predictor.
  goto <D.16797>;
  <D.16823>:
  D.16825 = bsymfile->size;
  D.16826 = bsymfile->raw_contents;
  D.16824 = mono_debug_open_image (image, D.16826, D.16825);
  return D.16824;
  <D.16797>:
  bsymfile = bsymfile->next;
  <D.16799>:
  if (bsymfile != 0B) goto <D.16798>; else goto <D.16800>;
  <D.16800>:
  D.16824 = 0B;
  return D.16824;
}


mono_debug_open_image (struct MonoImage * image, const guint8 * raw_contents, int size)
{
  int D.16828;
  struct MonoDebugHandle * D.16831;
  int next_symbol_file_id.5;
  int next_symbol_file_id.6;
  unsigned int next_symbol_file_id.7;
  const char * D.16837;
  gchar * D.16838;
  struct MonoDebugDataTable * D.16839;
  struct MonoSymbolFile * D.16840;
  struct MonoSymbolTable * mono_symbol_table.8;
  struct MonoDebugList * * D.16842;
  struct GHashTable * mono_debug_handles.9;
  struct MonoDebugHandle * handle;

  D.16828 = mono_image_is_dynamic (image);
  if (D.16828 != 0) goto <D.16829>; else goto <D.16830>;
  <D.16829>:
  D.16831 = 0B;
  return D.16831;
  <D.16830>:
  mono_debugger_lock ();
  handle = _mono_debug_get_image (image);
  if (handle != 0B) goto <D.16832>; else goto <D.16833>;
  <D.16832>:
  mono_debugger_unlock ();
  D.16831 = handle;
  return D.16831;
  <D.16833>:
  handle = monoeg_malloc0 (20);
  next_symbol_file_id.5 = next_symbol_file_id;
  next_symbol_file_id.6 = next_symbol_file_id.5 + 1;
  next_symbol_file_id = next_symbol_file_id.6;
  next_symbol_file_id.5 = next_symbol_file_id;
  next_symbol_file_id.7 = (unsigned int) next_symbol_file_id.5;
  handle->index = next_symbol_file_id.7;
  handle->image = image;
  mono_image_addref (image);
  D.16837 = mono_image_get_filename (image);
  D.16838 = monoeg_strdup (D.16837);
  handle->image_file = D.16838;
  D.16839 = create_data_table (0B);
  handle->type_table = D.16839;
  D.16840 = mono_debug_open_mono_symbols (handle, raw_contents, size, 0);
  handle->symfile = D.16840;
  mono_symbol_table.8 = mono_symbol_table;
  D.16842 = &mono_symbol_table.8->symbol_files;
  mono_debug_list_add (D.16842, handle);
  mono_debug_handles.9 = mono_debug_handles;
  monoeg_g_hash_table_insert_replace (mono_debug_handles.9, image, handle, 0);
  mono_debugger_unlock ();
  D.16831 = handle;
  return D.16831;
}


_mono_debug_get_image (struct MonoImage * image)
{
  struct MonoDebugHandle * D.16845;
  struct GHashTable * mono_debug_handles.10;

  mono_debug_handles.10 = mono_debug_handles;
  D.16845 = monoeg_g_hash_table_lookup (mono_debug_handles.10, image);
  return D.16845;
}


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

  if (str != 0B) goto <D.16848>; else goto <D.16849>;
  <D.16848>:
  D.16850 = __strdup (str);
  return D.16850;
  <D.16849>:
  D.16850 = 0B;
  return D.16850;
}


mono_debug_add_type (struct MonoClass * klass)
{
  struct MonoGenericClass * D.16854;
  unsigned char D.16856;
  unsigned char D.16858;
  struct MonoImage * D.16860;
  unsigned char D.16866;
  unsigned char D.16867;
  guint8 * ptr.11;
  unsigned int D.16871;
  int D.16872;
  int D.16873;
  unsigned int D.16874;
  guint8 * ptr.12;
  int ptr.13;
  int oldptr.14;
  int D.16878;
  _Bool D.16879;
  long int D.16880;
  long int D.16881;
  unsigned int D.16884;
  _Bool D.16885;
  long int D.16886;
  long int D.16887;
  struct MonoDebugDataTable * D.16890;
  guint8[0:] * D.16891;
  struct MonoDebugHandle * handle;
  struct MonoDebugClassEntry * entry;
  guint8 buffer[8192];
  guint8 * ptr;
  guint8 * oldptr;
  guint32 size;
  guint32 total_size;
  guint32 max_size;
  int base_offset;

  try
    {
      base_offset = 0;
      D.16854 = klass->generic_class;
      if (D.16854 != 0B) goto <D.16852>; else goto <D.16855>;
      <D.16855>:
      D.16856 = klass->rank;
      if (D.16856 != 0) goto <D.16852>; else goto <D.16857>;
      <D.16857>:
      D.16858 = klass->byval_arg.type;
      if (D.16858 == 19) goto <D.16852>; else goto <D.16859>;
      <D.16859>:
      D.16858 = klass->byval_arg.type;
      if (D.16858 == 30) goto <D.16852>; else goto <D.16853>;
      <D.16852>:
      return;
      <D.16853>:
      mono_debugger_lock ();
      D.16860 = klass->image;
      handle = _mono_debug_get_image (D.16860);
      if (handle == 0B) goto <D.16861>; else goto <D.16862>;
      <D.16861>:
      mono_debugger_unlock ();
      return;
      <D.16862>:
      max_size = 16;
      if (max_size > 8192) goto <D.16863>; else goto <D.16864>;
      <D.16863>:
      oldptr = monoeg_malloc (max_size);
      ptr = oldptr;
      goto <D.16865>;
      <D.16864>:
      oldptr = &buffer;
      ptr = oldptr;
      <D.16865>:
      D.16866 = BIT_FIELD_REF <*klass, 8, 160>;
      D.16867 = D.16866 & 8;
      if (D.16867 != 0) goto <D.16868>; else goto <D.16869>;
      <D.16868>:
      base_offset = -8;
      <D.16869>:
      ptr.11 = ptr;
      D.16871 = klass->type_token;
      write_leb128 (D.16871, ptr.11, &ptr);
      ptr.11 = ptr;
      D.16872 = klass->instance_size;
      D.16873 = D.16872 + base_offset;
      D.16874 = (unsigned int) D.16873;
      write_leb128 (D.16874, ptr.11, &ptr);
      ptr.11 = ptr;
      MEM[(void * *)ptr.11] = klass;
      ptr.11 = ptr;
      ptr.12 = ptr.11 + 4;
      ptr = ptr.12;
      ptr.11 = ptr;
      ptr.13 = (int) ptr.11;
      oldptr.14 = (int) oldptr;
      D.16878 = ptr.13 - oldptr.14;
      size = (guint32) D.16878;
      D.16879 = size >= max_size;
      D.16880 = (long int) D.16879;
      D.16881 = __builtin_expect (D.16880, 0);
      if (D.16881 != 0) goto <D.16882>; else goto <D.16883>;
      <D.16882>:
      monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "mono-debug.c", 906, "size < max_size");
      <D.16883>:
      total_size = size + 4;
      D.16884 = total_size + 9;
      D.16885 = D.16884 > 16363;
      D.16886 = (long int) D.16885;
      D.16887 = __builtin_expect (D.16886, 0);
      if (D.16887 != 0) goto <D.16888>; else goto <D.16889>;
      <D.16888>:
      monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "mono-debug.c", 909, "total_size + 9 < DATA_TABLE_CHUNK_SIZE");
      <D.16889>:
      D.16890 = handle->type_table;
      entry = allocate_data_item (D.16890, 1, total_size);
      entry->size = total_size;
      D.16891 = &entry->data;
      memcpy (D.16891, oldptr, size);
      D.16890 = handle->type_table;
      write_data_item (D.16890, entry);
      if (max_size > 8192) goto <D.16892>; else goto <D.16893>;
      <D.16892>:
      monoeg_g_free (oldptr);
      <D.16893>:
      mono_debugger_unlock ();
    }
  finally
    {
      buffer = {CLOBBER};
      ptr = {CLOBBER};
    }
}


write_leb128 (guint32 value, guint8 * ptr, guint8 * * rptr)
{
  unsigned char D.16897;
  guint8 * ptr.15;

  <D.16547>:
  {
    guint8 byte;

    D.16897 = (unsigned char) value;
    byte = D.16897 & 127;
    value = value >> 7;
    if (value != 0) goto <D.16898>; else goto <D.16899>;
    <D.16898>:
    byte = byte | 128;
    <D.16899>:
    ptr.15 = ptr;
    ptr = ptr.15 + 1;
    *ptr.15 = byte;
  }
  if (value != 0) goto <D.16547>; else goto <D.16548>;
  <D.16548>:
  *rptr = ptr;
}


allocate_data_item (struct MonoDebugDataTable * table, MonoDebugDataItemType type, guint32 size)
{
  unsigned int D.16901;
  unsigned int D.16902;
  struct MonoDebugDataChunk * D.16906;
  unsigned int D.16907;
  unsigned int D.16908;
  _Bool D.16909;
  long int D.16910;
  long int D.16911;
  unsigned int D.16914;
  unsigned int D.16915;
  unsigned int D.16916;
  unsigned int D.16919;
  guint8 * D.16920;
  guint32 chunk_size;
  guint8 * data;

  D.16901 = size + 3;
  size = D.16901 & 4294967292;
  D.16902 = size + 16;
  if (D.16902 <= 16363) goto <D.16903>; else goto <D.16904>;
  <D.16903>:
  chunk_size = 16364;
  goto <D.16905>;
  <D.16904>:
  chunk_size = size + 16;
  <D.16905>:
  D.16906 = table->current_chunk;
  D.16907 = D.16906->current_offset;
  D.16906 = table->current_chunk;
  D.16908 = D.16906->allocated_size;
  D.16909 = D.16907 != D.16908;
  D.16910 = (long int) D.16909;
  D.16911 = __builtin_expect (D.16910, 0);
  if (D.16911 != 0) goto <D.16912>; else goto <D.16913>;
  <D.16912>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "mono-debug.c", 442, "table->current_chunk->current_offset == table->current_chunk->allocated_size");
  <D.16913>:
  D.16906 = table->current_chunk;
  D.16908 = D.16906->allocated_size;
  D.16914 = D.16908 + size;
  D.16915 = D.16914 + 8;
  D.16906 = table->current_chunk;
  D.16916 = D.16906->total_size;
  if (D.16915 >= D.16916) goto <D.16917>; else goto <D.16918>;
  <D.16917>:
  {
    struct MonoDebugDataChunk * new_chunk;

    D.16919 = chunk_size + 20;
    new_chunk = monoeg_malloc0 (D.16919);
    new_chunk->total_size = chunk_size;
    D.16906 = table->current_chunk;
    D.16906->next = new_chunk;
    table->current_chunk = new_chunk;
  }
  <D.16918>:
  D.16906 = table->current_chunk;
  D.16906 = table->current_chunk;
  D.16908 = D.16906->allocated_size;
  data = &D.16906->data[D.16908];
  D.16906 = table->current_chunk;
  D.16906 = table->current_chunk;
  D.16908 = D.16906->allocated_size;
  D.16914 = D.16908 + size;
  D.16915 = D.16914 + 8;
  D.16906->allocated_size = D.16915;
  MEM[(guint32 *)data] = size;
  data = data + 4;
  MEM[(guint32 *)data] = type;
  data = data + 4;
  D.16920 = data;
  return D.16920;
}


memcpy (void * restrict __dest, const void * restrict __src, size_t __len)
{
  void * D.16922;
  unsigned int D.16923;

  D.16923 = __builtin_object_size (__dest, 0);
  D.16922 = __builtin___memcpy_chk (__dest, __src, __len, D.16923);
  return D.16922;
}


write_data_item (struct MonoDebugDataTable * table, const guint8 * data)
{
  unsigned int D.16925;
  unsigned int D.16926;
  unsigned int D.16927;
  unsigned int D.16928;
  _Bool D.16929;
  long int D.16930;
  long int D.16931;
  struct MonoDebugDataChunk * current_chunk;
  guint32 size;

  current_chunk = table->current_chunk;
  size = MEM[(guint32 *)data + 4294967288B];
  D.16925 = current_chunk->current_offset;
  D.16926 = D.16925 + size;
  D.16927 = D.16926 + 8;
  D.16928 = current_chunk->allocated_size;
  D.16929 = D.16927 != D.16928;
  D.16930 = (long int) D.16929;
  D.16931 = __builtin_expect (D.16930, 0);
  if (D.16931 != 0) goto <D.16932>; else goto <D.16933>;
  <D.16932>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "mono-debug.c", 470, "current_chunk->current_offset + size + 8 == current_chunk->allocated_size");
  <D.16933>:
  D.16928 = current_chunk->allocated_size;
  current_chunk->current_offset = D.16928;
}


free_data_table (struct MonoDebugDataTable * table)
{
  struct GHashTable * D.16934;
  struct GHashTable * D.16935;
  struct MonoDebugDataChunk * D.16936;
  struct MonoSymbolTable * mono_symbol_table.16;
  struct MonoDebugList * * D.16938;
  struct MonoDebugDataChunk * chunk;
  struct MonoDebugDataChunk * next_chunk;

  D.16934 = table->method_hash;
  monoeg_g_hash_table_foreach (D.16934, free_header_data, 0B);
  D.16934 = table->method_hash;
  monoeg_g_hash_table_destroy (D.16934);
  D.16935 = table->method_address_hash;
  monoeg_g_hash_table_destroy (D.16935);
  table->method_hash = 0B;
  table->method_address_hash = 0B;
  chunk = table->first_chunk;
  goto <D.16457>;
  <D.16456>:
  next_chunk = chunk->next;
  monoeg_g_free (chunk);
  chunk = next_chunk;
  <D.16457>:
  if (chunk != 0B) goto <D.16456>; else goto <D.16458>;
  <D.16458>:
  table->current_chunk = 0B;
  D.16936 = table->current_chunk;
  table->first_chunk = D.16936;
  mono_symbol_table.16 = mono_symbol_table;
  D.16938 = &mono_symbol_table.16->data_tables;
  mono_debug_list_remove (D.16938, table);
  monoeg_g_free (table);
}


free_header_data (void * key, void * value, void * user_data)
{
  struct MonoDebugWrapperData * D.16939;
  const gchar * D.16942;
  struct GSList * D.16943;
  struct MonoDebugMethodHeader * header;

  header = value;
  D.16939 = header->wrapper_data;
  if (D.16939 != 0B) goto <D.16940>; else goto <D.16941>;
  <D.16940>:
  D.16939 = header->wrapper_data;
  D.16942 = D.16939->method_name;
  monoeg_g_free (D.16942);
  D.16939 = header->wrapper_data;
  monoeg_g_free (D.16939);
  <D.16941>:
  D.16943 = header->address_list;
  monoeg_g_slist_free (D.16943);
}


free_debug_handle (struct MonoDebugHandle * handle)
{
  struct MonoSymbolFile * D.16944;
  struct MonoDebugDataTable * D.16947;
  struct MonoImage * D.16948;
  char * D.16949;

  D.16944 = handle->symfile;
  if (D.16944 != 0B) goto <D.16945>; else goto <D.16946>;
  <D.16945>:
  D.16944 = handle->symfile;
  mono_debug_close_mono_symbol_file (D.16944);
  <D.16946>:
  D.16947 = handle->type_table;
  free_data_table (D.16947);
  D.16948 = handle->image;
  mono_image_close (D.16948);
  D.16949 = handle->image_file;
  monoeg_g_free (D.16949);
  monoeg_g_free (handle);
}


create_data_table (struct MonoDomain * domain)
{
  int iftmp.17;
  struct GHashTable * D.16954;
  struct GHashTable * D.16955;
  struct MonoDebugDataChunk * D.16956;
  struct MonoSymbolTable * mono_symbol_table.18;
  struct MonoDebugList * * D.16960;
  struct GHashTable * data_table_hash.19;
  struct MonoDebugDataTable * D.16962;
  struct MonoDebugDataTable * table;
  struct MonoDebugDataChunk * chunk;

  table = monoeg_malloc0 (24);
  if (domain != 0B) goto <D.16951>; else goto <D.16952>;
  <D.16951>:
  iftmp.17 = mono_domain_get_id (domain);
  goto <D.16953>;
  <D.16952>:
  iftmp.17 = -1;
  <D.16953>:
  table->domain = iftmp.17;
  D.16954 = monoeg_g_hash_table_new (0B, 0B);
  table->method_address_hash = D.16954;
  D.16955 = monoeg_g_hash_table_new (0B, 0B);
  table->method_hash = D.16955;
  chunk = monoeg_malloc0 (16384);
  chunk->total_size = 16364;
  table->current_chunk = chunk;
  D.16956 = table->current_chunk;
  table->first_chunk = D.16956;
  if (domain != 0B) goto <D.16957>; else goto <D.16958>;
  <D.16957>:
  mono_symbol_table.18 = mono_symbol_table;
  D.16960 = &mono_symbol_table.18->data_tables;
  mono_debug_list_add (D.16960, table);
  data_table_hash.19 = data_table_hash;
  monoeg_g_hash_table_insert_replace (data_table_hash.19, domain, table, 0);
  <D.16958>:
  D.16962 = table;
  return D.16962;
}


_mono_debug_init_corlib (struct MonoDomain * domain)
{
  int mono_debug_initialized.20;
  struct MonoSymbolTable * mono_symbol_table.21;
  struct MonoImage * D.16968;
  struct MonoDebugHandle * D.16969;

  mono_debug_initialized.20 = mono_debug_initialized;
  if (mono_debug_initialized.20 == 0) goto <D.16965>; else goto <D.16966>;
  <D.16965>:
  return;
  <D.16966>:
  mono_symbol_table.21 = mono_symbol_table;
  D.16968 = mono_defaults.corlib;
  D.16969 = mono_debug_open_image (D.16968, 0B, 0);
  mono_symbol_table.21->corlib = D.16969;
}


mono_debug_open_image_from_memory (struct MonoImage * image, const guint8 * raw_contents, int size)
{
  int mono_debug_initialized.22;

  mono_debug_initialized.22 = mono_debug_initialized;
  if (mono_debug_initialized.22 == 0) goto <D.16972>; else goto <D.16973>;
  <D.16972>:
  return;
  <D.16973>:
  mono_debug_open_image (image, raw_contents, size);
}


mono_debug_cleanup ()
{
  struct GHashTable * mono_debug_handles.23;
  struct GHashTable * data_table_hash.24;
  struct MonoSymbolTable * mono_symbol_table.25;
  struct MonoDebugDataTable * D.16984;

  mono_debug_handles.23 = mono_debug_handles;
  if (mono_debug_handles.23 != 0B) goto <D.16976>; else goto <D.16977>;
  <D.16976>:
  mono_debug_handles.23 = mono_debug_handles;
  monoeg_g_hash_table_destroy (mono_debug_handles.23);
  <D.16977>:
  mono_debug_handles = 0B;
  data_table_hash.24 = data_table_hash;
  if (data_table_hash.24 != 0B) goto <D.16979>; else goto <D.16980>;
  <D.16979>:
  data_table_hash.24 = data_table_hash;
  monoeg_g_hash_table_destroy (data_table_hash.24);
  data_table_hash = 0B;
  <D.16980>:
  mono_symbol_table.25 = mono_symbol_table;
  if (mono_symbol_table.25 != 0B) goto <D.16982>; else goto <D.16983>;
  <D.16982>:
  mono_symbol_table.25 = mono_symbol_table;
  D.16984 = mono_symbol_table.25->global_data_table;
  if (D.16984 != 0B) goto <D.16985>; else goto <D.16986>;
  <D.16985>:
  mono_symbol_table.25 = mono_symbol_table;
  D.16984 = mono_symbol_table.25->global_data_table;
  free_data_table (D.16984);
  <D.16986>:
  mono_symbol_table.25 = mono_symbol_table;
  monoeg_g_free (mono_symbol_table.25);
  mono_symbol_table = 0B;
  <D.16983>:
}


mono_debug_domain_create (struct MonoDomain * domain)
{
  int mono_debug_initialized.26;
  struct MonoDebugDataTable * table;

  mono_debug_initialized.26 = mono_debug_initialized;
  if (mono_debug_initialized.26 == 0) goto <D.16988>; else goto <D.16989>;
  <D.16988>:
  return;
  <D.16989>:
  mono_debugger_lock ();
  table = create_data_table (domain);
  mono_debugger_unlock ();
}


mono_debug_domain_unload (struct MonoDomain * domain)
{
  int mono_debug_initialized.27;
  struct GHashTable * data_table_hash.28;
  int D.16997;
  struct MonoDebugDataTable * table;

  mono_debug_initialized.27 = mono_debug_initialized;
  if (mono_debug_initialized.27 == 0) goto <D.16992>; else goto <D.16993>;
  <D.16992>:
  return;
  <D.16993>:
  mono_debugger_lock ();
  data_table_hash.28 = data_table_hash;
  table = monoeg_g_hash_table_lookup (data_table_hash.28, domain);
  if (table == 0B) goto <D.16995>; else goto <D.16996>;
  <D.16995>:
  D.16997 = mono_domain_get_id (domain);
  monoeg_g_log (0B, 16, "mono-debug.c:337:: unloading unknown domain %p / %d", domain, D.16997);
  mono_debugger_unlock ();
  return;
  <D.16996>:
  data_table_hash.28 = data_table_hash;
  monoeg_g_hash_table_remove (data_table_hash.28, domain);
  mono_debugger_unlock ();
}


mono_debug_close_image (struct MonoImage * image)
{
  int mono_debug_initialized.29;
  struct MonoSymbolTable * mono_symbol_table.30;
  struct MonoDebugList * * D.17005;
  struct GHashTable * mono_debug_handles.31;
  struct MonoDebugHandle * handle;

  mono_debug_initialized.29 = mono_debug_initialized;
  if (mono_debug_initialized.29 == 0) goto <D.17000>; else goto <D.17001>;
  <D.17000>:
  return;
  <D.17001>:
  mono_debugger_lock ();
  handle = _mono_debug_get_image (image);
  if (handle == 0B) goto <D.17002>; else goto <D.17003>;
  <D.17002>:
  mono_debugger_unlock ();
  return;
  <D.17003>:
  mono_symbol_table.30 = mono_symbol_table;
  D.17005 = &mono_symbol_table.30->symbol_files;
  mono_debug_list_remove (D.17005, handle);
  mono_debug_handles.31 = mono_debug_handles;
  monoeg_g_hash_table_remove (mono_debug_handles.31, image);
  mono_debugger_unlock ();
}


mono_debug_lookup_method (struct MonoMethod * method)
{
  struct MonoDebugMethodInfo * D.17008;
  struct MonoDebugMethodInfo * minfo;

  mono_debugger_lock ();
  minfo = _mono_debug_lookup_method (method);
  mono_debugger_unlock ();
  D.17008 = minfo;
  return D.17008;
}


_mono_debug_lookup_method (struct MonoMethod * method)
{
  struct GHashTable * mono_debug_handles.32;
  struct MonoDebugMethodInfo * D.17013;
  struct LookupMethodData data;

  try
    {
      data.minfo = 0B;
      data.method = method;
      mono_debug_handles.32 = mono_debug_handles;
      if (mono_debug_handles.32 == 0B) goto <D.17011>; else goto <D.17012>;
      <D.17011>:
      D.17013 = 0B;
      return D.17013;
      <D.17012>:
      mono_debug_handles.32 = mono_debug_handles;
      monoeg_g_hash_table_foreach (mono_debug_handles.32, lookup_method_func, &data);
      D.17013 = data.minfo;
      return D.17013;
    }
  finally
    {
      data = {CLOBBER};
    }
}


lookup_method_func (void * key, void * value, void * user_data)
{
  struct MonoDebugMethodInfo * D.17016;
  struct MonoSymbolFile * D.17019;
  struct MonoMethod * D.17022;
  struct MonoDebugMethodInfo * D.17023;
  struct MonoDebugHandle * handle;
  struct LookupMethodData * data;

  handle = value;
  data = user_data;
  D.17016 = data->minfo;
  if (D.17016 != 0B) goto <D.17017>; else goto <D.17018>;
  <D.17017>:
  return;
  <D.17018>:
  D.17019 = handle->symfile;
  if (D.17019 != 0B) goto <D.17020>; else goto <D.17021>;
  <D.17020>:
  D.17022 = data->method;
  D.17023 = mono_debug_symfile_lookup_method (handle, D.17022);
  data->minfo = D.17023;
  <D.17021>:
}


mono_debug_add_method (struct MonoMethod * method, struct MonoDebugMethodJitInfo * jit, struct MonoDomain * domain)
{
  struct MonoClass * D.17025;
  struct MonoImage * D.17026;
  short unsigned int D.17030;
  unsigned int D.17031;
  unsigned int D.17032;
  short unsigned int D.17034;
  unsigned int D.17035;
  unsigned int D.17036;
  unsigned char D.17038;
  unsigned char D.17039;
  unsigned int D.17040;
  unsigned int D.17041;
  unsigned int D.17042;
  unsigned int D.17043;
  unsigned int D.17044;
  unsigned int D.17045;
  unsigned int D.17046;
  unsigned int D.17047;
  guint8 * ptr.33;
  unsigned int D.17052;
  unsigned int D.17053;
  struct MonoDebugLineNumberEntry * D.17054;
  unsigned int D.17055;
  unsigned int D.17056;
  int D.17057;
  unsigned int D.17058;
  int D.17059;
  guint8 * ptr.34;
  guint8 * ptr.35;
  struct MonoDebugVarInfo * D.17062;
  _Bool D.17063;
  unsigned char D.17064;
  struct MonoDebugVarInfo * D.17067;
  unsigned int D.17068;
  struct MonoDebugVarInfo * D.17069;
  struct MonoDebugVarInfo * D.17070;
  struct MonoDebugVarInfo * D.17071;
  guint8 * ptr.36;
  guint8 * ptr.37;
  struct MonoDebugVarInfo * D.17074;
  _Bool D.17075;
  unsigned char D.17076;
  struct MonoDebugVarInfo * D.17079;
  int ptr.38;
  int oldptr.39;
  int D.17082;
  _Bool D.17083;
  long int D.17084;
  long int D.17085;
  unsigned char D.17088;
  unsigned char D.17089;
  uint32_t iftmp.40;
  int D.17097;
  unsigned int D.17098;
  uint32_t iftmp.41;
  const mono_byte * D.17103;
  unsigned int D.17104;
  guint8[0:] * D.17105;
  struct MonoMethod * iftmp.42;
  unsigned char D.17109;
  struct GHashTable * D.17113;
  <unnamed-unsigned:5> D.17118;
  unsigned int D.17119;
  char * D.17120;
  struct MonoDebugWrapperData * D.17122;
  struct GSList * D.17123;
  struct GSList * D.17124;
  struct GHashTable * D.17125;
  struct MonoDebugMethodAddress * D.17128;
  struct MonoMethod * declaring;
  struct MonoDebugDataTable * table;
  struct MonoDebugMethodHeader * header;
  struct MonoDebugMethodAddress * address;
  struct MonoDebugMethodInfo * minfo;
  struct MonoDebugHandle * handle;
  guint8 buffer[8192];
  guint8 * ptr;
  guint8 * oldptr;
  guint32 i;
  guint32 size;
  guint32 total_size;
  guint32 max_size;
  gboolean is_wrapper;

  try
    {
      is_wrapper = 0;
      mono_debugger_lock ();
      table = lookup_data_table (domain);
      D.17025 = method->klass;
      D.17026 = D.17025->image;
      handle = _mono_debug_get_image (D.17026);
      minfo = _mono_debug_lookup_method (method);
      if (minfo == 0B) goto <D.17027>; else goto <D.17029>;
      <D.17029>:
      D.17030 = method->iflags;
      D.17031 = (unsigned int) D.17030;
      D.17032 = D.17031 & 4099;
      if (D.17032 != 0) goto <D.17027>; else goto <D.17033>;
      <D.17033>:
      D.17034 = method->flags;
      D.17035 = (unsigned int) D.17034;
      D.17036 = D.17035 & 9216;
      if (D.17036 != 0) goto <D.17027>; else goto <D.17037>;
      <D.17037>:
      D.17038 = BIT_FIELD_REF <*method, 8, 160>;
      D.17039 = D.17038 & 124;
      if (D.17039 != 0) goto <D.17027>; else goto <D.17028>;
      <D.17027>:
      is_wrapper = 1;
      <D.17028>:
      D.17040 = jit->num_line_numbers;
      D.17041 = D.17040 * 10;
      D.17042 = jit->num_params;
      D.17043 = jit->num_locals;
      D.17044 = D.17042 + D.17043;
      D.17045 = D.17044 + 1;
      D.17046 = D.17045 * 29;
      D.17047 = D.17041 + D.17046;
      max_size = D.17047 + 26;
      if (max_size > 8192) goto <D.17048>; else goto <D.17049>;
      <D.17048>:
      oldptr = monoeg_malloc (max_size);
      ptr = oldptr;
      goto <D.17050>;
      <D.17049>:
      oldptr = &buffer;
      ptr = oldptr;
      <D.17050>:
      ptr.33 = ptr;
      D.17052 = jit->prologue_end;
      write_leb128 (D.17052, ptr.33, &ptr);
      ptr.33 = ptr;
      D.17053 = jit->epilogue_begin;
      write_leb128 (D.17053, ptr.33, &ptr);
      ptr.33 = ptr;
      D.17040 = jit->num_line_numbers;
      write_leb128 (D.17040, ptr.33, &ptr);
      i = 0;
      goto <D.16585>;
      <D.16584>:
      {
        struct MonoDebugLineNumberEntry * lne;

        D.17054 = jit->line_numbers;
        D.17055 = i * 8;
        lne = D.17054 + D.17055;
        ptr.33 = ptr;
        D.17056 = lne->il_offset;
        D.17057 = (int) D.17056;
        write_sleb128 (D.17057, ptr.33, &ptr);
        ptr.33 = ptr;
        D.17058 = lne->native_offset;
        D.17059 = (int) D.17058;
        write_sleb128 (D.17059, ptr.33, &ptr);
      }
      i = i + 1;
      <D.16585>:
      D.17040 = jit->num_line_numbers;
      if (D.17040 > i) goto <D.16584>; else goto <D.16586>;
      <D.16586>:
      ptr.33 = ptr;
      ptr.34 = ptr.33;
      ptr.35 = ptr.34 + 1;
      ptr = ptr.35;
      D.17062 = jit->this_var;
      D.17063 = D.17062 != 0B;
      D.17064 = (unsigned char) D.17063;
      *ptr.34 = D.17064;
      D.17062 = jit->this_var;
      if (D.17062 != 0B) goto <D.17065>; else goto <D.17066>;
      <D.17065>:
      ptr.33 = ptr;
      D.17062 = jit->this_var;
      write_variable (D.17062, ptr.33, &ptr);
      <D.17066>:
      ptr.33 = ptr;
      D.17042 = jit->num_params;
      write_leb128 (D.17042, ptr.33, &ptr);
      i = 0;
      goto <D.16588>;
      <D.16587>:
      ptr.33 = ptr;
      D.17067 = jit->params;
      D.17068 = i * 24;
      D.17069 = D.17067 + D.17068;
      write_variable (D.17069, ptr.33, &ptr);
      i = i + 1;
      <D.16588>:
      D.17042 = jit->num_params;
      if (D.17042 > i) goto <D.16587>; else goto <D.16589>;
      <D.16589>:
      ptr.33 = ptr;
      D.17043 = jit->num_locals;
      write_leb128 (D.17043, ptr.33, &ptr);
      i = 0;
      goto <D.16591>;
      <D.16590>:
      ptr.33 = ptr;
      D.17070 = jit->locals;
      D.17068 = i * 24;
      D.17071 = D.17070 + D.17068;
      write_variable (D.17071, ptr.33, &ptr);
      i = i + 1;
      <D.16591>:
      D.17043 = jit->num_locals;
      if (D.17043 > i) goto <D.16590>; else goto <D.16592>;
      <D.16592>:
      ptr.33 = ptr;
      ptr.36 = ptr.33;
      ptr.37 = ptr.36 + 1;
      ptr = ptr.37;
      D.17074 = jit->gsharedvt_info_var;
      D.17075 = D.17074 != 0B;
      D.17076 = (unsigned char) D.17075;
      *ptr.36 = D.17076;
      D.17074 = jit->gsharedvt_info_var;
      if (D.17074 != 0B) goto <D.17077>; else goto <D.17078>;
      <D.17077>:
      ptr.33 = ptr;
      D.17074 = jit->gsharedvt_info_var;
      write_variable (D.17074, ptr.33, &ptr);
      ptr.33 = ptr;
      D.17079 = jit->gsharedvt_locals_var;
      write_variable (D.17079, ptr.33, &ptr);
      <D.17078>:
      ptr.33 = ptr;
      ptr.38 = (int) ptr.33;
      oldptr.39 = (int) oldptr;
      D.17082 = ptr.38 - oldptr.39;
      size = (guint32) D.17082;
      D.17083 = size >= max_size;
      D.17084 = (long int) D.17083;
      D.17085 = __builtin_expect (D.17084, 0);
      if (D.17085 != 0) goto <D.17086>; else goto <D.17087>;
      <D.17086>:
      monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "mono-debug.c", 639, "size < max_size");
      <D.17087>:
      total_size = size + 40;
      D.17088 = BIT_FIELD_REF <*method, 8, 168>;
      D.17089 = D.17088 & 2;
      if (D.17089 != 0) goto <D.17090>; else goto <D.17091>;
      <D.17090>:
      address = monoeg_malloc0 (total_size);
      goto <D.17092>;
      <D.17091>:
      address = allocate_data_item (table, 2, total_size);
      <D.17092>:
      address->header.size = total_size;
      if (handle != 0B) goto <D.17094>; else goto <D.17095>;
      <D.17094>:
      iftmp.40 = handle->index;
      goto <D.17096>;
      <D.17095>:
      iftmp.40 = 0;
      <D.17096>:
      address->header.symfile_id = iftmp.40;
      D.17097 = mono_domain_get_id (domain);
      D.17098 = (unsigned int) D.17097;
      address->header.domain_id = D.17098;
      if (is_wrapper == 0) goto <D.17100>; else goto <D.17101>;
      <D.17100>:
      iftmp.41 = minfo->index;
      goto <D.17102>;
      <D.17101>:
      iftmp.41 = 0;
      <D.17102>:
      address->header.method_id = iftmp.41;
      address->header.method = method;
      D.17103 = jit->code_start;
      address->code_start = D.17103;
      D.17104 = jit->code_size;
      address->code_size = D.17104;
      D.17105 = &address->data;
      memcpy (D.17105, oldptr, size);
      if (max_size > 8192) goto <D.17106>; else goto <D.17107>;
      <D.17106>:
      monoeg_g_free (oldptr);
      <D.17107>:
      D.17088 = BIT_FIELD_REF <*method, 8, 168>;
      D.17109 = D.17088 & 16;
      if (D.17109 != 0) goto <D.17110>; else goto <D.17111>;
      <D.17110>:
      iftmp.42 = MEM[(struct MonoMethodInflated *)method].declaring;
      goto <D.17112>;
      <D.17111>:
      iftmp.42 = method;
      <D.17112>:
      declaring = iftmp.42;
      D.17113 = table->method_hash;
      header = monoeg_g_hash_table_lookup (D.17113, declaring);
      if (header == 0B) goto <D.17114>; else goto <D.17115>;
      <D.17114>:
      header = &address->header;
      D.17113 = table->method_hash;
      monoeg_g_hash_table_insert_replace (D.17113, declaring, header, 0);
      if (is_wrapper != 0) goto <D.17116>; else goto <D.17117>;
      <D.17116>:
      {
        struct MonoDebugWrapperData * wrapper;

        wrapper = monoeg_malloc0 (12);
        header->wrapper_data = wrapper;
        D.17118 = method->wrapper_type;
        D.17119 = (unsigned int) D.17118;
        wrapper->wrapper_type = D.17119;
        D.17120 = mono_method_full_name (declaring, 1);
        wrapper->method_name = D.17120;
        wrapper->obsolete_cil_code = "";
      }
      <D.17117>:
      goto <D.17121>;
      <D.17115>:
      D.17122 = header->wrapper_data;
      address->header.wrapper_data = D.17122;
      D.17123 = header->address_list;
      D.17124 = monoeg_g_slist_prepend (D.17123, address);
      header->address_list = D.17124;
      <D.17121>:
      D.17125 = table->method_address_hash;
      monoeg_g_hash_table_insert_replace (D.17125, method, address, 0);
      D.17088 = BIT_FIELD_REF <*method, 8, 168>;
      D.17089 = D.17088 & 2;
      if (D.17089 == 0) goto <D.17126>; else goto <D.17127>;
      <D.17126>:
      write_data_item (table, address);
      <D.17127>:
      mono_debugger_unlock ();
      D.17128 = address;
      return D.17128;
    }
  finally
    {
      buffer = {CLOBBER};
      ptr = {CLOBBER};
    }
}


lookup_data_table (struct MonoDomain * domain)
{
  struct GHashTable * data_table_hash.43;
  _Bool D.17134;
  long int D.17135;
  long int D.17136;
  struct MonoDebugDataTable * D.17139;
  struct MonoDebugDataTable * table;

  data_table_hash.43 = data_table_hash;
  table = monoeg_g_hash_table_lookup (data_table_hash.43, domain);
  if (table == 0B) goto <D.17132>; else goto <D.17133>;
  <D.17132>:
  monoeg_g_log (0B, 4, "lookup_data_table () failed for %p\n", domain);
  <D.16463>:
  goto <D.16463>;
  D.17134 = table == 0B;
  D.17135 = (long int) D.17134;
  D.17136 = __builtin_expect (D.17135, 0);
  if (D.17136 != 0) goto <D.17137>; else goto <D.17138>;
  <D.17137>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "mono-debug.c", 201, "table");
  <D.17138>:
  <D.17133>:
  D.17139 = table;
  return D.17139;
}


write_sleb128 (gint32 value, guint8 * ptr, guint8 * * rptr)
{
  unsigned char D.17141;
  int D.17147;
  int D.17148;
  guint8 * ptr.44;
  gboolean more;

  more = 1;
  goto <D.16557>;
  <D.16556>:
  {
    guint8 byte;

    D.17141 = (unsigned char) value;
    byte = D.17141 & 127;
    value = value >> 7;
    if (value == 0) goto <D.17146>; else goto <D.17142>;
    <D.17146>:
    D.17147 = (int) byte;
    D.17148 = D.17147 & 64;
    if (D.17148 == 0) goto <D.17143>; else goto <D.17142>;
    <D.17142>:
    if (value == -1) goto <D.17149>; else goto <D.17144>;
    <D.17149>:
    D.17147 = (int) byte;
    D.17148 = D.17147 & 64;
    if (D.17148 != 0) goto <D.17143>; else goto <D.17144>;
    <D.17143>:
    more = 0;
    goto <D.17145>;
    <D.17144>:
    byte = byte | 128;
    <D.17145>:
    ptr.44 = ptr;
    ptr = ptr.44 + 1;
    *ptr.44 = byte;
  }
  <D.16557>:
  if (more != 0) goto <D.16556>; else goto <D.16558>;
  <D.16558>:
  *rptr = ptr;
}


write_variable (struct MonoDebugVarInfo * var, guint8 * ptr, guint8 * * rptr)
{
  guint8 * ptr.45;
  unsigned int D.17152;
  unsigned int D.17153;
  int D.17154;
  unsigned int D.17155;
  unsigned int D.17156;
  unsigned int D.17157;
  struct MonoType * D.17158;
  guint8 * ptr.46;

  ptr.45 = ptr;
  D.17152 = var->index;
  write_leb128 (D.17152, ptr.45, &ptr);
  ptr.45 = ptr;
  D.17153 = var->offset;
  D.17154 = (int) D.17153;
  write_sleb128 (D.17154, ptr.45, &ptr);
  ptr.45 = ptr;
  D.17155 = var->size;
  write_leb128 (D.17155, ptr.45, &ptr);
  ptr.45 = ptr;
  D.17156 = var->begin_scope;
  write_leb128 (D.17156, ptr.45, &ptr);
  ptr.45 = ptr;
  D.17157 = var->end_scope;
  write_leb128 (D.17157, ptr.45, &ptr);
  ptr.45 = ptr;
  D.17158 = var->type;
  MEM[(void * *)ptr.45] = D.17158;
  ptr.45 = ptr;
  ptr.46 = ptr.45 + 4;
  ptr = ptr.46;
  ptr.45 = ptr;
  *rptr = ptr.45;
}


mono_debug_remove_method (struct MonoMethod * method, struct MonoDomain * domain)
{
  int mono_debug_initialized.47;
  unsigned char D.17163;
  unsigned char D.17164;
  _Bool D.17165;
  long int D.17166;
  long int D.17167;
  struct MonoMethod * iftmp.48;
  unsigned char D.17171;
  struct GHashTable * D.17175;
  struct GHashTable * D.17176;
  struct MonoDebugWrapperData * D.17179;
  const gchar * D.17182;
  struct MonoMethod * declaring;
  struct MonoDebugDataTable * table;
  struct MonoDebugMethodHeader * header;
  struct MonoDebugMethodAddress * address;

  mono_debug_initialized.47 = mono_debug_initialized;
  if (mono_debug_initialized.47 == 0) goto <D.17161>; else goto <D.17162>;
  <D.17161>:
  return;
  <D.17162>:
  D.17163 = BIT_FIELD_REF <*method, 8, 168>;
  D.17164 = D.17163 & 2;
  D.17165 = D.17164 == 0;
  D.17166 = (long int) D.17165;
  D.17167 = __builtin_expect (D.17166, 0);
  if (D.17167 != 0) goto <D.17168>; else goto <D.17169>;
  <D.17168>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "mono-debug.c", 703, "method->dynamic");
  <D.17169>:
  mono_debugger_lock ();
  table = lookup_data_table (domain);
  D.17163 = BIT_FIELD_REF <*method, 8, 168>;
  D.17171 = D.17163 & 16;
  if (D.17171 != 0) goto <D.17172>; else goto <D.17173>;
  <D.17172>:
  iftmp.48 = MEM[(struct MonoMethodInflated *)method].declaring;
  goto <D.17174>;
  <D.17173>:
  iftmp.48 = method;
  <D.17174>:
  declaring = iftmp.48;
  D.17175 = table->method_hash;
  monoeg_g_hash_table_remove (D.17175, declaring);
  D.17176 = table->method_address_hash;
  address = monoeg_g_hash_table_lookup (D.17176, method);
  if (address != 0B) goto <D.17177>; else goto <D.17178>;
  <D.17177>:
  header = &address->header;
  D.17179 = header->wrapper_data;
  if (D.17179 != 0B) goto <D.17180>; else goto <D.17181>;
  <D.17180>:
  D.17179 = header->wrapper_data;
  D.17182 = D.17179->method_name;
  monoeg_g_free (D.17182);
  D.17179 = header->wrapper_data;
  monoeg_g_free (D.17179);
  <D.17181>:
  monoeg_g_free (address);
  <D.17178>:
  D.17176 = table->method_address_hash;
  monoeg_g_hash_table_remove (D.17176, method);
  mono_debugger_unlock ();
}


mono_debug_add_delegate_trampoline (void * code, int size)
{
  int mono_debug_initialized.49;
  struct MonoSymbolTable * mono_symbol_table.50;
  struct MonoDebugDataTable * D.17188;
  unsigned int size.51;
  struct MonoDebugDelegateTrampolineEntry * entry;

  mono_debug_initialized.49 = mono_debug_initialized;
  if (mono_debug_initialized.49 == 0) goto <D.17185>; else goto <D.17186>;
  <D.17185>:
  return;
  <D.17186>:
  mono_debugger_lock ();
  mono_symbol_table.50 = mono_symbol_table;
  D.17188 = mono_symbol_table.50->global_data_table;
  entry = allocate_data_item (D.17188, 3, 8);
  entry->code = code;
  size.51 = (unsigned int) size;
  entry->size = size.51;
  mono_symbol_table.50 = mono_symbol_table;
  D.17188 = mono_symbol_table.50->global_data_table;
  write_data_item (D.17188, entry);
  mono_debugger_unlock ();
}


mono_debug_free_method_jit_info (struct MonoDebugMethodJitInfo * jit)
{
  struct MonoDebugLineNumberEntry * D.17193;
  struct MonoDebugVarInfo * D.17194;
  struct MonoDebugVarInfo * D.17195;
  struct MonoDebugVarInfo * D.17196;
  struct MonoDebugVarInfo * D.17197;
  struct MonoDebugVarInfo * D.17198;

  if (jit == 0B) goto <D.17191>; else goto <D.17192>;
  <D.17191>:
  return;
  <D.17192>:
  D.17193 = jit->line_numbers;
  monoeg_g_free (D.17193);
  D.17194 = jit->this_var;
  monoeg_g_free (D.17194);
  D.17195 = jit->params;
  monoeg_g_free (D.17195);
  D.17196 = jit->locals;
  monoeg_g_free (D.17196);
  D.17197 = jit->gsharedvt_info_var;
  monoeg_g_free (D.17197);
  D.17198 = jit->gsharedvt_locals_var;
  monoeg_g_free (D.17198);
  monoeg_g_free (jit);
}


mono_debug_find_method (struct MonoMethod * method, struct MonoDomain * domain)
{
  <unnamed type> mono_debug_format.52;
  struct MonoDebugMethodJitInfo * D.17203;
  struct MonoDebugMethodJitInfo * res;

  mono_debug_format.52 = mono_debug_format;
  if (mono_debug_format.52 == 0) goto <D.17201>; else goto <D.17202>;
  <D.17201>:
  D.17203 = 0B;
  return D.17203;
  <D.17202>:
  mono_debugger_lock ();
  res = find_method (method, domain);
  mono_debugger_unlock ();
  D.17203 = res;
  return D.17203;
}


find_method (struct MonoMethod * method, struct MonoDomain * domain)
{
  struct GHashTable * D.17205;
  struct MonoDebugMethodJitInfo * D.17208;
  struct MonoDebugDataTable * table;
  struct MonoDebugMethodAddress * address;

  table = lookup_data_table (domain);
  D.17205 = table->method_address_hash;
  address = monoeg_g_hash_table_lookup (D.17205, method);
  if (address == 0B) goto <D.17206>; else goto <D.17207>;
  <D.17206>:
  D.17208 = 0B;
  return D.17208;
  <D.17207>:
  D.17208 = mono_debug_read_method (address);
  return D.17208;
}


mono_debug_read_method (struct MonoDebugMethodAddress * address)
{
  const guint8 * D.17210;
  unsigned int D.17211;
  const guint8 * D.17212;
  guint8[0:] * ptr.53;
  guint8 * ptr.54;
  unsigned int D.17215;
  unsigned int D.17216;
  unsigned int D.17217;
  unsigned int D.17218;
  unsigned int D.17219;
  void * D.17220;
  struct MonoDebugLineNumberEntry * D.17221;
  unsigned int D.17222;
  int D.17223;
  unsigned int D.17224;
  int D.17225;
  unsigned int D.17226;
  guint8 * ptr.55;
  guint8 * ptr.56;
  unsigned char D.17229;
  void * D.17232;
  struct MonoDebugVarInfo * D.17233;
  unsigned int D.17234;
  unsigned int D.17235;
  unsigned int D.17236;
  void * D.17237;
  struct MonoDebugVarInfo * D.17238;
  unsigned int D.17239;
  struct MonoDebugVarInfo * D.17240;
  unsigned int D.17241;
  unsigned int D.17242;
  unsigned int D.17243;
  void * D.17244;
  struct MonoDebugVarInfo * D.17245;
  struct MonoDebugVarInfo * D.17246;
  guint8 * ptr.57;
  guint8 * ptr.58;
  unsigned char D.17249;
  void * D.17252;
  void * D.17253;
  struct MonoDebugVarInfo * D.17254;
  struct MonoDebugVarInfo * D.17255;
  struct MonoDebugMethodJitInfo * D.17256;
  struct MonoDebugMethodJitInfo * jit;
  guint32 i;
  guint8 * ptr;

  try
    {
      jit = monoeg_malloc0 (56);
      D.17210 = address->code_start;
      jit->code_start = D.17210;
      D.17211 = address->code_size;
      jit->code_size = D.17211;
      D.17212 = address->wrapper_addr;
      jit->wrapper_addr = D.17212;
      ptr.53 = &address->data;
      ptr = ptr.53;
      ptr.54 = ptr;
      D.17215 = read_leb128 (ptr.54, &ptr);
      jit->prologue_end = D.17215;
      ptr.54 = ptr;
      D.17216 = read_leb128 (ptr.54, &ptr);
      jit->epilogue_begin = D.17216;
      ptr.54 = ptr;
      D.17217 = read_leb128 (ptr.54, &ptr);
      jit->num_line_numbers = D.17217;
      D.17218 = jit->num_line_numbers;
      D.17219 = D.17218 * 8;
      D.17220 = monoeg_malloc0 (D.17219);
      jit->line_numbers = D.17220;
      i = 0;
      goto <D.16642>;
      <D.16641>:
      {
        struct MonoDebugLineNumberEntry * lne;

        D.17221 = jit->line_numbers;
        D.17222 = i * 8;
        lne = D.17221 + D.17222;
        ptr.54 = ptr;
        D.17223 = read_sleb128 (ptr.54, &ptr);
        D.17224 = (unsigned int) D.17223;
        lne->il_offset = D.17224;
        ptr.54 = ptr;
        D.17225 = read_sleb128 (ptr.54, &ptr);
        D.17226 = (unsigned int) D.17225;
        lne->native_offset = D.17226;
      }
      i = i + 1;
      <D.16642>:
      D.17218 = jit->num_line_numbers;
      if (D.17218 > i) goto <D.16641>; else goto <D.16643>;
      <D.16643>:
      ptr.54 = ptr;
      ptr.55 = ptr.54;
      ptr.56 = ptr.55 + 1;
      ptr = ptr.56;
      D.17229 = *ptr.55;
      if (D.17229 != 0) goto <D.17230>; else goto <D.17231>;
      <D.17230>:
      D.17232 = monoeg_malloc0 (24);
      jit->this_var = D.17232;
      ptr.54 = ptr;
      D.17233 = jit->this_var;
      read_variable (D.17233, ptr.54, &ptr);
      <D.17231>:
      ptr.54 = ptr;
      D.17234 = read_leb128 (ptr.54, &ptr);
      jit->num_params = D.17234;
      D.17235 = jit->num_params;
      D.17236 = D.17235 * 24;
      D.17237 = monoeg_malloc0 (D.17236);
      jit->params = D.17237;
      i = 0;
      goto <D.16645>;
      <D.16644>:
      ptr.54 = ptr;
      D.17238 = jit->params;
      D.17239 = i * 24;
      D.17240 = D.17238 + D.17239;
      read_variable (D.17240, ptr.54, &ptr);
      i = i + 1;
      <D.16645>:
      D.17235 = jit->num_params;
      if (D.17235 > i) goto <D.16644>; else goto <D.16646>;
      <D.16646>:
      ptr.54 = ptr;
      D.17241 = read_leb128 (ptr.54, &ptr);
      jit->num_locals = D.17241;
      D.17242 = jit->num_locals;
      D.17243 = D.17242 * 24;
      D.17244 = monoeg_malloc0 (D.17243);
      jit->locals = D.17244;
      i = 0;
      goto <D.16648>;
      <D.16647>:
      ptr.54 = ptr;
      D.17245 = jit->locals;
      D.17239 = i * 24;
      D.17246 = D.17245 + D.17239;
      read_variable (D.17246, ptr.54, &ptr);
      i = i + 1;
      <D.16648>:
      D.17242 = jit->num_locals;
      if (D.17242 > i) goto <D.16647>; else goto <D.16649>;
      <D.16649>:
      ptr.54 = ptr;
      ptr.57 = ptr.54;
      ptr.58 = ptr.57 + 1;
      ptr = ptr.58;
      D.17249 = *ptr.57;
      if (D.17249 != 0) goto <D.17250>; else goto <D.17251>;
      <D.17250>:
      D.17252 = monoeg_malloc0 (24);
      jit->gsharedvt_info_var = D.17252;
      D.17253 = monoeg_malloc0 (24);
      jit->gsharedvt_locals_var = D.17253;
      ptr.54 = ptr;
      D.17254 = jit->gsharedvt_info_var;
      read_variable (D.17254, ptr.54, &ptr);
      ptr.54 = ptr;
      D.17255 = jit->gsharedvt_locals_var;
      read_variable (D.17255, ptr.54, &ptr);
      <D.17251>:
      D.17256 = jit;
      return D.17256;
    }
  finally
    {
      ptr = {CLOBBER};
    }
}


read_sleb128 (guint8 * ptr, guint8 * * rptr)
{
  guint8 * ptr.59;
  int D.17260;
  int D.17261;
  int shift.60;
  int D.17263;
  signed char byte.61;
  int D.17269;
  int D.17272;
  int D.17273;
  gint32 D.17274;
  gint32 result;
  guint32 shift;

  result = 0;
  shift = 0;
  <D.16625>:
  {
    guint8 byte;

    ptr.59 = ptr;
    ptr = ptr.59 + 1;
    byte = *ptr.59;
    D.17260 = (int) byte;
    D.17261 = D.17260 & 127;
    shift.60 = (int) shift;
    D.17263 = D.17261 << shift.60;
    result = D.17263 | result;
    shift = shift + 7;
    byte.61 = (signed char) byte;
    if (byte.61 < 0) goto <D.17265>; else goto <D.17266>;
    <D.17265>:
    // predicted unlikely by continue predictor.
    goto <D.16623>;
    <D.17266>:
    if (shift <= 31) goto <D.17267>; else goto <D.17268>;
    <D.17267>:
    D.17260 = (int) byte;
    D.17269 = D.17260 & 64;
    if (D.17269 != 0) goto <D.17270>; else goto <D.17271>;
    <D.17270>:
    shift.60 = (int) shift;
    D.17272 = 1 << shift.60;
    D.17273 = -D.17272;
    result = D.17273 | result;
    <D.17271>:
    <D.17268>:
    goto <D.16624>;
  }
  <D.16623>:
  goto <D.16625>;
  <D.16624>:
  *rptr = ptr;
  D.17274 = result;
  return D.17274;
}


read_leb128 (guint8 * ptr, guint8 * * rptr)
{
  guint8 * ptr.62;
  int D.17277;
  int D.17278;
  int shift.63;
  int D.17280;
  unsigned int D.17281;
  signed char byte.64;
  guint32 D.17284;
  guint32 result;
  guint32 shift;

  result = 0;
  shift = 0;
  <D.16615>:
  {
    guint8 byte;

    ptr.62 = ptr;
    ptr = ptr.62 + 1;
    byte = *ptr.62;
    D.17277 = (int) byte;
    D.17278 = D.17277 & 127;
    shift.63 = (int) shift;
    D.17280 = D.17278 << shift.63;
    D.17281 = (unsigned int) D.17280;
    result = D.17281 | result;
    byte.64 = (signed char) byte;
    if (byte.64 >= 0) goto <D.16614>; else goto <D.17283>;
    <D.17283>:
    shift = shift + 7;
  }
  goto <D.16615>;
  <D.16614>:
  *rptr = ptr;
  D.17284 = result;
  return D.17284;
}


read_variable (struct MonoDebugVarInfo * var, guint8 * ptr, guint8 * * rptr)
{
  guint8 * ptr.65;
  unsigned int D.17287;
  int D.17288;
  unsigned int D.17289;
  unsigned int D.17290;
  unsigned int D.17291;
  unsigned int D.17292;
  void * D.17293;
  guint8 * ptr.66;

  ptr.65 = ptr;
  D.17287 = read_leb128 (ptr.65, &ptr);
  var->index = D.17287;
  ptr.65 = ptr;
  D.17288 = read_sleb128 (ptr.65, &ptr);
  D.17289 = (unsigned int) D.17288;
  var->offset = D.17289;
  ptr.65 = ptr;
  D.17290 = read_leb128 (ptr.65, &ptr);
  var->size = D.17290;
  ptr.65 = ptr;
  D.17291 = read_leb128 (ptr.65, &ptr);
  var->begin_scope = D.17291;
  ptr.65 = ptr;
  D.17292 = read_leb128 (ptr.65, &ptr);
  var->end_scope = D.17292;
  ptr.65 = ptr;
  D.17293 = MEM[(void * *)ptr.65];
  var->type = D.17293;
  ptr.65 = ptr;
  ptr.66 = ptr.65 + 4;
  ptr = ptr.66;
  ptr.65 = ptr;
  *rptr = ptr.65;
}


mono_debug_lookup_method_addresses (struct MonoMethod * method)
{
  int mono_debug_debugger_version.67;
  unsigned int mono_debug_debugger_version.68;
  unsigned int D.17297;
  _Bool D.17298;
  long int D.17299;
  long int D.17300;
  struct MonoMethod * iftmp.69;
  unsigned char D.17304;
  unsigned char D.17305;
  struct GHashTable * data_table_hash.70;
  struct MonoDebugMethodAddressList * D.17312;
  struct GSList * D.17313;
  unsigned int D.17314;
  unsigned int D.17315;
  unsigned int count.71;
  unsigned int D.17317;
  unsigned int D.17318;
  unsigned int size.72;
  unsigned int size.73;
  unsigned int count.74;
  void * D.17322;
  struct MonoDebugMethodAddressList * info;
  struct MonoDebugMethodHeader * header;
  struct LookupMethodAddressData data;
  struct MonoMethod * declaring;
  int count;
  int size;
  struct GSList * list;
  guint8 * ptr;

  try
    {
      header = 0B;
      mono_debug_debugger_version.67 = mono_debug_debugger_version;
      mono_debug_debugger_version.68 = (unsigned int) mono_debug_debugger_version.67;
      D.17297 = mono_debug_debugger_version.68 + 4294967292;
      D.17298 = D.17297 > 1;
      D.17299 = (long int) D.17298;
      D.17300 = __builtin_expect (D.17299, 0);
      if (D.17300 != 0) goto <D.17301>; else goto <D.17302>;
      <D.17301>:
      monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "mono-debug.c", 984, "(mono_debug_debugger_version == 4) || (mono_debug_debugger_version == 5)");
      <D.17302>:
      mono_debugger_lock ();
      D.17304 = BIT_FIELD_REF <*method, 8, 168>;
      D.17305 = D.17304 & 16;
      if (D.17305 != 0) goto <D.17306>; else goto <D.17307>;
      <D.17306>:
      iftmp.69 = MEM[(struct MonoMethodInflated *)method].declaring;
      goto <D.17308>;
      <D.17307>:
      iftmp.69 = method;
      <D.17308>:
      declaring = iftmp.69;
      data.method = declaring;
      data.result = 0B;
      data_table_hash.70 = data_table_hash;
      monoeg_g_hash_table_foreach (data_table_hash.70, lookup_method_address_func, &data);
      header = data.result;
      if (header == 0B) goto <D.17310>; else goto <D.17311>;
      <D.17310>:
      mono_debugger_unlock ();
      D.17312 = 0B;
      return D.17312;
      <D.17311>:
      D.17313 = header->address_list;
      D.17314 = monoeg_g_slist_length (D.17313);
      D.17315 = D.17314 + 1;
      count = (int) D.17315;
      count.71 = (unsigned int) count;
      D.17317 = count.71 + 2;
      D.17318 = D.17317 * 4;
      size = (int) D.17318;
      size.72 = (unsigned int) size;
      info = monoeg_malloc0 (size.72);
      size.73 = (unsigned int) size;
      info->size = size.73;
      count.74 = (unsigned int) count;
      info->count = count.74;
      ptr = &info->data;
      MEM[(void * *)ptr] = header;
      ptr = ptr + 4;
      list = header->address_list;
      goto <D.16696>;
      <D.16695>:
      D.17322 = list->data;
      MEM[(void * *)ptr] = D.17322;
      ptr = ptr + 4;
      list = list->next;
      <D.16696>:
      if (list != 0B) goto <D.16695>; else goto <D.16697>;
      <D.16697>:
      mono_debugger_unlock ();
      D.17312 = info;
      return D.17312;
    }
  finally
    {
      data = {CLOBBER};
    }
}


lookup_method_address_func (void * key, void * value, void * user_data)
{
  struct MonoMethod * D.17325;
  struct GHashTable * D.17326;
  struct MonoDebugDataTable * table;
  struct LookupMethodAddressData * data;
  struct MonoDebugMethodHeader * header;

  table = value;
  data = user_data;
  D.17325 = data->method;
  D.17326 = table->method_hash;
  header = monoeg_g_hash_table_lookup (D.17326, D.17325);
  if (header != 0B) goto <D.17327>; else goto <D.17328>;
  <D.17327>:
  data->result = header;
  <D.17328>:
}


mono_debug_il_offset_from_address (struct MonoMethod * method, struct MonoDomain * domain, guint32 native_offset)
{
  int32_t D.17329;
  gint32 res;

  mono_debugger_lock ();
  res = il_offset_from_address (method, domain, native_offset);
  mono_debugger_unlock ();
  D.17329 = res;
  return D.17329;
}


il_offset_from_address (struct MonoMethod * method, struct MonoDomain * domain, guint32 native_offset)
{
  struct MonoDebugLineNumberEntry * D.17332;
  unsigned int D.17334;
  unsigned int D.17335;
  unsigned int i.75;
  unsigned int D.17337;
  struct MonoDebugLineNumberEntry * D.17338;
  unsigned int D.17339;
  gint32 D.17342;
  unsigned int D.17343;
  struct MonoDebugMethodJitInfo * jit;
  int i;
  void cleanup_and_fail = <<< error >>>;

  jit = find_method (method, domain);
  if (jit == 0B) goto cleanup_and_fail; else goto <D.17331>;
  <D.17331>:
  D.17332 = jit->line_numbers;
  if (D.17332 == 0B) goto cleanup_and_fail; else goto <D.17333>;
  <D.17333>:
  D.17334 = jit->num_line_numbers;
  D.17335 = D.17334 + 4294967295;
  i = (int) D.17335;
  goto <D.16708>;
  <D.16707>:
  {
    struct MonoDebugLineNumberEntry lne;

    try
      {
        D.17332 = jit->line_numbers;
        i.75 = (unsigned int) i;
        D.17337 = i.75 * 8;
        D.17338 = D.17332 + D.17337;
        lne = *D.17338;
        D.17339 = lne.native_offset;
        if (D.17339 <= native_offset) goto <D.17340>; else goto <D.17341>;
        <D.17340>:
        mono_debug_free_method_jit_info (jit);
        D.17343 = lne.il_offset;
        D.17342 = (gint32) D.17343;
        return D.17342;
        <D.17341>:
      }
    finally
      {
        lne = {CLOBBER};
      }
  }
  i = i + -1;
  <D.16708>:
  if (i >= 0) goto <D.16707>; else goto <D.16709>;
  <D.16709>:
  cleanup_and_fail:
  mono_debug_free_method_jit_info (jit);
  D.17342 = -1;
  return D.17342;
}


mono_debug_lookup_source_location (struct MonoMethod * method, guint32 address, struct MonoDomain * domain)
{
  <unnamed type> mono_debug_format.76;
  struct MonoDebugSourceLocation * D.17350;
  struct MonoDebugHandle * D.17354;
  struct MonoSymbolFile * D.17356;
  int D.17358;
  unsigned int offset.77;
  struct MonoDebugMethodInfo * minfo;
  struct MonoDebugSourceLocation * location;
  gint32 offset;

  mono_debug_format.76 = mono_debug_format;
  if (mono_debug_format.76 == 0) goto <D.17348>; else goto <D.17349>;
  <D.17348>:
  D.17350 = 0B;
  return D.17350;
  <D.17349>:
  mono_debugger_lock ();
  minfo = _mono_debug_lookup_method (method);
  if (minfo == 0B) goto <D.17351>; else goto <D.17353>;
  <D.17353>:
  D.17354 = minfo->handle;
  if (D.17354 == 0B) goto <D.17351>; else goto <D.17355>;
  <D.17355>:
  D.17354 = minfo->handle;
  D.17356 = D.17354->symfile;
  if (D.17356 == 0B) goto <D.17351>; else goto <D.17357>;
  <D.17357>:
  D.17354 = minfo->handle;
  D.17356 = D.17354->symfile;
  D.17358 = mono_debug_symfile_is_loaded (D.17356);
  if (D.17358 == 0) goto <D.17351>; else goto <D.17352>;
  <D.17351>:
  mono_debugger_unlock ();
  D.17350 = 0B;
  return D.17350;
  <D.17352>:
  offset = il_offset_from_address (method, domain, address);
  if (offset < 0) goto <D.17359>; else goto <D.17360>;
  <D.17359>:
  mono_debugger_unlock ();
  D.17350 = 0B;
  return D.17350;
  <D.17360>:
  offset.77 = (unsigned int) offset;
  location = mono_debug_symfile_lookup_location (minfo, offset.77);
  mono_debugger_unlock ();
  D.17350 = location;
  return D.17350;
}


mono_debug_lookup_locals (struct MonoMethod * method)
{
  <unnamed type> mono_debug_format.78;
  struct MonoDebugLocalsInfo * D.17366;
  struct MonoDebugHandle * D.17370;
  struct MonoSymbolFile * D.17372;
  int D.17374;
  struct MonoDebugMethodInfo * minfo;
  struct MonoDebugLocalsInfo * res;

  mono_debug_format.78 = mono_debug_format;
  if (mono_debug_format.78 == 0) goto <D.17364>; else goto <D.17365>;
  <D.17364>:
  D.17366 = 0B;
  return D.17366;
  <D.17365>:
  mono_debugger_lock ();
  minfo = _mono_debug_lookup_method (method);
  if (minfo == 0B) goto <D.17367>; else goto <D.17369>;
  <D.17369>:
  D.17370 = minfo->handle;
  if (D.17370 == 0B) goto <D.17367>; else goto <D.17371>;
  <D.17371>:
  D.17370 = minfo->handle;
  D.17372 = D.17370->symfile;
  if (D.17372 == 0B) goto <D.17367>; else goto <D.17373>;
  <D.17373>:
  D.17370 = minfo->handle;
  D.17372 = D.17370->symfile;
  D.17374 = mono_debug_symfile_is_loaded (D.17372);
  if (D.17374 == 0) goto <D.17367>; else goto <D.17368>;
  <D.17367>:
  mono_debugger_unlock ();
  D.17366 = 0B;
  return D.17366;
  <D.17368>:
  res = mono_debug_symfile_lookup_locals (minfo);
  mono_debugger_unlock ();
  D.17366 = res;
  return D.17366;
}


mono_debug_free_source_location (struct MonoDebugSourceLocation * location)
{
  char * D.17378;

  if (location != 0B) goto <D.17376>; else goto <D.17377>;
  <D.17376>:
  D.17378 = location->source_file;
  monoeg_g_free (D.17378);
  monoeg_g_free (location);
  <D.17377>:
}


mono_debug_print_stack_frame (struct MonoMethod * method, guint32 native_offset, struct MonoDomain * domain)
{
  char D.17379;
  int mono_debug_initialized.79;
  char * D.17391;
  unsigned int D.17392;
  char * D.17393;
  unsigned int D.17394;
  struct MonoDebugSourceLocation * location;
  gchar * fname;
  gchar * ptr;
  gchar * res;
  int offset;

  fname = mono_method_full_name (method, 1);
  ptr = fname;
  goto <D.16743>;
  <D.16742>:
  D.17379 = *ptr;
  if (D.17379 == 58) goto <D.17380>; else goto <D.17381>;
  <D.17380>:
  *ptr = 46;
  <D.17381>:
  ptr = ptr + 1;
  <D.16743>:
  D.17379 = *ptr;
  if (D.17379 != 0) goto <D.16742>; else goto <D.16744>;
  <D.16744>:
  location = mono_debug_lookup_source_location (method, native_offset, domain);
  if (location == 0B) goto <D.17382>; else goto <D.17383>;
  <D.17382>:
  mono_debug_initialized.79 = mono_debug_initialized;
  if (mono_debug_initialized.79 != 0) goto <D.17385>; else goto <D.17386>;
  <D.17385>:
  mono_debugger_lock ();
  offset = il_offset_from_address (method, domain, native_offset);
  mono_debugger_unlock ();
  goto <D.17387>;
  <D.17386>:
  offset = -1;
  <D.17387>:
  if (offset < 0) goto <D.17388>; else goto <D.17389>;
  <D.17388>:
  res = monoeg_g_strdup_printf ("at %s <0x%05x>", fname, native_offset);
  goto <D.17390>;
  <D.17389>:
  res = monoeg_g_strdup_printf ("at %s <IL 0x%05x, 0x%05x>", fname, offset, native_offset);
  <D.17390>:
  monoeg_g_free (fname);
  D.17391 = res;
  return D.17391;
  <D.17383>:
  D.17392 = location->row;
  D.17393 = location->source_file;
  D.17394 = location->il_offset;
  res = monoeg_g_strdup_printf ("at %s [0x%05x] in %s:%d", fname, D.17394, D.17393, D.17392);
  monoeg_g_free (fname);
  mono_debug_free_source_location (location);
  D.17391 = res;
  return D.17391;
}


mono_debug_list_add (struct MonoDebugList * * list, const void * data)
{
  struct MonoDebugList * D.17396;
  struct MonoDebugList * element;
  struct MonoDebugList * * ptr;

  element = monoeg_malloc0 (8);
  element->data = data;
  ptr = list;
  goto <D.16752>;
  <D.16751>:
  D.17396 = *ptr;
  ptr = &D.17396->next;
  <D.16752>:
  D.17396 = *ptr;
  if (D.17396 != 0B) goto <D.16751>; else goto <D.16753>;
  <D.16753>:
  *ptr = element;
}


mono_debug_list_remove (struct MonoDebugList * * list, const void * data)
{
  struct MonoDebugList * D.17397;
  const void * D.17398;
  struct MonoDebugList * * ptr;
  struct MonoDebugList * next;

  ptr = list;
  goto <D.16763>;
  <D.16762>:
  D.17397 = *ptr;
  D.17398 = D.17397->data;
  if (D.17398 != data) goto <D.17399>; else goto <D.17400>;
  <D.17399>:
  // predicted unlikely by continue predictor.
  goto <D.16760>;
  <D.17400>:
  D.17397 = *ptr;
  next = D.17397->next;
  D.17397 = *ptr;
  monoeg_g_free (D.17397);
  *ptr = next;
  goto <D.16761>;
  <D.16760>:
  D.17397 = *ptr;
  ptr = &D.17397->next;
  <D.16763>:
  D.17397 = *ptr;
  if (D.17397 != 0B) goto <D.16762>; else goto <D.16761>;
  <D.16761>:
}


mono_set_is_debugger_attached (gboolean attached)
{
  is_attached = attached;
}


mono_is_debugger_attached ()
{
  mono_bool D.17401;

  D.17401 = is_attached;
  return D.17401;
}


mono_register_symfile_for_assembly (const char * assembly_name, const mono_byte * raw_contents, int size)
{
  struct BundledSymfile * bundled_symfiles.80;
  struct BundledSymfile * bsymfile;

  bsymfile = monoeg_malloc0 (16);
  bsymfile->aname = assembly_name;
  bsymfile->raw_contents = raw_contents;
  bsymfile->size = size;
  bundled_symfiles.80 = bundled_symfiles;
  bsymfile->next = bundled_symfiles.80;
  bundled_symfiles = bsymfile;
}


mono_debug_enabled ()
{
  mono_bool D.17404;
  <unnamed type> mono_debug_format.81;
  _Bool D.17406;

  mono_debug_format.81 = mono_debug_format;
  D.17406 = mono_debug_format.81 != 0;
  D.17404 = (mono_bool) D.17406;
  return D.17404;
}