mono_debug_open_mono_symbols (struct MonoDebugHandle * handle, const uint8_t * raw_contents, int size, gboolean in_the_debugger)
{
  long unsigned int D.15251;
  long unsigned int D.15252;
  gchar * D.15253;
  struct MonoImage * D.15255;
  const char * D.15256;
  gchar * D.15257;
  char * D.15258;
  long unsigned int D.15261;
  int D.15262;
  int D.15263;
  int * D.15268;
  int D.15269;
  const gchar * D.15270;
  void * * D.15272;
  int D.15273;
  long unsigned int D.15274;
  void * D.15275;
  int D.15276;
  struct MonoSymbolFile * D.15279;
  struct MonoSymbolFile * symfile;

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

    symfile->raw_contents_size = size;
    D.15251 = (long unsigned int) size;
    p = monoeg_malloc (D.15251);
    symfile->raw_contents = p;
    D.15252 = (long unsigned int) size;
    memcpy (p, raw_contents, D.15252);
    D.15253 = monoeg_g_strdup_printf ("LoadedFromMemory");
    symfile->filename = D.15253;
    symfile->was_loaded_from_memory = 1;
  }
  goto <D.15254>;
  <D.15250>:
  {
    struct MonoFileMap * f;

    D.15255 = handle->image;
    D.15256 = mono_image_get_filename (D.15255);
    D.15257 = monoeg_g_strdup_printf ("%s.mdb", D.15256);
    symfile->filename = D.15257;
    symfile->was_loaded_from_memory = 0;
    D.15258 = symfile->filename;
    f = mono_file_map_open (D.15258);
    if (f != 0B) goto <D.15259>; else goto <D.15260>;
    <D.15259>:
    D.15261 = mono_file_map_size (f);
    D.15262 = (int) D.15261;
    symfile->raw_contents_size = D.15262;
    D.15263 = symfile->raw_contents_size;
    if (D.15263 == 0) goto <D.15264>; else goto <D.15265>;
    <D.15264>:
    if (in_the_debugger == 0) goto <D.15266>; else goto <D.15267>;
    <D.15266>:
    D.15268 = __errno_location ();
    D.15269 = *D.15268;
    D.15270 = monoeg_g_strerror (D.15269);
    D.15258 = symfile->filename;
    monoeg_g_log (0B, 16, "stat of %s failed: %s", D.15258, D.15270);
    <D.15267>:
    goto <D.15271>;
    <D.15265>:
    D.15272 = &symfile->raw_contents_handle;
    D.15273 = mono_file_map_fd (f);
    D.15263 = symfile->raw_contents_size;
    D.15274 = (long unsigned int) D.15263;
    D.15275 = mono_file_map (D.15274, 17, D.15273, 0, D.15272);
    symfile->raw_contents = D.15275;
    <D.15271>:
    mono_file_map_close (f);
    <D.15260>:
  }
  <D.15254>:
  D.15276 = load_symfile (handle, symfile, in_the_debugger);
  if (D.15276 != 0) goto <D.15277>; else goto <D.15278>;
  <D.15277>:
  mono_debugger_unlock ();
  D.15279 = symfile;
  return D.15279;
  <D.15278>:
  if (in_the_debugger == 0) goto <D.15280>; else goto <D.15281>;
  <D.15280>:
  mono_debug_close_mono_symbol_file (symfile);
  mono_debugger_unlock ();
  D.15279 = 0B;
  return D.15279;
  <D.15281>:
  mono_debugger_unlock ();
  D.15279 = symfile;
  return D.15279;
}


memcpy (void * restrict __dest, const void * restrict __src, size_t __len)
{
  void * D.15283;
  long unsigned int D.15284;

  D.15284 = __builtin_object_size (__dest, 0);
  D.15283 = __builtin___memcpy_chk (__dest, __src, __len, D.15284);
  return D.15283;
}


load_symfile (struct MonoDebugHandle * handle, struct MonoSymbolFile * symfile, mono_bool in_the_debugger)
{
  int D.15288;
  char * D.15293;
  unsigned int D.15294;
  int D.15045;
  struct MonoImage * D.15299;
  char * D.15300;
  char * D.15305;
  struct GHashTable * D.15308;
  struct GHashTable * D.15309;
  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.15286>; else goto <D.15287>;
  <D.15286>:
  D.15288 = 0;
  return D.15288;
  <D.15287>:
  magic = MEM[(const guint64 *)ptr];
  ptr = ptr + 8;
  if (magic != 5037318119232611860) goto <D.15289>; else goto <D.15290>;
  <D.15289>:
  if (in_the_debugger == 0) goto <D.15291>; else goto <D.15292>;
  <D.15291>:
  D.15293 = symfile->filename;
  monoeg_g_log (0B, 16, "Symbol file %s is not a mono symbol file", D.15293);
  <D.15292>:
  D.15288 = 0;
  return D.15288;
  <D.15290>:
  D.15294 = MEM[(const guint32 *)ptr];
  major = (int) D.15294;
  ptr = ptr + 4;
  D.15294 = MEM[(const guint32 *)ptr];
  minor = (int) D.15294;
  ptr = ptr + 4;
  if (major != 50) goto <D.15295>; else goto <D.15296>;
  <D.15295>:
  if (in_the_debugger == 0) goto <D.15297>; else goto <D.15298>;
  <D.15297>:
  D.15293 = symfile->filename;
  monoeg_g_log (0B, 16, "Symbol file %s has incorrect version (expected %d.%d, got %d)", D.15293, 50, 0, major);
  <D.15298>:
  D.15288 = 0;
  return D.15288;
  <D.15296>:
  guid = mono_guid_to_string (ptr);
  ptr = ptr + 16;
  {
    size_t __s1_len;
    size_t __s2_len;

    D.15299 = handle->image;
    D.15300 = D.15299->guid;
    D.15045 = __builtin_strcmp (D.15300, guid);
  }
  if (D.15045 != 0) goto <D.15301>; else goto <D.15302>;
  <D.15301>:
  if (in_the_debugger == 0) goto <D.15303>; else goto <D.15304>;
  <D.15303>:
  D.15305 = handle->image_file;
  D.15293 = symfile->filename;
  monoeg_g_log (0B, 16, "Symbol file %s doesn\'t match image %s", D.15293, D.15305);
  <D.15304>:
  if (guid != 0B) goto <D.15306>; else goto <D.15307>;
  <D.15306>:
  monoeg_g_free (guid);
  <D.15307>:
  D.15288 = 0;
  return D.15288;
  <D.15302>:
  symfile->major_version = major;
  symfile->minor_version = minor;
  symfile->offset_table = ptr;
  D.15308 = monoeg_g_hash_table_new_full (0B, 0B, 0B, free_method_info);
  symfile->method_hash = D.15308;
  D.15309 = monoeg_g_hash_table_new_full (0B, 0B, 0B, free_source_info);
  symfile->source_hash = D.15309;
  monoeg_g_free (guid);
  D.15288 = 1;
  return D.15288;
}


free_source_info (struct MonoDebugSourceInfo * sinfo)
{
  char * D.15311;
  guint8 * D.15312;
  guint8 * D.15313;

  D.15311 = sinfo->source_file;
  monoeg_g_free (D.15311);
  D.15312 = sinfo->guid;
  monoeg_g_free (D.15312);
  D.15313 = sinfo->hash;
  monoeg_g_free (D.15313);
  monoeg_g_free (sinfo);
}


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


