mono_debug_open_mono_symbols (struct MonoDebugHandle * handle, const uint8_t * raw_contents, int size, gboolean in_the_debugger)
{
  long unsigned int D.15785;
  long unsigned int D.15786;
  gchar * D.15787;
  struct MonoImage * D.15789;
  const char * D.15790;
  gchar * D.15791;
  char * D.15792;
  long unsigned int D.15795;
  int D.15796;
  int D.15797;
  int * D.15802;
  int D.15803;
  const gchar * D.15804;
  long unsigned int D.15806;
  int D.15807;
  void * * D.15808;
  void * D.15809;
  int D.15810;
  struct MonoSymbolFile * D.15813;
  struct MonoSymbolFile * symfile;

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

    symfile->raw_contents_size = size;
    D.15785 = (long unsigned int) size;
    p = monoeg_malloc (D.15785);
    symfile->raw_contents = p;
    D.15786 = (long unsigned int) size;
    memcpy (p, raw_contents, D.15786);
    D.15787 = monoeg_g_strdup_printf ("LoadedFromMemory");
    symfile->filename = D.15787;
    symfile->was_loaded_from_memory = 1;
  }
  goto <D.15788>;
  <D.15784>:
  {
    struct MonoFileMap * f;

    D.15789 = handle->image;
    D.15790 = mono_image_get_filename (D.15789);
    D.15791 = monoeg_g_strdup_printf ("%s.mdb", D.15790);
    symfile->filename = D.15791;
    symfile->was_loaded_from_memory = 0;
    D.15792 = symfile->filename;
    f = mono_file_map_open (D.15792);
    if (f != 0B) goto <D.15793>; else goto <D.15794>;
    <D.15793>:
    D.15795 = mono_file_map_size (f);
    D.15796 = (int) D.15795;
    symfile->raw_contents_size = D.15796;
    D.15797 = symfile->raw_contents_size;
    if (D.15797 == 0) goto <D.15798>; else goto <D.15799>;
    <D.15798>:
    if (in_the_debugger == 0) goto <D.15800>; else goto <D.15801>;
    <D.15800>:
    D.15792 = symfile->filename;
    D.15802 = __errno_location ();
    D.15803 = *D.15802;
    D.15804 = monoeg_g_strerror (D.15803);
    monoeg_g_log (0B, 16, "stat of %s failed: %s", D.15792, D.15804);
    <D.15801>:
    goto <D.15805>;
    <D.15799>:
    D.15797 = symfile->raw_contents_size;
    D.15806 = (long unsigned int) D.15797;
    D.15807 = mono_file_map_fd (f);
    D.15808 = &symfile->raw_contents_handle;
    D.15809 = mono_file_map (D.15806, 17, D.15807, 0, D.15808);
    symfile->raw_contents = D.15809;
    <D.15805>:
    mono_file_map_close (f);
    <D.15794>:
  }
  <D.15788>:
  D.15810 = load_symfile (handle, symfile, in_the_debugger);
  if (D.15810 != 0) goto <D.15811>; else goto <D.15812>;
  <D.15811>:
  mono_debugger_unlock ();
  D.15813 = symfile;
  return D.15813;
  <D.15812>:
  if (in_the_debugger == 0) goto <D.15814>; else goto <D.15815>;
  <D.15814>:
  mono_debug_close_mono_symbol_file (symfile);
  mono_debugger_unlock ();
  D.15813 = 0B;
  return D.15813;
  <D.15815>:
  mono_debugger_unlock ();
  D.15813 = symfile;
  return D.15813;
}


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

  D.15818 = __builtin_object_size (__dest, 0);
  D.15817 = __builtin___memcpy_chk (__dest, __src, __len, D.15818);
  return D.15817;
}


load_symfile (struct MonoDebugHandle * handle, struct MonoSymbolFile * symfile, mono_bool in_the_debugger)
{
  int D.15822;
  char * D.15827;
  unsigned int D.15828;
  int D.15579;
  struct MonoImage * D.15833;
  char * D.15834;
  char * D.15839;
  struct GHashTable * D.15842;
  struct GHashTable * D.15843;
  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.15820>; else goto <D.15821>;
  <D.15820>:
  D.15822 = 0;
  return D.15822;
  <D.15821>:
  magic = MEM[(const guint64 *)ptr];
  ptr = ptr + 8;
  if (magic != 5037318119232611860) goto <D.15823>; else goto <D.15824>;
  <D.15823>:
  if (in_the_debugger == 0) goto <D.15825>; else goto <D.15826>;
  <D.15825>:
  D.15827 = symfile->filename;
  monoeg_g_log (0B, 16, "Symbol file %s is not a mono symbol file", D.15827);
  <D.15826>:
  D.15822 = 0;
  return D.15822;
  <D.15824>:
  D.15828 = MEM[(const guint32 *)ptr];
  major = (int) D.15828;
  ptr = ptr + 4;
  D.15828 = MEM[(const guint32 *)ptr];
  minor = (int) D.15828;
  ptr = ptr + 4;
  if (major != 50) goto <D.15829>; else goto <D.15830>;
  <D.15829>:
  if (in_the_debugger == 0) goto <D.15831>; else goto <D.15832>;
  <D.15831>:
  D.15827 = symfile->filename;
  monoeg_g_log (0B, 16, "Symbol file %s has incorrect version (expected %d.%d, got %d)", D.15827, 50, 0, major);
  <D.15832>:
  D.15822 = 0;
  return D.15822;
  <D.15830>:
  guid = mono_guid_to_string (ptr);
  ptr = ptr + 16;
  {
    size_t __s1_len;
    size_t __s2_len;

    D.15833 = handle->image;
    D.15834 = D.15833->guid;
    D.15579 = __builtin_strcmp (D.15834, guid);
  }
  if (D.15579 != 0) goto <D.15835>; else goto <D.15836>;
  <D.15835>:
  if (in_the_debugger == 0) goto <D.15837>; else goto <D.15838>;
  <D.15837>:
  D.15827 = symfile->filename;
  D.15839 = handle->image_file;
  monoeg_g_log (0B, 16, "Symbol file %s doesn\'t match image %s", D.15827, D.15839);
  <D.15838>:
  if (guid != 0B) goto <D.15840>; else goto <D.15841>;
  <D.15840>:
  monoeg_g_free (guid);
  <D.15841>:
  D.15822 = 0;
  return D.15822;
  <D.15836>:
  symfile->major_version = major;
  symfile->minor_version = minor;
  symfile->offset_table = ptr;
  D.15842 = monoeg_g_hash_table_new_full (0B, 0B, 0B, free_method_info);
  symfile->method_hash = D.15842;
  D.15843 = monoeg_g_hash_table_new_full (0B, 0B, 0B, free_source_info);
  symfile->source_hash = D.15843;
  monoeg_g_free (guid);
  D.15822 = 1;
  return D.15822;
}


