mono_debug_open_mono_symbols (struct MonoDebugHandle * handle, const uint8_t * raw_contents, int size, gboolean in_the_debugger)
{
  long unsigned int D.15392;
  long unsigned int D.15393;
  gchar * D.15394;
  struct MonoImage * D.15396;
  const char * D.15397;
  gchar * D.15398;
  char * D.15399;
  long unsigned int D.15402;
  int D.15403;
  int D.15404;
  int * D.15409;
  int D.15410;
  const gchar * D.15411;
  long unsigned int D.15413;
  int D.15414;
  void * * D.15415;
  void * D.15416;
  int D.15417;
  struct MonoSymbolFile * D.15420;
  struct MonoSymbolFile * symfile;

  mono_debugger_lock ();
  symfile = monoeg_malloc0 (72);
  if (raw_contents != 0B) goto <D.15390>; else goto <D.15391>;
  <D.15390>:
  {
    unsigned char * p;

    symfile->raw_contents_size = size;
    D.15392 = (long unsigned int) size;
    p = monoeg_malloc (D.15392);
    symfile->raw_contents = p;
    D.15393 = (long unsigned int) size;
    memcpy (p, raw_contents, D.15393);
    D.15394 = monoeg_g_strdup_printf ("LoadedFromMemory");
    symfile->filename = D.15394;
    symfile->was_loaded_from_memory = 1;
  }
  goto <D.15395>;
  <D.15391>:
  {
    struct MonoFileMap * f;

    D.15396 = handle->image;
    D.15397 = mono_image_get_filename (D.15396);
    D.15398 = monoeg_g_strdup_printf ("%s.mdb", D.15397);
    symfile->filename = D.15398;
    symfile->was_loaded_from_memory = 0;
    D.15399 = symfile->filename;
    f = mono_file_map_open (D.15399);
    if (f != 0B) goto <D.15400>; else goto <D.15401>;
    <D.15400>:
    D.15402 = mono_file_map_size (f);
    D.15403 = (int) D.15402;
    symfile->raw_contents_size = D.15403;
    D.15404 = symfile->raw_contents_size;
    if (D.15404 == 0) goto <D.15405>; else goto <D.15406>;
    <D.15405>:
    if (in_the_debugger == 0) goto <D.15407>; else goto <D.15408>;
    <D.15407>:
    D.15399 = symfile->filename;
    D.15409 = __errno_location ();
    D.15410 = *D.15409;
    D.15411 = monoeg_g_strerror (D.15410);
    monoeg_g_log (0B, 16, "stat of %s failed: %s", D.15399, D.15411);
    <D.15408>:
    goto <D.15412>;
    <D.15406>:
    D.15404 = symfile->raw_contents_size;
    D.15413 = (long unsigned int) D.15404;
    D.15414 = mono_file_map_fd (f);
    D.15415 = &symfile->raw_contents_handle;
    D.15416 = mono_file_map (D.15413, 17, D.15414, 0, D.15415);
    symfile->raw_contents = D.15416;
    <D.15412>:
    mono_file_map_close (f);
    <D.15401>:
  }
  <D.15395>:
  D.15417 = load_symfile (handle, symfile, in_the_debugger);
  if (D.15417 != 0) goto <D.15418>; else goto <D.15419>;
  <D.15418>:
  mono_debugger_unlock ();
  D.15420 = symfile;
  return D.15420;
  <D.15419>:
  if (in_the_debugger == 0) goto <D.15421>; else goto <D.15422>;
  <D.15421>:
  mono_debug_close_mono_symbol_file (symfile);
  mono_debugger_unlock ();
  D.15420 = 0B;
  return D.15420;
  <D.15422>:
  mono_debugger_unlock ();
  D.15420 = symfile;
  return D.15420;
}


__attribute__((__artificial__, __gnu_inline__, __always_inline__, __nothrow__, __leaf__))
memcpy (void * restrict __dest, const void * restrict __src, size_t __len)
{
  void * D.15424;
  long unsigned int D.15425;

  D.15425 = __builtin_object_size (__dest, 0);
  D.15424 = __builtin___memcpy_chk (__dest, __src, __len, D.15425);
  return D.15424;
}


load_symfile (struct MonoDebugHandle * handle, struct MonoSymbolFile * symfile, mono_bool in_the_debugger)
{
  int D.15429;
  long unsigned int D.15430;
  unsigned int D.15431;
  unsigned int D.15432;
  unsigned int D.15433;
  unsigned int D.15434;
  unsigned int D.15435;
  unsigned int D.15436;
  unsigned int D.15437;
  unsigned int D.15438;
  unsigned int D.15439;
  unsigned int D.15440;
  long unsigned int D.15441;
  long unsigned int D.15442;
  long unsigned int D.15443;
  unsigned int D.15444;
  unsigned int D.15445;
  unsigned int D.15446;
  unsigned int D.15447;
  unsigned int D.15448;
  unsigned int D.15449;
  unsigned int D.15450;
  unsigned int D.15451;
  unsigned int D.15452;
  unsigned int D.15453;
  long unsigned int D.15454;
  char * D.15459;
  unsigned int D.15460;
  unsigned int D.15461;
  unsigned int D.15462;
  unsigned int D.15463;
  unsigned int D.15464;
  unsigned int D.15465;
  unsigned int D.15466;
  unsigned int D.15467;
  unsigned int D.15468;
  unsigned int D.15469;
  struct MonoImage * D.15474;
  char * D.15475;
  int D.15476;
  char * D.15481;
  struct GHashTable * D.15484;
  struct GHashTable * D.15485;
  const char * ptr;
  const char * start;
  gchar * guid;
  uint64_t magic;
  int minor;
  int major;

  start = symfile->raw_contents;
  ptr = start;
  if (ptr == 0B) goto <D.15427>; else goto <D.15428>;
  <D.15427>:
  D.15429 = 0;
  return D.15429;
  <D.15428>:
  D.15430 = MEM[(const guint64 *)ptr];
  D.15431 = (unsigned int) D.15430;
  D.15432 = D.15431 << 24;
  D.15430 = MEM[(const guint64 *)ptr];
  D.15431 = (unsigned int) D.15430;
  D.15433 = D.15431 >> 8;
  D.15434 = D.15433 & 65280;
  D.15435 = D.15432 | D.15434;
  D.15430 = MEM[(const guint64 *)ptr];
  D.15431 = (unsigned int) D.15430;
  D.15436 = D.15431 << 8;
  D.15437 = D.15436 & 16711680;
  D.15438 = D.15435 | D.15437;
  D.15430 = MEM[(const guint64 *)ptr];
  D.15431 = (unsigned int) D.15430;
  D.15439 = D.15431 >> 24;
  D.15440 = D.15438 | D.15439;
  D.15441 = (long unsigned int) D.15440;
  D.15442 = D.15441 << 32;
  D.15430 = MEM[(const guint64 *)ptr];
  D.15443 = D.15430 >> 32;
  D.15444 = (unsigned int) D.15443;
  D.15445 = D.15444 << 24;
  D.15430 = MEM[(const guint64 *)ptr];
  D.15443 = D.15430 >> 32;
  D.15444 = (unsigned int) D.15443;
  D.15446 = D.15444 >> 8;
  D.15447 = D.15446 & 65280;
  D.15448 = D.15445 | D.15447;
  D.15430 = MEM[(const guint64 *)ptr];
  D.15443 = D.15430 >> 32;
  D.15444 = (unsigned int) D.15443;
  D.15449 = D.15444 << 8;
  D.15450 = D.15449 & 16711680;
  D.15451 = D.15448 | D.15450;
  D.15430 = MEM[(const guint64 *)ptr];
  D.15443 = D.15430 >> 32;
  D.15444 = (unsigned int) D.15443;
  D.15452 = D.15444 >> 24;
  D.15453 = D.15451 | D.15452;
  D.15454 = (long unsigned int) D.15453;
  magic = D.15442 | D.15454;
  ptr = ptr + 8;
  if (magic != 5037318119232611860) goto <D.15455>; else goto <D.15456>;
  <D.15455>:
  if (in_the_debugger == 0) goto <D.15457>; else goto <D.15458>;
  <D.15457>:
  D.15459 = symfile->filename;
  monoeg_g_log (0B, 16, "Symbol file %s is not a mono symbol file", D.15459);
  <D.15458>:
  D.15429 = 0;
  return D.15429;
  <D.15456>:
  D.15460 = MEM[(const guint32 *)ptr];
  D.15461 = D.15460 << 24;
  D.15460 = MEM[(const guint32 *)ptr];
  D.15462 = D.15460 >> 8;
  D.15463 = D.15462 & 65280;
  D.15464 = D.15461 | D.15463;
  D.15460 = MEM[(const guint32 *)ptr];
  D.15465 = D.15460 << 8;
  D.15466 = D.15465 & 16711680;
  D.15467 = D.15464 | D.15466;
  D.15460 = MEM[(const guint32 *)ptr];
  D.15468 = D.15460 >> 24;
  D.15469 = D.15467 | D.15468;
  major = (int) D.15469;
  ptr = ptr + 4;
  D.15460 = MEM[(const guint32 *)ptr];
  D.15461 = D.15460 << 24;
  D.15460 = MEM[(const guint32 *)ptr];
  D.15462 = D.15460 >> 8;
  D.15463 = D.15462 & 65280;
  D.15464 = D.15461 | D.15463;
  D.15460 = MEM[(const guint32 *)ptr];
  D.15465 = D.15460 << 8;
  D.15466 = D.15465 & 16711680;
  D.15467 = D.15464 | D.15466;
  D.15460 = MEM[(const guint32 *)ptr];
  D.15468 = D.15460 >> 24;
  D.15469 = D.15467 | D.15468;
  minor = (int) D.15469;
  ptr = ptr + 4;
  if (major != 50) goto <D.15470>; else goto <D.15471>;
  <D.15470>:
  if (in_the_debugger == 0) goto <D.15472>; else goto <D.15473>;
  <D.15472>:
  D.15459 = symfile->filename;
  monoeg_g_log (0B, 16, "Symbol file %s has incorrect version (expected %d.%d, got %d)", D.15459, 50, 0, major);
  <D.15473>:
  D.15429 = 0;
  return D.15429;
  <D.15471>:
  guid = mono_guid_to_string (ptr);
  ptr = ptr + 16;
  D.15474 = handle->image;
  D.15475 = D.15474->guid;
  D.15476 = strcmp (D.15475, guid);
  if (D.15476 != 0) goto <D.15477>; else goto <D.15478>;
  <D.15477>:
  if (in_the_debugger == 0) goto <D.15479>; else goto <D.15480>;
  <D.15479>:
  D.15459 = symfile->filename;
  D.15481 = handle->image_file;
  monoeg_g_log (0B, 16, "Symbol file %s doesn\'t match image %s", D.15459, D.15481);
  <D.15480>:
  if (guid != 0B) goto <D.15482>; else goto <D.15483>;
  <D.15482>:
  monoeg_g_free (guid);
  <D.15483>:
  D.15429 = 0;
  return D.15429;
  <D.15478>:
  symfile->major_version = major;
  symfile->minor_version = minor;
  symfile->offset_table = ptr;
  D.15484 = monoeg_g_hash_table_new_full (0B, 0B, 0B, free_method_info);
  symfile->method_hash = D.15484;
  D.15485 = monoeg_g_hash_table_new_full (0B, 0B, 0B, free_source_info);
  symfile->source_hash = D.15485;
  monoeg_g_free (guid);
  D.15429 = 1;
  return D.15429;
}