mono_debug_close_mono_symbol_file (struct MonoSymbolFile * symfile)
{
  struct GHashTable * D.15316;
  const uint8_t * D.15319;
  int D.15322;
  void * D.15326;
  char * D.15327;

  if (symfile == 0B) goto <D.15314>; else goto <D.15315>;
  <D.15314>:
  return;
  <D.15315>:
  mono_debugger_lock ();
  D.15316 = symfile->method_hash;
  if (D.15316 != 0B) goto <D.15317>; else goto <D.15318>;
  <D.15317>:
  D.15316 = symfile->method_hash;
  monoeg_g_hash_table_destroy (D.15316);
  <D.15318>:
  D.15319 = symfile->raw_contents;
  if (D.15319 != 0B) goto <D.15320>; else goto <D.15321>;
  <D.15320>:
  D.15322 = symfile->was_loaded_from_memory;
  if (D.15322 != 0) goto <D.15323>; else goto <D.15324>;
  <D.15323>:
  D.15319 = symfile->raw_contents;
  monoeg_g_free (D.15319);
  goto <D.15325>;
  <D.15324>:
  D.15326 = symfile->raw_contents_handle;
  D.15319 = symfile->raw_contents;
  mono_file_unmap (D.15319, D.15326);
  <D.15325>:
  <D.15321>:
  D.15327 = symfile->filename;
  if (D.15327 != 0B) goto <D.15328>; else goto <D.15329>;
  <D.15328>:
  D.15327 = symfile->filename;
  monoeg_g_free (D.15327);
  <D.15329>:
  monoeg_g_free (symfile);
  mono_debugger_unlock ();
}


mono_debug_symfile_is_loaded (struct MonoSymbolFile * symfile)
{
  mono_bool D.15331;
  int iftmp.0;
  struct MonoSymbolFileOffsetTable * D.15336;

  if (symfile != 0B) goto <D.15335>; else goto <D.15333>;
  <D.15335>:
  D.15336 = symfile->offset_table;
  if (D.15336 != 0B) goto <D.15337>; else goto <D.15333>;
  <D.15337>:
  iftmp.0 = 1;
  goto <D.15334>;
  <D.15333>:
  iftmp.0 = 0;
  <D.15334>:
  D.15331 = iftmp.0;
  return D.15331;
}


mono_debug_symfile_lookup_location (struct MonoDebugMethodInfo * minfo, uint32_t offset)
{
  struct MonoDebugHandle * D.15339;
  struct MonoDebugSourceLocation * D.15342;
  struct MonoSymbolFileOffsetTable * D.15343;
  uint32_t * D.15344;
  unsigned int D.15345;
  int D.15346;
  uint32_t * D.15347;
  unsigned int D.15348;
  int D.15349;
  uint32_t * D.15350;
  unsigned int D.15351;
  unsigned char D.15352;
  unsigned char D.15353;
  int D.15354;
  int D.15355;
  int D.15356;
  int D.15357;
  const uint8_t * D.15358;
  unsigned int D.15359;
  sizetype D.15360;
  const unsigned char * ptr.1;
  const unsigned char * ptr.2;
  const unsigned char * ptr.3;
  const unsigned char * ptr.4;
  const unsigned char * ptr.5;
  const unsigned char * ptr.6;
  sizetype D.15369;
  const unsigned char * ptr.7;
  const unsigned char * ptr.8;
  int D.15374;
  int D.15378;
  _Bool D.15379;
  int D.15380;
  unsigned char D.15382;
  int D.15386;
  int offset.9;
  int D.15390;
  int D.15392;
  int D.15393;
  int D.15394;
  int D.15395;
  int D.15396;
  int D.15397;
  int D.15398;
  int D.15399;
  int D.15400;
  int D.15402;
  int D.15403;
  int D.15404;
  int D.15405;
  int D.15406;
  int D.15407;
  int D.15408;
  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.15339 = minfo->handle;
      symfile = D.15339->symfile;
      if (symfile == 0B) goto <D.15340>; else goto <D.15341>;
      <D.15340>:
      D.15342 = 0B;
      return D.15342;
      <D.15341>:
      D.15343 = symfile->offset_table;
      D.15344 = &D.15343->_line_number_table_line_base;
      D.15345 = MEM[(const guint32 *)D.15344];
      D.15346 = (int) D.15345;
      stm.line_base = D.15346;
      D.15343 = symfile->offset_table;
      D.15347 = &D.15343->_line_number_table_line_range;
      D.15348 = MEM[(const guint32 *)D.15347];
      D.15349 = (int) D.15348;
      stm.line_range = D.15349;
      D.15343 = symfile->offset_table;
      D.15350 = &D.15343->_line_number_table_opcode_base;
      D.15351 = MEM[(const guint32 *)D.15350];
      D.15352 = (unsigned char) D.15351;
      stm.opcode_base = D.15352;
      D.15353 = stm.opcode_base;
      D.15354 = (int) D.15353;
      D.15355 = 255 - D.15354;
      D.15356 = stm.line_range;
      D.15357 = D.15355 / D.15356;
      stm.max_address_incr = D.15357;
      mono_debugger_lock ();
      D.15358 = symfile->raw_contents;
      D.15359 = minfo->lnt_offset;
      D.15360 = (sizetype) D.15359;
      ptr.1 = D.15358 + D.15360;
      ptr = ptr.1;
      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.15121>:
      {
        uint8_t opcode;

        ptr.2 = ptr;
        ptr.3 = ptr.2;
        ptr.4 = ptr.3 + 1;
        ptr = ptr.4;
        opcode = *ptr.3;
        if (opcode == 0) goto <D.15365>; else goto <D.15366>;
        <D.15365>:
        {
          uint8_t size;
          const unsigned char * end_ptr;

          ptr.2 = ptr;
          ptr.5 = ptr.2;
          ptr.6 = ptr.5 + 1;
          ptr = ptr.6;
          size = *ptr.5;
          ptr.2 = ptr;
          D.15369 = (sizetype) size;
          end_ptr = ptr.2 + D.15369;
          ptr.2 = ptr;
          ptr.7 = ptr.2;
          ptr.8 = ptr.7 + 1;
          ptr = ptr.8;
          opcode = *ptr.7;
          if (opcode == 1) goto <D.15372>; else goto <D.15373>;
          <D.15372>:
          D.15374 = check_line (&stm, -1, &location);
          if (D.15374 != 0) goto out_success; else goto <D.15375>;
          <D.15375>:
          goto <D.15111>;
          <D.15373>:
          if (opcode == 64) goto <D.15376>; else goto <D.15377>;
          <D.15376>:
          D.15378 = stm.is_hidden;
          D.15379 = D.15378 == 0;
          D.15380 = (int) D.15379;
          stm.is_hidden = D.15380;
          goto <D.15381>;
          <D.15377>:
          D.15382 = opcode + 192;
          if (D.15382 <= 63) goto <D.15383>; else goto <D.15384>;
          <D.15383>:
          goto <D.15385>;
          <D.15384>:
          D.15386 = (int) opcode;
          monoeg_g_log (0B, 16, "Unknown extended opcode %x in LNT", D.15386);
          <D.15385>:
          <D.15381>:
          ptr = end_ptr;
          // predicted unlikely by continue predictor.
          goto <D.15112>;
        }
        <D.15366>:
        D.15353 = stm.opcode_base;
        if (D.15353 > opcode) goto <D.15387>; else goto <D.15388>;
        <D.15387>:
        D.15386 = (int) opcode;
        switch (D.15386) <default: <D.15119>, case 1: <D.15113>, case 2: <D.15115>, case 3: <D.15116>, case 4: <D.15117>, case 8: <D.15118>>
        <D.15113>:
        offset.9 = (int) offset;
        D.15390 = check_line (&stm, offset.9, &location);
        if (D.15390 != 0) goto out_success; else goto <D.15391>;
        <D.15391>:
        goto <D.15114>;
        <D.15115>:
        ptr.2 = ptr;
        D.15392 = read_leb128 (ptr.2, &ptr);
        D.15393 = stm.offset;
        D.15394 = D.15393 + D.15392;
        stm.offset = D.15394;
        goto <D.15114>;
        <D.15116>:
        ptr.2 = ptr;
        D.15395 = read_leb128 (ptr.2, &ptr);
        D.15396 = stm.line;
        D.15397 = D.15396 + D.15395;
        stm.line = D.15397;
        goto <D.15114>;
        <D.15117>:
        ptr.2 = ptr;
        D.15398 = read_leb128 (ptr.2, &ptr);
        stm.file = D.15398;
        goto <D.15114>;
        <D.15118>:
        D.15393 = stm.offset;
        D.15399 = stm.max_address_incr;
        D.15400 = D.15393 + D.15399;
        stm.offset = D.15400;
        goto <D.15114>;
        <D.15119>:
        D.15386 = (int) opcode;
        monoeg_g_log (0B, 16, "Unknown standard opcode %x in LNT", D.15386);
        goto error_out;
        <D.15114>:
        goto <D.15401>;
        <D.15388>:
        D.15353 = stm.opcode_base;
        opcode = opcode - D.15353;
        D.15393 = stm.offset;
        D.15386 = (int) opcode;
        D.15356 = stm.line_range;
        D.15402 = D.15386 / D.15356;
        D.15403 = D.15393 + D.15402;
        stm.offset = D.15403;
        D.15396 = stm.line;
        D.15404 = stm.line_base;
        D.15386 = (int) opcode;
        D.15356 = stm.line_range;
        D.15405 = D.15386 % D.15356;
        D.15406 = D.15404 + D.15405;
        D.15407 = D.15396 + D.15406;
        stm.line = D.15407;
        offset.9 = (int) offset;
        D.15408 = check_line (&stm, offset.9, &location);
        if (D.15408 != 0) goto out_success; else goto <D.15409>;
        <D.15409>:
        <D.15401>:
      }
      <D.15112>:
      goto <D.15121>;
      <D.15111>:
      error_out:
      mono_debugger_unlock ();
      D.15342 = 0B;
      return D.15342;
      out_success:
      mono_debugger_unlock ();
      D.15342 = location;
      return D.15342;
    }
  finally
    {
      location = {CLOBBER};
      ptr = {CLOBBER};
      stm = {CLOBBER};
    }
}