free_source_info (struct MonoDebugSourceInfo * sinfo)
{
  char * D.15845;
  guint8 * D.15846;
  guint8 * D.15847;

  D.15845 = sinfo->source_file;
  monoeg_g_free (D.15845);
  D.15846 = sinfo->guid;
  monoeg_g_free (D.15846);
  D.15847 = sinfo->hash;
  monoeg_g_free (D.15847);
  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.15850;
  const uint8_t * D.15853;
  int D.15856;
  void * D.15860;
  char * D.15861;

  if (symfile == 0B) goto <D.15848>; else goto <D.15849>;
  <D.15848>:
  return;
  <D.15849>:
  mono_debugger_lock ();
  D.15850 = symfile->method_hash;
  if (D.15850 != 0B) goto <D.15851>; else goto <D.15852>;
  <D.15851>:
  D.15850 = symfile->method_hash;
  monoeg_g_hash_table_destroy (D.15850);
  <D.15852>:
  D.15853 = symfile->raw_contents;
  if (D.15853 != 0B) goto <D.15854>; else goto <D.15855>;
  <D.15854>:
  D.15856 = symfile->was_loaded_from_memory;
  if (D.15856 != 0) goto <D.15857>; else goto <D.15858>;
  <D.15857>:
  D.15853 = symfile->raw_contents;
  monoeg_g_free (D.15853);
  goto <D.15859>;
  <D.15858>:
  D.15853 = symfile->raw_contents;
  D.15860 = symfile->raw_contents_handle;
  mono_file_unmap (D.15853, D.15860);
  <D.15859>:
  <D.15855>:
  D.15861 = symfile->filename;
  if (D.15861 != 0B) goto <D.15862>; else goto <D.15863>;
  <D.15862>:
  D.15861 = symfile->filename;
  monoeg_g_free (D.15861);
  <D.15863>:
  monoeg_g_free (symfile);
  mono_debugger_unlock ();
}


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

  if (symfile != 0B) goto <D.15869>; else goto <D.15867>;
  <D.15869>:
  D.15870 = symfile->offset_table;
  if (D.15870 != 0B) goto <D.15871>; else goto <D.15867>;
  <D.15871>:
  iftmp.0 = 1;
  goto <D.15868>;
  <D.15867>:
  iftmp.0 = 0;
  <D.15868>:
  D.15865 = iftmp.0;
  return D.15865;
}


mono_debug_symfile_lookup_location (struct MonoDebugMethodInfo * minfo, uint32_t offset)
{
  struct MonoDebugHandle * D.15873;
  struct MonoDebugSourceLocation * D.15876;
  struct MonoSymbolFileOffsetTable * D.15877;
  uint32_t * D.15878;
  unsigned int D.15879;
  int D.15880;
  uint32_t * D.15881;
  unsigned int D.15882;
  int D.15883;
  uint32_t * D.15884;
  unsigned int D.15885;
  unsigned char D.15886;
  unsigned char D.15887;
  int D.15888;
  int D.15889;
  int D.15890;
  int D.15891;
  const uint8_t * D.15892;
  unsigned int D.15893;
  sizetype D.15894;
  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.15903;
  const unsigned char * ptr.7;
  const unsigned char * ptr.8;
  int D.15908;
  int D.15912;
  _Bool D.15913;
  int D.15914;
  unsigned char D.15916;
  int D.15920;
  int offset.9;
  int D.15924;
  int D.15926;
  int D.15927;
  int D.15928;
  int D.15929;
  int D.15930;
  int D.15931;
  int D.15932;
  int D.15933;
  int D.15934;
  int D.15936;
  int D.15937;
  int D.15938;
  int D.15939;
  int D.15940;
  int D.15941;
  int D.15942;
  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.15873 = minfo->handle;
      symfile = D.15873->symfile;
      if (symfile == 0B) goto <D.15874>; else goto <D.15875>;
      <D.15874>:
      D.15876 = 0B;
      return D.15876;
      <D.15875>:
      D.15877 = symfile->offset_table;
      D.15878 = &D.15877->_line_number_table_line_base;
      D.15879 = MEM[(const guint32 *)D.15878];
      D.15880 = (int) D.15879;
      stm.line_base = D.15880;
      D.15877 = symfile->offset_table;
      D.15881 = &D.15877->_line_number_table_line_range;
      D.15882 = MEM[(const guint32 *)D.15881];
      D.15883 = (int) D.15882;
      stm.line_range = D.15883;
      D.15877 = symfile->offset_table;
      D.15884 = &D.15877->_line_number_table_opcode_base;
      D.15885 = MEM[(const guint32 *)D.15884];
      D.15886 = (unsigned char) D.15885;
      stm.opcode_base = D.15886;
      D.15887 = stm.opcode_base;
      D.15888 = (int) D.15887;
      D.15889 = 255 - D.15888;
      D.15890 = stm.line_range;
      D.15891 = D.15889 / D.15890;
      stm.max_address_incr = D.15891;
      mono_debugger_lock ();
      D.15892 = symfile->raw_contents;
      D.15893 = minfo->lnt_offset;
      D.15894 = (sizetype) D.15893;
      ptr.1 = D.15892 + D.15894;
      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.15655>:
      {
        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.15899>; else goto <D.15900>;
        <D.15899>:
        {
          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.15903 = (sizetype) size;
          end_ptr = ptr.2 + D.15903;
          ptr.2 = ptr;
          ptr.7 = ptr.2;
          ptr.8 = ptr.7 + 1;
          ptr = ptr.8;
          opcode = *ptr.7;
          if (opcode == 1) goto <D.15906>; else goto <D.15907>;
          <D.15906>:
          D.15908 = check_line (&stm, -1, &location);
          if (D.15908 != 0) goto out_success; else goto <D.15909>;
          <D.15909>:
          goto <D.15645>;
          <D.15907>:
          if (opcode == 64) goto <D.15910>; else goto <D.15911>;
          <D.15910>:
          D.15912 = stm.is_hidden;
          D.15913 = D.15912 == 0;
          D.15914 = (int) D.15913;
          stm.is_hidden = D.15914;
          goto <D.15915>;
          <D.15911>:
          D.15916 = opcode + 192;
          if (D.15916 <= 63) goto <D.15917>; else goto <D.15918>;
          <D.15917>:
          goto <D.15919>;
          <D.15918>:
          D.15920 = (int) opcode;
          monoeg_g_log (0B, 16, "Unknown extended opcode %x in LNT", D.15920);
          <D.15919>:
          <D.15915>:
          ptr = end_ptr;
          // predicted unlikely by continue predictor.
          goto <D.15646>;
        }
        <D.15900>:
        D.15887 = stm.opcode_base;
        if (D.15887 > opcode) goto <D.15921>; else goto <D.15922>;
        <D.15921>:
        D.15920 = (int) opcode;
        switch (D.15920) <default: <D.15653>, case 1: <D.15647>, case 2: <D.15649>, case 3: <D.15650>, case 4: <D.15651>, case 8: <D.15652>>
        <D.15647>:
        offset.9 = (int) offset;
        D.15924 = check_line (&stm, offset.9, &location);
        if (D.15924 != 0) goto out_success; else goto <D.15925>;
        <D.15925>:
        goto <D.15648>;
        <D.15649>:
        ptr.2 = ptr;
        D.15926 = read_leb128 (ptr.2, &ptr);
        D.15927 = stm.offset;
        D.15928 = D.15927 + D.15926;
        stm.offset = D.15928;
        goto <D.15648>;
        <D.15650>:
        ptr.2 = ptr;
        D.15929 = read_leb128 (ptr.2, &ptr);
        D.15930 = stm.line;
        D.15931 = D.15930 + D.15929;
        stm.line = D.15931;
        goto <D.15648>;
        <D.15651>:
        ptr.2 = ptr;
        D.15932 = read_leb128 (ptr.2, &ptr);
        stm.file = D.15932;
        goto <D.15648>;
        <D.15652>:
        D.15927 = stm.offset;
        D.15933 = stm.max_address_incr;
        D.15934 = D.15927 + D.15933;
        stm.offset = D.15934;
        goto <D.15648>;
        <D.15653>:
        D.15920 = (int) opcode;
        monoeg_g_log (0B, 16, "Unknown standard opcode %x in LNT", D.15920);
        goto error_out;
        <D.15648>:
        goto <D.15935>;
        <D.15922>:
        D.15887 = stm.opcode_base;
        opcode = opcode - D.15887;
        D.15927 = stm.offset;
        D.15920 = (int) opcode;
        D.15890 = stm.line_range;
        D.15936 = D.15920 / D.15890;
        D.15937 = D.15927 + D.15936;
        stm.offset = D.15937;
        D.15930 = stm.line;
        D.15938 = stm.line_base;
        D.15920 = (int) opcode;
        D.15890 = stm.line_range;
        D.15939 = D.15920 % D.15890;
        D.15940 = D.15938 + D.15939;
        D.15941 = D.15930 + D.15940;
        stm.line = D.15941;
        offset.9 = (int) offset;
        D.15942 = check_line (&stm, offset.9, &location);
        if (D.15942 != 0) goto out_success; else goto <D.15943>;
        <D.15943>:
        <D.15935>:
      }
      <D.15646>:
      goto <D.15655>;
      <D.15645>:
      error_out:
      mono_debugger_unlock ();
      D.15876 = 0B;
      return D.15876;
      out_success:
      mono_debugger_unlock ();
      D.15876 = location;
      return D.15876;
    }
  finally
    {
      location = {CLOBBER};
      ptr = {CLOBBER};
      stm = {CLOBBER};
    }
}


