mono_debug_init (MonoDebugFormat format)
{
  int mono_debug_initialized.0;
  _Bool D.16778;
  long int D.16779;
  long int D.16780;
  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.16789;

  mono_debug_initialized.0 = mono_debug_initialized;
  D.16778 = mono_debug_initialized.0 != 0;
  D.16779 = (long int) D.16778;
  D.16780 = __builtin_expect (D.16779, 0);
  if (D.16780 != 0) goto <D.16781>; else goto <D.16782>;
  <D.16781>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "mono-debug.c", 228, "!mono_debug_initialized");
  <D.16782>:
  if (format == 2) goto <D.16783>; else goto <D.16784>;
  <D.16783>:
  monoeg_g_log (0B, 4, "The mdb debugger is no longer supported.");
  <D.16442>:
  goto <D.16442>;
  <D.16784>:
  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.16789 = create_data_table (0B);
  mono_symbol_table.2->global_data_table = D.16789;
  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.16790>; else goto <D.16791>;
  <D.16790>:
  mono_debug_open_image (image, 0B, 0);
  <D.16791>:
  mono_debugger_unlock ();
}


open_symfile_from_bundle (struct MonoImage * image)
{
  int D.16768;
  const char * D.16792;
  const char * D.16793;
  struct MonoDebugHandle * D.16796;
  const mono_byte * D.16797;
  int D.16798;
  struct BundledSymfile * bsymfile;

  bsymfile = bundled_symfiles;
  goto <D.16771>;
  <D.16770>:
  {
    size_t __s1_len;
    size_t __s2_len;

    D.16792 = bsymfile->aname;
    D.16793 = image->module_name;
    D.16768 = __builtin_strcmp (D.16792, D.16793);
  }
  if (D.16768 != 0) goto <D.16794>; else goto <D.16795>;
  <D.16794>:
  // predicted unlikely by continue predictor.
  goto <D.16769>;
  <D.16795>:
  D.16797 = bsymfile->raw_contents;
  D.16798 = bsymfile->size;
  D.16796 = mono_debug_open_image (image, D.16797, D.16798);
  return D.16796;
  <D.16769>:
  bsymfile = bsymfile->next;
  <D.16771>:
  if (bsymfile != 0B) goto <D.16770>; else goto <D.16772>;
  <D.16772>:
  D.16796 = 0B;
  return D.16796;
}


mono_debug_open_image (struct MonoImage * image, const guint8 * raw_contents, int size)
{
  int D.16800;
  struct MonoDebugHandle * D.16803;
  int next_symbol_file_id.5;
  int next_symbol_file_id.6;
  unsigned int next_symbol_file_id.7;
  const char * D.16809;
  gchar * D.16810;
  struct MonoDebugDataTable * D.16811;
  struct MonoSymbolFile * D.16812;
  struct MonoSymbolTable * mono_symbol_table.8;
  struct MonoDebugList * * D.16814;
  struct GHashTable * mono_debug_handles.9;
  struct MonoDebugHandle * handle;

  D.16800 = mono_image_is_dynamic (image);
  if (D.16800 != 0) goto <D.16801>; else goto <D.16802>;
  <D.16801>:
  D.16803 = 0B;
  return D.16803;
  <D.16802>:
  mono_debugger_lock ();
  handle = _mono_debug_get_image (image);
  if (handle != 0B) goto <D.16804>; else goto <D.16805>;
  <D.16804>:
  mono_debugger_unlock ();
  D.16803 = handle;
  return D.16803;
  <D.16805>:
  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.16809 = mono_image_get_filename (image);
  D.16810 = monoeg_strdup (D.16809);
  handle->image_file = D.16810;
  D.16811 = create_data_table (0B);
  handle->type_table = D.16811;
  D.16812 = mono_debug_open_mono_symbols (handle, raw_contents, size, 0);
  handle->symfile = D.16812;
  mono_symbol_table.8 = mono_symbol_table;
  D.16814 = &mono_symbol_table.8->symbol_files;
  mono_debug_list_add (D.16814, 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.16803 = handle;
  return D.16803;
}


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

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


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

  if (str != 0B) goto <D.16820>; else goto <D.16821>;
  <D.16820>:
  D.16822 = __strdup (str);
  return D.16822;
  <D.16821>:
  D.16822 = 0B;
  return D.16822;
}


mono_debug_add_type (struct MonoClass * klass)
{
  struct MonoClass * klass.11;
  struct MonoGenericClass * D.16827;
  unsigned char D.16829;
  unsigned char D.16831;
  struct MonoImage * D.16833;
  unsigned int D.16839;
  unsigned int D.16840;
  unsigned int D.16843;
  guint8 * ptr.12;
  int D.16845;
  int D.16846;
  unsigned int D.16847;
  guint8 * ptr.13;
  int ptr.14;
  int oldptr.15;
  int D.16851;
  _Bool D.16852;
  long int D.16853;
  long int D.16854;
  unsigned int D.16857;
  _Bool D.16858;
  long int D.16859;
  long int D.16860;
  struct MonoDebugDataTable * D.16863;
  guint8[0:] * D.16864;
  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;
      klass.11 = klass;
      D.16827 = klass.11->generic_class;
      if (D.16827 != 0B) goto <D.16824>; else goto <D.16828>;
      <D.16828>:
      klass.11 = klass;
      D.16829 = klass.11->rank;
      if (D.16829 != 0) goto <D.16824>; else goto <D.16830>;
      <D.16830>:
      klass.11 = klass;
      D.16831 = klass.11->byval_arg.type;
      if (D.16831 == 19) goto <D.16824>; else goto <D.16832>;
      <D.16832>:
      klass.11 = klass;
      D.16831 = klass.11->byval_arg.type;
      if (D.16831 == 30) goto <D.16824>; else goto <D.16825>;
      <D.16824>:
      return;
      <D.16825>:
      mono_debugger_lock ();
      klass.11 = klass;
      D.16833 = klass.11->image;
      handle = _mono_debug_get_image (D.16833);
      if (handle == 0B) goto <D.16834>; else goto <D.16835>;
      <D.16834>:
      mono_debugger_unlock ();
      return;
      <D.16835>:
      max_size = 16;
      if (max_size > 8192) goto <D.16836>; else goto <D.16837>;
      <D.16836>:
      oldptr = monoeg_malloc (max_size);
      ptr = oldptr;
      goto <D.16838>;
      <D.16837>:
      oldptr = &buffer;
      ptr = oldptr;
      <D.16838>:
      klass.11 = klass;
      D.16839 = BIT_FIELD_REF <*klass.11, 32, 160>;
      D.16840 = D.16839 & 8;
      if (D.16840 != 0) goto <D.16841>; else goto <D.16842>;
      <D.16841>:
      base_offset = -8;
      <D.16842>:
      klass.11 = klass;
      D.16843 = klass.11->type_token;
      ptr.12 = ptr;
      write_leb128 (D.16843, ptr.12, &ptr);
      klass.11 = klass;
      D.16845 = klass.11->instance_size;
      D.16846 = D.16845 + base_offset;
      D.16847 = (unsigned int) D.16846;
      ptr.12 = ptr;
      write_leb128 (D.16847, ptr.12, &ptr);
      ptr.12 = ptr;
      memcpy (ptr.12, &klass, 4);
      ptr.12 = ptr;
      ptr.13 = ptr.12 + 4;
      ptr = ptr.13;
      ptr.12 = ptr;
      ptr.14 = (int) ptr.12;
      oldptr.15 = (int) oldptr;
      D.16851 = ptr.14 - oldptr.15;
      size = (guint32) D.16851;
      D.16852 = size >= max_size;
      D.16853 = (long int) D.16852;
      D.16854 = __builtin_expect (D.16853, 0);
      if (D.16854 != 0) goto <D.16855>; else goto <D.16856>;
      <D.16855>:
      monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "mono-debug.c", 906, "size < max_size");
      <D.16856>:
      total_size = size + 4;
      D.16857 = total_size + 9;
      D.16858 = D.16857 > 16363;
      D.16859 = (long int) D.16858;
      D.16860 = __builtin_expect (D.16859, 0);
      if (D.16860 != 0) goto <D.16861>; else goto <D.16862>;
      <D.16861>:
      monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "mono-debug.c", 909, "total_size + 9 < DATA_TABLE_CHUNK_SIZE");
      <D.16862>:
      D.16863 = handle->type_table;
      entry = allocate_data_item (D.16863, 1, total_size);
      entry->size = total_size;
      D.16864 = &entry->data;
      memcpy (D.16864, oldptr, size);
      D.16863 = handle->type_table;
      write_data_item (D.16863, entry);
      if (max_size > 8192) goto <D.16865>; else goto <D.16866>;
      <D.16865>:
      monoeg_g_free (oldptr);
      <D.16866>:
      mono_debugger_unlock ();
    }
  finally
    {
      buffer = {CLOBBER};
      ptr = {CLOBBER};
    }
}


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

  <D.16519>:
  {
    guint8 byte;

    D.16870 = (unsigned char) value;
    byte = D.16870 & 127;
    value = value >> 7;
    if (value != 0) goto <D.16871>; else goto <D.16872>;
    <D.16871>:
    byte = byte | 128;
    <D.16872>:
    ptr.16 = ptr;
    ptr = ptr.16 + 1;
    *ptr.16 = byte;
  }
  if (value != 0) goto <D.16519>; else goto <D.16520>;
  <D.16520>:
  *rptr = ptr;
}


