mono_debug_init (MonoDebugFormat format)
{
  int mono_debug_initialized.0;
  _Bool D.19363;
  long int D.19364;
  long int D.19365;
  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.19374;

  mono_debug_initialized.0 = mono_debug_initialized;
  D.19363 = mono_debug_initialized.0 != 0;
  D.19364 = (long int) D.19363;
  D.19365 = __builtin_expect (D.19364, 0);
  if (D.19365 != 0) goto <D.19366>; else goto <D.19367>;
  <D.19366>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "mono-debug.c", 228, "!mono_debug_initialized");
  <D.19367>:
  if (format == 2) goto <D.19368>; else goto <D.19369>;
  <D.19368>:
  monoeg_g_log (0B, 4, "The mdb debugger is no longer supported.");
  <D.19025>:
  goto <D.19025>;
  <D.19369>:
  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.19374 = create_data_table (0B);
  mono_symbol_table.2->global_data_table = D.19374;
  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.19375>; else goto <D.19376>;
  <D.19375>:
  mono_debug_open_image (image, 0B, 0);
  <D.19376>:
  mono_debugger_unlock ();
}


open_symfile_from_bundle (struct MonoImage * image)
{
  int D.19351;
  const char * D.19377;
  const char * D.19378;
  struct MonoDebugHandle * D.19381;
  const mono_byte * D.19382;
  int D.19383;
  struct BundledSymfile * bsymfile;

  bsymfile = bundled_symfiles;
  goto <D.19354>;
  <D.19353>:
  {
    size_t __s1_len;
    size_t __s2_len;

    D.19377 = bsymfile->aname;
    D.19378 = image->module_name;
    D.19351 = __builtin_strcmp (D.19377, D.19378);
  }
  if (D.19351 != 0) goto <D.19379>; else goto <D.19380>;
  <D.19379>:
  // predicted unlikely by continue predictor.
  goto <D.19352>;
  <D.19380>:
  D.19382 = bsymfile->raw_contents;
  D.19383 = bsymfile->size;
  D.19381 = mono_debug_open_image (image, D.19382, D.19383);
  return D.19381;
  <D.19352>:
  bsymfile = bsymfile->next;
  <D.19354>:
  if (bsymfile != 0B) goto <D.19353>; else goto <D.19355>;
  <D.19355>:
  D.19381 = 0B;
  return D.19381;
}


mono_debug_open_image (struct MonoImage * image, const guint8 * raw_contents, int size)
{
  int D.19385;
  struct MonoDebugHandle * D.19388;
  int next_symbol_file_id.5;
  int next_symbol_file_id.6;
  unsigned int next_symbol_file_id.7;
  const char * D.19394;
  gchar * D.19395;
  struct MonoDebugDataTable * D.19396;
  struct MonoSymbolFile * D.19397;
  struct MonoSymbolTable * mono_symbol_table.8;
  struct MonoDebugList * * D.19399;
  struct GHashTable * mono_debug_handles.9;
  struct MonoDebugHandle * handle;

  D.19385 = mono_image_is_dynamic (image);
  if (D.19385 != 0) goto <D.19386>; else goto <D.19387>;
  <D.19386>:
  D.19388 = 0B;
  return D.19388;
  <D.19387>:
  mono_debugger_lock ();
  handle = _mono_debug_get_image (image);
  if (handle != 0B) goto <D.19389>; else goto <D.19390>;
  <D.19389>:
  mono_debugger_unlock ();
  D.19388 = handle;
  return D.19388;
  <D.19390>:
  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.19394 = mono_image_get_filename (image);
  D.19395 = monoeg_strdup (D.19394);
  handle->image_file = D.19395;
  D.19396 = create_data_table (0B);
  handle->type_table = D.19396;
  D.19397 = mono_debug_open_mono_symbols (handle, raw_contents, size, 0);
  handle->symfile = D.19397;
  mono_symbol_table.8 = mono_symbol_table;
  D.19399 = &mono_symbol_table.8->symbol_files;
  mono_debug_list_add (D.19399, 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.19388 = handle;
  return D.19388;
}


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

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


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

  if (str != 0B) goto <D.19405>; else goto <D.19406>;
  <D.19405>:
  D.19407 = __strdup (str);
  return D.19407;
  <D.19406>:
  D.19407 = 0B;
  return D.19407;
}


mono_debug_add_type (struct MonoClass * klass)
{
  struct MonoClass * klass.11;
  struct MonoGenericClass * D.19412;
  unsigned char D.19414;
  unsigned char D.19416;
  struct MonoImage * D.19418;
  unsigned char D.19424;
  unsigned char D.19425;
  unsigned int D.19428;
  guint8 * ptr.12;
  int D.19430;
  int D.19431;
  unsigned int D.19432;
  guint8 * ptr.13;
  int ptr.14;
  int oldptr.15;
  int D.19436;
  _Bool D.19437;
  long int D.19438;
  long int D.19439;
  unsigned int D.19442;
  _Bool D.19443;
  long int D.19444;
  long int D.19445;
  struct MonoDebugDataTable * D.19448;
  guint8[0:] * D.19449;
  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.19412 = klass.11->generic_class;
      if (D.19412 != 0B) goto <D.19409>; else goto <D.19413>;
      <D.19413>:
      klass.11 = klass;
      D.19414 = klass.11->rank;
      if (D.19414 != 0) goto <D.19409>; else goto <D.19415>;
      <D.19415>:
      klass.11 = klass;
      D.19416 = klass.11->byval_arg.type;
      if (D.19416 == 19) goto <D.19409>; else goto <D.19417>;
      <D.19417>:
      klass.11 = klass;
      D.19416 = klass.11->byval_arg.type;
      if (D.19416 == 30) goto <D.19409>; else goto <D.19410>;
      <D.19409>:
      return;
      <D.19410>:
      mono_debugger_lock ();
      klass.11 = klass;
      D.19418 = klass.11->image;
      handle = _mono_debug_get_image (D.19418);
      if (handle == 0B) goto <D.19419>; else goto <D.19420>;
      <D.19419>:
      mono_debugger_unlock ();
      return;
      <D.19420>:
      max_size = 16;
      if (max_size > 8192) goto <D.19421>; else goto <D.19422>;
      <D.19421>:
      oldptr = monoeg_malloc (max_size);
      ptr = oldptr;
      goto <D.19423>;
      <D.19422>:
      oldptr = &buffer;
      ptr = oldptr;
      <D.19423>:
      klass.11 = klass;
      D.19424 = BIT_FIELD_REF <*klass.11, 8, 160>;
      D.19425 = D.19424 & 8;
      if (D.19425 != 0) goto <D.19426>; else goto <D.19427>;
      <D.19426>:
      base_offset = -8;
      <D.19427>:
      klass.11 = klass;
      D.19428 = klass.11->type_token;
      ptr.12 = ptr;
      write_leb128 (D.19428, ptr.12, &ptr);
      klass.11 = klass;
      D.19430 = klass.11->instance_size;
      D.19431 = D.19430 + base_offset;
      D.19432 = (unsigned int) D.19431;
      ptr.12 = ptr;
      write_leb128 (D.19432, 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.19436 = ptr.14 - oldptr.15;
      size = (guint32) D.19436;
      D.19437 = size >= max_size;
      D.19438 = (long int) D.19437;
      D.19439 = __builtin_expect (D.19438, 0);
      if (D.19439 != 0) goto <D.19440>; else goto <D.19441>;
      <D.19440>:
      monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "mono-debug.c", 906, "size < max_size");
      <D.19441>:
      total_size = size + 4;
      D.19442 = total_size + 9;
      D.19443 = D.19442 > 16363;
      D.19444 = (long int) D.19443;
      D.19445 = __builtin_expect (D.19444, 0);
      if (D.19445 != 0) goto <D.19446>; else goto <D.19447>;
      <D.19446>:
      monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "mono-debug.c", 909, "total_size + 9 < DATA_TABLE_CHUNK_SIZE");
      <D.19447>:
      D.19448 = handle->type_table;
      entry = allocate_data_item (D.19448, 1, total_size);
      entry->size = total_size;
      D.19449 = &entry->data;
      memcpy (D.19449, oldptr, size);
      D.19448 = handle->type_table;
      write_data_item (D.19448, entry);
      if (max_size > 8192) goto <D.19450>; else goto <D.19451>;
      <D.19450>:
      monoeg_g_free (oldptr);
      <D.19451>:
      mono_debugger_unlock ();
    }
  finally
    {
      buffer = {CLOBBER};
      ptr = {CLOBBER};
    }
}


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

  <D.19102>:
  {
    guint8 byte;

    D.19455 = (unsigned char) value;
    byte = D.19455 & 127;
    value = value >> 7;
    if (value != 0) goto <D.19456>; else goto <D.19457>;
    <D.19456>:
    byte = byte | 128;
    <D.19457>:
    ptr.16 = ptr;
    ptr = ptr.16 + 1;
    *ptr.16 = byte;
  }
  if (value != 0) goto <D.19102>; else goto <D.19103>;
  <D.19103>:
  *rptr = ptr;
}