read_leb128 (const uint8_t * ptr, const uint8_t * * rptr)
{
  const uint8_t * ptr.10;
  int D.15947;
  int D.15948;
  int D.15949;
  signed char b.11;
  int D.15953;
  int ret;
  int shift;
  char b;

  ret = 0;
  shift = 0;
  <D.15602>:
  ptr.10 = ptr;
  ptr = ptr.10 + 1;
  b = *ptr.10;
  D.15947 = (int) b;
  D.15948 = D.15947 & 127;
  D.15949 = D.15948 << shift;
  ret = D.15949 | ret;
  shift = shift + 7;
  b.11 = (signed char) b;
  if (b.11 < 0) goto <D.15602>; else goto <D.15603>;
  <D.15603>:
  if (rptr != 0B) goto <D.15951>; else goto <D.15952>;
  <D.15951>:
  *rptr = ptr;
  <D.15952>:
  D.15953 = ret;
  return D.15953;
}


check_line (struct StatementMachine * stm, int offset, struct MonoDebugSourceLocation * * location)
{
  int D.15955;
  unsigned int D.15958;
  int D.15959;
  unsigned int D.15960;
  int D.15961;
  unsigned int D.15964;
  gboolean D.15965;
  unsigned int D.15966;
  struct MonoSymbolFile * D.15969;
  struct MonoSymbolFileOffsetTable * D.15970;
  uint32_t * D.15971;
  unsigned int D.15972;
  unsigned int D.15973;
  unsigned int D.15974;
  unsigned int D.15975;
  const uint8_t * D.15976;
  sizetype D.15977;
  uint32_t * D.15978;
  unsigned int D.15979;
  sizetype D.15980;
  const uint8_t * D.15981;
  unsigned int D.15982;
  void * D.15985;
  struct MonoDebugSourceLocation * D.15986;
  unsigned int D.15987;
  gchar * source_file;

  source_file = 0B;
  D.15955 = stm->offset;
  if (D.15955 <= offset) goto <D.15956>; else goto <D.15957>;
  <D.15956>:
  D.15955 = stm->offset;
  D.15958 = (unsigned int) D.15955;
  stm->last_offset = D.15958;
  D.15959 = stm->file;
  D.15960 = (unsigned int) D.15959;
  stm->last_file = D.15960;
  D.15961 = stm->line;
  if (D.15961 != 16707566) goto <D.15962>; else goto <D.15963>;
  <D.15962>:
  D.15961 = stm->line;
  D.15964 = (unsigned int) D.15961;
  stm->last_line = D.15964;
  <D.15963>:
  D.15965 = 0;
  return D.15965;
  <D.15957>:
  D.15966 = stm->last_file;
  if (D.15966 != 0) goto <D.15967>; else goto <D.15968>;
  <D.15967>:
  {
    int offset;
    struct MonoSymbolFileSourceEntry * se;

    D.15969 = stm->symfile;
    D.15970 = D.15969->offset_table;
    D.15971 = &D.15970->_source_table_offset;
    D.15972 = MEM[(const guint32 *)D.15971];
    D.15966 = stm->last_file;
    D.15973 = D.15966 + 536870911;
    D.15974 = D.15973 * 8;
    D.15975 = D.15972 + D.15974;
    offset = (int) D.15975;
    D.15969 = stm->symfile;
    D.15976 = D.15969->raw_contents;
    D.15977 = (sizetype) offset;
    se = D.15976 + D.15977;
    D.15969 = stm->symfile;
    D.15976 = D.15969->raw_contents;
    D.15978 = &se->_data_offset;
    D.15979 = MEM[(const guint32 *)D.15978];
    D.15980 = (sizetype) D.15979;
    D.15981 = D.15976 + D.15980;
    source_file = read_string (D.15981, 0B);
  }
  <D.15968>:
  D.15982 = stm->last_line;
  if (D.15982 == 0) goto <D.15983>; else goto <D.15984>;
  <D.15983>:
  *location = 0B;
  D.15965 = 1;
  return D.15965;
  <D.15984>:
  D.15985 = monoeg_malloc0 (24);
  *location = D.15985;
  D.15986 = *location;
  D.15986->source_file = source_file;
  D.15986 = *location;
  D.15982 = stm->last_line;
  D.15986->row = D.15982;
  D.15986 = *location;
  D.15987 = stm->last_offset;
  D.15986->il_offset = D.15987;
  D.15965 = 1;
  return D.15965;
}