allocate_data_item (struct MonoDebugDataTable * table, MonoDebugDataItemType type, guint32 size)
{
  unsigned int D.16874;
  unsigned int D.16875;
  struct MonoDebugDataChunk * D.16879;
  unsigned int D.16880;
  unsigned int D.16881;
  _Bool D.16882;
  long int D.16883;
  long int D.16884;
  unsigned int D.16887;
  unsigned int D.16888;
  unsigned int D.16889;
  unsigned int D.16892;
  guint8 * D.16893;
  guint32 chunk_size;
  guint8 * data;

  D.16874 = size + 3;
  size = D.16874 & 4294967292;
  D.16875 = size + 16;
  if (D.16875 <= 16363) goto <D.16876>; else goto <D.16877>;
  <D.16876>:
  chunk_size = 16364;
  goto <D.16878>;
  <D.16877>:
  chunk_size = size + 16;
  <D.16878>:
  D.16879 = table->current_chunk;
  D.16880 = D.16879->current_offset;
  D.16879 = table->current_chunk;
  D.16881 = D.16879->allocated_size;
  D.16882 = D.16880 != D.16881;
  D.16883 = (long int) D.16882;
  D.16884 = __builtin_expect (D.16883, 0);
  if (D.16884 != 0) goto <D.16885>; else goto <D.16886>;
  <D.16885>:
  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.16886>:
  D.16879 = table->current_chunk;
  D.16881 = D.16879->allocated_size;
  D.16887 = D.16881 + size;
  D.16888 = D.16887 + 8;
  D.16879 = table->current_chunk;
  D.16889 = D.16879->total_size;
  if (D.16888 >= D.16889) goto <D.16890>; else goto <D.16891>;
  <D.16890>:
  {
    struct MonoDebugDataChunk * new_chunk;

    D.16892 = chunk_size + 20;
    new_chunk = monoeg_malloc0 (D.16892);
    new_chunk->total_size = chunk_size;
    D.16879 = table->current_chunk;
    D.16879->next = new_chunk;
    table->current_chunk = new_chunk;
  }
  <D.16891>:
  D.16879 = table->current_chunk;
  D.16879 = table->current_chunk;
  D.16881 = D.16879->allocated_size;
  data = &D.16879->data[D.16881];
  D.16879 = table->current_chunk;
  D.16879 = table->current_chunk;
  D.16881 = D.16879->allocated_size;
  D.16887 = D.16881 + size;
  D.16888 = D.16887 + 8;
  D.16879->allocated_size = D.16888;
  MEM[(guint32 *)data] = size;
  data = data + 4;
  MEM[(guint32 *)data] = type;
  data = data + 4;
  D.16893 = data;
  return D.16893;
}


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

  D.16896 = __builtin_object_size (__dest, 0);
  D.16895 = __builtin___memcpy_chk (__dest, __src, __len, D.16896);
  return D.16895;
}


write_data_item (struct MonoDebugDataTable * table, const guint8 * data)
{
  unsigned int D.16898;
  unsigned int D.16899;
  unsigned int D.16900;
  unsigned int D.16901;
  _Bool D.16902;
  long int D.16903;
  long int D.16904;
  struct MonoDebugDataChunk * current_chunk;
  guint32 size;

  current_chunk = table->current_chunk;
  size = MEM[(guint32 *)data + 4294967288B];
  D.16898 = current_chunk->current_offset;
  D.16899 = D.16898 + size;
  D.16900 = D.16899 + 8;
  D.16901 = current_chunk->allocated_size;
  D.16902 = D.16900 != D.16901;
  D.16903 = (long int) D.16902;
  D.16904 = __builtin_expect (D.16903, 0);
  if (D.16904 != 0) goto <D.16905>; else goto <D.16906>;
  <D.16905>:
  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.16906>:
  D.16901 = current_chunk->allocated_size;
  current_chunk->current_offset = D.16901;
}


free_data_table (struct MonoDebugDataTable * table)
{
  struct GHashTable * D.16907;
  struct GHashTable * D.16908;
  struct MonoDebugDataChunk * D.16909;
  struct MonoSymbolTable * mono_symbol_table.17;
  struct MonoDebugList * * D.16911;
  struct MonoDebugDataChunk * chunk;
  struct MonoDebugDataChunk * next_chunk;

  D.16907 = table->method_hash;
  monoeg_g_hash_table_foreach (D.16907, free_header_data, 0B);
  D.16907 = table->method_hash;
  monoeg_g_hash_table_destroy (D.16907);
  D.16908 = table->method_address_hash;
  monoeg_g_hash_table_destroy (D.16908);
  table->method_hash = 0B;
  table->method_address_hash = 0B;
  chunk = table->first_chunk;
  goto <D.16429>;
  <D.16428>:
  next_chunk = chunk->next;
  monoeg_g_free (chunk);
  chunk = next_chunk;
  <D.16429>:
  if (chunk != 0B) goto <D.16428>; else goto <D.16430>;
  <D.16430>:
  table->current_chunk = 0B;
  D.16909 = table->current_chunk;
  table->first_chunk = D.16909;
  mono_symbol_table.17 = mono_symbol_table;
  D.16911 = &mono_symbol_table.17->data_tables;
  mono_debug_list_remove (D.16911, table);
  monoeg_g_free (table);
}


free_header_data (void * key, void * value, void * user_data)
{
  struct MonoDebugWrapperData * D.16912;
  const gchar * D.16915;
  struct GSList * D.16916;
  struct MonoDebugMethodHeader * header;

  header = value;
  D.16912 = header->wrapper_data;
  if (D.16912 != 0B) goto <D.16913>; else goto <D.16914>;
  <D.16913>:
  D.16912 = header->wrapper_data;
  D.16915 = D.16912->method_name;
  monoeg_g_free (D.16915);
  D.16912 = header->wrapper_data;
  monoeg_g_free (D.16912);
  <D.16914>:
  D.16916 = header->address_list;
  monoeg_g_slist_free (D.16916);
}


free_debug_handle (struct MonoDebugHandle * handle)
{
  struct MonoSymbolFile * D.16917;
  struct MonoDebugDataTable * D.16920;
  struct MonoImage * D.16921;
  char * D.16922;

  D.16917 = handle->symfile;
  if (D.16917 != 0B) goto <D.16918>; else goto <D.16919>;
  <D.16918>:
  D.16917 = handle->symfile;
  mono_debug_close_mono_symbol_file (D.16917);
  <D.16919>:
  D.16920 = handle->type_table;
  free_data_table (D.16920);
  D.16921 = handle->image;
  mono_image_close (D.16921);
  D.16922 = handle->image_file;
  monoeg_g_free (D.16922);
  monoeg_g_free (handle);
}


create_data_table (struct MonoDomain * domain)
{
  int iftmp.18;
  struct GHashTable * D.16927;
  struct GHashTable * D.16928;
  struct MonoDebugDataChunk * D.16929;
  struct MonoSymbolTable * mono_symbol_table.19;
  struct MonoDebugList * * D.16933;
  struct GHashTable * data_table_hash.20;
  struct MonoDebugDataTable * D.16935;
  struct MonoDebugDataTable * table;
  struct MonoDebugDataChunk * chunk;

  table = monoeg_malloc0 (24);
  if (domain != 0B) goto <D.16924>; else goto <D.16925>;
  <D.16924>:
  iftmp.18 = mono_domain_get_id (domain);
  goto <D.16926>;
  <D.16925>:
  iftmp.18 = -1;
  <D.16926>:
  table->domain = iftmp.18;
  D.16927 = monoeg_g_hash_table_new (0B, 0B);
  table->method_address_hash = D.16927;
  D.16928 = monoeg_g_hash_table_new (0B, 0B);
  table->method_hash = D.16928;
  chunk = monoeg_malloc0 (16384);
  chunk->total_size = 16364;
  table->current_chunk = chunk;
  D.16929 = table->current_chunk;
  table->first_chunk = D.16929;
  if (domain != 0B) goto <D.16930>; else goto <D.16931>;
  <D.16930>:
  mono_symbol_table.19 = mono_symbol_table;
  D.16933 = &mono_symbol_table.19->data_tables;
  mono_debug_list_add (D.16933, table);
  data_table_hash.20 = data_table_hash;
  monoeg_g_hash_table_insert_replace (data_table_hash.20, domain, table, 0);
  <D.16931>:
  D.16935 = table;
  return D.16935;
}