read_leb128 (const uint8_t * ptr, const uint8_t * * rptr)
{
  const uint8_t * ptr.10;
  unsigned char D.15413;
  int D.15414;
  int D.15415;
  int D.15416;
  int D.15419;
  int ret;
  int shift;
  char b;

  ret = 0;
  shift = 0;
  <D.15068>:
  ptr.10 = ptr;
  ptr = ptr.10 + 1;
  D.15413 = *ptr.10;
  b = (char) D.15413;
  D.15414 = (int) b;
  D.15415 = D.15414 & 127;
  D.15416 = D.15415 << shift;
  ret = D.15416 | ret;
  shift = shift + 7;
  if (b < 0) goto <D.15068>; else goto <D.15069>;
  <D.15069>:
  if (rptr != 0B) goto <D.15417>; else goto <D.15418>;
  <D.15417>:
  *rptr = ptr;
  <D.15418>:
  D.15419 = ret;
  return D.15419;
}


check_line (struct StatementMachine * stm, int offset, struct MonoDebugSourceLocation * * location)
{
  int D.15421;
  unsigned int D.15424;
  int D.15425;
  unsigned int D.15426;
  int D.15427;
  unsigned int D.15430;
  gboolean D.15431;
  unsigned int D.15432;
  struct MonoSymbolFile * D.15435;
  struct MonoSymbolFileOffsetTable * D.15436;
  uint32_t * D.15437;
  unsigned int D.15438;
  unsigned int D.15439;
  unsigned int D.15440;
  unsigned int D.15441;
  const uint8_t * D.15442;
  sizetype D.15443;
  uint32_t * D.15444;
  unsigned int D.15445;
  sizetype D.15446;
  const uint8_t * D.15447;
  unsigned int D.15448;
  void * D.15451;
  struct MonoDebugSourceLocation * D.15452;
  unsigned int D.15453;
  gchar * source_file;

  source_file = 0B;
  D.15421 = stm->offset;
  if (D.15421 <= offset) goto <D.15422>; else goto <D.15423>;
  <D.15422>:
  D.15421 = stm->offset;
  D.15424 = (unsigned int) D.15421;
  stm->last_offset = D.15424;
  D.15425 = stm->file;
  D.15426 = (unsigned int) D.15425;
  stm->last_file = D.15426;
  D.15427 = stm->line;
  if (D.15427 != 16707566) goto <D.15428>; else goto <D.15429>;
  <D.15428>:
  D.15427 = stm->line;
  D.15430 = (unsigned int) D.15427;
  stm->last_line = D.15430;
  <D.15429>:
  D.15431 = 0;
  return D.15431;
  <D.15423>:
  D.15432 = stm->last_file;
  if (D.15432 != 0) goto <D.15433>; else goto <D.15434>;
  <D.15433>:
  {
    int offset;
    struct MonoSymbolFileSourceEntry * se;

    D.15435 = stm->symfile;
    D.15436 = D.15435->offset_table;
    D.15437 = &D.15436->_source_table_offset;
    D.15438 = MEM[(const guint32 *)D.15437];
    D.15432 = stm->last_file;
    D.15439 = D.15432 + 536870911;
    D.15440 = D.15439 * 8;
    D.15441 = D.15438 + D.15440;
    offset = (int) D.15441;
    D.15435 = stm->symfile;
    D.15442 = D.15435->raw_contents;
    D.15443 = (sizetype) offset;
    se = D.15442 + D.15443;
    D.15435 = stm->symfile;
    D.15442 = D.15435->raw_contents;
    D.15444 = &se->_data_offset;
    D.15445 = MEM[(const guint32 *)D.15444];
    D.15446 = (sizetype) D.15445;
    D.15447 = D.15442 + D.15446;
    source_file = read_string (D.15447, 0B);
  }
  <D.15434>:
  D.15448 = stm->last_line;
  if (D.15448 == 0) goto <D.15449>; else goto <D.15450>;
  <D.15449>:
  *location = 0B;
  D.15431 = 1;
  return D.15431;
  <D.15450>:
  D.15451 = monoeg_malloc0 (24);
  *location = D.15451;
  D.15452 = *location;
  D.15452->source_file = source_file;
  D.15452 = *location;
  D.15448 = stm->last_line;
  D.15452->row = D.15448;
  D.15452 = *location;
  D.15453 = stm->last_offset;
  D.15452->il_offset = D.15453;
  D.15431 = 1;
  return D.15431;
}