read_string (const uint8_t * ptr, const uint8_t * * endp)
{
  const uint8_t * ptr.12;
  long int D.15990;
  sizetype D.15991;
  const uint8_t * ptr.13;
  gchar * D.15995;
  gchar * s;
  int len;

  ptr.12 = ptr;
  len = read_leb128 (ptr.12, &ptr);
  ptr.12 = ptr;
  D.15990 = (long int) len;
  s = monoeg_g_filename_from_utf8 (ptr.12, D.15990, 0B, 0B, 0B);
  ptr.12 = ptr;
  D.15991 = (sizetype) len;
  ptr.13 = ptr.12 + D.15991;
  ptr = ptr.13;
  if (endp != 0B) goto <D.15993>; else goto <D.15994>;
  <D.15993>:
  ptr.12 = ptr;
  *endp = ptr.12;
  <D.15994>:
  D.15995 = s;
  return D.15995;
}


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

  D.15997 = location->source_file;
  monoeg_g_free (D.15997);
  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.16008;
  struct MonoSymbolFileOffsetTable * D.16011;
  uint32_t * D.16012;
  unsigned int D.16013;
  int D.16014;
  uint32_t * D.16015;
  unsigned int D.16016;
  int D.16017;
  uint32_t * D.16018;
  unsigned int D.16019;
  unsigned char D.16020;
  unsigned char D.16021;
  int D.16022;
  int D.16023;
  int D.16024;
  int D.16025;
  const uint8_t * D.16026;
  unsigned int D.16027;
  sizetype D.16028;
  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;
  const unsigned char * ptr.19;
  sizetype D.16037;
  const unsigned char * ptr.20;
  const unsigned char * ptr.21;
  unsigned int D.16042;
  int D.16046;
  _Bool D.16047;
  int D.16048;
  unsigned char D.16050;
  int D.16054;
  int D.16057;
  int D.16058;
  int D.16059;
  int D.16060;
  int D.16061;
  int D.16062;
  int D.16063;
  int D.16064;
  int D.16065;
  int D.16067;
  int D.16068;
  int D.16069;
  int D.16070;
  int D.16071;
  int D.16072;
  int D.16073;
  unsigned int D.16076;
  int D.16079;
  struct MonoSymbolFile * D.16084;
  struct MonoSymbolFileOffsetTable * D.16085;
  uint32_t * D.16086;
  unsigned int D.16087;
  int D.16088;
  long unsigned int D.16089;
  unsigned int D.16090;
  unsigned int D.16091;
  unsigned int D.16092;
  const uint8_t * D.16093;
  sizetype D.16094;
  uint32_t * D.16097;
  unsigned int D.16098;
  sizetype D.16099;
  const uint8_t * D.16100;
  gchar * D.16101;
  struct GPtrArray * D.16104;
  long unsigned int D.16107;
  long unsigned int D.16108;
  void * D.16109;
  void * * D.16110;
  long unsigned int D.16111;
  long unsigned int D.16112;
  void * * D.16113;
  void * D.16114;
  long int D.16115;
  struct GPtrArray * D.16120;
  int * D.16123;
  long unsigned int D.16124;
  int * D.16125;
  unsigned int D.16126;
  unsigned int D.16127;
  int D.16128;
  int D.16135;
  void * D.16140;
  void * D.16141;
  int * D.16142;
  int * D.16143;
  void * * D.16144;
  void * * D.16145;
  void * D.16146;
  long int D.16147;
  int D.16148;
  int * D.16149;
  int * D.16150;
  void * * D.16151;
  void * * D.16152;
  void * D.16153;
  long int D.16154;
  int D.16155;
  void * D.16160;
  int * D.16161;
  int * D.16162;
  int D.16163;
  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.15998>; else goto <D.15999>;
      <D.15998>:
      *source_file_list = 0B;
      <D.15999>:
      if (n_il_offsets != 0B) goto <D.16000>; else goto <D.16001>;
      <D.16000>:
      *n_il_offsets = 0;
      <D.16001>:
      if (source_files != 0B) goto <D.16002>; else goto <D.16003>;
      <D.16002>:
      *source_files = 0B;
      <D.16003>:
      if (source_file != 0B) goto <D.16004>; else goto <D.16005>;
      <D.16004>:
      *source_file = 0B;
      <D.16005>:
      if (column_numbers != 0B) goto <D.16006>; else goto <D.16007>;
      <D.16006>:
      *column_numbers = 0B;
      <D.16007>:
      D.16008 = minfo->handle;
      symfile = D.16008->symfile;
      if (symfile == 0B) goto <D.16009>; else goto <D.16010>;
      <D.16009>:
      return;
      <D.16010>:
      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.16011 = symfile->offset_table;
      D.16012 = &D.16011->_line_number_table_line_base;
      D.16013 = MEM[(const guint32 *)D.16012];
      D.16014 = (int) D.16013;
      stm.line_base = D.16014;
      D.16011 = symfile->offset_table;
      D.16015 = &D.16011->_line_number_table_line_range;
      D.16016 = MEM[(const guint32 *)D.16015];
      D.16017 = (int) D.16016;
      stm.line_range = D.16017;
      D.16011 = symfile->offset_table;
      D.16018 = &D.16011->_line_number_table_opcode_base;
      D.16019 = MEM[(const guint32 *)D.16018];
      D.16020 = (unsigned char) D.16019;
      stm.opcode_base = D.16020;
      D.16021 = stm.opcode_base;
      D.16022 = (int) D.16021;
      D.16023 = 255 - D.16022;
      D.16024 = stm.line_range;
      D.16025 = D.16023 / D.16024;
      stm.max_address_incr = D.16025;
      mono_debugger_lock ();
      D.16026 = symfile->raw_contents;
      D.16027 = minfo->lnt_offset;
      D.16028 = (sizetype) D.16027;
      ptr.14 = D.16026 + D.16028;
      ptr = ptr.14;
      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.15709>:
      {
        uint8_t opcode;

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

          ptr.15 = ptr;
          ptr.18 = ptr.15;
          ptr.19 = ptr.18 + 1;
          ptr = ptr.19;
          size = *ptr.18;
          ptr.15 = ptr;
          D.16037 = (sizetype) size;
          end_ptr = ptr.15 + D.16037;
          ptr.15 = ptr;
          ptr.20 = ptr.15;
          ptr.21 = ptr.20 + 1;
          ptr = ptr.21;
          opcode = *ptr.20;
          if (opcode == 1) goto <D.16040>; else goto <D.16041>;
          <D.16040>:
          D.16042 = il_offset_array->len;
          if (D.16042 == 0) goto <D.15700>; else goto <D.16043>;
          <D.16043>:
          add_line (&stm, il_offset_array, line_number_array, source_file_array);
          goto <D.15700>;
          <D.16041>:
          if (opcode == 64) goto <D.16044>; else goto <D.16045>;
          <D.16044>:
          D.16046 = stm.is_hidden;
          D.16047 = D.16046 == 0;
          D.16048 = (int) D.16047;
          stm.is_hidden = D.16048;
          goto <D.16049>;
          <D.16045>:
          D.16050 = opcode + 192;
          if (D.16050 <= 63) goto <D.16051>; else goto <D.16052>;
          <D.16051>:
          goto <D.16053>;
          <D.16052>:
          D.16054 = (int) opcode;
          monoeg_g_log (0B, 16, "Unknown extended opcode %x in LNT", D.16054);
          <D.16053>:
          <D.16049>:
          ptr = end_ptr;
          // predicted unlikely by continue predictor.
          goto <D.15701>;
        }
        <D.16034>:
        D.16021 = stm.opcode_base;
        if (D.16021 > opcode) goto <D.16055>; else goto <D.16056>;
        <D.16055>:
        D.16054 = (int) opcode;
        switch (D.16054) <default: <D.15708>, case 1: <D.15702>, case 2: <D.15704>, case 3: <D.15705>, case 4: <D.15706>, case 8: <D.15707>>
        <D.15702>:
        add_line (&stm, il_offset_array, line_number_array, source_file_array);
        goto <D.15703>;
        <D.15704>:
        ptr.15 = ptr;
        D.16057 = read_leb128 (ptr.15, &ptr);
        D.16058 = stm.offset;
        D.16059 = D.16058 + D.16057;
        stm.offset = D.16059;
        goto <D.15703>;
        <D.15705>:
        ptr.15 = ptr;
        D.16060 = read_leb128 (ptr.15, &ptr);
        D.16061 = stm.line;
        D.16062 = D.16061 + D.16060;
        stm.line = D.16062;
        goto <D.15703>;
        <D.15706>:
        ptr.15 = ptr;
        D.16063 = read_leb128 (ptr.15, &ptr);
        stm.file = D.16063;
        goto <D.15703>;
        <D.15707>:
        D.16058 = stm.offset;
        D.16064 = stm.max_address_incr;
        D.16065 = D.16058 + D.16064;
        stm.offset = D.16065;
        goto <D.15703>;
        <D.15708>:
        D.16054 = (int) opcode;
        monoeg_g_log (0B, 16, "Unknown standard opcode %x in LNT", D.16054);
        monoeg_assertion_message ("* Assertion: should not be reached at %s:%d\n", "debug-mono-symfile.c", 599);
        <D.15703>:
        goto <D.16066>;
        <D.16056>:
        D.16021 = stm.opcode_base;
        opcode = opcode - D.16021;
        D.16058 = stm.offset;
        D.16054 = (int) opcode;
        D.16024 = stm.line_range;
        D.16067 = D.16054 / D.16024;
        D.16068 = D.16058 + D.16067;
        stm.offset = D.16068;
        D.16061 = stm.line;
        D.16069 = stm.line_base;
        D.16054 = (int) opcode;
        D.16024 = stm.line_range;
        D.16070 = D.16054 % D.16024;
        D.16071 = D.16069 + D.16070;
        D.16072 = D.16061 + D.16071;
        stm.line = D.16072;
        add_line (&stm, il_offset_array, line_number_array, source_file_array);
        <D.16066>:
      }
      <D.15701>:
      goto <D.15709>;
      <D.15700>:
      D.16073 = stm.file;
      if (D.16073 == 0) goto <D.16074>; else goto <D.16075>;
      <D.16074>:
      D.16076 = stm.first_file;
      if (D.16076 != 0) goto <D.16077>; else goto <D.16078>;
      <D.16077>:
      D.16076 = stm.first_file;
      D.16079 = (int) D.16076;
      stm.file = D.16079;
      <D.16078>:
      <D.16075>:
      D.16073 = stm.file;
      if (D.16073 != 0) goto <D.16080>; else goto <D.16081>;
      <D.16080>:
      if (source_file != 0B) goto <D.16082>; else goto <D.16083>;
      <D.16082>:
      {
        int offset;
        struct MonoSymbolFileSourceEntry * se;

        D.16084 = stm.symfile;
        D.16085 = D.16084->offset_table;
        D.16086 = &D.16085->_source_table_offset;
        D.16087 = MEM[(const guint32 *)D.16086];
        D.16073 = stm.file;
        D.16088 = D.16073 + -1;
        D.16089 = (long unsigned int) D.16088;
        D.16090 = (unsigned int) D.16089;
        D.16091 = D.16090 * 8;
        D.16092 = D.16087 + D.16091;
        offset = (int) D.16092;
        D.16084 = stm.symfile;
        D.16093 = D.16084->raw_contents;
        D.16094 = (sizetype) offset;
        se = D.16093 + D.16094;
        if (source_file != 0B) goto <D.16095>; else goto <D.16096>;
        <D.16095>:
        D.16084 = stm.symfile;
        D.16093 = D.16084->raw_contents;
        D.16097 = &se->_data_offset;
        D.16098 = MEM[(const guint32 *)D.16097];
        D.16099 = (sizetype) D.16098;
        D.16100 = D.16093 + D.16099;
        D.16101 = read_string (D.16100, 0B);
        *source_file = D.16101;
        <D.16096>:
      }
      <D.16083>:
      <D.16081>:
      if (source_file_list != 0B) goto <D.16102>; else goto <D.16103>;
      <D.16102>:
      {
        int file;
        int last_file;

        last_file = 0;
        D.16104 = monoeg_g_ptr_array_new ();
        *source_file_list = D.16104;
        if (source_files != 0B) goto <D.16105>; else goto <D.16106>;
        <D.16105>:
        D.16042 = il_offset_array->len;
        D.16107 = (long unsigned int) D.16042;
        D.16108 = D.16107 * 4;
        D.16109 = monoeg_malloc (D.16108);
        *source_files = D.16109;
        <D.16106>:
        i = 0;
        goto <D.15716>;
        <D.15715>:
        D.16110 = source_file_array->pdata;
        D.16111 = (long unsigned int) i;
        D.16112 = D.16111 * 8;
        D.16113 = D.16110 + D.16112;
        D.16114 = *D.16113;
        D.16115 = (long int) D.16114;
        file = (int) D.16115;
        if (file != 0) goto <D.16116>; else goto <D.16117>;
        <D.16116>:
        if (file != last_file) goto <D.16118>; else goto <D.16119>;
        <D.16118>:
        {
          struct MonoDebugSourceInfo * info;

          info = get_source_info (symfile, file);
          D.16120 = *source_file_list;
          monoeg_g_ptr_array_add (D.16120, info);
        }
        <D.16119>:
        <D.16117>:
        last_file = file;
        if (source_files != 0B) goto <D.16121>; else goto <D.16122>;
        <D.16121>:
        D.16123 = *source_files;
        D.16111 = (long unsigned int) i;
        D.16124 = D.16111 * 4;
        D.16125 = D.16123 + D.16124;
        D.16120 = *source_file_list;
        D.16126 = D.16120->len;
        D.16127 = D.16126 + 4294967295;
        D.16128 = (int) D.16127;
        *D.16125 = D.16128;
        <D.16122>:
        i = i + 1;
        <D.15716>:
        D.16042 = il_offset_array->len;
        if (D.16042 > i) goto <D.15715>; else goto <D.15717>;
        <D.15717>:
        D.16120 = *source_file_list;
        D.16126 = D.16120->len;
        if (D.16126 == 0) goto <D.16129>; else goto <D.16130>;
        <D.16129>:
        D.16073 = stm.file;
        if (D.16073 != 0) goto <D.16131>; else goto <D.16132>;
        <D.16131>:
        {
          struct MonoDebugSourceInfo * info;

          D.16073 = stm.file;
          info = get_source_info (symfile, D.16073);
          D.16120 = *source_file_list;
          monoeg_g_ptr_array_add (D.16120, info);
        }
        <D.16132>:
        <D.16130>:
      }
      <D.16103>:
      if (n_il_offsets != 0B) goto <D.16133>; else goto <D.16134>;
      <D.16133>:
      D.16042 = il_offset_array->len;
      D.16135 = (int) D.16042;
      *n_il_offsets = D.16135;
      <D.16134>:
      if (il_offsets != 0B) goto <D.16136>; else goto <D.16137>;
      <D.16136>:
      if (line_numbers != 0B) goto <D.16138>; else goto <D.16139>;
      <D.16138>:
      D.16042 = il_offset_array->len;
      D.16107 = (long unsigned int) D.16042;
      D.16108 = D.16107 * 4;
      D.16140 = monoeg_malloc (D.16108);
      *il_offsets = D.16140;
      D.16042 = il_offset_array->len;
      D.16107 = (long unsigned int) D.16042;
      D.16108 = D.16107 * 4;
      D.16141 = monoeg_malloc (D.16108);
      *line_numbers = D.16141;
      i = 0;
      goto <D.15720>;
      <D.15719>:
      D.16142 = *il_offsets;
      D.16111 = (long unsigned int) i;
      D.16124 = D.16111 * 4;
      D.16143 = D.16142 + D.16124;
      D.16144 = il_offset_array->pdata;
      D.16111 = (long unsigned int) i;
      D.16112 = D.16111 * 8;
      D.16145 = D.16144 + D.16112;
      D.16146 = *D.16145;
      D.16147 = (long int) D.16146;
      D.16148 = (int) D.16147;
      *D.16143 = D.16148;
      D.16149 = *line_numbers;
      D.16111 = (long unsigned int) i;
      D.16124 = D.16111 * 4;
      D.16150 = D.16149 + D.16124;
      D.16151 = line_number_array->pdata;
      D.16111 = (long unsigned int) i;
      D.16112 = D.16111 * 8;
      D.16152 = D.16151 + D.16112;
      D.16153 = *D.16152;
      D.16154 = (long int) D.16153;
      D.16155 = (int) D.16154;
      *D.16150 = D.16155;
      i = i + 1;
      <D.15720>:
      D.16042 = il_offset_array->len;
      if (D.16042 > i) goto <D.15719>; else goto <D.15721>;
      <D.15721>:
      <D.16139>:
      <D.16137>:
      if (column_numbers != 0B) goto <D.16156>; else goto <D.16157>;
      <D.16156>:
      if (has_column_info != 0) goto <D.16158>; else goto <D.16159>;
      <D.16158>:
      D.16042 = il_offset_array->len;
      D.16107 = (long unsigned int) D.16042;
      D.16108 = D.16107 * 4;
      D.16160 = monoeg_malloc (D.16108);
      *column_numbers = D.16160;
      i = 0;
      goto <D.15723>;
      <D.15722>:
      D.16161 = *column_numbers;
      D.16111 = (long unsigned int) i;
      D.16124 = D.16111 * 4;
      D.16162 = D.16161 + D.16124;
      ptr.15 = ptr;
      D.16163 = read_leb128 (ptr.15, &ptr);
      *D.16162 = D.16163;
      i = i + 1;
      <D.15723>:
      D.16042 = il_offset_array->len;
      if (D.16042 > i) goto <D.15722>; else goto <D.15724>;
      <D.15724>:
      <D.16159>:
      <D.16157>:
      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.16166;
  gboolean D.16169;
  const uint8_t * D.16170;
  unsigned int D.16171;
  sizetype D.16172;
  const unsigned char * ptr.22;
  const unsigned char * ptr.23;
  int D.16175;
  unsigned int D.16176;
  _Bool D.16177;
  struct MonoSymbolFile * symfile;
  const unsigned char * ptr;
  guint32 flags;

  try
    {
      D.16166 = minfo->handle;
      symfile = D.16166->symfile;
      if (symfile == 0B) goto <D.16167>; else goto <D.16168>;
      <D.16167>:
      D.16169 = 0;
      return D.16169;
      <D.16168>:
      D.16170 = symfile->raw_contents;
      D.16171 = minfo->data_offset;
      D.16172 = (sizetype) D.16171;
      ptr.22 = D.16170 + D.16172;
      ptr = ptr.22;
      ptr.23 = ptr;
      read_leb128 (ptr.23, &ptr);
      ptr.23 = ptr;
      read_leb128 (ptr.23, &ptr);
      ptr.23 = ptr;
      read_leb128 (ptr.23, &ptr);
      ptr.23 = ptr;
      read_leb128 (ptr.23, &ptr);
      ptr.23 = ptr;
      read_leb128 (ptr.23, &ptr);
      ptr.23 = ptr;
      read_leb128 (ptr.23, &ptr);
      ptr.23 = ptr;
      D.16175 = read_leb128 (ptr.23, &ptr);
      flags = (guint32) D.16175;
      D.16176 = flags & 2;
      D.16177 = D.16176 != 0;
      D.16169 = (gboolean) D.16177;
      return D.16169;
    }
  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.16180;
  int D.16183;
  long unsigned int D.16184;
  void * D.16185;
  long unsigned int D.16186;
  void * D.16187;
  int D.16188;
  long unsigned int D.16189;
  void * D.16190;
  int D.16191;
  unsigned int D.16194;
  unsigned int D.16197;

  D.16180 = stm->line;
  if (D.16180 > 0) goto <D.16181>; else goto <D.16182>;
  <D.16181>:
  D.16183 = stm->offset;
  D.16184 = (long unsigned int) D.16183;
  D.16185 = (void *) D.16184;
  monoeg_g_ptr_array_add (il_offset_array, D.16185);
  D.16180 = stm->line;
  D.16186 = (long unsigned int) D.16180;
  D.16187 = (void *) D.16186;
  monoeg_g_ptr_array_add (line_number_array, D.16187);
  D.16188 = stm->file;
  D.16189 = (long unsigned int) D.16188;
  D.16190 = (void *) D.16189;
  monoeg_g_ptr_array_add (source_file_array, D.16190);
  <D.16182>:
  D.16191 = stm->is_hidden;
  if (D.16191 == 0) goto <D.16192>; else goto <D.16193>;
  <D.16192>:
  D.16194 = stm->first_file;
  if (D.16194 == 0) goto <D.16195>; else goto <D.16196>;
  <D.16195>:
  D.16188 = stm->file;
  D.16197 = (unsigned int) D.16188;
  stm->first_file = D.16197;
  <D.16196>:
  <D.16193>:
}


