mono_debug_open_mono_symbols (struct MonoDebugHandle * handle, const uint8_t * raw_contents, int size, gboolean in_the_debugger)
{
  unsigned int size.0;
  unsigned int size.1;
  gchar * D.14899;
  struct MonoImage * D.14901;
  const char * D.14902;
  gchar * D.14903;
  char * D.14904;
  long long unsigned int D.14907;
  int D.14908;
  int D.14909;
  int * D.14914;
  int D.14915;
  const gchar * D.14916;
  void * * D.14918;
  int D.14919;
  unsigned int D.14920;
  void * D.14921;
  int D.14922;
  struct MonoSymbolFile * D.14925;
  struct MonoSymbolFile * symfile;

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

    symfile->raw_contents_size = size;
    size.0 = (unsigned int) size;
    p = monoeg_malloc (size.0);
    symfile->raw_contents = p;
    size.1 = (unsigned int) size;
    memcpy (p, raw_contents, size.1);
    D.14899 = monoeg_g_strdup_printf ("LoadedFromMemory");
    symfile->filename = D.14899;
    symfile->was_loaded_from_memory = 1;
  }
  goto <D.14900>;
  <D.14896>:
  {
    struct MonoFileMap * f;

    D.14901 = handle->image;
    D.14902 = mono_image_get_filename (D.14901);
    D.14903 = monoeg_g_strdup_printf ("%s.mdb", D.14902);
    symfile->filename = D.14903;
    symfile->was_loaded_from_memory = 0;
    D.14904 = symfile->filename;
    f = mono_file_map_open (D.14904);
    if (f != 0B) goto <D.14905>; else goto <D.14906>;
    <D.14905>:
    D.14907 = mono_file_map_size (f);
    D.14908 = (int) D.14907;
    symfile->raw_contents_size = D.14908;
    D.14909 = symfile->raw_contents_size;
    if (D.14909 == 0) goto <D.14910>; else goto <D.14911>;
    <D.14910>:
    if (in_the_debugger == 0) goto <D.14912>; else goto <D.14913>;
    <D.14912>:
    D.14914 = __errno_location ();
    D.14915 = *D.14914;
    D.14916 = monoeg_g_strerror (D.14915);
    D.14904 = symfile->filename;
    monoeg_g_log (0B, 16, "stat of %s failed: %s", D.14904, D.14916);
    <D.14913>:
    goto <D.14917>;
    <D.14911>:
    D.14918 = &symfile->raw_contents_handle;
    D.14919 = mono_file_map_fd (f);
    D.14909 = symfile->raw_contents_size;
    D.14920 = (unsigned int) D.14909;
    D.14921 = mono_file_map (D.14920, 17, D.14919, 0, D.14918);
    symfile->raw_contents = D.14921;
    <D.14917>:
    mono_file_map_close (f);
    <D.14906>:
  }
  <D.14900>:
  D.14922 = load_symfile (handle, symfile, in_the_debugger);
  if (D.14922 != 0) goto <D.14923>; else goto <D.14924>;
  <D.14923>:
  mono_debugger_unlock ();
  D.14925 = symfile;
  return D.14925;
  <D.14924>:
  if (in_the_debugger == 0) goto <D.14926>; else goto <D.14927>;
  <D.14926>:
  mono_debug_close_mono_symbol_file (symfile);
  mono_debugger_unlock ();
  D.14925 = 0B;
  return D.14925;
  <D.14927>:
  mono_debugger_unlock ();
  D.14925 = symfile;
  return D.14925;
}


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

  D.14930 = __builtin_object_size (__dest, 0);
  D.14929 = __builtin___memcpy_chk (__dest, __src, __len, D.14930);
  return D.14929;
}


load_symfile (struct MonoDebugHandle * handle, struct MonoSymbolFile * symfile, mono_bool in_the_debugger)
{
  int D.14934;
  char * D.14939;
  unsigned int D.14940;
  int D.14691;
  struct MonoImage * D.14945;
  char * D.14946;
  char * D.14951;
  struct GHashTable * D.14954;
  struct GHashTable * D.14955;
  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.14932>; else goto <D.14933>;
  <D.14932>:
  D.14934 = 0;
  return D.14934;
  <D.14933>:
  magic = MEM[(const guint64 *)ptr];
  ptr = ptr + 8;
  if (magic != 5037318119232611860) goto <D.14935>; else goto <D.14936>;
  <D.14935>:
  if (in_the_debugger == 0) goto <D.14937>; else goto <D.14938>;
  <D.14937>:
  D.14939 = symfile->filename;
  monoeg_g_log (0B, 16, "Symbol file %s is not a mono symbol file", D.14939);
  <D.14938>:
  D.14934 = 0;
  return D.14934;
  <D.14936>:
  D.14940 = MEM[(const guint32 *)ptr];
  major = (int) D.14940;
  ptr = ptr + 4;
  D.14940 = MEM[(const guint32 *)ptr];
  minor = (int) D.14940;
  ptr = ptr + 4;
  if (major != 50) goto <D.14941>; else goto <D.14942>;
  <D.14941>:
  if (in_the_debugger == 0) goto <D.14943>; else goto <D.14944>;
  <D.14943>:
  D.14939 = symfile->filename;
  monoeg_g_log (0B, 16, "Symbol file %s has incorrect version (expected %d.%d, got %d)", D.14939, 50, 0, major);
  <D.14944>:
  D.14934 = 0;
  return D.14934;
  <D.14942>:
  guid = mono_guid_to_string (ptr);
  ptr = ptr + 16;
  {
    size_t __s1_len;
    size_t __s2_len;

    D.14945 = handle->image;
    D.14946 = D.14945->guid;
    D.14691 = __builtin_strcmp (D.14946, guid);
  }
  if (D.14691 != 0) goto <D.14947>; else goto <D.14948>;
  <D.14947>:
  if (in_the_debugger == 0) goto <D.14949>; else goto <D.14950>;
  <D.14949>:
  D.14951 = handle->image_file;
  D.14939 = symfile->filename;
  monoeg_g_log (0B, 16, "Symbol file %s doesn\'t match image %s", D.14939, D.14951);
  <D.14950>:
  if (guid != 0B) goto <D.14952>; else goto <D.14953>;
  <D.14952>:
  monoeg_g_free (guid);
  <D.14953>:
  D.14934 = 0;
  return D.14934;
  <D.14948>:
  symfile->major_version = major;
  symfile->minor_version = minor;
  symfile->offset_table = ptr;
  D.14954 = monoeg_g_hash_table_new_full (0B, 0B, 0B, free_method_info);
  symfile->method_hash = D.14954;
  D.14955 = monoeg_g_hash_table_new_full (0B, 0B, 0B, free_source_info);
  symfile->source_hash = D.14955;
  monoeg_g_free (guid);
  D.14934 = 1;
  return D.14934;
}