read_string (const uint8_t * ptr, const uint8_t * * endp)
{
  const uint8_t * ptr.11;
  long int D.15456;
  sizetype D.15457;
  const uint8_t * ptr.12;
  gchar * D.15461;
  gchar * s;
  int len;

  ptr.11 = ptr;
  len = read_leb128 (ptr.11, &ptr);
  D.15456 = (long int) len;
  ptr.11 = ptr;
  s = monoeg_g_filename_from_utf8 (ptr.11, D.15456, 0B, 0B, 0B);
  ptr.11 = ptr;
  D.15457 = (sizetype) len;
  ptr.12 = ptr.11 + D.15457;
  ptr = ptr.12;
  if (endp != 0B) goto <D.15459>; else goto <D.15460>;
  <D.15459>:
  ptr.11 = ptr;
  *endp = ptr.11;
  <D.15460>:
  D.15461 = s;
  return D.15461;
}


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

  D.15463 = location->source_file;
  monoeg_g_free (D.15463);
  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.15474;
  struct MonoSymbolFileOffsetTable * D.15477;
  uint32_t * D.15478;
  unsigned int D.15479;
  int D.15480;
  uint32_t * D.15481;
  unsigned int D.15482;
  int D.15483;
  uint32_t * D.15484;
  unsigned int D.15485;
  unsigned char D.15486;
  unsigned char D.15487;
  int D.15488;
  int D.15489;
  int D.15490;
  int D.15491;
  const uint8_t * D.15492;
  unsigned int D.15493;
  sizetype D.15494;
  const unsigned char * ptr.13;
  const unsigned char * ptr.14;
  const unsigned char * ptr.15;
  const unsigned char * ptr.16;
  const unsigned char * ptr.17;
  const unsigned char * ptr.18;
  sizetype D.15503;
  const unsigned char * ptr.19;
  const unsigned char * ptr.20;
  unsigned int D.15508;
  int D.15512;
  _Bool D.15513;
  int D.15514;
  unsigned char D.15516;
  int D.15520;
  int D.15523;
  int D.15524;
  int D.15525;
  int D.15526;
  int D.15527;
  int D.15528;
  int D.15529;
  int D.15530;
  int D.15531;
  int D.15533;
  int D.15534;
  int D.15535;
  int D.15536;
  int D.15537;
  int D.15538;
  int D.15539;
  unsigned int D.15542;
  int D.15545;
  struct MonoSymbolFile * D.15550;
  struct MonoSymbolFileOffsetTable * D.15551;
  uint32_t * D.15552;
  unsigned int D.15553;
  int D.15554;
  long unsigned int D.15555;
  unsigned int D.15556;
  unsigned int D.15557;
  unsigned int D.15558;
  const uint8_t * D.15559;
  sizetype D.15560;
  uint32_t * D.15563;
  unsigned int D.15564;
  sizetype D.15565;
  const uint8_t * D.15566;
  gchar * D.15567;
  struct GPtrArray * D.15570;
  long unsigned int D.15573;
  long unsigned int D.15574;
  void * D.15575;
  void * * D.15576;
  long unsigned int D.15577;
  long unsigned int D.15578;
  void * * D.15579;
  void * D.15580;
  long int D.15581;
  _Bool D.15582;
  _Bool D.15583;
  _Bool D.15584;
  struct GPtrArray * D.15587;
  int * D.15590;
  long unsigned int D.15591;
  int * D.15592;
  unsigned int D.15593;
  unsigned int D.15594;
  int D.15595;
  int D.15602;
  _Bool D.15603;
  _Bool D.15604;
  _Bool D.15605;
  void * D.15608;
  void * D.15609;
  int * D.15610;
  int * D.15611;
  void * * D.15612;
  void * * D.15613;
  void * D.15614;
  long int D.15615;
  int D.15616;
  int * D.15617;
  int * D.15618;
  void * * D.15619;
  void * * D.15620;
  void * D.15621;
  long int D.15622;
  int D.15623;
  _Bool D.15624;
  _Bool D.15625;
  _Bool D.15626;
  void * D.15629;
  int * D.15630;
  int * D.15631;
  int D.15632;
  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.15464>; else goto <D.15465>;
      <D.15464>:
      *source_file_list = 0B;
      <D.15465>:
      if (n_il_offsets != 0B) goto <D.15466>; else goto <D.15467>;
      <D.15466>:
      *n_il_offsets = 0;
      <D.15467>:
      if (source_files != 0B) goto <D.15468>; else goto <D.15469>;
      <D.15468>:
      *source_files = 0B;
      <D.15469>:
      if (source_file != 0B) goto <D.15470>; else goto <D.15471>;
      <D.15470>:
      *source_file = 0B;
      <D.15471>:
      if (column_numbers != 0B) goto <D.15472>; else goto <D.15473>;
      <D.15472>:
      *column_numbers = 0B;
      <D.15473>:
      D.15474 = minfo->handle;
      symfile = D.15474->symfile;
      if (symfile == 0B) goto <D.15475>; else goto <D.15476>;
      <D.15475>:
      return;
      <D.15476>:
      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.15477 = symfile->offset_table;
      D.15478 = &D.15477->_line_number_table_line_base;
      D.15479 = MEM[(const guint32 *)D.15478];
      D.15480 = (int) D.15479;
      stm.line_base = D.15480;
      D.15477 = symfile->offset_table;
      D.15481 = &D.15477->_line_number_table_line_range;
      D.15482 = MEM[(const guint32 *)D.15481];
      D.15483 = (int) D.15482;
      stm.line_range = D.15483;
      D.15477 = symfile->offset_table;
      D.15484 = &D.15477->_line_number_table_opcode_base;
      D.15485 = MEM[(const guint32 *)D.15484];
      D.15486 = (unsigned char) D.15485;
      stm.opcode_base = D.15486;
      D.15487 = stm.opcode_base;
      D.15488 = (int) D.15487;
      D.15489 = 255 - D.15488;
      D.15490 = stm.line_range;
      D.15491 = D.15489 / D.15490;
      stm.max_address_incr = D.15491;
      mono_debugger_lock ();
      D.15492 = symfile->raw_contents;
      D.15493 = minfo->lnt_offset;
      D.15494 = (sizetype) D.15493;
      ptr.13 = D.15492 + D.15494;
      ptr = ptr.13;
      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.15175>:
      {
        uint8_t opcode;

        ptr.14 = ptr;
        ptr.15 = ptr.14;
        ptr.16 = ptr.15 + 1;
        ptr = ptr.16;
        opcode = *ptr.15;
        if (opcode == 0) goto <D.15499>; else goto <D.15500>;
        <D.15499>:
        {
          uint8_t size;
          const unsigned char * end_ptr;

          ptr.14 = ptr;
          ptr.17 = ptr.14;
          ptr.18 = ptr.17 + 1;
          ptr = ptr.18;
          size = *ptr.17;
          ptr.14 = ptr;
          D.15503 = (sizetype) size;
          end_ptr = ptr.14 + D.15503;
          ptr.14 = ptr;
          ptr.19 = ptr.14;
          ptr.20 = ptr.19 + 1;
          ptr = ptr.20;
          opcode = *ptr.19;
          if (opcode == 1) goto <D.15506>; else goto <D.15507>;
          <D.15506>:
          D.15508 = il_offset_array->len;
          if (D.15508 == 0) goto <D.15166>; else goto <D.15509>;
          <D.15509>:
          add_line (&stm, il_offset_array, line_number_array, source_file_array);
          goto <D.15166>;
          <D.15507>:
          if (opcode == 64) goto <D.15510>; else goto <D.15511>;
          <D.15510>:
          D.15512 = stm.is_hidden;
          D.15513 = D.15512 == 0;
          D.15514 = (int) D.15513;
          stm.is_hidden = D.15514;
          goto <D.15515>;
          <D.15511>:
          D.15516 = opcode + 192;
          if (D.15516 <= 63) goto <D.15517>; else goto <D.15518>;
          <D.15517>:
          goto <D.15519>;
          <D.15518>:
          D.15520 = (int) opcode;
          monoeg_g_log (0B, 16, "Unknown extended opcode %x in LNT", D.15520);
          <D.15519>:
          <D.15515>:
          ptr = end_ptr;
          // predicted unlikely by continue predictor.
          goto <D.15167>;
        }
        <D.15500>:
        D.15487 = stm.opcode_base;
        if (D.15487 > opcode) goto <D.15521>; else goto <D.15522>;
        <D.15521>:
        D.15520 = (int) opcode;
        switch (D.15520) <default: <D.15174>, case 1: <D.15168>, case 2: <D.15170>, case 3: <D.15171>, case 4: <D.15172>, case 8: <D.15173>>
        <D.15168>:
        add_line (&stm, il_offset_array, line_number_array, source_file_array);
        goto <D.15169>;
        <D.15170>:
        ptr.14 = ptr;
        D.15523 = read_leb128 (ptr.14, &ptr);
        D.15524 = stm.offset;
        D.15525 = D.15524 + D.15523;
        stm.offset = D.15525;
        goto <D.15169>;
        <D.15171>:
        ptr.14 = ptr;
        D.15526 = read_leb128 (ptr.14, &ptr);
        D.15527 = stm.line;
        D.15528 = D.15527 + D.15526;
        stm.line = D.15528;
        goto <D.15169>;
        <D.15172>:
        ptr.14 = ptr;
        D.15529 = read_leb128 (ptr.14, &ptr);
        stm.file = D.15529;
        goto <D.15169>;
        <D.15173>:
        D.15524 = stm.offset;
        D.15530 = stm.max_address_incr;
        D.15531 = D.15524 + D.15530;
        stm.offset = D.15531;
        goto <D.15169>;
        <D.15174>:
        D.15520 = (int) opcode;
        monoeg_g_log (0B, 16, "Unknown standard opcode %x in LNT", D.15520);
        monoeg_assertion_message ("* Assertion: should not be reached at %s:%d\n", "debug-mono-symfile.c", 599);
        <D.15169>:
        goto <D.15532>;
        <D.15522>:
        D.15487 = stm.opcode_base;
        opcode = opcode - D.15487;
        D.15524 = stm.offset;
        D.15520 = (int) opcode;
        D.15490 = stm.line_range;
        D.15533 = D.15520 / D.15490;
        D.15534 = D.15524 + D.15533;
        stm.offset = D.15534;
        D.15527 = stm.line;
        D.15535 = stm.line_base;
        D.15520 = (int) opcode;
        D.15490 = stm.line_range;
        D.15536 = D.15520 % D.15490;
        D.15537 = D.15535 + D.15536;
        D.15538 = D.15527 + D.15537;
        stm.line = D.15538;
        add_line (&stm, il_offset_array, line_number_array, source_file_array);
        <D.15532>:
      }
      <D.15167>:
      goto <D.15175>;
      <D.15166>:
      D.15539 = stm.file;
      if (D.15539 == 0) goto <D.15540>; else goto <D.15541>;
      <D.15540>:
      D.15542 = stm.first_file;
      if (D.15542 != 0) goto <D.15543>; else goto <D.15544>;
      <D.15543>:
      D.15542 = stm.first_file;
      D.15545 = (int) D.15542;
      stm.file = D.15545;
      <D.15544>:
      <D.15541>:
      D.15539 = stm.file;
      if (D.15539 != 0) goto <D.15546>; else goto <D.15547>;
      <D.15546>:
      if (source_file != 0B) goto <D.15548>; else goto <D.15549>;
      <D.15548>:
      {
        int offset;
        struct MonoSymbolFileSourceEntry * se;

        D.15550 = stm.symfile;
        D.15551 = D.15550->offset_table;
        D.15552 = &D.15551->_source_table_offset;
        D.15553 = MEM[(const guint32 *)D.15552];
        D.15539 = stm.file;
        D.15554 = D.15539 + -1;
        D.15555 = (long unsigned int) D.15554;
        D.15556 = (unsigned int) D.15555;
        D.15557 = D.15556 * 8;
        D.15558 = D.15553 + D.15557;
        offset = (int) D.15558;
        D.15550 = stm.symfile;
        D.15559 = D.15550->raw_contents;
        D.15560 = (sizetype) offset;
        se = D.15559 + D.15560;
        if (source_file != 0B) goto <D.15561>; else goto <D.15562>;
        <D.15561>:
        D.15550 = stm.symfile;
        D.15559 = D.15550->raw_contents;
        D.15563 = &se->_data_offset;
        D.15564 = MEM[(const guint32 *)D.15563];
        D.15565 = (sizetype) D.15564;
        D.15566 = D.15559 + D.15565;
        D.15567 = read_string (D.15566, 0B);
        *source_file = D.15567;
        <D.15562>:
      }
      <D.15549>:
      <D.15547>:
      if (source_file_list != 0B) goto <D.15568>; else goto <D.15569>;
      <D.15568>:
      {
        int file;
        int last_file;

        last_file = 0;
        D.15570 = monoeg_g_ptr_array_new ();
        *source_file_list = D.15570;
        if (source_files != 0B) goto <D.15571>; else goto <D.15572>;
        <D.15571>:
        D.15508 = il_offset_array->len;
        D.15573 = (long unsigned int) D.15508;
        D.15574 = D.15573 * 4;
        D.15575 = monoeg_malloc (D.15574);
        *source_files = D.15575;
        <D.15572>:
        i = 0;
        goto <D.15182>;
        <D.15181>:
        D.15576 = source_file_array->pdata;
        D.15577 = (long unsigned int) i;
        D.15578 = D.15577 * 8;
        D.15579 = D.15576 + D.15578;
        D.15580 = *D.15579;
        D.15581 = (long int) D.15580;
        file = (int) D.15581;
        D.15582 = file != 0;
        D.15583 = file != last_file;
        D.15584 = D.15582 & D.15583;
        if (D.15584 != 0) goto <D.15585>; else goto <D.15586>;
        <D.15585>:
        {
          struct MonoDebugSourceInfo * info;

          info = get_source_info (symfile, file);
          D.15587 = *source_file_list;
          monoeg_g_ptr_array_add (D.15587, info);
        }
        <D.15586>:
        last_file = file;
        if (source_files != 0B) goto <D.15588>; else goto <D.15589>;
        <D.15588>:
        D.15590 = *source_files;
        D.15577 = (long unsigned int) i;
        D.15591 = D.15577 * 4;
        D.15592 = D.15590 + D.15591;
        D.15587 = *source_file_list;
        D.15593 = D.15587->len;
        D.15594 = D.15593 + 4294967295;
        D.15595 = (int) D.15594;
        *D.15592 = D.15595;
        <D.15589>:
        i = i + 1;
        <D.15182>:
        D.15508 = il_offset_array->len;
        if (D.15508 > i) goto <D.15181>; else goto <D.15183>;
        <D.15183>:
        D.15587 = *source_file_list;
        D.15593 = D.15587->len;
        if (D.15593 == 0) goto <D.15596>; else goto <D.15597>;
        <D.15596>:
        D.15539 = stm.file;
        if (D.15539 != 0) goto <D.15598>; else goto <D.15599>;
        <D.15598>:
        {
          struct MonoDebugSourceInfo * info;

          D.15539 = stm.file;
          info = get_source_info (symfile, D.15539);
          D.15587 = *source_file_list;
          monoeg_g_ptr_array_add (D.15587, info);
        }
        <D.15599>:
        <D.15597>:
      }
      <D.15569>:
      if (n_il_offsets != 0B) goto <D.15600>; else goto <D.15601>;
      <D.15600>:
      D.15508 = il_offset_array->len;
      D.15602 = (int) D.15508;
      *n_il_offsets = D.15602;
      <D.15601>:
      D.15603 = il_offsets != 0B;
      D.15604 = line_numbers != 0B;
      D.15605 = D.15603 & D.15604;
      if (D.15605 != 0) goto <D.15606>; else goto <D.15607>;
      <D.15606>:
      D.15508 = il_offset_array->len;
      D.15573 = (long unsigned int) D.15508;
      D.15574 = D.15573 * 4;
      D.15608 = monoeg_malloc (D.15574);
      *il_offsets = D.15608;
      D.15508 = il_offset_array->len;
      D.15573 = (long unsigned int) D.15508;
      D.15574 = D.15573 * 4;
      D.15609 = monoeg_malloc (D.15574);
      *line_numbers = D.15609;
      i = 0;
      goto <D.15186>;
      <D.15185>:
      D.15610 = *il_offsets;
      D.15577 = (long unsigned int) i;
      D.15591 = D.15577 * 4;
      D.15611 = D.15610 + D.15591;
      D.15612 = il_offset_array->pdata;
      D.15577 = (long unsigned int) i;
      D.15578 = D.15577 * 8;
      D.15613 = D.15612 + D.15578;
      D.15614 = *D.15613;
      D.15615 = (long int) D.15614;
      D.15616 = (int) D.15615;
      *D.15611 = D.15616;
      D.15617 = *line_numbers;
      D.15577 = (long unsigned int) i;
      D.15591 = D.15577 * 4;
      D.15618 = D.15617 + D.15591;
      D.15619 = line_number_array->pdata;
      D.15577 = (long unsigned int) i;
      D.15578 = D.15577 * 8;
      D.15620 = D.15619 + D.15578;
      D.15621 = *D.15620;
      D.15622 = (long int) D.15621;
      D.15623 = (int) D.15622;
      *D.15618 = D.15623;
      i = i + 1;
      <D.15186>:
      D.15508 = il_offset_array->len;
      if (D.15508 > i) goto <D.15185>; else goto <D.15187>;
      <D.15187>:
      <D.15607>:
      D.15624 = column_numbers != 0B;
      D.15625 = has_column_info != 0;
      D.15626 = D.15624 & D.15625;
      if (D.15626 != 0) goto <D.15627>; else goto <D.15628>;
      <D.15627>:
      D.15508 = il_offset_array->len;
      D.15573 = (long unsigned int) D.15508;
      D.15574 = D.15573 * 4;
      D.15629 = monoeg_malloc (D.15574);
      *column_numbers = D.15629;
      i = 0;
      goto <D.15189>;
      <D.15188>:
      D.15630 = *column_numbers;
      D.15577 = (long unsigned int) i;
      D.15591 = D.15577 * 4;
      D.15631 = D.15630 + D.15591;
      ptr.14 = ptr;
      D.15632 = read_leb128 (ptr.14, &ptr);
      *D.15631 = D.15632;
      i = i + 1;
      <D.15189>:
      D.15508 = il_offset_array->len;
      if (D.15508 > i) goto <D.15188>; else goto <D.15190>;
      <D.15190>:
      <D.15628>:
      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.15635;
  gboolean D.15638;
  const uint8_t * D.15639;
  unsigned int D.15640;
  sizetype D.15641;
  const unsigned char * ptr.21;
  const unsigned char * ptr.22;
  int D.15644;
  unsigned int D.15645;
  _Bool D.15646;
  struct MonoSymbolFile * symfile;
  const unsigned char * ptr;
  guint32 flags;

  try
    {
      D.15635 = minfo->handle;
      symfile = D.15635->symfile;
      if (symfile == 0B) goto <D.15636>; else goto <D.15637>;
      <D.15636>:
      D.15638 = 0;
      return D.15638;
      <D.15637>:
      D.15639 = symfile->raw_contents;
      D.15640 = minfo->data_offset;
      D.15641 = (sizetype) D.15640;
      ptr.21 = D.15639 + D.15641;
      ptr = ptr.21;
      ptr.22 = ptr;
      read_leb128 (ptr.22, &ptr);
      ptr.22 = ptr;
      read_leb128 (ptr.22, &ptr);
      ptr.22 = ptr;
      read_leb128 (ptr.22, &ptr);
      ptr.22 = ptr;
      read_leb128 (ptr.22, &ptr);
      ptr.22 = ptr;
      read_leb128 (ptr.22, &ptr);
      ptr.22 = ptr;
      read_leb128 (ptr.22, &ptr);
      ptr.22 = ptr;
      D.15644 = read_leb128 (ptr.22, &ptr);
      flags = (guint32) D.15644;
      D.15645 = flags & 2;
      D.15646 = D.15645 != 0;
      D.15638 = (gboolean) D.15646;
      return D.15638;
    }
  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.15649;
  int D.15652;
  long unsigned int D.15653;
  void * D.15654;
  long unsigned int D.15655;
  void * D.15656;
  int D.15657;
  long unsigned int D.15658;
  void * D.15659;
  int D.15660;
  unsigned int D.15663;
  unsigned int D.15666;

  D.15649 = stm->line;
  if (D.15649 > 0) goto <D.15650>; else goto <D.15651>;
  <D.15650>:
  D.15652 = stm->offset;
  D.15653 = (long unsigned int) D.15652;
  D.15654 = (void *) D.15653;
  monoeg_g_ptr_array_add (il_offset_array, D.15654);
  D.15649 = stm->line;
  D.15655 = (long unsigned int) D.15649;
  D.15656 = (void *) D.15655;
  monoeg_g_ptr_array_add (line_number_array, D.15656);
  D.15657 = stm->file;
  D.15658 = (long unsigned int) D.15657;
  D.15659 = (void *) D.15658;
  monoeg_g_ptr_array_add (source_file_array, D.15659);
  <D.15651>:
  D.15660 = stm->is_hidden;
  if (D.15660 == 0) goto <D.15661>; else goto <D.15662>;
  <D.15661>:
  D.15663 = stm->first_file;
  if (D.15663 == 0) goto <D.15664>; else goto <D.15665>;
  <D.15664>:
  D.15657 = stm->file;
  D.15666 = (unsigned int) D.15657;
  stm->first_file = D.15666;
  <D.15665>:
  <D.15662>:
}