get_source_info (struct MonoSymbolFile * symfile, int index)
{
  struct GHashTable * D.16198;
  long unsigned int D.16199;
  const void * D.16200;
  struct MonoSymbolFileOffsetTable * D.16203;
  uint32_t * D.16204;
  unsigned int D.16205;
  int D.16206;
  long unsigned int D.16207;
  unsigned int D.16208;
  unsigned int D.16209;
  unsigned int D.16210;
  const uint8_t * D.16211;
  sizetype D.16212;
  uint32_t * D.16213;
  unsigned int D.16214;
  sizetype D.16215;
  const uint8_t * ptr.24;
  const uint8_t * ptr.25;
  gchar * D.16218;
  void * D.16219;
  guint8 * D.16220;
  const uint8_t * ptr.26;
  void * D.16222;
  guint8 * D.16223;
  void * D.16224;
  struct MonoDebugSourceInfo * D.16225;
  struct MonoDebugSourceInfo * info;

  D.16198 = symfile->source_hash;
  D.16199 = (long unsigned int) index;
  D.16200 = (const void *) D.16199;
  info = monoeg_g_hash_table_lookup (D.16198, D.16200);
  if (info == 0B) goto <D.16201>; else goto <D.16202>;
  <D.16201>:
  {
    int offset;
    struct MonoSymbolFileSourceEntry * se;
    const uint8_t * ptr;

    try
      {
        D.16203 = symfile->offset_table;
        D.16204 = &D.16203->_source_table_offset;
        D.16205 = MEM[(const guint32 *)D.16204];
        D.16206 = index + -1;
        D.16207 = (long unsigned int) D.16206;
        D.16208 = (unsigned int) D.16207;
        D.16209 = D.16208 * 8;
        D.16210 = D.16205 + D.16209;
        offset = (int) D.16210;
        D.16211 = symfile->raw_contents;
        D.16212 = (sizetype) offset;
        se = D.16211 + D.16212;
        D.16211 = symfile->raw_contents;
        D.16213 = &se->_data_offset;
        D.16214 = MEM[(const guint32 *)D.16213];
        D.16215 = (sizetype) D.16214;
        ptr.24 = D.16211 + D.16215;
        ptr = ptr.24;
        info = monoeg_malloc0 (24);
        ptr.25 = ptr;
        D.16218 = read_string (ptr.25, &ptr);
        info->source_file = D.16218;
        D.16219 = monoeg_malloc0 (16);
        info->guid = D.16219;
        D.16220 = info->guid;
        ptr.25 = ptr;
        memcpy (D.16220, ptr.25, 16);
        ptr.25 = ptr;
        ptr.26 = ptr.25 + 16;
        ptr = ptr.26;
        D.16222 = monoeg_malloc0 (16);
        info->hash = D.16222;
        D.16223 = info->hash;
        ptr.25 = ptr;
        memcpy (D.16223, ptr.25, 16);
        ptr.25 = ptr;
        ptr.26 = ptr.25 + 16;
        ptr = ptr.26;
        D.16198 = symfile->source_hash;
        D.16199 = (long unsigned int) index;
        D.16224 = (void *) D.16199;
        monoeg_g_hash_table_insert_replace (D.16198, D.16224, info, 0);
      }
    finally
      {
        ptr = {CLOBBER};
      }
  }
  <D.16202>:
  D.16225 = info;
  return D.16225;
}


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.16230;
  int32_t D.16231;
  unsigned int D.16232;
  unsigned int D.16233;
  long unsigned int D.16234;
  long unsigned int D.16235;
  struct MonoDebugLineNumberEntry * D.16236;
  unsigned int D.16237;
  unsigned int D.16240;
  int i;

  if (jit == 0B) goto <D.16227>; else goto <D.16229>;
  <D.16229>:
  D.16230 = jit->line_numbers;
  if (D.16230 == 0B) goto <D.16227>; else goto <D.16228>;
  <D.16227>:
  D.16231 = -1;
  return D.16231;
  <D.16228>:
  D.16232 = jit->num_line_numbers;
  D.16233 = D.16232 + 4294967295;
  i = (int) D.16233;
  goto <D.15739>;
  <D.15738>:
  {
    struct MonoDebugLineNumberEntry lne;

    try
      {
        D.16230 = jit->line_numbers;
        D.16234 = (long unsigned int) i;
        D.16235 = D.16234 * 8;
        D.16236 = D.16230 + D.16235;
        lne = *D.16236;
        D.16237 = lne.il_offset;
        if (D.16237 <= il_offset) goto <D.16238>; else goto <D.16239>;
        <D.16238>:
        D.16240 = lne.native_offset;
        D.16231 = (int32_t) D.16240;
        return D.16231;
        <D.16239>:
      }
    finally
      {
        lne = {CLOBBER};
      }
  }
  i = i + -1;
  <D.15739>:
  if (i >= 0) goto <D.15738>; else goto <D.15740>;
  <D.15740>:
  D.16231 = 0;
  return D.16231;
}