allocate_data_item (struct MonoDebugDataTable * table, MonoDebugDataItemType type, guint32 size)
{
  unsigned int D.19459;
  unsigned int D.19460;
  struct MonoDebugDataChunk * D.19464;
  unsigned int D.19465;
  unsigned int D.19466;
  _Bool D.19467;
  long int D.19468;
  long int D.19469;
  unsigned int D.19472;
  unsigned int D.19473;
  unsigned int D.19474;
  unsigned int D.19477;
  guint8 * D.19478;
  guint32 chunk_size;
  guint8 * data;

  D.19459 = size + 3;
  size = D.19459 & 4294967292;
  D.19460 = size + 16;
  if (D.19460 <= 16363) goto <D.19461>; else goto <D.19462>;
  <D.19461>:
  chunk_size = 16364;
  goto <D.19463>;
  <D.19462>:
  chunk_size = size + 16;
  <D.19463>:
  D.19464 = table->current_chunk;
  D.19465 = D.19464->current_offset;
  D.19464 = table->current_chunk;
  D.19466 = D.19464->allocated_size;
  D.19467 = D.19465 != D.19466;
  D.19468 = (long int) D.19467;
  D.19469 = __builtin_expect (D.19468, 0);
  if (D.19469 != 0) goto <D.19470>; else goto <D.19471>;
  <D.19470>:
  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.19471>:
  D.19464 = table->current_chunk;
  D.19466 = D.19464->allocated_size;
  D.19472 = D.19466 + size;
  D.19473 = D.19472 + 8;
  D.19464 = table->current_chunk;
  D.19474 = D.19464->total_size;
  if (D.19473 >= D.19474) goto <D.19475>; else goto <D.19476>;
  <D.19475>:
  {
    struct MonoDebugDataChunk * new_chunk;

    D.19477 = chunk_size + 20;
    new_chunk = monoeg_malloc0 (D.19477);
    new_chunk->total_size = chunk_size;
    D.19464 = table->current_chunk;
    D.19464->next = new_chunk;
    table->current_chunk = new_chunk;
  }
  <D.19476>:
  D.19464 = table->current_chunk;
  D.19464 = table->current_chunk;
  D.19466 = D.19464->allocated_size;
  data = &D.19464->data[D.19466];
  D.19464 = table->current_chunk;
  D.19464 = table->current_chunk;
  D.19466 = D.19464->allocated_size;
  D.19472 = D.19466 + size;
  D.19473 = D.19472 + 8;
  D.19464->allocated_size = D.19473;
  MEM[(guint32 *)data] = size;
  data = data + 4;
  MEM[(guint32 *)data] = type;
  data = data + 4;
  D.19478 = data;
  return D.19478;
}


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

  D.19481 = __builtin_object_size (__dest, 0);
  D.19480 = __builtin___memcpy_chk (__dest, __src, __len, D.19481);
  return D.19480;
}


write_data_item (struct MonoDebugDataTable * table, const guint8 * data)
{
  unsigned int D.19483;
  unsigned int D.19484;
  unsigned int D.19485;
  unsigned int D.19486;
  _Bool D.19487;
  long int D.19488;
  long int D.19489;
  struct MonoDebugDataChunk * current_chunk;
  guint32 size;

  current_chunk = table->current_chunk;
  size = MEM[(guint32 *)data + 4294967288B];
  D.19483 = current_chunk->current_offset;
  D.19484 = D.19483 + size;
  D.19485 = D.19484 + 8;
  D.19486 = current_chunk->allocated_size;
  D.19487 = D.19485 != D.19486;
  D.19488 = (long int) D.19487;
  D.19489 = __builtin_expect (D.19488, 0);
  if (D.19489 != 0) goto <D.19490>; else goto <D.19491>;
  <D.19490>:
  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.19491>:
  D.19486 = current_chunk->allocated_size;
  current_chunk->current_offset = D.19486;
}


free_data_table (struct MonoDebugDataTable * table)
{
  struct GHashTable * D.19492;
  struct GHashTable * D.19493;
  struct MonoDebugDataChunk * D.19494;
  struct MonoSymbolTable * mono_symbol_table.17;
  struct MonoDebugList * * D.19496;
  struct MonoDebugDataChunk * chunk;
  struct MonoDebugDataChunk * next_chunk;

  D.19492 = table->method_hash;
  monoeg_g_hash_table_foreach (D.19492, free_header_data, 0B);
  D.19492 = table->method_hash;
  monoeg_g_hash_table_destroy (D.19492);
  D.19493 = table->method_address_hash;
  monoeg_g_hash_table_destroy (D.19493);
  table->method_hash = 0B;
  table->method_address_hash = 0B;
  chunk = table->first_chunk;
  goto <D.19012>;
  <D.19011>:
  next_chunk = chunk->next;
  monoeg_g_free (chunk);
  chunk = next_chunk;
  <D.19012>:
  if (chunk != 0B) goto <D.19011>; else goto <D.19013>;
  <D.19013>:
  table->current_chunk = 0B;
  D.19494 = table->current_chunk;
  table->first_chunk = D.19494;
  mono_symbol_table.17 = mono_symbol_table;
  D.19496 = &mono_symbol_table.17->data_tables;
  mono_debug_list_remove (D.19496, table);
  monoeg_g_free (table);
}


free_header_data (void * key, void * value, void * user_data)
{
  struct MonoDebugWrapperData * D.19497;
  const gchar * D.19500;
  struct GSList * D.19501;
  struct MonoDebugMethodHeader * header;

  header = value;
  D.19497 = header->wrapper_data;
  if (D.19497 != 0B) goto <D.19498>; else goto <D.19499>;
  <D.19498>:
  D.19497 = header->wrapper_data;
  D.19500 = D.19497->method_name;
  monoeg_g_free (D.19500);
  D.19497 = header->wrapper_data;
  monoeg_g_free (D.19497);
  <D.19499>:
  D.19501 = header->address_list;
  monoeg_g_slist_free (D.19501);
}


free_debug_handle (struct MonoDebugHandle * handle)
{
  struct MonoSymbolFile * D.19502;
  struct MonoDebugDataTable * D.19505;
  struct MonoImage * D.19506;
  char * D.19507;

  D.19502 = handle->symfile;
  if (D.19502 != 0B) goto <D.19503>; else goto <D.19504>;
  <D.19503>:
  D.19502 = handle->symfile;
  mono_debug_close_mono_symbol_file (D.19502);
  <D.19504>:
  D.19505 = handle->type_table;
  free_data_table (D.19505);
  D.19506 = handle->image;
  mono_image_close (D.19506);
  D.19507 = handle->image_file;
  monoeg_g_free (D.19507);
  monoeg_g_free (handle);
}