_mono_debug_init_corlib (struct MonoDomain * domain)
{
  int mono_debug_initialized.21;
  struct MonoSymbolTable * mono_symbol_table.22;
  struct MonoImage * D.16941;
  struct MonoDebugHandle * D.16942;

  mono_debug_initialized.21 = mono_debug_initialized;
  if (mono_debug_initialized.21 == 0) goto <D.16938>; else goto <D.16939>;
  <D.16938>:
  return;
  <D.16939>:
  mono_symbol_table.22 = mono_symbol_table;
  D.16941 = mono_defaults.corlib;
  D.16942 = mono_debug_open_image (D.16941, 0B, 0);
  mono_symbol_table.22->corlib = D.16942;
}


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

  mono_debug_initialized.23 = mono_debug_initialized;
  if (mono_debug_initialized.23 == 0) goto <D.16945>; else goto <D.16946>;
  <D.16945>:
  return;
  <D.16946>:
  mono_debug_open_image (image, raw_contents, size);
}


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

  mono_debug_handles.24 = mono_debug_handles;
  if (mono_debug_handles.24 != 0B) goto <D.16949>; else goto <D.16950>;
  <D.16949>:
  mono_debug_handles.24 = mono_debug_handles;
  monoeg_g_hash_table_destroy (mono_debug_handles.24);
  <D.16950>:
  mono_debug_handles = 0B;
  data_table_hash.25 = data_table_hash;
  if (data_table_hash.25 != 0B) goto <D.16952>; else goto <D.16953>;
  <D.16952>:
  data_table_hash.25 = data_table_hash;
  monoeg_g_hash_table_destroy (data_table_hash.25);
  data_table_hash = 0B;
  <D.16953>:
  mono_symbol_table.26 = mono_symbol_table;
  if (mono_symbol_table.26 != 0B) goto <D.16955>; else goto <D.16956>;
  <D.16955>:
  mono_symbol_table.26 = mono_symbol_table;
  D.16957 = mono_symbol_table.26->global_data_table;
  if (D.16957 != 0B) goto <D.16958>; else goto <D.16959>;
  <D.16958>:
  mono_symbol_table.26 = mono_symbol_table;
  D.16957 = mono_symbol_table.26->global_data_table;
  free_data_table (D.16957);
  <D.16959>:
  mono_symbol_table.26 = mono_symbol_table;
  monoeg_g_free (mono_symbol_table.26);
  mono_symbol_table = 0B;
  <D.16956>:
}


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

  mono_debug_initialized.27 = mono_debug_initialized;
  if (mono_debug_initialized.27 == 0) goto <D.16961>; else goto <D.16962>;
  <D.16961>:
  return;
  <D.16962>:
  mono_debugger_lock ();
  table = create_data_table (domain);
  mono_debugger_unlock ();
}


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

  mono_debug_initialized.28 = mono_debug_initialized;
  if (mono_debug_initialized.28 == 0) goto <D.16965>; else goto <D.16966>;
  <D.16965>:
  return;
  <D.16966>:
  mono_debugger_lock ();
  data_table_hash.29 = data_table_hash;
  table = monoeg_g_hash_table_lookup (data_table_hash.29, domain);
  if (table == 0B) goto <D.16968>; else goto <D.16969>;
  <D.16968>:
  D.16970 = mono_domain_get_id (domain);
  monoeg_g_log (0B, 16, "mono-debug.c:337:: unloading unknown domain %p / %d", domain, D.16970);
  mono_debugger_unlock ();
  return;
  <D.16969>:
  data_table_hash.29 = data_table_hash;
  monoeg_g_hash_table_remove (data_table_hash.29, domain);
  mono_debugger_unlock ();
}


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

  mono_debug_initialized.30 = mono_debug_initialized;
  if (mono_debug_initialized.30 == 0) goto <D.16973>; else goto <D.16974>;
  <D.16973>:
  return;
  <D.16974>:
  mono_debugger_lock ();
  handle = _mono_debug_get_image (image);
  if (handle == 0B) goto <D.16975>; else goto <D.16976>;
  <D.16975>:
  mono_debugger_unlock ();
  return;
  <D.16976>:
  mono_symbol_table.31 = mono_symbol_table;
  D.16978 = &mono_symbol_table.31->symbol_files;
  mono_debug_list_remove (D.16978, handle);
  mono_debug_handles.32 = mono_debug_handles;
  monoeg_g_hash_table_remove (mono_debug_handles.32, image);
  mono_debugger_unlock ();
}


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

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


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

  try
    {
      data.minfo = 0B;
      data.method = method;
      mono_debug_handles.33 = mono_debug_handles;
      if (mono_debug_handles.33 == 0B) goto <D.16984>; else goto <D.16985>;
      <D.16984>:
      D.16986 = 0B;
      return D.16986;
      <D.16985>:
      mono_debug_handles.33 = mono_debug_handles;
      monoeg_g_hash_table_foreach (mono_debug_handles.33, lookup_method_func, &data);
      D.16986 = data.minfo;
      return D.16986;
    }
  finally
    {
      data = {CLOBBER};
    }
}


lookup_method_func (void * key, void * value, void * user_data)
{
  struct MonoDebugMethodInfo * D.16989;
  struct MonoSymbolFile * D.16992;
  struct MonoMethod * D.16995;
  struct MonoDebugMethodInfo * D.16996;
  struct MonoDebugHandle * handle;
  struct LookupMethodData * data;

  handle = value;
  data = user_data;
  D.16989 = data->minfo;
  if (D.16989 != 0B) goto <D.16990>; else goto <D.16991>;
  <D.16990>:
  return;
  <D.16991>:
  D.16992 = handle->symfile;
  if (D.16992 != 0B) goto <D.16993>; else goto <D.16994>;
  <D.16993>:
  D.16995 = data->method;
  D.16996 = mono_debug_symfile_lookup_method (handle, D.16995);
  data->minfo = D.16996;
  <D.16994>:
}