free_source_info (struct MonoDebugSourceInfo * sinfo)
{
  char * D.15487;
  guint8 * D.15488;
  guint8 * D.15489;

  D.15487 = sinfo->source_file;
  monoeg_g_free (D.15487);
  D.15488 = sinfo->guid;
  monoeg_g_free (D.15488);
  D.15489 = sinfo->hash;
  monoeg_g_free (D.15489);
  monoeg_g_free (sinfo);
}


free_method_info (struct MonoDebugMethodInfo * minfo)
{
  monoeg_g_free (minfo);
}


__attribute__((__gnu_inline__, nothrow, leaf, pure))
strcmp (const char * __s1, const char * __s2)
{
  int iftmp.0;
  int iftmp.1;
  int D.15498;
  char * __p1;
  char * __p2;
  int __ret;

  __p1 = __s1;
  __p2 = __s2;
  __asm__ __volatile__("   slr   0,0
0: clst  %1,%2
   jo    0b
   ipm   %0
   srl   %0,28" : "=d" __ret, "=&a" __p1, "=&a" __p2 : "1" __p1, "2" __p2 : "0", "memory", "cc");
  if (__ret != 0) goto <D.15491>; else goto <D.15492>;
  <D.15491>:
  if (__ret == 1) goto <D.15494>; else goto <D.15495>;
  <D.15494>:
  iftmp.1 = -1;
  goto <D.15496>;
  <D.15495>:
  iftmp.1 = 1;
  <D.15496>:
  iftmp.0 = iftmp.1;
  goto <D.15497>;
  <D.15492>:
  iftmp.0 = 0;
  <D.15497>:
  __ret = iftmp.0;
  D.15498 = __ret;
  return D.15498;
}


mono_debug_close_mono_symbol_file (struct MonoSymbolFile * symfile)
{
  struct GHashTable * D.15502;
  const uint8_t * D.15505;
  int D.15508;
  void * D.15512;
  char * D.15513;

  if (symfile == 0B) goto <D.15500>; else goto <D.15501>;
  <D.15500>:
  return;
  <D.15501>:
  mono_debugger_lock ();
  D.15502 = symfile->method_hash;
  if (D.15502 != 0B) goto <D.15503>; else goto <D.15504>;
  <D.15503>:
  D.15502 = symfile->method_hash;
  monoeg_g_hash_table_destroy (D.15502);
  <D.15504>:
  D.15505 = symfile->raw_contents;
  if (D.15505 != 0B) goto <D.15506>; else goto <D.15507>;
  <D.15506>:
  D.15508 = symfile->was_loaded_from_memory;
  if (D.15508 != 0) goto <D.15509>; else goto <D.15510>;
  <D.15509>:
  D.15505 = symfile->raw_contents;
  monoeg_g_free (D.15505);
  goto <D.15511>;
  <D.15510>:
  D.15505 = symfile->raw_contents;
  D.15512 = symfile->raw_contents_handle;
  mono_file_unmap (D.15505, D.15512);
  <D.15511>:
  <D.15507>:
  D.15513 = symfile->filename;
  if (D.15513 != 0B) goto <D.15514>; else goto <D.15515>;
  <D.15514>:
  D.15513 = symfile->filename;
  monoeg_g_free (D.15513);
  <D.15515>:
  monoeg_g_free (symfile);
  mono_debugger_unlock ();
}


mono_debug_symfile_is_loaded (struct MonoSymbolFile * symfile)
{
  mono_bool D.15517;
  int iftmp.2;
  struct MonoSymbolFileOffsetTable * D.15522;

  if (symfile != 0B) goto <D.15521>; else goto <D.15519>;
  <D.15521>:
  D.15522 = symfile->offset_table;
  if (D.15522 != 0B) goto <D.15523>; else goto <D.15519>;
  <D.15523>:
  iftmp.2 = 1;
  goto <D.15520>;
  <D.15519>:
  iftmp.2 = 0;
  <D.15520>:
  D.15517 = iftmp.2;
  return D.15517;
}


mono_debug_symfile_lookup_location (struct MonoDebugMethodInfo * minfo, uint32_t offset)
{
  struct MonoDebugHandle * D.15525;
  struct MonoDebugSourceLocation * D.15528;
  struct MonoSymbolFileOffsetTable * D.15529;
  uint32_t * D.15530;
  unsigned int D.15531;
  unsigned int D.15532;
  unsigned int D.15533;
  unsigned int D.15534;
  unsigned int D.15535;
  unsigned int D.15536;
  unsigned int D.15537;
  unsigned int D.15538;
  unsigned int D.15539;
  unsigned int D.15540;
  int D.15541;
  uint32_t * D.15542;
  unsigned int D.15543;
  unsigned int D.15544;
  unsigned int D.15545;
  unsigned int D.15546;
  unsigned int D.15547;
  unsigned int D.15548;
  unsigned int D.15549;
  unsigned int D.15550;
  unsigned int D.15551;
  unsigned int D.15552;
  int D.15553;
  uint32_t * D.15554;
  unsigned int D.15555;
  unsigned int D.15556;
  unsigned char D.15557;
  unsigned char D.15558;
  int D.15559;
  int D.15560;
  int D.15561;
  int D.15562;
  const uint8_t * D.15563;
  unsigned int D.15564;
  sizetype D.15565;
  const uint8_t * ptr.3;
  const unsigned char * ptr.4;
  const unsigned char * ptr.5;
  const unsigned char * ptr.6;
  const unsigned char * ptr.7;
  const unsigned char * ptr.8;
  sizetype D.15574;
  const unsigned char * ptr.9;
  const unsigned char * ptr.10;
  int D.15579;
  int D.15583;
  _Bool D.15584;
  int D.15585;
  unsigned char D.15587;
  int D.15591;
  int offset.11;
  int D.15595;
  int D.15597;
  int D.15598;
  int D.15599;
  int D.15600;
  int D.15601;
  int D.15602;
  int D.15603;
  int D.15604;
  int D.15605;
  int D.15607;
  int D.15608;
  int D.15609;
  int D.15610;
  int D.15611;
  int D.15612;
  int D.15613;
  struct MonoDebugSourceLocation * location;
  struct MonoSymbolFile * symfile;
  const unsigned char * ptr;
  struct StatementMachine stm;
  void out_success = <<< error >>>;
  void error_out = <<< error >>>;

  try
    {
      location = 0B;
      D.15525 = minfo->handle;
      symfile = D.15525->symfile;
      if (symfile == 0B) goto <D.15526>; else goto <D.15527>;
      <D.15526>:
      D.15528 = 0B;
      return D.15528;
      <D.15527>:
      D.15529 = symfile->offset_table;
      D.15530 = &D.15529->_line_number_table_line_base;
      D.15531 = MEM[(const guint32 *)D.15530];
      D.15532 = D.15531 << 24;
      D.15529 = symfile->offset_table;
      D.15530 = &D.15529->_line_number_table_line_base;
      D.15531 = MEM[(const guint32 *)D.15530];
      D.15533 = D.15531 >> 8;
      D.15534 = D.15533 & 65280;
      D.15535 = D.15532 | D.15534;
      D.15529 = symfile->offset_table;
      D.15530 = &D.15529->_line_number_table_line_base;
      D.15531 = MEM[(const guint32 *)D.15530];
      D.15536 = D.15531 << 8;
      D.15537 = D.15536 & 16711680;
      D.15538 = D.15535 | D.15537;
      D.15529 = symfile->offset_table;
      D.15530 = &D.15529->_line_number_table_line_base;
      D.15531 = MEM[(const guint32 *)D.15530];
      D.15539 = D.15531 >> 24;
      D.15540 = D.15538 | D.15539;
      D.15541 = (int) D.15540;
      stm.line_base = D.15541;
      D.15529 = symfile->offset_table;
      D.15542 = &D.15529->_line_number_table_line_range;
      D.15543 = MEM[(const guint32 *)D.15542];
      D.15544 = D.15543 << 24;
      D.15529 = symfile->offset_table;
      D.15542 = &D.15529->_line_number_table_line_range;
      D.15543 = MEM[(const guint32 *)D.15542];
      D.15545 = D.15543 >> 8;
      D.15546 = D.15545 & 65280;
      D.15547 = D.15544 | D.15546;
      D.15529 = symfile->offset_table;
      D.15542 = &D.15529->_line_number_table_line_range;
      D.15543 = MEM[(const guint32 *)D.15542];
      D.15548 = D.15543 << 8;
      D.15549 = D.15548 & 16711680;
      D.15550 = D.15547 | D.15549;
      D.15529 = symfile->offset_table;
      D.15542 = &D.15529->_line_number_table_line_range;
      D.15543 = MEM[(const guint32 *)D.15542];
      D.15551 = D.15543 >> 24;
      D.15552 = D.15550 | D.15551;
      D.15553 = (int) D.15552;
      stm.line_range = D.15553;
      D.15529 = symfile->offset_table;
      D.15554 = &D.15529->_line_number_table_opcode_base;
      D.15555 = MEM[(const guint32 *)D.15554];
      D.15556 = D.15555 >> 24;
      D.15557 = (unsigned char) D.15556;
      stm.opcode_base = D.15557;
      D.15558 = stm.opcode_base;
      D.15559 = (int) D.15558;
      D.15560 = 255 - D.15559;
      D.15561 = stm.line_range;
      D.15562 = D.15560 / D.15561;
      stm.max_address_incr = D.15562;
      mono_debugger_lock ();
      D.15563 = symfile->raw_contents;
      D.15564 = minfo->lnt_offset;
      D.15565 = (sizetype) D.15564;
      ptr.3 = D.15563 + D.15565;
      ptr = ptr.3;
      stm.symfile = symfile;
      stm.last_offset = 0;
      stm.offset = 0;
      stm.last_file = 0;
      stm.last_line = 0;
      stm.first_file = 0;
      stm.file = 1;
      stm.line = 1;
      stm.is_hidden = 0;
      <D.15262>:
      {
        uint8_t opcode;

        ptr.4 = ptr;
        ptr.5 = ptr.4;
        ptr.6 = ptr.5 + 1;
        ptr = ptr.6;
        opcode = *ptr.5;
        if (opcode == 0) goto <D.15570>; else goto <D.15571>;
        <D.15570>:
        {
          uint8_t size;
          const unsigned char * end_ptr;

          ptr.4 = ptr;
          ptr.7 = ptr.4;
          ptr.8 = ptr.7 + 1;
          ptr = ptr.8;
          size = *ptr.7;
          ptr.4 = ptr;
          D.15574 = (sizetype) size;
          end_ptr = ptr.4 + D.15574;
          ptr.4 = ptr;
          ptr.9 = ptr.4;
          ptr.10 = ptr.9 + 1;
          ptr = ptr.10;
          opcode = *ptr.9;
          if (opcode == 1) goto <D.15577>; else goto <D.15578>;
          <D.15577>:
          D.15579 = check_line (&stm, -1, &location);
          if (D.15579 != 0) goto out_success; else goto <D.15580>;
          <D.15580>:
          goto <D.15252>;
          <D.15578>:
          if (opcode == 64) goto <D.15581>; else goto <D.15582>;
          <D.15581>:
          D.15583 = stm.is_hidden;
          D.15584 = D.15583 == 0;
          D.15585 = (int) D.15584;
          stm.is_hidden = D.15585;
          goto <D.15586>;
          <D.15582>:
          D.15587 = opcode + 192;
          if (D.15587 <= 63) goto <D.15588>; else goto <D.15589>;
          <D.15588>:
          goto <D.15590>;
          <D.15589>:
          D.15591 = (int) opcode;
          monoeg_g_log (0B, 16, "Unknown extended opcode %x in LNT", D.15591);
          <D.15590>:
          <D.15586>:
          ptr = end_ptr;
          // predicted unlikely by continue predictor.
          goto <D.15253>;
        }
        <D.15571>:
        D.15558 = stm.opcode_base;
        if (D.15558 > opcode) goto <D.15592>; else goto <D.15593>;
        <D.15592>:
        D.15591 = (int) opcode;
        switch (D.15591) <default: <D.15260>, case 1: <D.15254>, case 2: <D.15256>, case 3: <D.15257>, case 4: <D.15258>, case 8: <D.15259>>
        <D.15254>:
        offset.11 = (int) offset;
        D.15595 = check_line (&stm, offset.11, &location);
        if (D.15595 != 0) goto out_success; else goto <D.15596>;
        <D.15596>:
        goto <D.15255>;
        <D.15256>:
        ptr.4 = ptr;
        D.15597 = read_leb128 (ptr.4, &ptr);
        D.15598 = stm.offset;
        D.15599 = D.15598 + D.15597;
        stm.offset = D.15599;
        goto <D.15255>;
        <D.15257>:
        ptr.4 = ptr;
        D.15600 = read_leb128 (ptr.4, &ptr);
        D.15601 = stm.line;
        D.15602 = D.15601 + D.15600;
        stm.line = D.15602;
        goto <D.15255>;
        <D.15258>:
        ptr.4 = ptr;
        D.15603 = read_leb128 (ptr.4, &ptr);
        stm.file = D.15603;
        goto <D.15255>;
        <D.15259>:
        D.15598 = stm.offset;
        D.15604 = stm.max_address_incr;
        D.15605 = D.15598 + D.15604;
        stm.offset = D.15605;
        goto <D.15255>;
        <D.15260>:
        D.15591 = (int) opcode;
        monoeg_g_log (0B, 16, "Unknown standard opcode %x in LNT", D.15591);
        goto error_out;
        <D.15255>:
        goto <D.15606>;
        <D.15593>:
        D.15558 = stm.opcode_base;
        opcode = opcode - D.15558;
        D.15598 = stm.offset;
        D.15591 = (int) opcode;
        D.15561 = stm.line_range;
        D.15607 = D.15591 / D.15561;
        D.15608 = D.15598 + D.15607;
        stm.offset = D.15608;
        D.15601 = stm.line;
        D.15609 = stm.line_base;
        D.15591 = (int) opcode;
        D.15561 = stm.line_range;
        D.15610 = D.15591 % D.15561;
        D.15611 = D.15609 + D.15610;
        D.15612 = D.15601 + D.15611;
        stm.line = D.15612;
        offset.11 = (int) offset;
        D.15613 = check_line (&stm, offset.11, &location);
        if (D.15613 != 0) goto out_success; else goto <D.15614>;
        <D.15614>:
        <D.15606>:
      }
      <D.15253>:
      goto <D.15262>;
      <D.15252>:
      error_out:
      mono_debugger_unlock ();
      D.15528 = 0B;
      return D.15528;
      out_success:
      mono_debugger_unlock ();
      D.15528 = location;
      return D.15528;
    }
  finally
    {
      location = {CLOBBER};
      ptr = {CLOBBER};
      stm = {CLOBBER};
    }
}


read_leb128 (const uint8_t * ptr, const uint8_t * * rptr)
{
  const uint8_t * ptr.12;
  int D.15618;
  int D.15619;
  int D.15620;
  signed char b.13;
  int D.15624;
  int ret;
  int shift;
  char b;

  ret = 0;
  shift = 0;
  <D.15209>:
  ptr.12 = ptr;
  ptr = ptr.12 + 1;
  b = *ptr.12;
  D.15618 = (int) b;
  D.15619 = D.15618 & 127;
  D.15620 = D.15619 << shift;
  ret = D.15620 | ret;
  shift = shift + 7;
  b.13 = (signed char) b;
  if (b.13 < 0) goto <D.15209>; else goto <D.15210>;
  <D.15210>:
  if (rptr != 0B) goto <D.15622>; else goto <D.15623>;
  <D.15622>:
  *rptr = ptr;
  <D.15623>:
  D.15624 = ret;
  return D.15624;
}


check_line (struct StatementMachine * stm, int offset, struct MonoDebugSourceLocation * * location)
{
  int D.15626;
  unsigned int D.15629;
  int D.15630;
  unsigned int D.15631;
  int D.15632;
  unsigned int D.15635;
  gboolean D.15636;
  unsigned int D.15637;
  struct MonoSymbolFile * D.15640;
  struct MonoSymbolFileOffsetTable * D.15641;
  uint32_t * D.15642;
  unsigned int D.15643;
  unsigned int D.15644;
  unsigned int D.15645;
  unsigned int D.15646;
  unsigned int D.15647;
  unsigned int D.15648;
  unsigned int D.15649;
  unsigned int D.15650;
  unsigned int D.15651;
  unsigned int D.15652;
  unsigned int D.15653;
  unsigned int D.15654;
  unsigned int D.15655;
  const uint8_t * D.15656;
  sizetype D.15657;
  uint32_t * D.15658;
  unsigned int D.15659;
  unsigned int D.15660;
  unsigned int D.15661;
  unsigned int D.15662;
  unsigned int D.15663;
  unsigned int D.15664;
  unsigned int D.15665;
  unsigned int D.15666;
  unsigned int D.15667;
  unsigned int D.15668;
  sizetype D.15669;
  const uint8_t * D.15670;
  unsigned int D.15671;
  void * D.15674;
  struct MonoDebugSourceLocation * D.15675;
  unsigned int D.15676;
  gchar * source_file;

  source_file = 0B;
  D.15626 = stm->offset;
  if (D.15626 <= offset) goto <D.15627>; else goto <D.15628>;
  <D.15627>:
  D.15626 = stm->offset;
  D.15629 = (unsigned int) D.15626;
  stm->last_offset = D.15629;
  D.15630 = stm->file;
  D.15631 = (unsigned int) D.15630;
  stm->last_file = D.15631;
  D.15632 = stm->line;
  if (D.15632 != 16707566) goto <D.15633>; else goto <D.15634>;
  <D.15633>:
  D.15632 = stm->line;
  D.15635 = (unsigned int) D.15632;
  stm->last_line = D.15635;
  <D.15634>:
  D.15636 = 0;
  return D.15636;
  <D.15628>:
  D.15637 = stm->last_file;
  if (D.15637 != 0) goto <D.15638>; else goto <D.15639>;
  <D.15638>:
  {
    int offset;
    struct MonoSymbolFileSourceEntry * se;

    D.15640 = stm->symfile;
    D.15641 = D.15640->offset_table;
    D.15642 = &D.15641->_source_table_offset;
    D.15643 = MEM[(const guint32 *)D.15642];
    D.15644 = D.15643 << 24;
    D.15640 = stm->symfile;
    D.15641 = D.15640->offset_table;
    D.15642 = &D.15641->_source_table_offset;
    D.15643 = MEM[(const guint32 *)D.15642];
    D.15645 = D.15643 >> 8;
    D.15646 = D.15645 & 65280;
    D.15647 = D.15644 | D.15646;
    D.15640 = stm->symfile;
    D.15641 = D.15640->offset_table;
    D.15642 = &D.15641->_source_table_offset;
    D.15643 = MEM[(const guint32 *)D.15642];
    D.15648 = D.15643 << 8;
    D.15649 = D.15648 & 16711680;
    D.15650 = D.15647 | D.15649;
    D.15640 = stm->symfile;
    D.15641 = D.15640->offset_table;
    D.15642 = &D.15641->_source_table_offset;
    D.15643 = MEM[(const guint32 *)D.15642];
    D.15651 = D.15643 >> 24;
    D.15652 = D.15650 | D.15651;
    D.15637 = stm->last_file;
    D.15653 = D.15637 + 536870911;
    D.15654 = D.15653 * 8;
    D.15655 = D.15652 + D.15654;
    offset = (int) D.15655;
    D.15640 = stm->symfile;
    D.15656 = D.15640->raw_contents;
    D.15657 = (sizetype) offset;
    se = D.15656 + D.15657;
    D.15640 = stm->symfile;
    D.15656 = D.15640->raw_contents;
    D.15658 = &se->_data_offset;
    D.15659 = MEM[(const guint32 *)D.15658];
    D.15660 = D.15659 << 24;
    D.15658 = &se->_data_offset;
    D.15659 = MEM[(const guint32 *)D.15658];
    D.15661 = D.15659 >> 8;
    D.15662 = D.15661 & 65280;
    D.15663 = D.15660 | D.15662;
    D.15658 = &se->_data_offset;
    D.15659 = MEM[(const guint32 *)D.15658];
    D.15664 = D.15659 << 8;
    D.15665 = D.15664 & 16711680;
    D.15666 = D.15663 | D.15665;
    D.15658 = &se->_data_offset;
    D.15659 = MEM[(const guint32 *)D.15658];
    D.15667 = D.15659 >> 24;
    D.15668 = D.15666 | D.15667;
    D.15669 = (sizetype) D.15668;
    D.15670 = D.15656 + D.15669;
    source_file = read_string (D.15670, 0B);
  }
  <D.15639>:
  D.15671 = stm->last_line;
  if (D.15671 == 0) goto <D.15672>; else goto <D.15673>;
  <D.15672>:
  *location = 0B;
  D.15636 = 1;
  return D.15636;
  <D.15673>:
  D.15674 = monoeg_malloc0 (24);
  *location = D.15674;
  D.15675 = *location;
  D.15675->source_file = source_file;
  D.15675 = *location;
  D.15671 = stm->last_line;
  D.15675->row = D.15671;
  D.15675 = *location;
  D.15676 = stm->last_offset;
  D.15675->il_offset = D.15676;
  D.15636 = 1;
  return D.15636;
}


read_string (const uint8_t * ptr, const uint8_t * * endp)
{
  const uint8_t * ptr.14;
  long int D.15679;
  sizetype D.15680;
  const uint8_t * ptr.15;
  gchar * D.15684;
  gchar * s;
  int len;

  ptr.14 = ptr;
  len = read_leb128 (ptr.14, &ptr);
  ptr.14 = ptr;
  D.15679 = (long int) len;
  s = monoeg_g_filename_from_utf8 (ptr.14, D.15679, 0B, 0B, 0B);
  ptr.14 = ptr;
  D.15680 = (sizetype) len;
  ptr.15 = ptr.14 + D.15680;
  ptr = ptr.15;
  if (endp != 0B) goto <D.15682>; else goto <D.15683>;
  <D.15682>:
  ptr.14 = ptr;
  *endp = ptr.14;
  <D.15683>:
  D.15684 = s;
  return D.15684;
}


mono_debug_symfile_free_location (struct MonoDebugSourceLocation * location)
{
  char * D.15686;

  D.15686 = location->source_file;
  monoeg_g_free (D.15686);
  monoeg_g_free (location);
}


mono_debug_symfile_get_line_numbers_full (struct MonoDebugMethodInfo * minfo, char * * source_file, struct GPtrArray * * source_file_list, int * n_il_offsets, int * * il_offsets, int * * line_numbers, int * * column_numbers, int * * source_files)
{
  struct MonoDebugHandle * D.15697;
  struct MonoSymbolFileOffsetTable * D.15700;
  uint32_t * D.15701;
  unsigned int D.15702;
  unsigned int D.15703;
  unsigned int D.15704;
  unsigned int D.15705;
  unsigned int D.15706;
  unsigned int D.15707;
  unsigned int D.15708;
  unsigned int D.15709;
  unsigned int D.15710;
  unsigned int D.15711;
  int D.15712;
  uint32_t * D.15713;
  unsigned int D.15714;
  unsigned int D.15715;
  unsigned int D.15716;
  unsigned int D.15717;
  unsigned int D.15718;
  unsigned int D.15719;
  unsigned int D.15720;
  unsigned int D.15721;
  unsigned int D.15722;
  unsigned int D.15723;
  int D.15724;
  uint32_t * D.15725;
  unsigned int D.15726;
  unsigned int D.15727;
  unsigned char D.15728;
  unsigned char D.15729;
  int D.15730;
  int D.15731;
  int D.15732;
  int D.15733;
  const uint8_t * D.15734;
  unsigned int D.15735;
  sizetype D.15736;
  const uint8_t * ptr.16;
  const unsigned char * ptr.17;
  const unsigned char * ptr.18;
  const unsigned char * ptr.19;
  const unsigned char * ptr.20;
  const unsigned char * ptr.21;
  sizetype D.15745;
  const unsigned char * ptr.22;
  const unsigned char * ptr.23;
  unsigned int D.15750;
  int D.15754;
  _Bool D.15755;
  int D.15756;
  unsigned char D.15758;
  int D.15762;
  int D.15765;
  int D.15766;
  int D.15767;
  int D.15768;
  int D.15769;
  int D.15770;
  int D.15771;
  int D.15772;
  int D.15773;
  int D.15775;
  int D.15776;
  int D.15777;
  int D.15778;
  int D.15779;
  int D.15780;
  int D.15781;
  unsigned int D.15784;
  int D.15787;
  struct MonoSymbolFile * D.15792;
  struct MonoSymbolFileOffsetTable * D.15793;
  uint32_t * D.15794;
  unsigned int D.15795;
  unsigned int D.15796;
  unsigned int D.15797;
  unsigned int D.15798;
  unsigned int D.15799;
  unsigned int D.15800;
  unsigned int D.15801;
  unsigned int D.15802;
  unsigned int D.15803;
  unsigned int D.15804;
  int D.15805;
  long unsigned int D.15806;
  unsigned int D.15807;
  unsigned int D.15808;
  unsigned int D.15809;
  const uint8_t * D.15810;
  sizetype D.15811;
  uint32_t * D.15814;
  unsigned int D.15815;
  unsigned int D.15816;
  unsigned int D.15817;
  unsigned int D.15818;
  unsigned int D.15819;
  unsigned int D.15820;
  unsigned int D.15821;
  unsigned int D.15822;
  unsigned int D.15823;
  unsigned int D.15824;
  sizetype D.15825;
  const uint8_t * D.15826;
  gchar * D.15827;
  struct GPtrArray * D.15830;
  long unsigned int D.15833;
  long unsigned int D.15834;
  void * D.15835;
  void * * D.15836;
  long unsigned int D.15837;
  long unsigned int D.15838;
  void * * D.15839;
  void * D.15840;
  long int D.15841;
  struct GPtrArray * D.15846;
  int * D.15849;
  long unsigned int D.15850;
  int * D.15851;
  unsigned int D.15852;
  unsigned int D.15853;
  int D.15854;
  int D.15861;
  void * D.15866;
  void * D.15867;
  int * D.15868;
  int * D.15869;
  void * * D.15870;
  void * * D.15871;
  void * D.15872;
  long int D.15873;
  int D.15874;
  int * D.15875;
  int * D.15876;
  void * * D.15877;
  void * * D.15878;
  void * D.15879;
  long int D.15880;
  int D.15881;
  void * D.15886;
  int * D.15887;
  int * D.15888;
  int D.15889;
  struct MonoSymbolFile * symfile;
  const unsigned char * ptr;
  struct StatementMachine stm;
  uint32_t i;
  struct GPtrArray * il_offset_array;
  struct GPtrArray * line_number_array;
  struct GPtrArray * source_file_array;
  gboolean has_column_info;

  try
    {
      if (source_file_list != 0B) goto <D.15687>; else goto <D.15688>;
      <D.15687>:
      *source_file_list = 0B;
      <D.15688>:
      if (n_il_offsets != 0B) goto <D.15689>; else goto <D.15690>;
      <D.15689>:
      *n_il_offsets = 0;
      <D.15690>:
      if (source_files != 0B) goto <D.15691>; else goto <D.15692>;
      <D.15691>:
      *source_files = 0B;
      <D.15692>:
      if (source_file != 0B) goto <D.15693>; else goto <D.15694>;
      <D.15693>:
      *source_file = 0B;
      <D.15694>:
      if (column_numbers != 0B) goto <D.15695>; else goto <D.15696>;
      <D.15695>:
      *column_numbers = 0B;
      <D.15696>:
      D.15697 = minfo->handle;
      symfile = D.15697->symfile;
      if (symfile == 0B) goto <D.15698>; else goto <D.15699>;
      <D.15698>:
      return;
      <D.15699>:
      has_column_info = method_has_column_info (minfo);
      il_offset_array = monoeg_g_ptr_array_new ();
      line_number_array = monoeg_g_ptr_array_new ();
      source_file_array = monoeg_g_ptr_array_new ();
      D.15700 = symfile->offset_table;
      D.15701 = &D.15700->_line_number_table_line_base;
      D.15702 = MEM[(const guint32 *)D.15701];
      D.15703 = D.15702 << 24;
      D.15700 = symfile->offset_table;
      D.15701 = &D.15700->_line_number_table_line_base;
      D.15702 = MEM[(const guint32 *)D.15701];
      D.15704 = D.15702 >> 8;
      D.15705 = D.15704 & 65280;
      D.15706 = D.15703 | D.15705;
      D.15700 = symfile->offset_table;
      D.15701 = &D.15700->_line_number_table_line_base;
      D.15702 = MEM[(const guint32 *)D.15701];
      D.15707 = D.15702 << 8;
      D.15708 = D.15707 & 16711680;
      D.15709 = D.15706 | D.15708;
      D.15700 = symfile->offset_table;
      D.15701 = &D.15700->_line_number_table_line_base;
      D.15702 = MEM[(const guint32 *)D.15701];
      D.15710 = D.15702 >> 24;
      D.15711 = D.15709 | D.15710;
      D.15712 = (int) D.15711;
      stm.line_base = D.15712;
      D.15700 = symfile->offset_table;
      D.15713 = &D.15700->_line_number_table_line_range;
      D.15714 = MEM[(const guint32 *)D.15713];
      D.15715 = D.15714 << 24;
      D.15700 = symfile->offset_table;
      D.15713 = &D.15700->_line_number_table_line_range;
      D.15714 = MEM[(const guint32 *)D.15713];
      D.15716 = D.15714 >> 8;
      D.15717 = D.15716 & 65280;
      D.15718 = D.15715 | D.15717;
      D.15700 = symfile->offset_table;
      D.15713 = &D.15700->_line_number_table_line_range;
      D.15714 = MEM[(const guint32 *)D.15713];
      D.15719 = D.15714 << 8;
      D.15720 = D.15719 & 16711680;
      D.15721 = D.15718 | D.15720;
      D.15700 = symfile->offset_table;
      D.15713 = &D.15700->_line_number_table_line_range;
      D.15714 = MEM[(const guint32 *)D.15713];
      D.15722 = D.15714 >> 24;
      D.15723 = D.15721 | D.15722;
      D.15724 = (int) D.15723;
      stm.line_range = D.15724;
      D.15700 = symfile->offset_table;
      D.15725 = &D.15700->_line_number_table_opcode_base;
      D.15726 = MEM[(const guint32 *)D.15725];
      D.15727 = D.15726 >> 24;
      D.15728 = (unsigned char) D.15727;
      stm.opcode_base = D.15728;
      D.15729 = stm.opcode_base;
      D.15730 = (int) D.15729;
      D.15731 = 255 - D.15730;
      D.15732 = stm.line_range;
      D.15733 = D.15731 / D.15732;
      stm.max_address_incr = D.15733;
      mono_debugger_lock ();
      D.15734 = symfile->raw_contents;
      D.15735 = minfo->lnt_offset;
      D.15736 = (sizetype) D.15735;
      ptr.16 = D.15734 + D.15736;
      ptr = ptr.16;
      stm.symfile = symfile;
      stm.last_offset = 0;
      stm.offset = 0;
      stm.last_file = 0;
      stm.last_line = 0;
      stm.first_file = 0;
      stm.file = 1;
      stm.line = 1;
      stm.is_hidden = 0;
      <D.15316>:
      {
        uint8_t opcode;

        ptr.17 = ptr;
        ptr.18 = ptr.17;
        ptr.19 = ptr.18 + 1;
        ptr = ptr.19;
        opcode = *ptr.18;
        if (opcode == 0) goto <D.15741>; else goto <D.15742>;
        <D.15741>:
        {
          uint8_t size;
          const unsigned char * end_ptr;

          ptr.17 = ptr;
          ptr.20 = ptr.17;
          ptr.21 = ptr.20 + 1;
          ptr = ptr.21;
          size = *ptr.20;
          ptr.17 = ptr;
          D.15745 = (sizetype) size;
          end_ptr = ptr.17 + D.15745;
          ptr.17 = ptr;
          ptr.22 = ptr.17;
          ptr.23 = ptr.22 + 1;
          ptr = ptr.23;
          opcode = *ptr.22;
          if (opcode == 1) goto <D.15748>; else goto <D.15749>;
          <D.15748>:
          D.15750 = il_offset_array->len;
          if (D.15750 == 0) goto <D.15307>; else goto <D.15751>;
          <D.15751>:
          add_line (&stm, il_offset_array, line_number_array, source_file_array);
          goto <D.15307>;
          <D.15749>:
          if (opcode == 64) goto <D.15752>; else goto <D.15753>;
          <D.15752>:
          D.15754 = stm.is_hidden;
          D.15755 = D.15754 == 0;
          D.15756 = (int) D.15755;
          stm.is_hidden = D.15756;
          goto <D.15757>;
          <D.15753>:
          D.15758 = opcode + 192;
          if (D.15758 <= 63) goto <D.15759>; else goto <D.15760>;
          <D.15759>:
          goto <D.15761>;
          <D.15760>:
          D.15762 = (int) opcode;
          monoeg_g_log (0B, 16, "Unknown extended opcode %x in LNT", D.15762);
          <D.15761>:
          <D.15757>:
          ptr = end_ptr;
          // predicted unlikely by continue predictor.
          goto <D.15308>;
        }
        <D.15742>:
        D.15729 = stm.opcode_base;
        if (D.15729 > opcode) goto <D.15763>; else goto <D.15764>;
        <D.15763>:
        D.15762 = (int) opcode;
        switch (D.15762) <default: <D.15315>, case 1: <D.15309>, case 2: <D.15311>, case 3: <D.15312>, case 4: <D.15313>, case 8: <D.15314>>
        <D.15309>:
        add_line (&stm, il_offset_array, line_number_array, source_file_array);
        goto <D.15310>;
        <D.15311>:
        ptr.17 = ptr;
        D.15765 = read_leb128 (ptr.17, &ptr);
        D.15766 = stm.offset;
        D.15767 = D.15766 + D.15765;
        stm.offset = D.15767;
        goto <D.15310>;
        <D.15312>:
        ptr.17 = ptr;
        D.15768 = read_leb128 (ptr.17, &ptr);
        D.15769 = stm.line;
        D.15770 = D.15769 + D.15768;
        stm.line = D.15770;
        goto <D.15310>;
        <D.15313>:
        ptr.17 = ptr;
        D.15771 = read_leb128 (ptr.17, &ptr);
        stm.file = D.15771;
        goto <D.15310>;
        <D.15314>:
        D.15766 = stm.offset;
        D.15772 = stm.max_address_incr;
        D.15773 = D.15766 + D.15772;
        stm.offset = D.15773;
        goto <D.15310>;
        <D.15315>:
        D.15762 = (int) opcode;
        monoeg_g_log (0B, 16, "Unknown standard opcode %x in LNT", D.15762);
        monoeg_assertion_message ("* Assertion: should not be reached at %s:%d\n", "debug-mono-symfile.c", 599);
        <D.15310>:
        goto <D.15774>;
        <D.15764>:
        D.15729 = stm.opcode_base;
        opcode = opcode - D.15729;
        D.15766 = stm.offset;
        D.15762 = (int) opcode;
        D.15732 = stm.line_range;
        D.15775 = D.15762 / D.15732;
        D.15776 = D.15766 + D.15775;
        stm.offset = D.15776;
        D.15769 = stm.line;
        D.15777 = stm.line_base;
        D.15762 = (int) opcode;
        D.15732 = stm.line_range;
        D.15778 = D.15762 % D.15732;
        D.15779 = D.15777 + D.15778;
        D.15780 = D.15769 + D.15779;
        stm.line = D.15780;
        add_line (&stm, il_offset_array, line_number_array, source_file_array);
        <D.15774>:
      }
      <D.15308>:
      goto <D.15316>;
      <D.15307>:
      D.15781 = stm.file;
      if (D.15781 == 0) goto <D.15782>; else goto <D.15783>;
      <D.15782>:
      D.15784 = stm.first_file;
      if (D.15784 != 0) goto <D.15785>; else goto <D.15786>;
      <D.15785>:
      D.15784 = stm.first_file;
      D.15787 = (int) D.15784;
      stm.file = D.15787;
      <D.15786>:
      <D.15783>:
      D.15781 = stm.file;
      if (D.15781 != 0) goto <D.15788>; else goto <D.15789>;
      <D.15788>:
      if (source_file != 0B) goto <D.15790>; else goto <D.15791>;
      <D.15790>:
      {
        int offset;
        struct MonoSymbolFileSourceEntry * se;

        D.15792 = stm.symfile;
        D.15793 = D.15792->offset_table;
        D.15794 = &D.15793->_source_table_offset;
        D.15795 = MEM[(const guint32 *)D.15794];
        D.15796 = D.15795 << 24;
        D.15792 = stm.symfile;
        D.15793 = D.15792->offset_table;
        D.15794 = &D.15793->_source_table_offset;
        D.15795 = MEM[(const guint32 *)D.15794];
        D.15797 = D.15795 >> 8;
        D.15798 = D.15797 & 65280;
        D.15799 = D.15796 | D.15798;
        D.15792 = stm.symfile;
        D.15793 = D.15792->offset_table;
        D.15794 = &D.15793->_source_table_offset;
        D.15795 = MEM[(const guint32 *)D.15794];
        D.15800 = D.15795 << 8;
        D.15801 = D.15800 & 16711680;
        D.15802 = D.15799 | D.15801;
        D.15792 = stm.symfile;
        D.15793 = D.15792->offset_table;
        D.15794 = &D.15793->_source_table_offset;
        D.15795 = MEM[(const guint32 *)D.15794];
        D.15803 = D.15795 >> 24;
        D.15804 = D.15802 | D.15803;
        D.15781 = stm.file;
        D.15805 = D.15781 + -1;
        D.15806 = (long unsigned int) D.15805;
        D.15807 = (unsigned int) D.15806;
        D.15808 = D.15807 * 8;
        D.15809 = D.15804 + D.15808;
        offset = (int) D.15809;
        D.15792 = stm.symfile;
        D.15810 = D.15792->raw_contents;
        D.15811 = (sizetype) offset;
        se = D.15810 + D.15811;
        if (source_file != 0B) goto <D.15812>; else goto <D.15813>;
        <D.15812>:
        D.15792 = stm.symfile;
        D.15810 = D.15792->raw_contents;
        D.15814 = &se->_data_offset;
        D.15815 = MEM[(const guint32 *)D.15814];
        D.15816 = D.15815 << 24;
        D.15814 = &se->_data_offset;
        D.15815 = MEM[(const guint32 *)D.15814];
        D.15817 = D.15815 >> 8;
        D.15818 = D.15817 & 65280;
        D.15819 = D.15816 | D.15818;
        D.15814 = &se->_data_offset;
        D.15815 = MEM[(const guint32 *)D.15814];
        D.15820 = D.15815 << 8;
        D.15821 = D.15820 & 16711680;
        D.15822 = D.15819 | D.15821;
        D.15814 = &se->_data_offset;
        D.15815 = MEM[(const guint32 *)D.15814];
        D.15823 = D.15815 >> 24;
        D.15824 = D.15822 | D.15823;
        D.15825 = (sizetype) D.15824;
        D.15826 = D.15810 + D.15825;
        D.15827 = read_string (D.15826, 0B);
        *source_file = D.15827;
        <D.15813>:
      }
      <D.15791>:
      <D.15789>:
      if (source_file_list != 0B) goto <D.15828>; else goto <D.15829>;
      <D.15828>:
      {
        int file;
        int last_file;

        last_file = 0;
        D.15830 = monoeg_g_ptr_array_new ();
        *source_file_list = D.15830;
        if (source_files != 0B) goto <D.15831>; else goto <D.15832>;
        <D.15831>:
        D.15750 = il_offset_array->len;
        D.15833 = (long unsigned int) D.15750;
        D.15834 = D.15833 * 4;
        D.15835 = monoeg_malloc (D.15834);
        *source_files = D.15835;
        <D.15832>:
        i = 0;
        goto <D.15323>;
        <D.15322>:
        D.15836 = source_file_array->pdata;
        D.15837 = (long unsigned int) i;
        D.15838 = D.15837 * 8;
        D.15839 = D.15836 + D.15838;
        D.15840 = *D.15839;
        D.15841 = (long int) D.15840;
        file = (int) D.15841;
        if (file != 0) goto <D.15842>; else goto <D.15843>;
        <D.15842>:
        if (file != last_file) goto <D.15844>; else goto <D.15845>;
        <D.15844>:
        {
          struct MonoDebugSourceInfo * info;

          info = get_source_info (symfile, file);
          D.15846 = *source_file_list;
          monoeg_g_ptr_array_add (D.15846, info);
        }
        <D.15845>:
        <D.15843>:
        last_file = file;
        if (source_files != 0B) goto <D.15847>; else goto <D.15848>;
        <D.15847>:
        D.15849 = *source_files;
        D.15837 = (long unsigned int) i;
        D.15850 = D.15837 * 4;
        D.15851 = D.15849 + D.15850;
        D.15846 = *source_file_list;
        D.15852 = D.15846->len;
        D.15853 = D.15852 + 4294967295;
        D.15854 = (int) D.15853;
        *D.15851 = D.15854;
        <D.15848>:
        i = i + 1;
        <D.15323>:
        D.15750 = il_offset_array->len;
        if (D.15750 > i) goto <D.15322>; else goto <D.15324>;
        <D.15324>:
        D.15846 = *source_file_list;
        D.15852 = D.15846->len;
        if (D.15852 == 0) goto <D.15855>; else goto <D.15856>;
        <D.15855>:
        D.15781 = stm.file;
        if (D.15781 != 0) goto <D.15857>; else goto <D.15858>;
        <D.15857>:
        {
          struct MonoDebugSourceInfo * info;

          D.15781 = stm.file;
          info = get_source_info (symfile, D.15781);
          D.15846 = *source_file_list;
          monoeg_g_ptr_array_add (D.15846, info);
        }
        <D.15858>:
        <D.15856>:
      }
      <D.15829>:
      if (n_il_offsets != 0B) goto <D.15859>; else goto <D.15860>;
      <D.15859>:
      D.15750 = il_offset_array->len;
      D.15861 = (int) D.15750;
      *n_il_offsets = D.15861;
      <D.15860>:
      if (il_offsets != 0B) goto <D.15862>; else goto <D.15863>;
      <D.15862>:
      if (line_numbers != 0B) goto <D.15864>; else goto <D.15865>;
      <D.15864>:
      D.15750 = il_offset_array->len;
      D.15833 = (long unsigned int) D.15750;
      D.15834 = D.15833 * 4;
      D.15866 = monoeg_malloc (D.15834);
      *il_offsets = D.15866;
      D.15750 = il_offset_array->len;
      D.15833 = (long unsigned int) D.15750;
      D.15834 = D.15833 * 4;
      D.15867 = monoeg_malloc (D.15834);
      *line_numbers = D.15867;
      i = 0;
      goto <D.15327>;
      <D.15326>:
      D.15868 = *il_offsets;
      D.15837 = (long unsigned int) i;
      D.15850 = D.15837 * 4;
      D.15869 = D.15868 + D.15850;
      D.15870 = il_offset_array->pdata;
      D.15837 = (long unsigned int) i;
      D.15838 = D.15837 * 8;
      D.15871 = D.15870 + D.15838;
      D.15872 = *D.15871;
      D.15873 = (long int) D.15872;
      D.15874 = (int) D.15873;
      *D.15869 = D.15874;
      D.15875 = *line_numbers;
      D.15837 = (long unsigned int) i;
      D.15850 = D.15837 * 4;
      D.15876 = D.15875 + D.15850;
      D.15877 = line_number_array->pdata;
      D.15837 = (long unsigned int) i;
      D.15838 = D.15837 * 8;
      D.15878 = D.15877 + D.15838;
      D.15879 = *D.15878;
      D.15880 = (long int) D.15879;
      D.15881 = (int) D.15880;
      *D.15876 = D.15881;
      i = i + 1;
      <D.15327>:
      D.15750 = il_offset_array->len;
      if (D.15750 > i) goto <D.15326>; else goto <D.15328>;
      <D.15328>:
      <D.15865>:
      <D.15863>:
      if (column_numbers != 0B) goto <D.15882>; else goto <D.15883>;
      <D.15882>:
      if (has_column_info != 0) goto <D.15884>; else goto <D.15885>;
      <D.15884>:
      D.15750 = il_offset_array->len;
      D.15833 = (long unsigned int) D.15750;
      D.15834 = D.15833 * 4;
      D.15886 = monoeg_malloc (D.15834);
      *column_numbers = D.15886;
      i = 0;
      goto <D.15330>;
      <D.15329>:
      D.15887 = *column_numbers;
      D.15837 = (long unsigned int) i;
      D.15850 = D.15837 * 4;
      D.15888 = D.15887 + D.15850;
      ptr.17 = ptr;
      D.15889 = read_leb128 (ptr.17, &ptr);
      *D.15888 = D.15889;
      i = i + 1;
      <D.15330>:
      D.15750 = il_offset_array->len;
      if (D.15750 > i) goto <D.15329>; else goto <D.15331>;
      <D.15331>:
      <D.15885>:
      <D.15883>:
      monoeg_g_ptr_array_free (il_offset_array, 1);
      monoeg_g_ptr_array_free (line_number_array, 1);
      mono_debugger_unlock ();
      return;
    }
  finally
    {
      ptr = {CLOBBER};
      stm = {CLOBBER};
    }
}


method_has_column_info (struct MonoDebugMethodInfo * minfo)
{
  struct MonoDebugHandle * D.15892;
  gboolean D.15895;
  const uint8_t * D.15896;
  unsigned int D.15897;
  sizetype D.15898;
  const uint8_t * ptr.24;
  const unsigned char * ptr.25;
  int D.15901;
  unsigned int D.15902;
  _Bool D.15903;
  struct MonoSymbolFile * symfile;
  const unsigned char * ptr;
  guint32 flags;

  try
    {
      D.15892 = minfo->handle;
      symfile = D.15892->symfile;
      if (symfile == 0B) goto <D.15893>; else goto <D.15894>;
      <D.15893>:
      D.15895 = 0;
      return D.15895;
      <D.15894>:
      D.15896 = symfile->raw_contents;
      D.15897 = minfo->data_offset;
      D.15898 = (sizetype) D.15897;
      ptr.24 = D.15896 + D.15898;
      ptr = ptr.24;
      ptr.25 = ptr;
      read_leb128 (ptr.25, &ptr);
      ptr.25 = ptr;
      read_leb128 (ptr.25, &ptr);
      ptr.25 = ptr;
      read_leb128 (ptr.25, &ptr);
      ptr.25 = ptr;
      read_leb128 (ptr.25, &ptr);
      ptr.25 = ptr;
      read_leb128 (ptr.25, &ptr);
      ptr.25 = ptr;
      read_leb128 (ptr.25, &ptr);
      ptr.25 = ptr;
      D.15901 = read_leb128 (ptr.25, &ptr);
      flags = (guint32) D.15901;
      D.15902 = flags & 2;
      D.15903 = D.15902 != 0;
      D.15895 = (gboolean) D.15903;
      return D.15895;
    }
  finally
    {
      ptr = {CLOBBER};
    }
}


add_line (struct StatementMachine * stm, struct GPtrArray * il_offset_array, struct GPtrArray * line_number_array, struct GPtrArray * source_file_array)
{
  int D.15906;
  int D.15909;
  long unsigned int D.15910;
  void * D.15911;
  long unsigned int D.15912;
  void * D.15913;
  int D.15914;
  long unsigned int D.15915;
  void * D.15916;
  int D.15917;
  unsigned int D.15920;
  unsigned int D.15923;

  D.15906 = stm->line;
  if (D.15906 > 0) goto <D.15907>; else goto <D.15908>;
  <D.15907>:
  D.15909 = stm->offset;
  D.15910 = (long unsigned int) D.15909;
  D.15911 = (void *) D.15910;
  monoeg_g_ptr_array_add (il_offset_array, D.15911);
  D.15906 = stm->line;
  D.15912 = (long unsigned int) D.15906;
  D.15913 = (void *) D.15912;
  monoeg_g_ptr_array_add (line_number_array, D.15913);
  D.15914 = stm->file;
  D.15915 = (long unsigned int) D.15914;
  D.15916 = (void *) D.15915;
  monoeg_g_ptr_array_add (source_file_array, D.15916);
  <D.15908>:
  D.15917 = stm->is_hidden;
  if (D.15917 == 0) goto <D.15918>; else goto <D.15919>;
  <D.15918>:
  D.15920 = stm->first_file;
  if (D.15920 == 0) goto <D.15921>; else goto <D.15922>;
  <D.15921>:
  D.15914 = stm->file;
  D.15923 = (unsigned int) D.15914;
  stm->first_file = D.15923;
  <D.15922>:
  <D.15919>:
}


get_source_info (struct MonoSymbolFile * symfile, int index)
{
  struct GHashTable * D.15924;
  long unsigned int D.15925;
  const void * D.15926;
  struct MonoSymbolFileOffsetTable * D.15929;
  uint32_t * D.15930;
  unsigned int D.15931;
  unsigned int D.15932;
  unsigned int D.15933;
  unsigned int D.15934;
  unsigned int D.15935;
  unsigned int D.15936;
  unsigned int D.15937;
  unsigned int D.15938;
  unsigned int D.15939;
  unsigned int D.15940;
  int D.15941;
  long unsigned int D.15942;
  unsigned int D.15943;
  unsigned int D.15944;
  unsigned int D.15945;
  const uint8_t * D.15946;
  sizetype D.15947;
  uint32_t * D.15948;
  unsigned int D.15949;
  unsigned int D.15950;
  unsigned int D.15951;
  unsigned int D.15952;
  unsigned int D.15953;
  unsigned int D.15954;
  unsigned int D.15955;
  unsigned int D.15956;
  unsigned int D.15957;
  unsigned int D.15958;
  sizetype D.15959;
  const uint8_t * ptr.26;
  const uint8_t * ptr.27;
  gchar * D.15962;
  void * D.15963;
  guint8 * D.15964;
  const uint8_t * ptr.28;
  void * D.15966;
  guint8 * D.15967;
  void * D.15968;
  struct MonoDebugSourceInfo * D.15969;
  struct MonoDebugSourceInfo * info;

  D.15924 = symfile->source_hash;
  D.15925 = (long unsigned int) index;
  D.15926 = (const void *) D.15925;
  info = monoeg_g_hash_table_lookup (D.15924, D.15926);
  if (info == 0B) goto <D.15927>; else goto <D.15928>;
  <D.15927>:
  {
    int offset;
    struct MonoSymbolFileSourceEntry * se;
    const uint8_t * ptr;

    try
      {
        D.15929 = symfile->offset_table;
        D.15930 = &D.15929->_source_table_offset;
        D.15931 = MEM[(const guint32 *)D.15930];
        D.15932 = D.15931 << 24;
        D.15929 = symfile->offset_table;
        D.15930 = &D.15929->_source_table_offset;
        D.15931 = MEM[(const guint32 *)D.15930];
        D.15933 = D.15931 >> 8;
        D.15934 = D.15933 & 65280;
        D.15935 = D.15932 | D.15934;
        D.15929 = symfile->offset_table;
        D.15930 = &D.15929->_source_table_offset;
        D.15931 = MEM[(const guint32 *)D.15930];
        D.15936 = D.15931 << 8;
        D.15937 = D.15936 & 16711680;
        D.15938 = D.15935 | D.15937;
        D.15929 = symfile->offset_table;
        D.15930 = &D.15929->_source_table_offset;
        D.15931 = MEM[(const guint32 *)D.15930];
        D.15939 = D.15931 >> 24;
        D.15940 = D.15938 | D.15939;
        D.15941 = index + -1;
        D.15942 = (long unsigned int) D.15941;
        D.15943 = (unsigned int) D.15942;
        D.15944 = D.15943 * 8;
        D.15945 = D.15940 + D.15944;
        offset = (int) D.15945;
        D.15946 = symfile->raw_contents;
        D.15947 = (sizetype) offset;
        se = D.15946 + D.15947;
        D.15946 = symfile->raw_contents;
        D.15948 = &se->_data_offset;
        D.15949 = MEM[(const guint32 *)D.15948];
        D.15950 = D.15949 << 24;
        D.15948 = &se->_data_offset;
        D.15949 = MEM[(const guint32 *)D.15948];
        D.15951 = D.15949 >> 8;
        D.15952 = D.15951 & 65280;
        D.15953 = D.15950 | D.15952;
        D.15948 = &se->_data_offset;
        D.15949 = MEM[(const guint32 *)D.15948];
        D.15954 = D.15949 << 8;
        D.15955 = D.15954 & 16711680;
        D.15956 = D.15953 | D.15955;
        D.15948 = &se->_data_offset;
        D.15949 = MEM[(const guint32 *)D.15948];
        D.15957 = D.15949 >> 24;
        D.15958 = D.15956 | D.15957;
        D.15959 = (sizetype) D.15958;
        ptr.26 = D.15946 + D.15959;
        ptr = ptr.26;
        info = monoeg_malloc0 (24);
        ptr.27 = ptr;
        D.15962 = read_string (ptr.27, &ptr);
        info->source_file = D.15962;
        D.15963 = monoeg_malloc0 (16);
        info->guid = D.15963;
        D.15964 = info->guid;
        ptr.27 = ptr;
        memcpy (D.15964, ptr.27, 16);
        ptr.27 = ptr;
        ptr.28 = ptr.27 + 16;
        ptr = ptr.28;
        D.15966 = monoeg_malloc0 (16);
        info->hash = D.15966;
        D.15967 = info->hash;
        ptr.27 = ptr;
        memcpy (D.15967, ptr.27, 16);
        ptr.27 = ptr;
        ptr.28 = ptr.27 + 16;
        ptr = ptr.28;
        D.15924 = symfile->source_hash;
        D.15925 = (long unsigned int) index;
        D.15968 = (void *) D.15925;
        monoeg_g_hash_table_insert_replace (D.15924, D.15968, info, 0);
      }
    finally
      {
        ptr = {CLOBBER};
      }
  }
  <D.15928>:
  D.15969 = info;
  return D.15969;
}


mono_debug_symfile_get_line_numbers (struct MonoDebugMethodInfo * minfo, char * * source_file, int * n_il_offsets, int * * il_offsets, int * * line_numbers)
{
  mono_debug_symfile_get_line_numbers_full (minfo, source_file, 0B, n_il_offsets, il_offsets, line_numbers, 0B, 0B);
}


_mono_debug_address_from_il_offset (struct MonoDebugMethodJitInfo * jit, uint32_t il_offset)
{
  struct MonoDebugLineNumberEntry * D.15974;
  int32_t D.15975;
  unsigned int D.15976;
  unsigned int D.15977;
  long unsigned int D.15978;
  long unsigned int D.15979;
  struct MonoDebugLineNumberEntry * D.15980;
  unsigned int D.15981;
  unsigned int D.15984;
  int i;

  if (jit == 0B) goto <D.15971>; else goto <D.15973>;
  <D.15973>:
  D.15974 = jit->line_numbers;
  if (D.15974 == 0B) goto <D.15971>; else goto <D.15972>;
  <D.15971>:
  D.15975 = -1;
  return D.15975;
  <D.15972>:
  D.15976 = jit->num_line_numbers;
  D.15977 = D.15976 + 4294967295;
  i = (int) D.15977;
  goto <D.15346>;
  <D.15345>:
  {
    struct MonoDebugLineNumberEntry lne;

    try
      {
        D.15974 = jit->line_numbers;
        D.15978 = (long unsigned int) i;
        D.15979 = D.15978 * 8;
        D.15980 = D.15974 + D.15979;
        lne = *D.15980;
        D.15981 = lne.il_offset;
        if (D.15981 <= il_offset) goto <D.15982>; else goto <D.15983>;
        <D.15982>:
        D.15984 = lne.native_offset;
        D.15975 = (int32_t) D.15984;
        return D.15975;
        <D.15983>:
      }
    finally
      {
        lne = {CLOBBER};
      }
  }
  i = i + -1;
  <D.15346>:
  if (i >= 0) goto <D.15345>; else goto <D.15347>;
  <D.15347>:
  D.15975 = 0;
  return D.15975;
}


mono_debug_symfile_lookup_method (struct MonoDebugHandle * handle, struct MonoMethod * method)
{
  struct GHashTable * D.15988;
  struct MonoDebugMethodInfo * D.15991;
  struct MonoImage * D.15992;
  struct MonoClass * D.15993;
  struct MonoImage * D.15994;
  const uint8_t * D.15999;
  struct MonoSymbolFileOffsetTable * D.16000;
  uint32_t * D.16001;
  unsigned int D.16002;
  unsigned int D.16003;
  unsigned int D.16004;
  unsigned int D.16005;
  unsigned int D.16006;
  unsigned int D.16007;
  unsigned int D.16008;
  unsigned int D.16009;
  unsigned int D.16010;
  unsigned int D.16011;
  sizetype D.16012;
  unsigned int D.16013;
  long unsigned int D.16014;
  const void * D.16015;
  uint32_t * D.16016;
  unsigned int D.16017;
  unsigned int D.16018;
  unsigned int D.16019;
  unsigned int D.16020;
  unsigned int D.16021;
  unsigned int D.16022;
  unsigned int D.16023;
  unsigned int D.16024;
  unsigned int D.16025;
  unsigned int D.16026;
  long unsigned int D.16027;
  long int ie.29;
  long int first_ie.30;
  long int D.16032;
  long int D.16033;
  unsigned int D.16034;
  unsigned int D.16035;
  uint32_t * D.16036;
  unsigned int D.16037;
  unsigned int D.16038;
  unsigned int D.16039;
  unsigned int D.16040;
  unsigned int D.16041;
  unsigned int D.16042;
  unsigned int D.16043;
  unsigned int D.16044;
  unsigned int D.16045;
  unsigned int D.16046;
  uint32_t * D.16047;
  unsigned int D.16048;
  unsigned int D.16049;
  unsigned int D.16050;
  unsigned int D.16051;
  unsigned int D.16052;
  unsigned int D.16053;
  unsigned int D.16054;
  unsigned int D.16055;
  unsigned int D.16056;
  unsigned int D.16057;
  struct MonoSymbolFileMethodEntry * first_ie;
  struct MonoSymbolFileMethodEntry * ie;
  struct MonoDebugMethodInfo * minfo;
  struct MonoSymbolFile * symfile;

  symfile = handle->symfile;
  D.15988 = symfile->method_hash;
  if (D.15988 == 0B) goto <D.15989>; else goto <D.15990>;
  <D.15989>:
  D.15991 = 0B;
  return D.15991;
  <D.15990>:
  D.15992 = handle->image;
  D.15993 = mono_method_get_class (method);
  D.15994 = mono_class_get_image (D.15993);
  if (D.15992 != D.15994) goto <D.15995>; else goto <D.15996>;
  <D.15995>:
  D.15991 = 0B;
  return D.15991;
  <D.15996>:
  mono_debugger_lock ();
  D.15988 = symfile->method_hash;
  minfo = monoeg_g_hash_table_lookup (D.15988, method);
  if (minfo != 0B) goto <D.15997>; else goto <D.15998>;
  <D.15997>:
  mono_debugger_unlock ();
  D.15991 = minfo;
  return D.15991;
  <D.15998>:
  D.15999 = symfile->raw_contents;
  D.16000 = symfile->offset_table;
  D.16001 = &D.16000->_method_table_offset;
  D.16002 = MEM[(const guint32 *)D.16001];
  D.16003 = D.16002 << 24;
  D.16000 = symfile->offset_table;
  D.16001 = &D.16000->_method_table_offset;
  D.16002 = MEM[(const guint32 *)D.16001];
  D.16004 = D.16002 >> 8;
  D.16005 = D.16004 & 65280;
  D.16006 = D.16003 | D.16005;
  D.16000 = symfile->offset_table;
  D.16001 = &D.16000->_method_table_offset;
  D.16002 = MEM[(const guint32 *)D.16001];
  D.16007 = D.16002 << 8;
  D.16008 = D.16007 & 16711680;
  D.16009 = D.16006 | D.16008;
  D.16000 = symfile->offset_table;
  D.16001 = &D.16000->_method_table_offset;
  D.16002 = MEM[(const guint32 *)D.16001];
  D.16010 = D.16002 >> 24;
  D.16011 = D.16009 | D.16010;
  D.16012 = (sizetype) D.16011;
  first_ie = D.15999 + D.16012;
  D.16013 = mono_method_get_token (method);
  D.16014 = (long unsigned int) D.16013;
  D.16015 = (const void *) D.16014;
  D.16000 = symfile->offset_table;
  D.16016 = &D.16000->_method_count;
  D.16017 = MEM[(const guint32 *)D.16016];
  D.16018 = D.16017 << 24;
  D.16000 = symfile->offset_table;
  D.16016 = &D.16000->_method_count;
  D.16017 = MEM[(const guint32 *)D.16016];
  D.16019 = D.16017 >> 8;
  D.16020 = D.16019 & 65280;
  D.16021 = D.16018 | D.16020;
  D.16000 = symfile->offset_table;
  D.16016 = &D.16000->_method_count;
  D.16017 = MEM[(const guint32 *)D.16016];
  D.16022 = D.16017 << 8;
  D.16023 = D.16022 & 16711680;
  D.16024 = D.16021 | D.16023;
  D.16000 = symfile->offset_table;
  D.16016 = &D.16000->_method_count;
  D.16017 = MEM[(const guint32 *)D.16016];
  D.16025 = D.16017 >> 24;
  D.16026 = D.16024 | D.16025;
  D.16027 = (long unsigned int) D.16026;
  ie = mono_binary_search (D.16015, first_ie, D.16027, 12, compare_method);
  if (ie == 0B) goto <D.16028>; else goto <D.16029>;
  <D.16028>:
  mono_debugger_unlock ();
  D.15991 = 0B;
  return D.15991;
  <D.16029>:
  minfo = monoeg_malloc0 (32);
  ie.29 = (long int) ie;
  first_ie.30 = (long int) first_ie;
  D.16032 = ie.29 - first_ie.30;
  D.16033 = D.16032 /[ex] 12;
  D.16034 = (unsigned int) D.16033;
  D.16035 = D.16034 + 1;
  minfo->index = D.16035;
  minfo->method = method;
  minfo->handle = handle;
  D.16036 = &ie->_data_offset;
  D.16037 = MEM[(const guint32 *)D.16036];
  D.16038 = D.16037 << 24;
  D.16036 = &ie->_data_offset;
  D.16037 = MEM[(const guint32 *)D.16036];
  D.16039 = D.16037 >> 8;
  D.16040 = D.16039 & 65280;
  D.16041 = D.16038 | D.16040;
  D.16036 = &ie->_data_offset;
  D.16037 = MEM[(const guint32 *)D.16036];
  D.16042 = D.16037 << 8;
  D.16043 = D.16042 & 16711680;
  D.16044 = D.16041 | D.16043;
  D.16036 = &ie->_data_offset;
  D.16037 = MEM[(const guint32 *)D.16036];
  D.16045 = D.16037 >> 24;
  D.16046 = D.16044 | D.16045;
  minfo->data_offset = D.16046;
  D.16047 = &ie->_line_number_table;
  D.16048 = MEM[(const guint32 *)D.16047];
  D.16049 = D.16048 << 24;
  D.16047 = &ie->_line_number_table;
  D.16048 = MEM[(const guint32 *)D.16047];
  D.16050 = D.16048 >> 8;
  D.16051 = D.16050 & 65280;
  D.16052 = D.16049 | D.16051;
  D.16047 = &ie->_line_number_table;
  D.16048 = MEM[(const guint32 *)D.16047];
  D.16053 = D.16048 << 8;
  D.16054 = D.16053 & 16711680;
  D.16055 = D.16052 | D.16054;
  D.16047 = &ie->_line_number_table;
  D.16048 = MEM[(const guint32 *)D.16047];
  D.16056 = D.16048 >> 24;
  D.16057 = D.16055 | D.16056;
  minfo->lnt_offset = D.16057;
  D.15988 = symfile->method_hash;
  monoeg_g_hash_table_insert_replace (D.15988, method, minfo, 0);
  mono_debugger_unlock ();
  D.15991 = minfo;
  return D.15991;
}


compare_method (const void * key, const void * object)
{
  long int key.31;
  int D.16060;
  uint32_t * D.16061;
  unsigned int D.16062;
  unsigned int D.16063;
  unsigned int D.16064;
  unsigned int D.16065;
  unsigned int D.16066;
  unsigned int D.16067;
  unsigned int D.16068;
  unsigned int D.16069;
  unsigned int D.16070;
  unsigned int D.16071;
  unsigned int D.16072;
  uint32_t token;
  struct MonoSymbolFileMethodEntry * me;

  key.31 = (long int) key;
  token = (uint32_t) key.31;
  me = object;
  D.16061 = &me->_token;
  D.16062 = MEM[(const guint32 *)D.16061];
  D.16063 = D.16062 << 24;
  D.16061 = &me->_token;
  D.16062 = MEM[(const guint32 *)D.16061];
  D.16064 = D.16062 >> 8;
  D.16065 = D.16064 & 65280;
  D.16066 = D.16063 | D.16065;
  D.16061 = &me->_token;
  D.16062 = MEM[(const guint32 *)D.16061];
  D.16067 = D.16062 << 8;
  D.16068 = D.16067 & 16711680;
  D.16069 = D.16066 | D.16068;
  D.16061 = &me->_token;
  D.16062 = MEM[(const guint32 *)D.16061];
  D.16070 = D.16062 >> 24;
  D.16071 = D.16069 | D.16070;
  D.16072 = token - D.16071;
  D.16060 = (int) D.16072;
  return D.16060;
}


mono_debug_symfile_lookup_locals (struct MonoDebugMethodInfo * minfo)
{
  struct MonoDebugHandle * D.16074;
  struct MonoDebugLocalsInfo * D.16077;
  const uint8_t * D.16078;
  unsigned int D.16079;
  sizetype D.16080;
  const uint8_t * p.32;
  const uint8_t * p.33;
  sizetype D.16083;
  const uint8_t * p.34;
  int D.16085;
  int D.16086;
  long unsigned int D.16087;
  long unsigned int D.16088;
  void * D.16089;
  struct MonoDebugCodeBlock * D.16090;
  long unsigned int D.16091;
  long unsigned int D.16092;
  struct MonoDebugCodeBlock * D.16093;
  int D.16094;
  int D.16095;
  int D.16096;
  int D.16097;
  sizetype D.16098;
  const uint8_t * p.35;
  long unsigned int D.16100;
  long unsigned int D.16101;
  void * D.16102;
  struct MonoDebugLocalVar * D.16103;
  long unsigned int D.16104;
  struct MonoDebugLocalVar * D.16105;
  int D.16106;
  int D.16107;
  long unsigned int D.16108;
  void * D.16109;
  char * D.16110;
  long unsigned int D.16111;
  sizetype D.16112;
  char * D.16113;
  const uint8_t * p.36;
  long unsigned int D.16119;
  long unsigned int D.16120;
  sizetype D.16121;
  struct MonoDebugCodeBlock * D.16122;
  struct MonoSymbolFile * symfile;
  const uint8_t * p;
  int i;
  int len;
  int compile_unit_index;
  int locals_offset;
  int num_locals;
  int block_index;
  int namespace_id;
  int code_block_table_offset;
  struct MonoDebugLocalsInfo * res;

  try
    {
      D.16074 = minfo->handle;
      symfile = D.16074->symfile;
      if (symfile == 0B) goto <D.16075>; else goto <D.16076>;
      <D.16075>:
      D.16077 = 0B;
      return D.16077;
      <D.16076>:
      D.16078 = symfile->raw_contents;
      D.16079 = minfo->data_offset;
      D.16080 = (sizetype) D.16079;
      p.32 = D.16078 + D.16080;
      p = p.32;
      p.33 = p;
      compile_unit_index = read_leb128 (p.33, &p);
      p.33 = p;
      locals_offset = read_leb128 (p.33, &p);
      p.33 = p;
      namespace_id = read_leb128 (p.33, &p);
      p.33 = p;
      code_block_table_offset = read_leb128 (p.33, &p);
      res = monoeg_malloc0 (32);
      D.16078 = symfile->raw_contents;
      D.16083 = (sizetype) code_block_table_offset;
      p.34 = D.16078 + D.16083;
      p = p.34;
      p.33 = p;
      D.16085 = read_leb128 (p.33, &p);
      res->num_blocks = D.16085;
      D.16086 = res->num_blocks;
      D.16087 = (long unsigned int) D.16086;
      D.16088 = D.16087 * 16;
      D.16089 = monoeg_malloc0 (D.16088);
      res->code_blocks = D.16089;
      i = 0;
      goto <D.15377>;
      <D.15376>:
      D.16090 = res->code_blocks;
      D.16091 = (long unsigned int) i;
      D.16092 = D.16091 * 16;
      D.16093 = D.16090 + D.16092;
      p.33 = p;
      D.16094 = read_leb128 (p.33, &p);
      D.16093->type = D.16094;
      D.16090 = res->code_blocks;
      D.16091 = (long unsigned int) i;
      D.16092 = D.16091 * 16;
      D.16093 = D.16090 + D.16092;
      p.33 = p;
      D.16095 = read_leb128 (p.33, &p);
      D.16093->parent = D.16095;
      D.16090 = res->code_blocks;
      D.16091 = (long unsigned int) i;
      D.16092 = D.16091 * 16;
      D.16093 = D.16090 + D.16092;
      p.33 = p;
      D.16096 = read_leb128 (p.33, &p);
      D.16093->start_offset = D.16096;
      D.16090 = res->code_blocks;
      D.16091 = (long unsigned int) i;
      D.16092 = D.16091 * 16;
      D.16093 = D.16090 + D.16092;
      p.33 = p;
      D.16097 = read_leb128 (p.33, &p);
      D.16093->end_offset = D.16097;
      i = i + 1;
      <D.15377>:
      D.16086 = res->num_blocks;
      if (D.16086 > i) goto <D.15376>; else goto <D.15378>;
      <D.15378>:
      D.16078 = symfile->raw_contents;
      D.16098 = (sizetype) locals_offset;
      p.35 = D.16078 + D.16098;
      p = p.35;
      p.33 = p;
      num_locals = read_leb128 (p.33, &p);
      res->num_locals = num_locals;
      D.16100 = (long unsigned int) num_locals;
      D.16101 = D.16100 * 24;
      D.16102 = monoeg_malloc0 (D.16101);
      res->locals = D.16102;
      i = 0;
      goto <D.15380>;
      <D.15379>:
      D.16103 = res->locals;
      D.16091 = (long unsigned int) i;
      D.16104 = D.16091 * 24;
      D.16105 = D.16103 + D.16104;
      p.33 = p;
      D.16106 = read_leb128 (p.33, &p);
      D.16105->index = D.16106;
      p.33 = p;
      len = read_leb128 (p.33, &p);
      D.16103 = res->locals;
      D.16091 = (long unsigned int) i;
      D.16104 = D.16091 * 24;
      D.16105 = D.16103 + D.16104;
      D.16107 = len + 1;
      D.16108 = (long unsigned int) D.16107;
      D.16109 = monoeg_malloc (D.16108);
      D.16105->name = D.16109;
      D.16103 = res->locals;
      D.16091 = (long unsigned int) i;
      D.16104 = D.16091 * 24;
      D.16105 = D.16103 + D.16104;
      D.16110 = D.16105->name;
      p.33 = p;
      D.16111 = (long unsigned int) len;
      memcpy (D.16110, p.33, D.16111);
      D.16103 = res->locals;
      D.16091 = (long unsigned int) i;
      D.16104 = D.16091 * 24;
      D.16105 = D.16103 + D.16104;
      D.16110 = D.16105->name;
      D.16112 = (sizetype) len;
      D.16113 = D.16110 + D.16112;
      *D.16113 = 0;
      p.33 = p;
      D.16112 = (sizetype) len;
      p.36 = p.33 + D.16112;
      p = p.36;
      p.33 = p;
      block_index = read_leb128 (p.33, &p);
      if (block_index > 0) goto <D.16115>; else goto <D.16116>;
      <D.16115>:
      D.16086 = res->num_blocks;
      if (D.16086 >= block_index) goto <D.16117>; else goto <D.16118>;
      <D.16117>:
      D.16103 = res->locals;
      D.16091 = (long unsigned int) i;
      D.16104 = D.16091 * 24;
      D.16105 = D.16103 + D.16104;
      D.16090 = res->code_blocks;
      D.16119 = (long unsigned int) block_index;
      D.16120 = D.16119 * 16;
      D.16121 = D.16120 + 18446744073709551600;
      D.16122 = D.16090 + D.16121;
      D.16105->block = D.16122;
      <D.16118>:
      <D.16116>:
      i = i + 1;
      <D.15380>:
      if (i < num_locals) goto <D.15379>; else goto <D.15381>;
      <D.15381>:
      D.16077 = res;
      return D.16077;
    }
  finally
    {
      p = {CLOBBER};
    }
}


mono_debug_symfile_free_locals (struct MonoDebugLocalsInfo * info)
{
  struct MonoDebugLocalVar * D.16125;
  long unsigned int D.16126;
  long unsigned int D.16127;
  struct MonoDebugLocalVar * D.16128;
  char * D.16129;
  int D.16130;
  struct MonoDebugCodeBlock * D.16131;
  int i;

  i = 0;
  goto <D.15387>;
  <D.15386>:
  D.16125 = info->locals;
  D.16126 = (long unsigned int) i;
  D.16127 = D.16126 * 24;
  D.16128 = D.16125 + D.16127;
  D.16129 = D.16128->name;
  monoeg_g_free (D.16129);
  i = i + 1;
  <D.15387>:
  D.16130 = info->num_locals;
  if (D.16130 > i) goto <D.15386>; else goto <D.15388>;
  <D.15388>:
  D.16125 = info->locals;
  monoeg_g_free (D.16125);
  D.16131 = info->code_blocks;
  monoeg_g_free (D.16131);
  monoeg_g_free (info);
}