get_source_info (struct MonoSymbolFile * symfile, int index)
{
  long unsigned int D.15667;
  const void * D.15668;
  struct GHashTable * D.15669;
  struct MonoSymbolFileOffsetTable * D.15672;
  uint32_t * D.15673;
  unsigned int D.15674;
  int D.15675;
  long unsigned int D.15676;
  unsigned int D.15677;
  unsigned int D.15678;
  unsigned int D.15679;
  const uint8_t * D.15680;
  sizetype D.15681;
  uint32_t * D.15682;
  unsigned int D.15683;
  sizetype D.15684;
  const uint8_t * ptr.23;
  const uint8_t * ptr.24;
  gchar * D.15687;
  void * D.15688;
  guint8 * D.15689;
  const uint8_t * ptr.25;
  void * D.15691;
  guint8 * D.15692;
  void * D.15693;
  struct MonoDebugSourceInfo * D.15694;
  struct MonoDebugSourceInfo * info;

  D.15667 = (long unsigned int) index;
  D.15668 = (const void *) D.15667;
  D.15669 = symfile->source_hash;
  info = monoeg_g_hash_table_lookup (D.15669, D.15668);
  if (info == 0B) goto <D.15670>; else goto <D.15671>;
  <D.15670>:
  {
    int offset;
    struct MonoSymbolFileSourceEntry * se;
    const uint8_t * ptr;

    try
      {
        D.15672 = symfile->offset_table;
        D.15673 = &D.15672->_source_table_offset;
        D.15674 = MEM[(const guint32 *)D.15673];
        D.15675 = index + -1;
        D.15676 = (long unsigned int) D.15675;
        D.15677 = (unsigned int) D.15676;
        D.15678 = D.15677 * 8;
        D.15679 = D.15674 + D.15678;
        offset = (int) D.15679;
        D.15680 = symfile->raw_contents;
        D.15681 = (sizetype) offset;
        se = D.15680 + D.15681;
        D.15680 = symfile->raw_contents;
        D.15682 = &se->_data_offset;
        D.15683 = MEM[(const guint32 *)D.15682];
        D.15684 = (sizetype) D.15683;
        ptr.23 = D.15680 + D.15684;
        ptr = ptr.23;
        info = monoeg_malloc0 (24);
        ptr.24 = ptr;
        D.15687 = read_string (ptr.24, &ptr);
        info->source_file = D.15687;
        D.15688 = monoeg_malloc0 (16);
        info->guid = D.15688;
        ptr.24 = ptr;
        D.15689 = info->guid;
        memcpy (D.15689, ptr.24, 16);
        ptr.24 = ptr;
        ptr.25 = ptr.24 + 16;
        ptr = ptr.25;
        D.15691 = monoeg_malloc0 (16);
        info->hash = D.15691;
        ptr.24 = ptr;
        D.15692 = info->hash;
        memcpy (D.15692, ptr.24, 16);
        ptr.24 = ptr;
        ptr.25 = ptr.24 + 16;
        ptr = ptr.25;
        D.15667 = (long unsigned int) index;
        D.15693 = (void *) D.15667;
        D.15669 = symfile->source_hash;
        monoeg_g_hash_table_insert_replace (D.15669, D.15693, info, 0);
      }
    finally
      {
        ptr = {CLOBBER};
      }
  }
  <D.15671>:
  D.15694 = info;
  return D.15694;
}


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.15699;
  int32_t D.15700;
  unsigned int D.15701;
  unsigned int D.15702;
  long unsigned int D.15703;
  long unsigned int D.15704;
  struct MonoDebugLineNumberEntry * D.15705;
  unsigned int D.15706;
  unsigned int D.15709;
  int i;

  if (jit == 0B) goto <D.15696>; else goto <D.15698>;
  <D.15698>:
  D.15699 = jit->line_numbers;
  if (D.15699 == 0B) goto <D.15696>; else goto <D.15697>;
  <D.15696>:
  D.15700 = -1;
  return D.15700;
  <D.15697>:
  D.15701 = jit->num_line_numbers;
  D.15702 = D.15701 + 4294967295;
  i = (int) D.15702;
  goto <D.15205>;
  <D.15204>:
  {
    struct MonoDebugLineNumberEntry lne;

    try
      {
        D.15699 = jit->line_numbers;
        D.15703 = (long unsigned int) i;
        D.15704 = D.15703 * 8;
        D.15705 = D.15699 + D.15704;
        lne = *D.15705;
        D.15706 = lne.il_offset;
        if (D.15706 <= il_offset) goto <D.15707>; else goto <D.15708>;
        <D.15707>:
        D.15709 = lne.native_offset;
        D.15700 = (int32_t) D.15709;
        return D.15700;
        <D.15708>:
      }
    finally
      {
        lne = {CLOBBER};
      }
  }
  i = i + -1;
  <D.15205>:
  if (i >= 0) goto <D.15204>; else goto <D.15206>;
  <D.15206>:
  D.15700 = 0;
  return D.15700;
}