free_source_info (struct MonoDebugSourceInfo * sinfo)
{
  char * D.14957;
  guint8 * D.14958;
  guint8 * D.14959;

  D.14957 = sinfo->source_file;
  monoeg_g_free (D.14957);
  D.14958 = sinfo->guid;
  monoeg_g_free (D.14958);
  D.14959 = sinfo->hash;
  monoeg_g_free (D.14959);
  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.14962;
  const uint8_t * D.14965;
  int D.14968;
  void * D.14972;
  char * D.14973;

  if (symfile == 0B) goto <D.14960>; else goto <D.14961>;
  <D.14960>:
  return;
  <D.14961>:
  mono_debugger_lock ();
  D.14962 = symfile->method_hash;
  if (D.14962 != 0B) goto <D.14963>; else goto <D.14964>;
  <D.14963>:
  D.14962 = symfile->method_hash;
  monoeg_g_hash_table_destroy (D.14962);
  <D.14964>:
  D.14965 = symfile->raw_contents;
  if (D.14965 != 0B) goto <D.14966>; else goto <D.14967>;
  <D.14966>:
  D.14968 = symfile->was_loaded_from_memory;
  if (D.14968 != 0) goto <D.14969>; else goto <D.14970>;
  <D.14969>:
  D.14965 = symfile->raw_contents;
  monoeg_g_free (D.14965);
  goto <D.14971>;
  <D.14970>:
  D.14972 = symfile->raw_contents_handle;
  D.14965 = symfile->raw_contents;
  mono_file_unmap (D.14965, D.14972);
  <D.14971>:
  <D.14967>:
  D.14973 = symfile->filename;
  if (D.14973 != 0B) goto <D.14974>; else goto <D.14975>;
  <D.14974>:
  D.14973 = symfile->filename;
  monoeg_g_free (D.14973);
  <D.14975>:
  monoeg_g_free (symfile);
  mono_debugger_unlock ();
}


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

  if (symfile != 0B) goto <D.14981>; else goto <D.14979>;
  <D.14981>:
  D.14982 = symfile->offset_table;
  if (D.14982 != 0B) goto <D.14983>; else goto <D.14979>;
  <D.14983>:
  iftmp.2 = 1;
  goto <D.14980>;
  <D.14979>:
  iftmp.2 = 0;
  <D.14980>:
  D.14977 = iftmp.2;
  return D.14977;
}


mono_debug_symfile_lookup_location (struct MonoDebugMethodInfo * minfo, uint32_t offset)
{
  struct MonoDebugHandle * D.14985;
  struct MonoDebugSourceLocation * D.14988;
  struct MonoSymbolFileOffsetTable * D.14989;
  uint32_t * D.14990;
  unsigned int D.14991;
  int D.14992;
  uint32_t * D.14993;
  unsigned int D.14994;
  int D.14995;
  uint32_t * D.14996;
  unsigned int D.14997;
  unsigned char D.14998;
  unsigned char D.14999;
  int D.15000;
  int D.15001;
  int D.15002;
  int D.15003;
  const uint8_t * D.15004;
  unsigned int D.15005;
  const unsigned char * 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.15014;
  const unsigned char * ptr.9;
  const unsigned char * ptr.10;
  int D.15019;
  int D.15023;
  _Bool D.15024;
  int D.15025;
  unsigned char D.15027;
  int D.15031;
  int offset.11;
  int D.15035;
  int D.15037;
  int D.15038;
  int D.15039;
  int D.15040;
  int D.15041;
  int D.15042;
  int D.15043;
  int D.15044;
  int D.15045;
  int D.15047;
  int D.15048;
  int D.15049;
  int D.15050;
  int D.15051;
  int D.15052;
  int D.15053;
  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.14985 = minfo->handle;
      symfile = D.14985->symfile;
      if (symfile == 0B) goto <D.14986>; else goto <D.14987>;
      <D.14986>:
      D.14988 = 0B;
      return D.14988;
      <D.14987>:
      D.14989 = symfile->offset_table;
      D.14990 = &D.14989->_line_number_table_line_base;
      D.14991 = MEM[(const guint32 *)D.14990];
      D.14992 = (int) D.14991;
      stm.line_base = D.14992;
      D.14989 = symfile->offset_table;
      D.14993 = &D.14989->_line_number_table_line_range;
      D.14994 = MEM[(const guint32 *)D.14993];
      D.14995 = (int) D.14994;
      stm.line_range = D.14995;
      D.14989 = symfile->offset_table;
      D.14996 = &D.14989->_line_number_table_opcode_base;
      D.14997 = MEM[(const guint32 *)D.14996];
      D.14998 = (unsigned char) D.14997;
      stm.opcode_base = D.14998;
      D.14999 = stm.opcode_base;
      D.15000 = (int) D.14999;
      D.15001 = 255 - D.15000;
      D.15002 = stm.line_range;
      D.15003 = D.15001 / D.15002;
      stm.max_address_incr = D.15003;
      mono_debugger_lock ();
      D.15004 = symfile->raw_contents;
      D.15005 = minfo->lnt_offset;
      ptr.3 = D.15004 + D.15005;
      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.14767>:
      {
        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.15010>; else goto <D.15011>;
        <D.15010>:
        {
          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.15014 = (sizetype) size;
          end_ptr = ptr.4 + D.15014;
          ptr.4 = ptr;
          ptr.9 = ptr.4;
          ptr.10 = ptr.9 + 1;
          ptr = ptr.10;
          opcode = *ptr.9;
          if (opcode == 1) goto <D.15017>; else goto <D.15018>;
          <D.15017>:
          D.15019 = check_line (&stm, -1, &location);
          if (D.15019 != 0) goto out_success; else goto <D.15020>;
          <D.15020>:
          goto <D.14757>;
          <D.15018>:
          if (opcode == 64) goto <D.15021>; else goto <D.15022>;
          <D.15021>:
          D.15023 = stm.is_hidden;
          D.15024 = D.15023 == 0;
          D.15025 = (int) D.15024;
          stm.is_hidden = D.15025;
          goto <D.15026>;
          <D.15022>:
          D.15027 = opcode + 192;
          if (D.15027 <= 63) goto <D.15028>; else goto <D.15029>;
          <D.15028>:
          goto <D.15030>;
          <D.15029>:
          D.15031 = (int) opcode;
          monoeg_g_log (0B, 16, "Unknown extended opcode %x in LNT", D.15031);
          <D.15030>:
          <D.15026>:
          ptr = end_ptr;
          // predicted unlikely by continue predictor.
          goto <D.14758>;
        }
        <D.15011>:
        D.14999 = stm.opcode_base;
        if (D.14999 > opcode) goto <D.15032>; else goto <D.15033>;
        <D.15032>:
        D.15031 = (int) opcode;
        switch (D.15031) <default: <D.14765>, case 1: <D.14759>, case 2: <D.14761>, case 3: <D.14762>, case 4: <D.14763>, case 8: <D.14764>>
        <D.14759>:
        offset.11 = (int) offset;
        D.15035 = check_line (&stm, offset.11, &location);
        if (D.15035 != 0) goto out_success; else goto <D.15036>;
        <D.15036>:
        goto <D.14760>;
        <D.14761>:
        ptr.4 = ptr;
        D.15037 = read_leb128 (ptr.4, &ptr);
        D.15038 = stm.offset;
        D.15039 = D.15038 + D.15037;
        stm.offset = D.15039;
        goto <D.14760>;
        <D.14762>:
        ptr.4 = ptr;
        D.15040 = read_leb128 (ptr.4, &ptr);
        D.15041 = stm.line;
        D.15042 = D.15041 + D.15040;
        stm.line = D.15042;
        goto <D.14760>;
        <D.14763>:
        ptr.4 = ptr;
        D.15043 = read_leb128 (ptr.4, &ptr);
        stm.file = D.15043;
        goto <D.14760>;
        <D.14764>:
        D.15038 = stm.offset;
        D.15044 = stm.max_address_incr;
        D.15045 = D.15038 + D.15044;
        stm.offset = D.15045;
        goto <D.14760>;
        <D.14765>:
        D.15031 = (int) opcode;
        monoeg_g_log (0B, 16, "Unknown standard opcode %x in LNT", D.15031);
        goto error_out;
        <D.14760>:
        goto <D.15046>;
        <D.15033>:
        D.14999 = stm.opcode_base;
        opcode = opcode - D.14999;
        D.15038 = stm.offset;
        D.15031 = (int) opcode;
        D.15002 = stm.line_range;
        D.15047 = D.15031 / D.15002;
        D.15048 = D.15038 + D.15047;
        stm.offset = D.15048;
        D.15041 = stm.line;
        D.15049 = stm.line_base;
        D.15031 = (int) opcode;
        D.15002 = stm.line_range;
        D.15050 = D.15031 % D.15002;
        D.15051 = D.15049 + D.15050;
        D.15052 = D.15041 + D.15051;
        stm.line = D.15052;
        offset.11 = (int) offset;
        D.15053 = check_line (&stm, offset.11, &location);
        if (D.15053 != 0) goto out_success; else goto <D.15054>;
        <D.15054>:
        <D.15046>:
      }
      <D.14758>:
      goto <D.14767>;
      <D.14757>:
      error_out:
      mono_debugger_unlock ();
      D.14988 = 0B;
      return D.14988;
      out_success:
      mono_debugger_unlock ();
      D.14988 = location;
      return D.14988;
    }
  finally
    {
      location = {CLOBBER};
      ptr = {CLOBBER};
      stm = {CLOBBER};
    }
}