mono_debug_symfile_lookup_method (struct MonoDebugHandle * handle, struct MonoMethod * method)
{
  struct GHashTable * D.16244;
  struct MonoDebugMethodInfo * D.16247;
  struct MonoImage * D.16248;
  struct MonoClass * D.16249;
  struct MonoImage * D.16250;
  const uint8_t * D.16255;
  struct MonoSymbolFileOffsetTable * D.16256;
  uint32_t * D.16257;
  unsigned int D.16258;
  sizetype D.16259;
  unsigned int D.16260;
  long unsigned int D.16261;
  const void * D.16262;
  uint32_t * D.16263;
  unsigned int D.16264;
  long unsigned int D.16265;
  long int ie.27;
  long int first_ie.28;
  long int D.16270;
  long int D.16271;
  unsigned int D.16272;
  unsigned int D.16273;
  unsigned int D.16274;
  unsigned int D.16275;
  struct MonoSymbolFileMethodEntry * first_ie;
  struct MonoSymbolFileMethodEntry * ie;
  struct MonoDebugMethodInfo * minfo;
  struct MonoSymbolFile * symfile;

  symfile = handle->symfile;
  D.16244 = symfile->method_hash;
  if (D.16244 == 0B) goto <D.16245>; else goto <D.16246>;
  <D.16245>:
  D.16247 = 0B;
  return D.16247;
  <D.16246>:
  D.16248 = handle->image;
  D.16249 = mono_method_get_class (method);
  D.16250 = mono_class_get_image (D.16249);
  if (D.16248 != D.16250) goto <D.16251>; else goto <D.16252>;
  <D.16251>:
  D.16247 = 0B;
  return D.16247;
  <D.16252>:
  mono_debugger_lock ();
  D.16244 = symfile->method_hash;
  minfo = monoeg_g_hash_table_lookup (D.16244, method);
  if (minfo != 0B) goto <D.16253>; else goto <D.16254>;
  <D.16253>:
  mono_debugger_unlock ();
  D.16247 = minfo;
  return D.16247;
  <D.16254>:
  D.16255 = symfile->raw_contents;
  D.16256 = symfile->offset_table;
  D.16257 = &D.16256->_method_table_offset;
  D.16258 = MEM[(const guint32 *)D.16257];
  D.16259 = (sizetype) D.16258;
  first_ie = D.16255 + D.16259;
  D.16260 = mono_method_get_token (method);
  D.16261 = (long unsigned int) D.16260;
  D.16262 = (const void *) D.16261;
  D.16256 = symfile->offset_table;
  D.16263 = &D.16256->_method_count;
  D.16264 = MEM[(const guint32 *)D.16263];
  D.16265 = (long unsigned int) D.16264;
  ie = mono_binary_search (D.16262, first_ie, D.16265, 12, compare_method);
  if (ie == 0B) goto <D.16266>; else goto <D.16267>;
  <D.16266>:
  mono_debugger_unlock ();
  D.16247 = 0B;
  return D.16247;
  <D.16267>:
  minfo = monoeg_malloc0 (32);
  ie.27 = (long int) ie;
  first_ie.28 = (long int) first_ie;
  D.16270 = ie.27 - first_ie.28;
  D.16271 = D.16270 /[ex] 12;
  D.16272 = (unsigned int) D.16271;
  D.16273 = D.16272 + 1;
  minfo->index = D.16273;
  minfo->method = method;
  minfo->handle = handle;
  D.16274 = ie->_data_offset;
  minfo->data_offset = D.16274;
  D.16275 = ie->_line_number_table;
  minfo->lnt_offset = D.16275;
  D.16244 = symfile->method_hash;
  monoeg_g_hash_table_insert_replace (D.16244, method, minfo, 0);
  mono_debugger_unlock ();
  D.16247 = minfo;
  return D.16247;
}