mono_debug_symfile_lookup_method (struct MonoDebugHandle * handle, struct MonoMethod * method)
{
  struct GHashTable * D.15713;
  struct MonoDebugMethodInfo * D.15716;
  struct MonoImage * D.15717;
  struct MonoClass * D.15718;
  struct MonoImage * D.15719;
  const uint8_t * D.15724;
  struct MonoSymbolFileOffsetTable * D.15725;
  uint32_t * D.15726;
  unsigned int D.15727;
  sizetype D.15728;
  uint32_t * D.15729;
  unsigned int D.15730;
  long unsigned int D.15731;
  unsigned int D.15732;
  long unsigned int D.15733;
  const void * D.15734;
  long int ie.26;
  long int first_ie.27;
  long int D.15739;
  long int D.15740;
  unsigned int D.15741;
  unsigned int D.15742;
  unsigned int D.15743;
  unsigned int D.15744;
  struct MonoSymbolFileMethodEntry * first_ie;
  struct MonoSymbolFileMethodEntry * ie;
  struct MonoDebugMethodInfo * minfo;
  struct MonoSymbolFile * symfile;

  symfile = handle->symfile;
  D.15713 = symfile->method_hash;
  if (D.15713 == 0B) goto <D.15714>; else goto <D.15715>;
  <D.15714>:
  D.15716 = 0B;
  return D.15716;
  <D.15715>:
  D.15717 = handle->image;
  D.15718 = mono_method_get_class (method);
  D.15719 = mono_class_get_image (D.15718);
  if (D.15717 != D.15719) goto <D.15720>; else goto <D.15721>;
  <D.15720>:
  D.15716 = 0B;
  return D.15716;
  <D.15721>:
  mono_debugger_lock ();
  D.15713 = symfile->method_hash;
  minfo = monoeg_g_hash_table_lookup (D.15713, method);
  if (minfo != 0B) goto <D.15722>; else goto <D.15723>;
  <D.15722>:
  mono_debugger_unlock ();
  D.15716 = minfo;
  return D.15716;
  <D.15723>:
  D.15724 = symfile->raw_contents;
  D.15725 = symfile->offset_table;
  D.15726 = &D.15725->_method_table_offset;
  D.15727 = MEM[(const guint32 *)D.15726];
  D.15728 = (sizetype) D.15727;
  first_ie = D.15724 + D.15728;
  D.15725 = symfile->offset_table;
  D.15729 = &D.15725->_method_count;
  D.15730 = MEM[(const guint32 *)D.15729];
  D.15731 = (long unsigned int) D.15730;
  D.15732 = mono_method_get_token (method);
  D.15733 = (long unsigned int) D.15732;
  D.15734 = (const void *) D.15733;
  ie = mono_binary_search (D.15734, first_ie, D.15731, 12, compare_method);
  if (ie == 0B) goto <D.15735>; else goto <D.15736>;
  <D.15735>:
  mono_debugger_unlock ();
  D.15716 = 0B;
  return D.15716;
  <D.15736>:
  minfo = monoeg_malloc0 (32);
  ie.26 = (long int) ie;
  first_ie.27 = (long int) first_ie;
  D.15739 = ie.26 - first_ie.27;
  D.15740 = D.15739 /[ex] 12;
  D.15741 = (unsigned int) D.15740;
  D.15742 = D.15741 + 1;
  minfo->index = D.15742;
  minfo->method = method;
  minfo->handle = handle;
  D.15743 = ie->_data_offset;
  minfo->data_offset = D.15743;
  D.15744 = ie->_line_number_table;
  minfo->lnt_offset = D.15744;
  D.15713 = symfile->method_hash;
  monoeg_g_hash_table_insert_replace (D.15713, method, minfo, 0);
  mono_debugger_unlock ();
  D.15716 = minfo;
  return D.15716;
}