read_leb128 (const uint8_t * ptr, const uint8_t * * rptr)
{
  const uint8_t * ptr.12;
  unsigned char D.15058;
  int D.15059;
  int D.15060;
  int D.15061;
  int D.15064;
  int ret;
  int shift;
  char b;

  ret = 0;
  shift = 0;
  <D.14714>:
  ptr.12 = ptr;
  ptr = ptr.12 + 1;
  D.15058 = *ptr.12;
  b = (char) D.15058;
  D.15059 = (int) b;
  D.15060 = D.15059 & 127;
  D.15061 = D.15060 << shift;
  ret = D.15061 | ret;
  shift = shift + 7;
  if (b < 0) goto <D.14714>; else goto <D.14715>;
  <D.14715>:
  if (rptr != 0B) goto <D.15062>; else goto <D.15063>;
  <D.15062>:
  *rptr = ptr;
  <D.15063>:
  D.15064 = ret;
  return D.15064;
}


check_line (struct StatementMachine * stm, int offset, struct MonoDebugSourceLocation * * location)
{
  int D.15066;
  unsigned int D.15069;
  int D.15070;
  unsigned int D.15071;
  int D.15072;
  unsigned int D.15075;
  gboolean D.15076;
  unsigned int D.15077;
  struct MonoSymbolFile * D.15080;
  struct MonoSymbolFileOffsetTable * D.15081;
  uint32_t * D.15082;
  unsigned int D.15083;
  unsigned int D.15084;
  unsigned int D.15085;
  unsigned int D.15086;
  const uint8_t * D.15087;
  sizetype offset.13;
  uint32_t * D.15089;
  unsigned int D.15090;
  const uint8_t * D.15091;
  unsigned int D.15092;
  void * D.15095;
  struct MonoDebugSourceLocation * D.15096;
  unsigned int D.15097;
  gchar * source_file;

  source_file = 0B;
  D.15066 = stm->offset;
  if (D.15066 <= offset) goto <D.15067>; else goto <D.15068>;
  <D.15067>:
  D.15066 = stm->offset;
  D.15069 = (unsigned int) D.15066;
  stm->last_offset = D.15069;
  D.15070 = stm->file;
  D.15071 = (unsigned int) D.15070;
  stm->last_file = D.15071;
  D.15072 = stm->line;
  if (D.15072 != 16707566) goto <D.15073>; else goto <D.15074>;
  <D.15073>:
  D.15072 = stm->line;
  D.15075 = (unsigned int) D.15072;
  stm->last_line = D.15075;
  <D.15074>:
  D.15076 = 0;
  return D.15076;
  <D.15068>:
  D.15077 = stm->last_file;
  if (D.15077 != 0) goto <D.15078>; else goto <D.15079>;
  <D.15078>:
  {
    int offset;
    struct MonoSymbolFileSourceEntry * se;

    D.15080 = stm->symfile;
    D.15081 = D.15080->offset_table;
    D.15082 = &D.15081->_source_table_offset;
    D.15083 = MEM[(const guint32 *)D.15082];
    D.15077 = stm->last_file;
    D.15084 = D.15077 + 536870911;
    D.15085 = D.15084 * 8;
    D.15086 = D.15083 + D.15085;
    offset = (int) D.15086;
    D.15080 = stm->symfile;
    D.15087 = D.15080->raw_contents;
    offset.13 = (sizetype) offset;
    se = D.15087 + offset.13;
    D.15080 = stm->symfile;
    D.15087 = D.15080->raw_contents;
    D.15089 = &se->_data_offset;
    D.15090 = MEM[(const guint32 *)D.15089];
    D.15091 = D.15087 + D.15090;
    source_file = read_string (D.15091, 0B);
  }
  <D.15079>:
  D.15092 = stm->last_line;
  if (D.15092 == 0) goto <D.15093>; else goto <D.15094>;
  <D.15093>:
  *location = 0B;
  D.15076 = 1;
  return D.15076;
  <D.15094>:
  D.15095 = monoeg_malloc0 (16);
  *location = D.15095;
  D.15096 = *location;
  D.15096->source_file = source_file;
  D.15096 = *location;
  D.15092 = stm->last_line;
  D.15096->row = D.15092;
  D.15096 = *location;
  D.15097 = stm->last_offset;
  D.15096->il_offset = D.15097;
  D.15076 = 1;
  return D.15076;
}