create_data_table (struct MonoDomain * domain)
{
  int iftmp.18;
  struct GHashTable * D.19512;
  struct GHashTable * D.19513;
  struct MonoDebugDataChunk * D.19514;
  struct MonoSymbolTable * mono_symbol_table.19;
  struct MonoDebugList * * D.19518;
  struct GHashTable * data_table_hash.20;
  struct MonoDebugDataTable * D.19520;
  struct MonoDebugDataTable * table;
  struct MonoDebugDataChunk * chunk;

  table = monoeg_malloc0 (24);
  if (domain != 0B) goto <D.19509>; else goto <D.19510>;
  <D.19509>:
  iftmp.18 = mono_domain_get_id (domain);
  goto <D.19511>;
  <D.19510>:
  iftmp.18 = -1;
  <D.19511>:
  table->domain = iftmp.18;
  D.19512 = monoeg_g_hash_table_new (0B, 0B);
  table->method_address_hash = D.19512;
  D.19513 = monoeg_g_hash_table_new (0B, 0B);
  table->method_hash = D.19513;
  chunk = monoeg_malloc0 (16384);
  chunk->total_size = 16364;
  table->current_chunk = chunk;
  D.19514 = table->current_chunk;
  table->first_chunk = D.19514;
  if (domain != 0B) goto <D.19515>; else goto <D.19516>;
  <D.19515>:
  mono_symbol_table.19 = mono_symbol_table;
  D.19518 = &mono_symbol_table.19->data_tables;
  mono_debug_list_add (D.19518, table);
  data_table_hash.20 = data_table_hash;
  monoeg_g_hash_table_insert_replace (data_table_hash.20, domain, table, 0);
  <D.19516>:
  D.19520 = table;
  return D.19520;
}


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

  mono_debug_initialized.21 = mono_debug_initialized;
  if (mono_debug_initialized.21 == 0) goto <D.19523>; else goto <D.19524>;
  <D.19523>:
  return;
  <D.19524>:
  mono_symbol_table.22 = mono_symbol_table;
  D.19526 = mono_defaults.corlib;
  D.19527 = mono_debug_open_image (D.19526, 0B, 0);
  mono_symbol_table.22->corlib = D.19527;
}


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.19530>; else goto <D.19531>;
  <D.19530>:
  return;
  <D.19531>:
  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.19542;

  mono_debug_handles.24 = mono_debug_handles;
  if (mono_debug_handles.24 != 0B) goto <D.19534>; else goto <D.19535>;
  <D.19534>:
  mono_debug_handles.24 = mono_debug_handles;
  monoeg_g_hash_table_destroy (mono_debug_handles.24);
  <D.19535>:
  mono_debug_handles = 0B;
  data_table_hash.25 = data_table_hash;
  if (data_table_hash.25 != 0B) goto <D.19537>; else goto <D.19538>;
  <D.19537>:
  data_table_hash.25 = data_table_hash;
  monoeg_g_hash_table_destroy (data_table_hash.25);
  data_table_hash = 0B;
  <D.19538>:
  mono_symbol_table.26 = mono_symbol_table;
  if (mono_symbol_table.26 != 0B) goto <D.19540>; else goto <D.19541>;
  <D.19540>:
  mono_symbol_table.26 = mono_symbol_table;
  D.19542 = mono_symbol_table.26->global_data_table;
  if (D.19542 != 0B) goto <D.19543>; else goto <D.19544>;
  <D.19543>:
  mono_symbol_table.26 = mono_symbol_table;
  D.19542 = mono_symbol_table.26->global_data_table;
  free_data_table (D.19542);
  <D.19544>:
  mono_symbol_table.26 = mono_symbol_table;
  monoeg_g_free (mono_symbol_table.26);
  mono_symbol_table = 0B;
  <D.19541>:
}


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.19546>; else goto <D.19547>;
  <D.19546>:
  return;
  <D.19547>:
  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.19555;
  struct MonoDebugDataTable * table;

  mono_debug_initialized.28 = mono_debug_initialized;
  if (mono_debug_initialized.28 == 0) goto <D.19550>; else goto <D.19551>;
  <D.19550>:
  return;
  <D.19551>:
  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.19553>; else goto <D.19554>;
  <D.19553>:
  D.19555 = mono_domain_get_id (domain);
  monoeg_g_log (0B, 16, "mono-debug.c:337:: unloading unknown domain %p / %d", domain, D.19555);
  mono_debugger_unlock ();
  return;
  <D.19554>:
  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.19563;
  struct GHashTable * mono_debug_handles.32;
  struct MonoDebugHandle * handle;

  mono_debug_initialized.30 = mono_debug_initialized;
  if (mono_debug_initialized.30 == 0) goto <D.19558>; else goto <D.19559>;
  <D.19558>:
  return;
  <D.19559>:
  mono_debugger_lock ();
  handle = _mono_debug_get_image (image);
  if (handle == 0B) goto <D.19560>; else goto <D.19561>;
  <D.19560>:
  mono_debugger_unlock ();
  return;
  <D.19561>:
  mono_symbol_table.31 = mono_symbol_table;
  D.19563 = &mono_symbol_table.31->symbol_files;
  mono_debug_list_remove (D.19563, 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.19566;
  struct MonoDebugMethodInfo * minfo;

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


_mono_debug_lookup_method (struct MonoMethod * method)
{
  struct GHashTable * mono_debug_handles.33;
  struct MonoDebugMethodInfo * D.19571;
  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.19569>; else goto <D.19570>;
      <D.19569>:
      D.19571 = 0B;
      return D.19571;
      <D.19570>:
      mono_debug_handles.33 = mono_debug_handles;
      monoeg_g_hash_table_foreach (mono_debug_handles.33, lookup_method_func, &data);
      D.19571 = data.minfo;
      return D.19571;
    }
  finally
    {
      data = {CLOBBER};
    }
}


lookup_method_func (void * key, void * value, void * user_data)
{
  struct MonoDebugMethodInfo * D.19574;
  struct MonoSymbolFile * D.19577;
  struct MonoMethod * D.19580;
  struct MonoDebugMethodInfo * D.19581;
  struct MonoDebugHandle * handle;
  struct LookupMethodData * data;

  handle = value;
  data = user_data;
  D.19574 = data->minfo;
  if (D.19574 != 0B) goto <D.19575>; else goto <D.19576>;
  <D.19575>:
  return;
  <D.19576>:
  D.19577 = handle->symfile;
  if (D.19577 != 0B) goto <D.19578>; else goto <D.19579>;
  <D.19578>:
  D.19580 = data->method;
  D.19581 = mono_debug_symfile_lookup_method (handle, D.19580);
  data->minfo = D.19581;
  <D.19579>:
}