mono_debug_add_method (struct MonoMethod * method, struct MonoDebugMethodJitInfo * jit, struct MonoDomain * domain)
{
  struct MonoClass * D.16998;
  struct MonoImage * D.16999;
  short unsigned int D.17003;
  unsigned int D.17004;
  unsigned int D.17005;
  short unsigned int D.17007;
  unsigned int D.17008;
  unsigned int D.17009;
  unsigned int D.17011;
  unsigned int D.17012;
  unsigned int D.17013;
  unsigned int D.17014;
  unsigned int D.17015;
  unsigned int D.17016;
  unsigned int D.17017;
  unsigned int D.17018;
  unsigned int D.17019;
  unsigned int D.17020;
  unsigned int D.17024;
  guint8 * ptr.34;
  unsigned int D.17026;
  struct MonoDebugLineNumberEntry * D.17027;
  unsigned int D.17028;
  unsigned int D.17029;
  int D.17030;
  unsigned int D.17031;
  int D.17032;
  guint8 * ptr.35;
  guint8 * ptr.36;
  struct MonoDebugVarInfo * D.17035;
  _Bool D.17036;
  unsigned char D.17037;
  struct MonoDebugVarInfo * D.17040;
  unsigned int D.17041;
  struct MonoDebugVarInfo * D.17042;
  struct MonoDebugVarInfo * D.17043;
  struct MonoDebugVarInfo * D.17044;
  guint8 * ptr.37;
  guint8 * ptr.38;
  struct MonoDebugVarInfo * D.17047;
  _Bool D.17048;
  unsigned char D.17049;
  struct MonoDebugVarInfo * D.17052;
  int ptr.39;
  int oldptr.40;
  int D.17055;
  _Bool D.17056;
  long int D.17057;
  long int D.17058;
  unsigned int D.17061;
  uint32_t iftmp.41;
  int D.17069;
  unsigned int D.17070;
  uint32_t iftmp.42;
  const mono_byte * D.17075;
  unsigned int D.17076;
  guint8[0:] * D.17077;
  struct MonoMethod * iftmp.43;
  unsigned int D.17081;
  struct GHashTable * D.17085;
  <unnamed-unsigned:5> D.17090;
  unsigned int D.17091;
  char * D.17092;
  struct MonoDebugWrapperData * D.17094;
  struct GSList * D.17095;
  struct GSList * D.17096;
  struct GHashTable * D.17097;
  struct MonoDebugMethodAddress * D.17100;
  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.16998 = method->klass;
      D.16999 = D.16998->image;
      handle = _mono_debug_get_image (D.16999);
      minfo = _mono_debug_lookup_method (method);
      if (minfo == 0B) goto <D.17000>; else goto <D.17002>;
      <D.17002>:
      D.17003 = method->iflags;
      D.17004 = (unsigned int) D.17003;
      D.17005 = D.17004 & 4099;
      if (D.17005 != 0) goto <D.17000>; else goto <D.17006>;
      <D.17006>:
      D.17007 = method->flags;
      D.17008 = (unsigned int) D.17007;
      D.17009 = D.17008 & 9216;
      if (D.17009 != 0) goto <D.17000>; else goto <D.17010>;
      <D.17010>:
      D.17011 = BIT_FIELD_REF <*method, 32, 160>;
      D.17012 = D.17011 & 124;
      if (D.17012 != 0) goto <D.17000>; else goto <D.17001>;
      <D.17000>:
      is_wrapper = 1;
      <D.17001>:
      D.17013 = jit->num_line_numbers;
      D.17014 = D.17013 * 10;
      D.17015 = jit->num_params;
      D.17016 = jit->num_locals;
      D.17017 = D.17015 + D.17016;
      D.17018 = D.17017 + 1;
      D.17019 = D.17018 * 29;
      D.17020 = D.17014 + D.17019;
      max_size = D.17020 + 26;
      if (max_size > 8192) goto <D.17021>; else goto <D.17022>;
      <D.17021>:
      oldptr = monoeg_malloc (max_size);
      ptr = oldptr;
      goto <D.17023>;
      <D.17022>:
      oldptr = &buffer;
      ptr = oldptr;
      <D.17023>:
      D.17024 = jit->prologue_end;
      ptr.34 = ptr;
      write_leb128 (D.17024, ptr.34, &ptr);
      D.17026 = jit->epilogue_begin;
      ptr.34 = ptr;
      write_leb128 (D.17026, ptr.34, &ptr);
      D.17013 = jit->num_line_numbers;
      ptr.34 = ptr;
      write_leb128 (D.17013, ptr.34, &ptr);
      i = 0;
      goto <D.16557>;
      <D.16556>:
      {
        struct MonoDebugLineNumberEntry * lne;

        D.17027 = jit->line_numbers;
        D.17028 = i * 8;
        lne = D.17027 + D.17028;
        D.17029 = lne->il_offset;
        D.17030 = (int) D.17029;
        ptr.34 = ptr;
        write_sleb128 (D.17030, ptr.34, &ptr);
        D.17031 = lne->native_offset;
        D.17032 = (int) D.17031;
        ptr.34 = ptr;
        write_sleb128 (D.17032, ptr.34, &ptr);
      }
      i = i + 1;
      <D.16557>:
      D.17013 = jit->num_line_numbers;
      if (D.17013 > i) goto <D.16556>; else goto <D.16558>;
      <D.16558>:
      ptr.34 = ptr;
      ptr.35 = ptr.34;
      ptr.36 = ptr.35 + 1;
      ptr = ptr.36;
      D.17035 = jit->this_var;
      D.17036 = D.17035 != 0B;
      D.17037 = (unsigned char) D.17036;
      *ptr.35 = D.17037;
      D.17035 = jit->this_var;
      if (D.17035 != 0B) goto <D.17038>; else goto <D.17039>;
      <D.17038>:
      D.17035 = jit->this_var;
      ptr.34 = ptr;
      write_variable (D.17035, ptr.34, &ptr);
      <D.17039>:
      D.17015 = jit->num_params;
      ptr.34 = ptr;
      write_leb128 (D.17015, ptr.34, &ptr);
      i = 0;
      goto <D.16560>;
      <D.16559>:
      D.17040 = jit->params;
      D.17041 = i * 24;
      D.17042 = D.17040 + D.17041;
      ptr.34 = ptr;
      write_variable (D.17042, ptr.34, &ptr);
      i = i + 1;
      <D.16560>:
      D.17015 = jit->num_params;
      if (D.17015 > i) goto <D.16559>; else goto <D.16561>;
      <D.16561>:
      D.17016 = jit->num_locals;
      ptr.34 = ptr;
      write_leb128 (D.17016, ptr.34, &ptr);
      i = 0;
      goto <D.16563>;
      <D.16562>:
      D.17043 = jit->locals;
      D.17041 = i * 24;
      D.17044 = D.17043 + D.17041;
      ptr.34 = ptr;
      write_variable (D.17044, ptr.34, &ptr);
      i = i + 1;
      <D.16563>:
      D.17016 = jit->num_locals;
      if (D.17016 > i) goto <D.16562>; else goto <D.16564>;
      <D.16564>:
      ptr.34 = ptr;
      ptr.37 = ptr.34;
      ptr.38 = ptr.37 + 1;
      ptr = ptr.38;
      D.17047 = jit->gsharedvt_info_var;
      D.17048 = D.17047 != 0B;
      D.17049 = (unsigned char) D.17048;
      *ptr.37 = D.17049;
      D.17047 = jit->gsharedvt_info_var;
      if (D.17047 != 0B) goto <D.17050>; else goto <D.17051>;
      <D.17050>:
      D.17047 = jit->gsharedvt_info_var;
      ptr.34 = ptr;
      write_variable (D.17047, ptr.34, &ptr);
      D.17052 = jit->gsharedvt_locals_var;
      ptr.34 = ptr;
      write_variable (D.17052, ptr.34, &ptr);
      <D.17051>:
      ptr.34 = ptr;
      ptr.39 = (int) ptr.34;
      oldptr.40 = (int) oldptr;
      D.17055 = ptr.39 - oldptr.40;
      size = (guint32) D.17055;
      D.17056 = size >= max_size;
      D.17057 = (long int) D.17056;
      D.17058 = __builtin_expect (D.17057, 0);
      if (D.17058 != 0) goto <D.17059>; else goto <D.17060>;
      <D.17059>:
      monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "mono-debug.c", 639, "size < max_size");
      <D.17060>:
      total_size = size + 40;
      D.17011 = BIT_FIELD_REF <*method, 32, 160>;
      D.17061 = D.17011 & 512;
      if (D.17061 != 0) goto <D.17062>; else goto <D.17063>;
      <D.17062>:
      address = monoeg_malloc0 (total_size);
      goto <D.17064>;
      <D.17063>:
      address = allocate_data_item (table, 2, total_size);
      <D.17064>:
      address->header.size = total_size;
      if (handle != 0B) goto <D.17066>; else goto <D.17067>;
      <D.17066>:
      iftmp.41 = handle->index;
      goto <D.17068>;
      <D.17067>:
      iftmp.41 = 0;
      <D.17068>:
      address->header.symfile_id = iftmp.41;
      D.17069 = mono_domain_get_id (domain);
      D.17070 = (unsigned int) D.17069;
      address->header.domain_id = D.17070;
      if (is_wrapper == 0) goto <D.17072>; else goto <D.17073>;
      <D.17072>:
      iftmp.42 = minfo->index;
      goto <D.17074>;
      <D.17073>:
      iftmp.42 = 0;
      <D.17074>:
      address->header.method_id = iftmp.42;
      address->header.method = method;
      D.17075 = jit->code_start;
      address->code_start = D.17075;
      D.17076 = jit->code_size;
      address->code_size = D.17076;
      D.17077 = &address->data;
      memcpy (D.17077, oldptr, size);
      if (max_size > 8192) goto <D.17078>; else goto <D.17079>;
      <D.17078>:
      monoeg_g_free (oldptr);
      <D.17079>:
      D.17011 = BIT_FIELD_REF <*method, 32, 160>;
      D.17081 = D.17011 & 4096;
      if (D.17081 != 0) goto <D.17082>; else goto <D.17083>;
      <D.17082>:
      iftmp.43 = MEM[(struct MonoMethodInflated *)method].declaring;
      goto <D.17084>;
      <D.17083>:
      iftmp.43 = method;
      <D.17084>:
      declaring = iftmp.43;
      D.17085 = table->method_hash;
      header = monoeg_g_hash_table_lookup (D.17085, declaring);
      if (header == 0B) goto <D.17086>; else goto <D.17087>;
      <D.17086>:
      header = &address->header;
      D.17085 = table->method_hash;
      monoeg_g_hash_table_insert_replace (D.17085, declaring, header, 0);
      if (is_wrapper != 0) goto <D.17088>; else goto <D.17089>;
      <D.17088>:
      {
        struct MonoDebugWrapperData * wrapper;

        wrapper = monoeg_malloc0 (12);
        header->wrapper_data = wrapper;
        D.17090 = method->wrapper_type;
        D.17091 = (unsigned int) D.17090;
        wrapper->wrapper_type = D.17091;
        D.17092 = mono_method_full_name (declaring, 1);
        wrapper->method_name = D.17092;
        wrapper->obsolete_cil_code = "";
      }
      <D.17089>:
      goto <D.17093>;
      <D.17087>:
      D.17094 = header->wrapper_data;
      address->header.wrapper_data = D.17094;
      D.17095 = header->address_list;
      D.17096 = monoeg_g_slist_prepend (D.17095, address);
      header->address_list = D.17096;
      <D.17093>:
      D.17097 = table->method_address_hash;
      monoeg_g_hash_table_insert_replace (D.17097, method, address, 0);
      D.17011 = BIT_FIELD_REF <*method, 32, 160>;
      D.17061 = D.17011 & 512;
      if (D.17061 == 0) goto <D.17098>; else goto <D.17099>;
      <D.17098>:
      write_data_item (table, address);
      <D.17099>:
      mono_debugger_unlock ();
      D.17100 = address;
      return D.17100;
    }
  finally
    {
      buffer = {CLOBBER};
      ptr = {CLOBBER};
    }
}