read_string (const uint8_t * ptr, const uint8_t * * endp)
{
  const uint8_t * ptr.14;
  sizetype len.15;
  const uint8_t * ptr.16;
  gchar * D.15104;
  gchar * s;
  int len;

  ptr.14 = ptr;
  len = read_leb128 (ptr.14, &ptr);
  ptr.14 = ptr;
  s = monoeg_g_filename_from_utf8 (ptr.14, len, 0B, 0B, 0B);
  ptr.14 = ptr;
  len.15 = (sizetype) len;
  ptr.16 = ptr.14 + len.15;
  ptr = ptr.16;
  if (endp != 0B) goto <D.15102>; else goto <D.15103>;
  <D.15102>:
  ptr.14 = ptr;
  *endp = ptr.14;
  <D.15103>:
  D.15104 = s;
  return D.15104;
}


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

  D.15106 = location->source_file;
  monoeg_g_free (D.15106);
  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.15117;
  struct MonoSymbolFileOffsetTable * D.15120;
  uint32_t * D.15121;
  unsigned int D.15122;
  int D.15123;
  uint32_t * D.15124;
  unsigned int D.15125;
  int D.15126;
  uint32_t * D.15127;
  unsigned int D.15128;
  unsigned char D.15129;
  unsigned char D.15130;
  int D.15131;
  int D.15132;
  int D.15133;
  int D.15134;
  const uint8_t * D.15135;
  unsigned int D.15136;
  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;
  const unsigned char * ptr.22;
  sizetype D.15145;
  const unsigned char * ptr.23;
  const unsigned char * ptr.24;
  unsigned int D.15150;
  int D.15154;
  _Bool D.15155;
  int D.15156;
  unsigned char D.15158;
  int D.15162;
  int D.15165;
  int D.15166;
  int D.15167;
  int D.15168;
  int D.15169;
  int D.15170;
  int D.15171;
  int D.15172;
  int D.15173;
  int D.15175;
  int D.15176;
  int D.15177;
  int D.15178;
  int D.15179;
  int D.15180;
  int D.15181;
  unsigned int D.15184;
  int D.15187;
  struct MonoSymbolFile * D.15192;
  struct MonoSymbolFileOffsetTable * D.15193;
  uint32_t * D.15194;
  unsigned int D.15195;
  int D.15196;
  unsigned int D.15197;
  unsigned int D.15198;
  unsigned int D.15199;
  const uint8_t * D.15200;
  sizetype offset.25;
  uint32_t * D.15204;
  unsigned int D.15205;
  const uint8_t * D.15206;
  gchar * D.15207;
  struct GPtrArray * D.15210;
  unsigned int D.15213;
  void * D.15214;
  void * * D.15215;
  unsigned int D.15216;
  void * * D.15217;
  void * D.15218;
  _Bool D.15219;
  _Bool D.15220;
  _Bool D.15221;
  struct GPtrArray * D.15224;
  int * D.15227;
  int * D.15228;
  unsigned int D.15229;
  unsigned int D.15230;
  int D.15231;
  int D.15238;
  _Bool D.15239;
  _Bool D.15240;
  _Bool D.15241;
  void * D.15244;
  void * D.15245;
  int * D.15246;
  int * D.15247;
  void * * D.15248;
  void * * D.15249;
  void * D.15250;
  int D.15251;
  int * D.15252;
  int * D.15253;
  void * * D.15254;
  void * * D.15255;
  void * D.15256;
  int D.15257;
  _Bool D.15258;
  _Bool D.15259;
  _Bool D.15260;
  void * D.15263;
  int * D.15264;
  int * D.15265;
  int D.15266;
  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.15107>; else goto <D.15108>;
      <D.15107>:
      *source_file_list = 0B;
      <D.15108>:
      if (n_il_offsets != 0B) goto <D.15109>; else goto <D.15110>;
      <D.15109>:
      *n_il_offsets = 0;
      <D.15110>:
      if (source_files != 0B) goto <D.15111>; else goto <D.15112>;
      <D.15111>:
      *source_files = 0B;
      <D.15112>:
      if (source_file != 0B) goto <D.15113>; else goto <D.15114>;
      <D.15113>:
      *source_file = 0B;
      <D.15114>:
      if (column_numbers != 0B) goto <D.15115>; else goto <D.15116>;
      <D.15115>:
      *column_numbers = 0B;
      <D.15116>:
      D.15117 = minfo->handle;
      symfile = D.15117->symfile;
      if (symfile == 0B) goto <D.15118>; else goto <D.15119>;
      <D.15118>:
      return;
      <D.15119>:
      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.15120 = symfile->offset_table;
      D.15121 = &D.15120->_line_number_table_line_base;
      D.15122 = MEM[(const guint32 *)D.15121];
      D.15123 = (int) D.15122;
      stm.line_base = D.15123;
      D.15120 = symfile->offset_table;
      D.15124 = &D.15120->_line_number_table_line_range;
      D.15125 = MEM[(const guint32 *)D.15124];
      D.15126 = (int) D.15125;
      stm.line_range = D.15126;
      D.15120 = symfile->offset_table;
      D.15127 = &D.15120->_line_number_table_opcode_base;
      D.15128 = MEM[(const guint32 *)D.15127];
      D.15129 = (unsigned char) D.15128;
      stm.opcode_base = D.15129;
      D.15130 = stm.opcode_base;
      D.15131 = (int) D.15130;
      D.15132 = 255 - D.15131;
      D.15133 = stm.line_range;
      D.15134 = D.15132 / D.15133;
      stm.max_address_incr = D.15134;
      mono_debugger_lock ();
      D.15135 = symfile->raw_contents;
      D.15136 = minfo->lnt_offset;
      ptr.17 = D.15135 + D.15136;
      ptr = ptr.17;
      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.14821>:
      {
        uint8_t opcode;

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

          ptr.18 = ptr;
          ptr.21 = ptr.18;
          ptr.22 = ptr.21 + 1;
          ptr = ptr.22;
          size = *ptr.21;
          ptr.18 = ptr;
          D.15145 = (sizetype) size;
          end_ptr = ptr.18 + D.15145;
          ptr.18 = ptr;
          ptr.23 = ptr.18;
          ptr.24 = ptr.23 + 1;
          ptr = ptr.24;
          opcode = *ptr.23;
          if (opcode == 1) goto <D.15148>; else goto <D.15149>;
          <D.15148>:
          D.15150 = il_offset_array->len;
          if (D.15150 == 0) goto <D.14812>; else goto <D.15151>;
          <D.15151>:
          add_line (&stm, il_offset_array, line_number_array, source_file_array);
          goto <D.14812>;
          <D.15149>:
          if (opcode == 64) goto <D.15152>; else goto <D.15153>;
          <D.15152>:
          D.15154 = stm.is_hidden;
          D.15155 = D.15154 == 0;
          D.15156 = (int) D.15155;
          stm.is_hidden = D.15156;
          goto <D.15157>;
          <D.15153>:
          D.15158 = opcode + 192;
          if (D.15158 <= 63) goto <D.15159>; else goto <D.15160>;
          <D.15159>:
          goto <D.15161>;
          <D.15160>:
          D.15162 = (int) opcode;
          monoeg_g_log (0B, 16, "Unknown extended opcode %x in LNT", D.15162);
          <D.15161>:
          <D.15157>:
          ptr = end_ptr;
          // predicted unlikely by continue predictor.
          goto <D.14813>;
        }
        <D.15142>:
        D.15130 = stm.opcode_base;
        if (D.15130 > opcode) goto <D.15163>; else goto <D.15164>;
        <D.15163>:
        D.15162 = (int) opcode;
        switch (D.15162) <default: <D.14820>, case 1: <D.14814>, case 2: <D.14816>, case 3: <D.14817>, case 4: <D.14818>, case 8: <D.14819>>
        <D.14814>:
        add_line (&stm, il_offset_array, line_number_array, source_file_array);
        goto <D.14815>;
        <D.14816>:
        ptr.18 = ptr;
        D.15165 = read_leb128 (ptr.18, &ptr);
        D.15166 = stm.offset;
        D.15167 = D.15166 + D.15165;
        stm.offset = D.15167;
        goto <D.14815>;
        <D.14817>:
        ptr.18 = ptr;
        D.15168 = read_leb128 (ptr.18, &ptr);
        D.15169 = stm.line;
        D.15170 = D.15169 + D.15168;
        stm.line = D.15170;
        goto <D.14815>;
        <D.14818>:
        ptr.18 = ptr;
        D.15171 = read_leb128 (ptr.18, &ptr);
        stm.file = D.15171;
        goto <D.14815>;
        <D.14819>:
        D.15166 = stm.offset;
        D.15172 = stm.max_address_incr;
        D.15173 = D.15166 + D.15172;
        stm.offset = D.15173;
        goto <D.14815>;
        <D.14820>:
        D.15162 = (int) opcode;
        monoeg_g_log (0B, 16, "Unknown standard opcode %x in LNT", D.15162);
        monoeg_assertion_message ("* Assertion: should not be reached at %s:%d\n", "debug-mono-symfile.c", 599);
        <D.14815>:
        goto <D.15174>;
        <D.15164>:
        D.15130 = stm.opcode_base;
        opcode = opcode - D.15130;
        D.15166 = stm.offset;
        D.15162 = (int) opcode;
        D.15133 = stm.line_range;
        D.15175 = D.15162 / D.15133;
        D.15176 = D.15166 + D.15175;
        stm.offset = D.15176;
        D.15169 = stm.line;
        D.15177 = stm.line_base;
        D.15162 = (int) opcode;
        D.15133 = stm.line_range;
        D.15178 = D.15162 % D.15133;
        D.15179 = D.15177 + D.15178;
        D.15180 = D.15169 + D.15179;
        stm.line = D.15180;
        add_line (&stm, il_offset_array, line_number_array, source_file_array);
        <D.15174>:
      }
      <D.14813>:
      goto <D.14821>;
      <D.14812>:
      D.15181 = stm.file;
      if (D.15181 == 0) goto <D.15182>; else goto <D.15183>;
      <D.15182>:
      D.15184 = stm.first_file;
      if (D.15184 != 0) goto <D.15185>; else goto <D.15186>;
      <D.15185>:
      D.15184 = stm.first_file;
      D.15187 = (int) D.15184;
      stm.file = D.15187;
      <D.15186>:
      <D.15183>:
      D.15181 = stm.file;
      if (D.15181 != 0) goto <D.15188>; else goto <D.15189>;
      <D.15188>:
      if (source_file != 0B) goto <D.15190>; else goto <D.15191>;
      <D.15190>:
      {
        int offset;
        struct MonoSymbolFileSourceEntry * se;

        D.15192 = stm.symfile;
        D.15193 = D.15192->offset_table;
        D.15194 = &D.15193->_source_table_offset;
        D.15195 = MEM[(const guint32 *)D.15194];
        D.15181 = stm.file;
        D.15196 = D.15181 + -1;
        D.15197 = (unsigned int) D.15196;
        D.15198 = D.15197 * 8;
        D.15199 = D.15195 + D.15198;
        offset = (int) D.15199;
        D.15192 = stm.symfile;
        D.15200 = D.15192->raw_contents;
        offset.25 = (sizetype) offset;
        se = D.15200 + offset.25;
        if (source_file != 0B) goto <D.15202>; else goto <D.15203>;
        <D.15202>:
        D.15192 = stm.symfile;
        D.15200 = D.15192->raw_contents;
        D.15204 = &se->_data_offset;
        D.15205 = MEM[(const guint32 *)D.15204];
        D.15206 = D.15200 + D.15205;
        D.15207 = read_string (D.15206, 0B);
        *source_file = D.15207;
        <D.15203>:
      }
      <D.15191>:
      <D.15189>:
      if (source_file_list != 0B) goto <D.15208>; else goto <D.15209>;
      <D.15208>:
      {
        int file;
        int last_file;

        last_file = 0;
        D.15210 = monoeg_g_ptr_array_new ();
        *source_file_list = D.15210;
        if (source_files != 0B) goto <D.15211>; else goto <D.15212>;
        <D.15211>:
        D.15150 = il_offset_array->len;
        D.15213 = D.15150 * 4;
        D.15214 = monoeg_malloc (D.15213);
        *source_files = D.15214;
        <D.15212>:
        i = 0;
        goto <D.14828>;
        <D.14827>:
        D.15215 = source_file_array->pdata;
        D.15216 = i * 4;
        D.15217 = D.15215 + D.15216;
        D.15218 = *D.15217;
        file = (int) D.15218;
        D.15219 = file != 0;
        D.15220 = file != last_file;
        D.15221 = D.15219 & D.15220;
        if (D.15221 != 0) goto <D.15222>; else goto <D.15223>;
        <D.15222>:
        {
          struct MonoDebugSourceInfo * info;

          info = get_source_info (symfile, file);
          D.15224 = *source_file_list;
          monoeg_g_ptr_array_add (D.15224, info);
        }
        <D.15223>:
        last_file = file;
        if (source_files != 0B) goto <D.15225>; else goto <D.15226>;
        <D.15225>:
        D.15227 = *source_files;
        D.15216 = i * 4;
        D.15228 = D.15227 + D.15216;
        D.15224 = *source_file_list;
        D.15229 = D.15224->len;
        D.15230 = D.15229 + 4294967295;
        D.15231 = (int) D.15230;
        *D.15228 = D.15231;
        <D.15226>:
        i = i + 1;
        <D.14828>:
        D.15150 = il_offset_array->len;
        if (D.15150 > i) goto <D.14827>; else goto <D.14829>;
        <D.14829>:
        D.15224 = *source_file_list;
        D.15229 = D.15224->len;
        if (D.15229 == 0) goto <D.15232>; else goto <D.15233>;
        <D.15232>:
        D.15181 = stm.file;
        if (D.15181 != 0) goto <D.15234>; else goto <D.15235>;
        <D.15234>:
        {
          struct MonoDebugSourceInfo * info;

          D.15181 = stm.file;
          info = get_source_info (symfile, D.15181);
          D.15224 = *source_file_list;
          monoeg_g_ptr_array_add (D.15224, info);
        }
        <D.15235>:
        <D.15233>:
      }
      <D.15209>:
      if (n_il_offsets != 0B) goto <D.15236>; else goto <D.15237>;
      <D.15236>:
      D.15150 = il_offset_array->len;
      D.15238 = (int) D.15150;
      *n_il_offsets = D.15238;
      <D.15237>:
      D.15239 = il_offsets != 0B;
      D.15240 = line_numbers != 0B;
      D.15241 = D.15239 & D.15240;
      if (D.15241 != 0) goto <D.15242>; else goto <D.15243>;
      <D.15242>:
      D.15150 = il_offset_array->len;
      D.15213 = D.15150 * 4;
      D.15244 = monoeg_malloc (D.15213);
      *il_offsets = D.15244;
      D.15150 = il_offset_array->len;
      D.15213 = D.15150 * 4;
      D.15245 = monoeg_malloc (D.15213);
      *line_numbers = D.15245;
      i = 0;
      goto <D.14832>;
      <D.14831>:
      D.15246 = *il_offsets;
      D.15216 = i * 4;
      D.15247 = D.15246 + D.15216;
      D.15248 = il_offset_array->pdata;
      D.15216 = i * 4;
      D.15249 = D.15248 + D.15216;
      D.15250 = *D.15249;
      D.15251 = (int) D.15250;
      *D.15247 = D.15251;
      D.15252 = *line_numbers;
      D.15216 = i * 4;
      D.15253 = D.15252 + D.15216;
      D.15254 = line_number_array->pdata;
      D.15216 = i * 4;
      D.15255 = D.15254 + D.15216;
      D.15256 = *D.15255;
      D.15257 = (int) D.15256;
      *D.15253 = D.15257;
      i = i + 1;
      <D.14832>:
      D.15150 = il_offset_array->len;
      if (D.15150 > i) goto <D.14831>; else goto <D.14833>;
      <D.14833>:
      <D.15243>:
      D.15258 = column_numbers != 0B;
      D.15259 = has_column_info != 0;
      D.15260 = D.15258 & D.15259;
      if (D.15260 != 0) goto <D.15261>; else goto <D.15262>;
      <D.15261>:
      D.15150 = il_offset_array->len;
      D.15213 = D.15150 * 4;
      D.15263 = monoeg_malloc (D.15213);
      *column_numbers = D.15263;
      i = 0;
      goto <D.14835>;
      <D.14834>:
      D.15264 = *column_numbers;
      D.15216 = i * 4;
      D.15265 = D.15264 + D.15216;
      ptr.18 = ptr;
      D.15266 = read_leb128 (ptr.18, &ptr);
      *D.15265 = D.15266;
      i = i + 1;
      <D.14835>:
      D.15150 = il_offset_array->len;
      if (D.15150 > i) goto <D.14834>; else goto <D.14836>;
      <D.14836>:
      <D.15262>:
      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.15269;
  gboolean D.15272;
  const uint8_t * D.15273;
  unsigned int D.15274;
  const unsigned char * ptr.26;
  const unsigned char * ptr.27;
  int D.15277;
  unsigned int D.15278;
  _Bool D.15279;
  struct MonoSymbolFile * symfile;
  const unsigned char * ptr;
  guint32 flags;

  try
    {
      D.15269 = minfo->handle;
      symfile = D.15269->symfile;
      if (symfile == 0B) goto <D.15270>; else goto <D.15271>;
      <D.15270>:
      D.15272 = 0;
      return D.15272;
      <D.15271>:
      D.15273 = symfile->raw_contents;
      D.15274 = minfo->data_offset;
      ptr.26 = D.15273 + D.15274;
      ptr = ptr.26;
      ptr.27 = ptr;
      read_leb128 (ptr.27, &ptr);
      ptr.27 = ptr;
      read_leb128 (ptr.27, &ptr);
      ptr.27 = ptr;
      read_leb128 (ptr.27, &ptr);
      ptr.27 = ptr;
      read_leb128 (ptr.27, &ptr);
      ptr.27 = ptr;
      read_leb128 (ptr.27, &ptr);
      ptr.27 = ptr;
      read_leb128 (ptr.27, &ptr);
      ptr.27 = ptr;
      D.15277 = read_leb128 (ptr.27, &ptr);
      flags = (guint32) D.15277;
      D.15278 = flags & 2;
      D.15279 = D.15278 != 0;
      D.15272 = (gboolean) D.15279;
      return D.15272;
    }
  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.15282;
  int D.15285;
  void * D.15286;
  void * D.15287;
  int D.15288;
  void * D.15289;
  int D.15290;
  unsigned int D.15293;
  unsigned int D.15296;

  D.15282 = stm->line;
  if (D.15282 > 0) goto <D.15283>; else goto <D.15284>;
  <D.15283>:
  D.15285 = stm->offset;
  D.15286 = (void *) D.15285;
  monoeg_g_ptr_array_add (il_offset_array, D.15286);
  D.15282 = stm->line;
  D.15287 = (void *) D.15282;
  monoeg_g_ptr_array_add (line_number_array, D.15287);
  D.15288 = stm->file;
  D.15289 = (void *) D.15288;
  monoeg_g_ptr_array_add (source_file_array, D.15289);
  <D.15284>:
  D.15290 = stm->is_hidden;
  if (D.15290 == 0) goto <D.15291>; else goto <D.15292>;
  <D.15291>:
  D.15293 = stm->first_file;
  if (D.15293 == 0) goto <D.15294>; else goto <D.15295>;
  <D.15294>:
  D.15288 = stm->file;
  D.15296 = (unsigned int) D.15288;
  stm->first_file = D.15296;
  <D.15295>:
  <D.15292>:
}