compare_method (const void * key, const void * object)
{
  long int key.29;
  int D.16278;
  uint32_t * D.16279;
  unsigned int D.16280;
  unsigned int D.16281;
  uint32_t token;
  struct MonoSymbolFileMethodEntry * me;

  key.29 = (long int) key;
  token = (uint32_t) key.29;
  me = object;
  D.16279 = &me->_token;
  D.16280 = MEM[(const guint32 *)D.16279];
  D.16281 = token - D.16280;
  D.16278 = (int) D.16281;
  return D.16278;
}


mono_debug_symfile_lookup_locals (struct MonoDebugMethodInfo * minfo)
{
  struct MonoDebugHandle * D.16283;
  struct MonoDebugLocalsInfo * D.16286;
  const uint8_t * D.16287;
  unsigned int D.16288;
  sizetype D.16289;
  const uint8_t * p.30;
  const uint8_t * p.31;
  sizetype D.16292;
  const uint8_t * p.32;
  int D.16294;
  int D.16295;
  long unsigned int D.16296;
  long unsigned int D.16297;
  void * D.16298;
  struct MonoDebugCodeBlock * D.16299;
  long unsigned int D.16300;
  long unsigned int D.16301;
  struct MonoDebugCodeBlock * D.16302;
  int D.16303;
  int D.16304;
  int D.16305;
  int D.16306;
  sizetype D.16307;
  const uint8_t * p.33;
  long unsigned int D.16309;
  long unsigned int D.16310;
  void * D.16311;
  struct MonoDebugLocalVar * D.16312;
  long unsigned int D.16313;
  struct MonoDebugLocalVar * D.16314;
  int D.16315;
  int D.16316;
  long unsigned int D.16317;
  void * D.16318;
  char * D.16319;
  long unsigned int D.16320;
  sizetype D.16321;
  char * D.16322;
  const uint8_t * p.34;
  long unsigned int D.16328;
  long unsigned int D.16329;
  sizetype D.16330;
  struct MonoDebugCodeBlock * D.16331;
  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.16283 = minfo->handle;
      symfile = D.16283->symfile;
      if (symfile == 0B) goto <D.16284>; else goto <D.16285>;
      <D.16284>:
      D.16286 = 0B;
      return D.16286;
      <D.16285>:
      D.16287 = symfile->raw_contents;
      D.16288 = minfo->data_offset;
      D.16289 = (sizetype) D.16288;
      p.30 = D.16287 + D.16289;
      p = p.30;
      p.31 = p;
      compile_unit_index = read_leb128 (p.31, &p);
      p.31 = p;
      locals_offset = read_leb128 (p.31, &p);
      p.31 = p;
      namespace_id = read_leb128 (p.31, &p);
      p.31 = p;
      code_block_table_offset = read_leb128 (p.31, &p);
      res = monoeg_malloc0 (32);
      D.16287 = symfile->raw_contents;
      D.16292 = (sizetype) code_block_table_offset;
      p.32 = D.16287 + D.16292;
      p = p.32;
      p.31 = p;
      D.16294 = read_leb128 (p.31, &p);
      res->num_blocks = D.16294;
      D.16295 = res->num_blocks;
      D.16296 = (long unsigned int) D.16295;
      D.16297 = D.16296 * 16;
      D.16298 = monoeg_malloc0 (D.16297);
      res->code_blocks = D.16298;
      i = 0;
      goto <D.15770>;
      <D.15769>:
      D.16299 = res->code_blocks;
      D.16300 = (long unsigned int) i;
      D.16301 = D.16300 * 16;
      D.16302 = D.16299 + D.16301;
      p.31 = p;
      D.16303 = read_leb128 (p.31, &p);
      D.16302->type = D.16303;
      D.16299 = res->code_blocks;
      D.16300 = (long unsigned int) i;
      D.16301 = D.16300 * 16;
      D.16302 = D.16299 + D.16301;
      p.31 = p;
      D.16304 = read_leb128 (p.31, &p);
      D.16302->parent = D.16304;
      D.16299 = res->code_blocks;
      D.16300 = (long unsigned int) i;
      D.16301 = D.16300 * 16;
      D.16302 = D.16299 + D.16301;
      p.31 = p;
      D.16305 = read_leb128 (p.31, &p);
      D.16302->start_offset = D.16305;
      D.16299 = res->code_blocks;
      D.16300 = (long unsigned int) i;
      D.16301 = D.16300 * 16;
      D.16302 = D.16299 + D.16301;
      p.31 = p;
      D.16306 = read_leb128 (p.31, &p);
      D.16302->end_offset = D.16306;
      i = i + 1;
      <D.15770>:
      D.16295 = res->num_blocks;
      if (D.16295 > i) goto <D.15769>; else goto <D.15771>;
      <D.15771>:
      D.16287 = symfile->raw_contents;
      D.16307 = (sizetype) locals_offset;
      p.33 = D.16287 + D.16307;
      p = p.33;
      p.31 = p;
      num_locals = read_leb128 (p.31, &p);
      res->num_locals = num_locals;
      D.16309 = (long unsigned int) num_locals;
      D.16310 = D.16309 * 24;
      D.16311 = monoeg_malloc0 (D.16310);
      res->locals = D.16311;
      i = 0;
      goto <D.15773>;
      <D.15772>:
      D.16312 = res->locals;
      D.16300 = (long unsigned int) i;
      D.16313 = D.16300 * 24;
      D.16314 = D.16312 + D.16313;
      p.31 = p;
      D.16315 = read_leb128 (p.31, &p);
      D.16314->index = D.16315;
      p.31 = p;
      len = read_leb128 (p.31, &p);
      D.16312 = res->locals;
      D.16300 = (long unsigned int) i;
      D.16313 = D.16300 * 24;
      D.16314 = D.16312 + D.16313;
      D.16316 = len + 1;
      D.16317 = (long unsigned int) D.16316;
      D.16318 = monoeg_malloc (D.16317);
      D.16314->name = D.16318;
      D.16312 = res->locals;
      D.16300 = (long unsigned int) i;
      D.16313 = D.16300 * 24;
      D.16314 = D.16312 + D.16313;
      D.16319 = D.16314->name;
      p.31 = p;
      D.16320 = (long unsigned int) len;
      memcpy (D.16319, p.31, D.16320);
      D.16312 = res->locals;
      D.16300 = (long unsigned int) i;
      D.16313 = D.16300 * 24;
      D.16314 = D.16312 + D.16313;
      D.16319 = D.16314->name;
      D.16321 = (sizetype) len;
      D.16322 = D.16319 + D.16321;
      *D.16322 = 0;
      p.31 = p;
      D.16321 = (sizetype) len;
      p.34 = p.31 + D.16321;
      p = p.34;
      p.31 = p;
      block_index = read_leb128 (p.31, &p);
      if (block_index > 0) goto <D.16324>; else goto <D.16325>;
      <D.16324>:
      D.16295 = res->num_blocks;
      if (D.16295 >= block_index) goto <D.16326>; else goto <D.16327>;
      <D.16326>:
      D.16312 = res->locals;
      D.16300 = (long unsigned int) i;
      D.16313 = D.16300 * 24;
      D.16314 = D.16312 + D.16313;
      D.16299 = res->code_blocks;
      D.16328 = (long unsigned int) block_index;
      D.16329 = D.16328 * 16;
      D.16330 = D.16329 + 18446744073709551600;
      D.16331 = D.16299 + D.16330;
      D.16314->block = D.16331;
      <D.16327>:
      <D.16325>:
      i = i + 1;
      <D.15773>:
      if (i < num_locals) goto <D.15772>; else goto <D.15774>;
      <D.15774>:
      D.16286 = res;
      return D.16286;
    }
  finally
    {
      p = {CLOBBER};
    }
}


mono_debug_symfile_free_locals (struct MonoDebugLocalsInfo * info)
{
  struct MonoDebugLocalVar * D.16334;
  long unsigned int D.16335;
  long unsigned int D.16336;
  struct MonoDebugLocalVar * D.16337;
  char * D.16338;
  int D.16339;
  struct MonoDebugCodeBlock * D.16340;
  int i;

  i = 0;
  goto <D.15780>;
  <D.15779>:
  D.16334 = info->locals;
  D.16335 = (long unsigned int) i;
  D.16336 = D.16335 * 24;
  D.16337 = D.16334 + D.16336;
  D.16338 = D.16337->name;
  monoeg_g_free (D.16338);
  i = i + 1;
  <D.15780>:
  D.16339 = info->num_locals;
  if (D.16339 > i) goto <D.15779>; else goto <D.15781>;
  <D.15781>:
  D.16334 = info->locals;
  monoeg_g_free (D.16334);
  D.16340 = info->code_blocks;
  monoeg_g_free (D.16340);
  monoeg_g_free (info);
}