lookup_data_table (struct MonoDomain * domain)
{
  struct GHashTable * data_table_hash.44;
  _Bool D.17106;
  long int D.17107;
  long int D.17108;
  struct MonoDebugDataTable * D.17111;
  struct MonoDebugDataTable * table;

  data_table_hash.44 = data_table_hash;
  table = monoeg_g_hash_table_lookup (data_table_hash.44, domain);
  if (table == 0B) goto <D.17104>; else goto <D.17105>;
  <D.17104>:
  monoeg_g_log (0B, 4, "lookup_data_table () failed for %p\n", domain);
  <D.16435>:
  goto <D.16435>;
  D.17106 = table == 0B;
  D.17107 = (long int) D.17106;
  D.17108 = __builtin_expect (D.17107, 0);
  if (D.17108 != 0) goto <D.17109>; else goto <D.17110>;
  <D.17109>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "mono-debug.c", 201, "table");
  <D.17110>:
  <D.17105>:
  D.17111 = table;
  return D.17111;
}


write_sleb128 (gint32 value, guint8 * ptr, guint8 * * rptr)
{
  unsigned char D.17113;
  int D.17119;
  int D.17120;
  guint8 * ptr.45;
  gboolean more;

  more = 1;
  goto <D.16529>;
  <D.16528>:
  {
    guint8 byte;

    D.17113 = (unsigned char) value;
    byte = D.17113 & 127;
    value = value >> 7;
    if (value == 0) goto <D.17118>; else goto <D.17114>;
    <D.17118>:
    D.17119 = (int) byte;
    D.17120 = D.17119 & 64;
    if (D.17120 == 0) goto <D.17115>; else goto <D.17114>;
    <D.17114>:
    if (value == -1) goto <D.17121>; else goto <D.17116>;
    <D.17121>:
    D.17119 = (int) byte;
    D.17120 = D.17119 & 64;
    if (D.17120 != 0) goto <D.17115>; else goto <D.17116>;
    <D.17115>:
    more = 0;
    goto <D.17117>;
    <D.17116>:
    byte = byte | 128;
    <D.17117>:
    ptr.45 = ptr;
    ptr = ptr.45 + 1;
    *ptr.45 = byte;
  }
  <D.16529>:
  if (more != 0) goto <D.16528>; else goto <D.16530>;
  <D.16530>:
  *rptr = ptr;
}


write_variable (struct MonoDebugVarInfo * var, guint8 * ptr, guint8 * * rptr)
{
  unsigned int D.17123;
  guint8 * ptr.46;
  unsigned int D.17125;
  int D.17126;
  unsigned int D.17127;
  unsigned int D.17128;
  unsigned int D.17129;
  struct MonoType * * D.17130;
  guint8 * ptr.47;

  D.17123 = var->index;
  ptr.46 = ptr;
  write_leb128 (D.17123, ptr.46, &ptr);
  D.17125 = var->offset;
  D.17126 = (int) D.17125;
  ptr.46 = ptr;
  write_sleb128 (D.17126, ptr.46, &ptr);
  D.17127 = var->size;
  ptr.46 = ptr;
  write_leb128 (D.17127, ptr.46, &ptr);
  D.17128 = var->begin_scope;
  ptr.46 = ptr;
  write_leb128 (D.17128, ptr.46, &ptr);
  D.17129 = var->end_scope;
  ptr.46 = ptr;
  write_leb128 (D.17129, ptr.46, &ptr);
  ptr.46 = ptr;
  D.17130 = &var->type;
  memcpy (ptr.46, D.17130, 4);
  ptr.46 = ptr;
  ptr.47 = ptr.46 + 4;
  ptr = ptr.47;
  ptr.46 = ptr;
  *rptr = ptr.46;
}


mono_debug_remove_method (struct MonoMethod * method, struct MonoDomain * domain)
{
  int mono_debug_initialized.48;
  unsigned int D.17135;
  unsigned int D.17136;
  _Bool D.17137;
  long int D.17138;
  long int D.17139;
  struct MonoMethod * iftmp.49;
  unsigned int D.17143;
  struct GHashTable * D.17147;
  struct GHashTable * D.17148;
  struct MonoDebugWrapperData * D.17151;
  const gchar * D.17154;
  struct MonoMethod * declaring;
  struct MonoDebugDataTable * table;
  struct MonoDebugMethodHeader * header;
  struct MonoDebugMethodAddress * address;

  mono_debug_initialized.48 = mono_debug_initialized;
  if (mono_debug_initialized.48 == 0) goto <D.17133>; else goto <D.17134>;
  <D.17133>:
  return;
  <D.17134>:
  D.17135 = BIT_FIELD_REF <*method, 32, 160>;
  D.17136 = D.17135 & 512;
  D.17137 = D.17136 == 0;
  D.17138 = (long int) D.17137;
  D.17139 = __builtin_expect (D.17138, 0);
  if (D.17139 != 0) goto <D.17140>; else goto <D.17141>;
  <D.17140>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "mono-debug.c", 703, "method->dynamic");
  <D.17141>:
  mono_debugger_lock ();
  table = lookup_data_table (domain);
  D.17135 = BIT_FIELD_REF <*method, 32, 160>;
  D.17143 = D.17135 & 4096;
  if (D.17143 != 0) goto <D.17144>; else goto <D.17145>;
  <D.17144>:
  iftmp.49 = MEM[(struct MonoMethodInflated *)method].declaring;
  goto <D.17146>;
  <D.17145>:
  iftmp.49 = method;
  <D.17146>:
  declaring = iftmp.49;
  D.17147 = table->method_hash;
  monoeg_g_hash_table_remove (D.17147, declaring);
  D.17148 = table->method_address_hash;
  address = monoeg_g_hash_table_lookup (D.17148, method);
  if (address != 0B) goto <D.17149>; else goto <D.17150>;
  <D.17149>:
  header = &address->header;
  D.17151 = header->wrapper_data;
  if (D.17151 != 0B) goto <D.17152>; else goto <D.17153>;
  <D.17152>:
  D.17151 = header->wrapper_data;
  D.17154 = D.17151->method_name;
  monoeg_g_free (D.17154);
  D.17151 = header->wrapper_data;
  monoeg_g_free (D.17151);
  <D.17153>:
  monoeg_g_free (address);
  <D.17150>:
  D.17148 = table->method_address_hash;
  monoeg_g_hash_table_remove (D.17148, method);
  mono_debugger_unlock ();
}


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

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