get_source_info (struct MonoSymbolFile * symfile, int index)
{
  const void * index.28;
  struct GHashTable * D.15298;
  struct MonoSymbolFileOffsetTable * D.15301;
  uint32_t * D.15302;
  unsigned int D.15303;
  int D.15304;
  unsigned int D.15305;
  unsigned int D.15306;
  unsigned int D.15307;
  const uint8_t * D.15308;
  sizetype offset.29;
  uint32_t * D.15310;
  unsigned int D.15311;
  const uint8_t * ptr.30;
  const uint8_t * ptr.31;
  gchar * D.15314;
  void * D.15315;
  guint8 * D.15316;
  const uint8_t * ptr.32;
  void * D.15318;
  guint8 * D.15319;
  void * index.33;
  struct MonoDebugSourceInfo * D.15321;
  struct MonoDebugSourceInfo * info;

  index.28 = (const void *) index;
  D.15298 = symfile->source_hash;
  info = monoeg_g_hash_table_lookup (D.15298, index.28);
  if (info == 0B) goto <D.15299>; else goto <D.15300>;
  <D.15299>:
  {
    int offset;
    struct MonoSymbolFileSourceEntry * se;
    const uint8_t * ptr;

    try
      {
        D.15301 = symfile->offset_table;
        D.15302 = &D.15301->_source_table_offset;
        D.15303 = MEM[(const guint32 *)D.15302];
        D.15304 = index + -1;
        D.15305 = (unsigned int) D.15304;
        D.15306 = D.15305 * 8;
        D.15307 = D.15303 + D.15306;
        offset = (int) D.15307;
        D.15308 = symfile->raw_contents;
        offset.29 = (sizetype) offset;
        se = D.15308 + offset.29;
        D.15308 = symfile->raw_contents;
        D.15310 = &se->_data_offset;
        D.15311 = MEM[(const guint32 *)D.15310];
        ptr.30 = D.15308 + D.15311;
        ptr = ptr.30;
        info = monoeg_malloc0 (12);
        ptr.31 = ptr;
        D.15314 = read_string (ptr.31, &ptr);
        info->source_file = D.15314;
        D.15315 = monoeg_malloc0 (16);
        info->guid = D.15315;
        ptr.31 = ptr;
        D.15316 = info->guid;
        memcpy (D.15316, ptr.31, 16);
        ptr.31 = ptr;
        ptr.32 = ptr.31 + 16;
        ptr = ptr.32;
        D.15318 = monoeg_malloc0 (16);
        info->hash = D.15318;
        ptr.31 = ptr;
        D.15319 = info->hash;
        memcpy (D.15319, ptr.31, 16);
        ptr.31 = ptr;
        ptr.32 = ptr.31 + 16;
        ptr = ptr.32;
        index.33 = (void *) index;
        D.15298 = symfile->source_hash;
        monoeg_g_hash_table_insert_replace (D.15298, index.33, info, 0);
      }
    finally
      {
        ptr = {CLOBBER};
      }
  }
  <D.15300>:
  D.15321 = info;
  return D.15321;
}


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.15326;
  int32_t D.15327;
  unsigned int D.15328;
  unsigned int D.15329;
  unsigned int i.34;
  unsigned int D.15331;
  struct MonoDebugLineNumberEntry * D.15332;
  unsigned int D.15333;
  unsigned int D.15336;
  int i;

  if (jit == 0B) goto <D.15323>; else goto <D.15325>;
  <D.15325>:
  D.15326 = jit->line_numbers;
  if (D.15326 == 0B) goto <D.15323>; else goto <D.15324>;
  <D.15323>:
  D.15327 = -1;
  return D.15327;
  <D.15324>:
  D.15328 = jit->num_line_numbers;
  D.15329 = D.15328 + 4294967295;
  i = (int) D.15329;
  goto <D.14851>;
  <D.14850>:
  {
    struct MonoDebugLineNumberEntry lne;

    try
      {
        D.15326 = jit->line_numbers;
        i.34 = (unsigned int) i;
        D.15331 = i.34 * 8;
        D.15332 = D.15326 + D.15331;
        lne = *D.15332;
        D.15333 = lne.il_offset;
        if (D.15333 <= il_offset) goto <D.15334>; else goto <D.15335>;
        <D.15334>:
        D.15336 = lne.native_offset;
        D.15327 = (int32_t) D.15336;
        return D.15327;
        <D.15335>:
      }
    finally
      {
        lne = {CLOBBER};
      }
  }
  i = i + -1;
  <D.14851>:
  if (i >= 0) goto <D.14850>; else goto <D.14852>;
  <D.14852>:
  D.15327 = 0;
  return D.15327;
}