compare_method (const void * key, const void * object)
{
  long int key.28;
  int D.15747;
  uint32_t * D.15748;
  unsigned int D.15749;
  unsigned int D.15750;
  uint32_t token;
  struct MonoSymbolFileMethodEntry * me;

  key.28 = (long int) key;
  token = (uint32_t) key.28;
  me = object;
  D.15748 = &me->_token;
  D.15749 = MEM[(const guint32 *)D.15748];
  D.15750 = token - D.15749;
  D.15747 = (int) D.15750;
  return D.15747;
}


mono_debug_symfile_lookup_locals (struct MonoDebugMethodInfo * minfo)
{
  struct MonoDebugHandle * D.15752;
  struct MonoDebugLocalsInfo * D.15755;
  const uint8_t * D.15756;
  unsigned int D.15757;
  sizetype D.15758;
  const uint8_t * p.29;
  const uint8_t * p.30;
  sizetype D.15761;
  const uint8_t * p.31;
  int D.15763;
  int D.15764;
  long unsigned int D.15765;
  long unsigned int D.15766;
  void * D.15767;
  struct MonoDebugCodeBlock * D.15768;
  long unsigned int D.15769;
  long unsigned int D.15770;
  struct MonoDebugCodeBlock * D.15771;
  int D.15772;
  int D.15773;
  int D.15774;
  int D.15775;
  sizetype D.15776;
  const uint8_t * p.32;
  long unsigned int D.15778;
  long unsigned int D.15779;
  void * D.15780;
  struct MonoDebugLocalVar * D.15781;
  long unsigned int D.15782;
  struct MonoDebugLocalVar * D.15783;
  int D.15784;
  int D.15785;
  long unsigned int D.15786;
  void * D.15787;
  long unsigned int D.15788;
  char * D.15789;
  sizetype D.15790;
  char * D.15791;
  const uint8_t * p.33;
  long unsigned int D.15797;
  long unsigned int D.15798;
  sizetype D.15799;
  struct MonoDebugCodeBlock * D.15800;
  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.15752 = minfo->handle;
      symfile = D.15752->symfile;
      if (symfile == 0B) goto <D.15753>; else goto <D.15754>;
      <D.15753>:
      D.15755 = 0B;
      return D.15755;
      <D.15754>:
      D.15756 = symfile->raw_contents;
      D.15757 = minfo->data_offset;
      D.15758 = (sizetype) D.15757;
      p.29 = D.15756 + D.15758;
      p = p.29;
      p.30 = p;
      compile_unit_index = read_leb128 (p.30, &p);
      p.30 = p;
      locals_offset = read_leb128 (p.30, &p);
      p.30 = p;
      namespace_id = read_leb128 (p.30, &p);
      p.30 = p;
      code_block_table_offset = read_leb128 (p.30, &p);
      res = monoeg_malloc0 (32);
      D.15756 = symfile->raw_contents;
      D.15761 = (sizetype) code_block_table_offset;
      p.31 = D.15756 + D.15761;
      p = p.31;
      p.30 = p;
      D.15763 = read_leb128 (p.30, &p);
      res->num_blocks = D.15763;
      D.15764 = res->num_blocks;
      D.15765 = (long unsigned int) D.15764;
      D.15766 = D.15765 * 16;
      D.15767 = monoeg_malloc0 (D.15766);
      res->code_blocks = D.15767;
      i = 0;
      goto <D.15236>;
      <D.15235>:
      D.15768 = res->code_blocks;
      D.15769 = (long unsigned int) i;
      D.15770 = D.15769 * 16;
      D.15771 = D.15768 + D.15770;
      p.30 = p;
      D.15772 = read_leb128 (p.30, &p);
      D.15771->type = D.15772;
      D.15768 = res->code_blocks;
      D.15769 = (long unsigned int) i;
      D.15770 = D.15769 * 16;
      D.15771 = D.15768 + D.15770;
      p.30 = p;
      D.15773 = read_leb128 (p.30, &p);
      D.15771->parent = D.15773;
      D.15768 = res->code_blocks;
      D.15769 = (long unsigned int) i;
      D.15770 = D.15769 * 16;
      D.15771 = D.15768 + D.15770;
      p.30 = p;
      D.15774 = read_leb128 (p.30, &p);
      D.15771->start_offset = D.15774;
      D.15768 = res->code_blocks;
      D.15769 = (long unsigned int) i;
      D.15770 = D.15769 * 16;
      D.15771 = D.15768 + D.15770;
      p.30 = p;
      D.15775 = read_leb128 (p.30, &p);
      D.15771->end_offset = D.15775;
      i = i + 1;
      <D.15236>:
      D.15764 = res->num_blocks;
      if (D.15764 > i) goto <D.15235>; else goto <D.15237>;
      <D.15237>:
      D.15756 = symfile->raw_contents;
      D.15776 = (sizetype) locals_offset;
      p.32 = D.15756 + D.15776;
      p = p.32;
      p.30 = p;
      num_locals = read_leb128 (p.30, &p);
      res->num_locals = num_locals;
      D.15778 = (long unsigned int) num_locals;
      D.15779 = D.15778 * 24;
      D.15780 = monoeg_malloc0 (D.15779);
      res->locals = D.15780;
      i = 0;
      goto <D.15239>;
      <D.15238>:
      D.15781 = res->locals;
      D.15769 = (long unsigned int) i;
      D.15782 = D.15769 * 24;
      D.15783 = D.15781 + D.15782;
      p.30 = p;
      D.15784 = read_leb128 (p.30, &p);
      D.15783->index = D.15784;
      p.30 = p;
      len = read_leb128 (p.30, &p);
      D.15781 = res->locals;
      D.15769 = (long unsigned int) i;
      D.15782 = D.15769 * 24;
      D.15783 = D.15781 + D.15782;
      D.15785 = len + 1;
      D.15786 = (long unsigned int) D.15785;
      D.15787 = monoeg_malloc (D.15786);
      D.15783->name = D.15787;
      D.15788 = (long unsigned int) len;
      p.30 = p;
      D.15781 = res->locals;
      D.15769 = (long unsigned int) i;
      D.15782 = D.15769 * 24;
      D.15783 = D.15781 + D.15782;
      D.15789 = D.15783->name;
      memcpy (D.15789, p.30, D.15788);
      D.15781 = res->locals;
      D.15769 = (long unsigned int) i;
      D.15782 = D.15769 * 24;
      D.15783 = D.15781 + D.15782;
      D.15789 = D.15783->name;
      D.15790 = (sizetype) len;
      D.15791 = D.15789 + D.15790;
      *D.15791 = 0;
      p.30 = p;
      D.15790 = (sizetype) len;
      p.33 = p.30 + D.15790;
      p = p.33;
      p.30 = p;
      block_index = read_leb128 (p.30, &p);
      if (block_index > 0) goto <D.15793>; else goto <D.15794>;
      <D.15793>:
      D.15764 = res->num_blocks;
      if (D.15764 >= block_index) goto <D.15795>; else goto <D.15796>;
      <D.15795>:
      D.15781 = res->locals;
      D.15769 = (long unsigned int) i;
      D.15782 = D.15769 * 24;
      D.15783 = D.15781 + D.15782;
      D.15768 = res->code_blocks;
      D.15797 = (long unsigned int) block_index;
      D.15798 = D.15797 * 16;
      D.15799 = D.15798 + 18446744073709551600;
      D.15800 = D.15768 + D.15799;
      D.15783->block = D.15800;
      <D.15796>:
      <D.15794>:
      i = i + 1;
      <D.15239>:
      if (i < num_locals) goto <D.15238>; else goto <D.15240>;
      <D.15240>:
      D.15755 = res;
      return D.15755;
    }
  finally
    {
      p = {CLOBBER};
    }
}


mono_debug_symfile_free_locals (struct MonoDebugLocalsInfo * info)
{
  struct MonoDebugLocalVar * D.15803;
  long unsigned int D.15804;
  long unsigned int D.15805;
  struct MonoDebugLocalVar * D.15806;
  char * D.15807;
  int D.15808;
  struct MonoDebugCodeBlock * D.15809;
  int i;

  i = 0;
  goto <D.15246>;
  <D.15245>:
  D.15803 = info->locals;
  D.15804 = (long unsigned int) i;
  D.15805 = D.15804 * 24;
  D.15806 = D.15803 + D.15805;
  D.15807 = D.15806->name;
  monoeg_g_free (D.15807);
  i = i + 1;
  <D.15246>:
  D.15808 = info->num_locals;
  if (D.15808 > i) goto <D.15245>; else goto <D.15247>;
  <D.15247>:
  D.15803 = info->locals;
  monoeg_g_free (D.15803);
  D.15809 = info->code_blocks;
  monoeg_g_free (D.15809);
  monoeg_g_free (info);
}