mono_debug_free_method_jit_info (struct MonoDebugMethodJitInfo * jit)
{
  struct MonoDebugLineNumberEntry * D.17165;
  struct MonoDebugVarInfo * D.17166;
  struct MonoDebugVarInfo * D.17167;
  struct MonoDebugVarInfo * D.17168;
  struct MonoDebugVarInfo * D.17169;
  struct MonoDebugVarInfo * D.17170;

  if (jit == 0B) goto <D.17163>; else goto <D.17164>;
  <D.17163>:
  return;
  <D.17164>:
  D.17165 = jit->line_numbers;
  monoeg_g_free (D.17165);
  D.17166 = jit->this_var;
  monoeg_g_free (D.17166);
  D.17167 = jit->params;
  monoeg_g_free (D.17167);
  D.17168 = jit->locals;
  monoeg_g_free (D.17168);
  D.17169 = jit->gsharedvt_info_var;
  monoeg_g_free (D.17169);
  D.17170 = jit->gsharedvt_locals_var;
  monoeg_g_free (D.17170);
  monoeg_g_free (jit);
}


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

  mono_debug_format.53 = mono_debug_format;
  if (mono_debug_format.53 == 0) goto <D.17173>; else goto <D.17174>;
  <D.17173>:
  D.17175 = 0B;
  return D.17175;
  <D.17174>:
  mono_debugger_lock ();
  res = find_method (method, domain);
  mono_debugger_unlock ();
  D.17175 = res;
  return D.17175;
}


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

  table = lookup_data_table (domain);
  D.17177 = table->method_address_hash;
  address = monoeg_g_hash_table_lookup (D.17177, method);
  if (address == 0B) goto <D.17178>; else goto <D.17179>;
  <D.17178>:
  D.17180 = 0B;
  return D.17180;
  <D.17179>:
  D.17180 = mono_debug_read_method (address);
  return D.17180;
}


mono_debug_read_method (struct MonoDebugMethodAddress * address)
{
  const guint8 * D.17182;
  unsigned int D.17183;
  const guint8 * D.17184;
  guint8[0:] * ptr.54;
  guint8 * ptr.55;
  unsigned int D.17187;
  unsigned int D.17188;
  unsigned int D.17189;
  unsigned int D.17190;
  unsigned int D.17191;
  void * D.17192;
  struct MonoDebugLineNumberEntry * D.17193;
  unsigned int D.17194;
  int D.17195;
  unsigned int D.17196;
  int D.17197;
  unsigned int D.17198;
  guint8 * ptr.56;
  guint8 * ptr.57;
  unsigned char D.17201;
  void * D.17204;
  struct MonoDebugVarInfo * D.17205;
  unsigned int D.17206;
  unsigned int D.17207;
  unsigned int D.17208;
  void * D.17209;
  struct MonoDebugVarInfo * D.17210;
  unsigned int D.17211;
  struct MonoDebugVarInfo * D.17212;
  unsigned int D.17213;
  unsigned int D.17214;
  unsigned int D.17215;
  void * D.17216;
  struct MonoDebugVarInfo * D.17217;
  struct MonoDebugVarInfo * D.17218;
  guint8 * ptr.58;
  guint8 * ptr.59;
  unsigned char D.17221;
  void * D.17224;
  void * D.17225;
  struct MonoDebugVarInfo * D.17226;
  struct MonoDebugVarInfo * D.17227;
  struct MonoDebugMethodJitInfo * D.17228;
  struct MonoDebugMethodJitInfo * jit;
  guint32 i;
  guint8 * ptr;

  try
    {
      jit = monoeg_malloc0 (56);
      D.17182 = address->code_start;
      jit->code_start = D.17182;
      D.17183 = address->code_size;
      jit->code_size = D.17183;
      D.17184 = address->wrapper_addr;
      jit->wrapper_addr = D.17184;
      ptr.54 = &address->data;
      ptr = ptr.54;
      ptr.55 = ptr;
      D.17187 = read_leb128 (ptr.55, &ptr);
      jit->prologue_end = D.17187;
      ptr.55 = ptr;
      D.17188 = read_leb128 (ptr.55, &ptr);
      jit->epilogue_begin = D.17188;
      ptr.55 = ptr;
      D.17189 = read_leb128 (ptr.55, &ptr);
      jit->num_line_numbers = D.17189;
      D.17190 = jit->num_line_numbers;
      D.17191 = D.17190 * 8;
      D.17192 = monoeg_malloc0 (D.17191);
      jit->line_numbers = D.17192;
      i = 0;
      goto <D.16614>;
      <D.16613>:
      {
        struct MonoDebugLineNumberEntry * lne;

        D.17193 = jit->line_numbers;
        D.17194 = i * 8;
        lne = D.17193 + D.17194;
        ptr.55 = ptr;
        D.17195 = read_sleb128 (ptr.55, &ptr);
        D.17196 = (unsigned int) D.17195;
        lne->il_offset = D.17196;
        ptr.55 = ptr;
        D.17197 = read_sleb128 (ptr.55, &ptr);
        D.17198 = (unsigned int) D.17197;
        lne->native_offset = D.17198;
      }
      i = i + 1;
      <D.16614>:
      D.17190 = jit->num_line_numbers;
      if (D.17190 > i) goto <D.16613>; else goto <D.16615>;
      <D.16615>:
      ptr.55 = ptr;
      ptr.56 = ptr.55;
      ptr.57 = ptr.56 + 1;
      ptr = ptr.57;
      D.17201 = *ptr.56;
      if (D.17201 != 0) goto <D.17202>; else goto <D.17203>;
      <D.17202>:
      D.17204 = monoeg_malloc0 (24);
      jit->this_var = D.17204;
      D.17205 = jit->this_var;
      ptr.55 = ptr;
      read_variable (D.17205, ptr.55, &ptr);
      <D.17203>:
      ptr.55 = ptr;
      D.17206 = read_leb128 (ptr.55, &ptr);
      jit->num_params = D.17206;
      D.17207 = jit->num_params;
      D.17208 = D.17207 * 24;
      D.17209 = monoeg_malloc0 (D.17208);
      jit->params = D.17209;
      i = 0;
      goto <D.16617>;
      <D.16616>:
      D.17210 = jit->params;
      D.17211 = i * 24;
      D.17212 = D.17210 + D.17211;
      ptr.55 = ptr;
      read_variable (D.17212, ptr.55, &ptr);
      i = i + 1;
      <D.16617>:
      D.17207 = jit->num_params;
      if (D.17207 > i) goto <D.16616>; else goto <D.16618>;
      <D.16618>:
      ptr.55 = ptr;
      D.17213 = read_leb128 (ptr.55, &ptr);
      jit->num_locals = D.17213;
      D.17214 = jit->num_locals;
      D.17215 = D.17214 * 24;
      D.17216 = monoeg_malloc0 (D.17215);
      jit->locals = D.17216;
      i = 0;
      goto <D.16620>;
      <D.16619>:
      D.17217 = jit->locals;
      D.17211 = i * 24;
      D.17218 = D.17217 + D.17211;
      ptr.55 = ptr;
      read_variable (D.17218, ptr.55, &ptr);
      i = i + 1;
      <D.16620>:
      D.17214 = jit->num_locals;
      if (D.17214 > i) goto <D.16619>; else goto <D.16621>;
      <D.16621>:
      ptr.55 = ptr;
      ptr.58 = ptr.55;
      ptr.59 = ptr.58 + 1;
      ptr = ptr.59;
      D.17221 = *ptr.58;
      if (D.17221 != 0) goto <D.17222>; else goto <D.17223>;
      <D.17222>:
      D.17224 = monoeg_malloc0 (24);
      jit->gsharedvt_info_var = D.17224;
      D.17225 = monoeg_malloc0 (24);
      jit->gsharedvt_locals_var = D.17225;
      D.17226 = jit->gsharedvt_info_var;
      ptr.55 = ptr;
      read_variable (D.17226, ptr.55, &ptr);
      D.17227 = jit->gsharedvt_locals_var;
      ptr.55 = ptr;
      read_variable (D.17227, ptr.55, &ptr);
      <D.17223>:
      D.17228 = jit;
      return D.17228;
    }
  finally
    {
      ptr = {CLOBBER};
    }
}