mono_debug_add_method (struct MonoMethod * method, struct MonoDebugMethodJitInfo * jit, struct MonoDomain * domain)
{
  struct MonoClass * D.19583;
  struct MonoImage * D.19584;
  short unsigned int D.19588;
  unsigned int D.19589;
  unsigned int D.19590;
  short unsigned int D.19592;
  unsigned int D.19593;
  unsigned int D.19594;
  unsigned char D.19596;
  unsigned char D.19597;
  unsigned int D.19598;
  unsigned int D.19599;
  unsigned int D.19600;
  unsigned int D.19601;
  unsigned int D.19602;
  unsigned int D.19603;
  unsigned int D.19604;
  unsigned int D.19605;
  unsigned int D.19609;
  guint8 * ptr.34;
  unsigned int D.19611;
  struct MonoDebugLineNumberEntry * D.19612;
  unsigned int D.19613;
  unsigned int D.19614;
  int D.19615;
  unsigned int D.19616;
  int D.19617;
  guint8 * ptr.35;
  guint8 * ptr.36;
  struct MonoDebugVarInfo * D.19620;
  _Bool D.19621;
  unsigned char D.19622;
  struct MonoDebugVarInfo * D.19625;
  unsigned int D.19626;
  struct MonoDebugVarInfo * D.19627;
  struct MonoDebugVarInfo * D.19628;
  struct MonoDebugVarInfo * D.19629;
  guint8 * ptr.37;
  guint8 * ptr.38;
  struct MonoDebugVarInfo * D.19632;
  _Bool D.19633;
  unsigned char D.19634;
  struct MonoDebugVarInfo * D.19637;
  int ptr.39;
  int oldptr.40;
  int D.19640;
  _Bool D.19641;
  long int D.19642;
  long int D.19643;
  unsigned char D.19646;
  unsigned char D.19647;
  uint32_t iftmp.41;
  int D.19655;
  unsigned int D.19656;
  uint32_t iftmp.42;
  const mono_byte * D.19661;
  unsigned int D.19662;
  guint8[0:] * D.19663;
  struct MonoMethod * iftmp.43;
  unsigned char D.19667;
  struct GHashTable * D.19671;
  <unnamed-unsigned:5> D.19676;
  unsigned int D.19677;
  char * D.19678;
  struct MonoDebugWrapperData * D.19680;
  struct GSList * D.19681;
  struct GSList * D.19682;
  struct GHashTable * D.19683;
  struct MonoDebugMethodAddress * D.19686;
  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.19583 = method->klass;
      D.19584 = D.19583->image;
      handle = _mono_debug_get_image (D.19584);
      minfo = _mono_debug_lookup_method (method);
      if (minfo == 0B) goto <D.19585>; else goto <D.19587>;
      <D.19587>:
      D.19588 = method->iflags;
      D.19589 = (unsigned int) D.19588;
      D.19590 = D.19589 & 4099;
      if (D.19590 != 0) goto <D.19585>; else goto <D.19591>;
      <D.19591>:
      D.19592 = method->flags;
      D.19593 = (unsigned int) D.19592;
      D.19594 = D.19593 & 9216;
      if (D.19594 != 0) goto <D.19585>; else goto <D.19595>;
      <D.19595>:
      D.19596 = BIT_FIELD_REF <*method, 8, 160>;
      D.19597 = D.19596 & 124;
      if (D.19597 != 0) goto <D.19585>; else goto <D.19586>;
      <D.19585>:
      is_wrapper = 1;
      <D.19586>:
      D.19598 = jit->num_line_numbers;
      D.19599 = D.19598 * 10;
      D.19600 = jit->num_params;
      D.19601 = jit->num_locals;
      D.19602 = D.19600 + D.19601;
      D.19603 = D.19602 + 1;
      D.19604 = D.19603 * 29;
      D.19605 = D.19599 + D.19604;
      max_size = D.19605 + 26;
      if (max_size > 8192) goto <D.19606>; else goto <D.19607>;
      <D.19606>:
      oldptr = monoeg_malloc (max_size);
      ptr = oldptr;
      goto <D.19608>;
      <D.19607>:
      oldptr = &buffer;
      ptr = oldptr;
      <D.19608>:
      D.19609 = jit->prologue_end;
      ptr.34 = ptr;
      write_leb128 (D.19609, ptr.34, &ptr);
      D.19611 = jit->epilogue_begin;
      ptr.34 = ptr;
      write_leb128 (D.19611, ptr.34, &ptr);
      D.19598 = jit->num_line_numbers;
      ptr.34 = ptr;
      write_leb128 (D.19598, ptr.34, &ptr);
      i = 0;
      goto <D.19140>;
      <D.19139>:
      {
        struct MonoDebugLineNumberEntry * lne;

        D.19612 = jit->line_numbers;
        D.19613 = i * 8;
        lne = D.19612 + D.19613;
        D.19614 = lne->il_offset;
        D.19615 = (int) D.19614;
        ptr.34 = ptr;
        write_sleb128 (D.19615, ptr.34, &ptr);
        D.19616 = lne->native_offset;
        D.19617 = (int) D.19616;
        ptr.34 = ptr;
        write_sleb128 (D.19617, ptr.34, &ptr);
      }
      i = i + 1;
      <D.19140>:
      D.19598 = jit->num_line_numbers;
      if (D.19598 > i) goto <D.19139>; else goto <D.19141>;
      <D.19141>:
      ptr.34 = ptr;
      ptr.35 = ptr.34;
      ptr.36 = ptr.35 + 1;
      ptr = ptr.36;
      D.19620 = jit->this_var;
      D.19621 = D.19620 != 0B;
      D.19622 = (unsigned char) D.19621;
      *ptr.35 = D.19622;
      D.19620 = jit->this_var;
      if (D.19620 != 0B) goto <D.19623>; else goto <D.19624>;
      <D.19623>:
      D.19620 = jit->this_var;
      ptr.34 = ptr;
      write_variable (D.19620, ptr.34, &ptr);
      <D.19624>:
      D.19600 = jit->num_params;
      ptr.34 = ptr;
      write_leb128 (D.19600, ptr.34, &ptr);
      i = 0;
      goto <D.19143>;
      <D.19142>:
      D.19625 = jit->params;
      D.19626 = i * 24;
      D.19627 = D.19625 + D.19626;
      ptr.34 = ptr;
      write_variable (D.19627, ptr.34, &ptr);
      i = i + 1;
      <D.19143>:
      D.19600 = jit->num_params;
      if (D.19600 > i) goto <D.19142>; else goto <D.19144>;
      <D.19144>:
      D.19601 = jit->num_locals;
      ptr.34 = ptr;
      write_leb128 (D.19601, ptr.34, &ptr);
      i = 0;
      goto <D.19146>;
      <D.19145>:
      D.19628 = jit->locals;
      D.19626 = i * 24;
      D.19629 = D.19628 + D.19626;
      ptr.34 = ptr;
      write_variable (D.19629, ptr.34, &ptr);
      i = i + 1;
      <D.19146>:
      D.19601 = jit->num_locals;
      if (D.19601 > i) goto <D.19145>; else goto <D.19147>;
      <D.19147>:
      ptr.34 = ptr;
      ptr.37 = ptr.34;
      ptr.38 = ptr.37 + 1;
      ptr = ptr.38;
      D.19632 = jit->gsharedvt_info_var;
      D.19633 = D.19632 != 0B;
      D.19634 = (unsigned char) D.19633;
      *ptr.37 = D.19634;
      D.19632 = jit->gsharedvt_info_var;
      if (D.19632 != 0B) goto <D.19635>; else goto <D.19636>;
      <D.19635>:
      D.19632 = jit->gsharedvt_info_var;
      ptr.34 = ptr;
      write_variable (D.19632, ptr.34, &ptr);
      D.19637 = jit->gsharedvt_locals_var;
      ptr.34 = ptr;
      write_variable (D.19637, ptr.34, &ptr);
      <D.19636>:
      ptr.34 = ptr;
      ptr.39 = (int) ptr.34;
      oldptr.40 = (int) oldptr;
      D.19640 = ptr.39 - oldptr.40;
      size = (guint32) D.19640;
      D.19641 = size >= max_size;
      D.19642 = (long int) D.19641;
      D.19643 = __builtin_expect (D.19642, 0);
      if (D.19643 != 0) goto <D.19644>; else goto <D.19645>;
      <D.19644>:
      monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "mono-debug.c", 639, "size < max_size");
      <D.19645>:
      total_size = size + 40;
      D.19646 = BIT_FIELD_REF <*method, 8, 168>;
      D.19647 = D.19646 & 2;
      if (D.19647 != 0) goto <D.19648>; else goto <D.19649>;
      <D.19648>:
      address = monoeg_malloc0 (total_size);
      goto <D.19650>;
      <D.19649>:
      address = allocate_data_item (table, 2, total_size);
      <D.19650>:
      address->header.size = total_size;
      if (handle != 0B) goto <D.19652>; else goto <D.19653>;
      <D.19652>:
      iftmp.41 = handle->index;
      goto <D.19654>;
      <D.19653>:
      iftmp.41 = 0;
      <D.19654>:
      address->header.symfile_id = iftmp.41;
      D.19655 = mono_domain_get_id (domain);
      D.19656 = (unsigned int) D.19655;
      address->header.domain_id = D.19656;
      if (is_wrapper == 0) goto <D.19658>; else goto <D.19659>;
      <D.19658>:
      iftmp.42 = minfo->index;
      goto <D.19660>;
      <D.19659>:
      iftmp.42 = 0;
      <D.19660>:
      address->header.method_id = iftmp.42;
      address->header.method = method;
      D.19661 = jit->code_start;
      address->code_start = D.19661;
      D.19662 = jit->code_size;
      address->code_size = D.19662;
      D.19663 = &address->data;
      memcpy (D.19663, oldptr, size);
      if (max_size > 8192) goto <D.19664>; else goto <D.19665>;
      <D.19664>:
      monoeg_g_free (oldptr);
      <D.19665>:
      D.19646 = BIT_FIELD_REF <*method, 8, 168>;
      D.19667 = D.19646 & 16;
      if (D.19667 != 0) goto <D.19668>; else goto <D.19669>;
      <D.19668>:
      iftmp.43 = MEM[(struct MonoMethodInflated *)method].declaring;
      goto <D.19670>;
      <D.19669>:
      iftmp.43 = method;
      <D.19670>:
      declaring = iftmp.43;
      D.19671 = table->method_hash;
      header = monoeg_g_hash_table_lookup (D.19671, declaring);
      if (header == 0B) goto <D.19672>; else goto <D.19673>;
      <D.19672>:
      header = &address->header;
      D.19671 = table->method_hash;
      monoeg_g_hash_table_insert_replace (D.19671, declaring, header, 0);
      if (is_wrapper != 0) goto <D.19674>; else goto <D.19675>;
      <D.19674>:
      {
        struct MonoDebugWrapperData * wrapper;

        wrapper = monoeg_malloc0 (12);
        header->wrapper_data = wrapper;
        D.19676 = method->wrapper_type;
        D.19677 = (unsigned int) D.19676;
        wrapper->wrapper_type = D.19677;
        D.19678 = mono_method_full_name (declaring, 1);
        wrapper->method_name = D.19678;
        wrapper->obsolete_cil_code = "";
      }
      <D.19675>:
      goto <D.19679>;
      <D.19673>:
      D.19680 = header->wrapper_data;
      address->header.wrapper_data = D.19680;
      D.19681 = header->address_list;
      D.19682 = monoeg_g_slist_prepend (D.19681, address);
      header->address_list = D.19682;
      <D.19679>:
      D.19683 = table->method_address_hash;
      monoeg_g_hash_table_insert_replace (D.19683, method, address, 0);
      D.19646 = BIT_FIELD_REF <*method, 8, 168>;
      D.19647 = D.19646 & 2;
      if (D.19647 == 0) goto <D.19684>; else goto <D.19685>;
      <D.19684>:
      write_data_item (table, address);
      <D.19685>:
      mono_debugger_unlock ();
      D.19686 = address;
      return D.19686;
    }
  finally
    {
      buffer = {CLOBBER};
      ptr = {CLOBBER};
    }
}