mono_debug_symfile_lookup_method (struct MonoDebugHandle * handle, struct MonoMethod * method)
{
  struct GHashTable * D.15340;
  struct MonoDebugMethodInfo * D.15343;
  struct MonoImage * D.15344;
  struct MonoClass * D.15345;
  struct MonoImage * D.15346;
  const uint8_t * D.15351;
  struct MonoSymbolFileOffsetTable * D.15352;
  uint32_t * D.15353;
  unsigned int D.15354;
  uint32_t * D.15355;
  unsigned int D.15356;
  unsigned int D.15357;
  const void * D.15358;
  int ie.35;
  int first_ie.36;
  int D.15363;
  int D.15364;
  int D.15365;
  unsigned int D.15366;
  unsigned int D.15367;
  unsigned int D.15368;
  struct MonoSymbolFileMethodEntry * first_ie;
  struct MonoSymbolFileMethodEntry * ie;
  struct MonoDebugMethodInfo * minfo;
  struct MonoSymbolFile * symfile;

  symfile = handle->symfile;
  D.15340 = symfile->method_hash;
  if (D.15340 == 0B) goto <D.15341>; else goto <D.15342>;
  <D.15341>:
  D.15343 = 0B;
  return D.15343;
  <D.15342>:
  D.15344 = handle->image;
  D.15345 = mono_method_get_class (method);
  D.15346 = mono_class_get_image (D.15345);
  if (D.15344 != D.15346) goto <D.15347>; else goto <D.15348>;
  <D.15347>:
  D.15343 = 0B;
  return D.15343;
  <D.15348>:
  mono_debugger_lock ();
  D.15340 = symfile->method_hash;
  minfo = monoeg_g_hash_table_lookup (D.15340, method);
  if (minfo != 0B) goto <D.15349>; else goto <D.15350>;
  <D.15349>:
  mono_debugger_unlock ();
  D.15343 = minfo;
  return D.15343;
  <D.15350>:
  D.15351 = symfile->raw_contents;
  D.15352 = symfile->offset_table;
  D.15353 = &D.15352->_method_table_offset;
  D.15354 = MEM[(const guint32 *)D.15353];
  first_ie = D.15351 + D.15354;
  D.15352 = symfile->offset_table;
  D.15355 = &D.15352->_method_count;
  D.15356 = MEM[(const guint32 *)D.15355];
  D.15357 = mono_method_get_token (method);
  D.15358 = (const void *) D.15357;
  ie = mono_binary_search (D.15358, first_ie, D.15356, 12, compare_method);
  if (ie == 0B) goto <D.15359>; else goto <D.15360>;
  <D.15359>:
  mono_debugger_unlock ();
  D.15343 = 0B;
  return D.15343;
  <D.15360>:
  minfo = monoeg_malloc0 (20);
  ie.35 = (int) ie;
  first_ie.36 = (int) first_ie;
  D.15363 = ie.35 - first_ie.36;
  D.15364 = D.15363 /[ex] 12;
  D.15365 = D.15364 + 1;
  D.15366 = (unsigned int) D.15365;
  minfo->index = D.15366;
  minfo->method = method;
  minfo->handle = handle;
  D.15367 = ie->_data_offset;
  minfo->data_offset = D.15367;
  D.15368 = ie->_line_number_table;
  minfo->lnt_offset = D.15368;
  D.15340 = symfile->method_hash;
  monoeg_g_hash_table_insert_replace (D.15340, method, minfo, 0);
  mono_debugger_unlock ();
  D.15343 = minfo;
  return D.15343;
}