read_sleb128 (guint8 * ptr, guint8 * * rptr)
{
  guint8 * ptr.60;
  int D.17232;
  int D.17233;
  int shift.61;
  int D.17235;
  signed char byte.62;
  int D.17241;
  int D.17244;
  int D.17245;
  gint32 D.17246;
  gint32 result;
  guint32 shift;

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

    ptr.60 = ptr;
    ptr = ptr.60 + 1;
    byte = *ptr.60;
    D.17232 = (int) byte;
    D.17233 = D.17232 & 127;
    shift.61 = (int) shift;
    D.17235 = D.17233 << shift.61;
    result = D.17235 | result;
    shift = shift + 7;
    byte.62 = (signed char) byte;
    if (byte.62 < 0) goto <D.17237>; else goto <D.17238>;
    <D.17237>:
    // predicted unlikely by continue predictor.
    goto <D.16595>;
    <D.17238>:
    if (shift <= 31) goto <D.17239>; else goto <D.17240>;
    <D.17239>:
    D.17232 = (int) byte;
    D.17241 = D.17232 & 64;
    if (D.17241 != 0) goto <D.17242>; else goto <D.17243>;
    <D.17242>:
    shift.61 = (int) shift;
    D.17244 = 1 << shift.61;
    D.17245 = -D.17244;
    result = D.17245 | result;
    <D.17243>:
    <D.17240>:
    goto <D.16596>;
  }
  <D.16595>:
  goto <D.16597>;
  <D.16596>:
  *rptr = ptr;
  D.17246 = result;
  return D.17246;
}


read_leb128 (guint8 * ptr, guint8 * * rptr)
{
  guint8 * ptr.63;
  int D.17249;
  int D.17250;
  int shift.64;
  int D.17252;
  unsigned int D.17253;
  signed char byte.65;
  guint32 D.17256;
  guint32 result;
  guint32 shift;

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

    ptr.63 = ptr;
    ptr = ptr.63 + 1;
    byte = *ptr.63;
    D.17249 = (int) byte;
    D.17250 = D.17249 & 127;
    shift.64 = (int) shift;
    D.17252 = D.17250 << shift.64;
    D.17253 = (unsigned int) D.17252;
    result = D.17253 | result;
    byte.65 = (signed char) byte;
    if (byte.65 >= 0) goto <D.16586>; else goto <D.17255>;
    <D.17255>:
    shift = shift + 7;
  }
  goto <D.16587>;
  <D.16586>:
  *rptr = ptr;
  D.17256 = result;
  return D.17256;
}


read_variable (struct MonoDebugVarInfo * var, guint8 * ptr, guint8 * * rptr)
{
  guint8 * ptr.66;
  unsigned int D.17259;
  int D.17260;
  unsigned int D.17261;
  unsigned int D.17262;
  unsigned int D.17263;
  unsigned int D.17264;
  struct MonoType * * D.17265;
  guint8 * ptr.67;

  ptr.66 = ptr;
  D.17259 = read_leb128 (ptr.66, &ptr);
  var->index = D.17259;
  ptr.66 = ptr;
  D.17260 = read_sleb128 (ptr.66, &ptr);
  D.17261 = (unsigned int) D.17260;
  var->offset = D.17261;
  ptr.66 = ptr;
  D.17262 = read_leb128 (ptr.66, &ptr);
  var->size = D.17262;
  ptr.66 = ptr;
  D.17263 = read_leb128 (ptr.66, &ptr);
  var->begin_scope = D.17263;
  ptr.66 = ptr;
  D.17264 = read_leb128 (ptr.66, &ptr);
  var->end_scope = D.17264;
  D.17265 = &var->type;
  ptr.66 = ptr;
  memcpy (D.17265, ptr.66, 4);
  ptr.66 = ptr;
  ptr.67 = ptr.66 + 4;
  ptr = ptr.67;
  ptr.66 = ptr;
  *rptr = ptr.66;
}


mono_debug_lookup_method_addresses (struct MonoMethod * method)
{
  int mono_debug_debugger_version.68;
  unsigned int mono_debug_debugger_version.69;
  unsigned int D.17269;
  _Bool D.17270;
  long int D.17271;
  long int D.17272;
  struct MonoMethod * iftmp.70;
  unsigned int D.17276;
  unsigned int D.17277;
  struct GHashTable * data_table_hash.71;
  struct MonoDebugMethodHeader * header.72;
  struct MonoDebugMethodHeader * header.73;
  struct MonoDebugMethodAddressList * D.17286;
  struct GSList * D.17287;
  unsigned int D.17288;
  unsigned int D.17289;
  unsigned int count.74;
  unsigned int D.17291;
  unsigned int D.17292;
  unsigned int size.75;
  unsigned int size.76;
  unsigned int count.77;
  void * * D.17296;
  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.68 = mono_debug_debugger_version;
      mono_debug_debugger_version.69 = (unsigned int) mono_debug_debugger_version.68;
      D.17269 = mono_debug_debugger_version.69 + 4294967292;
      D.17270 = D.17269 > 1;
      D.17271 = (long int) D.17270;
      D.17272 = __builtin_expect (D.17271, 0);
      if (D.17272 != 0) goto <D.17273>; else goto <D.17274>;
      <D.17273>:
      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.17274>:
      mono_debugger_lock ();
      D.17276 = BIT_FIELD_REF <*method, 32, 160>;
      D.17277 = D.17276 & 4096;
      if (D.17277 != 0) goto <D.17278>; else goto <D.17279>;
      <D.17278>:
      iftmp.70 = MEM[(struct MonoMethodInflated *)method].declaring;
      goto <D.17280>;
      <D.17279>:
      iftmp.70 = method;
      <D.17280>:
      declaring = iftmp.70;
      data.method = declaring;
      data.result = 0B;
      data_table_hash.71 = data_table_hash;
      monoeg_g_hash_table_foreach (data_table_hash.71, lookup_method_address_func, &data);
      header.72 = data.result;
      header = header.72;
      header.73 = header;
      if (header.73 == 0B) goto <D.17284>; else goto <D.17285>;
      <D.17284>:
      mono_debugger_unlock ();
      D.17286 = 0B;
      return D.17286;
      <D.17285>:
      header.73 = header;
      D.17287 = header.73->address_list;
      D.17288 = monoeg_g_slist_length (D.17287);
      D.17289 = D.17288 + 1;
      count = (int) D.17289;
      count.74 = (unsigned int) count;
      D.17291 = count.74 + 2;
      D.17292 = D.17291 * 4;
      size = (int) D.17292;
      size.75 = (unsigned int) size;
      info = monoeg_malloc0 (size.75);
      size.76 = (unsigned int) size;
      info->size = size.76;
      count.77 = (unsigned int) count;
      info->count = count.77;
      ptr = &info->data;
      memcpy (ptr, &header, 4);
      ptr = ptr + 4;
      header.73 = header;
      list = header.73->address_list;
      goto <D.16668>;
      <D.16667>:
      D.17296 = &list->data;
      memcpy (ptr, D.17296, 4);
      ptr = ptr + 4;
      list = list->next;
      <D.16668>:
      if (list != 0B) goto <D.16667>; else goto <D.16669>;
      <D.16669>:
      mono_debugger_unlock ();
      D.17286 = info;
      return D.17286;
    }
  finally
    {
      header = {CLOBBER};
      data = {CLOBBER};
    }
}


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

  table = value;
  data = user_data;
  D.17299 = table->method_hash;
  D.17300 = data->method;
  header = monoeg_g_hash_table_lookup (D.17299, D.17300);
  if (header != 0B) goto <D.17301>; else goto <D.17302>;
  <D.17301>:
  data->result = header;
  <D.17302>:
}


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

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


il_offset_from_address (struct MonoMethod * method, struct MonoDomain * domain, guint32 native_offset)
{
  struct MonoDebugLineNumberEntry * D.17306;
  unsigned int D.17308;
  unsigned int D.17309;
  unsigned int i.78;
  unsigned int D.17311;
  struct MonoDebugLineNumberEntry * D.17312;
  unsigned int D.17313;
  gint32 D.17316;
  unsigned int D.17317;
  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.17305>;
  <D.17305>:
  D.17306 = jit->line_numbers;
  if (D.17306 == 0B) goto cleanup_and_fail; else goto <D.17307>;
  <D.17307>:
  D.17308 = jit->num_line_numbers;
  D.17309 = D.17308 + 4294967295;
  i = (int) D.17309;
  goto <D.16680>;
  <D.16679>:
  {
    struct MonoDebugLineNumberEntry lne;

    try
      {
        D.17306 = jit->line_numbers;
        i.78 = (unsigned int) i;
        D.17311 = i.78 * 8;
        D.17312 = D.17306 + D.17311;
        lne = *D.17312;
        D.17313 = lne.native_offset;
        if (D.17313 <= native_offset) goto <D.17314>; else goto <D.17315>;
        <D.17314>:
        mono_debug_free_method_jit_info (jit);
        D.17317 = lne.il_offset;
        D.17316 = (gint32) D.17317;
        return D.17316;
        <D.17315>:
      }
    finally
      {
        lne = {CLOBBER};
      }
  }
  i = i + -1;
  <D.16680>:
  if (i >= 0) goto <D.16679>; else goto <D.16681>;
  <D.16681>:
  cleanup_and_fail:
  mono_debug_free_method_jit_info (jit);
  D.17316 = -1;
  return D.17316;
}