lookup_data_table (struct MonoDomain * domain)
{
  struct GHashTable * data_table_hash.44;
  _Bool D.19692;
  long int D.19693;
  long int D.19694;
  struct MonoDebugDataTable * D.19697;
  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.19690>; else goto <D.19691>;
  <D.19690>:
  monoeg_g_log (0B, 4, "lookup_data_table () failed for %p\n", domain);
  <D.19018>:
  goto <D.19018>;
  D.19692 = table == 0B;
  D.19693 = (long int) D.19692;
  D.19694 = __builtin_expect (D.19693, 0);
  if (D.19694 != 0) goto <D.19695>; else goto <D.19696>;
  <D.19695>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "mono-debug.c", 201, "table");
  <D.19696>:
  <D.19691>:
  D.19697 = table;
  return D.19697;
}


write_sleb128 (gint32 value, guint8 * ptr, guint8 * * rptr)
{
  unsigned char D.19699;
  int D.19705;
  int D.19706;
  guint8 * ptr.45;
  gboolean more;

  more = 1;
  goto <D.19112>;
  <D.19111>:
  {
    guint8 byte;

    D.19699 = (unsigned char) value;
    byte = D.19699 & 127;
    value = value >> 7;
    if (value == 0) goto <D.19704>; else goto <D.19700>;
    <D.19704>:
    D.19705 = (int) byte;
    D.19706 = D.19705 & 64;
    if (D.19706 == 0) goto <D.19701>; else goto <D.19700>;
    <D.19700>:
    if (value == -1) goto <D.19707>; else goto <D.19702>;
    <D.19707>:
    D.19705 = (int) byte;
    D.19706 = D.19705 & 64;
    if (D.19706 != 0) goto <D.19701>; else goto <D.19702>;
    <D.19701>:
    more = 0;
    goto <D.19703>;
    <D.19702>:
    byte = byte | 128;
    <D.19703>:
    ptr.45 = ptr;
    ptr = ptr.45 + 1;
    *ptr.45 = byte;
  }
  <D.19112>:
  if (more != 0) goto <D.19111>; else goto <D.19113>;
  <D.19113>:
  *rptr = ptr;
}