compare_method (const void * key, const void * object)
{
  int D.15370;
  uint32_t * D.15371;
  unsigned int D.15372;
  unsigned int D.15373;
  uint32_t token;
  struct MonoSymbolFileMethodEntry * me;

  token = (uint32_t) key;
  me = object;
  D.15371 = &me->_token;
  D.15372 = MEM[(const guint32 *)D.15371];
  D.15373 = token - D.15372;
  D.15370 = (int) D.15373;
  return D.15370;
}


mono_debug_symfile_lookup_locals (struct MonoDebugMethodInfo * minfo)
{
  struct MonoDebugHandle * D.15375;
  struct MonoDebugLocalsInfo * D.15378;
  const uint8_t * D.15379;
  unsigned int D.15380;
  const uint8_t * p.37;
  const uint8_t * p.38;
  sizetype code_block_table_offset.39;
  const uint8_t * p.40;
  int D.15385;
  int D.15386;
  unsigned int D.15387;
  unsigned int D.15388;
  void * D.15389;
  struct MonoDebugCodeBlock * D.15390;
  unsigned int i.41;
  unsigned int D.15392;
  struct MonoDebugCodeBlock * D.15393;
  int D.15394;
  int D.15395;
  int D.15396;
  int D.15397;
  sizetype locals_offset.42;
  const uint8_t * p.43;
  unsigned int num_locals.44;
  unsigned int D.15401;
  void * D.15402;
  struct MonoDebugLocalVar * D.15403;
  unsigned int D.15404;
  struct MonoDebugLocalVar * D.15405;
  int D.15406;
  int D.15407;
  unsigned int D.15408;
  void * D.15409;
  unsigned int len.45;
  char * D.15411;
  sizetype len.46;
  char * D.15413;
  const uint8_t * p.47;
  sizetype block_index.48;
  sizetype D.15420;
  sizetype D.15421;
  struct MonoDebugCodeBlock * D.15422;
  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.15375 = minfo->handle;
      symfile = D.15375->symfile;
      if (symfile == 0B) goto <D.15376>; else goto <D.15377>;
      <D.15376>:
      D.15378 = 0B;
      return D.15378;
      <D.15377>:
      D.15379 = symfile->raw_contents;
      D.15380 = minfo->data_offset;
      p.37 = D.15379 + D.15380;
      p = p.37;
      p.38 = p;
      compile_unit_index = read_leb128 (p.38, &p);
      p.38 = p;
      locals_offset = read_leb128 (p.38, &p);
      p.38 = p;
      namespace_id = read_leb128 (p.38, &p);
      p.38 = p;
      code_block_table_offset = read_leb128 (p.38, &p);
      res = monoeg_malloc0 (16);
      D.15379 = symfile->raw_contents;
      code_block_table_offset.39 = (sizetype) code_block_table_offset;
      p.40 = D.15379 + code_block_table_offset.39;
      p = p.40;
      p.38 = p;
      D.15385 = read_leb128 (p.38, &p);
      res->num_blocks = D.15385;
      D.15386 = res->num_blocks;
      D.15387 = (unsigned int) D.15386;
      D.15388 = D.15387 * 16;
      D.15389 = monoeg_malloc0 (D.15388);
      res->code_blocks = D.15389;
      i = 0;
      goto <D.14882>;
      <D.14881>:
      D.15390 = res->code_blocks;
      i.41 = (unsigned int) i;
      D.15392 = i.41 * 16;
      D.15393 = D.15390 + D.15392;
      p.38 = p;
      D.15394 = read_leb128 (p.38, &p);
      D.15393->type = D.15394;
      D.15390 = res->code_blocks;
      i.41 = (unsigned int) i;
      D.15392 = i.41 * 16;
      D.15393 = D.15390 + D.15392;
      p.38 = p;
      D.15395 = read_leb128 (p.38, &p);
      D.15393->parent = D.15395;
      D.15390 = res->code_blocks;
      i.41 = (unsigned int) i;
      D.15392 = i.41 * 16;
      D.15393 = D.15390 + D.15392;
      p.38 = p;
      D.15396 = read_leb128 (p.38, &p);
      D.15393->start_offset = D.15396;
      D.15390 = res->code_blocks;
      i.41 = (unsigned int) i;
      D.15392 = i.41 * 16;
      D.15393 = D.15390 + D.15392;
      p.38 = p;
      D.15397 = read_leb128 (p.38, &p);
      D.15393->end_offset = D.15397;
      i = i + 1;
      <D.14882>:
      D.15386 = res->num_blocks;
      if (D.15386 > i) goto <D.14881>; else goto <D.14883>;
      <D.14883>:
      D.15379 = symfile->raw_contents;
      locals_offset.42 = (sizetype) locals_offset;
      p.43 = D.15379 + locals_offset.42;
      p = p.43;
      p.38 = p;
      num_locals = read_leb128 (p.38, &p);
      res->num_locals = num_locals;
      num_locals.44 = (unsigned int) num_locals;
      D.15401 = num_locals.44 * 12;
      D.15402 = monoeg_malloc0 (D.15401);
      res->locals = D.15402;
      i = 0;
      goto <D.14885>;
      <D.14884>:
      D.15403 = res->locals;
      i.41 = (unsigned int) i;
      D.15404 = i.41 * 12;
      D.15405 = D.15403 + D.15404;
      p.38 = p;
      D.15406 = read_leb128 (p.38, &p);
      D.15405->index = D.15406;
      p.38 = p;
      len = read_leb128 (p.38, &p);
      D.15403 = res->locals;
      i.41 = (unsigned int) i;
      D.15404 = i.41 * 12;
      D.15405 = D.15403 + D.15404;
      D.15407 = len + 1;
      D.15408 = (unsigned int) D.15407;
      D.15409 = monoeg_malloc (D.15408);
      D.15405->name = D.15409;
      len.45 = (unsigned int) len;
      p.38 = p;
      D.15403 = res->locals;
      i.41 = (unsigned int) i;
      D.15404 = i.41 * 12;
      D.15405 = D.15403 + D.15404;
      D.15411 = D.15405->name;
      memcpy (D.15411, p.38, len.45);
      D.15403 = res->locals;
      i.41 = (unsigned int) i;
      D.15404 = i.41 * 12;
      D.15405 = D.15403 + D.15404;
      D.15411 = D.15405->name;
      len.46 = (sizetype) len;
      D.15413 = D.15411 + len.46;
      *D.15413 = 0;
      p.38 = p;
      len.46 = (sizetype) len;
      p.47 = p.38 + len.46;
      p = p.47;
      p.38 = p;
      block_index = read_leb128 (p.38, &p);
      if (block_index > 0) goto <D.15415>; else goto <D.15416>;
      <D.15415>:
      D.15386 = res->num_blocks;
      if (D.15386 >= block_index) goto <D.15417>; else goto <D.15418>;
      <D.15417>:
      D.15403 = res->locals;
      i.41 = (unsigned int) i;
      D.15404 = i.41 * 12;
      D.15405 = D.15403 + D.15404;
      D.15390 = res->code_blocks;
      block_index.48 = (sizetype) block_index;
      D.15420 = block_index.48 + 268435455;
      D.15421 = D.15420 * 16;
      D.15422 = D.15390 + D.15421;
      D.15405->block = D.15422;
      <D.15418>:
      <D.15416>:
      i = i + 1;
      <D.14885>:
      if (i < num_locals) goto <D.14884>; else goto <D.14886>;
      <D.14886>:
      D.15378 = res;
      return D.15378;
    }
  finally
    {
      p = {CLOBBER};
    }
}


mono_debug_symfile_free_locals (struct MonoDebugLocalsInfo * info)
{
  struct MonoDebugLocalVar * D.15425;
  unsigned int i.49;
  unsigned int D.15427;
  struct MonoDebugLocalVar * D.15428;
  char * D.15429;
  int D.15430;
  struct MonoDebugCodeBlock * D.15431;
  int i;

  i = 0;
  goto <D.14892>;
  <D.14891>:
  D.15425 = info->locals;
  i.49 = (unsigned int) i;
  D.15427 = i.49 * 12;
  D.15428 = D.15425 + D.15427;
  D.15429 = D.15428->name;
  monoeg_g_free (D.15429);
  i = i + 1;
  <D.14892>:
  D.15430 = info->num_locals;
  if (D.15430 > i) goto <D.14891>; else goto <D.14893>;
  <D.14893>:
  D.15425 = info->locals;
  monoeg_g_free (D.15425);
  D.15431 = info->code_blocks;
  monoeg_g_free (D.15431);
  monoeg_g_free (info);
}