mono_debug_lookup_source_location (struct MonoMethod * method, guint32 address, struct MonoDomain * domain)
{
  <unnamed type> mono_debug_format.79;
  struct MonoDebugSourceLocation * D.17324;
  struct MonoDebugHandle * D.17328;
  struct MonoSymbolFile * D.17330;
  int D.17332;
  unsigned int offset.80;
  struct MonoDebugMethodInfo * minfo;
  struct MonoDebugSourceLocation * location;
  gint32 offset;

  mono_debug_format.79 = mono_debug_format;
  if (mono_debug_format.79 == 0) goto <D.17322>; else goto <D.17323>;
  <D.17322>:
  D.17324 = 0B;
  return D.17324;
  <D.17323>:
  mono_debugger_lock ();
  minfo = _mono_debug_lookup_method (method);
  if (minfo == 0B) goto <D.17325>; else goto <D.17327>;
  <D.17327>:
  D.17328 = minfo->handle;
  if (D.17328 == 0B) goto <D.17325>; else goto <D.17329>;
  <D.17329>:
  D.17328 = minfo->handle;
  D.17330 = D.17328->symfile;
  if (D.17330 == 0B) goto <D.17325>; else goto <D.17331>;
  <D.17331>:
  D.17328 = minfo->handle;
  D.17330 = D.17328->symfile;
  D.17332 = mono_debug_symfile_is_loaded (D.17330);
  if (D.17332 == 0) goto <D.17325>; else goto <D.17326>;
  <D.17325>:
  mono_debugger_unlock ();
  D.17324 = 0B;
  return D.17324;
  <D.17326>:
  offset = il_offset_from_address (method, domain, address);
  if (offset < 0) goto <D.17333>; else goto <D.17334>;
  <D.17333>:
  mono_debugger_unlock ();
  D.17324 = 0B;
  return D.17324;
  <D.17334>:
  offset.80 = (unsigned int) offset;
  location = mono_debug_symfile_lookup_location (minfo, offset.80);
  mono_debugger_unlock ();
  D.17324 = location;
  return D.17324;
}


mono_debug_lookup_locals (struct MonoMethod * method)
{
  <unnamed type> mono_debug_format.81;
  struct MonoDebugLocalsInfo * D.17340;
  struct MonoDebugHandle * D.17344;
  struct MonoSymbolFile * D.17346;
  int D.17348;
  struct MonoDebugMethodInfo * minfo;
  struct MonoDebugLocalsInfo * res;

  mono_debug_format.81 = mono_debug_format;
  if (mono_debug_format.81 == 0) goto <D.17338>; else goto <D.17339>;
  <D.17338>:
  D.17340 = 0B;
  return D.17340;
  <D.17339>:
  mono_debugger_lock ();
  minfo = _mono_debug_lookup_method (method);
  if (minfo == 0B) goto <D.17341>; else goto <D.17343>;
  <D.17343>:
  D.17344 = minfo->handle;
  if (D.17344 == 0B) goto <D.17341>; else goto <D.17345>;
  <D.17345>:
  D.17344 = minfo->handle;
  D.17346 = D.17344->symfile;
  if (D.17346 == 0B) goto <D.17341>; else goto <D.17347>;
  <D.17347>:
  D.17344 = minfo->handle;
  D.17346 = D.17344->symfile;
  D.17348 = mono_debug_symfile_is_loaded (D.17346);
  if (D.17348 == 0) goto <D.17341>; else goto <D.17342>;
  <D.17341>:
  mono_debugger_unlock ();
  D.17340 = 0B;
  return D.17340;
  <D.17342>:
  res = mono_debug_symfile_lookup_locals (minfo);
  mono_debugger_unlock ();
  D.17340 = res;
  return D.17340;
}


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

  if (location != 0B) goto <D.17350>; else goto <D.17351>;
  <D.17350>:
  D.17352 = location->source_file;
  monoeg_g_free (D.17352);
  monoeg_g_free (location);
  <D.17351>:
}


mono_debug_print_stack_frame (struct MonoMethod * method, guint32 native_offset, struct MonoDomain * domain)
{
  char D.17353;
  int mono_debug_initialized.82;
  char * D.17365;
  unsigned int D.17366;
  char * D.17367;
  unsigned int D.17368;
  struct MonoDebugSourceLocation * location;
  gchar * fname;
  gchar * ptr;
  gchar * res;
  int offset;

  fname = mono_method_full_name (method, 1);
  ptr = fname;
  goto <D.16715>;
  <D.16714>:
  D.17353 = *ptr;
  if (D.17353 == 58) goto <D.17354>; else goto <D.17355>;
  <D.17354>:
  *ptr = 46;
  <D.17355>:
  ptr = ptr + 1;
  <D.16715>:
  D.17353 = *ptr;
  if (D.17353 != 0) goto <D.16714>; else goto <D.16716>;
  <D.16716>:
  location = mono_debug_lookup_source_location (method, native_offset, domain);
  if (location == 0B) goto <D.17356>; else goto <D.17357>;
  <D.17356>:
  mono_debug_initialized.82 = mono_debug_initialized;
  if (mono_debug_initialized.82 != 0) goto <D.17359>; else goto <D.17360>;
  <D.17359>:
  mono_debugger_lock ();
  offset = il_offset_from_address (method, domain, native_offset);
  mono_debugger_unlock ();
  goto <D.17361>;
  <D.17360>:
  offset = -1;
  <D.17361>:
  if (offset < 0) goto <D.17362>; else goto <D.17363>;
  <D.17362>:
  res = monoeg_g_strdup_printf ("at %s <0x%05x>", fname, native_offset);
  goto <D.17364>;
  <D.17363>:
  res = monoeg_g_strdup_printf ("at %s <IL 0x%05x, 0x%05x>", fname, offset, native_offset);
  <D.17364>:
  monoeg_g_free (fname);
  D.17365 = res;
  return D.17365;
  <D.17357>:
  D.17366 = location->il_offset;
  D.17367 = location->source_file;
  D.17368 = location->row;
  res = monoeg_g_strdup_printf ("at %s [0x%05x] in %s:%d", fname, D.17366, D.17367, D.17368);
  monoeg_g_free (fname);
  mono_debug_free_source_location (location);
  D.17365 = res;
  return D.17365;
}


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

  element = monoeg_malloc0 (8);
  element->data = data;
  ptr = list;
  goto <D.16724>;
  <D.16723>:
  D.17370 = *ptr;
  ptr = &D.17370->next;
  <D.16724>:
  D.17370 = *ptr;
  if (D.17370 != 0B) goto <D.16723>; else goto <D.16725>;
  <D.16725>:
  *ptr = element;
}


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

  ptr = list;
  goto <D.16735>;
  <D.16734>:
  D.17371 = *ptr;
  D.17372 = D.17371->data;
  if (D.17372 != data) goto <D.17373>; else goto <D.17374>;
  <D.17373>:
  // predicted unlikely by continue predictor.
  goto <D.16732>;
  <D.17374>:
  D.17371 = *ptr;
  next = D.17371->next;
  D.17371 = *ptr;
  monoeg_g_free (D.17371);
  *ptr = next;
  goto <D.16733>;
  <D.16732>:
  D.17371 = *ptr;
  ptr = &D.17371->next;
  <D.16735>:
  D.17371 = *ptr;
  if (D.17371 != 0B) goto <D.16734>; else goto <D.16733>;
  <D.16733>:
}


mono_set_is_debugger_attached (gboolean attached)
{
  is_attached = attached;
}


mono_is_debugger_attached ()
{
  mono_bool D.17375;

  D.17375 = is_attached;
  return D.17375;
}


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

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


mono_debug_enabled ()
{
  mono_bool D.17378;
  <unnamed type> mono_debug_format.84;
  _Bool D.17380;

  mono_debug_format.84 = mono_debug_format;
  D.17380 = mono_debug_format.84 != 0;
  D.17378 = (mono_bool) D.17380;
  return D.17378;
}