write_variable (struct MonoDebugVarInfo * var, guint8 * ptr, guint8 * * rptr)
{
  unsigned int D.19709;
  guint8 * ptr.46;
  unsigned int D.19711;
  int D.19712;
  unsigned int D.19713;
  unsigned int D.19714;
  unsigned int D.19715;
  struct MonoType * * D.19716;
  guint8 * ptr.47;

  D.19709 = var->index;
  ptr.46 = ptr;
  write_leb128 (D.19709, ptr.46, &ptr);
  D.19711 = var->offset;
  D.19712 = (int) D.19711;
  ptr.46 = ptr;
  write_sleb128 (D.19712, ptr.46, &ptr);
  D.19713 = var->size;
  ptr.46 = ptr;
  write_leb128 (D.19713, ptr.46, &ptr);
  D.19714 = var->begin_scope;
  ptr.46 = ptr;
  write_leb128 (D.19714, ptr.46, &ptr);
  D.19715 = var->end_scope;
  ptr.46 = ptr;
  write_leb128 (D.19715, ptr.46, &ptr);
  ptr.46 = ptr;
  D.19716 = &var->type;
  memcpy (ptr.46, D.19716, 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 char D.19721;
  unsigned char D.19722;
  _Bool D.19723;
  long int D.19724;
  long int D.19725;
  struct MonoMethod * iftmp.49;
  unsigned char D.19729;
  struct GHashTable * D.19733;
  struct GHashTable * D.19734;
  struct MonoDebugWrapperData * D.19737;
  const gchar * D.19740;
  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.19719>; else goto <D.19720>;
  <D.19719>:
  return;
  <D.19720>:
  D.19721 = BIT_FIELD_REF <*method, 8, 168>;
  D.19722 = D.19721 & 2;
  D.19723 = D.19722 == 0;
  D.19724 = (long int) D.19723;
  D.19725 = __builtin_expect (D.19724, 0);
  if (D.19725 != 0) goto <D.19726>; else goto <D.19727>;
  <D.19726>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "mono-debug.c", 703, "method->dynamic");
  <D.19727>:
  mono_debugger_lock ();
  table = lookup_data_table (domain);
  D.19721 = BIT_FIELD_REF <*method, 8, 168>;
  D.19729 = D.19721 & 16;
  if (D.19729 != 0) goto <D.19730>; else goto <D.19731>;
  <D.19730>:
  iftmp.49 = MEM[(struct MonoMethodInflated *)method].declaring;
  goto <D.19732>;
  <D.19731>:
  iftmp.49 = method;
  <D.19732>:
  declaring = iftmp.49;
  D.19733 = table->method_hash;
  monoeg_g_hash_table_remove (D.19733, declaring);
  D.19734 = table->method_address_hash;
  address = monoeg_g_hash_table_lookup (D.19734, method);
  if (address != 0B) goto <D.19735>; else goto <D.19736>;
  <D.19735>:
  header = &address->header;
  D.19737 = header->wrapper_data;
  if (D.19737 != 0B) goto <D.19738>; else goto <D.19739>;
  <D.19738>:
  D.19737 = header->wrapper_data;
  D.19740 = D.19737->method_name;
  monoeg_g_free (D.19740);
  D.19737 = header->wrapper_data;
  monoeg_g_free (D.19737);
  <D.19739>:
  monoeg_g_free (address);
  <D.19736>:
  D.19734 = table->method_address_hash;
  monoeg_g_hash_table_remove (D.19734, 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.19746;
  unsigned int size.52;
  struct MonoDebugDelegateTrampolineEntry * entry;

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


mono_debug_free_method_jit_info (struct MonoDebugMethodJitInfo * jit)
{
  struct MonoDebugLineNumberEntry * D.19751;
  struct MonoDebugVarInfo * D.19752;
  struct MonoDebugVarInfo * D.19753;
  struct MonoDebugVarInfo * D.19754;
  struct MonoDebugVarInfo * D.19755;
  struct MonoDebugVarInfo * D.19756;

  if (jit == 0B) goto <D.19749>; else goto <D.19750>;
  <D.19749>:
  return;
  <D.19750>:
  D.19751 = jit->line_numbers;
  monoeg_g_free (D.19751);
  D.19752 = jit->this_var;
  monoeg_g_free (D.19752);
  D.19753 = jit->params;
  monoeg_g_free (D.19753);
  D.19754 = jit->locals;
  monoeg_g_free (D.19754);
  D.19755 = jit->gsharedvt_info_var;
  monoeg_g_free (D.19755);
  D.19756 = jit->gsharedvt_locals_var;
  monoeg_g_free (D.19756);
  monoeg_g_free (jit);
}


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

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


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

  table = lookup_data_table (domain);
  D.19763 = table->method_address_hash;
  address = monoeg_g_hash_table_lookup (D.19763, method);
  if (address == 0B) goto <D.19764>; else goto <D.19765>;
  <D.19764>:
  D.19766 = 0B;
  return D.19766;
  <D.19765>:
  D.19766 = mono_debug_read_method (address);
  return D.19766;
}


mono_debug_read_method (struct MonoDebugMethodAddress * address)
{
  const guint8 * D.19768;
  unsigned int D.19769;
  const guint8 * D.19770;
  guint8[0:] * ptr.54;
  guint8 * ptr.55;
  unsigned int D.19773;
  unsigned int D.19774;
  unsigned int D.19775;
  unsigned int D.19776;
  unsigned int D.19777;
  void * D.19778;
  struct MonoDebugLineNumberEntry * D.19779;
  unsigned int D.19780;
  int D.19781;
  unsigned int D.19782;
  int D.19783;
  unsigned int D.19784;
  guint8 * ptr.56;
  guint8 * ptr.57;
  unsigned char D.19787;
  void * D.19790;
  struct MonoDebugVarInfo * D.19791;
  unsigned int D.19792;
  unsigned int D.19793;
  unsigned int D.19794;
  void * D.19795;
  struct MonoDebugVarInfo * D.19796;
  unsigned int D.19797;
  struct MonoDebugVarInfo * D.19798;
  unsigned int D.19799;
  unsigned int D.19800;
  unsigned int D.19801;
  void * D.19802;
  struct MonoDebugVarInfo * D.19803;
  struct MonoDebugVarInfo * D.19804;
  guint8 * ptr.58;
  guint8 * ptr.59;
  unsigned char D.19807;
  void * D.19810;
  void * D.19811;
  struct MonoDebugVarInfo * D.19812;
  struct MonoDebugVarInfo * D.19813;
  struct MonoDebugMethodJitInfo * D.19814;
  struct MonoDebugMethodJitInfo * jit;
  guint32 i;
  guint8 * ptr;

  try
    {
      jit = monoeg_malloc0 (56);
      D.19768 = address->code_start;
      jit->code_start = D.19768;
      D.19769 = address->code_size;
      jit->code_size = D.19769;
      D.19770 = address->wrapper_addr;
      jit->wrapper_addr = D.19770;
      ptr.54 = &address->data;
      ptr = ptr.54;
      ptr.55 = ptr;
      D.19773 = read_leb128 (ptr.55, &ptr);
      jit->prologue_end = D.19773;
      ptr.55 = ptr;
      D.19774 = read_leb128 (ptr.55, &ptr);
      jit->epilogue_begin = D.19774;
      ptr.55 = ptr;
      D.19775 = read_leb128 (ptr.55, &ptr);
      jit->num_line_numbers = D.19775;
      D.19776 = jit->num_line_numbers;
      D.19777 = D.19776 * 8;
      D.19778 = monoeg_malloc0 (D.19777);
      jit->line_numbers = D.19778;
      i = 0;
      goto <D.19197>;
      <D.19196>:
      {
        struct MonoDebugLineNumberEntry * lne;

        D.19779 = jit->line_numbers;
        D.19780 = i * 8;
        lne = D.19779 + D.19780;
        ptr.55 = ptr;
        D.19781 = read_sleb128 (ptr.55, &ptr);
        D.19782 = (unsigned int) D.19781;
        lne->il_offset = D.19782;
        ptr.55 = ptr;
        D.19783 = read_sleb128 (ptr.55, &ptr);
        D.19784 = (unsigned int) D.19783;
        lne->native_offset = D.19784;
      }
      i = i + 1;
      <D.19197>:
      D.19776 = jit->num_line_numbers;
      if (D.19776 > i) goto <D.19196>; else goto <D.19198>;
      <D.19198>:
      ptr.55 = ptr;
      ptr.56 = ptr.55;
      ptr.57 = ptr.56 + 1;
      ptr = ptr.57;
      D.19787 = *ptr.56;
      if (D.19787 != 0) goto <D.19788>; else goto <D.19789>;
      <D.19788>:
      D.19790 = monoeg_malloc0 (24);
      jit->this_var = D.19790;
      D.19791 = jit->this_var;
      ptr.55 = ptr;
      read_variable (D.19791, ptr.55, &ptr);
      <D.19789>:
      ptr.55 = ptr;
      D.19792 = read_leb128 (ptr.55, &ptr);
      jit->num_params = D.19792;
      D.19793 = jit->num_params;
      D.19794 = D.19793 * 24;
      D.19795 = monoeg_malloc0 (D.19794);
      jit->params = D.19795;
      i = 0;
      goto <D.19200>;
      <D.19199>:
      D.19796 = jit->params;
      D.19797 = i * 24;
      D.19798 = D.19796 + D.19797;
      ptr.55 = ptr;
      read_variable (D.19798, ptr.55, &ptr);
      i = i + 1;
      <D.19200>:
      D.19793 = jit->num_params;
      if (D.19793 > i) goto <D.19199>; else goto <D.19201>;
      <D.19201>:
      ptr.55 = ptr;
      D.19799 = read_leb128 (ptr.55, &ptr);
      jit->num_locals = D.19799;
      D.19800 = jit->num_locals;
      D.19801 = D.19800 * 24;
      D.19802 = monoeg_malloc0 (D.19801);
      jit->locals = D.19802;
      i = 0;
      goto <D.19203>;
      <D.19202>:
      D.19803 = jit->locals;
      D.19797 = i * 24;
      D.19804 = D.19803 + D.19797;
      ptr.55 = ptr;
      read_variable (D.19804, ptr.55, &ptr);
      i = i + 1;
      <D.19203>:
      D.19800 = jit->num_locals;
      if (D.19800 > i) goto <D.19202>; else goto <D.19204>;
      <D.19204>:
      ptr.55 = ptr;
      ptr.58 = ptr.55;
      ptr.59 = ptr.58 + 1;
      ptr = ptr.59;
      D.19807 = *ptr.58;
      if (D.19807 != 0) goto <D.19808>; else goto <D.19809>;
      <D.19808>:
      D.19810 = monoeg_malloc0 (24);
      jit->gsharedvt_info_var = D.19810;
      D.19811 = monoeg_malloc0 (24);
      jit->gsharedvt_locals_var = D.19811;
      D.19812 = jit->gsharedvt_info_var;
      ptr.55 = ptr;
      read_variable (D.19812, ptr.55, &ptr);
      D.19813 = jit->gsharedvt_locals_var;
      ptr.55 = ptr;
      read_variable (D.19813, ptr.55, &ptr);
      <D.19809>:
      D.19814 = jit;
      return D.19814;
    }
  finally
    {
      ptr = {CLOBBER};
    }
}


read_sleb128 (guint8 * ptr, guint8 * * rptr)
{
  guint8 * ptr.60;
  int D.19818;
  int D.19819;
  int shift.61;
  int D.19821;
  signed char byte.62;
  int D.19827;
  int D.19830;
  int D.19831;
  gint32 D.19832;
  gint32 result;
  guint32 shift;

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

    ptr.60 = ptr;
    ptr = ptr.60 + 1;
    byte = *ptr.60;
    D.19818 = (int) byte;
    D.19819 = D.19818 & 127;
    shift.61 = (int) shift;
    D.19821 = D.19819 << shift.61;
    result = D.19821 | result;
    shift = shift + 7;
    byte.62 = (signed char) byte;
    if (byte.62 < 0) goto <D.19823>; else goto <D.19824>;
    <D.19823>:
    // predicted unlikely by continue predictor.
    goto <D.19178>;
    <D.19824>:
    if (shift <= 31) goto <D.19825>; else goto <D.19826>;
    <D.19825>:
    D.19818 = (int) byte;
    D.19827 = D.19818 & 64;
    if (D.19827 != 0) goto <D.19828>; else goto <D.19829>;
    <D.19828>:
    shift.61 = (int) shift;
    D.19830 = 1 << shift.61;
    D.19831 = -D.19830;
    result = D.19831 | result;
    <D.19829>:
    <D.19826>:
    goto <D.19179>;
  }
  <D.19178>:
  goto <D.19180>;
  <D.19179>:
  *rptr = ptr;
  D.19832 = result;
  return D.19832;
}


read_leb128 (guint8 * ptr, guint8 * * rptr)
{
  guint8 * ptr.63;
  int D.19835;
  int D.19836;
  int shift.64;
  int D.19838;
  unsigned int D.19839;
  signed char byte.65;
  guint32 D.19842;
  guint32 result;
  guint32 shift;

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

    ptr.63 = ptr;
    ptr = ptr.63 + 1;
    byte = *ptr.63;
    D.19835 = (int) byte;
    D.19836 = D.19835 & 127;
    shift.64 = (int) shift;
    D.19838 = D.19836 << shift.64;
    D.19839 = (unsigned int) D.19838;
    result = D.19839 | result;
    byte.65 = (signed char) byte;
    if (byte.65 >= 0) goto <D.19169>; else goto <D.19841>;
    <D.19841>:
    shift = shift + 7;
  }
  goto <D.19170>;
  <D.19169>:
  *rptr = ptr;
  D.19842 = result;
  return D.19842;
}


read_variable (struct MonoDebugVarInfo * var, guint8 * ptr, guint8 * * rptr)
{
  guint8 * ptr.66;
  unsigned int D.19845;
  int D.19846;
  unsigned int D.19847;
  unsigned int D.19848;
  unsigned int D.19849;
  unsigned int D.19850;
  struct MonoType * * D.19851;
  guint8 * ptr.67;

  ptr.66 = ptr;
  D.19845 = read_leb128 (ptr.66, &ptr);
  var->index = D.19845;
  ptr.66 = ptr;
  D.19846 = read_sleb128 (ptr.66, &ptr);
  D.19847 = (unsigned int) D.19846;
  var->offset = D.19847;
  ptr.66 = ptr;
  D.19848 = read_leb128 (ptr.66, &ptr);
  var->size = D.19848;
  ptr.66 = ptr;
  D.19849 = read_leb128 (ptr.66, &ptr);
  var->begin_scope = D.19849;
  ptr.66 = ptr;
  D.19850 = read_leb128 (ptr.66, &ptr);
  var->end_scope = D.19850;
  D.19851 = &var->type;
  ptr.66 = ptr;
  memcpy (D.19851, 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.19855;
  _Bool D.19856;
  long int D.19857;
  long int D.19858;
  struct MonoMethod * iftmp.70;
  unsigned char D.19862;
  unsigned char D.19863;
  struct GHashTable * data_table_hash.71;
  struct MonoDebugMethodHeader * header.72;
  struct MonoDebugMethodHeader * header.73;
  struct MonoDebugMethodAddressList * D.19872;
  struct GSList * D.19873;
  unsigned int D.19874;
  unsigned int D.19875;
  unsigned int count.74;
  unsigned int D.19877;
  unsigned int D.19878;
  unsigned int size.75;
  unsigned int size.76;
  unsigned int count.77;
  void * * D.19882;
  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.19855 = mono_debug_debugger_version.69 + 4294967292;
      D.19856 = D.19855 > 1;
      D.19857 = (long int) D.19856;
      D.19858 = __builtin_expect (D.19857, 0);
      if (D.19858 != 0) goto <D.19859>; else goto <D.19860>;
      <D.19859>:
      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.19860>:
      mono_debugger_lock ();
      D.19862 = BIT_FIELD_REF <*method, 8, 168>;
      D.19863 = D.19862 & 16;
      if (D.19863 != 0) goto <D.19864>; else goto <D.19865>;
      <D.19864>:
      iftmp.70 = MEM[(struct MonoMethodInflated *)method].declaring;
      goto <D.19866>;
      <D.19865>:
      iftmp.70 = method;
      <D.19866>:
      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.19870>; else goto <D.19871>;
      <D.19870>:
      mono_debugger_unlock ();
      D.19872 = 0B;
      return D.19872;
      <D.19871>:
      header.73 = header;
      D.19873 = header.73->address_list;
      D.19874 = monoeg_g_slist_length (D.19873);
      D.19875 = D.19874 + 1;
      count = (int) D.19875;
      count.74 = (unsigned int) count;
      D.19877 = count.74 + 2;
      D.19878 = D.19877 * 4;
      size = (int) D.19878;
      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.19251>;
      <D.19250>:
      D.19882 = &list->data;
      memcpy (ptr, D.19882, 4);
      ptr = ptr + 4;
      list = list->next;
      <D.19251>:
      if (list != 0B) goto <D.19250>; else goto <D.19252>;
      <D.19252>:
      mono_debugger_unlock ();
      D.19872 = info;
      return D.19872;
    }
  finally
    {
      header = {CLOBBER};
      data = {CLOBBER};
    }
}


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

  table = value;
  data = user_data;
  D.19885 = table->method_hash;
  D.19886 = data->method;
  header = monoeg_g_hash_table_lookup (D.19885, D.19886);
  if (header != 0B) goto <D.19887>; else goto <D.19888>;
  <D.19887>:
  data->result = header;
  <D.19888>:
}


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

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


il_offset_from_address (struct MonoMethod * method, struct MonoDomain * domain, guint32 native_offset)
{
  struct MonoDebugLineNumberEntry * D.19892;
  unsigned int D.19894;
  unsigned int D.19895;
  unsigned int i.78;
  unsigned int D.19897;
  struct MonoDebugLineNumberEntry * D.19898;
  unsigned int D.19899;
  gint32 D.19902;
  unsigned int D.19903;
  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.19891>;
  <D.19891>:
  D.19892 = jit->line_numbers;
  if (D.19892 == 0B) goto cleanup_and_fail; else goto <D.19893>;
  <D.19893>:
  D.19894 = jit->num_line_numbers;
  D.19895 = D.19894 + 4294967295;
  i = (int) D.19895;
  goto <D.19263>;
  <D.19262>:
  {
    struct MonoDebugLineNumberEntry lne;

    try
      {
        D.19892 = jit->line_numbers;
        i.78 = (unsigned int) i;
        D.19897 = i.78 * 8;
        D.19898 = D.19892 + D.19897;
        lne = *D.19898;
        D.19899 = lne.native_offset;
        if (D.19899 <= native_offset) goto <D.19900>; else goto <D.19901>;
        <D.19900>:
        mono_debug_free_method_jit_info (jit);
        D.19903 = lne.il_offset;
        D.19902 = (gint32) D.19903;
        return D.19902;
        <D.19901>:
      }
    finally
      {
        lne = {CLOBBER};
      }
  }
  i = i + -1;
  <D.19263>:
  if (i >= 0) goto <D.19262>; else goto <D.19264>;
  <D.19264>:
  cleanup_and_fail:
  mono_debug_free_method_jit_info (jit);
  D.19902 = -1;
  return D.19902;
}


mono_debug_lookup_source_location (struct MonoMethod * method, guint32 address, struct MonoDomain * domain)
{
  <unnamed type> mono_debug_format.79;
  struct MonoDebugSourceLocation * D.19910;
  struct MonoDebugHandle * D.19914;
  struct MonoSymbolFile * D.19916;
  int D.19918;
  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.19908>; else goto <D.19909>;
  <D.19908>:
  D.19910 = 0B;
  return D.19910;
  <D.19909>:
  mono_debugger_lock ();
  minfo = _mono_debug_lookup_method (method);
  if (minfo == 0B) goto <D.19911>; else goto <D.19913>;
  <D.19913>:
  D.19914 = minfo->handle;
  if (D.19914 == 0B) goto <D.19911>; else goto <D.19915>;
  <D.19915>:
  D.19914 = minfo->handle;
  D.19916 = D.19914->symfile;
  if (D.19916 == 0B) goto <D.19911>; else goto <D.19917>;
  <D.19917>:
  D.19914 = minfo->handle;
  D.19916 = D.19914->symfile;
  D.19918 = mono_debug_symfile_is_loaded (D.19916);
  if (D.19918 == 0) goto <D.19911>; else goto <D.19912>;
  <D.19911>:
  mono_debugger_unlock ();
  D.19910 = 0B;
  return D.19910;
  <D.19912>:
  offset = il_offset_from_address (method, domain, address);
  if (offset < 0) goto <D.19919>; else goto <D.19920>;
  <D.19919>:
  mono_debugger_unlock ();
  D.19910 = 0B;
  return D.19910;
  <D.19920>:
  offset.80 = (unsigned int) offset;
  location = mono_debug_symfile_lookup_location (minfo, offset.80);
  mono_debugger_unlock ();
  D.19910 = location;
  return D.19910;
}


mono_debug_lookup_locals (struct MonoMethod * method)
{
  <unnamed type> mono_debug_format.81;
  struct MonoDebugLocalsInfo * D.19926;
  struct MonoDebugHandle * D.19930;
  struct MonoSymbolFile * D.19932;
  int D.19934;
  struct MonoDebugMethodInfo * minfo;
  struct MonoDebugLocalsInfo * res;

  mono_debug_format.81 = mono_debug_format;
  if (mono_debug_format.81 == 0) goto <D.19924>; else goto <D.19925>;
  <D.19924>:
  D.19926 = 0B;
  return D.19926;
  <D.19925>:
  mono_debugger_lock ();
  minfo = _mono_debug_lookup_method (method);
  if (minfo == 0B) goto <D.19927>; else goto <D.19929>;
  <D.19929>:
  D.19930 = minfo->handle;
  if (D.19930 == 0B) goto <D.19927>; else goto <D.19931>;
  <D.19931>:
  D.19930 = minfo->handle;
  D.19932 = D.19930->symfile;
  if (D.19932 == 0B) goto <D.19927>; else goto <D.19933>;
  <D.19933>:
  D.19930 = minfo->handle;
  D.19932 = D.19930->symfile;
  D.19934 = mono_debug_symfile_is_loaded (D.19932);
  if (D.19934 == 0) goto <D.19927>; else goto <D.19928>;
  <D.19927>:
  mono_debugger_unlock ();
  D.19926 = 0B;
  return D.19926;
  <D.19928>:
  res = mono_debug_symfile_lookup_locals (minfo);
  mono_debugger_unlock ();
  D.19926 = res;
  return D.19926;
}


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

  if (location != 0B) goto <D.19936>; else goto <D.19937>;
  <D.19936>:
  D.19938 = location->source_file;
  monoeg_g_free (D.19938);
  monoeg_g_free (location);
  <D.19937>:
}


mono_debug_print_stack_frame (struct MonoMethod * method, guint32 native_offset, struct MonoDomain * domain)
{
  char D.19939;
  int mono_debug_initialized.82;
  char * D.19951;
  unsigned int D.19952;
  char * D.19953;
  unsigned int D.19954;
  struct MonoDebugSourceLocation * location;
  gchar * fname;
  gchar * ptr;
  gchar * res;
  int offset;

  fname = mono_method_full_name (method, 1);
  ptr = fname;
  goto <D.19298>;
  <D.19297>:
  D.19939 = *ptr;
  if (D.19939 == 58) goto <D.19940>; else goto <D.19941>;
  <D.19940>:
  *ptr = 46;
  <D.19941>:
  ptr = ptr + 1;
  <D.19298>:
  D.19939 = *ptr;
  if (D.19939 != 0) goto <D.19297>; else goto <D.19299>;
  <D.19299>:
  location = mono_debug_lookup_source_location (method, native_offset, domain);
  if (location == 0B) goto <D.19942>; else goto <D.19943>;
  <D.19942>:
  mono_debug_initialized.82 = mono_debug_initialized;
  if (mono_debug_initialized.82 != 0) goto <D.19945>; else goto <D.19946>;
  <D.19945>:
  mono_debugger_lock ();
  offset = il_offset_from_address (method, domain, native_offset);
  mono_debugger_unlock ();
  goto <D.19947>;
  <D.19946>:
  offset = -1;
  <D.19947>:
  if (offset < 0) goto <D.19948>; else goto <D.19949>;
  <D.19948>:
  res = monoeg_g_strdup_printf ("at %s <0x%05x>", fname, native_offset);
  goto <D.19950>;
  <D.19949>:
  res = monoeg_g_strdup_printf ("at %s <IL 0x%05x, 0x%05x>", fname, offset, native_offset);
  <D.19950>:
  monoeg_g_free (fname);
  D.19951 = res;
  return D.19951;
  <D.19943>:
  D.19952 = location->il_offset;
  D.19953 = location->source_file;
  D.19954 = location->row;
  res = monoeg_g_strdup_printf ("at %s [0x%05x] in %s:%d", fname, D.19952, D.19953, D.19954);
  monoeg_g_free (fname);
  mono_debug_free_source_location (location);
  D.19951 = res;
  return D.19951;
}


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

  element = monoeg_malloc0 (8);
  element->data = data;
  ptr = list;
  goto <D.19307>;
  <D.19306>:
  D.19956 = *ptr;
  ptr = &D.19956->next;
  <D.19307>:
  D.19956 = *ptr;
  if (D.19956 != 0B) goto <D.19306>; else goto <D.19308>;
  <D.19308>:
  *ptr = element;
}


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

  ptr = list;
  goto <D.19318>;
  <D.19317>:
  D.19957 = *ptr;
  D.19958 = D.19957->data;
  if (D.19958 != data) goto <D.19959>; else goto <D.19960>;
  <D.19959>:
  // predicted unlikely by continue predictor.
  goto <D.19315>;
  <D.19960>:
  D.19957 = *ptr;
  next = D.19957->next;
  D.19957 = *ptr;
  monoeg_g_free (D.19957);
  *ptr = next;
  goto <D.19316>;
  <D.19315>:
  D.19957 = *ptr;
  ptr = &D.19957->next;
  <D.19318>:
  D.19957 = *ptr;
  if (D.19957 != 0B) goto <D.19317>; else goto <D.19316>;
  <D.19316>:
}


mono_set_is_debugger_attached (gboolean attached)
{
  is_attached = attached;
}


mono_is_debugger_attached ()
{
  mono_bool D.19961;

  D.19961 = is_attached;
  return D.19961;
}


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.19964;
  <unnamed type> mono_debug_format.84;
  _Bool D.19966;

  mono_debug_format.84 = mono_debug_format;
  D.19966 = mono_debug_format.84 != 0;
  D.19964 = (mono_bool) D.19966;
  return D.19964;
}