mono_aot_register_globals (void * * globals)
{
  monoeg_assertion_message ("* Assertion: should not be reached at %s:%d\n", "aot-runtime.c", 1872);
}


mono_aot_register_module (void * * aot_info)
{
  unsigned int D.24578;
  _Bool D.24579;
  long int D.24580;
  long int D.24581;
  _Bool D.24584;
  long int D.24585;
  long int D.24586;
  struct GHashTable * aot_modules.0;
  _Bool D.24594;
  long int D.24595;
  long int D.24596;
  struct GHashTable * static_aot_modules.1;
  struct GHashTable * D.24602;
  _Bool D.24607;
  long int D.24608;
  long int D.24609;
  void * * globals;
  char * aname;
  struct MonoAotFileInfo * info;

  info = aot_info;
  D.24578 = info->version;
  D.24579 = D.24578 != 97;
  D.24580 = (long int) D.24579;
  D.24581 = __builtin_expect (D.24580, 0);
  if (D.24581 != 0) goto <D.24582>; else goto <D.24583>;
  <D.24582>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "aot-runtime.c", 1889, "info->version == MONO_AOT_FILE_VERSION");
  <D.24583>:
  globals = info->globals;
  D.24584 = globals == 0B;
  D.24585 = (long int) D.24584;
  D.24586 = __builtin_expect (D.24585, 0);
  if (D.24586 != 0) goto <D.24587>; else goto <D.24588>;
  <D.24587>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "aot-runtime.c", 1892, "globals");
  <D.24588>:
  aname = info->assembly_name;
  aot_modules.0 = aot_modules;
  if (aot_modules.0 != 0B) goto <D.24590>; else goto <D.24591>;
  <D.24590>:
  {
    int ret;

    ret = pthread_mutex_lock (&aot_mutex.mutex);
    if (ret != 0) goto <D.24592>; else goto <D.24593>;
    <D.24592>:
    monoeg_g_log (0B, 16, "Bad call to mono_mutex_lock result %d", ret);
    <D.24593>:
    D.24594 = ret != 0;
    D.24595 = (long int) D.24594;
    D.24596 = __builtin_expect (D.24595, 0);
    if (D.24596 != 0) goto <D.24597>; else goto <D.24598>;
    <D.24597>:
    monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "aot-runtime.c", 1898, "ret == 0");
    <D.24598>:
  }
  <D.24591>:
  static_aot_modules.1 = static_aot_modules;
  if (static_aot_modules.1 == 0B) goto <D.24600>; else goto <D.24601>;
  <D.24600>:
  D.24602 = monoeg_g_hash_table_new (monoeg_g_str_hash, monoeg_g_str_equal);
  static_aot_modules = D.24602;
  <D.24601>:
  static_aot_modules.1 = static_aot_modules;
  monoeg_g_hash_table_insert_replace (static_aot_modules.1, aname, info, 0);
  aot_modules.0 = aot_modules;
  if (aot_modules.0 != 0B) goto <D.24603>; else goto <D.24604>;
  <D.24603>:
  {
    int ret;

    ret = pthread_mutex_unlock (&aot_mutex.mutex);
    if (ret != 0) goto <D.24605>; else goto <D.24606>;
    <D.24605>:
    monoeg_g_log (0B, 16, "Bad call to mono_mutex_unlock result %d", ret);
    <D.24606>:
    D.24607 = ret != 0;
    D.24608 = (long int) D.24607;
    D.24609 = __builtin_expect (D.24608, 0);
    if (D.24609 != 0) goto <D.24610>; else goto <D.24611>;
    <D.24610>:
    monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "aot-runtime.c", 1906, "ret == 0");
    <D.24611>:
  }
  <D.24604>:
}


__attribute__((visibility ("hidden")))
mono_aot_init ()
{
  struct GHashTable * D.24612;
  const gchar * D.24613;
  const gchar * D.24616;
  int D.24617;
  const gchar * D.24618;

  InitializeCriticalSection (&aot_mutex);
  InitializeCriticalSection (&aot_page_mutex);
  D.24612 = monoeg_g_hash_table_new (0B, 0B);
  aot_modules = D.24612;
  mono_install_assembly_load_hook (load_aot_module, 0B);
  mono_counters_register ("Async JIT info size", 256, &async_jit_info_size);
  D.24613 = monoeg_g_getenv ("MONO_LASTAOT");
  if (D.24613 != 0B) goto <D.24614>; else goto <D.24615>;
  <D.24614>:
  D.24616 = monoeg_g_getenv ("MONO_LASTAOT");
  D.24617 = atoi (D.24616);
  mono_last_aot_method = D.24617;
  <D.24615>:
  D.24618 = monoeg_g_getenv ("MONO_AOT_CACHE");
  if (D.24618 != 0B) goto <D.24619>; else goto <D.24620>;
  <D.24619>:
  use_aot_cache = 1;
  <D.24620>:
}


load_aot_module (struct MonoAssembly * assembly, void * user_data)
{
  int mono_compile_aot.2;
  struct MonoImage * D.24624;
  void * D.24625;
  long unsigned int D.24630;
  long unsigned int D.24631;
  int D.24633;
  <unnamed type> D.24634;
  _Bool D.24639;
  long int D.24640;
  long int D.24641;
  struct GHashTable * static_aot_modules.3;
  const char * D.24647;
  void * info.4;
  _Bool D.24652;
  long int D.24653;
  long int D.24654;
  struct MonoAotFileInfo * info.5;
  gchar * aot_name.6;
  char * aot_name.7;
  int use_aot_cache.8;
  char * D.24667;
  gchar * aot_name.9;
  char * err.10;
  int mono_aot_only.11;
  long unsigned int D.24679;
  long unsigned int D.24680;
  struct _IO_FILE * stderr.12;
  char * version_symbol.13;
  _Bool D.24690;
  long int D.24691;
  long int D.24692;
  unsigned int D.24695;
  gchar * msg.14;
  char * msg.15;
  unsigned int D.24707;
  unsigned int align_double.16;
  _Bool D.24709;
  long int D.24710;
  long int D.24711;
  unsigned int D.24714;
  unsigned int align_int64.17;
  _Bool D.24716;
  long int D.24717;
  long int D.24718;
  unsigned int D.24721;
  _Bool D.24722;
  long int D.24723;
  long int D.24724;
  struct MonoAotFileInfo * D.24727;
  void * D.24728;
  void * * D.24729;
  struct GHashTable * D.24730;
  _Bool D.24731;
  long int D.24732;
  long int D.24733;
  long unsigned int D.24736;
  long unsigned int D.24737;
  void * D.24738;
  long unsigned int D.24739;
  void * D.24740;
  void * D.24741;
  struct MonoAssemblyName * D.24742;
  long unsigned int D.24743;
  long unsigned int D.24744;
  gchar * D.24745;
  long unsigned int D.24746;
  long unsigned int D.24747;
  char * * D.24748;
  long unsigned int D.24749;
  char * * D.24750;
  gchar * D.24751;
  long unsigned int D.24752;
  long unsigned int D.24753;
  char D.24754;
  gchar * D.24757;
  long unsigned int D.24758;
  long unsigned int D.24759;
  mono_byte[17] * D.24760;
  long unsigned int D.24761;
  long unsigned int D.24762;
  long unsigned int D.24763;
  long unsigned int D.24764;
  long int table.18;
  long int D.24766;
  long int D.24767;
  unsigned int D.24768;
  short unsigned int D.24769;
  void * D.24770;
  void * D.24771;
  void * D.24772;
  void * D.24773;
  void * D.24774;
  void * D.24775;
  void * D.24776;
  void * D.24777;
  void * D.24778;
  void * D.24779;
  void * D.24780;
  void * D.24781;
  void * D.24782;
  void * D.24783;
  void * D.24784;
  guint8 * D.24785;
  void * D.24786;
  void * D.24787;
  void * D.24788;
  void * D.24789;
  void * D.24790;
  void * D.24791;
  void * D.24792;
  void * D.24793;
  int make_unreadable.19;
  guint8 * D.24797;
  long int D.24798;
  guint8 * D.24799;
  long int D.24800;
  long int D.24801;
  int D.24802;
  sizetype D.24803;
  int D.24804;
  int D.24805;
  int D.24806;
  long int D.24807;
  long int addr.20;
  long int D.24809;
  sizetype D.24810;
  sizetype D.24811;
  sizetype D.24812;
  guint8 * D.24813;
  long int D.24814;
  int D.24815;
  int D.24816;
  int D.24817;
  long int D.24818;
  long int D.24819;
  long int page_end.21;
  long int page_start.22;
  long int D.24824;
  long unsigned int D.24825;
  _Bool D.24826;
  long int D.24827;
  long int D.24828;
  _Bool D.24833;
  long int D.24834;
  long int D.24835;
  long unsigned int D.24838;
  long unsigned int aot_code_low_addr.23;
  long unsigned int D.24840;
  guint8 * D.24841;
  long unsigned int D.24842;
  long unsigned int aot_code_high_addr.24;
  long unsigned int D.24844;
  struct GHashTable * aot_modules.25;
  _Bool D.24848;
  long int D.24849;
  long int D.24850;
  struct MonoDl * D.24855;
  void * * D.24856;
  char * code.26;
  _Bool D.24858;
  int D.24859;
  struct MonoImage * D.24860;
  void * * D.24863;
  void * * D.24864;
  int D.24866;
  void * * D.24869;
  struct MonoDomain * D.24870;
  void * D.24871;
  unsigned int D.24874;
  unsigned int i.27;
  int D.24876;
  char * aot_name;
  struct MonoAotModule * amodule;
  struct MonoDl * sofile;
  gboolean usable;
  char * version_symbol;
  char * msg;
  void * * globals;
  struct MonoAotFileInfo * info;
  int i;
  int version;
  guint8 * blob;
  gboolean do_load_image;
  int align_double;
  int align_int64;

  try
    {
      usable = 1;
      version_symbol = 0B;
      msg = 0B;
      globals = 0B;
      info = 0B;
      do_load_image = 1;
      mono_compile_aot.2 = mono_compile_aot;
      if (mono_compile_aot.2 != 0) goto <D.24622>; else goto <D.24623>;
      <D.24622>:
      return;
      <D.24623>:
      D.24624 = assembly->image;
      D.24625 = D.24624->aot_module;
      if (D.24625 != 0B) goto <D.24626>; else goto <D.24627>;
      <D.24626>:
      return;
      <D.24627>:
      D.24624 = assembly->image;
      D.24630 = BIT_FIELD_REF <*D.24624, 64, 192>;
      D.24631 = D.24630 & 268435456;
      if (D.24631 != 0) goto <D.24628>; else goto <D.24632>;
      <D.24632>:
      D.24633 = assembly->ref_only;
      if (D.24633 != 0) goto <D.24628>; else goto <D.24629>;
      <D.24628>:
      return;
      <D.24629>:
      D.24634 = mono_security_get_mode ();
      if (D.24634 == 2) goto <D.24635>; else goto <D.24636>;
      <D.24635>:
      return;
      <D.24636>:
      {
        int ret;

        ret = pthread_mutex_lock (&aot_mutex.mutex);
        if (ret != 0) goto <D.24637>; else goto <D.24638>;
        <D.24637>:
        monoeg_g_log (0B, 16, "Bad call to mono_mutex_lock result %d", ret);
        <D.24638>:
        D.24639 = ret != 0;
        D.24640 = (long int) D.24639;
        D.24641 = __builtin_expect (D.24640, 0);
        if (D.24641 != 0) goto <D.24642>; else goto <D.24643>;
        <D.24642>:
        monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "aot-runtime.c", 1577, "ret == 0");
        <D.24643>:
      }
      static_aot_modules.3 = static_aot_modules;
      if (static_aot_modules.3 != 0B) goto <D.24645>; else goto <D.24646>;
      <D.24645>:
      static_aot_modules.3 = static_aot_modules;
      D.24647 = assembly->aname.name;
      info.4 = monoeg_g_hash_table_lookup (static_aot_modules.3, D.24647);
      info = info.4;
      goto <D.24649>;
      <D.24646>:
      info = 0B;
      <D.24649>:
      {
        int ret;

        ret = pthread_mutex_unlock (&aot_mutex.mutex);
        if (ret != 0) goto <D.24650>; else goto <D.24651>;
        <D.24650>:
        monoeg_g_log (0B, 16, "Bad call to mono_mutex_unlock result %d", ret);
        <D.24651>:
        D.24652 = ret != 0;
        D.24653 = (long int) D.24652;
        D.24654 = __builtin_expect (D.24653, 0);
        if (D.24654 != 0) goto <D.24655>; else goto <D.24656>;
        <D.24655>:
        monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "aot-runtime.c", 1582, "ret == 0");
        <D.24656>:
      }
      info.5 = info;
      if (info.5 != 0B) goto <D.24658>; else goto <D.24659>;
      <D.24658>:
      sofile = 0B;
      D.24647 = assembly->aname.name;
      aot_name.6 = monoeg_g_strdup_printf ("%s", D.24647);
      aot_name = aot_name.6;
      aot_name.7 = aot_name;
      mono_trace (64, 32, "Found statically linked AOT module \'%s\'.\n", aot_name.7);
      info.5 = info;
      globals = info.5->globals;
      goto <D.24662>;
      <D.24659>:
      use_aot_cache.8 = use_aot_cache;
      if (use_aot_cache.8 != 0) goto <D.24664>; else goto <D.24665>;
      <D.24664>:
      sofile = load_aot_module_from_cache (assembly, &aot_name);
      goto <D.24666>;
      <D.24665>:
      {
        char * err;

        try
          {
            D.24624 = assembly->image;
            D.24667 = D.24624->name;
            aot_name.9 = monoeg_g_strdup_printf ("%s%s", D.24667, ".so");
            aot_name = aot_name.9;
            aot_name.7 = aot_name;
            sofile = mono_dl_open (aot_name.7, 1, &err);
            if (sofile == 0B) goto <D.24669>; else goto <D.24670>;
            <D.24669>:
            aot_name.7 = aot_name;
            err.10 = err;
            mono_trace (64, 32, "AOT module \'%s\' not found: %s\n", aot_name.7, err.10);
            err.10 = err;
            monoeg_g_free (err.10);
            <D.24670>:
          }
        finally
          {
            err = {CLOBBER};
          }
      }
      <D.24666>:
      <D.24662>:
      if (sofile == 0B) goto <D.24672>; else goto <D.24673>;
      <D.24672>:
      if (globals == 0B) goto <D.24674>; else goto <D.24675>;
      <D.24674>:
      mono_aot_only.11 = mono_aot_only;
      if (mono_aot_only.11 != 0) goto <D.24677>; else goto <D.24678>;
      <D.24677>:
      D.24624 = assembly->image;
      D.24679 = BIT_FIELD_REF <*D.24624, 64, 2368>;
      D.24680 = D.24679 & 18446742974197923840;
      if (D.24680 != 0) goto <D.24681>; else goto <D.24682>;
      <D.24681>:
      stderr.12 = stderr;
      aot_name.7 = aot_name;
      fprintf (stderr.12, "Failed to load AOT module \'%s\' in aot-only mode.\n", aot_name.7);
      exit (1);
      <D.24682>:
      <D.24678>:
      aot_name.7 = aot_name;
      monoeg_g_free (aot_name.7);
      return;
      <D.24675>:
      <D.24673>:
      info.5 = info;
      if (info.5 == 0B) goto <D.24684>; else goto <D.24685>;
      <D.24684>:
      find_symbol (sofile, globals, "mono_aot_version", &version_symbol);
      find_symbol (sofile, globals, "mono_aot_file_info", &info);
      <D.24685>:
      version_symbol.13 = version_symbol;
      if (version_symbol.13 != 0B) goto <D.24687>; else goto <D.24688>;
      <D.24687>:
      version_symbol.13 = version_symbol;
      version = atoi (version_symbol.13);
      goto <D.24689>;
      <D.24688>:
      info.5 = info;
      D.24690 = info.5 == 0B;
      D.24691 = (long int) D.24690;
      D.24692 = __builtin_expect (D.24691, 0);
      if (D.24692 != 0) goto <D.24693>; else goto <D.24694>;
      <D.24693>:
      monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "aot-runtime.c", 1624, "info");
      <D.24694>:
      info.5 = info;
      D.24695 = info.5->version;
      version = (int) D.24695;
      <D.24689>:
      if (version != 97) goto <D.24696>; else goto <D.24697>;
      <D.24696>:
      msg.14 = monoeg_g_strdup_printf ("wrong file format version (expected %d got %d)", 97, version);
      msg = msg.14;
      usable = 0;
      goto <D.24699>;
      <D.24697>:
      info.5 = info;
      usable = check_usable (assembly, info.5, &msg);
      <D.24699>:
      if (usable == 0) goto <D.24700>; else goto <D.24701>;
      <D.24700>:
      mono_aot_only.11 = mono_aot_only;
      if (mono_aot_only.11 != 0) goto <D.24702>; else goto <D.24703>;
      <D.24702>:
      stderr.12 = stderr;
      aot_name.7 = aot_name;
      msg.15 = msg;
      fprintf (stderr.12, "Failed to load AOT module \'%s\' while running in aot-only mode: %s.\n", aot_name.7, msg.15);
      exit (1);
      <D.24703>:
      aot_name.7 = aot_name;
      msg.15 = msg;
      mono_trace (64, 32, "AOT module %s is unusable: %s.\n", aot_name.7, msg.15);
      msg.15 = msg;
      monoeg_g_free (msg.15);
      aot_name.7 = aot_name;
      monoeg_g_free (aot_name.7);
      if (sofile != 0B) goto <D.24705>; else goto <D.24706>;
      <D.24705>:
      mono_dl_close (sofile);
      <D.24706>:
      D.24624 = assembly->image;
      D.24624->aot_module = 0B;
      return;
      <D.24701>:
      align_double = 8;
      align_int64 = 8;
      info.5 = info;
      D.24707 = info.5->double_align;
      align_double.16 = (unsigned int) align_double;
      D.24709 = D.24707 != align_double.16;
      D.24710 = (long int) D.24709;
      D.24711 = __builtin_expect (D.24710, 0);
      if (D.24711 != 0) goto <D.24712>; else goto <D.24713>;
      <D.24712>:
      monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "aot-runtime.c", 1670, "info->double_align == align_double");
      <D.24713>:
      info.5 = info;
      D.24714 = info.5->long_align;
      align_int64.17 = (unsigned int) align_int64;
      D.24716 = D.24714 != align_int64.17;
      D.24717 = (long int) D.24716;
      D.24718 = __builtin_expect (D.24717, 0);
      if (D.24718 != 0) goto <D.24719>; else goto <D.24720>;
      <D.24719>:
      monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "aot-runtime.c", 1671, "info->long_align == align_int64");
      <D.24720>:
      info.5 = info;
      D.24721 = info.5->generic_tramp_num;
      D.24722 = D.24721 != 14;
      D.24723 = (long int) D.24722;
      D.24724 = __builtin_expect (D.24723, 0);
      if (D.24724 != 0) goto <D.24725>; else goto <D.24726>;
      <D.24725>:
      monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "aot-runtime.c", 1672, "info->generic_tramp_num == MONO_TRAMPOLINE_NUM");
      <D.24726>:
      info.5 = info;
      blob = info.5->blob;
      amodule = monoeg_malloc0 (736);
      aot_name.7 = aot_name;
      amodule->aot_name = aot_name.7;
      amodule->assembly = assembly;
      D.24727 = &amodule->info;
      info.5 = info;
      memcpy (D.24727, info.5, 368);
      D.24728 = amodule->info.got;
      amodule->got = D.24728;
      D.24729 = amodule->got;
      D.24624 = assembly->image;
      *D.24729 = D.24624;
      amodule->globals = globals;
      amodule->sofile = sofile;
      D.24730 = monoeg_g_hash_table_new (mono_aligned_addr_hash, 0B);
      amodule->method_to_code = D.24730;
      amodule->blob = blob;
      {
        guint32 table_len;
        guint32 i;
        char * table;

        table = 0B;
        info.5 = info;
        table = info.5->image_table;
        D.24731 = table == 0B;
        D.24732 = (long int) D.24731;
        D.24733 = __builtin_expect (D.24732, 0);
        if (D.24733 != 0) goto <D.24734>; else goto <D.24735>;
        <D.24734>:
        monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "aot-runtime.c", 1695, "table");
        <D.24735>:
        table_len = MEM[(guint32 *)table];
        table = table + 4;
        D.24736 = (long unsigned int) table_len;
        D.24737 = D.24736 * 8;
        D.24738 = monoeg_malloc0 (D.24737);
        amodule->image_table = D.24738;
        D.24736 = (long unsigned int) table_len;
        D.24739 = D.24736 * 80;
        D.24740 = monoeg_malloc0 (D.24739);
        amodule->image_names = D.24740;
        D.24736 = (long unsigned int) table_len;
        D.24737 = D.24736 * 8;
        D.24741 = monoeg_malloc0 (D.24737);
        amodule->image_guids = D.24741;
        amodule->image_table_len = table_len;
        i = 0;
        goto <D.23731>;
        <D.23730>:
        {
          struct MonoAssemblyName * aname;

          D.24742 = amodule->image_names;
          D.24743 = (long unsigned int) i;
          D.24744 = D.24743 * 80;
          aname = D.24742 + D.24744;
          D.24745 = monoeg_strdup (table);
          aname->name = D.24745;
          D.24746 = __strlen_g (table);
          D.24747 = D.24746 + 1;
          table = table + D.24747;
          D.24748 = amodule->image_guids;
          D.24743 = (long unsigned int) i;
          D.24749 = D.24743 * 8;
          D.24750 = D.24748 + D.24749;
          D.24751 = monoeg_strdup (table);
          *D.24750 = D.24751;
          D.24752 = __strlen_g (table);
          D.24753 = D.24752 + 1;
          table = table + D.24753;
          D.24754 = *table;
          if (D.24754 != 0) goto <D.24755>; else goto <D.24756>;
          <D.24755>:
          D.24757 = monoeg_strdup (table);
          aname->culture = D.24757;
          <D.24756>:
          D.24758 = __strlen_g (table);
          D.24759 = D.24758 + 1;
          table = table + D.24759;
          D.24760 = &aname->public_key_token;
          D.24761 = __strlen_g (table);
          D.24762 = D.24761 + 1;
          memcpy (D.24760, table, D.24762);
          D.24763 = __strlen_g (table);
          D.24764 = D.24763 + 1;
          table = table + D.24764;
          table.18 = (long int) table;
          D.24766 = table.18 + 7;
          D.24767 = D.24766 & -8;
          table = (char *) D.24767;
          D.24768 = MEM[(guint32 *)table];
          aname->flags = D.24768;
          table = table + 4;
          D.24768 = MEM[(guint32 *)table];
          D.24769 = (short unsigned int) D.24768;
          aname->major = D.24769;
          table = table + 4;
          D.24768 = MEM[(guint32 *)table];
          D.24769 = (short unsigned int) D.24768;
          aname->minor = D.24769;
          table = table + 4;
          D.24768 = MEM[(guint32 *)table];
          D.24769 = (short unsigned int) D.24768;
          aname->build = D.24769;
          table = table + 4;
          D.24768 = MEM[(guint32 *)table];
          D.24769 = (short unsigned int) D.24768;
          aname->revision = D.24769;
          table = table + 4;
        }
        i = i + 1;
        <D.23731>:
        if (i < table_len) goto <D.23730>; else goto <D.23732>;
        <D.23732>:
      }
      info.5 = info;
      D.24770 = info.5->code_offsets;
      amodule->code_offsets = D.24770;
      info.5 = info;
      D.24771 = info.5->method_addresses;
      amodule->method_addresses = D.24771;
      info.5 = info;
      D.24772 = info.5->methods;
      amodule->code = D.24772;
      info.5 = info;
      D.24773 = info.5->methods_end;
      amodule->code_end = D.24773;
      info.5 = info;
      D.24774 = info.5->method_info_offsets;
      amodule->method_info_offsets = D.24774;
      info.5 = info;
      D.24775 = info.5->ex_info_offsets;
      amodule->ex_info_offsets = D.24775;
      info.5 = info;
      D.24776 = info.5->class_info_offsets;
      amodule->class_info_offsets = D.24776;
      info.5 = info;
      D.24777 = info.5->class_name_table;
      amodule->class_name_table = D.24777;
      info.5 = info;
      D.24778 = info.5->extra_method_table;
      amodule->extra_method_table = D.24778;
      info.5 = info;
      D.24779 = info.5->extra_method_info_offsets;
      amodule->extra_method_info_offsets = D.24779;
      info.5 = info;
      D.24780 = info.5->unbox_trampolines;
      amodule->unbox_trampolines = D.24780;
      info.5 = info;
      D.24781 = info.5->unbox_trampolines_end;
      amodule->unbox_trampolines_end = D.24781;
      info.5 = info;
      D.24782 = info.5->got_info_offsets;
      amodule->got_info_offsets = D.24782;
      info.5 = info;
      D.24783 = info.5->unwind_info;
      amodule->unwind_info = D.24783;
      info.5 = info;
      D.24784 = info.5->mem_end;
      amodule->mem_end = D.24784;
      D.24785 = amodule->code;
      amodule->mem_begin = D.24785;
      info.5 = info;
      D.24786 = info.5->plt;
      amodule->plt = D.24786;
      info.5 = info;
      D.24787 = info.5->plt_end;
      amodule->plt_end = D.24787;
      info.5 = info;
      D.24788 = info.5->mono_eh_frame;
      amodule->mono_eh_frame = D.24788;
      info.5 = info;
      D.24789 = info.5->specific_trampolines;
      amodule->trampolines[0] = D.24789;
      info.5 = info;
      D.24790 = info.5->static_rgctx_trampolines;
      amodule->trampolines[1] = D.24790;
      info.5 = info;
      D.24791 = info.5->imt_thunks;
      amodule->trampolines[2] = D.24791;
      info.5 = info;
      D.24792 = info.5->gsharedvt_arg_trampolines;
      amodule->trampolines[3] = D.24792;
      info.5 = info;
      D.24793 = info.5->thumb_end;
      amodule->thumb_end = D.24793;
      make_unreadable.19 = make_unreadable;
      if (make_unreadable.19 != 0) goto <D.24795>; else goto <D.24796>;
      <D.24795>:
      {
        guint8 * addr;
        guint8 * page_start;
        guint8 * page_end;
        int err;
        int len;

        addr = amodule->mem_begin;
        D.24797 = amodule->mem_end;
        D.24798 = (long int) D.24797;
        D.24799 = amodule->mem_begin;
        D.24800 = (long int) D.24799;
        D.24801 = D.24798 - D.24800;
        len = (int) D.24801;
        D.24802 = mono_pagesize ();
        D.24803 = (sizetype) D.24802;
        D.24804 = mono_pagesize ();
        D.24805 = D.24804 + -1;
        D.24806 = ~D.24805;
        D.24807 = (long int) D.24806;
        addr.20 = (long int) addr;
        D.24809 = D.24807 & addr.20;
        D.24810 = (sizetype) D.24809;
        D.24811 = D.24803 + D.24810;
        page_start = (guint8 *) D.24811;
        D.24812 = (sizetype) len;
        D.24813 = addr + D.24812;
        D.24814 = (long int) D.24813;
        D.24815 = mono_pagesize ();
        D.24816 = D.24815 + -1;
        D.24817 = ~D.24816;
        D.24818 = (long int) D.24817;
        D.24819 = D.24814 & D.24818;
        page_end = (guint8 *) D.24819;
        if (page_end > page_start) goto <D.24820>; else goto <D.24821>;
        <D.24820>:
        page_end.21 = (long int) page_end;
        page_start.22 = (long int) page_start;
        D.24824 = page_end.21 - page_start.22;
        D.24825 = (long unsigned int) D.24824;
        err = mono_mprotect (page_start, D.24825, 0);
        D.24826 = err != 0;
        D.24827 = (long int) D.24826;
        D.24828 = __builtin_expect (D.24827, 0);
        if (D.24828 != 0) goto <D.24829>; else goto <D.24830>;
        <D.24829>:
        monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "aot-runtime.c", 1789, "err == 0");
        <D.24830>:
        <D.24821>:
      }
      <D.24796>:
      {
        int ret;

        ret = pthread_mutex_lock (&aot_mutex.mutex);
        if (ret != 0) goto <D.24831>; else goto <D.24832>;
        <D.24831>:
        monoeg_g_log (0B, 16, "Bad call to mono_mutex_lock result %d", ret);
        <D.24832>:
        D.24833 = ret != 0;
        D.24834 = (long int) D.24833;
        D.24835 = __builtin_expect (D.24834, 0);
        if (D.24835 != 0) goto <D.24836>; else goto <D.24837>;
        <D.24836>:
        monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "aot-runtime.c", 1794, "ret == 0");
        <D.24837>:
      }
      D.24785 = amodule->code;
      D.24838 = (long unsigned int) D.24785;
      aot_code_low_addr.23 = aot_code_low_addr;
      D.24840 = MIN_EXPR <D.24838, aot_code_low_addr.23>;
      aot_code_low_addr = D.24840;
      D.24841 = amodule->code_end;
      D.24842 = (long unsigned int) D.24841;
      aot_code_high_addr.24 = aot_code_high_addr;
      D.24844 = MAX_EXPR <D.24842, aot_code_high_addr.24>;
      aot_code_high_addr = D.24844;
      aot_modules.25 = aot_modules;
      monoeg_g_hash_table_insert_replace (aot_modules.25, assembly, amodule, 0);
      {
        int ret;

        ret = pthread_mutex_unlock (&aot_mutex.mutex);
        if (ret != 0) goto <D.24846>; else goto <D.24847>;
        <D.24846>:
        monoeg_g_log (0B, 16, "Bad call to mono_mutex_unlock result %d", ret);
        <D.24847>:
        D.24848 = ret != 0;
        D.24849 = (long int) D.24848;
        D.24850 = __builtin_expect (D.24849, 0);
        if (D.24850 != 0) goto <D.24851>; else goto <D.24852>;
        <D.24851>:
        monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "aot-runtime.c", 1800, "ret == 0");
        <D.24852>:
      }
      D.24624 = assembly->image;
      D.24785 = amodule->code;
      D.24841 = amodule->code_end;
      mono_jit_info_add_aot_module (D.24624, D.24785, D.24841);
      D.24624 = assembly->image;
      D.24624->aot_module = amodule;
      mono_aot_only.11 = mono_aot_only;
      if (mono_aot_only.11 != 0) goto <D.24853>; else goto <D.24854>;
      <D.24853>:
      {
        char * code;

        try
          {
            D.24855 = amodule->sofile;
            D.24856 = amodule->globals;
            find_symbol (D.24855, D.24856, "specific_trampolines_page", &code);
            code.26 = code;
            D.24858 = code.26 != 0B;
            D.24859 = (int) D.24858;
            amodule->use_page_trampolines = D.24859;
            D.24860 = mono_defaults.corlib;
            if (D.24860 != 0B) goto <D.24861>; else goto <D.24862>;
            <D.24861>:
            {
              struct MonoAotModule * mscorlib_amodule;

              D.24860 = mono_defaults.corlib;
              mscorlib_amodule = D.24860->aot_module;
              D.24729 = amodule->got;
              D.24863 = D.24729 + 8;
              D.24864 = mscorlib_amodule->got;
              *D.24863 = D.24864;
            }
            goto <D.24865>;
            <D.24862>:
            D.24729 = amodule->got;
            D.24863 = D.24729 + 8;
            D.24729 = amodule->got;
            *D.24863 = D.24729;
            <D.24865>:
          }
        finally
          {
            code = {CLOBBER};
          }
      }
      <D.24854>:
      D.24866 = mono_gc_is_moving ();
      if (D.24866 != 0) goto <D.24867>; else goto <D.24868>;
      <D.24867>:
      {
        struct MonoJumpInfo ji;

        try
          {
            memset (&ji, 0, 40);
            ji.type = 42;
            D.24729 = amodule->got;
            D.24869 = D.24729 + 16;
            D.24870 = mono_get_root_domain ();
            D.24871 = mono_resolve_patch_target (0B, D.24870, 0B, &ji, 0);
            *D.24869 = D.24871;
          }
        finally
          {
            ji = {CLOBBER};
          }
      }
      <D.24868>:
      if (do_load_image != 0) goto <D.24872>; else goto <D.24873>;
      <D.24872>:
      i = 0;
      goto <D.23744>;
      <D.23743>:
      load_image (amodule, i, 0);
      i = i + 1;
      <D.23744>:
      D.24874 = amodule->image_table_len;
      i.27 = (unsigned int) i;
      if (D.24874 > i.27) goto <D.23743>; else goto <D.23745>;
      <D.23745>:
      <D.24873>:
      D.24876 = amodule->out_of_date;
      if (D.24876 != 0) goto <D.24877>; else goto <D.24878>;
      <D.24877>:
      D.24624 = assembly->image;
      D.24667 = D.24624->name;
      mono_trace (64, 32, "AOT Module %s is unusable because a dependency is out-of-date.\n", D.24667);
      mono_aot_only.11 = mono_aot_only;
      if (mono_aot_only.11 != 0) goto <D.24879>; else goto <D.24880>;
      <D.24879>:
      stderr.12 = stderr;
      aot_name.7 = aot_name;
      fprintf (stderr.12, "Failed to load AOT module \'%s\' while running in aot-only mode because a dependency cannot be found or it is out of date.\n", aot_name.7);
      exit (1);
      <D.24880>:
      goto <D.24881>;
      <D.24878>:
      D.24624 = assembly->image;
      D.24667 = D.24624->name;
      mono_trace (64, 32, "AOT loaded AOT Module for %s.\n", D.24667);
      <D.24881>:
    }
  finally
    {
      aot_name = {CLOBBER};
      version_symbol = {CLOBBER};
      msg = {CLOBBER};
      info = {CLOBBER};
    }
}


load_aot_module_from_cache (struct MonoAssembly * assembly, char * * aot_name)
{
  struct MonoImage * D.24885;
  long unsigned int D.24886;
  long unsigned int D.24887;
  struct MonoDl * D.24890;
  const char * D.24891;
  char * D.24892;
  char * D.24895;
  int spawn_compiler.28;
  int exit_status.29;
  int D.24904;
  int D.24906;
  int D.24907;
  gchar * err.30;
  gchar * out.31;
  int D.24912;
  unsigned int D.24913;
  char * fname;
  char * cmd;
  char * tmp2;
  char * aot_options;
  const char * home;
  struct MonoDl * module;
  gboolean res;
  gchar * out;
  gchar * err;
  gint exit_status;

  try
    {
      *aot_name = 0B;
      D.24885 = assembly->image;
      D.24886 = BIT_FIELD_REF <*D.24885, 64, 192>;
      D.24887 = D.24886 & 268435456;
      if (D.24887 != 0) goto <D.24888>; else goto <D.24889>;
      <D.24888>:
      D.24890 = 0B;
      return D.24890;
      <D.24889>:
      create_cache_structure ();
      home = monoeg_g_get_home_dir ();
      D.24885 = assembly->image;
      D.24891 = D.24885->assembly_name;
      D.24885 = assembly->image;
      D.24892 = D.24885->guid;
      tmp2 = monoeg_g_strdup_printf ("%s-%s%s", D.24891, D.24892, ".so");
      fname = monoeg_g_build_path ("/", home, ".mono", "aot-cache", tmp2, 0B);
      *aot_name = fname;
      monoeg_g_free (tmp2);
      mono_trace (64, 32, "AOT trying to load from cache: \'%s\'.", fname);
      module = mono_dl_open (fname, 1, 0B);
      if (module == 0B) goto <D.24893>; else goto <D.24894>;
      <D.24893>:
      mono_trace (64, 32, "AOT not found.");
      D.24885 = assembly->image;
      D.24895 = D.24885->name;
      mono_trace (32, 32, "AOT precompiling assembly \'%s\'... ", D.24895);
      aot_options = monoeg_g_strdup_printf ("outfile=%s", fname);
      spawn_compiler.28 = spawn_compiler;
      if (spawn_compiler.28 != 0) goto <D.24897>; else goto <D.24898>;
      <D.24897>:
      D.24885 = assembly->image;
      D.24895 = D.24885->name;
      cmd = monoeg_g_strdup_printf ("mono -O=all --aot=%s %s", aot_options, D.24895);
      res = monoeg_g_spawn_command_line_sync (cmd, &out, &err, &exit_status, 0B);
      if (res != 0) goto <D.24899>; else goto <D.24900>;
      <D.24899>:
      exit_status.29 = exit_status;
      D.24904 = exit_status.29 & 127;
      if (D.24904 != 0) goto <D.24905>; else goto <D.24901>;
      <D.24905>:
      exit_status.29 = exit_status;
      D.24906 = exit_status.29 >> 8;
      D.24907 = D.24906 & 255;
      if (D.24907 == 0) goto <D.24908>; else goto <D.24901>;
      <D.24908>:
      err.30 = err;
      mono_trace (32, 32, "AOT failed: %s.", err.30);
      goto <D.24902>;
      <D.24901>:
      mono_trace (32, 32, "AOT succeeded.");
      <D.24902>:
      out.31 = out;
      monoeg_g_free (out.31);
      err.30 = err;
      monoeg_g_free (err.30);
      <D.24900>:
      monoeg_g_free (cmd);
      goto <D.24911>;
      <D.24898>:
      D.24912 = mono_parse_default_optimizations (0B);
      D.24913 = (unsigned int) D.24912;
      res = mono_compile_assembly (assembly, D.24913, aot_options);
      if (res == 0) goto <D.24914>; else goto <D.24915>;
      <D.24914>:
      mono_trace (32, 32, "AOT failed.");
      goto <D.24916>;
      <D.24915>:
      mono_trace (32, 32, "AOT succeeded.");
      <D.24916>:
      <D.24911>:
      module = mono_dl_open (fname, 1, 0B);
      monoeg_g_free (aot_options);
      <D.24894>:
      D.24890 = module;
      return D.24890;
    }
  finally
    {
      out = {CLOBBER};
      err = {CLOBBER};
      exit_status = {CLOBBER};
    }
}


create_cache_structure ()
{
  int D.24921;
  int * D.24926;
  int D.24927;
  const gchar * D.24928;
  int D.24929;
  const gchar * D.24934;
  const char * home;
  char * tmp;
  int err;

  home = monoeg_g_get_home_dir ();
  if (home == 0B) goto <D.24919>; else goto <D.24920>;
  <D.24919>:
  return;
  <D.24920>:
  tmp = monoeg_g_build_path ("/", home, ".mono", 0B);
  D.24921 = monoeg_g_file_test (tmp, 4);
  if (D.24921 == 0) goto <D.24922>; else goto <D.24923>;
  <D.24922>:
  mono_trace (64, 32, "AOT creating directory %s", tmp);
  err = mkdir (tmp, 511);
  if (err != 0) goto <D.24924>; else goto <D.24925>;
  <D.24924>:
  D.24926 = __errno_location ();
  D.24927 = *D.24926;
  D.24928 = monoeg_g_strerror (D.24927);
  mono_trace (64, 32, "AOT failed: %s", D.24928);
  monoeg_g_free (tmp);
  return;
  <D.24925>:
  <D.24923>:
  monoeg_g_free (tmp);
  tmp = monoeg_g_build_path ("/", home, ".mono", "aot-cache", 0B);
  D.24929 = monoeg_g_file_test (tmp, 4);
  if (D.24929 == 0) goto <D.24930>; else goto <D.24931>;
  <D.24930>:
  mono_trace (64, 32, "AOT creating directory %s", tmp);
  err = mkdir (tmp, 511);
  if (err != 0) goto <D.24932>; else goto <D.24933>;
  <D.24932>:
  D.24926 = __errno_location ();
  D.24927 = *D.24926;
  D.24934 = monoeg_g_strerror (D.24927);
  mono_trace (64, 32, "AOT failed: %s", D.24934);
  monoeg_g_free (tmp);
  return;
  <D.24933>:
  <D.24931>:
  monoeg_g_free (tmp);
}


check_usable (struct MonoAssembly * assembly, struct MonoAotFileInfo * info, char * * out_msg)
{
  struct MonoImage * D.24936;
  char * D.24937;
  void * D.24938;
  int D.24939;
  void * D.24942;
  long unsigned int D.24943;
  int D.24946;
  unsigned int D.24949;
  int D.24950;
  int mono_aot_only.32;
  struct MonoDebugOptions * D.24960;
  int D.24961;
  unsigned int D.24964;
  unsigned int D.24969;
  unsigned int excluded_cpu_optimizations.33;
  unsigned int D.24971;
  unsigned int D.24976;
  unsigned int D.24977;
  unsigned int D.24978;
  unsigned int D.24979;
  int D.24982;
  sizetype D.24985;
  int D.24986;
  gboolean D.24989;
  char * build_info;
  char * msg;
  gboolean usable;
  gboolean full_aot;
  guint8 * blob;
  guint32 excluded_cpu_optimizations;

  try
    {
      msg = 0B;
      usable = 1;
      D.24936 = assembly->image;
      D.24937 = D.24936->guid;
      D.24938 = info->assembly_guid;
      D.24939 = strcmp (D.24937, D.24938);
      if (D.24939 != 0) goto <D.24940>; else goto <D.24941>;
      <D.24940>:
      msg = monoeg_g_strdup_printf ("doesn\'t match assembly");
      usable = 0;
      <D.24941>:
      build_info = mono_get_runtime_build_info ();
      D.24942 = info->runtime_version;
      D.24943 = __strlen_g (D.24942);
      if (D.24943 != 0) goto <D.24944>; else goto <D.24945>;
      <D.24944>:
      D.24942 = info->runtime_version;
      D.24946 = strcmp (D.24942, build_info);
      if (D.24946 != 0) goto <D.24947>; else goto <D.24948>;
      <D.24947>:
      D.24942 = info->runtime_version;
      msg = monoeg_g_strdup_printf ("compiled against runtime version \'%s\' while this runtime has version \'%s\'", D.24942, build_info);
      usable = 0;
      <D.24948>:
      <D.24945>:
      monoeg_g_free (build_info);
      D.24949 = info->flags;
      D.24950 = (int) D.24949;
      full_aot = D.24950 & 2;
      mono_aot_only.32 = mono_aot_only;
      if (mono_aot_only.32 != 0) goto <D.24952>; else goto <D.24953>;
      <D.24952>:
      if (full_aot == 0) goto <D.24954>; else goto <D.24955>;
      <D.24954>:
      msg = monoeg_g_strdup_printf ("not compiled with --aot=full");
      usable = 0;
      <D.24955>:
      <D.24953>:
      mono_aot_only.32 = mono_aot_only;
      if (mono_aot_only.32 == 0) goto <D.24956>; else goto <D.24957>;
      <D.24956>:
      if (full_aot != 0) goto <D.24958>; else goto <D.24959>;
      <D.24958>:
      msg = monoeg_g_strdup_printf ("compiled with --aot=full");
      usable = 0;
      <D.24959>:
      <D.24957>:
      D.24960 = mini_get_debug_options ();
      D.24961 = D.24960->mdb_optimizations;
      if (D.24961 != 0) goto <D.24962>; else goto <D.24963>;
      <D.24962>:
      D.24949 = info->flags;
      D.24964 = D.24949 & 4;
      if (D.24964 == 0) goto <D.24965>; else goto <D.24966>;
      <D.24965>:
      if (full_aot == 0) goto <D.24967>; else goto <D.24968>;
      <D.24967>:
      msg = monoeg_g_strdup_printf ("not compiled for debugging");
      usable = 0;
      <D.24968>:
      <D.24966>:
      <D.24963>:
      mono_arch_cpu_optimizations (&excluded_cpu_optimizations);
      D.24969 = info->opts;
      excluded_cpu_optimizations.33 = excluded_cpu_optimizations;
      D.24971 = D.24969 & excluded_cpu_optimizations.33;
      if (D.24971 != 0) goto <D.24972>; else goto <D.24973>;
      <D.24972>:
      msg = monoeg_g_strdup_printf ("compiled with unsupported CPU optimizations");
      usable = 0;
      <D.24973>:
      mono_aot_only.32 = mono_aot_only;
      if (mono_aot_only.32 == 0) goto <D.24974>; else goto <D.24975>;
      <D.24974>:
      D.24976 = info->simd_opts;
      D.24977 = mono_arch_cpu_enumerate_simd_versions ();
      D.24978 = ~D.24977;
      D.24979 = D.24976 & D.24978;
      if (D.24979 != 0) goto <D.24980>; else goto <D.24981>;
      <D.24980>:
      msg = monoeg_g_strdup_printf ("compiled with unsupported SIMD extensions");
      usable = 0;
      <D.24981>:
      <D.24975>:
      blob = info->blob;
      D.24982 = info->gc_name_index;
      if (D.24982 != -1) goto <D.24983>; else goto <D.24984>;
      <D.24983>:
      {
        char * gc_name;
        const char * current_gc_name;

        D.24982 = info->gc_name_index;
        D.24985 = (sizetype) D.24982;
        gc_name = blob + D.24985;
        current_gc_name = mono_gc_get_gc_name ();
        D.24986 = strcmp (current_gc_name, gc_name);
        if (D.24986 != 0) goto <D.24987>; else goto <D.24988>;
        <D.24987>:
        msg = monoeg_g_strdup_printf ("compiled against GC %s, while the current runtime uses GC %s.\n", gc_name, current_gc_name);
        usable = 0;
        <D.24988>:
      }
      <D.24984>:
      *out_msg = msg;
      D.24989 = usable;
      return D.24989;
    }
  finally
    {
      excluded_cpu_optimizations = {CLOBBER};
    }
}


__attribute__((__gnu_inline__, nothrow, leaf, pure))
strcmp (const char * __s1, const char * __s2)
{
  int iftmp.34;
  int iftmp.35;
  int D.25000;
  char * __p1;
  char * __p2;
  int __ret;

  __p1 = __s1;
  __p2 = __s2;
  __asm__ __volatile__("   slr   0,0
0: clst  %1,%2
   jo    0b
   ipm   %0
   srl   %0,28" : "=d" __ret, "=&a" __p1, "=&a" __p2 : "1" __p1, "2" __p2 : "0", "memory", "cc");
  if (__ret != 0) goto <D.24993>; else goto <D.24994>;
  <D.24993>:
  if (__ret == 1) goto <D.24996>; else goto <D.24997>;
  <D.24996>:
  iftmp.35 = -1;
  goto <D.24998>;
  <D.24997>:
  iftmp.35 = 1;
  <D.24998>:
  iftmp.34 = iftmp.35;
  goto <D.24999>;
  <D.24994>:
  iftmp.34 = 0;
  <D.24999>:
  __ret = iftmp.34;
  D.25000 = __ret;
  return D.25000;
}


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

  if (str != 0B) goto <D.25002>; else goto <D.25003>;
  <D.25002>:
  D.25004 = __strdup (str);
  return D.25004;
  <D.25003>:
  D.25004 = 0B;
  return D.25004;
}


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

  D.25007 = __builtin_object_size (__dest, 0);
  D.25006 = __builtin___memcpy_chk (__dest, __src, __len, D.25007);
  return D.25006;
}


__attribute__((__gnu_inline__))
__strlen_g (const char * __str)
{
  size_t D.25009;
  long int __ptr.36;
  long int __str.37;
  long int D.25012;
  char * __ptr;
  char * __tmp;

  __ptr = 0B;
  __tmp = __str;
  __asm__ __volatile__("   la    0,0
0: srst  %0,%1
   jo    0b
" : "=&a" __ptr, "=&a" __tmp : "0" __ptr, "1" __tmp : "0", "memory", "cc");
  __ptr.36 = (long int) __ptr;
  __str.37 = (long int) __str;
  D.25012 = __ptr.36 - __str.37;
  D.25009 = (size_t) D.25012;
  return D.25009;
}


find_symbol (struct MonoDl * module, void * * globals, const char * name, void * * value)
{
  unsigned int D.25016;
  unsigned int D.25017;
  unsigned int D.25018;
  long unsigned int D.25019;
  long unsigned int D.25020;
  short unsigned int D.25021;
  int D.25022;
  int D.25023;
  guint16 * D.25024;
  short unsigned int D.25025;
  unsigned int D.25026;
  long unsigned int D.25027;
  long unsigned int D.25028;
  void * * D.25029;
  void * D.25030;
  int D.25031;
  unsigned int D.25035;
  long unsigned int D.25036;
  long unsigned int D.25037;
  int D.25040;
  sizetype D.25041;
  sizetype D.25042;
  sizetype D.25043;
  void * * D.25044;
  void * D.25045;

  if (globals != 0B) goto <D.25014>; else goto <D.25015>;
  <D.25014>:
  {
    int global_index;
    guint16 * table;
    guint16 * entry;
    guint16 table_size;
    guint32 hash;
    char * symbol;

    symbol = name;
    table = *globals;
    globals = globals + 8;
    table_size = *table;
    table = table + 2;
    D.25016 = mono_metadata_str_hash (symbol);
    D.25017 = (unsigned int) table_size;
    hash = D.25016 % D.25017;
    D.25018 = hash * 2;
    D.25019 = (long unsigned int) D.25018;
    D.25020 = D.25019 * 2;
    entry = table + D.25020;
    global_index = -1;
    goto <D.23687>;
    <D.23686>:
    {
      guint32 index;
      guint32 next;

      D.25021 = *entry;
      D.25022 = (int) D.25021;
      D.25023 = D.25022 + -1;
      index = (guint32) D.25023;
      D.25024 = entry + 2;
      D.25025 = *D.25024;
      next = (guint32) D.25025;
      D.25026 = index * 2;
      D.25027 = (long unsigned int) D.25026;
      D.25028 = D.25027 * 8;
      D.25029 = globals + D.25028;
      D.25030 = *D.25029;
      D.25031 = strcmp (D.25030, symbol);
      if (D.25031 == 0) goto <D.25032>; else goto <D.25033>;
      <D.25032>:
      global_index = (int) index;
      goto <D.23685>;
      <D.25033>:
      if (next != 0) goto <D.25034>; else goto <D.23685>;
      <D.25034>:
      D.25035 = next * 2;
      D.25036 = (long unsigned int) D.25035;
      D.25037 = D.25036 * 2;
      entry = table + D.25037;
    }
    <D.23687>:
    D.25021 = *entry;
    if (D.25021 != 0) goto <D.23686>; else goto <D.23685>;
    <D.23685>:
    if (global_index != -1) goto <D.25038>; else goto <D.25039>;
    <D.25038>:
    D.25040 = global_index * 2;
    D.25041 = (sizetype) D.25040;
    D.25042 = D.25041 + 1;
    D.25043 = D.25042 * 8;
    D.25044 = globals + D.25043;
    D.25045 = *D.25044;
    *value = D.25045;
    goto <D.25046>;
    <D.25039>:
    *value = 0B;
    <D.25046>:
    if (symbol != name) goto <D.25047>; else goto <D.25048>;
    <D.25047>:
    monoeg_g_free (symbol);
    <D.25048>:
  }
  goto <D.25049>;
  <D.25015>:
  {
    char * err;

    err = mono_dl_symbol (module, name, value);
    if (err != 0B) goto <D.25050>; else goto <D.25051>;
    <D.25050>:
    monoeg_g_free (err);
    <D.25051>:
  }
  <D.25049>:
}


__attribute__((__artificial__, __gnu_inline__, __always_inline__, __nothrow__, __leaf__))
memset (void * __dest, int __ch, size_t __len)
{
  void * D.25052;
  long unsigned int D.25053;

  D.25053 = __builtin_object_size (__dest, 0);
  D.25052 = __builtin___memset_chk (__dest, __ch, __len, D.25053);
  return D.25052;
}


load_image (struct MonoAotModule * amodule, int index, gboolean set_error)
{
  unsigned int D.25055;
  unsigned int index.38;
  _Bool D.25057;
  long int D.25058;
  long int D.25059;
  struct MonoImage * * D.25062;
  long unsigned int D.25063;
  long unsigned int D.25064;
  struct MonoImage * * D.25065;
  struct MonoImage * D.25066;
  struct MonoImage * D.25069;
  int D.25070;
  struct MonoAssemblyName * D.25073;
  long unsigned int D.25074;
  struct MonoAssemblyName * D.25075;
  struct MonoAssembly * D.25076;
  char * D.25077;
  char * D.25080;
  const char * D.25081;
  struct MonoImage * D.25084;
  char * D.25085;
  char * * D.25086;
  char * * D.25087;
  char * D.25088;
  int D.25089;
  struct MonoAssembly * assembly;
  MonoImageOpenStatus status;

  try
    {
      D.25055 = amodule->image_table_len;
      index.38 = (unsigned int) index;
      D.25057 = D.25055 <= index.38;
      D.25058 = (long int) D.25057;
      D.25059 = __builtin_expect (D.25058, 0);
      if (D.25059 != 0) goto <D.25060>; else goto <D.25061>;
      <D.25060>:
      monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "aot-runtime.c", 223, "index < amodule->image_table_len");
      <D.25061>:
      D.25062 = amodule->image_table;
      D.25063 = (long unsigned int) index;
      D.25064 = D.25063 * 8;
      D.25065 = D.25062 + D.25064;
      D.25066 = *D.25065;
      if (D.25066 != 0B) goto <D.25067>; else goto <D.25068>;
      <D.25067>:
      D.25062 = amodule->image_table;
      D.25063 = (long unsigned int) index;
      D.25064 = D.25063 * 8;
      D.25065 = D.25062 + D.25064;
      D.25069 = *D.25065;
      return D.25069;
      <D.25068>:
      D.25070 = amodule->out_of_date;
      if (D.25070 != 0) goto <D.25071>; else goto <D.25072>;
      <D.25071>:
      D.25069 = 0B;
      return D.25069;
      <D.25072>:
      D.25073 = amodule->image_names;
      D.25063 = (long unsigned int) index;
      D.25074 = D.25063 * 80;
      D.25075 = D.25073 + D.25074;
      D.25076 = amodule->assembly;
      D.25077 = D.25076->basedir;
      assembly = mono_assembly_load (D.25075, D.25077, &status);
      if (assembly == 0B) goto <D.25078>; else goto <D.25079>;
      <D.25078>:
      D.25080 = amodule->aot_name;
      D.25073 = amodule->image_names;
      D.25063 = (long unsigned int) index;
      D.25074 = D.25063 * 80;
      D.25075 = D.25073 + D.25074;
      D.25081 = D.25075->name;
      mono_trace (64, 32, "AOT module %s is unusable because dependency %s is not found.\n", D.25080, D.25081);
      amodule->out_of_date = 1;
      if (set_error != 0) goto <D.25082>; else goto <D.25083>;
      <D.25082>:
      {
        char * full_name;

        D.25073 = amodule->image_names;
        D.25063 = (long unsigned int) index;
        D.25074 = D.25063 * 80;
        D.25075 = D.25073 + D.25074;
        full_name = mono_stringify_assembly_name (D.25075);
        mono_loader_set_error_assembly_load (full_name, 0);
        monoeg_g_free (full_name);
      }
      <D.25083>:
      D.25069 = 0B;
      return D.25069;
      <D.25079>:
      D.25084 = assembly->image;
      D.25085 = D.25084->guid;
      D.25086 = amodule->image_guids;
      D.25063 = (long unsigned int) index;
      D.25064 = D.25063 * 8;
      D.25087 = D.25086 + D.25064;
      D.25088 = *D.25087;
      D.25089 = strcmp (D.25085, D.25088);
      if (D.25089 != 0) goto <D.25090>; else goto <D.25091>;
      <D.25090>:
      D.25080 = amodule->aot_name;
      D.25073 = amodule->image_names;
      D.25063 = (long unsigned int) index;
      D.25074 = D.25063 * 80;
      D.25075 = D.25073 + D.25074;
      D.25081 = D.25075->name;
      D.25086 = amodule->image_guids;
      D.25063 = (long unsigned int) index;
      D.25064 = D.25063 * 8;
      D.25087 = D.25086 + D.25064;
      D.25088 = *D.25087;
      D.25084 = assembly->image;
      D.25085 = D.25084->guid;
      mono_trace (64, 32, "AOT module %s is unusable (GUID of dependent assembly %s doesn\'t match (expected \'%s\', got \'%s\').\n", D.25080, D.25081, D.25088, D.25085);
      amodule->out_of_date = 1;
      D.25069 = 0B;
      return D.25069;
      <D.25091>:
      D.25062 = amodule->image_table;
      D.25063 = (long unsigned int) index;
      D.25064 = D.25063 * 8;
      D.25065 = D.25062 + D.25064;
      D.25084 = assembly->image;
      *D.25065 = D.25084;
      D.25069 = assembly->image;
      return D.25069;
    }
  finally
    {
      status = {CLOBBER};
    }
}


__attribute__((__artificial__, __gnu_inline__, __always_inline__))
fprintf (struct FILE * restrict __stream, const char * restrict __fmt)
{
  int D.25094;

  D.25094 = __fprintf_chk (__stream, 1, __fmt, __builtin_va_arg_pack ());
  return D.25094;
}


__attribute__((__gnu_inline__, __pure__, __leaf__, __nothrow__))
atoi (const char * __nptr)
{
  int D.25096;
  long int D.25097;

  D.25097 = strtol (__nptr, 0B, 10);
  D.25096 = (int) D.25097;
  return D.25096;
}


__attribute__((visibility ("hidden")))
mono_aot_cleanup ()
{
  struct GHashTable * aot_jit_icall_hash.39;
  struct GHashTable * aot_modules.40;

  aot_jit_icall_hash.39 = aot_jit_icall_hash;
  if (aot_jit_icall_hash.39 != 0B) goto <D.25100>; else goto <D.25101>;
  <D.25100>:
  aot_jit_icall_hash.39 = aot_jit_icall_hash;
  monoeg_g_hash_table_destroy (aot_jit_icall_hash.39);
  <D.25101>:
  aot_modules.40 = aot_modules;
  if (aot_modules.40 != 0B) goto <D.25103>; else goto <D.25104>;
  <D.25103>:
  aot_modules.40 = aot_modules;
  monoeg_g_hash_table_destroy (aot_modules.40);
  <D.25104>:
}


__attribute__((visibility ("hidden")))
mono_aot_get_method_from_vt_slot (struct MonoDomain * domain, struct MonoVTable * vtable, int slot)
{
  struct MonoImage * D.25105;
  unsigned int D.25108;
  unsigned int D.25109;
  unsigned char D.25111;
  unsigned char D.25114;
  void * D.25116;
  guint8 * D.25117;
  guint32 * D.25118;
  unsigned int D.25119;
  unsigned int D.25120;
  unsigned int D.25121;
  int D.25122;
  unsigned int D.25123;
  sizetype D.25124;
  guint8 * p.41;
  int D.25130;
  unsigned int D.25135;
  unsigned int D.25136;
  unsigned int D.25138;
  struct MonoImage * D.25139;
  int i;
  struct MonoClass * klass;
  struct MonoAotModule * amodule;
  guint8 * info;
  guint8 * p;
  struct MonoCachedClassInfo class_info;
  gboolean err;
  struct MethodRef ref;
  gboolean res;

  try
    {
      klass = vtable->klass;
      D.25105 = klass->image;
      amodule = D.25105->aot_module;
      D.25108 = klass->flags;
      D.25109 = D.25108 & 32;
      if (D.25109 != 0) goto <D.25106>; else goto <D.25110>;
      <D.25110>:
      D.25111 = klass->byval_arg.type;
      if (D.25111 == 19) goto <D.25106>; else goto <D.25112>;
      <D.25112>:
      D.25111 = klass->byval_arg.type;
      if (D.25111 == 30) goto <D.25106>; else goto <D.25113>;
      <D.25113>:
      D.25114 = klass->rank;
      if (D.25114 != 0) goto <D.25106>; else goto <D.25115>;
      <D.25115>:
      if (amodule == 0B) goto <D.25106>; else goto <D.25107>;
      <D.25106>:
      D.25116 = 0B;
      return D.25116;
      <D.25107>:
      D.25117 = amodule->blob;
      D.25118 = amodule->class_info_offsets;
      D.25119 = klass->type_token;
      D.25120 = D.25119 & 16777215;
      D.25121 = D.25120 + 4294967295;
      D.25122 = (int) D.25121;
      D.25123 = mono_aot_get_offset (D.25118, D.25122);
      D.25124 = (sizetype) D.25123;
      info = D.25117 + D.25124;
      p = info;
      p.41 = p;
      err = decode_cached_class_info (amodule, &class_info, p.41, &p);
      if (err == 0) goto <D.25126>; else goto <D.25127>;
      <D.25126>:
      D.25116 = 0B;
      return D.25116;
      <D.25127>:
      i = 0;
      goto <D.23787>;
      <D.23786>:
      p.41 = p;
      decode_method_ref (amodule, &ref, p.41, &p);
      i = i + 1;
      <D.23787>:
      if (i < slot) goto <D.23786>; else goto <D.23788>;
      <D.23788>:
      p.41 = p;
      res = decode_method_ref (amodule, &ref, p.41, &p);
      if (res == 0) goto <D.25128>; else goto <D.25129>;
      <D.25128>:
      D.25116 = 0B;
      return D.25116;
      <D.25129>:
      D.25130 = ref.no_aot_trampoline;
      if (D.25130 != 0) goto <D.25131>; else goto <D.25132>;
      <D.25131>:
      D.25116 = 0B;
      return D.25116;
      <D.25132>:
      D.25135 = ref.token;
      D.25136 = D.25135 & 16777215;
      if (D.25136 == 0) goto <D.25133>; else goto <D.25137>;
      <D.25137>:
      D.25135 = ref.token;
      D.25138 = D.25135 >> 24;
      if (D.25138 != 6) goto <D.25133>; else goto <D.25134>;
      <D.25133>:
      D.25116 = 0B;
      return D.25116;
      <D.25134>:
      D.25139 = ref.image;
      D.25135 = ref.token;
      D.25116 = mono_aot_get_method_from_token (domain, D.25139, D.25135);
      return D.25116;
    }
  finally
    {
      p = {CLOBBER};
      class_info = {CLOBBER};
      ref = {CLOBBER};
    }
}


mono_aot_get_offset (guint32 * table, int index)
{
  unsigned int D.25142;
  guint32 * D.25143;
  unsigned int D.25144;
  guint32 * D.25145;
  unsigned int D.25146;
  guint32 * D.25147;
  unsigned int D.25148;
  long unsigned int D.25151;
  long unsigned int D.25152;
  long unsigned int D.25153;
  long unsigned int D.25154;
  guint16 * D.25155;
  short unsigned int D.25156;
  sizetype D.25157;
  guint8 * p.42;
  long unsigned int D.25160;
  long unsigned int D.25161;
  guint32 * D.25162;
  unsigned int D.25163;
  sizetype D.25164;
  guint8 * p.43;
  guint8 * p.44;
  int D.25167;
  int D.25168;
  guint32 D.25169;
  int i;
  int group;
  int ngroups;
  int index_entry_size;
  int start_offset;
  int offset;
  int noffsets;
  int group_size;
  guint8 * data_start;
  guint8 * p;
  guint32 * index32;
  guint16 * index16;

  try
    {
      index32 = 0B;
      index16 = 0B;
      D.25142 = *table;
      noffsets = (int) D.25142;
      D.25143 = table + 4;
      D.25144 = *D.25143;
      group_size = (int) D.25144;
      D.25145 = table + 8;
      D.25146 = *D.25145;
      ngroups = (int) D.25146;
      D.25147 = table + 12;
      D.25148 = *D.25147;
      index_entry_size = (int) D.25148;
      group = index / group_size;
      if (index_entry_size == 2) goto <D.25149>; else goto <D.25150>;
      <D.25149>:
      index16 = table + 16;
      D.25151 = (long unsigned int) ngroups;
      D.25152 = D.25151 * 2;
      data_start = index16 + D.25152;
      D.25153 = (long unsigned int) group;
      D.25154 = D.25153 * 2;
      D.25155 = index16 + D.25154;
      D.25156 = *D.25155;
      D.25157 = (sizetype) D.25156;
      p.42 = data_start + D.25157;
      p = p.42;
      goto <D.25159>;
      <D.25150>:
      index32 = table + 16;
      D.25151 = (long unsigned int) ngroups;
      D.25160 = D.25151 * 4;
      data_start = index32 + D.25160;
      D.25153 = (long unsigned int) group;
      D.25161 = D.25153 * 4;
      D.25162 = index32 + D.25161;
      D.25163 = *D.25162;
      D.25164 = (sizetype) D.25163;
      p.43 = data_start + D.25164;
      p = p.43;
      <D.25159>:
      p.44 = p;
      start_offset = decode_value (p.44, &p);
      offset = start_offset;
      D.25167 = group * group_size;
      i = D.25167 + 1;
      goto <D.23372>;
      <D.23371>:
      p.44 = p;
      D.25168 = decode_value (p.44, &p);
      offset = D.25168 + offset;
      i = i + 1;
      <D.23372>:
      if (i <= index) goto <D.23371>; else goto <D.23373>;
      <D.23373>:
      D.25169 = (guint32) offset;
      return D.25169;
    }
  finally
    {
      p = {CLOBBER};
    }
}


decode_value (guint8 * ptr, guint8 * * rptr)
{
  signed char b.45;
  int D.25176;
  int D.25177;
  int D.25180;
  int D.25181;
  guint8 * D.25182;
  unsigned char D.25183;
  int D.25184;
  int D.25188;
  int D.25189;
  int D.25190;
  int D.25191;
  guint8 * D.25192;
  unsigned char D.25193;
  int D.25194;
  int D.25195;
  int D.25196;
  guint8 * D.25197;
  unsigned char D.25198;
  int D.25199;
  int D.25201;
  int D.25202;
  int D.25203;
  int D.25204;
  int D.25205;
  guint8 * D.25206;
  unsigned char D.25207;
  int D.25208;
  gint32 D.25211;
  guint8 b;
  gint32 len;

  b = *ptr;
  b.45 = (signed char) b;
  if (b.45 >= 0) goto <D.25173>; else goto <D.25174>;
  <D.25173>:
  len = (gint32) b;
  ptr = ptr + 1;
  goto <D.25175>;
  <D.25174>:
  D.25176 = (int) b;
  D.25177 = D.25176 & 64;
  if (D.25177 == 0) goto <D.25178>; else goto <D.25179>;
  <D.25178>:
  D.25176 = (int) b;
  D.25180 = D.25176 << 8;
  D.25181 = D.25180 & 16128;
  D.25182 = ptr + 1;
  D.25183 = *D.25182;
  D.25184 = (int) D.25183;
  len = D.25181 | D.25184;
  ptr = ptr + 2;
  goto <D.25185>;
  <D.25179>:
  if (b != 255) goto <D.25186>; else goto <D.25187>;
  <D.25186>:
  D.25176 = (int) b;
  D.25188 = D.25176 << 24;
  D.25189 = D.25188 & 520093696;
  D.25182 = ptr + 1;
  D.25183 = *D.25182;
  D.25184 = (int) D.25183;
  D.25190 = D.25184 << 16;
  D.25191 = D.25189 | D.25190;
  D.25192 = ptr + 2;
  D.25193 = *D.25192;
  D.25194 = (int) D.25193;
  D.25195 = D.25194 << 8;
  D.25196 = D.25191 | D.25195;
  D.25197 = ptr + 3;
  D.25198 = *D.25197;
  D.25199 = (int) D.25198;
  len = D.25196 | D.25199;
  ptr = ptr + 4;
  goto <D.25200>;
  <D.25187>:
  D.25182 = ptr + 1;
  D.25183 = *D.25182;
  D.25184 = (int) D.25183;
  D.25201 = D.25184 << 24;
  D.25192 = ptr + 2;
  D.25193 = *D.25192;
  D.25194 = (int) D.25193;
  D.25202 = D.25194 << 16;
  D.25203 = D.25201 | D.25202;
  D.25197 = ptr + 3;
  D.25198 = *D.25197;
  D.25199 = (int) D.25198;
  D.25204 = D.25199 << 8;
  D.25205 = D.25203 | D.25204;
  D.25206 = ptr + 4;
  D.25207 = *D.25206;
  D.25208 = (int) D.25207;
  len = D.25205 | D.25208;
  ptr = ptr + 5;
  <D.25200>:
  <D.25185>:
  <D.25175>:
  if (rptr != 0B) goto <D.25209>; else goto <D.25210>;
  <D.25209>:
  *rptr = ptr;
  <D.25210>:
  D.25211 = len;
  return D.25211;
}


decode_cached_class_info (struct MonoAotModule * module, struct MonoCachedClassInfo * info, guint8 * buf, guint8 * * endbuf)
{
  guint8 * buf.46;
  int D.25214;
  unsigned int D.25215;
  unsigned int D.25216;
  gboolean D.25219;
  int D.25220;
  unsigned char D.25221;
  <unnamed-unsigned:1> D.25222;
  unsigned int D.25223;
  unsigned char D.25224;
  <unnamed-unsigned:1> D.25225;
  unsigned int D.25226;
  unsigned char D.25227;
  <unnamed-unsigned:1> D.25228;
  unsigned int D.25229;
  unsigned char D.25230;
  <unnamed-unsigned:1> D.25231;
  unsigned int D.25232;
  unsigned char D.25233;
  <unnamed-unsigned:1> D.25234;
  unsigned int D.25235;
  unsigned char D.25236;
  <unnamed-unsigned:1> D.25237;
  unsigned int D.25238;
  unsigned char D.25239;
  <unnamed-unsigned:1> D.25240;
  unsigned int D.25241;
  unsigned char D.25242;
  <unnamed-unsigned:1> D.25243;
  unsigned int D.25244;
  unsigned char D.25245;
  <unnamed-unsigned:1> D.25246;
  long unsigned int D.25247;
  long unsigned int D.25248;
  unsigned int D.25253;
  long unsigned int D.25254;
  struct MonoImage * D.25259;
  int D.25260;
  unsigned int D.25261;
  int D.25262;
  unsigned int D.25263;
  int D.25264;
  unsigned int D.25265;
  int D.25266;
  unsigned int D.25267;
  guint32 flags;
  struct MethodRef ref;
  gboolean res;

  try
    {
      buf.46 = buf;
      D.25214 = decode_value (buf.46, &buf);
      D.25215 = (unsigned int) D.25214;
      info->vtable_size = D.25215;
      D.25216 = info->vtable_size;
      if (D.25216 == 4294967295) goto <D.25217>; else goto <D.25218>;
      <D.25217>:
      D.25219 = 0;
      return D.25219;
      <D.25218>:
      buf.46 = buf;
      D.25220 = decode_value (buf.46, &buf);
      flags = (guint32) D.25220;
      D.25221 = (unsigned char) flags;
      D.25222 = (<unnamed-unsigned:1>) D.25221;
      info->ghcimpl = D.25222;
      D.25223 = flags >> 1;
      D.25224 = (unsigned char) D.25223;
      D.25225 = (<unnamed-unsigned:1>) D.25224;
      info->has_finalize = D.25225;
      D.25226 = flags >> 2;
      D.25227 = (unsigned char) D.25226;
      D.25228 = (<unnamed-unsigned:1>) D.25227;
      info->has_cctor = D.25228;
      D.25229 = flags >> 3;
      D.25230 = (unsigned char) D.25229;
      D.25231 = (<unnamed-unsigned:1>) D.25230;
      info->has_nested_classes = D.25231;
      D.25232 = flags >> 4;
      D.25233 = (unsigned char) D.25232;
      D.25234 = (<unnamed-unsigned:1>) D.25233;
      info->blittable = D.25234;
      D.25235 = flags >> 5;
      D.25236 = (unsigned char) D.25235;
      D.25237 = (<unnamed-unsigned:1>) D.25236;
      info->has_references = D.25237;
      D.25238 = flags >> 6;
      D.25239 = (unsigned char) D.25238;
      D.25240 = (<unnamed-unsigned:1>) D.25239;
      info->has_static_refs = D.25240;
      D.25241 = flags >> 7;
      D.25242 = (unsigned char) D.25241;
      D.25243 = (<unnamed-unsigned:1>) D.25242;
      info->no_special_static_fields = D.25243;
      D.25244 = flags >> 8;
      D.25245 = (unsigned char) D.25244;
      D.25246 = (<unnamed-unsigned:1>) D.25245;
      info->is_generic_container = D.25246;
      D.25247 = BIT_FIELD_REF <*info, 64, 0>;
      D.25248 = D.25247 & 536870912;
      if (D.25248 != 0) goto <D.25249>; else goto <D.25250>;
      <D.25249>:
      buf.46 = buf;
      res = decode_method_ref (module, &ref, buf.46, &buf);
      if (res == 0) goto <D.25251>; else goto <D.25252>;
      <D.25251>:
      D.25219 = 0;
      return D.25219;
      <D.25252>:
      D.25253 = ref.token;
      info->cctor_token = D.25253;
      <D.25250>:
      D.25247 = BIT_FIELD_REF <*info, 64, 0>;
      D.25254 = D.25247 & 2147483648;
      if (D.25254 != 0) goto <D.25255>; else goto <D.25256>;
      <D.25255>:
      buf.46 = buf;
      res = decode_method_ref (module, &ref, buf.46, &buf);
      if (res == 0) goto <D.25257>; else goto <D.25258>;
      <D.25257>:
      D.25219 = 0;
      return D.25219;
      <D.25258>:
      D.25259 = ref.image;
      info->finalize_image = D.25259;
      D.25253 = ref.token;
      info->finalize_token = D.25253;
      <D.25256>:
      buf.46 = buf;
      D.25260 = decode_value (buf.46, &buf);
      D.25261 = (unsigned int) D.25260;
      info->instance_size = D.25261;
      buf.46 = buf;
      D.25262 = decode_value (buf.46, &buf);
      D.25263 = (unsigned int) D.25262;
      info->class_size = D.25263;
      buf.46 = buf;
      D.25264 = decode_value (buf.46, &buf);
      D.25265 = (unsigned int) D.25264;
      info->packing_size = D.25265;
      buf.46 = buf;
      D.25266 = decode_value (buf.46, &buf);
      D.25267 = (unsigned int) D.25266;
      info->min_align = D.25267;
      buf.46 = buf;
      *endbuf = buf.46;
      D.25219 = 1;
      return D.25219;
    }
  finally
    {
      ref = {CLOBBER};
    }
}


decode_method_ref (struct MonoAotModule * module, struct MethodRef * ref, guint8 * buf, guint8 * * endbuf)
{
  gboolean D.25270;

  D.25270 = decode_method_ref_with_target (module, ref, 0B, buf, endbuf);
  return D.25270;
}


decode_method_ref_with_target (struct MonoAotModule * module, struct MethodRef * ref, struct MonoMethod * target, guint8 * buf, guint8 * * endbuf)
{
  guint8 * p.47;
  int D.25273;
  int D.25276;
  long unsigned int D.25283;
  long unsigned int D.25284;
  gboolean D.25287;
  int D.25290;
  <unnamed-unsigned:5> D.25293;
  unsigned int D.25294;
  struct MonoClass * D.25299;
  struct MonoMethod * D.25300;
  struct MonoMethod * D.25303;
  struct MonoType * D.25308;
  struct MonoMethod * D.25309;
  struct MonoMethod * D.25313;
  struct MonoMethod * D.25317;
  struct MonoMethod * D.25321;
  struct MonoMethod * D.25323;
  struct MonoMethod * D.25324;
  struct MonoMethod * D.25325;
  struct MonoMethod * D.25326;
  _Bool D.25327;
  long int D.25328;
  long int D.25329;
  struct MonoMethod * D.25332;
  struct MonoMethod * D.25335;
  _Bool D.25343;
  long int D.25344;
  long int D.25345;
  <unnamed type> D.25350;
  unsigned int subtype.48;
  int D.25353;
  struct MonoMethod * D.25359;
  unsigned int subtype.49;
  unsigned int D.25361;
  struct MonoClass * D.25368;
  const char * D.25373;
  int D.25374;
  struct MonoMethod * D.25377;
  int D.25379;
  struct MonoMethod * D.25382;
  struct MonoMethod * D.25388;
  struct MonoMethod * D.25394;
  struct MonoMethod * D.25398;
  struct MonoMethod * D.25402;
  struct MonoClass * D.25413;
  _Bool D.25414;
  long int D.25415;
  long int D.25416;
  struct MonoMethod * D.25419;
  struct MonoMethod * D.25422;
  _Bool D.25430;
  long int D.25431;
  long int D.25432;
  <unnamed type> D.25438;
  unsigned int subtype.50;
  struct MonoMethod * D.25441;
  int D.25447;
  struct MonoMethod * D.25455;
  struct MonoMethod * D.25461;
  struct MonoMethod * D.25465;
  int D.25471;
  struct MonoMethod * D.25479;
  struct MonoMethod * D.25485;
  _Bool D.25487;
  long int D.25488;
  long int D.25489;
  <unnamed type> D.25492;
  unsigned int subtype.51;
  struct MonoMethodSignature * D.25496;
  _Bool D.25497;
  long int D.25498;
  long int D.25499;
  int D.25502;
  int D.25519;
  <unnamed type> D.25522;
  int D.25528;
  struct MonoMethod * D.25536;
  int D.25540;
  int D.25541;
  unsigned int D.25542;
  int image_index.52;
  int D.25555;
  int D.25556;
  unsigned int D.25557;
  unsigned int D.25560;
  struct MonoMethod * D.25561;
  struct MonoGenericClass * D.25566;
  struct MonoGenericInst * D.25567;
  struct MonoMethod * D.25568;
  int D.25569;
  struct MonoMethod * D.25572;
  unsigned char D.25578;
  int D.25579;
  struct MonoMethod * D.25580;
  int D.25581;
  struct MonoMethod * D.25582;
  struct MonoMethod * D.25583;
  struct MonoMethod * D.25584;
  struct MonoMethod * D.25585;
  int D.25589;
  int D.25590;
  unsigned int D.25591;
  unsigned int D.25592;
  guint32 image_index;
  guint32 value;
  struct MonoImage * image;
  guint8 * p;

  try
    {
      image = 0B;
      p = buf;
      memset (ref, 0, 32);
      p.47 = p;
      D.25273 = decode_value (p.47, &p);
      value = (guint32) D.25273;
      image_index = value >> 24;
      if (image_index == 251) goto <D.25274>; else goto <D.25275>;
      <D.25274>:
      ref->no_aot_trampoline = 1;
      p.47 = p;
      D.25276 = decode_value (p.47, &p);
      value = (guint32) D.25276;
      image_index = value >> 24;
      <D.25275>:
      if (image_index <= 239) goto <D.25277>; else goto <D.25279>;
      <D.25279>:
      if (image_index == 254) goto <D.25277>; else goto <D.25280>;
      <D.25280>:
      if (image_index == 253) goto <D.25277>; else goto <D.25278>;
      <D.25277>:
      if (target != 0B) goto <D.25281>; else goto <D.25282>;
      <D.25281>:
      D.25283 = BIT_FIELD_REF <*target, 64, 256>;
      D.25284 = D.25283 & 4467570830351532032;
      if (D.25284 != 0) goto <D.25285>; else goto <D.25286>;
      <D.25285>:
      D.25287 = 0;
      return D.25287;
      <D.25286>:
      <D.25282>:
      <D.25278>:
      if (image_index == 252) goto <D.25288>; else goto <D.25289>;
      <D.25288>:
      {
        guint32 wrapper_type;

        p.47 = p;
        D.25290 = decode_value (p.47, &p);
        wrapper_type = (guint32) D.25290;
        if (target != 0B) goto <D.25291>; else goto <D.25292>;
        <D.25291>:
        D.25293 = target->wrapper_type;
        D.25294 = (unsigned int) D.25293;
        if (D.25294 != wrapper_type) goto <D.25295>; else goto <D.25296>;
        <D.25295>:
        D.25287 = 0;
        return D.25287;
        <D.25296>:
        <D.25292>:
        image = mono_defaults.corlib;
        switch (wrapper_type) <default: <D.23620>, case 1: <D.23603>, case 2: <D.23604>, case 3: <D.23605>, case 4: <D.23597>, case 5: <D.23617>, case 6: <D.23591>, case 7: <D.23585>, case 9: <D.23557>, case 12: <D.23562>, case 13: <D.23564>, case 14: <D.23567>, case 15: <D.23568>, case 16: <D.23576>, case 18: <D.23565>, case 19: <D.23595>, case 20: <D.23560>, case 21: <D.23572>, case 23: <D.23563>, case 24: <D.23571>, case 25: <D.23578>, case 28: <D.23569>>
        <D.23557>:
        {
          struct MonoMethod * m;

          p.47 = p;
          m = decode_resolve_method_ref (module, p.47, &p);
          if (m == 0B) goto <D.25297>; else goto <D.25298>;
          <D.25297>:
          D.25287 = 0;
          return D.25287;
          <D.25298>:
          D.25299 = m->klass;
          mono_class_init (D.25299);
          D.25300 = mono_marshal_get_remoting_invoke_with_check (m);
          ref->method = D.25300;
          goto <D.23559>;
        }
        <D.23560>:
        {
          struct MonoClass * klass;

          p.47 = p;
          klass = decode_klass_ref (module, p.47, &p);
          if (klass == 0B) goto <D.25301>; else goto <D.25302>;
          <D.25301>:
          D.25287 = 0;
          return D.25287;
          <D.25302>:
          D.25303 = mono_marshal_get_proxy_cancast (klass);
          ref->method = D.25303;
          goto <D.23559>;
        }
        <D.23562>:
        <D.23563>:
        <D.23564>:
        <D.23565>:
        {
          struct MonoClass * klass;

          p.47 = p;
          klass = decode_klass_ref (module, p.47, &p);
          if (klass == 0B) goto <D.25304>; else goto <D.25305>;
          <D.25304>:
          D.25287 = 0;
          return D.25287;
          <D.25305>:
          if (wrapper_type == 12) goto <D.25306>; else goto <D.25307>;
          <D.25306>:
          D.25308 = &klass->byval_arg;
          D.25309 = mono_marshal_get_ldfld_wrapper (D.25308);
          ref->method = D.25309;
          goto <D.25310>;
          <D.25307>:
          if (wrapper_type == 23) goto <D.25311>; else goto <D.25312>;
          <D.25311>:
          D.25308 = &klass->byval_arg;
          D.25313 = mono_marshal_get_ldflda_wrapper (D.25308);
          ref->method = D.25313;
          goto <D.25314>;
          <D.25312>:
          if (wrapper_type == 13) goto <D.25315>; else goto <D.25316>;
          <D.25315>:
          D.25308 = &klass->byval_arg;
          D.25317 = mono_marshal_get_stfld_wrapper (D.25308);
          ref->method = D.25317;
          goto <D.25318>;
          <D.25316>:
          if (wrapper_type == 18) goto <D.25319>; else goto <D.25320>;
          <D.25319>:
          D.25321 = mono_marshal_get_isinst (klass);
          ref->method = D.25321;
          goto <D.25322>;
          <D.25320>:
          monoeg_assertion_message ("* Assertion: should not be reached at %s:%d\n", "aot-runtime.c", 831);
          <D.25322>:
          <D.25318>:
          <D.25314>:
          <D.25310>:
          goto <D.23559>;
        }
        <D.23567>:
        D.25323 = mono_marshal_get_ldfld_remote_wrapper (0B);
        ref->method = D.25323;
        goto <D.23559>;
        <D.23568>:
        D.25324 = mono_marshal_get_stfld_remote_wrapper (0B);
        ref->method = D.25324;
        goto <D.23559>;
        <D.23569>:
        {
          int atype;

          p.47 = p;
          atype = decode_value (p.47, &p);
          D.25325 = mono_gc_get_managed_allocator_by_type (atype);
          ref->method = D.25325;
          D.25326 = ref->method;
          D.25327 = D.25326 == 0B;
          D.25328 = (long int) D.25327;
          D.25329 = __builtin_expect (D.25328, 0);
          if (D.25329 != 0) goto <D.25330>; else goto <D.25331>;
          <D.25330>:
          monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "aot-runtime.c", 845, "ref->method");
          <D.25331>:
          goto <D.23559>;
        }
        <D.23571>:
        D.25332 = mono_gc_get_write_barrier ();
        ref->method = D.25332;
        goto <D.23559>;
        <D.23572>:
        {
          int subtype;

          p.47 = p;
          subtype = decode_value (p.47, &p);
          if (subtype == 0) goto <D.25333>; else goto <D.25334>;
          <D.25333>:
          D.25335 = mono_marshal_get_stelemref ();
          ref->method = D.25335;
          goto <D.25336>;
          <D.25334>:
          if (subtype == 3) goto <D.25337>; else goto <D.25338>;
          <D.25337>:
          {
            int kind;
            struct WrapperInfo * info;

            p.47 = p;
            kind = decode_value (p.47, &p);
            if (target == 0B) goto <D.25339>; else goto <D.25340>;
            <D.25339>:
            D.25287 = 0;
            return D.25287;
            <D.25340>:
            D.25283 = BIT_FIELD_REF <*target, 64, 256>;
            D.25284 = D.25283 & 4467570830351532032;
            if (D.25284 == 3026418949592973312) goto <D.25341>; else goto <D.25342>;
            <D.25341>:
            info = mono_marshal_get_wrapper_info (target);
            D.25343 = info == 0B;
            D.25344 = (long int) D.25343;
            D.25345 = __builtin_expect (D.25344, 0);
            if (D.25345 != 0) goto <D.25346>; else goto <D.25347>;
            <D.25346>:
            monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "aot-runtime.c", 868, "info");
            <D.25347>:
            D.25350 = info->subtype;
            subtype.48 = (unsigned int) subtype;
            if (D.25350 == subtype.48) goto <D.25352>; else goto <D.25348>;
            <D.25352>:
            D.25353 = info->d.virtual_stelemref.kind;
            if (D.25353 == kind) goto <D.25354>; else goto <D.25348>;
            <D.25354>:
            ref->method = target;
            goto <D.25349>;
            <D.25348>:
            D.25287 = 0;
            return D.25287;
            <D.25349>:
            goto <D.25355>;
            <D.25342>:
            D.25287 = 0;
            return D.25287;
            <D.25355>:
          }
          goto <D.25356>;
          <D.25338>:
          monoeg_assertion_message ("* Assertion: should not be reached at %s:%d\n", "aot-runtime.c", 877);
          <D.25356>:
          <D.25336>:
          goto <D.23559>;
        }
        <D.23576>:
        {
          struct MonoMethod * m;

          p.47 = p;
          m = decode_resolve_method_ref (module, p.47, &p);
          if (m == 0B) goto <D.25357>; else goto <D.25358>;
          <D.25357>:
          D.25287 = 0;
          return D.25287;
          <D.25358>:
          D.25359 = mono_marshal_get_synchronized_wrapper (m);
          ref->method = D.25359;
          goto <D.23559>;
        }
        <D.23578>:
        {
          struct MonoMethodDesc * desc;
          struct MonoMethod * orig_method;
          int subtype;

          p.47 = p;
          subtype = decode_value (p.47, &p);
          subtype.49 = (unsigned int) subtype;
          D.25361 = subtype.49 + 4294967289;
          if (D.25361 <= 1) goto <D.25362>; else goto <D.25363>;
          <D.25362>:
          {
            struct MonoClass * klass;

            p.47 = p;
            klass = decode_klass_ref (module, p.47, &p);
            if (klass == 0B) goto <D.25364>; else goto <D.25365>;
            <D.25364>:
            D.25287 = 0;
            return D.25287;
            <D.25365>:
            if (target == 0B) goto <D.25366>; else goto <D.25367>;
            <D.25366>:
            D.25287 = 0;
            return D.25287;
            <D.25367>:
            D.25368 = target->klass;
            if (D.25368 != klass) goto <D.25369>; else goto <D.25370>;
            <D.25369>:
            D.25287 = 0;
            return D.25287;
            <D.25370>:
            if (subtype == 7) goto <D.25371>; else goto <D.25372>;
            <D.25371>:
            D.25373 = target->name;
            D.25374 = strcmp (D.25373, "PtrToStructure");
            if (D.25374 != 0) goto <D.25375>; else goto <D.25376>;
            <D.25375>:
            D.25287 = 0;
            return D.25287;
            <D.25376>:
            D.25377 = mono_marshal_get_ptr_to_struct (klass);
            ref->method = D.25377;
            goto <D.25378>;
            <D.25372>:
            D.25373 = target->name;
            D.25379 = strcmp (D.25373, "StructureToPtr");
            if (D.25379 != 0) goto <D.25380>; else goto <D.25381>;
            <D.25380>:
            D.25287 = 0;
            return D.25287;
            <D.25381>:
            D.25382 = mono_marshal_get_struct_to_ptr (klass);
            ref->method = D.25382;
            <D.25378>:
          }
          goto <D.25383>;
          <D.25363>:
          if (subtype == 17) goto <D.25384>; else goto <D.25385>;
          <D.25384>:
          {
            struct MonoMethod * m;

            p.47 = p;
            m = decode_resolve_method_ref (module, p.47, &p);
            if (m == 0B) goto <D.25386>; else goto <D.25387>;
            <D.25386>:
            D.25287 = 0;
            return D.25287;
            <D.25387>:
            D.25388 = mono_marshal_get_synchronized_inner_wrapper (m);
            ref->method = D.25388;
          }
          goto <D.25389>;
          <D.25385>:
          if (subtype == 20) goto <D.25390>; else goto <D.25391>;
          <D.25390>:
          {
            struct MonoMethod * m;

            p.47 = p;
            m = decode_resolve_method_ref (module, p.47, &p);
            if (m == 0B) goto <D.25392>; else goto <D.25393>;
            <D.25392>:
            D.25287 = 0;
            return D.25287;
            <D.25393>:
            D.25394 = mono_marshal_get_array_accessor_wrapper (m);
            ref->method = D.25394;
          }
          goto <D.25395>;
          <D.25391>:
          if (subtype == 18) goto <D.25396>; else goto <D.25397>;
          <D.25396>:
          D.25398 = mono_marshal_get_gsharedvt_in_wrapper ();
          ref->method = D.25398;
          goto <D.25399>;
          <D.25397>:
          if (subtype == 19) goto <D.25400>; else goto <D.25401>;
          <D.25400>:
          D.25402 = mono_marshal_get_gsharedvt_out_wrapper ();
          ref->method = D.25402;
          goto <D.25403>;
          <D.25401>:
          if (subtype == 4) goto <D.25404>; else goto <D.25405>;
          <D.25404>:
          desc = mono_method_desc_new ("Monitor:Enter", 0);
          goto <D.25406>;
          <D.25405>:
          if (subtype == 6) goto <D.25407>; else goto <D.25408>;
          <D.25407>:
          desc = mono_method_desc_new ("Monitor:Exit", 0);
          goto <D.25409>;
          <D.25408>:
          if (subtype == 5) goto <D.25410>; else goto <D.25411>;
          <D.25410>:
          desc = mono_method_desc_new ("Monitor:Enter(object,bool&)", 0);
          goto <D.25412>;
          <D.25411>:
          monoeg_assertion_message ("* Assertion: should not be reached at %s:%d\n", "aot-runtime.c", 938);
          <D.25412>:
          <D.25409>:
          <D.25406>:
          D.25413 = mono_defaults.monitor_class;
          orig_method = mono_method_desc_search_in_class (desc, D.25413);
          D.25414 = orig_method == 0B;
          D.25415 = (long int) D.25414;
          D.25416 = __builtin_expect (D.25415, 0);
          if (D.25416 != 0) goto <D.25417>; else goto <D.25418>;
          <D.25417>:
          monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "aot-runtime.c", 940, "orig_method");
          <D.25418>:
          mono_method_desc_free (desc);
          D.25419 = mono_monitor_get_fast_path (orig_method);
          ref->method = D.25419;
          <D.25403>:
          <D.25399>:
          <D.25395>:
          <D.25389>:
          <D.25383>:
          goto <D.23559>;
        }
        <D.23585>:
        {
          int subtype;

          p.47 = p;
          subtype = decode_value (p.47, &p);
          if (subtype == 1) goto <D.25420>; else goto <D.25421>;
          <D.25420>:
          {
            int rank;
            int elem_size;

            p.47 = p;
            rank = decode_value (p.47, &p);
            p.47 = p;
            elem_size = decode_value (p.47, &p);
            D.25422 = mono_marshal_get_array_address (rank, elem_size);
            ref->method = D.25422;
          }
          goto <D.25423>;
          <D.25421>:
          if (subtype == 2) goto <D.25424>; else goto <D.25425>;
          <D.25424>:
          {
            struct WrapperInfo * info;
            struct MonoMethod * m;

            p.47 = p;
            m = decode_resolve_method_ref (module, p.47, &p);
            if (m == 0B) goto <D.25426>; else goto <D.25427>;
            <D.25426>:
            D.25287 = 0;
            return D.25287;
            <D.25427>:
            if (target == 0B) goto <D.25428>; else goto <D.25429>;
            <D.25428>:
            D.25287 = 0;
            return D.25287;
            <D.25429>:
            D.25283 = BIT_FIELD_REF <*target, 64, 256>;
            D.25284 = D.25283 & 4467570830351532032;
            D.25430 = D.25284 != 1008806316530991104;
            D.25431 = (long int) D.25430;
            D.25432 = __builtin_expect (D.25431, 0);
            if (D.25432 != 0) goto <D.25433>; else goto <D.25434>;
            <D.25433>:
            monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "aot-runtime.c", 964, "target->wrapper_type == MONO_WRAPPER_MANAGED_TO_MANAGED");
            <D.25434>:
            info = mono_marshal_get_wrapper_info (target);
            if (info != 0B) goto <D.25437>; else goto <D.25435>;
            <D.25437>:
            D.25438 = info->subtype;
            subtype.50 = (unsigned int) subtype;
            if (D.25438 == subtype.50) goto <D.25440>; else goto <D.25435>;
            <D.25440>:
            D.25441 = info->d.string_ctor.method;
            if (D.25441 == m) goto <D.25442>; else goto <D.25435>;
            <D.25442>:
            ref->method = target;
            goto <D.25436>;
            <D.25435>:
            D.25287 = 0;
            return D.25287;
            <D.25436>:
          }
          <D.25425>:
          <D.25423>:
          goto <D.23559>;
        }
        <D.23591>:
        {
          struct MonoMethod * m;
          int subtype;
          char * name;

          p.47 = p;
          subtype = decode_value (p.47, &p);
          if (subtype == 15) goto <D.25443>; else goto <D.25444>;
          <D.25443>:
          if (target == 0B) goto <D.25445>; else goto <D.25446>;
          <D.25445>:
          D.25287 = 0;
          return D.25287;
          <D.25446>:
          name = p;
          D.25373 = target->name;
          D.25447 = strcmp (D.25373, name);
          if (D.25447 != 0) goto <D.25448>; else goto <D.25449>;
          <D.25448>:
          D.25287 = 0;
          return D.25287;
          <D.25449>:
          ref->method = target;
          goto <D.25450>;
          <D.25444>:
          p.47 = p;
          m = decode_resolve_method_ref (module, p.47, &p);
          if (m == 0B) goto <D.25451>; else goto <D.25452>;
          <D.25451>:
          D.25287 = 0;
          return D.25287;
          <D.25452>:
          if (target == 0B) goto <D.25453>; else goto <D.25454>;
          <D.25453>:
          D.25287 = 0;
          return D.25287;
          <D.25454>:
          D.25455 = mono_marshal_method_from_wrapper (target);
          if (D.25455 == m) goto <D.25456>; else goto <D.25457>;
          <D.25456>:
          ref->method = target;
          goto <D.25458>;
          <D.25457>:
          D.25287 = 0;
          return D.25287;
          <D.25458>:
          <D.25450>:
          goto <D.23559>;
        }
        <D.23595>:
        {
          int subtype;

          p.47 = p;
          subtype = decode_value (p.47, &p);
          if (subtype == 9) goto <D.25459>; else goto <D.25460>;
          <D.25459>:
          D.25461 = mono_marshal_get_castclass_with_cache ();
          ref->method = D.25461;
          goto <D.25462>;
          <D.25460>:
          if (subtype == 10) goto <D.25463>; else goto <D.25464>;
          <D.25463>:
          D.25465 = mono_marshal_get_isinst_with_cache ();
          ref->method = D.25465;
          goto <D.25466>;
          <D.25464>:
          monoeg_assertion_message ("* Assertion: should not be reached at %s:%d\n", "aot-runtime.c", 1011);
          <D.25466>:
          <D.25462>:
          goto <D.23559>;
        }
        <D.23597>:
        {
          int subtype;

          p.47 = p;
          subtype = decode_value (p.47, &p);
          if (target == 0B) goto <D.25467>; else goto <D.25468>;
          <D.25467>:
          D.25287 = 0;
          return D.25287;
          <D.25468>:
          if (subtype == 12) goto <D.25469>; else goto <D.25470>;
          <D.25469>:
          D.25373 = target->name;
          D.25471 = strcmp (D.25373, "runtime_invoke_dynamic");
          if (D.25471 != 0) goto <D.25472>; else goto <D.25473>;
          <D.25472>:
          D.25287 = 0;
          return D.25287;
          <D.25473>:
          ref->method = target;
          goto <D.25474>;
          <D.25470>:
          if (subtype == 13) goto <D.25475>; else goto <D.25476>;
          <D.25475>:
          {
            struct MonoMethod * m;

            p.47 = p;
            m = decode_resolve_method_ref (module, p.47, &p);
            if (m == 0B) goto <D.25477>; else goto <D.25478>;
            <D.25477>:
            D.25287 = 0;
            return D.25287;
            <D.25478>:
            D.25479 = mono_marshal_get_runtime_invoke (m, 0);
            ref->method = D.25479;
          }
          goto <D.25480>;
          <D.25476>:
          if (subtype == 14) goto <D.25481>; else goto <D.25482>;
          <D.25481>:
          {
            struct MonoMethod * m;

            p.47 = p;
            m = decode_resolve_method_ref (module, p.47, &p);
            if (m == 0B) goto <D.25483>; else goto <D.25484>;
            <D.25483>:
            D.25287 = 0;
            return D.25287;
            <D.25484>:
            D.25485 = mono_marshal_get_runtime_invoke (m, 1);
            ref->method = D.25485;
          }
          goto <D.25486>;
          <D.25482>:
          {
            struct MonoMethodSignature * sig;
            struct WrapperInfo * info;

            p.47 = p;
            sig = decode_signature_with_target (module, 0B, p.47, &p);
            info = mono_marshal_get_wrapper_info (target);
            D.25487 = info == 0B;
            D.25488 = (long int) D.25487;
            D.25489 = __builtin_expect (D.25488, 0);
            if (D.25489 != 0) goto <D.25490>; else goto <D.25491>;
            <D.25490>:
            monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "aot-runtime.c", 1044, "info");
            <D.25491>:
            D.25492 = info->subtype;
            subtype.51 = (unsigned int) subtype;
            if (D.25492 != subtype.51) goto <D.25494>; else goto <D.25495>;
            <D.25494>:
            D.25287 = 0;
            return D.25287;
            <D.25495>:
            D.25496 = info->d.runtime_invoke.sig;
            D.25497 = D.25496 == 0B;
            D.25498 = (long int) D.25497;
            D.25499 = __builtin_expect (D.25498, 0);
            if (D.25499 != 0) goto <D.25500>; else goto <D.25501>;
            <D.25500>:
            monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "aot-runtime.c", 1048, "info->d.runtime_invoke.sig");
            <D.25501>:
            D.25496 = info->d.runtime_invoke.sig;
            D.25502 = mono_metadata_signature_equal (sig, D.25496);
            if (D.25502 != 0) goto <D.25503>; else goto <D.25504>;
            <D.25503>:
            ref->method = target;
            goto <D.25505>;
            <D.25504>:
            D.25287 = 0;
            return D.25287;
            <D.25505>:
          }
          <D.25486>:
          <D.25480>:
          <D.25474>:
          goto <D.23559>;
        }
        <D.23603>:
        <D.23604>:
        <D.23605>:
        {
          gboolean is_inflated;
          WrapperSubtype subtype;

          p.47 = p;
          is_inflated = decode_value (p.47, &p);
          if (is_inflated != 0) goto <D.25506>; else goto <D.25507>;
          <D.25506>:
          {
            struct MonoClass * klass;
            struct MonoMethod * invoke;
            struct MonoMethod * wrapper;

            p.47 = p;
            klass = decode_klass_ref (module, p.47, &p);
            if (klass == 0B) goto <D.25508>; else goto <D.25509>;
            <D.25508>:
            D.25287 = 0;
            return D.25287;
            <D.25509>:
            switch (wrapper_type) <default: <D.23615>, case 1: <D.23611>, case 2: <D.23613>, case 3: <D.23614>>
            <D.23611>:
            invoke = mono_get_delegate_invoke (klass);
            wrapper = mono_marshal_get_delegate_invoke (invoke, 0B);
            goto <D.23612>;
            <D.23613>:
            invoke = mono_get_delegate_begin_invoke (klass);
            wrapper = mono_marshal_get_delegate_begin_invoke (invoke);
            goto <D.23612>;
            <D.23614>:
            invoke = mono_get_delegate_end_invoke (klass);
            wrapper = mono_marshal_get_delegate_end_invoke (invoke);
            goto <D.23612>;
            <D.23615>:
            monoeg_assertion_message ("* Assertion: should not be reached at %s:%d\n", "aot-runtime.c", 1084);
            <D.23612>:
            if (target != 0B) goto <D.25510>; else goto <D.25511>;
            <D.25510>:
            if (wrapper != target) goto <D.25512>; else goto <D.25513>;
            <D.25512>:
            D.25287 = 0;
            return D.25287;
            <D.25513>:
            <D.25511>:
            ref->method = wrapper;
          }
          goto <D.25514>;
          <D.25507>:
          if (target == 0B) goto <D.25515>; else goto <D.25516>;
          <D.25515>:
          D.25287 = 0;
          return D.25287;
          <D.25516>:
          if (wrapper_type == 1) goto <D.25517>; else goto <D.25518>;
          <D.25517>:
          {
            struct WrapperInfo * info;

            p.47 = p;
            D.25519 = decode_value (p.47, &p);
            subtype = (WrapperSubtype) D.25519;
            info = mono_marshal_get_wrapper_info (target);
            if (info != 0B) goto <D.25520>; else goto <D.25521>;
            <D.25520>:
            D.25522 = info->subtype;
            if (D.25522 != subtype) goto <D.25523>; else goto <D.25524>;
            <D.25523>:
            D.25287 = 0;
            return D.25287;
            <D.25524>:
            goto <D.25525>;
            <D.25521>:
            if (subtype != 0) goto <D.25526>; else goto <D.25527>;
            <D.25526>:
            D.25287 = 0;
            return D.25287;
            <D.25527>:
            <D.25525>:
          }
          <D.25518>:
          p.47 = p;
          D.25528 = sig_matches_target (module, target, p.47, &p);
          if (D.25528 != 0) goto <D.25529>; else goto <D.25530>;
          <D.25529>:
          ref->method = target;
          goto <D.25531>;
          <D.25530>:
          D.25287 = 0;
          return D.25287;
          <D.25531>:
          <D.25514>:
          goto <D.23559>;
        }
        <D.23617>:
        {
          struct MonoMethod * m;
          struct MonoClass * klass;

          p.47 = p;
          m = decode_resolve_method_ref (module, p.47, &p);
          if (m == 0B) goto <D.25532>; else goto <D.25533>;
          <D.25532>:
          D.25287 = 0;
          return D.25287;
          <D.25533>:
          p.47 = p;
          klass = decode_klass_ref (module, p.47, &p);
          if (klass == 0B) goto <D.25534>; else goto <D.25535>;
          <D.25534>:
          D.25287 = 0;
          return D.25287;
          <D.25535>:
          D.25536 = mono_marshal_get_managed_wrapper (m, klass, 0);
          ref->method = D.25536;
          goto <D.23559>;
        }
        <D.23620>:
        monoeg_assertion_message ("* Assertion: should not be reached at %s:%d\n", "aot-runtime.c", 1132);
        <D.23559>:
      }
      goto <D.25537>;
      <D.25289>:
      if (image_index == 254) goto <D.25538>; else goto <D.25539>;
      <D.25538>:
      p.47 = p;
      D.25540 = decode_value (p.47, &p);
      image_index = (guint32) D.25540;
      p.47 = p;
      D.25541 = decode_value (p.47, &p);
      D.25542 = (unsigned int) D.25541;
      ref->token = D.25542;
      image_index.52 = (int) image_index;
      image = load_image (module, image_index.52, 1);
      if (image == 0B) goto <D.25544>; else goto <D.25545>;
      <D.25544>:
      D.25287 = 0;
      return D.25287;
      <D.25545>:
      goto <D.25546>;
      <D.25539>:
      if (image_index == 253) goto <D.25547>; else goto <D.25548>;
      <D.25547>:
      {
        struct MonoClass * klass;
        struct MonoGenericContext ctx;

        try
          {
            p.47 = p;
            klass = decode_klass_ref (module, p.47, &p);
            if (klass == 0B) goto <D.25549>; else goto <D.25550>;
            <D.25549>:
            D.25287 = 0;
            return D.25287;
            <D.25550>:
            if (target != 0B) goto <D.25551>; else goto <D.25552>;
            <D.25551>:
            D.25368 = target->klass;
            if (D.25368 != klass) goto <D.25553>; else goto <D.25554>;
            <D.25553>:
            D.25287 = 0;
            return D.25287;
            <D.25554>:
            <D.25552>:
            p.47 = p;
            D.25555 = decode_value (p.47, &p);
            image_index = (guint32) D.25555;
            p.47 = p;
            D.25556 = decode_value (p.47, &p);
            D.25557 = (unsigned int) D.25556;
            ref->token = D.25557;
            image_index.52 = (int) image_index;
            image = load_image (module, image_index.52, 1);
            if (image == 0B) goto <D.25558>; else goto <D.25559>;
            <D.25558>:
            D.25287 = 0;
            return D.25287;
            <D.25559>:
            D.25560 = ref->token;
            D.25561 = mono_get_method_full (image, D.25560, 0B, 0B);
            ref->method = D.25561;
            D.25326 = ref->method;
            if (D.25326 == 0B) goto <D.25562>; else goto <D.25563>;
            <D.25562>:
            D.25287 = 0;
            return D.25287;
            <D.25563>:
            memset (&ctx, 0, 16);
            if (0 != 0) goto <D.25564>; else goto <D.25565>;
            <D.25564>:
            D.25566 = klass->generic_class;
            D.25567 = D.25566->context.class_inst;
            ctx.class_inst = D.25567;
            ctx.method_inst = 0B;
            D.25326 = ref->method;
            D.25568 = mono_class_inflate_generic_method_full (D.25326, klass, &ctx);
            ref->method = D.25568;
            <D.25565>:
            memset (&ctx, 0, 16);
            p.47 = p;
            D.25569 = decode_generic_context (module, &ctx, p.47, &p);
            if (D.25569 == 0) goto <D.25570>; else goto <D.25571>;
            <D.25570>:
            D.25287 = 0;
            return D.25287;
            <D.25571>:
            D.25326 = ref->method;
            D.25572 = mono_class_inflate_generic_method_full (D.25326, klass, &ctx);
            ref->method = D.25572;
          }
        finally
          {
            ctx = {CLOBBER};
          }
      }
      goto <D.25573>;
      <D.25548>:
      if (image_index == 250) goto <D.25574>; else goto <D.25575>;
      <D.25574>:
      {
        struct MonoClass * klass;
        int method_type;

        p.47 = p;
        klass = decode_klass_ref (module, p.47, &p);
        if (klass == 0B) goto <D.25576>; else goto <D.25577>;
        <D.25576>:
        D.25287 = 0;
        return D.25287;
        <D.25577>:
        p.47 = p;
        method_type = decode_value (p.47, &p);
        switch (method_type) <default: <D.23631>, case 0: <D.23625>, case 1: <D.23627>, case 2: <D.23628>, case 3: <D.23629>, case 4: <D.23630>>
        <D.23625>:
        D.25578 = klass->rank;
        D.25579 = (int) D.25578;
        D.25580 = mono_class_get_method_from_name (klass, ".ctor", D.25579);
        ref->method = D.25580;
        goto <D.23626>;
        <D.23627>:
        D.25578 = klass->rank;
        D.25579 = (int) D.25578;
        D.25581 = D.25579 * 2;
        D.25582 = mono_class_get_method_from_name (klass, ".ctor", D.25581);
        ref->method = D.25582;
        goto <D.23626>;
        <D.23628>:
        D.25583 = mono_class_get_method_from_name (klass, "Get", -1);
        ref->method = D.25583;
        goto <D.23626>;
        <D.23629>:
        D.25584 = mono_class_get_method_from_name (klass, "Address", -1);
        ref->method = D.25584;
        goto <D.23626>;
        <D.23630>:
        D.25585 = mono_class_get_method_from_name (klass, "Set", -1);
        ref->method = D.25585;
        goto <D.23626>;
        <D.23631>:
        monoeg_assertion_message ("* Assertion: should not be reached at %s:%d\n", "aot-runtime.c", 1207);
        <D.23626>:
      }
      goto <D.25586>;
      <D.25575>:
      if (image_index == 249) goto <D.25587>; else goto <D.25588>;
      <D.25587>:
      p.47 = p;
      D.25589 = decode_value (p.47, &p);
      image_index = (guint32) D.25589;
      p.47 = p;
      D.25590 = decode_value (p.47, &p);
      value = (guint32) D.25590;
      <D.25588>:
      D.25591 = value & 16777215;
      D.25592 = D.25591 | 100663296;
      ref->token = D.25592;
      image_index.52 = (int) image_index;
      image = load_image (module, image_index.52, 1);
      if (image == 0B) goto <D.25593>; else goto <D.25594>;
      <D.25593>:
      D.25287 = 0;
      return D.25287;
      <D.25594>:
      <D.25586>:
      <D.25573>:
      <D.25546>:
      <D.25537>:
      p.47 = p;
      *endbuf = p.47;
      ref->image = image;
      D.25287 = 1;
      return D.25287;
    }
  finally
    {
      p = {CLOBBER};
    }
}


decode_signature_with_target (struct MonoAotModule * module, struct MonoMethodSignature * target, guint8 * buf, guint8 * * endbuf)
{
  guint8 * p.53;
  unsigned char D.25600;
  guint8 * p.54;
  unsigned int D.25602;
  _Bool D.25603;
  unsigned int D.25604;
  _Bool D.25605;
  unsigned int D.25606;
  _Bool D.25607;
  int flags.55;
  short unsigned int D.25613;
  int D.25614;
  struct MonoMethodSignature * D.25617;
  long unsigned int D.25618;
  long unsigned int D.25619;
  long unsigned int D.25620;
  short unsigned int D.25621;
  unsigned char D.25622;
  <unnamed-unsigned:1> D.25623;
  unsigned char D.25624;
  <unnamed-unsigned:1> D.25625;
  unsigned char D.25626;
  <unnamed-unsigned:6> D.25627;
  struct MonoType * D.25628;
  long unsigned int D.25631;
  long unsigned int D.25632;
  _Bool D.25633;
  long int D.25634;
  long int D.25635;
  short int D.25638;
  struct MonoType * D.25639;
  long unsigned int D.25640;
  short unsigned int D.25643;
  short int D.25644;
  struct MonoMethodSignature * sig;
  guint32 flags;
  int i;
  int param_count;
  int call_conv;
  int gen_param_count;
  guint8 * p;
  gboolean hasthis;
  gboolean explicit_this;
  gboolean has_gen_params;

  try
    {
      gen_param_count = 0;
      p = buf;
      p.53 = p;
      D.25600 = *p.53;
      flags = (guint32) D.25600;
      p.53 = p;
      p.54 = p.53 + 1;
      p = p.54;
      D.25602 = flags & 16;
      D.25603 = D.25602 != 0;
      has_gen_params = (gboolean) D.25603;
      D.25604 = flags & 32;
      D.25605 = D.25604 != 0;
      hasthis = (gboolean) D.25605;
      D.25606 = flags & 64;
      D.25607 = D.25606 != 0;
      explicit_this = (gboolean) D.25607;
      flags.55 = (int) flags;
      call_conv = flags.55 & 15;
      if (has_gen_params != 0) goto <D.25609>; else goto <D.25610>;
      <D.25609>:
      p.53 = p;
      gen_param_count = decode_value (p.53, &p);
      <D.25610>:
      p.53 = p;
      param_count = decode_value (p.53, &p);
      if (target != 0B) goto <D.25611>; else goto <D.25612>;
      <D.25611>:
      D.25613 = target->param_count;
      D.25614 = (int) D.25613;
      if (D.25614 != param_count) goto <D.25615>; else goto <D.25616>;
      <D.25615>:
      D.25617 = 0B;
      return D.25617;
      <D.25616>:
      <D.25612>:
      D.25618 = (long unsigned int) param_count;
      D.25619 = D.25618 + 2;
      D.25620 = D.25619 * 8;
      sig = monoeg_malloc0 (D.25620);
      D.25621 = (short unsigned int) param_count;
      sig->param_count = D.25621;
      sig->sentinelpos = -1;
      D.25622 = (unsigned char) hasthis;
      D.25623 = (<unnamed-unsigned:1>) D.25622;
      sig->hasthis = D.25623;
      D.25624 = (unsigned char) explicit_this;
      D.25625 = (<unnamed-unsigned:1>) D.25624;
      sig->explicit_this = D.25625;
      D.25626 = (unsigned char) call_conv;
      D.25627 = (<unnamed-unsigned:6>) D.25626;
      sig->call_convention = D.25627;
      D.25621 = (short unsigned int) param_count;
      sig->param_count = D.25621;
      p.53 = p;
      D.25628 = decode_type (module, p.53, &p);
      sig->ret = D.25628;
      i = 0;
      goto <D.23523>;
      <D.23522>:
      p.53 = p;
      D.25600 = *p.53;
      if (D.25600 == 65) goto <D.25629>; else goto <D.25630>;
      <D.25629>:
      D.25631 = BIT_FIELD_REF <*sig, 64, 64>;
      D.25632 = D.25631 & 64512;
      D.25633 = D.25632 != 5120;
      D.25634 = (long int) D.25633;
      D.25635 = __builtin_expect (D.25634, 0);
      if (D.25635 != 0) goto <D.25636>; else goto <D.25637>;
      <D.25636>:
      monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "aot-runtime.c", 706, "sig->call_convention == MONO_CALL_VARARG");
      <D.25637>:
      D.25638 = (short int) i;
      sig->sentinelpos = D.25638;
      p.53 = p;
      p.54 = p.53 + 1;
      p = p.54;
      <D.25630>:
      p.53 = p;
      D.25639 = decode_type (module, p.53, &p);
      sig->params[i] = D.25639;
      i = i + 1;
      <D.23523>:
      if (i < param_count) goto <D.23522>; else goto <D.23524>;
      <D.23524>:
      D.25631 = BIT_FIELD_REF <*sig, 64, 64>;
      D.25640 = D.25631 & 281470681807872;
      if (D.25640 == 281470681748480) goto <D.25641>; else goto <D.25642>;
      <D.25641>:
      D.25643 = sig->param_count;
      D.25644 = (short int) D.25643;
      sig->sentinelpos = D.25644;
      <D.25642>:
      p.53 = p;
      *endbuf = p.53;
      D.25617 = sig;
      return D.25617;
    }
  finally
    {
      p = {CLOBBER};
    }
}


decode_type (struct MonoAotModule * module, guint8 * buf, guint8 * * endbuf)
{
  guint8 * p.56;
  unsigned char D.25648;
  guint8 * p.57;
  unsigned char D.25654;
  int D.25655;
  struct MonoClass * D.25656;
  struct MonoClass * D.25657;
  struct MonoClass * D.25658;
  struct MonoType * D.25661;
  struct MonoType * D.25662;
  struct MonoGenericContainer * D.25665;
  _Bool D.25666;
  long int D.25667;
  long int D.25668;
  struct MonoGenericInst * D.25671;
  struct MonoGenericInst * D.25672;
  struct MonoType * D.25675;
  struct MonoGenericClass * D.25676;
  struct MonoClass * D.25677;
  struct MonoClass * D.25678;
  int D.25681;
  unsigned char D.25682;
  int D.25683;
  unsigned char D.25684;
  unsigned char D.25685;
  long unsigned int D.25688;
  long unsigned int D.25689;
  void * D.25690;
  int * D.25691;
  long unsigned int D.25692;
  long unsigned int D.25693;
  int * D.25694;
  int D.25695;
  int D.25696;
  int D.25697;
  unsigned char D.25698;
  unsigned char D.25699;
  long unsigned int D.25702;
  long unsigned int D.25703;
  void * D.25704;
  int * D.25705;
  int * D.25706;
  int D.25707;
  int D.25708;
  struct MonoGenericParam * D.25711;
  guint8 * p;
  struct MonoType * t;

  try
    {
      p = buf;
      t = monoeg_malloc0 (16);
      <D.23464>:
      p.56 = p;
      D.25648 = *p.56;
      if (D.25648 == 69) goto <D.25649>; else goto <D.25650>;
      <D.25649>:
      t->pinned = 1;
      p.56 = p;
      p.57 = p.56 + 1;
      p = p.57;
      goto <D.25652>;
      <D.25650>:
      p.56 = p;
      D.25648 = *p.56;
      if (D.25648 == 16) goto <D.25653>; else goto <D.23463>;
      <D.25653>:
      t->byref = 1;
      p.56 = p;
      p.57 = p.56 + 1;
      p = p.57;
      <D.25652>:
      goto <D.23464>;
      <D.23463>:
      p.56 = p;
      D.25648 = *p.56;
      t->type = D.25648;
      p.56 = p;
      p.57 = p.56 + 1;
      p = p.57;
      D.25654 = t->type;
      D.25655 = (int) D.25654;
      switch (D.25655) <default: <D.23505>, case 1: <D.23465>, case 2: <D.23466>, case 3: <D.23467>, case 4: <D.23468>, case 5: <D.23469>, case 6: <D.23470>, case 7: <D.23471>, case 8: <D.23472>, case 9: <D.23473>, case 10: <D.23474>, case 11: <D.23475>, case 12: <D.23476>, case 13: <D.23477>, case 14: <D.23480>, case 15: <D.23487>, case 17: <D.23484>, case 18: <D.23485>, case 19: <D.23502>, case 20: <D.23493>, case 21: <D.23488>, case 22: <D.23482>, case 24: <D.23478>, case 25: <D.23479>, case 28: <D.23481>, case 29: <D.23486>, case 30: <D.23503>>
      <D.23465>:
      <D.23466>:
      <D.23467>:
      <D.23468>:
      <D.23469>:
      <D.23470>:
      <D.23471>:
      <D.23472>:
      <D.23473>:
      <D.23474>:
      <D.23475>:
      <D.23476>:
      <D.23477>:
      <D.23478>:
      <D.23479>:
      <D.23480>:
      <D.23481>:
      <D.23482>:
      goto <D.23483>;
      <D.23484>:
      <D.23485>:
      p.56 = p;
      D.25656 = decode_klass_ref (module, p.56, &p);
      t->data.klass = D.25656;
      goto <D.23483>;
      <D.23486>:
      p.56 = p;
      D.25657 = decode_klass_ref (module, p.56, &p);
      t->data.klass = D.25657;
      D.25658 = t->data.klass;
      if (D.25658 == 0B) goto <D.25659>; else goto <D.25660>;
      <D.25659>:
      D.25661 = 0B;
      return D.25661;
      <D.25660>:
      goto <D.23483>;
      <D.23487>:
      p.56 = p;
      D.25662 = decode_type (module, p.56, &p);
      t->data.type = D.25662;
      goto <D.23483>;
      <D.23488>:
      {
        struct MonoClass * gclass;
        struct MonoGenericContext ctx;
        struct MonoType * type;
        struct MonoClass * klass;

        try
          {
            p.56 = p;
            gclass = decode_klass_ref (module, p.56, &p);
            if (gclass == 0B) goto <D.25663>; else goto <D.25664>;
            <D.25663>:
            D.25661 = 0B;
            return D.25661;
            <D.25664>:
            D.25665 = gclass->generic_container;
            D.25666 = D.25665 == 0B;
            D.25667 = (long int) D.25666;
            D.25668 = __builtin_expect (D.25667, 0);
            if (D.25668 != 0) goto <D.25669>; else goto <D.25670>;
            <D.25669>:
            monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "aot-runtime.c", 620, "gclass->generic_container");
            <D.25670>:
            memset (&ctx, 0, 16);
            p.56 = p;
            D.25671 = decode_generic_inst (module, p.56, &p);
            ctx.class_inst = D.25671;
            D.25672 = ctx.class_inst;
            if (D.25672 == 0B) goto <D.25673>; else goto <D.25674>;
            <D.25673>:
            D.25661 = 0B;
            return D.25661;
            <D.25674>:
            D.25675 = &gclass->byval_arg;
            type = mono_class_inflate_generic_type (D.25675, &ctx);
            klass = mono_class_from_mono_type (type);
            D.25676 = klass->generic_class;
            t->data.generic_class = D.25676;
            goto <D.23483>;
          }
        finally
          {
            ctx = {CLOBBER};
          }
      }
      <D.23493>:
      {
        struct MonoArrayType * array;
        int i;

        array = monoeg_malloc0 (32);
        p.56 = p;
        D.25677 = decode_klass_ref (module, p.56, &p);
        array->eklass = D.25677;
        D.25678 = array->eklass;
        if (D.25678 == 0B) goto <D.25679>; else goto <D.25680>;
        <D.25679>:
        D.25661 = 0B;
        return D.25661;
        <D.25680>:
        p.56 = p;
        D.25681 = decode_value (p.56, &p);
        D.25682 = (unsigned char) D.25681;
        array->rank = D.25682;
        p.56 = p;
        D.25683 = decode_value (p.56, &p);
        D.25684 = (unsigned char) D.25683;
        array->numsizes = D.25684;
        D.25685 = array->numsizes;
        if (D.25685 != 0) goto <D.25686>; else goto <D.25687>;
        <D.25686>:
        D.25685 = array->numsizes;
        D.25688 = (long unsigned int) D.25685;
        D.25689 = D.25688 * 4;
        D.25690 = monoeg_malloc0 (D.25689);
        array->sizes = D.25690;
        <D.25687>:
        i = 0;
        goto <D.23497>;
        <D.23496>:
        D.25691 = array->sizes;
        D.25692 = (long unsigned int) i;
        D.25693 = D.25692 * 4;
        D.25694 = D.25691 + D.25693;
        p.56 = p;
        D.25695 = decode_value (p.56, &p);
        *D.25694 = D.25695;
        i = i + 1;
        <D.23497>:
        D.25685 = array->numsizes;
        D.25696 = (int) D.25685;
        if (D.25696 > i) goto <D.23496>; else goto <D.23498>;
        <D.23498>:
        p.56 = p;
        D.25697 = decode_value (p.56, &p);
        D.25698 = (unsigned char) D.25697;
        array->numlobounds = D.25698;
        D.25699 = array->numlobounds;
        if (D.25699 != 0) goto <D.25700>; else goto <D.25701>;
        <D.25700>:
        D.25699 = array->numlobounds;
        D.25702 = (long unsigned int) D.25699;
        D.25703 = D.25702 * 4;
        D.25704 = monoeg_malloc0 (D.25703);
        array->lobounds = D.25704;
        <D.25701>:
        i = 0;
        goto <D.23500>;
        <D.23499>:
        D.25705 = array->lobounds;
        D.25692 = (long unsigned int) i;
        D.25693 = D.25692 * 4;
        D.25706 = D.25705 + D.25693;
        p.56 = p;
        D.25707 = decode_value (p.56, &p);
        *D.25706 = D.25707;
        i = i + 1;
        <D.23500>:
        D.25699 = array->numlobounds;
        D.25708 = (int) D.25699;
        if (D.25708 > i) goto <D.23499>; else goto <D.23501>;
        <D.23501>:
        t->data.array = array;
        goto <D.23483>;
      }
      <D.23502>:
      <D.23503>:
      {
        struct MonoClass * klass;

        p.56 = p;
        klass = decode_klass_ref (module, p.56, &p);
        if (klass == 0B) goto <D.25709>; else goto <D.25710>;
        <D.25709>:
        D.25661 = 0B;
        return D.25661;
        <D.25710>:
        D.25711 = klass->byval_arg.data.generic_param;
        t->data.generic_param = D.25711;
        goto <D.23483>;
      }
      <D.23505>:
      monoeg_assertion_message ("* Assertion: should not be reached at %s:%d\n", "aot-runtime.c", 665);
      <D.23483>:
      p.56 = p;
      *endbuf = p.56;
      D.25661 = t;
      return D.25661;
    }
  finally
    {
      p = {CLOBBER};
    }
}


decode_generic_inst (struct MonoAotModule * module, guint8 * buf, guint8 * * endbuf)
{
  guint8 * p.58;
  long unsigned int D.25718;
  long unsigned int D.25719;
  struct MonoGenericInst * D.25722;
  long unsigned int D.25723;
  long unsigned int D.25724;
  struct MonoType * * D.25725;
  struct MonoType * D.25726;
  int type_argc;
  int i;
  struct MonoType * * type_argv;
  struct MonoGenericInst * inst;
  guint8 * p;

  try
    {
      p = buf;
      p.58 = p;
      type_argc = decode_value (p.58, &p);
      D.25718 = (long unsigned int) type_argc;
      D.25719 = D.25718 * 8;
      type_argv = monoeg_malloc0 (D.25719);
      i = 0;
      goto <D.23398>;
      <D.23397>:
      {
        struct MonoClass * pclass;

        p.58 = p;
        pclass = decode_klass_ref (module, p.58, &p);
        if (pclass == 0B) goto <D.25720>; else goto <D.25721>;
        <D.25720>:
        monoeg_g_free (type_argv);
        D.25722 = 0B;
        return D.25722;
        <D.25721>:
        D.25723 = (long unsigned int) i;
        D.25724 = D.25723 * 8;
        D.25725 = type_argv + D.25724;
        D.25726 = &pclass->byval_arg;
        *D.25725 = D.25726;
      }
      i = i + 1;
      <D.23398>:
      if (i < type_argc) goto <D.23397>; else goto <D.23399>;
      <D.23399>:
      inst = mono_metadata_get_generic_inst (type_argc, type_argv);
      monoeg_g_free (type_argv);
      p.58 = p;
      *endbuf = p.58;
      D.25722 = inst;
      return D.25722;
    }
  finally
    {
      p = {CLOBBER};
    }
}


sig_matches_target (struct MonoAotModule * module, struct MonoMethod * target, guint8 * buf, guint8 * * endbuf)
{
  struct MonoMethodSignature * D.25729;
  guint8 * p.59;
  int iftmp.60;
  struct MonoMethodSignature * D.25735;
  int D.25736;
  gboolean D.25738;
  struct MonoMethodSignature * sig;
  gboolean res;
  guint8 * p;

  try
    {
      p = buf;
      D.25729 = mono_method_signature (target);
      p.59 = p;
      sig = decode_signature_with_target (module, D.25729, p.59, &p);
      if (sig != 0B) goto <D.25734>; else goto <D.25732>;
      <D.25734>:
      D.25735 = mono_method_signature (target);
      D.25736 = mono_metadata_signature_equal (D.25735, sig);
      if (D.25736 != 0) goto <D.25737>; else goto <D.25732>;
      <D.25737>:
      iftmp.60 = 1;
      goto <D.25733>;
      <D.25732>:
      iftmp.60 = 0;
      <D.25733>:
      res = iftmp.60;
      monoeg_g_free (sig);
      p.59 = p;
      *endbuf = p.59;
      D.25738 = res;
      return D.25738;
    }
  finally
    {
      p = {CLOBBER};
    }
}


decode_resolve_method_ref (struct MonoAotModule * module, guint8 * buf, guint8 * * endbuf)
{
  struct MonoMethod * D.25741;

  D.25741 = decode_resolve_method_ref_with_target (module, 0B, buf, endbuf);
  return D.25741;
}


decode_resolve_method_ref_with_target (struct MonoAotModule * module, struct MonoMethod * target, guint8 * buf, guint8 * * endbuf)
{
  struct MonoMethod * D.25745;
  struct MonoMethod * D.25746;
  struct MonoImage * D.25749;
  unsigned int D.25752;
  struct MethodRef ref;
  gboolean res;

  try
    {
      res = decode_method_ref_with_target (module, &ref, target, buf, endbuf);
      if (res == 0) goto <D.25743>; else goto <D.25744>;
      <D.25743>:
      D.25745 = 0B;
      return D.25745;
      <D.25744>:
      D.25746 = ref.method;
      if (D.25746 != 0B) goto <D.25747>; else goto <D.25748>;
      <D.25747>:
      D.25745 = ref.method;
      return D.25745;
      <D.25748>:
      D.25749 = ref.image;
      if (D.25749 == 0B) goto <D.25750>; else goto <D.25751>;
      <D.25750>:
      D.25745 = 0B;
      return D.25745;
      <D.25751>:
      D.25749 = ref.image;
      D.25752 = ref.token;
      D.25745 = mono_get_method (D.25749, D.25752, 0B);
      return D.25745;
    }
  finally
    {
      ref = {CLOBBER};
    }
}


decode_generic_context (struct MonoAotModule * module, struct MonoGenericContext * ctx, guint8 * buf, guint8 * * endbuf)
{
  guint8 * p.61;
  struct MonoGenericInst * D.25758;
  struct MonoGenericInst * D.25759;
  gboolean D.25762;
  struct MonoGenericInst * D.25765;
  struct MonoGenericInst * D.25766;
  guint8 * p;
  guint8 * p2;
  int argc;

  try
    {
      p = buf;
      p2 = p;
      p.61 = p;
      argc = decode_value (p.61, &p);
      if (argc != 0) goto <D.25756>; else goto <D.25757>;
      <D.25756>:
      p = p2;
      p.61 = p;
      D.25758 = decode_generic_inst (module, p.61, &p);
      ctx->class_inst = D.25758;
      D.25759 = ctx->class_inst;
      if (D.25759 == 0B) goto <D.25760>; else goto <D.25761>;
      <D.25760>:
      D.25762 = 0;
      return D.25762;
      <D.25761>:
      <D.25757>:
      p2 = p;
      p.61 = p;
      argc = decode_value (p.61, &p);
      if (argc != 0) goto <D.25763>; else goto <D.25764>;
      <D.25763>:
      p = p2;
      p.61 = p;
      D.25765 = decode_generic_inst (module, p.61, &p);
      ctx->method_inst = D.25765;
      D.25766 = ctx->method_inst;
      if (D.25766 == 0B) goto <D.25767>; else goto <D.25768>;
      <D.25767>:
      D.25762 = 0;
      return D.25762;
      <D.25768>:
      <D.25764>:
      p.61 = p;
      *endbuf = p.61;
      D.25762 = 1;
      return D.25762;
    }
  finally
    {
      p = {CLOBBER};
    }
}


decode_klass_ref (struct MonoAotModule * module, guint8 * buf, guint8 * * endbuf)
{
  guint8 * p.62;
  struct MonoClass * D.25774;
  int D.25775;
  unsigned int D.25778;
  int D.25779;
  int D.25780;
  int D.25783;
  struct MonoAssembly * D.25784;
  struct MonoGenericContainer * D.25789;
  _Bool D.25790;
  long int D.25791;
  long int D.25792;
  struct MonoGenericInst * D.25795;
  struct MonoGenericInst * D.25796;
  struct MonoType * D.25799;
  _Bool D.25804;
  long int D.25805;
  long int D.25806;
  _Bool D.25812;
  long int D.25813;
  long int D.25814;
  unsigned char D.25820;
  struct MonoGenericParamFull * D.25823;
  long unsigned int D.25824;
  long unsigned int D.25825;
  struct MonoGenericParamFull * D.25826;
  _Bool D.25827;
  long int D.25828;
  long int D.25829;
  short unsigned int D.25833;
  short unsigned int D.25834;
  struct MonoImage * D.25835;
  int D.25836;
  int D.25839;
  guint8 * D.25840;
  sizetype D.25841;
  guint8 * p2.63;
  guint8 * p2.64;
  _Bool D.25844;
  long int D.25845;
  long int D.25846;
  struct MonoImage * image;
  struct MonoClass * klass;
  struct MonoClass * eklass;
  guint32 token;
  guint32 rank;
  guint32 idx;
  guint8 * p;
  int reftype;

  try
    {
      klass = 0B;
      p = buf;
      p.62 = p;
      reftype = decode_value (p.62, &p);
      if (reftype == 0) goto <D.25772>; else goto <D.25773>;
      <D.25772>:
      p.62 = p;
      *endbuf = p.62;
      D.25774 = 0B;
      return D.25774;
      <D.25773>:
      switch (reftype) <default: <D.23447>, case 1: <D.23422>, case 2: <D.23424>, case 3: <D.23425>, case 4: <D.23426>, case 5: <D.23430>, case 6: <D.23441>, case 7: <D.23444>, case 8: <D.23442>>
      <D.23422>:
      p.62 = p;
      D.25775 = decode_value (p.62, &p);
      idx = (guint32) D.25775;
      image = load_image (module, 0, 1);
      if (image == 0B) goto <D.25776>; else goto <D.25777>;
      <D.25776>:
      D.25774 = 0B;
      return D.25774;
      <D.25777>:
      D.25778 = idx + 33554432;
      klass = mono_class_get (image, D.25778);
      goto <D.23423>;
      <D.23424>:
      p.62 = p;
      D.25779 = decode_value (p.62, &p);
      idx = (guint32) D.25779;
      p.62 = p;
      D.25780 = decode_value (p.62, &p);
      image = load_image (module, D.25780, 1);
      if (image == 0B) goto <D.25781>; else goto <D.25782>;
      <D.25781>:
      D.25774 = 0B;
      return D.25774;
      <D.25782>:
      D.25778 = idx + 33554432;
      klass = mono_class_get (image, D.25778);
      goto <D.23423>;
      <D.23425>:
      p.62 = p;
      D.25783 = decode_value (p.62, &p);
      token = (guint32) D.25783;
      D.25784 = module->assembly;
      image = D.25784->image;
      if (image == 0B) goto <D.25785>; else goto <D.25786>;
      <D.25785>:
      D.25774 = 0B;
      return D.25774;
      <D.25786>:
      klass = mono_class_get (image, token);
      goto <D.23423>;
      <D.23426>:
      {
        struct MonoClass * gclass;
        struct MonoGenericContext ctx;
        struct MonoType * type;

        try
          {
            p.62 = p;
            gclass = decode_klass_ref (module, p.62, &p);
            if (gclass == 0B) goto <D.25787>; else goto <D.25788>;
            <D.25787>:
            D.25774 = 0B;
            return D.25774;
            <D.25788>:
            D.25789 = gclass->generic_container;
            D.25790 = D.25789 == 0B;
            D.25791 = (long int) D.25790;
            D.25792 = __builtin_expect (D.25791, 0);
            if (D.25792 != 0) goto <D.25793>; else goto <D.25794>;
            <D.25793>:
            monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "aot-runtime.c", 435, "gclass->generic_container");
            <D.25794>:
            memset (&ctx, 0, 16);
            p.62 = p;
            D.25795 = decode_generic_inst (module, p.62, &p);
            ctx.class_inst = D.25795;
            D.25796 = ctx.class_inst;
            if (D.25796 == 0B) goto <D.25797>; else goto <D.25798>;
            <D.25797>:
            D.25774 = 0B;
            return D.25774;
            <D.25798>:
            D.25799 = &gclass->byval_arg;
            type = mono_class_inflate_generic_type (D.25799, &ctx);
            klass = mono_class_from_mono_type (type);
            mono_metadata_free_type (type);
            goto <D.23423>;
          }
        finally
          {
            ctx = {CLOBBER};
          }
      }
      <D.23430>:
      {
        struct MonoType * t;
        struct MonoGenericContainer * container;
        int type;
        int num;
        gboolean has_container;
        int serial;

        container = 0B;
        p.62 = p;
        type = decode_value (p.62, &p);
        p.62 = p;
        num = decode_value (p.62, &p);
        p.62 = p;
        has_container = decode_value (p.62, &p);
        serial = 0;
        if (has_container != 0) goto <D.25800>; else goto <D.25801>;
        <D.25800>:
        {
          gboolean is_method;

          p.62 = p;
          is_method = decode_value (p.62, &p);
          if (is_method != 0) goto <D.25802>; else goto <D.25803>;
          <D.25802>:
          {
            struct MonoMethod * method_def;

            D.25804 = type != 30;
            D.25805 = (long int) D.25804;
            D.25806 = __builtin_expect (D.25805, 0);
            if (D.25806 != 0) goto <D.25807>; else goto <D.25808>;
            <D.25807>:
            monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "aot-runtime.c", 459, "type == MONO_TYPE_MVAR");
            <D.25808>:
            p.62 = p;
            method_def = decode_resolve_method_ref (module, p.62, &p);
            if (method_def == 0B) goto <D.25809>; else goto <D.25810>;
            <D.25809>:
            D.25774 = 0B;
            return D.25774;
            <D.25810>:
            container = mono_method_get_generic_container (method_def);
          }
          goto <D.25811>;
          <D.25803>:
          {
            struct MonoClass * class_def;

            D.25812 = type != 19;
            D.25813 = (long int) D.25812;
            D.25814 = __builtin_expect (D.25813, 0);
            if (D.25814 != 0) goto <D.25815>; else goto <D.25816>;
            <D.25815>:
            monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "aot-runtime.c", 467, "type == MONO_TYPE_VAR");
            <D.25816>:
            p.62 = p;
            class_def = decode_klass_ref (module, p.62, &p);
            if (class_def == 0B) goto <D.25817>; else goto <D.25818>;
            <D.25817>:
            D.25774 = 0B;
            return D.25774;
            <D.25818>:
            container = class_def->generic_container;
          }
          <D.25811>:
        }
        goto <D.25819>;
        <D.25801>:
        p.62 = p;
        serial = decode_value (p.62, &p);
        <D.25819>:
        t = monoeg_malloc0 (16);
        D.25820 = (unsigned char) type;
        t->type = D.25820;
        if (container != 0B) goto <D.25821>; else goto <D.25822>;
        <D.25821>:
        D.25823 = container->type_params;
        D.25824 = (long unsigned int) num;
        D.25825 = D.25824 * 56;
        D.25826 = D.25823 + D.25825;
        t->data.generic_param = D.25826;
        D.25827 = serial != 0;
        D.25828 = (long int) D.25827;
        D.25829 = __builtin_expect (D.25828, 0);
        if (D.25829 != 0) goto <D.25830>; else goto <D.25831>;
        <D.25830>:
        monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "aot-runtime.c", 483, "serial == 0");
        <D.25831>:
        goto <D.25832>;
        <D.25822>:
        {
          struct MonoGenericParam * par;

          par = monoeg_malloc0 (56);
          D.25833 = (short unsigned int) num;
          par->num = D.25833;
          D.25834 = (short unsigned int) serial;
          par->serial = D.25834;
          D.25835 = mono_defaults.corlib;
          par->image = D.25835;
          t->data.generic_param = par;
        }
        <D.25832>:
        klass = mono_class_from_mono_type (t);
        monoeg_g_free (t);
        goto <D.23423>;
      }
      <D.23441>:
      p.62 = p;
      D.25836 = decode_value (p.62, &p);
      rank = (guint32) D.25836;
      p.62 = p;
      eklass = decode_klass_ref (module, p.62, &p);
      klass = mono_array_class_get (eklass, rank);
      goto <D.23423>;
      <D.23442>:
      {
        struct MonoType * t;

        p.62 = p;
        t = decode_type (module, p.62, &p);
        if (t == 0B) goto <D.25837>; else goto <D.25838>;
        <D.25837>:
        D.25774 = 0B;
        return D.25774;
        <D.25838>:
        klass = mono_class_from_mono_type (t);
        monoeg_g_free (t);
        goto <D.23423>;
      }
      <D.23444>:
      {
        guint32 offset;
        guint8 * p2;

        try
          {
            p.62 = p;
            D.25839 = decode_value (p.62, &p);
            offset = (guint32) D.25839;
            D.25840 = module->blob;
            D.25841 = (sizetype) offset;
            p2.63 = D.25840 + D.25841;
            p2 = p2.63;
            p2.64 = p2;
            klass = decode_klass_ref (module, p2.64, &p2);
            goto <D.23423>;
          }
        finally
          {
            p2 = {CLOBBER};
          }
      }
      <D.23447>:
      monoeg_assertion_message ("* Assertion: should not be reached at %s:%d\n", "aot-runtime.c", 526);
      <D.23423>:
      D.25844 = klass == 0B;
      D.25845 = (long int) D.25844;
      D.25846 = __builtin_expect (D.25845, 0);
      if (D.25846 != 0) goto <D.25847>; else goto <D.25848>;
      <D.25847>:
      monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "aot-runtime.c", 528, "klass");
      <D.25848>:
      p.62 = p;
      *endbuf = p.62;
      D.25774 = klass;
      return D.25774;
    }
  finally
    {
      p = {CLOBBER};
    }
}


__attribute__((visibility ("hidden")))
mono_aot_get_cached_class_info (struct MonoClass * klass, struct MonoCachedClassInfo * res)
{
  struct MonoImage * D.25854;
  unsigned char D.25857;
  gboolean D.25859;
  guint8 * D.25860;
  guint32 * D.25861;
  unsigned int D.25862;
  unsigned int D.25863;
  unsigned int D.25864;
  int D.25865;
  unsigned int D.25866;
  sizetype D.25867;
  guint8 * p.65;
  guint8 * p.66;
  struct MonoAotModule * amodule;
  guint8 * p;
  gboolean err;

  try
    {
      D.25854 = klass->image;
      amodule = D.25854->aot_module;
      D.25857 = klass->rank;
      if (D.25857 != 0) goto <D.25855>; else goto <D.25858>;
      <D.25858>:
      if (amodule == 0B) goto <D.25855>; else goto <D.25856>;
      <D.25855>:
      D.25859 = 0;
      return D.25859;
      <D.25856>:
      D.25860 = amodule->blob;
      D.25861 = amodule->class_info_offsets;
      D.25862 = klass->type_token;
      D.25863 = D.25862 & 16777215;
      D.25864 = D.25863 + 4294967295;
      D.25865 = (int) D.25864;
      D.25866 = mono_aot_get_offset (D.25861, D.25865);
      D.25867 = (sizetype) D.25866;
      p.65 = D.25860 + D.25867;
      p = p.65;
      p.66 = p;
      err = decode_cached_class_info (amodule, res, p.66, &p);
      if (err == 0) goto <D.25870>; else goto <D.25871>;
      <D.25870>:
      D.25859 = 0;
      return D.25859;
      <D.25871>:
      D.25859 = 1;
      return D.25859;
    }
  finally
    {
      p = {CLOBBER};
    }
}


__attribute__((visibility ("hidden")))
mono_aot_get_class_from_name (struct MonoImage * image, const char * name_space, const char * name, struct MonoClass * * klass)
{
  guint16 * D.25877;
  gboolean D.25878;
  _Bool D.25881;
  long int D.25882;
  long int D.25883;
  struct GHashTable * D.25886;
  struct GHashTable * D.25889;
  void * D.25892;
  struct MonoClass * D.25893;
  _Bool D.25898;
  long int D.25899;
  long int D.25900;
  char D.25903;
  long unsigned int D.25907;
  long unsigned int D.25908;
  long unsigned int D.25909;
  unsigned int D.25913;
  unsigned int D.25914;
  unsigned int D.25917;
  long unsigned int D.25918;
  long unsigned int D.25919;
  short unsigned int D.25920;
  guint16 * D.25923;
  short unsigned int D.25924;
  unsigned int name_table_accesses.67;
  unsigned int D.25926;
  unsigned int D.25927;
  int D.25928;
  unsigned int D.25929;
  unsigned int D.25930;
  int D.25931;
  int D.25934;
  _Bool D.25939;
  long int D.25940;
  long int D.25941;
  struct MonoClass * D.25944;
  _Bool D.25949;
  long int D.25950;
  long int D.25951;
  _Bool D.25958;
  long int D.25959;
  long int D.25960;
  unsigned int D.25964;
  long unsigned int D.25965;
  long unsigned int D.25966;
  _Bool D.25969;
  long int D.25970;
  long int D.25971;
  struct MonoAotModule * amodule;
  guint16 * table;
  guint16 * entry;
  guint16 table_size;
  guint32 hash;
  char full_name_buf[1024];
  char * full_name;
  const char * name2;
  const char * name_space2;
  struct MonoTableInfo * t;
  guint32 cols[6];
  struct GHashTable * nspace_table;

  try
    {
      amodule = image->aot_module;
      if (amodule == 0B) goto <D.25874>; else goto <D.25876>;
      <D.25876>:
      D.25877 = amodule->class_name_table;
      if (D.25877 == 0B) goto <D.25874>; else goto <D.25875>;
      <D.25874>:
      D.25878 = 0;
      return D.25878;
      <D.25875>:
      {
        int ret;

        ret = pthread_mutex_lock (&aot_mutex.mutex);
        if (ret != 0) goto <D.25879>; else goto <D.25880>;
        <D.25879>:
        monoeg_g_log (0B, 16, "Bad call to mono_mutex_lock result %d", ret);
        <D.25880>:
        D.25881 = ret != 0;
        D.25882 = (long int) D.25881;
        D.25883 = __builtin_expect (D.25882, 0);
        if (D.25883 != 0) goto <D.25884>; else goto <D.25885>;
        <D.25884>:
        monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "aot-runtime.c", 2065, "ret == 0");
        <D.25885>:
      }
      *klass = 0B;
      D.25886 = amodule->name_cache;
      if (D.25886 == 0B) goto <D.25887>; else goto <D.25888>;
      <D.25887>:
      D.25889 = monoeg_g_hash_table_new (monoeg_g_str_hash, monoeg_g_str_equal);
      amodule->name_cache = D.25889;
      <D.25888>:
      D.25886 = amodule->name_cache;
      nspace_table = monoeg_g_hash_table_lookup (D.25886, name_space);
      if (nspace_table != 0B) goto <D.25890>; else goto <D.25891>;
      <D.25890>:
      D.25892 = monoeg_g_hash_table_lookup (nspace_table, name);
      *klass = D.25892;
      D.25893 = *klass;
      if (D.25893 != 0B) goto <D.25894>; else goto <D.25895>;
      <D.25894>:
      {
        int ret;

        ret = pthread_mutex_unlock (&aot_mutex.mutex);
        if (ret != 0) goto <D.25896>; else goto <D.25897>;
        <D.25896>:
        monoeg_g_log (0B, 16, "Bad call to mono_mutex_unlock result %d", ret);
        <D.25897>:
        D.25898 = ret != 0;
        D.25899 = (long int) D.25898;
        D.25900 = __builtin_expect (D.25899, 0);
        if (D.25900 != 0) goto <D.25901>; else goto <D.25902>;
        <D.25901>:
        monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "aot-runtime.c", 2076, "ret == 0");
        <D.25902>:
      }
      D.25878 = 1;
      return D.25878;
      <D.25895>:
      <D.25891>:
      D.25877 = amodule->class_name_table;
      table_size = *D.25877;
      D.25877 = amodule->class_name_table;
      table = D.25877 + 2;
      D.25903 = *name_space;
      if (D.25903 == 0) goto <D.25904>; else goto <D.25905>;
      <D.25904>:
      full_name = monoeg_g_strdup_printf ("%s", name);
      goto <D.25906>;
      <D.25905>:
      D.25907 = __strlen_g (name_space);
      D.25908 = __strlen_g (name);
      D.25909 = D.25907 + D.25908;
      if (D.25909 <= 999) goto <D.25910>; else goto <D.25911>;
      <D.25910>:
      sprintf (&full_name_buf, "%s.%s", name_space, name);
      full_name = &full_name_buf;
      goto <D.25912>;
      <D.25911>:
      full_name = monoeg_g_strdup_printf ("%s.%s", name_space, name);
      <D.25912>:
      <D.25906>:
      D.25913 = mono_metadata_str_hash (full_name);
      D.25914 = (unsigned int) table_size;
      hash = D.25913 % D.25914;
      if (&full_name_buf != full_name) goto <D.25915>; else goto <D.25916>;
      <D.25915>:
      monoeg_g_free (full_name);
      <D.25916>:
      D.25917 = hash * 2;
      D.25918 = (long unsigned int) D.25917;
      D.25919 = D.25918 * 2;
      entry = table + D.25919;
      D.25920 = *entry;
      if (D.25920 != 0) goto <D.25921>; else goto <D.25922>;
      <D.25921>:
      t = &image->tables[2];
      <D.23823>:
      {
        guint32 index;
        guint32 next;
        guint32 token;

        D.25920 = *entry;
        index = (guint32) D.25920;
        D.25923 = entry + 2;
        D.25924 = *D.25923;
        next = (guint32) D.25924;
        token = index | 33554432;
        name_table_accesses.67 = name_table_accesses;
        D.25926 = name_table_accesses.67 + 1;
        name_table_accesses = D.25926;
        D.25927 = index + 4294967295;
        D.25928 = (int) D.25927;
        mono_metadata_decode_row (t, D.25928, &cols, 6);
        D.25929 = cols[1];
        name2 = mono_metadata_string_heap (image, D.25929);
        D.25930 = cols[2];
        name_space2 = mono_metadata_string_heap (image, D.25930);
        D.25931 = strcmp (name, name2);
        if (D.25931 == 0) goto <D.25932>; else goto <D.25933>;
        <D.25932>:
        D.25934 = strcmp (name_space, name_space2);
        if (D.25934 == 0) goto <D.25935>; else goto <D.25936>;
        <D.25935>:
        {
          int ret;

          ret = pthread_mutex_unlock (&aot_mutex.mutex);
          if (ret != 0) goto <D.25937>; else goto <D.25938>;
          <D.25937>:
          monoeg_g_log (0B, 16, "Bad call to mono_mutex_unlock result %d", ret);
          <D.25938>:
          D.25939 = ret != 0;
          D.25940 = (long int) D.25939;
          D.25941 = __builtin_expect (D.25940, 0);
          if (D.25941 != 0) goto <D.25942>; else goto <D.25943>;
          <D.25942>:
          monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "aot-runtime.c", 2116, "ret == 0");
          <D.25943>:
        }
        D.25944 = mono_class_get (image, token);
        *klass = D.25944;
        D.25893 = *klass;
        if (D.25893 != 0B) goto <D.25945>; else goto <D.25946>;
        <D.25945>:
        {
          int ret;

          ret = pthread_mutex_lock (&aot_mutex.mutex);
          if (ret != 0) goto <D.25947>; else goto <D.25948>;
          <D.25947>:
          monoeg_g_log (0B, 16, "Bad call to mono_mutex_lock result %d", ret);
          <D.25948>:
          D.25949 = ret != 0;
          D.25950 = (long int) D.25949;
          D.25951 = __builtin_expect (D.25950, 0);
          if (D.25951 != 0) goto <D.25952>; else goto <D.25953>;
          <D.25952>:
          monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "aot-runtime.c", 2121, "ret == 0");
          <D.25953>:
        }
        D.25886 = amodule->name_cache;
        nspace_table = monoeg_g_hash_table_lookup (D.25886, name_space);
        if (nspace_table == 0B) goto <D.25954>; else goto <D.25955>;
        <D.25954>:
        nspace_table = monoeg_g_hash_table_new (monoeg_g_str_hash, monoeg_g_str_equal);
        D.25886 = amodule->name_cache;
        monoeg_g_hash_table_insert_replace (D.25886, name_space2, nspace_table, 0);
        <D.25955>:
        D.25893 = *klass;
        monoeg_g_hash_table_insert_replace (nspace_table, name2, D.25893, 0);
        {
          int ret;

          ret = pthread_mutex_unlock (&aot_mutex.mutex);
          if (ret != 0) goto <D.25956>; else goto <D.25957>;
          <D.25956>:
          monoeg_g_log (0B, 16, "Bad call to mono_mutex_unlock result %d", ret);
          <D.25957>:
          D.25958 = ret != 0;
          D.25959 = (long int) D.25958;
          D.25960 = __builtin_expect (D.25959, 0);
          if (D.25960 != 0) goto <D.25961>; else goto <D.25962>;
          <D.25961>:
          monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "aot-runtime.c", 2128, "ret == 0");
          <D.25962>:
        }
        <D.25946>:
        D.25878 = 1;
        return D.25878;
        <D.25936>:
        <D.25933>:
        if (next != 0) goto <D.25963>; else goto <D.23822>;
        <D.25963>:
        D.25964 = next * 2;
        D.25965 = (long unsigned int) D.25964;
        D.25966 = D.25965 * 2;
        entry = table + D.25966;
      }
      goto <D.23823>;
      <D.23822>:
      <D.25922>:
      {
        int ret;

        ret = pthread_mutex_unlock (&aot_mutex.mutex);
        if (ret != 0) goto <D.25967>; else goto <D.25968>;
        <D.25967>:
        monoeg_g_log (0B, 16, "Bad call to mono_mutex_unlock result %d", ret);
        <D.25968>:
        D.25969 = ret != 0;
        D.25970 = (long int) D.25969;
        D.25971 = __builtin_expect (D.25970, 0);
        if (D.25971 != 0) goto <D.25972>; else goto <D.25973>;
        <D.25972>:
        monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "aot-runtime.c", 2141, "ret == 0");
        <D.25973>:
      }
      D.25878 = 1;
      return D.25878;
    }
  finally
    {
      full_name_buf = {CLOBBER};
      cols = {CLOBBER};
    }
}


__attribute__((__artificial__, __gnu_inline__, __always_inline__, __leaf__, __nothrow__))
sprintf (char * restrict __s, const char * restrict __fmt)
{
  int D.25976;
  long unsigned int D.25977;

  D.25977 = __builtin_object_size (__s, 1);
  D.25976 = __builtin___sprintf_chk (__s, 1, D.25977, __fmt, __builtin_va_arg_pack ());
  return D.25976;
}


__attribute__((visibility ("hidden")))
mono_aot_get_unwind_info (struct MonoJitInfo * ji, guint32 * unwind_info_len)
{
  long unsigned int D.25979;
  long unsigned int D.25980;
  struct MonoMethod * D.25984;
  struct MonoClass * D.25985;
  struct MonoImage * D.25986;
  _Bool D.25987;
  long int D.25988;
  long int D.25989;
  long unsigned int D.25992;
  _Bool D.25993;
  long int D.25994;
  long int D.25995;
  guint8 * D.26000;
  guint8 * D.26002;
  _Bool D.26005;
  long int D.26006;
  long int D.26007;
  struct GHashTable * ji_to_amodule.68;
  _Bool D.26011;
  long int D.26012;
  long int D.26013;
  int iftmp.69;
  _Bool D.26023;
  long int D.26024;
  long int D.26025;
  _Bool D.26030;
  long int D.26031;
  long int D.26032;
  guint8 * D.26035;
  unsigned int D.26036;
  sizetype D.26037;
  guint8 * p.70;
  guint8 * p.71;
  int D.26040;
  unsigned int D.26041;
  guint8 * D.26042;
  struct MonoAotModule * amodule;
  guint8 * p;
  guint8 * code;

  try
    {
      code = ji->code_start;
      D.25979 = BIT_FIELD_REF <*ji, 64, 256>;
      D.25980 = D.25979 & 549755813888;
      if (D.25980 != 0) goto <D.25981>; else goto <D.25982>;
      <D.25981>:
      amodule = ji->d.aot_info;
      goto <D.25983>;
      <D.25982>:
      D.25984 = jinfo_get_method (ji);
      D.25985 = D.25984->klass;
      D.25986 = D.25985->image;
      amodule = D.25986->aot_module;
      <D.25983>:
      D.25987 = amodule == 0B;
      D.25988 = (long int) D.25987;
      D.25989 = __builtin_expect (D.25988, 0);
      if (D.25989 != 0) goto <D.25990>; else goto <D.25991>;
      <D.25990>:
      monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "aot-runtime.c", 2655, "amodule");
      <D.25991>:
      D.25979 = BIT_FIELD_REF <*ji, 64, 256>;
      D.25992 = D.25979 & 8796093022208;
      D.25993 = D.25992 == 0;
      D.25994 = (long int) D.25993;
      D.25995 = __builtin_expect (D.25994, 0);
      if (D.25995 != 0) goto <D.25996>; else goto <D.25997>;
      <D.25996>:
      monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "aot-runtime.c", 2656, "ji->from_aot");
      <D.25997>:
      D.26000 = amodule->code;
      if (D.26000 > code) goto <D.25998>; else goto <D.26001>;
      <D.26001>:
      D.26002 = amodule->code_end;
      if (D.26002 < code) goto <D.25998>; else goto <D.25999>;
      <D.25998>:
      {
        int ret;

        ret = pthread_mutex_lock (&aot_mutex.mutex);
        if (ret != 0) goto <D.26003>; else goto <D.26004>;
        <D.26003>:
        monoeg_g_log (0B, 16, "Bad call to mono_mutex_lock result %d", ret);
        <D.26004>:
        D.26005 = ret != 0;
        D.26006 = (long int) D.26005;
        D.26007 = __builtin_expect (D.26006, 0);
        if (D.26007 != 0) goto <D.26008>; else goto <D.26009>;
        <D.26008>:
        monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "aot-runtime.c", 2660, "ret == 0");
        <D.26009>:
      }
      ji_to_amodule.68 = ji_to_amodule;
      D.26011 = ji_to_amodule.68 == 0B;
      D.26012 = (long int) D.26011;
      D.26013 = __builtin_expect (D.26012, 0);
      if (D.26013 != 0) goto <D.26014>; else goto <D.26015>;
      <D.26014>:
      monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "aot-runtime.c", 2661, "ji_to_amodule");
      <D.26015>:
      ji_to_amodule.68 = ji_to_amodule;
      amodule = monoeg_g_hash_table_lookup (ji_to_amodule.68, ji);
      D.25987 = amodule == 0B;
      D.25988 = (long int) D.25987;
      D.25989 = __builtin_expect (D.25988, 0);
      if (D.25989 != 0) goto <D.26016>; else goto <D.26017>;
      <D.26016>:
      monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "aot-runtime.c", 2663, "amodule");
      <D.26017>:
      D.26000 = amodule->code;
      if (D.26000 > code) goto <D.26019>; else goto <D.26022>;
      <D.26022>:
      D.26002 = amodule->code_end;
      if (D.26002 < code) goto <D.26019>; else goto <D.26020>;
      <D.26019>:
      iftmp.69 = 1;
      goto <D.26021>;
      <D.26020>:
      iftmp.69 = 0;
      <D.26021>:
      D.26023 = iftmp.69 != 0;
      D.26024 = (long int) D.26023;
      D.26025 = __builtin_expect (D.26024, 0);
      if (D.26025 != 0) goto <D.26026>; else goto <D.26027>;
      <D.26026>:
      monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "aot-runtime.c", 2664, "code >= amodule->code && code <= amodule->code_end");
      <D.26027>:
      {
        int ret;

        ret = pthread_mutex_unlock (&aot_mutex.mutex);
        if (ret != 0) goto <D.26028>; else goto <D.26029>;
        <D.26028>:
        monoeg_g_log (0B, 16, "Bad call to mono_mutex_unlock result %d", ret);
        <D.26029>:
        D.26030 = ret != 0;
        D.26031 = (long int) D.26030;
        D.26032 = __builtin_expect (D.26031, 0);
        if (D.26032 != 0) goto <D.26033>; else goto <D.26034>;
        <D.26033>:
        monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "aot-runtime.c", 2665, "ret == 0");
        <D.26034>:
      }
      <D.25999>:
      D.26035 = amodule->unwind_info;
      D.26036 = ji->used_regs;
      D.26037 = (sizetype) D.26036;
      p.70 = D.26035 + D.26037;
      p = p.70;
      p.71 = p;
      D.26040 = decode_value (p.71, &p);
      D.26041 = (unsigned int) D.26040;
      *unwind_info_len = D.26041;
      D.26042 = p;
      return D.26042;
    }
  finally
    {
      p = {CLOBBER};
    }
}


jinfo_get_method (struct MonoJitInfo * ji)
{
  struct MonoMethod * D.26045;

  D.26045 = mono_jit_info_get_method (ji);
  return D.26045;
}


__attribute__((visibility ("hidden")))
mono_aot_find_jit_info (struct MonoDomain * domain, struct MonoImage * image, void * addr)
{
  unsigned int D.26047;
  struct MonoJitInfo * D.26050;
  struct MonoDomain * D.26051;
  long int addr.72;
  guint8 * D.26055;
  long int D.26056;
  long int D.26057;
  gint32 * D.26058;
  int D.26061;
  long unsigned int D.26062;
  long unsigned int D.26063;
  gint32 * D.26064;
  long unsigned int D.26065;
  long unsigned int D.26066;
  gint32 * D.26067;
  int D.26068;
  int D.26071;
  long unsigned int D.26072;
  long unsigned int D.26073;
  gint32 * D.26074;
  sizetype D.26075;
  sizetype D.26076;
  sizetype D.26077;
  gint32 * D.26078;
  int D.26079;
  long unsigned int D.26080;
  long unsigned int D.26081;
  gint32 * D.26082;
  int D.26083;
  int D.26084;
  int D.26085;
  long unsigned int D.26086;
  long unsigned int D.26087;
  gint32 * D.26088;
  int D.26089;
  _Bool D.26090;
  long int D.26091;
  long int D.26092;
  int D.26095;
  gint32 * * D.26096;
  void * D.26097;
  int D.26104;
  long int D.26106;
  guint8 * D.26107;
  long int D.26108;
  long int D.26109;
  int D.26110;
  int D.26111;
  long unsigned int D.26112;
  long unsigned int D.26113;
  gint32 * D.26114;
  int D.26115;
  int D.26119;
  long unsigned int D.26120;
  long unsigned int D.26121;
  gint32 * D.26122;
  int D.26127;
  _Bool D.26128;
  long int D.26129;
  long int D.26130;
  int D.26135;
  _Bool D.26136;
  long int D.26137;
  long int D.26138;
  sizetype D.26141;
  sizetype D.26142;
  sizetype D.26143;
  gint32 * D.26144;
  long unsigned int D.26149;
  struct JitInfoMap * D.26150;
  int D.26151;
  long unsigned int D.26154;
  long unsigned int D.26155;
  gint32 * D.26156;
  int D.26157;
  sizetype D.26158;
  guint8 * D.26159;
  guint32 * D.26160;
  unsigned int D.26161;
  sizetype D.26162;
  long int code.73;
  long int D.26166;
  int iftmp.74;
  sizetype D.26173;
  guint8 * D.26174;
  _Bool D.26175;
  long int D.26176;
  long int D.26177;
  struct GHashTable * D.26182;
  _Bool D.26187;
  long int D.26188;
  long int D.26189;
  const void * D.26192;
  _Bool D.26195;
  long int D.26196;
  long int D.26197;
  <unnamed-unsigned:24> D.26203;
  int D.26204;
  guint32 * D.26207;
  unsigned int D.26208;
  _Bool D.26209;
  long int D.26210;
  long int D.26211;
  guint32 * D.26214;
  unsigned int D.26215;
  unsigned int method_index.75;
  guint32 * D.26221;
  unsigned int D.26222;
  sizetype D.26223;
  guint8 * p.76;
  guint8 * p.77;
  int D.26229;
  int D.26230;
  _Bool D.26231;
  long int D.26232;
  long int D.26233;
  unsigned int code_len.78;
  void * D.26237;
  _Bool D.26238;
  long int D.26239;
  long int D.26240;
  int D.26243;
  sizetype D.26244;
  guint8 * D.26245;
  _Bool D.26246;
  long int D.26247;
  long int D.26248;
  int D.26256;
  unsigned int D.26257;
  unsigned int D.26258;
  int D.26259;
  long unsigned int D.26262;
  long unsigned int D.26263;
  struct JitInfoMap * D.26264;
  struct JitInfoMap * * D.26265;
  void * D.26266;
  int pos;
  int left;
  int right;
  int offset;
  int offset1;
  int offset2;
  int code_len;
  int method_index;
  int table_len;
  guint32 token;
  struct MonoAotModule * amodule;
  struct MonoMethod * method;
  struct MonoJitInfo * jinfo;
  guint8 * code;
  guint8 * ex_info;
  guint8 * p;
  guint32 * table;
  int nmethods;
  gint32 * code_offsets;
  int offsets_len;
  int i;
  gboolean async;

  try
    {
      amodule = image->aot_module;
      method = 0B;
      D.26047 = amodule->info.nmethods;
      nmethods = (int) D.26047;
      if (amodule == 0B) goto <D.26048>; else goto <D.26049>;
      <D.26048>:
      D.26050 = 0B;
      return D.26050;
      <D.26049>:
      D.26051 = mono_get_root_domain ();
      if (D.26051 != domain) goto <D.26052>; else goto <D.26053>;
      <D.26052>:
      D.26050 = 0B;
      return D.26050;
      <D.26053>:
      async = mono_thread_info_is_async_context ();
      addr.72 = (long int) addr;
      D.26055 = amodule->code;
      D.26056 = (long int) D.26055;
      D.26057 = addr.72 - D.26056;
      offset = (int) D.26057;
      D.26058 = amodule->sorted_code_offsets;
      if (D.26058 == 0B) goto <D.26059>; else goto <D.26060>;
      <D.26059>:
      D.26061 = nmethods * 2;
      D.26062 = (long unsigned int) D.26061;
      D.26063 = D.26062 * 4;
      code_offsets = monoeg_malloc0 (D.26063);
      offsets_len = 0;
      i = 0;
      goto <D.24063>;
      <D.24062>:
      D.26064 = amodule->code_offsets;
      D.26065 = (long unsigned int) i;
      D.26066 = D.26065 * 4;
      D.26067 = D.26064 + D.26066;
      D.26068 = *D.26067;
      if (D.26068 == -1) goto <D.26069>; else goto <D.26070>;
      <D.26069>:
      // predicted unlikely by continue predictor.
      goto <D.24061>;
      <D.26070>:
      D.26071 = offsets_len * 2;
      D.26072 = (long unsigned int) D.26071;
      D.26073 = D.26072 * 4;
      D.26074 = code_offsets + D.26073;
      D.26064 = amodule->code_offsets;
      D.26065 = (long unsigned int) i;
      D.26066 = D.26065 * 4;
      D.26067 = D.26064 + D.26066;
      D.26068 = *D.26067;
      *D.26074 = D.26068;
      D.26071 = offsets_len * 2;
      D.26075 = (sizetype) D.26071;
      D.26076 = D.26075 + 1;
      D.26077 = D.26076 * 4;
      D.26078 = code_offsets + D.26077;
      *D.26078 = i;
      offsets_len = offsets_len + 1;
      <D.24061>:
      i = i + 1;
      <D.24063>:
      if (i < nmethods) goto <D.24062>; else goto <D.24064>;
      <D.24064>:
      msort_code_offsets (code_offsets, offsets_len);
      i = 0;
      goto <D.24066>;
      <D.24065>:
      D.26079 = i * 2;
      D.26080 = (long unsigned int) D.26079;
      D.26081 = D.26080 * 4;
      D.26082 = code_offsets + D.26081;
      D.26083 = *D.26082;
      D.26084 = i + 1;
      D.26085 = D.26084 * 2;
      D.26086 = (long unsigned int) D.26085;
      D.26087 = D.26086 * 4;
      D.26088 = code_offsets + D.26087;
      D.26089 = *D.26088;
      D.26090 = D.26083 > D.26089;
      D.26091 = (long int) D.26090;
      D.26092 = __builtin_expect (D.26091, 0);
      if (D.26092 != 0) goto <D.26093>; else goto <D.26094>;
      <D.26093>:
      monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "aot-runtime.c", 2784, "code_offsets [(i * 2)] <= code_offsets [(i + 1) * 2]");
      <D.26094>:
      i = i + 1;
      <D.24066>:
      D.26095 = offsets_len + -1;
      if (D.26095 > i) goto <D.24065>; else goto <D.24067>;
      <D.24067>:
      amodule->sorted_code_offsets_len = offsets_len;
      mono_memory_barrier ();
      D.26096 = &amodule->sorted_code_offsets;
      D.26097 = InterlockedCompareExchangePointer (D.26096, code_offsets, 0B);
      if (D.26097 != 0B) goto <D.26098>; else goto <D.26099>;
      <D.26098>:
      monoeg_g_free (code_offsets);
      <D.26099>:
      <D.26060>:
      code_offsets = amodule->sorted_code_offsets;
      offsets_len = amodule->sorted_code_offsets_len;
      if (offsets_len > 0) goto <D.26102>; else goto <D.26103>;
      <D.26102>:
      D.26104 = *code_offsets;
      if (D.26104 > offset) goto <D.26100>; else goto <D.26105>;
      <D.26105>:
      D.26106 = (long int) offset;
      D.26107 = amodule->code_end;
      D.26108 = (long int) D.26107;
      D.26055 = amodule->code;
      D.26056 = (long int) D.26055;
      D.26109 = D.26108 - D.26056;
      if (D.26106 >= D.26109) goto <D.26100>; else goto <D.26101>;
      <D.26100>:
      D.26050 = 0B;
      return D.26050;
      <D.26101>:
      <D.26103>:
      left = 0;
      right = offsets_len;
      <D.24069>:
      D.26110 = left + right;
      pos = D.26110 / 2;
      D.26111 = pos * 2;
      D.26112 = (long unsigned int) D.26111;
      D.26113 = D.26112 * 4;
      D.26114 = code_offsets + D.26113;
      offset1 = *D.26114;
      D.26115 = pos + 1;
      if (D.26115 == offsets_len) goto <D.26116>; else goto <D.26117>;
      <D.26116>:
      D.26107 = amodule->code_end;
      D.26108 = (long int) D.26107;
      D.26055 = amodule->code;
      D.26056 = (long int) D.26055;
      D.26109 = D.26108 - D.26056;
      offset2 = (int) D.26109;
      goto <D.26118>;
      <D.26117>:
      D.26115 = pos + 1;
      D.26119 = D.26115 * 2;
      D.26120 = (long unsigned int) D.26119;
      D.26121 = D.26120 * 4;
      D.26122 = code_offsets + D.26121;
      offset2 = *D.26122;
      <D.26118>:
      if (offset < offset1) goto <D.26123>; else goto <D.26124>;
      <D.26123>:
      right = pos;
      goto <D.26125>;
      <D.26124>:
      if (offset >= offset2) goto <D.26126>; else goto <D.24068>;
      <D.26126>:
      left = pos + 1;
      <D.26125>:
      goto <D.24069>;
      <D.24068>:
      D.26111 = pos * 2;
      D.26112 = (long unsigned int) D.26111;
      D.26113 = D.26112 * 4;
      D.26114 = code_offsets + D.26113;
      D.26127 = *D.26114;
      D.26128 = D.26127 > offset;
      D.26129 = (long int) D.26128;
      D.26130 = __builtin_expect (D.26129, 0);
      if (D.26130 != 0) goto <D.26131>; else goto <D.26132>;
      <D.26131>:
      monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "aot-runtime.c", 2819, "offset >= code_offsets [(pos * 2)]");
      <D.26132>:
      D.26115 = pos + 1;
      if (D.26115 < offsets_len) goto <D.26133>; else goto <D.26134>;
      <D.26133>:
      D.26115 = pos + 1;
      D.26119 = D.26115 * 2;
      D.26120 = (long unsigned int) D.26119;
      D.26121 = D.26120 * 4;
      D.26122 = code_offsets + D.26121;
      D.26135 = *D.26122;
      D.26136 = D.26135 <= offset;
      D.26137 = (long int) D.26136;
      D.26138 = __builtin_expect (D.26137, 0);
      if (D.26138 != 0) goto <D.26139>; else goto <D.26140>;
      <D.26139>:
      monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "aot-runtime.c", 2821, "offset < code_offsets [((pos + 1) * 2)]");
      <D.26140>:
      <D.26134>:
      D.26111 = pos * 2;
      D.26141 = (sizetype) D.26111;
      D.26142 = D.26141 + 1;
      D.26143 = D.26142 * 4;
      D.26144 = code_offsets + D.26143;
      method_index = *D.26144;
      if (async != 0) goto <D.26145>; else goto <D.26146>;
      <D.26145>:
      {
        struct JitInfoMap * table;
        int len;

        table = amodule->async_jit_info_table;
        if (table != 0B) goto <D.26147>; else goto <D.26148>;
        <D.26147>:
        len = table->method_index;
        i = 1;
        goto <D.24073>;
        <D.24072>:
        D.26065 = (long unsigned int) i;
        D.26149 = D.26065 * 16;
        D.26150 = table + D.26149;
        D.26151 = D.26150->method_index;
        if (D.26151 == method_index) goto <D.26152>; else goto <D.26153>;
        <D.26152>:
        D.26065 = (long unsigned int) i;
        D.26149 = D.26065 * 16;
        D.26150 = table + D.26149;
        D.26050 = D.26150->jinfo;
        return D.26050;
        <D.26153>:
        i = i + 1;
        <D.24073>:
        if (i < len) goto <D.24072>; else goto <D.24074>;
        <D.24074>:
        <D.26148>:
      }
      <D.26146>:
      D.26055 = amodule->code;
      D.26064 = amodule->code_offsets;
      D.26154 = (long unsigned int) method_index;
      D.26155 = D.26154 * 4;
      D.26156 = D.26064 + D.26155;
      D.26157 = *D.26156;
      D.26158 = (sizetype) D.26157;
      code = D.26055 + D.26158;
      D.26159 = amodule->blob;
      D.26160 = amodule->ex_info_offsets;
      D.26161 = mono_aot_get_offset (D.26160, method_index);
      D.26162 = (sizetype) D.26161;
      ex_info = D.26159 + D.26162;
      D.26095 = offsets_len + -1;
      if (D.26095 == pos) goto <D.26163>; else goto <D.26164>;
      <D.26163>:
      D.26107 = amodule->code_end;
      D.26108 = (long int) D.26107;
      code.73 = (long int) code;
      D.26166 = D.26108 - code.73;
      code_len = (int) D.26166;
      goto <D.26167>;
      <D.26164>:
      D.26115 = pos + 1;
      D.26119 = D.26115 * 2;
      D.26120 = (long unsigned int) D.26119;
      D.26121 = D.26120 * 4;
      D.26122 = code_offsets + D.26121;
      D.26135 = *D.26122;
      D.26111 = pos * 2;
      D.26112 = (long unsigned int) D.26111;
      D.26113 = D.26112 * 4;
      D.26114 = code_offsets + D.26113;
      D.26127 = *D.26114;
      code_len = D.26135 - D.26127;
      <D.26167>:
      if (code > addr) goto <D.26169>; else goto <D.26172>;
      <D.26172>:
      D.26173 = (sizetype) code_len;
      D.26174 = code + D.26173;
      if (D.26174 <= addr) goto <D.26169>; else goto <D.26170>;
      <D.26169>:
      iftmp.74 = 1;
      goto <D.26171>;
      <D.26170>:
      iftmp.74 = 0;
      <D.26171>:
      D.26175 = iftmp.74 != 0;
      D.26176 = (long int) D.26175;
      D.26177 = __builtin_expect (D.26176, 0);
      if (D.26177 != 0) goto <D.26178>; else goto <D.26179>;
      <D.26178>:
      monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "aot-runtime.c", 2846, "(guint8*)code <= (guint8*)addr && (guint8*)addr < (guint8*)code + code_len");
      <D.26179>:
      if (async == 0) goto <D.26180>; else goto <D.26181>;
      <D.26180>:
      D.26182 = amodule->extra_methods;
      if (D.26182 != 0B) goto <D.26183>; else goto <D.26184>;
      <D.26183>:
      {
        int ret;

        ret = pthread_mutex_lock (&aot_mutex.mutex);
        if (ret != 0) goto <D.26185>; else goto <D.26186>;
        <D.26185>:
        monoeg_g_log (0B, 16, "Bad call to mono_mutex_lock result %d", ret);
        <D.26186>:
        D.26187 = ret != 0;
        D.26188 = (long int) D.26187;
        D.26189 = __builtin_expect (D.26188, 0);
        if (D.26189 != 0) goto <D.26190>; else goto <D.26191>;
        <D.26190>:
        monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "aot-runtime.c", 2851, "ret == 0");
        <D.26191>:
      }
      D.26182 = amodule->extra_methods;
      D.26154 = (long unsigned int) method_index;
      D.26192 = (const void *) D.26154;
      method = monoeg_g_hash_table_lookup (D.26182, D.26192);
      {
        int ret;

        ret = pthread_mutex_unlock (&aot_mutex.mutex);
        if (ret != 0) goto <D.26193>; else goto <D.26194>;
        <D.26193>:
        monoeg_g_log (0B, 16, "Bad call to mono_mutex_unlock result %d", ret);
        <D.26194>:
        D.26195 = ret != 0;
        D.26196 = (long int) D.26195;
        D.26197 = __builtin_expect (D.26196, 0);
        if (D.26197 != 0) goto <D.26198>; else goto <D.26199>;
        <D.26198>:
        monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "aot-runtime.c", 2853, "ret == 0");
        <D.26199>:
      }
      goto <D.26200>;
      <D.26184>:
      method = 0B;
      <D.26200>:
      if (method == 0B) goto <D.26201>; else goto <D.26202>;
      <D.26201>:
      D.26203 = image->tables[6].rows;
      D.26204 = (int) D.26203;
      if (D.26204 <= method_index) goto <D.26205>; else goto <D.26206>;
      <D.26205>:
      D.26207 = amodule->extra_method_info_offsets;
      D.26208 = *D.26207;
      table_len = (int) D.26208;
      D.26207 = amodule->extra_method_info_offsets;
      table = D.26207 + 4;
      left = 0;
      right = table_len;
      pos = 0;
      <D.24078>:
      D.26110 = left + right;
      pos = D.26110 / 2;
      D.26209 = pos >= table_len;
      D.26210 = (long int) D.26209;
      D.26211 = __builtin_expect (D.26210, 0);
      if (D.26211 != 0) goto <D.26212>; else goto <D.26213>;
      <D.26212>:
      monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "aot-runtime.c", 2874, "pos < table_len");
      <D.26213>:
      D.26111 = pos * 2;
      D.26112 = (long unsigned int) D.26111;
      D.26113 = D.26112 * 4;
      D.26214 = table + D.26113;
      D.26215 = *D.26214;
      method_index.75 = (unsigned int) method_index;
      if (D.26215 < method_index.75) goto <D.26217>; else goto <D.26218>;
      <D.26217>:
      left = pos + 1;
      goto <D.26219>;
      <D.26218>:
      D.26111 = pos * 2;
      D.26112 = (long unsigned int) D.26111;
      D.26113 = D.26112 * 4;
      D.26214 = table + D.26113;
      D.26215 = *D.26214;
      method_index.75 = (unsigned int) method_index;
      if (D.26215 > method_index.75) goto <D.26220>; else goto <D.24077>;
      <D.26220>:
      right = pos;
      <D.26219>:
      goto <D.24078>;
      <D.24077>:
      D.26159 = amodule->blob;
      D.26111 = pos * 2;
      D.26141 = (sizetype) D.26111;
      D.26142 = D.26141 + 1;
      D.26143 = D.26142 * 4;
      D.26221 = table + D.26143;
      D.26222 = *D.26221;
      D.26223 = (sizetype) D.26222;
      p.76 = D.26159 + D.26223;
      p = p.76;
      p.77 = p;
      method = decode_resolve_method_ref (amodule, p.77, &p);
      if (method == 0B) goto <D.26226>; else goto <D.26227>;
      <D.26226>:
      D.26050 = 0B;
      return D.26050;
      <D.26227>:
      goto <D.26228>;
      <D.26206>:
      D.26229 = method_index + 1;
      D.26230 = D.26229 | 100663296;
      token = (guint32) D.26230;
      method = mono_get_method (image, token, 0B);
      <D.26228>:
      <D.26202>:
      D.26231 = method == 0B;
      D.26232 = (long int) D.26231;
      D.26233 = __builtin_expect (D.26232, 0);
      if (D.26233 != 0) goto <D.26234>; else goto <D.26235>;
      <D.26234>:
      monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "aot-runtime.c", 2895, "method");
      <D.26235>:
      <D.26181>:
      code_len.78 = (unsigned int) code_len;
      jinfo = decode_exception_debug_info (amodule, domain, method, ex_info, addr, code, code_len.78);
      D.26237 = jinfo->code_start;
      D.26238 = D.26237 > addr;
      D.26239 = (long int) D.26238;
      D.26240 = __builtin_expect (D.26239, 0);
      if (D.26240 != 0) goto <D.26241>; else goto <D.26242>;
      <D.26241>:
      monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "aot-runtime.c", 2902, "(guint8*)addr >= (guint8*)jinfo->code_start");
      <D.26242>:
      D.26237 = jinfo->code_start;
      D.26243 = jinfo->code_size;
      D.26244 = (sizetype) D.26243;
      D.26245 = D.26237 + D.26244;
      D.26246 = D.26245 <= addr;
      D.26247 = (long int) D.26246;
      D.26248 = __builtin_expect (D.26247, 0);
      if (D.26248 != 0) goto <D.26249>; else goto <D.26250>;
      <D.26249>:
      monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "aot-runtime.c", 2903, "(guint8*)addr < (guint8*)jinfo->code_start + jinfo->code_size");
      <D.26250>:
      if (async != 0) goto <D.26251>; else goto <D.26252>;
      <D.26251>:
      {
        struct JitInfoMap * old_table;
        struct JitInfoMap * new_table;
        int len;

        <D.24083>:
        old_table = amodule->async_jit_info_table;
        if (old_table != 0B) goto <D.26253>; else goto <D.26254>;
        <D.26253>:
        len = old_table->method_index;
        goto <D.26255>;
        <D.26254>:
        len = 1;
        <D.26255>:
        D.26256 = len + 1;
        D.26257 = (unsigned int) D.26256;
        D.26258 = D.26257 * 16;
        D.26259 = (int) D.26258;
        new_table = alloc0_jit_info_data (domain, D.26259, async);
        if (old_table != 0B) goto <D.26260>; else goto <D.26261>;
        <D.26260>:
        D.26262 = (long unsigned int) len;
        D.26263 = D.26262 * 16;
        memcpy (new_table, old_table, D.26263);
        <D.26261>:
        D.26256 = len + 1;
        new_table->method_index = D.26256;
        D.26262 = (long unsigned int) len;
        D.26263 = D.26262 * 16;
        D.26264 = new_table + D.26263;
        D.26264->method_index = method_index;
        D.26262 = (long unsigned int) len;
        D.26263 = D.26262 * 16;
        D.26264 = new_table + D.26263;
        D.26264->jinfo = jinfo;
        mono_memory_barrier ();
        D.26265 = &amodule->async_jit_info_table;
        D.26266 = InterlockedCompareExchangePointer (D.26265, new_table, old_table);
        if (D.26266 == old_table) goto <D.24082>; else goto <D.26267>;
        <D.26267>:
        goto <D.24083>;
        <D.24082>:
      }
      goto <D.26268>;
      <D.26252>:
      mono_jit_info_table_add (domain, jinfo);
      <D.26268>:
      D.26050 = jinfo;
      return D.26050;
    }
  finally
    {
      p = {CLOBBER};
    }
}


msort_code_offsets (gint32 * array, int len)
{
  int D.26271;
  long unsigned int D.26272;
  long unsigned int D.26273;
  int D.26274;
  gint32 * scratch;

  D.26271 = len * 2;
  D.26272 = (long unsigned int) D.26271;
  D.26273 = D.26272 * 4;
  scratch = monoeg_malloc (D.26273);
  D.26274 = len + -1;
  msort_code_offsets_internal (array, 0, D.26274, scratch);
  monoeg_g_free (scratch);
}


msort_code_offsets_internal (gint32 * array, int lo, int hi, gint32 * scratch)
{
  int D.26275;
  int D.26278;
  int D.26281;
  long unsigned int D.26282;
  long unsigned int D.26283;
  gint32 * D.26284;
  int D.26285;
  sizetype D.26286;
  sizetype D.26287;
  sizetype D.26288;
  gint32 * D.26289;
  int D.26290;
  int D.26294;
  int D.26295;
  long unsigned int D.26296;
  long unsigned int D.26297;
  gint32 * D.26298;
  int D.26299;
  int D.26300;
  long unsigned int D.26301;
  long unsigned int D.26302;
  gint32 * D.26303;
  int D.26304;
  int D.26312;
  long unsigned int D.26313;
  long unsigned int D.26314;
  gint32 * D.26315;
  int D.26316;
  int D.26317;
  long unsigned int D.26318;
  long unsigned int D.26319;
  gint32 * D.26320;
  int D.26321;
  gint32 * D.26322;
  sizetype D.26323;
  sizetype D.26324;
  gint32 * D.26325;
  sizetype D.26326;
  sizetype D.26327;
  sizetype D.26328;
  gint32 * D.26329;
  int D.26330;
  sizetype D.26331;
  sizetype D.26332;
  sizetype D.26333;
  gint32 * D.26334;
  int D.26335;
  int D.26336;
  gint32 * D.26337;
  int D.26338;
  int mid;
  int i;
  int t_lo;
  int t_hi;

  D.26275 = lo + hi;
  mid = D.26275 / 2;
  if (lo >= hi) goto <D.26276>; else goto <D.26277>;
  <D.26276>:
  return;
  <D.26277>:
  D.26278 = hi - lo;
  if (D.26278 <= 31) goto <D.26279>; else goto <D.26280>;
  <D.26279>:
  i = lo;
  goto <D.24022>;
  <D.24021>:
  D.26281 = i * 2;
  D.26282 = (long unsigned int) D.26281;
  D.26283 = D.26282 * 4;
  D.26284 = array + D.26283;
  D.26285 = *D.26284;
  D.26281 = i * 2;
  D.26286 = (sizetype) D.26281;
  D.26287 = D.26286 + 2;
  D.26288 = D.26287 * 4;
  D.26289 = array + D.26288;
  D.26290 = *D.26289;
  if (D.26285 > D.26290) goto <D.24020>; else goto <D.26291>;
  <D.26291>:
  i = i + 1;
  <D.24022>:
  if (i < hi) goto <D.24021>; else goto <D.24020>;
  <D.24020>:
  if (i == hi) goto <D.26292>; else goto <D.26293>;
  <D.26292>:
  return;
  <D.26293>:
  <D.26280>:
  msort_code_offsets_internal (array, lo, mid, scratch);
  D.26294 = mid + 1;
  msort_code_offsets_internal (array, D.26294, hi, scratch);
  D.26295 = mid * 2;
  D.26296 = (long unsigned int) D.26295;
  D.26297 = D.26296 * 4;
  D.26298 = array + D.26297;
  D.26299 = *D.26298;
  D.26294 = mid + 1;
  D.26300 = D.26294 * 2;
  D.26301 = (long unsigned int) D.26300;
  D.26302 = D.26301 * 4;
  D.26303 = array + D.26302;
  D.26304 = *D.26303;
  if (D.26299 < D.26304) goto <D.26305>; else goto <D.26306>;
  <D.26305>:
  return;
  <D.26306>:
  t_lo = lo;
  t_hi = mid + 1;
  i = lo;
  goto <D.24024>;
  <D.24023>:
  if (t_lo <= mid) goto <D.26310>; else goto <D.26307>;
  <D.26310>:
  if (t_hi > hi) goto <D.26308>; else goto <D.26311>;
  <D.26311>:
  D.26312 = t_lo * 2;
  D.26313 = (long unsigned int) D.26312;
  D.26314 = D.26313 * 4;
  D.26315 = array + D.26314;
  D.26316 = *D.26315;
  D.26317 = t_hi * 2;
  D.26318 = (long unsigned int) D.26317;
  D.26319 = D.26318 * 4;
  D.26320 = array + D.26319;
  D.26321 = *D.26320;
  if (D.26316 < D.26321) goto <D.26308>; else goto <D.26307>;
  <D.26308>:
  D.26281 = i * 2;
  D.26282 = (long unsigned int) D.26281;
  D.26283 = D.26282 * 4;
  D.26322 = scratch + D.26283;
  D.26312 = t_lo * 2;
  D.26313 = (long unsigned int) D.26312;
  D.26314 = D.26313 * 4;
  D.26315 = array + D.26314;
  D.26316 = *D.26315;
  *D.26322 = D.26316;
  D.26281 = i * 2;
  D.26286 = (sizetype) D.26281;
  D.26323 = D.26286 + 1;
  D.26324 = D.26323 * 4;
  D.26325 = scratch + D.26324;
  D.26312 = t_lo * 2;
  D.26326 = (sizetype) D.26312;
  D.26327 = D.26326 + 1;
  D.26328 = D.26327 * 4;
  D.26329 = array + D.26328;
  D.26330 = *D.26329;
  *D.26325 = D.26330;
  t_lo = t_lo + 1;
  goto <D.26309>;
  <D.26307>:
  D.26281 = i * 2;
  D.26282 = (long unsigned int) D.26281;
  D.26283 = D.26282 * 4;
  D.26322 = scratch + D.26283;
  D.26317 = t_hi * 2;
  D.26318 = (long unsigned int) D.26317;
  D.26319 = D.26318 * 4;
  D.26320 = array + D.26319;
  D.26321 = *D.26320;
  *D.26322 = D.26321;
  D.26281 = i * 2;
  D.26286 = (sizetype) D.26281;
  D.26323 = D.26286 + 1;
  D.26324 = D.26323 * 4;
  D.26325 = scratch + D.26324;
  D.26317 = t_hi * 2;
  D.26331 = (sizetype) D.26317;
  D.26332 = D.26331 + 1;
  D.26333 = D.26332 * 4;
  D.26334 = array + D.26333;
  D.26335 = *D.26334;
  *D.26325 = D.26335;
  t_hi = t_hi + 1;
  <D.26309>:
  i = i + 1;
  <D.24024>:
  if (i <= hi) goto <D.24023>; else goto <D.24025>;
  <D.24025>:
  i = lo;
  goto <D.24027>;
  <D.24026>:
  D.26281 = i * 2;
  D.26282 = (long unsigned int) D.26281;
  D.26283 = D.26282 * 4;
  D.26284 = array + D.26283;
  D.26281 = i * 2;
  D.26282 = (long unsigned int) D.26281;
  D.26283 = D.26282 * 4;
  D.26322 = scratch + D.26283;
  D.26336 = *D.26322;
  *D.26284 = D.26336;
  D.26281 = i * 2;
  D.26286 = (sizetype) D.26281;
  D.26323 = D.26286 + 1;
  D.26324 = D.26323 * 4;
  D.26337 = array + D.26324;
  D.26281 = i * 2;
  D.26286 = (sizetype) D.26281;
  D.26323 = D.26286 + 1;
  D.26324 = D.26323 * 4;
  D.26325 = scratch + D.26324;
  D.26338 = *D.26325;
  *D.26337 = D.26338;
  i = i + 1;
  <D.24027>:
  if (i <= hi) goto <D.24026>; else goto <D.24028>;
  <D.24028>:
}


decode_exception_debug_info (struct MonoAotModule * amodule, struct MonoDomain * domain, struct MonoMethod * method, guint8 * ex_info, guint8 * addr, guint8 * code, guint32 code_len)
{
  guint8 * p.79;
  int D.26341;
  unsigned int D.26342;
  _Bool D.26343;
  unsigned int D.26344;
  _Bool D.26345;
  unsigned int D.26346;
  _Bool D.26347;
  unsigned int D.26348;
  _Bool D.26349;
  unsigned int D.26350;
  _Bool D.26351;
  unsigned int D.26352;
  _Bool D.26353;
  unsigned int D.26354;
  _Bool D.26355;
  unsigned int D.26356;
  _Bool D.26357;
  int D.26360;
  _Bool D.26361;
  long int D.26362;
  long int D.26363;
  int D.26367;
  long unsigned int D.26373;
  unsigned int D.26374;
  unsigned int D.26375;
  unsigned int D.26376;
  _Bool D.26386;
  long int D.26387;
  long int D.26388;
  long unsigned int D.26391;
  long unsigned int D.26392;
  long unsigned int D.26393;
  long unsigned int D.26394;
  long unsigned int D.26395;
  int D.26396;
  unsigned int D.26397;
  int D.26398;
  struct MonoClass * D.26401;
  long unsigned int D.26403;
  struct GSList * * D.26404;
  struct GSList * D.26405;
  long int D.26406;
  void * D.26407;
  struct GSList * D.26408;
  int D.26409;
  int D.26410;
  unsigned int D.26412;
  unsigned int D.26413;
  unsigned int generic_info_size.80;
  unsigned int D.26415;
  unsigned int try_holes_info_size.81;
  unsigned int D.26417;
  unsigned int arch_eh_jit_info_size.82;
  unsigned int D.26419;
  unsigned int D.26420;
  short unsigned int D.26421;
  <unnamed-unsigned:15> D.26422;
  int D.26423;
  unsigned int D.26424;
  int D.26425;
  unsigned int D.26426;
  unsigned int D.26427;
  int D.26430;
  sizetype D.26431;
  guint8 * D.26432;
  sizetype D.26438;
  guint8 * p.83;
  struct MonoClass * D.26441;
  int D.26442;
  sizetype D.26443;
  guint8 * D.26444;
  int D.26445;
  sizetype D.26446;
  guint8 * D.26447;
  int D.26448;
  sizetype D.26449;
  guint8 * D.26450;
  <unnamed-unsigned:15> D.26451;
  int D.26452;
  int code_len.84;
  _Bool D.26456;
  long int D.26457;
  long int D.26458;
  short unsigned int D.26461;
  int D.26462;
  short unsigned int D.26463;
  int D.26464;
  short unsigned int D.26465;
  int D.26466;
  unsigned int D.26467;
  int D.26470;
  unsigned int D.26471;
  struct MonoJitInfo * D.26474;
  _Bool D.26477;
  long int D.26478;
  long int D.26479;
  int D.26482;
  int D.26483;
  unsigned int D.26486;
  unsigned int D.26487;
  int D.26488;
  void * D.26489;
  struct MonoDwarfLocListEntry * D.26490;
  long unsigned int D.26491;
  int D.26492;
  int D.26493;
  int D.26494;
  int D.26497;
  int D.26500;
  int D.26501;
  int this_reg.85;
  _Bool D.26506;
  <unnamed-signed:1> D.26507;
  unsigned char D.26508;
  int this_offset.86;
  int D.26511;
  signed char D.26512;
  <unnamed-signed:1> D.26513;
  int D.26514;
  unsigned char D.26515;
  int D.26516;
  sizetype D.26519;
  guint8 * p.87;
  struct MonoMethod * D.26522;
  void * D.26523;
  int D.26524;
  unsigned int n.88;
  unsigned int D.26530;
  int D.26531;
  void * D.26532;
  gboolean * D.26533;
  long unsigned int D.26534;
  long unsigned int D.26535;
  gboolean * D.26536;
  int D.26537;
  void * D.26540;
  gboolean * D.26541;
  gboolean * D.26542;
  int D.26543;
  long unsigned int D.26548;
  long unsigned int D.26549;
  long unsigned int D.26550;
  int D.26551;
  int D.26552;
  int D.26553;
  int D.26554;
  int D.26555;
  long unsigned int D.26556;
  long unsigned int D.26557;
  void * D.26558;
  int * D.26559;
  long unsigned int D.26560;
  long unsigned int D.26561;
  int * D.26562;
  int D.26563;
  union mono_mutex_t * D.26564;
  _Bool D.26567;
  long int D.26568;
  long int D.26569;
  void * D.26572;
  struct GHashTable * D.26573;
  _Bool D.26576;
  long int D.26577;
  long int D.26578;
  unsigned int buf_len.89;
  sizetype D.26584;
  guint8 * p.90;
  guint8 * p.91;
  long unsigned int p.92;
  long unsigned int D.26590;
  sizetype D.26591;
  guint8 * p.93;
  struct MonoMethod * D.26593;
  struct MonoClass * D.26594;
  struct MonoImage * D.26595;
  void * D.26596;
  _Bool D.26601;
  long int D.26602;
  long int D.26603;
  struct GHashTable * ji_to_amodule.94;
  struct GHashTable * D.26609;
  _Bool D.26612;
  long int D.26613;
  long int D.26614;
  int i;
  int buf_len;
  int num_clauses;
  int len;
  struct MonoJitInfo * jinfo;
  guint used_int_regs;
  guint flags;
  gboolean has_generic_jit_info;
  gboolean has_dwarf_unwind_info;
  gboolean has_clauses;
  gboolean has_seq_points;
  gboolean has_try_block_holes;
  gboolean has_arch_eh_jit_info;
  gboolean from_llvm;
  gboolean has_gc_map;
  guint8 * p;
  int generic_info_size;
  int try_holes_info_size;
  int num_holes;
  int arch_eh_jit_info_size;
  int this_reg;
  int this_offset;
  gboolean async;

  try
    {
      this_reg = 0;
      this_offset = 0;
      async = mono_thread_info_is_async_context ();
      p = ex_info;
      p.79 = p;
      D.26341 = decode_value (p.79, &p);
      flags = (guint) D.26341;
      D.26342 = flags & 1;
      D.26343 = D.26342 != 0;
      has_generic_jit_info = (gboolean) D.26343;
      D.26344 = flags & 2;
      D.26345 = D.26344 != 0;
      has_dwarf_unwind_info = (gboolean) D.26345;
      D.26346 = flags & 4;
      D.26347 = D.26346 != 0;
      has_clauses = (gboolean) D.26347;
      D.26348 = flags & 8;
      D.26349 = D.26348 != 0;
      has_seq_points = (gboolean) D.26349;
      D.26350 = flags & 16;
      D.26351 = D.26350 != 0;
      from_llvm = (gboolean) D.26351;
      D.26352 = flags & 32;
      D.26353 = D.26352 != 0;
      has_try_block_holes = (gboolean) D.26353;
      D.26354 = flags & 64;
      D.26355 = D.26354 != 0;
      has_gc_map = (gboolean) D.26355;
      D.26356 = flags & 128;
      D.26357 = D.26356 != 0;
      has_arch_eh_jit_info = (gboolean) D.26357;
      if (has_dwarf_unwind_info != 0) goto <D.26358>; else goto <D.26359>;
      <D.26358>:
      {
        guint32 offset;

        p.79 = p;
        D.26360 = decode_value (p.79, &p);
        offset = (guint32) D.26360;
        D.26361 = offset > 1073741823;
        D.26362 = (long int) D.26361;
        D.26363 = __builtin_expect (D.26362, 0);
        if (D.26363 != 0) goto <D.26364>; else goto <D.26365>;
        <D.26364>:
        monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "aot-runtime.c", 2383, "offset < (1 << 30)");
        <D.26365>:
        used_int_regs = offset;
      }
      goto <D.26366>;
      <D.26359>:
      p.79 = p;
      D.26367 = decode_value (p.79, &p);
      used_int_regs = (guint) D.26367;
      <D.26366>:
      if (has_generic_jit_info != 0) goto <D.26368>; else goto <D.26369>;
      <D.26368>:
      generic_info_size = 32;
      goto <D.26370>;
      <D.26369>:
      generic_info_size = 0;
      <D.26370>:
      if (has_try_block_holes != 0) goto <D.26371>; else goto <D.26372>;
      <D.26371>:
      p.79 = p;
      num_holes = decode_value (p.79, &p);
      D.26373 = (long unsigned int) num_holes;
      D.26374 = (unsigned int) D.26373;
      D.26375 = D.26374 * 8;
      D.26376 = D.26375 + 4;
      try_holes_info_size = (int) D.26376;
      goto <D.26377>;
      <D.26372>:
      try_holes_info_size = 0;
      num_holes = try_holes_info_size;
      <D.26377>:
      if (has_clauses != 0) goto <D.26378>; else goto <D.26379>;
      <D.26378>:
      p.79 = p;
      num_clauses = decode_value (p.79, &p);
      goto <D.26380>;
      <D.26379>:
      num_clauses = 0;
      <D.26380>:
      if (has_arch_eh_jit_info != 0) goto <D.26381>; else goto <D.26382>;
      <D.26381>:
      arch_eh_jit_info_size = 4;
      goto <D.26383>;
      <D.26382>:
      arch_eh_jit_info_size = 0;
      <D.26383>:
      if (from_llvm != 0) goto <D.26384>; else goto <D.26385>;
      <D.26384>:
      {
        struct MonoJitExceptionInfo * clauses;
        struct GSList * * nesting;

        D.26386 = async != 0;
        D.26387 = (long int) D.26386;
        D.26388 = __builtin_expect (D.26387, 0);
        if (D.26388 != 0) goto <D.26389>; else goto <D.26390>;
        <D.26389>:
        monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "aot-runtime.c", 2414, "!async");
        <D.26390>:
        D.26391 = (long unsigned int) num_clauses;
        D.26392 = D.26391 * 40;
        clauses = monoeg_malloc0 (D.26392);
        D.26391 = (long unsigned int) num_clauses;
        D.26393 = D.26391 * 8;
        nesting = monoeg_malloc0 (D.26393);
        i = 0;
        goto <D.23944>;
        <D.23943>:
        {
          struct MonoJitExceptionInfo * ei;

          D.26394 = (long unsigned int) i;
          D.26395 = D.26394 * 40;
          ei = clauses + D.26395;
          p.79 = p;
          D.26396 = decode_value (p.79, &p);
          D.26397 = (unsigned int) D.26396;
          ei->flags = D.26397;
          p.79 = p;
          D.26398 = decode_value (p.79, &p);
          if (D.26398 != 0) goto <D.26399>; else goto <D.26400>;
          <D.26399>:
          p.79 = p;
          D.26401 = decode_klass_ref (amodule, p.79, &p);
          ei->data.catch_class = D.26401;
          <D.26400>:
          <D.23942>:
          {
            int nesting_index;

            p.79 = p;
            nesting_index = decode_value (p.79, &p);
            if (nesting_index == -1) goto <D.23941>; else goto <D.26402>;
            <D.26402>:
            D.26394 = (long unsigned int) i;
            D.26403 = D.26394 * 8;
            D.26404 = nesting + D.26403;
            D.26394 = (long unsigned int) i;
            D.26403 = D.26394 * 8;
            D.26404 = nesting + D.26403;
            D.26405 = *D.26404;
            D.26406 = (long int) nesting_index;
            D.26407 = (void *) D.26406;
            D.26408 = monoeg_g_slist_prepend (D.26405, D.26407);
            *D.26404 = D.26408;
          }
          goto <D.23942>;
          <D.23941>:
        }
        i = i + 1;
        <D.23944>:
        if (i < num_clauses) goto <D.23943>; else goto <D.23945>;
        <D.23945>:
        D.26409 = generic_info_size + try_holes_info_size;
        D.26410 = D.26409 + arch_eh_jit_info_size;
        jinfo = decode_llvm_mono_eh_frame (amodule, domain, method, code, clauses, num_clauses, D.26410, nesting, &this_reg, &this_offset);
        jinfo->from_llvm = -1;
        monoeg_g_free (clauses);
        i = 0;
        goto <D.23947>;
        <D.23946>:
        D.26394 = (long unsigned int) i;
        D.26403 = D.26394 * 8;
        D.26404 = nesting + D.26403;
        D.26405 = *D.26404;
        monoeg_g_slist_free (D.26405);
        i = i + 1;
        <D.23947>:
        if (i < num_clauses) goto <D.23946>; else goto <D.23948>;
        <D.23948>:
        monoeg_g_free (nesting);
      }
      goto <D.26411>;
      <D.26385>:
      D.26391 = (long unsigned int) num_clauses;
      D.26412 = (unsigned int) D.26391;
      D.26413 = D.26412 * 40;
      generic_info_size.80 = (unsigned int) generic_info_size;
      D.26415 = D.26413 + generic_info_size.80;
      try_holes_info_size.81 = (unsigned int) try_holes_info_size;
      D.26417 = D.26415 + try_holes_info_size.81;
      arch_eh_jit_info_size.82 = (unsigned int) arch_eh_jit_info_size;
      D.26419 = D.26417 + arch_eh_jit_info_size.82;
      D.26420 = D.26419 + 48;
      len = (int) D.26420;
      jinfo = alloc0_jit_info_data (domain, len, async);
      D.26421 = (short unsigned int) num_clauses;
      D.26422 = (<unnamed-unsigned:15>) D.26421;
      jinfo->num_clauses = D.26422;
      i = 0;
      goto <D.23952>;
      <D.23951>:
      {
        struct MonoJitExceptionInfo * ei;

        ei = &jinfo->clauses[i];
        p.79 = p;
        D.26423 = decode_value (p.79, &p);
        D.26424 = (unsigned int) D.26423;
        ei->flags = D.26424;
        p.79 = p;
        D.26425 = decode_value (p.79, &p);
        ei->exvar_offset = D.26425;
        D.26426 = ei->flags;
        D.26427 = D.26426 + 4294967295;
        if (D.26427 <= 1) goto <D.26428>; else goto <D.26429>;
        <D.26428>:
        p.79 = p;
        D.26430 = decode_value (p.79, &p);
        D.26431 = (sizetype) D.26430;
        D.26432 = code + D.26431;
        ei->data.filter = D.26432;
        goto <D.26433>;
        <D.26429>:
        {
          int len;

          p.79 = p;
          len = decode_value (p.79, &p);
          if (len > 0) goto <D.26434>; else goto <D.26435>;
          <D.26434>:
          if (async != 0) goto <D.26436>; else goto <D.26437>;
          <D.26436>:
          p.79 = p;
          D.26438 = (sizetype) len;
          p.83 = p.79 + D.26438;
          p = p.83;
          goto <D.26440>;
          <D.26437>:
          p.79 = p;
          D.26441 = decode_klass_ref (amodule, p.79, &p);
          ei->data.catch_class = D.26441;
          <D.26440>:
          <D.26435>:
        }
        <D.26433>:
        p.79 = p;
        D.26442 = decode_value (p.79, &p);
        D.26443 = (sizetype) D.26442;
        D.26444 = code + D.26443;
        ei->try_start = D.26444;
        p.79 = p;
        D.26445 = decode_value (p.79, &p);
        D.26446 = (sizetype) D.26445;
        D.26447 = code + D.26446;
        ei->try_end = D.26447;
        p.79 = p;
        D.26448 = decode_value (p.79, &p);
        D.26449 = (sizetype) D.26448;
        D.26450 = code + D.26449;
        ei->handler_start = D.26450;
      }
      i = i + 1;
      <D.23952>:
      D.26451 = jinfo->num_clauses;
      D.26452 = (int) D.26451;
      if (D.26452 > i) goto <D.23951>; else goto <D.23953>;
      <D.23953>:
      code_len.84 = (int) code_len;
      jinfo->code_size = code_len.84;
      jinfo->used_regs = used_int_regs;
      jinfo->d.method = method;
      jinfo->code_start = code;
      jinfo->domain_neutral = 0;
      jinfo->from_aot = -1;
      <D.26411>:
      if (has_try_block_holes != 0) goto <D.26454>; else goto <D.26455>;
      <D.26454>:
      {
        struct MonoTryBlockHoleTableJitInfo * table;

        jinfo->has_try_block_holes = -1;
        table = mono_jit_info_get_try_block_hole_table_info (jinfo);
        D.26456 = table == 0B;
        D.26457 = (long int) D.26456;
        D.26458 = __builtin_expect (D.26457, 0);
        if (D.26458 != 0) goto <D.26459>; else goto <D.26460>;
        <D.26459>:
        monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "aot-runtime.c", 2491, "table");
        <D.26460>:
        D.26461 = (short unsigned int) num_holes;
        table->num_holes = D.26461;
        i = 0;
        goto <D.23957>;
        <D.23956>:
        {
          struct MonoTryBlockHoleJitInfo * hole;

          hole = &table->holes[i];
          p.79 = p;
          D.26462 = decode_value (p.79, &p);
          D.26463 = (short unsigned int) D.26462;
          hole->clause = D.26463;
          p.79 = p;
          D.26464 = decode_value (p.79, &p);
          D.26465 = (short unsigned int) D.26464;
          hole->length = D.26465;
          p.79 = p;
          D.26466 = decode_value (p.79, &p);
          D.26467 = (unsigned int) D.26466;
          hole->offset = D.26467;
        }
        i = i + 1;
        <D.23957>:
        if (i < num_holes) goto <D.23956>; else goto <D.23958>;
        <D.23958>:
      }
      <D.26455>:
      if (has_arch_eh_jit_info != 0) goto <D.26468>; else goto <D.26469>;
      <D.26468>:
      {
        struct MonoArchEHJitInfo * eh_info;

        jinfo->has_arch_eh_info = -1;
        eh_info = mono_jit_info_get_arch_eh_info (jinfo);
        p.79 = p;
        D.26470 = decode_value (p.79, &p);
        D.26471 = (unsigned int) D.26470;
        eh_info->stack_size = D.26471;
      }
      <D.26469>:
      if (async != 0) goto <D.26472>; else goto <D.26473>;
      <D.26472>:
      jinfo->async = -1;
      jinfo->d.aot_info = amodule;
      D.26474 = jinfo;
      return D.26474;
      <D.26473>:
      if (has_generic_jit_info != 0) goto <D.26475>; else goto <D.26476>;
      <D.26475>:
      {
        struct MonoGenericJitInfo * gi;
        int len;

        jinfo->has_generic_jit_info = -1;
        gi = mono_jit_info_get_generic_jit_info (jinfo);
        D.26477 = gi == 0B;
        D.26478 = (long int) D.26477;
        D.26479 = __builtin_expect (D.26478, 0);
        if (D.26479 != 0) goto <D.26480>; else goto <D.26481>;
        <D.26480>:
        monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "aot-runtime.c", 2526, "gi");
        <D.26481>:
        p.79 = p;
        D.26482 = decode_value (p.79, &p);
        gi->nlocs = D.26482;
        D.26483 = gi->nlocs;
        if (D.26483 != 0) goto <D.26484>; else goto <D.26485>;
        <D.26484>:
        D.26483 = gi->nlocs;
        D.26486 = (unsigned int) D.26483;
        D.26487 = D.26486 * 20;
        D.26488 = (int) D.26487;
        D.26489 = alloc0_jit_info_data (domain, D.26488, async);
        gi->locations = D.26489;
        i = 0;
        goto <D.23964>;
        <D.23963>:
        {
          struct MonoDwarfLocListEntry * entry;

          D.26490 = gi->locations;
          D.26394 = (long unsigned int) i;
          D.26491 = D.26394 * 20;
          entry = D.26490 + D.26491;
          p.79 = p;
          D.26492 = decode_value (p.79, &p);
          entry->is_reg = D.26492;
          p.79 = p;
          D.26493 = decode_value (p.79, &p);
          entry->reg = D.26493;
          D.26494 = entry->is_reg;
          if (D.26494 == 0) goto <D.26495>; else goto <D.26496>;
          <D.26495>:
          p.79 = p;
          D.26497 = decode_value (p.79, &p);
          entry->offset = D.26497;
          <D.26496>:
          if (i > 0) goto <D.26498>; else goto <D.26499>;
          <D.26498>:
          p.79 = p;
          D.26500 = decode_value (p.79, &p);
          entry->from = D.26500;
          <D.26499>:
          p.79 = p;
          D.26501 = decode_value (p.79, &p);
          entry->to = D.26501;
        }
        i = i + 1;
        <D.23964>:
        D.26483 = gi->nlocs;
        if (D.26483 > i) goto <D.23963>; else goto <D.23965>;
        <D.23965>:
        goto <D.26502>;
        <D.26485>:
        if (from_llvm != 0) goto <D.26503>; else goto <D.26504>;
        <D.26503>:
        this_reg.85 = this_reg;
        D.26506 = this_reg.85 != -1;
        D.26507 = (<unnamed-signed:1>) D.26506;
        gi->has_this = D.26507;
        this_reg.85 = this_reg;
        D.26508 = (unsigned char) this_reg.85;
        gi->this_reg = D.26508;
        this_offset.86 = this_offset;
        gi->this_offset = this_offset.86;
        goto <D.26510>;
        <D.26504>:
        p.79 = p;
        D.26511 = decode_value (p.79, &p);
        D.26512 = (signed char) D.26511;
        D.26513 = (<unnamed-signed:1>) D.26512;
        gi->has_this = D.26513;
        p.79 = p;
        D.26514 = decode_value (p.79, &p);
        D.26515 = (unsigned char) D.26514;
        gi->this_reg = D.26515;
        p.79 = p;
        D.26516 = decode_value (p.79, &p);
        gi->this_offset = D.26516;
        <D.26510>:
        <D.26502>:
        p.79 = p;
        len = decode_value (p.79, &p);
        if (async != 0) goto <D.26517>; else goto <D.26518>;
        <D.26517>:
        p.79 = p;
        D.26519 = (sizetype) len;
        p.87 = p.79 + D.26519;
        p = p.87;
        goto <D.26521>;
        <D.26518>:
        p.79 = p;
        D.26522 = decode_resolve_method_ref (amodule, p.79, &p);
        jinfo->d.method = D.26522;
        <D.26521>:
        D.26523 = monoeg_malloc0 (16);
        gi->generic_sharing_context = D.26523;
        p.79 = p;
        D.26524 = decode_value (p.79, &p);
        if (D.26524 != 0) goto <D.26525>; else goto <D.26526>;
        <D.26525>:
        {
          int i;
          int n;
          struct MonoGenericSharingContext * gsctx;

          gsctx = gi->generic_sharing_context;
          p.79 = p;
          n = decode_value (p.79, &p);
          if (n != 0) goto <D.26527>; else goto <D.26528>;
          <D.26527>:
          n.88 = (unsigned int) n;
          D.26530 = n.88 * 4;
          D.26531 = (int) D.26530;
          D.26532 = alloc0_jit_info_data (domain, D.26531, async);
          gsctx->var_is_vt = D.26532;
          i = 0;
          goto <D.23970>;
          <D.23969>:
          D.26533 = gsctx->var_is_vt;
          D.26534 = (long unsigned int) i;
          D.26535 = D.26534 * 4;
          D.26536 = D.26533 + D.26535;
          p.79 = p;
          D.26537 = decode_value (p.79, &p);
          *D.26536 = D.26537;
          i = i + 1;
          <D.23970>:
          if (i < n) goto <D.23969>; else goto <D.23971>;
          <D.23971>:
          <D.26528>:
          p.79 = p;
          n = decode_value (p.79, &p);
          if (n != 0) goto <D.26538>; else goto <D.26539>;
          <D.26538>:
          n.88 = (unsigned int) n;
          D.26530 = n.88 * 4;
          D.26531 = (int) D.26530;
          D.26540 = alloc0_jit_info_data (domain, D.26531, async);
          gsctx->mvar_is_vt = D.26540;
          i = 0;
          goto <D.23973>;
          <D.23972>:
          D.26541 = gsctx->mvar_is_vt;
          D.26534 = (long unsigned int) i;
          D.26535 = D.26534 * 4;
          D.26542 = D.26541 + D.26535;
          p.79 = p;
          D.26543 = decode_value (p.79, &p);
          *D.26542 = D.26543;
          i = i + 1;
          <D.23973>:
          if (i < n) goto <D.23972>; else goto <D.23974>;
          <D.23974>:
          <D.26539>:
        }
        <D.26526>:
      }
      <D.26476>:
      if (method != 0B) goto <D.26544>; else goto <D.26545>;
      <D.26544>:
      if (has_seq_points != 0) goto <D.26546>; else goto <D.26547>;
      <D.26546>:
      {
        struct MonoSeqPointInfo * seq_points;
        int il_offset;
        int native_offset;
        int last_il_offset;
        int last_native_offset;
        int j;
        int len;

        p.79 = p;
        len = decode_value (p.79, &p);
        D.26548 = (long unsigned int) len;
        D.26549 = D.26548 * 32;
        D.26550 = D.26549 + 8;
        seq_points = monoeg_malloc0 (D.26550);
        seq_points->len = len;
        last_native_offset = 0;
        last_il_offset = last_native_offset;
        i = 0;
        goto <D.23987>;
        <D.23986>:
        {
          struct SeqPoint * sp;

          sp = &seq_points->seq_points[i];
          p.79 = p;
          D.26551 = decode_value (p.79, &p);
          il_offset = D.26551 + last_il_offset;
          p.79 = p;
          D.26552 = decode_value (p.79, &p);
          native_offset = D.26552 + last_native_offset;
          sp->il_offset = il_offset;
          sp->native_offset = native_offset;
          p.79 = p;
          D.26553 = decode_value (p.79, &p);
          sp->flags = D.26553;
          p.79 = p;
          D.26554 = decode_value (p.79, &p);
          sp->next_len = D.26554;
          D.26555 = sp->next_len;
          D.26556 = (long unsigned int) D.26555;
          D.26557 = D.26556 * 4;
          D.26558 = monoeg_malloc (D.26557);
          sp->next = D.26558;
          j = 0;
          goto <D.23984>;
          <D.23983>:
          D.26559 = sp->next;
          D.26560 = (long unsigned int) j;
          D.26561 = D.26560 * 4;
          D.26562 = D.26559 + D.26561;
          p.79 = p;
          D.26563 = decode_value (p.79, &p);
          *D.26562 = D.26563;
          j = j + 1;
          <D.23984>:
          D.26555 = sp->next_len;
          if (D.26555 > j) goto <D.23983>; else goto <D.23985>;
          <D.23985>:
          last_il_offset = il_offset;
          last_native_offset = native_offset;
        }
        i = i + 1;
        <D.23987>:
        if (i < len) goto <D.23986>; else goto <D.23988>;
        <D.23988>:
        {
          int ret;

          D.26564 = &domain->lock.mutex;
          ret = pthread_mutex_lock (D.26564);
          if (ret != 0) goto <D.26565>; else goto <D.26566>;
          <D.26565>:
          monoeg_g_log (0B, 16, "Bad call to mono_mutex_lock result %d", ret);
          <D.26566>:
          D.26567 = ret != 0;
          D.26568 = (long int) D.26567;
          D.26569 = __builtin_expect (D.26568, 0);
          if (D.26569 != 0) goto <D.26570>; else goto <D.26571>;
          <D.26570>:
          monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "aot-runtime.c", 2608, "ret == 0");
          <D.26571>:
        }
        D.26572 = domain->runtime_info;
        D.26573 = MEM[(struct MonoJitDomainInfo *)D.26572].seq_points;
        monoeg_g_hash_table_insert_replace (D.26573, method, seq_points, 0);
        {
          int ret;

          D.26564 = &domain->lock.mutex;
          ret = pthread_mutex_unlock (D.26564);
          if (ret != 0) goto <D.26574>; else goto <D.26575>;
          <D.26574>:
          monoeg_g_log (0B, 16, "Bad call to mono_mutex_unlock result %d", ret);
          <D.26575>:
          D.26576 = ret != 0;
          D.26577 = (long int) D.26576;
          D.26578 = __builtin_expect (D.26577, 0);
          if (D.26578 != 0) goto <D.26579>; else goto <D.26580>;
          <D.26579>:
          monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "aot-runtime.c", 2610, "ret == 0");
          <D.26580>:
        }
      }
      <D.26547>:
      <D.26545>:
      p.79 = p;
      buf_len = decode_value (p.79, &p);
      if (async == 0) goto <D.26581>; else goto <D.26582>;
      <D.26581>:
      p.79 = p;
      buf_len.89 = (unsigned int) buf_len;
      mono_debug_add_aot_method (domain, method, code, p.79, buf_len.89);
      <D.26582>:
      p.79 = p;
      D.26584 = (sizetype) buf_len;
      p.90 = p.79 + D.26584;
      p = p.90;
      if (has_gc_map != 0) goto <D.26586>; else goto <D.26587>;
      <D.26586>:
      {
        int map_size;

        p.79 = p;
        map_size = decode_value (p.79, &p);
        goto <D.23993>;
        <D.23992>:
        p.79 = p;
        p.91 = p.79 + 1;
        p = p.91;
        <D.23993>:
        p.79 = p;
        p.92 = (long unsigned int) p.79;
        D.26590 = p.92 & 3;
        if (D.26590 != 0) goto <D.23992>; else goto <D.23994>;
        <D.23994>:
        p.79 = p;
        jinfo->gc_info = p.79;
        p.79 = p;
        D.26591 = (sizetype) map_size;
        p.93 = p.79 + D.26591;
        p = p.93;
      }
      <D.26587>:
      D.26593 = jinfo->d.method;
      D.26594 = D.26593->klass;
      D.26595 = D.26594->image;
      D.26596 = D.26595->aot_module;
      if (D.26596 != amodule) goto <D.26597>; else goto <D.26598>;
      <D.26597>:
      {
        int ret;

        ret = pthread_mutex_lock (&aot_mutex.mutex);
        if (ret != 0) goto <D.26599>; else goto <D.26600>;
        <D.26599>:
        monoeg_g_log (0B, 16, "Bad call to mono_mutex_lock result %d", ret);
        <D.26600>:
        D.26601 = ret != 0;
        D.26602 = (long int) D.26601;
        D.26603 = __builtin_expect (D.26602, 0);
        if (D.26603 != 0) goto <D.26604>; else goto <D.26605>;
        <D.26604>:
        monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "aot-runtime.c", 2629, "ret == 0");
        <D.26605>:
      }
      ji_to_amodule.94 = ji_to_amodule;
      if (ji_to_amodule.94 == 0B) goto <D.26607>; else goto <D.26608>;
      <D.26607>:
      D.26609 = monoeg_g_hash_table_new (0B, 0B);
      ji_to_amodule = D.26609;
      <D.26608>:
      ji_to_amodule.94 = ji_to_amodule;
      monoeg_g_hash_table_insert_replace (ji_to_amodule.94, jinfo, amodule, 0);
      {
        int ret;

        ret = pthread_mutex_unlock (&aot_mutex.mutex);
        if (ret != 0) goto <D.26610>; else goto <D.26611>;
        <D.26610>:
        monoeg_g_log (0B, 16, "Bad call to mono_mutex_unlock result %d", ret);
        <D.26611>:
        D.26612 = ret != 0;
        D.26613 = (long int) D.26612;
        D.26614 = __builtin_expect (D.26613, 0);
        if (D.26614 != 0) goto <D.26615>; else goto <D.26616>;
        <D.26615>:
        monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "aot-runtime.c", 2633, "ret == 0");
        <D.26616>:
      }
      <D.26598>:
      D.26474 = jinfo;
      return D.26474;
    }
  finally
    {
      p = {CLOBBER};
      this_reg = {CLOBBER};
      this_offset = {CLOBBER};
    }
}


decode_llvm_mono_eh_frame (struct MonoAotModule * amodule, struct MonoDomain * domain, struct MonoMethod * method, guint8 * code, struct MonoJitExceptionInfo * clauses, int num_clauses, int extra_size, struct GSList * * nesting, int * this_reg, int * this_offset)
{
  guint8 * D.26619;
  _Bool D.26620;
  long int D.26621;
  long int D.26622;
  unsigned char D.26625;
  _Bool D.26626;
  long int D.26627;
  long int D.26628;
  long int p.95;
  long int D.26632;
  long int D.26633;
  unsigned int D.26634;
  int D.26635;
  int D.26636;
  sizetype D.26637;
  long int code.96;
  guint8 * D.26639;
  long int D.26640;
  long int D.26641;
  int D.26642;
  int D.26643;
  long unsigned int D.26644;
  long unsigned int D.26645;
  gint32 * D.26646;
  int D.26647;
  _Bool D.26648;
  long int D.26649;
  long int D.26650;
  gint32 * D.26653;
  long unsigned int D.26654;
  long unsigned int D.26655;
  gint32 * D.26656;
  int D.26657;
  guint8 * D.26660;
  long int D.26661;
  long int D.26662;
  int D.26664;
  long unsigned int D.26665;
  long unsigned int D.26666;
  gint32 * D.26667;
  int D.26668;
  _Bool D.26669;
  long int D.26670;
  long int D.26671;
  long unsigned int D.26674;
  long unsigned int D.26675;
  gint32 * D.26676;
  int D.26681;
  sizetype D.26682;
  sizetype D.26685;
  int D.26687;
  sizetype D.26688;
  long int code_end.97;
  long int code_start.98;
  long int D.26691;
  int iftmp.99;
  _Bool D.26697;
  long int D.26698;
  long int D.26699;
  guint8 * D.26702;
  long int D.26707;
  sizetype D.26708;
  sizetype D.26709;
  sizetype D.26710;
  gint32 * D.26711;
  int D.26712;
  sizetype D.26713;
  sizetype D.26714;
  sizetype D.26715;
  sizetype D.26716;
  gint32 * D.26717;
  int D.26718;
  int D.26719;
  int fde_len.100;
  int D.26721;
  int D.26722;
  long unsigned int D.26723;
  long unsigned int D.26724;
  void * * D.26725;
  void * D.26726;
  unsigned int D.26727;
  unsigned int D.26728;
  unsigned int D.26729;
  unsigned int D.26730;
  unsigned int D.26731;
  unsigned int D.26732;
  unsigned int D.26733;
  unsigned int D.26734;
  unsigned int D.26735;
  unsigned int D.26736;
  long unsigned int D.26737;
  long unsigned int D.26738;
  struct GSList * * D.26739;
  void * D.26740;
  long int D.26741;
  long unsigned int D.26742;
  long unsigned int D.26743;
  void * * D.26744;
  void * D.26745;
  unsigned int D.26746;
  unsigned int D.26747;
  unsigned int D.26748;
  unsigned int D.26749;
  unsigned int D.26750;
  unsigned int D.26751;
  unsigned int D.26752;
  unsigned int D.26753;
  unsigned int D.26754;
  unsigned int D.26755;
  unsigned int j.101;
  unsigned int i.102;
  unsigned int D.26760;
  unsigned int D.26761;
  unsigned int extra_size.103;
  unsigned int D.26763;
  unsigned int D.26764;
  guint8 * D.26765;
  unsigned int D.26766;
  unsigned int D.26767;
  short unsigned int D.26768;
  short unsigned int D.26769;
  short unsigned int D.26770;
  <unnamed-unsigned:15> D.26771;
  long unsigned int D.26772;
  long unsigned int D.26773;
  _Bool D.26774;
  long int D.26775;
  long int D.26776;
  unsigned int D.26779;
  struct MonoClass * D.26780;
  long unsigned int D.26781;
  struct MonoJitExceptionInfo * D.26782;
  void * D.26783;
  void * D.26784;
  void * D.26785;
  void * D.26788;
  long int D.26791;
  long int D.26792;
  void * D.26793;
  long unsigned int D.26794;
  long unsigned int D.26795;
  struct GSList * * D.26796;
  void * D.26797;
  long int D.26798;
  struct MonoJitExceptionInfo * D.26801;
  struct MonoJitExceptionInfo * D.26802;
  void * D.26803;
  void * D.26804;
  _Bool D.26805;
  long int D.26806;
  long int D.26807;
  struct MonoJitInfo * D.26810;
  guint8 * p;
  guint8 * fde;
  guint8 * cie;
  guint8 * code_start;
  guint8 * code_end;
  int version;
  int fde_count;
  gint32 * table;
  int i;
  int j;
  int pos;
  int left;
  int right;
  int offset;
  int offset1;
  int offset2;
  int code_len;
  int func_encoding;
  struct MonoJitExceptionInfo * ei;
  guint32 fde_len;
  guint32 ei_len;
  guint32 nested_len;
  guint32 nindex;
  void * * type_info;
  struct MonoJitInfo * jinfo;
  struct MonoLLVMFDEInfo info;

  try
    {
      D.26619 = amodule->mono_eh_frame;
      D.26620 = D.26619 == 0B;
      D.26621 = (long int) D.26620;
      D.26622 = __builtin_expect (D.26621, 0);
      if (D.26622 != 0) goto <D.26623>; else goto <D.26624>;
      <D.26623>:
      monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "aot-runtime.c", 2171, "amodule->mono_eh_frame");
      <D.26624>:
      p = amodule->mono_eh_frame;
      D.26625 = *p;
      version = (int) D.26625;
      D.26626 = version != 3;
      D.26627 = (long int) D.26626;
      D.26628 = __builtin_expect (D.26627, 0);
      if (D.26628 != 0) goto <D.26629>; else goto <D.26630>;
      <D.26629>:
      monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "aot-runtime.c", 2179, "version == 3");
      <D.26630>:
      p = p + 1;
      D.26625 = *p;
      func_encoding = (int) D.26625;
      p = p + 1;
      p.95 = (long int) p;
      D.26632 = p.95 + 3;
      D.26633 = D.26632 & -4;
      p = (guint8 *) D.26633;
      D.26634 = MEM[(guint32 *)p];
      fde_count = (int) D.26634;
      p = p + 4;
      table = p;
      D.26635 = fde_count + 1;
      D.26636 = D.26635 * 8;
      D.26637 = (sizetype) D.26636;
      cie = p + D.26637;
      code.96 = (long int) code;
      D.26639 = amodule->code;
      D.26640 = (long int) D.26639;
      D.26641 = code.96 - D.26640;
      offset = (int) D.26641;
      left = 0;
      right = fde_count;
      <D.23864>:
      D.26642 = left + right;
      pos = D.26642 / 2;
      D.26643 = pos * 2;
      D.26644 = (long unsigned int) D.26643;
      D.26645 = D.26644 * 4;
      D.26646 = table + D.26645;
      D.26647 = *D.26646;
      D.26648 = D.26647 == -1;
      D.26649 = (long int) D.26648;
      D.26650 = __builtin_expect (D.26649, 0);
      if (D.26650 != 0) goto <D.26651>; else goto <D.26652>;
      <D.26651>:
      monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "aot-runtime.c", 2200, "table [(pos * 2)] != -1");
      <D.26652>:
      D.26653 = amodule->code_offsets;
      D.26643 = pos * 2;
      D.26644 = (long unsigned int) D.26643;
      D.26645 = D.26644 * 4;
      D.26646 = table + D.26645;
      D.26647 = *D.26646;
      D.26654 = (long unsigned int) D.26647;
      D.26655 = D.26654 * 4;
      D.26656 = D.26653 + D.26655;
      offset1 = *D.26656;
      D.26657 = pos + 1;
      if (D.26657 == fde_count) goto <D.26658>; else goto <D.26659>;
      <D.26658>:
      D.26660 = amodule->code_end;
      D.26661 = (long int) D.26660;
      D.26639 = amodule->code;
      D.26640 = (long int) D.26639;
      D.26662 = D.26661 - D.26640;
      offset2 = (int) D.26662;
      goto <D.26663>;
      <D.26659>:
      D.26657 = pos + 1;
      D.26664 = D.26657 * 2;
      D.26665 = (long unsigned int) D.26664;
      D.26666 = D.26665 * 4;
      D.26667 = table + D.26666;
      D.26668 = *D.26667;
      D.26669 = D.26668 == -1;
      D.26670 = (long int) D.26669;
      D.26671 = __builtin_expect (D.26670, 0);
      if (D.26671 != 0) goto <D.26672>; else goto <D.26673>;
      <D.26672>:
      monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "aot-runtime.c", 2205, "table [(pos + 1) * 2] != -1");
      <D.26673>:
      D.26653 = amodule->code_offsets;
      D.26657 = pos + 1;
      D.26664 = D.26657 * 2;
      D.26665 = (long unsigned int) D.26664;
      D.26666 = D.26665 * 4;
      D.26667 = table + D.26666;
      D.26668 = *D.26667;
      D.26674 = (long unsigned int) D.26668;
      D.26675 = D.26674 * 4;
      D.26676 = D.26653 + D.26675;
      offset2 = *D.26676;
      <D.26663>:
      if (offset < offset1) goto <D.26677>; else goto <D.26678>;
      <D.26677>:
      right = pos;
      goto <D.26679>;
      <D.26678>:
      if (offset >= offset2) goto <D.26680>; else goto <D.23863>;
      <D.26680>:
      left = pos + 1;
      <D.26679>:
      goto <D.23864>;
      <D.23863>:
      D.26639 = amodule->code;
      D.26653 = amodule->code_offsets;
      D.26643 = pos * 2;
      D.26644 = (long unsigned int) D.26643;
      D.26645 = D.26644 * 4;
      D.26646 = table + D.26645;
      D.26647 = *D.26646;
      D.26654 = (long unsigned int) D.26647;
      D.26655 = D.26654 * 4;
      D.26656 = D.26653 + D.26655;
      D.26681 = *D.26656;
      D.26682 = (sizetype) D.26681;
      code_start = D.26639 + D.26682;
      D.26657 = pos + 1;
      if (D.26657 == fde_count) goto <D.26683>; else goto <D.26684>;
      <D.26683>:
      {
        int len;

        D.26657 = pos + 1;
        D.26664 = D.26657 * 2;
        D.26665 = (long unsigned int) D.26664;
        D.26666 = D.26665 * 4;
        D.26667 = table + D.26666;
        len = *D.26667;
        D.26685 = (sizetype) len;
        code_end = code_start + D.26685;
      }
      goto <D.26686>;
      <D.26684>:
      D.26639 = amodule->code;
      D.26653 = amodule->code_offsets;
      D.26657 = pos + 1;
      D.26664 = D.26657 * 2;
      D.26665 = (long unsigned int) D.26664;
      D.26666 = D.26665 * 4;
      D.26667 = table + D.26666;
      D.26668 = *D.26667;
      D.26674 = (long unsigned int) D.26668;
      D.26675 = D.26674 * 4;
      D.26676 = D.26653 + D.26675;
      D.26687 = *D.26676;
      D.26688 = (sizetype) D.26687;
      code_end = D.26639 + D.26688;
      <D.26686>:
      code_end.97 = (long int) code_end;
      code_start.98 = (long int) code_start;
      D.26691 = code_end.97 - code_start.98;
      code_len = (int) D.26691;
      if (code < code_start) goto <D.26693>; else goto <D.26696>;
      <D.26696>:
      if (code >= code_end) goto <D.26693>; else goto <D.26694>;
      <D.26693>:
      iftmp.99 = 1;
      goto <D.26695>;
      <D.26694>:
      iftmp.99 = 0;
      <D.26695>:
      D.26697 = iftmp.99 != 0;
      D.26698 = (long int) D.26697;
      D.26699 = __builtin_expect (D.26698, 0);
      if (D.26699 != 0) goto <D.26700>; else goto <D.26701>;
      <D.26700>:
      monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "aot-runtime.c", 2227, "code >= code_start && code < code_end");
      <D.26701>:
      D.26702 = amodule->thumb_end;
      if (D.26702 != 0B) goto <D.26703>; else goto <D.26704>;
      <D.26703>:
      D.26702 = amodule->thumb_end;
      if (D.26702 > code_start) goto <D.26705>; else goto <D.26706>;
      <D.26705>:
      code_start.98 = (long int) code_start;
      D.26707 = code_start.98 & -2;
      code_start = (guint8 *) D.26707;
      <D.26706>:
      <D.26704>:
      D.26619 = amodule->mono_eh_frame;
      D.26643 = pos * 2;
      D.26708 = (sizetype) D.26643;
      D.26709 = D.26708 + 1;
      D.26710 = D.26709 * 4;
      D.26711 = table + D.26710;
      D.26712 = *D.26711;
      D.26713 = (sizetype) D.26712;
      fde = D.26619 + D.26713;
      D.26657 = pos + 1;
      D.26664 = D.26657 * 2;
      D.26714 = (sizetype) D.26664;
      D.26715 = D.26714 + 1;
      D.26716 = D.26715 * 4;
      D.26717 = table + D.26716;
      D.26718 = *D.26717;
      D.26643 = pos * 2;
      D.26708 = (sizetype) D.26643;
      D.26709 = D.26708 + 1;
      D.26710 = D.26709 * 4;
      D.26711 = table + D.26710;
      D.26712 = *D.26711;
      D.26719 = D.26718 - D.26712;
      fde_len = (guint32) D.26719;
      fde_len.100 = (int) fde_len;
      mono_unwind_decode_llvm_mono_fde (fde, fde_len.100, cie, code_start, &info);
      ei = info.ex_info;
      ei_len = info.ex_info_len;
      type_info = info.type_info;
      D.26721 = info.this_reg;
      *this_reg = D.26721;
      D.26722 = info.this_offset;
      *this_offset = D.26722;
      nested_len = 0;
      i = 0;
      goto <D.23877>;
      <D.23876>:
      {
        gint32 cindex1;
        struct GSList * l;

        D.26723 = (long unsigned int) i;
        D.26724 = D.26723 * 8;
        D.26725 = type_info + D.26724;
        D.26726 = *D.26725;
        D.26727 = MEM[(const guint32 *)D.26726];
        D.26728 = D.26727 << 24;
        D.26723 = (long unsigned int) i;
        D.26724 = D.26723 * 8;
        D.26725 = type_info + D.26724;
        D.26726 = *D.26725;
        D.26727 = MEM[(const guint32 *)D.26726];
        D.26729 = D.26727 >> 8;
        D.26730 = D.26729 & 65280;
        D.26731 = D.26728 | D.26730;
        D.26723 = (long unsigned int) i;
        D.26724 = D.26723 * 8;
        D.26725 = type_info + D.26724;
        D.26726 = *D.26725;
        D.26727 = MEM[(const guint32 *)D.26726];
        D.26732 = D.26727 << 8;
        D.26733 = D.26732 & 16711680;
        D.26734 = D.26731 | D.26733;
        D.26723 = (long unsigned int) i;
        D.26724 = D.26723 * 8;
        D.26725 = type_info + D.26724;
        D.26726 = *D.26725;
        D.26727 = MEM[(const guint32 *)D.26726];
        D.26735 = D.26727 >> 24;
        D.26736 = D.26734 | D.26735;
        cindex1 = (gint32) D.26736;
        D.26737 = (long unsigned int) cindex1;
        D.26738 = D.26737 * 8;
        D.26739 = nesting + D.26738;
        l = *D.26739;
        goto <D.23874>;
        <D.23873>:
        {
          gint32 nesting_cindex;

          D.26740 = l->data;
          D.26741 = (long int) D.26740;
          nesting_cindex = (gint32) D.26741;
          j = 0;
          goto <D.23871>;
          <D.23870>:
          {
            gint32 cindex2;

            D.26742 = (long unsigned int) j;
            D.26743 = D.26742 * 8;
            D.26744 = type_info + D.26743;
            D.26745 = *D.26744;
            D.26746 = MEM[(const guint32 *)D.26745];
            D.26747 = D.26746 << 24;
            D.26742 = (long unsigned int) j;
            D.26743 = D.26742 * 8;
            D.26744 = type_info + D.26743;
            D.26745 = *D.26744;
            D.26746 = MEM[(const guint32 *)D.26745];
            D.26748 = D.26746 >> 8;
            D.26749 = D.26748 & 65280;
            D.26750 = D.26747 | D.26749;
            D.26742 = (long unsigned int) j;
            D.26743 = D.26742 * 8;
            D.26744 = type_info + D.26743;
            D.26745 = *D.26744;
            D.26746 = MEM[(const guint32 *)D.26745];
            D.26751 = D.26746 << 8;
            D.26752 = D.26751 & 16711680;
            D.26753 = D.26750 | D.26752;
            D.26742 = (long unsigned int) j;
            D.26743 = D.26742 * 8;
            D.26744 = type_info + D.26743;
            D.26745 = *D.26744;
            D.26746 = MEM[(const guint32 *)D.26745];
            D.26754 = D.26746 >> 24;
            D.26755 = D.26753 | D.26754;
            cindex2 = (gint32) D.26755;
            if (cindex2 == nesting_cindex) goto <D.26756>; else goto <D.26757>;
            <D.26756>:
            nested_len = nested_len + 1;
            <D.26757>:
          }
          j = j + 1;
          <D.23871>:
          j.101 = (unsigned int) j;
          if (j.101 < ei_len) goto <D.23870>; else goto <D.23872>;
          <D.23872>:
        }
        l = l->next;
        <D.23874>:
        if (l != 0B) goto <D.23873>; else goto <D.23875>;
        <D.23875>:
      }
      i = i + 1;
      <D.23877>:
      i.102 = (unsigned int) i;
      if (i.102 < ei_len) goto <D.23876>; else goto <D.23878>;
      <D.23878>:
      D.26760 = ei_len + nested_len;
      D.26761 = D.26760 * 40;
      extra_size.103 = (unsigned int) extra_size;
      D.26763 = D.26761 + extra_size.103;
      D.26764 = D.26763 + 48;
      jinfo = mono_domain_alloc0_lock_free (domain, D.26764);
      jinfo->code_size = code_len;
      D.26765 = info.unw_info;
      D.26766 = info.unw_info_len;
      D.26767 = mono_cache_unwind_info (D.26765, D.26766);
      jinfo->used_regs = D.26767;
      jinfo->d.method = method;
      jinfo->code_start = code;
      jinfo->domain_neutral = 0;
      jinfo->from_aot = 0;
      D.26768 = (short unsigned int) ei_len;
      D.26769 = (short unsigned int) nested_len;
      D.26770 = D.26768 + D.26769;
      D.26771 = (<unnamed-unsigned:15>) D.26770;
      jinfo->num_clauses = D.26771;
      i = 0;
      goto <D.23883>;
      <D.23882>:
      {
        int clause_index;
        struct MonoJitExceptionInfo * jei;
        struct MonoJitExceptionInfo * orig_jei;

        D.26723 = (long unsigned int) i;
        D.26724 = D.26723 * 8;
        D.26725 = type_info + D.26724;
        D.26726 = *D.26725;
        D.26727 = MEM[(const guint32 *)D.26726];
        D.26728 = D.26727 << 24;
        D.26723 = (long unsigned int) i;
        D.26724 = D.26723 * 8;
        D.26725 = type_info + D.26724;
        D.26726 = *D.26725;
        D.26727 = MEM[(const guint32 *)D.26726];
        D.26729 = D.26727 >> 8;
        D.26730 = D.26729 & 65280;
        D.26731 = D.26728 | D.26730;
        D.26723 = (long unsigned int) i;
        D.26724 = D.26723 * 8;
        D.26725 = type_info + D.26724;
        D.26726 = *D.26725;
        D.26727 = MEM[(const guint32 *)D.26726];
        D.26732 = D.26727 << 8;
        D.26733 = D.26732 & 16711680;
        D.26734 = D.26731 | D.26733;
        D.26723 = (long unsigned int) i;
        D.26724 = D.26723 * 8;
        D.26725 = type_info + D.26724;
        D.26726 = *D.26725;
        D.26727 = MEM[(const guint32 *)D.26726];
        D.26735 = D.26727 >> 24;
        D.26736 = D.26734 | D.26735;
        clause_index = (int) D.26736;
        jei = &jinfo->clauses[i];
        D.26772 = (long unsigned int) clause_index;
        D.26773 = D.26772 * 40;
        orig_jei = clauses + D.26773;
        D.26774 = clause_index >= num_clauses;
        D.26775 = (long int) D.26774;
        D.26776 = __builtin_expect (D.26775, 0);
        if (D.26776 != 0) goto <D.26777>; else goto <D.26778>;
        <D.26777>:
        monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "aot-runtime.c", 2289, "clause_index < num_clauses");
        <D.26778>:
        D.26779 = orig_jei->flags;
        jei->flags = D.26779;
        D.26780 = orig_jei->data.catch_class;
        jei->data.catch_class = D.26780;
        D.26723 = (long unsigned int) i;
        D.26781 = D.26723 * 40;
        D.26782 = ei + D.26781;
        D.26783 = D.26782->try_start;
        jei->try_start = D.26783;
        D.26723 = (long unsigned int) i;
        D.26781 = D.26723 * 40;
        D.26782 = ei + D.26781;
        D.26784 = D.26782->try_end;
        jei->try_end = D.26784;
        D.26723 = (long unsigned int) i;
        D.26781 = D.26723 * 40;
        D.26782 = ei + D.26781;
        D.26785 = D.26782->handler_start;
        jei->handler_start = D.26785;
        D.26702 = amodule->thumb_end;
        if (D.26702 != 0B) goto <D.26786>; else goto <D.26787>;
        <D.26786>:
        D.26788 = jei->handler_start;
        D.26702 = amodule->thumb_end;
        if (D.26788 < D.26702) goto <D.26789>; else goto <D.26790>;
        <D.26789>:
        D.26788 = jei->handler_start;
        D.26791 = (long int) D.26788;
        D.26792 = D.26791 + 1;
        D.26793 = (void *) D.26792;
        jei->handler_start = D.26793;
        <D.26790>:
        <D.26787>:
      }
      i = i + 1;
      <D.23883>:
      i.102 = (unsigned int) i;
      if (i.102 < ei_len) goto <D.23882>; else goto <D.23884>;
      <D.23884>:
      nindex = ei_len;
      i = 0;
      goto <D.23896>;
      <D.23895>:
      {
        gint32 cindex1;
        struct GSList * l;

        D.26723 = (long unsigned int) i;
        D.26724 = D.26723 * 8;
        D.26725 = type_info + D.26724;
        D.26726 = *D.26725;
        D.26727 = MEM[(const guint32 *)D.26726];
        D.26728 = D.26727 << 24;
        D.26723 = (long unsigned int) i;
        D.26724 = D.26723 * 8;
        D.26725 = type_info + D.26724;
        D.26726 = *D.26725;
        D.26727 = MEM[(const guint32 *)D.26726];
        D.26729 = D.26727 >> 8;
        D.26730 = D.26729 & 65280;
        D.26731 = D.26728 | D.26730;
        D.26723 = (long unsigned int) i;
        D.26724 = D.26723 * 8;
        D.26725 = type_info + D.26724;
        D.26726 = *D.26725;
        D.26727 = MEM[(const guint32 *)D.26726];
        D.26732 = D.26727 << 8;
        D.26733 = D.26732 & 16711680;
        D.26734 = D.26731 | D.26733;
        D.26723 = (long unsigned int) i;
        D.26724 = D.26723 * 8;
        D.26725 = type_info + D.26724;
        D.26726 = *D.26725;
        D.26727 = MEM[(const guint32 *)D.26726];
        D.26735 = D.26727 >> 24;
        D.26736 = D.26734 | D.26735;
        cindex1 = (gint32) D.26736;
        D.26794 = (long unsigned int) cindex1;
        D.26795 = D.26794 * 8;
        D.26796 = nesting + D.26795;
        l = *D.26796;
        goto <D.23893>;
        <D.23892>:
        {
          gint32 nesting_cindex;

          D.26797 = l->data;
          D.26798 = (long int) D.26797;
          nesting_cindex = (gint32) D.26798;
          j = 0;
          goto <D.23890>;
          <D.23889>:
          {
            gint32 cindex2;

            D.26742 = (long unsigned int) j;
            D.26743 = D.26742 * 8;
            D.26744 = type_info + D.26743;
            D.26745 = *D.26744;
            D.26746 = MEM[(const guint32 *)D.26745];
            D.26747 = D.26746 << 24;
            D.26742 = (long unsigned int) j;
            D.26743 = D.26742 * 8;
            D.26744 = type_info + D.26743;
            D.26745 = *D.26744;
            D.26746 = MEM[(const guint32 *)D.26745];
            D.26748 = D.26746 >> 8;
            D.26749 = D.26748 & 65280;
            D.26750 = D.26747 | D.26749;
            D.26742 = (long unsigned int) j;
            D.26743 = D.26742 * 8;
            D.26744 = type_info + D.26743;
            D.26745 = *D.26744;
            D.26746 = MEM[(const guint32 *)D.26745];
            D.26751 = D.26746 << 8;
            D.26752 = D.26751 & 16711680;
            D.26753 = D.26750 | D.26752;
            D.26742 = (long unsigned int) j;
            D.26743 = D.26742 * 8;
            D.26744 = type_info + D.26743;
            D.26745 = *D.26744;
            D.26746 = MEM[(const guint32 *)D.26745];
            D.26754 = D.26746 >> 24;
            D.26755 = D.26753 | D.26754;
            cindex2 = (gint32) D.26755;
            if (cindex2 == nesting_cindex) goto <D.26799>; else goto <D.26800>;
            <D.26799>:
            D.26801 = &jinfo->clauses[nindex];
            D.26802 = &jinfo->clauses[j];
            memcpy (D.26801, D.26802, 40);
            D.26803 = jinfo->clauses[i].try_start;
            jinfo->clauses[nindex].try_start = D.26803;
            D.26804 = jinfo->clauses[i].try_end;
            jinfo->clauses[nindex].try_end = D.26804;
            nindex = nindex + 1;
            <D.26800>:
          }
          j = j + 1;
          <D.23890>:
          j.101 = (unsigned int) j;
          if (j.101 < ei_len) goto <D.23889>; else goto <D.23891>;
          <D.23891>:
        }
        l = l->next;
        <D.23893>:
        if (l != 0B) goto <D.23892>; else goto <D.23894>;
        <D.23894>:
      }
      i = i + 1;
      <D.23896>:
      i.102 = (unsigned int) i;
      if (i.102 < ei_len) goto <D.23895>; else goto <D.23897>;
      <D.23897>:
      D.26760 = ei_len + nested_len;
      D.26805 = D.26760 != nindex;
      D.26806 = (long int) D.26805;
      D.26807 = __builtin_expect (D.26806, 0);
      if (D.26807 != 0) goto <D.26808>; else goto <D.26809>;
      <D.26808>:
      monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "aot-runtime.c", 2327, "nindex == ei_len + nested_len");
      <D.26809>:
      D.26810 = jinfo;
      return D.26810;
    }
  finally
    {
      info = {CLOBBER};
    }
}


alloc0_jit_info_data (struct MonoDomain * domain, int size, gboolean async_context)
{
  unsigned int size.104;
  void * D.26817;
  void * res;

  if (async_context != 0) goto <D.26813>; else goto <D.26814>;
  <D.26813>:
  size.104 = (unsigned int) size;
  res = mono_domain_alloc0_lock_free (domain, size.104);
  InterlockedExchangeAdd (&async_jit_info_size, size);
  goto <D.26816>;
  <D.26814>:
  size.104 = (unsigned int) size;
  res = mono_domain_alloc0 (domain, size.104);
  <D.26816>:
  D.26817 = res;
  return D.26817;
}


InterlockedExchangeAdd (volatile gint32 * val, gint32 add)
{
  gint32 D.26819;
  unsigned int add.105;
  unsigned int D.26821;

  add.105 = (unsigned int) add;
  D.26821 = __sync_fetch_and_add_4 (val, add.105);
  D.26819 = (gint32) D.26821;
  return D.26819;
}


mono_memory_barrier ()
{
  __sync_synchronize ();
}


InterlockedCompareExchangePointer (void * volatile * dest, void * exch, void * comp)
{
  void * D.26823;
  long unsigned int comp.106;
  long unsigned int exch.107;
  long unsigned int D.26826;

  comp.106 = (long unsigned int) comp;
  exch.107 = (long unsigned int) exch;
  D.26826 = __sync_val_compare_and_swap_8 (dest, comp.106, exch.107);
  D.26823 = (void *) D.26826;
  return D.26823;
}


__attribute__((visibility ("hidden")))
mono_aot_get_method (struct MonoDomain * domain, struct MonoMethod * method)
{
  struct MonoImage * D.26828;
  void * amodule.108;
  struct MonoAotModule * amodule.109;
  void * D.26833;
  int D.26834;
  short unsigned int D.26839;
  int D.26840;
  int D.26841;
  short unsigned int D.26843;
  int D.26844;
  int D.26845;
  int D.26847;
  int D.26849;
  int mono_aot_only.110;
  long unsigned int D.26853;
  long unsigned int D.26854;
  struct MonoMethod * D.26857;
  long unsigned int D.26858;
  signed long D.26859;
  _Bool D.26860;
  long int D.26861;
  long int D.26862;
  long unsigned int D.26867;
  int D.26869;
  unsigned int D.26871;
  unsigned int D.26872;
  long unsigned int D.26876;
  _Bool D.26880;
  long int D.26881;
  long int D.26882;
  struct GHashTable * D.26885;
  _Bool D.26888;
  long int D.26889;
  long int D.26890;
  struct MonoClass * D.26899;
  unsigned char D.26900;
  const char * D.26903;
  char * D.26904;
  int D.26909;
  void * D.26912;
  struct MonoClass * D.26917;
  int D.26920;
  struct MonoMethodSignature * D.26923;
  struct MonoType * D.26924;
  unsigned char D.26925;
  _Bool D.26928;
  long int D.26929;
  long int D.26930;
  struct MonoClass * D.26933;
  struct MonoType * D.26934;
  struct MonoGenericInst * D.26935;
  struct MonoMethod * D.26936;
  struct MonoImage * D.26948;
  struct MonoImage * D.26949;
  const char * D.26952;
  int D.26953;
  const char * D.26955;
  int D.26956;
  int D.26958;
  int D.26960;
  struct MonoMethodSignature * D.26961;
  struct MonoType * D.26962;
  int D.26963;
  int D.26964;
  int D.26966;
  int D.26968;
  struct MonoMethodSignature * D.26970;
  struct MonoType * D.26971;
  int D.26972;
  int D.26973;
  int D.26975;
  int D.26977;
  struct MonoMethodSignature * D.26979;
  struct MonoType * D.26980;
  int D.26981;
  struct MonoMethodSignature * D.26982;
  short unsigned int D.26983;
  const char * D.26986;
  int D.26987;
  _Bool D.26989;
  long int D.26990;
  long int D.26991;
  struct MonoGenericInst * D.26994;
  struct MonoMethod * D.26995;
  int D.27004;
  int D.27013;
  struct MonoMethod * D.27016;
  int D.27023;
  _Bool D.27030;
  long int D.27031;
  long int D.27032;
  struct GHashTable * D.27035;
  struct GHashTable * D.27038;
  long unsigned int D.27039;
  void * D.27040;
  _Bool D.27043;
  long int D.27044;
  long int D.27045;
  int method_index.111;
  struct MonoClass * klass;
  guint32 method_index;
  struct MonoAotModule * amodule;
  guint8 * code;

  try
    {
      klass = method->klass;
      D.26828 = klass->image;
      amodule.108 = D.26828->aot_module;
      amodule = amodule.108;
      amodule.109 = amodule;
      if (amodule.109 == 0B) goto <D.26831>; else goto <D.26832>;
      <D.26831>:
      D.26833 = 0B;
      return D.26833;
      <D.26832>:
      amodule.109 = amodule;
      D.26834 = amodule.109->out_of_date;
      if (D.26834 != 0) goto <D.26835>; else goto <D.26836>;
      <D.26835>:
      D.26833 = 0B;
      return D.26833;
      <D.26836>:
      D.26839 = method->iflags;
      D.26840 = (int) D.26839;
      D.26841 = D.26840 & 4096;
      if (D.26841 != 0) goto <D.26837>; else goto <D.26842>;
      <D.26842>:
      D.26843 = method->flags;
      D.26844 = (int) D.26843;
      D.26845 = D.26844 & 8192;
      if (D.26845 != 0) goto <D.26837>; else goto <D.26846>;
      <D.26846>:
      D.26839 = method->iflags;
      D.26840 = (int) D.26839;
      D.26847 = D.26840 & 3;
      if (D.26847 != 0) goto <D.26837>; else goto <D.26848>;
      <D.26848>:
      D.26843 = method->flags;
      D.26844 = (int) D.26843;
      D.26849 = D.26844 & 1024;
      if (D.26849 != 0) goto <D.26837>; else goto <D.26838>;
      <D.26837>:
      D.26833 = 0B;
      return D.26833;
      <D.26838>:
      mono_aot_only.110 = mono_aot_only;
      if (mono_aot_only.110 != 0) goto <D.26851>; else goto <D.26852>;
      <D.26851>:
      D.26853 = BIT_FIELD_REF <*method, 64, 256>;
      D.26854 = D.26853 & 4467570830351532032;
      if (D.26854 == 1297036692682702848) goto <D.26855>; else goto <D.26856>;
      <D.26855>:
      D.26857 = mono_marshal_method_from_wrapper (method);
      D.26833 = mono_aot_get_method (domain, D.26857);
      return D.26833;
      <D.26856>:
      <D.26852>:
      D.26858 = BIT_FIELD_REF <*klass, 64, 256>;
      D.26859 = (signed long) D.26858;
      D.26860 = D.26859 >= 0;
      D.26861 = (long int) D.26860;
      D.26862 = __builtin_expect (D.26861, 0);
      if (D.26862 != 0) goto <D.26863>; else goto <D.26864>;
      <D.26863>:
      monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "aot-runtime.c", 3615, "klass->inited");
      <D.26864>:
      method_index = 16777215;
      D.26853 = BIT_FIELD_REF <*method, 64, 256>;
      D.26867 = D.26853 & 4469822630165217280;
      if (D.26867 == 2251799813685248) goto <D.26868>; else goto <D.26865>;
      <D.26868>:
      D.26869 = mono_method_is_generic_sharable_full (method, 0, 0, 0);
      if (D.26869 != 0) goto <D.26870>; else goto <D.26865>;
      <D.26870>:
      method = mono_method_get_declaring_generic_method (method);
      D.26871 = method->token;
      D.26872 = D.26871 & 16777215;
      method_index = D.26872 + 4294967295;
      goto <D.26866>;
      <D.26865>:
      D.26853 = BIT_FIELD_REF <*method, 64, 256>;
      D.26876 = D.26853 & 2251799813685248;
      if (D.26876 != 0) goto <D.26873>; else goto <D.26877>;
      <D.26877>:
      D.26871 = method->token;
      if (D.26871 == 0) goto <D.26873>; else goto <D.26874>;
      <D.26873>:
      {
        int ret;

        ret = pthread_mutex_lock (&aot_mutex.mutex);
        if (ret != 0) goto <D.26878>; else goto <D.26879>;
        <D.26878>:
        monoeg_g_log (0B, 16, "Bad call to mono_mutex_lock result %d", ret);
        <D.26879>:
        D.26880 = ret != 0;
        D.26881 = (long int) D.26880;
        D.26882 = __builtin_expect (D.26881, 0);
        if (D.26882 != 0) goto <D.26883>; else goto <D.26884>;
        <D.26883>:
        monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "aot-runtime.c", 3628, "ret == 0");
        <D.26884>:
      }
      amodule.109 = amodule;
      D.26885 = amodule.109->method_to_code;
      code = monoeg_g_hash_table_lookup (D.26885, method);
      {
        int ret;

        ret = pthread_mutex_unlock (&aot_mutex.mutex);
        if (ret != 0) goto <D.26886>; else goto <D.26887>;
        <D.26886>:
        monoeg_g_log (0B, 16, "Bad call to mono_mutex_unlock result %d", ret);
        <D.26887>:
        D.26888 = ret != 0;
        D.26889 = (long int) D.26888;
        D.26890 = __builtin_expect (D.26889, 0);
        if (D.26890 != 0) goto <D.26891>; else goto <D.26892>;
        <D.26891>:
        monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "aot-runtime.c", 3630, "ret == 0");
        <D.26892>:
      }
      if (code != 0B) goto <D.26893>; else goto <D.26894>;
      <D.26893>:
      D.26833 = code;
      return D.26833;
      <D.26894>:
      method_index = find_extra_method (method, &amodule);
      if (method_index == 16777215) goto <D.26895>; else goto <D.26896>;
      <D.26895>:
      D.26853 = BIT_FIELD_REF <*method, 64, 256>;
      D.26854 = D.26853 & 4467570830351532032;
      if (D.26854 == 1008806316530991104) goto <D.26897>; else goto <D.26898>;
      <D.26897>:
      D.26899 = method->klass;
      D.26900 = D.26899->rank;
      if (D.26900 != 0) goto <D.26901>; else goto <D.26902>;
      <D.26901>:
      D.26903 = method->name;
      D.26904 = strstr (D.26903, "System.Collections.Generic");
      if (D.26904 != 0B) goto <D.26905>; else goto <D.26906>;
      <D.26905>:
      {
        struct MonoMethod * m;

        m = mono_aot_get_array_helper_from_wrapper (method);
        code = mono_aot_get_method (domain, m);
        if (code != 0B) goto <D.26907>; else goto <D.26908>;
        <D.26907>:
        D.26909 = mono_method_needs_static_rgctx_invoke (m, 0);
        if (D.26909 != 0) goto <D.26910>; else goto <D.26911>;
        <D.26910>:
        D.26912 = mono_create_ftnptr (domain, code);
        code = mono_create_static_rgctx_trampoline (m, D.26912);
        code = mono_get_addr_from_ftnptr (code);
        <D.26911>:
        D.26833 = code;
        return D.26833;
        <D.26908>:
      }
      <D.26906>:
      <D.26902>:
      <D.26898>:
      <D.26896>:
      if (method_index == 16777215) goto <D.26913>; else goto <D.26914>;
      <D.26913>:
      D.26853 = BIT_FIELD_REF <*method, 64, 256>;
      D.26854 = D.26853 & 4467570830351532032;
      if (D.26854 == 864691128455135232) goto <D.26915>; else goto <D.26916>;
      <D.26915>:
      D.26899 = method->klass;
      D.26917 = mono_defaults.array_class;
      if (D.26899 == D.26917) goto <D.26918>; else goto <D.26919>;
      <D.26918>:
      D.26903 = method->name;
      D.26920 = strcmp (D.26903, "GetGenericValueImpl");
      if (D.26920 == 0) goto <D.26921>; else goto <D.26922>;
      <D.26921>:
      {
        struct MonoMethod * m;
        struct MonoGenericContext ctx;
        struct MonoType * args[16];

        try
          {
            D.26923 = mono_method_signature (method);
            D.26924 = D.26923->params[1];
            D.26925 = D.26924->type;
            if (D.26925 == 28) goto <D.26926>; else goto <D.26927>;
            <D.26926>:
            D.26833 = 0B;
            return D.26833;
            <D.26927>:
            D.26917 = mono_defaults.array_class;
            m = mono_class_get_method_from_name (D.26917, "GetGenericValueImpl", 2);
            D.26928 = m == 0B;
            D.26929 = (long int) D.26928;
            D.26930 = __builtin_expect (D.26929, 0);
            if (D.26930 != 0) goto <D.26931>; else goto <D.26932>;
            <D.26931>:
            monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "aot-runtime.c", 3670, "m");
            <D.26932>:
            memset (&ctx, 0, 16);
            D.26933 = mono_defaults.object_class;
            D.26934 = &D.26933->byval_arg;
            args[0] = D.26934;
            D.26935 = mono_metadata_get_generic_inst (1, &args);
            ctx.method_inst = D.26935;
            D.26936 = mono_class_inflate_generic_method (m, &ctx);
            m = mono_marshal_get_native_wrapper (D.26936, 1, 1);
            code = mono_aot_get_method (domain, m);
            if (code != 0B) goto <D.26937>; else goto <D.26938>;
            <D.26937>:
            D.26833 = code;
            return D.26833;
            <D.26938>:
          }
        finally
          {
            ctx = {CLOBBER};
            args = {CLOBBER};
          }
      }
      <D.26922>:
      <D.26919>:
      <D.26916>:
      <D.26914>:
      if (method_index == 16777215) goto <D.26944>; else goto <D.26945>;
      <D.26944>:
      D.26853 = BIT_FIELD_REF <*method, 64, 256>;
      D.26854 = D.26853 & 4467570830351532032;
      if (D.26854 == 864691128455135232) goto <D.26946>; else goto <D.26947>;
      <D.26946>:
      D.26899 = method->klass;
      D.26948 = D.26899->image;
      D.26949 = mono_defaults.corlib;
      if (D.26948 == D.26949) goto <D.26950>; else goto <D.26951>;
      <D.26950>:
      D.26899 = method->klass;
      D.26952 = D.26899->name_space;
      D.26953 = strcmp (D.26952, "System.Threading");
      if (D.26953 == 0) goto <D.26954>; else goto <D.26939>;
      <D.26954>:
      D.26899 = method->klass;
      D.26955 = D.26899->name;
      D.26956 = strcmp (D.26955, "Interlocked");
      if (D.26956 == 0) goto <D.26957>; else goto <D.26939>;
      <D.26957>:
      D.26903 = method->name;
      D.26958 = strcmp (D.26903, "CompareExchange");
      if (D.26958 == 0) goto <D.26940>; else goto <D.26959>;
      <D.26959>:
      D.26903 = method->name;
      D.26960 = strcmp (D.26903, "Exchange");
      if (D.26960 == 0) goto <D.26940>; else goto <D.26939>;
      <D.26940>:
      D.26961 = mono_method_signature (method);
      D.26962 = D.26961->params[1];
      D.26963 = mono_type_is_reference (D.26962);
      if (D.26963 != 0) goto <D.26941>; else goto <D.26939>;
      <D.26939>:
      D.26899 = method->klass;
      D.26952 = D.26899->name_space;
      D.26964 = strcmp (D.26952, "System.Threading");
      if (D.26964 == 0) goto <D.26965>; else goto <D.26942>;
      <D.26965>:
      D.26899 = method->klass;
      D.26955 = D.26899->name;
      D.26966 = strcmp (D.26955, "Volatile");
      if (D.26966 == 0) goto <D.26967>; else goto <D.26942>;
      <D.26967>:
      D.26903 = method->name;
      D.26968 = strcmp (D.26903, "Read");
      if (D.26968 == 0) goto <D.26969>; else goto <D.26942>;
      <D.26969>:
      D.26970 = mono_method_signature (method);
      D.26971 = D.26970->ret;
      D.26972 = mono_type_is_reference (D.26971);
      if (D.26972 != 0) goto <D.26941>; else goto <D.26942>;
      <D.26942>:
      D.26899 = method->klass;
      D.26952 = D.26899->name_space;
      D.26973 = strcmp (D.26952, "System.Threading");
      if (D.26973 == 0) goto <D.26974>; else goto <D.26943>;
      <D.26974>:
      D.26899 = method->klass;
      D.26955 = D.26899->name;
      D.26975 = strcmp (D.26955, "Volatile");
      if (D.26975 == 0) goto <D.26976>; else goto <D.26943>;
      <D.26976>:
      D.26903 = method->name;
      D.26977 = strcmp (D.26903, "Write");
      if (D.26977 == 0) goto <D.26978>; else goto <D.26943>;
      <D.26978>:
      D.26979 = mono_method_signature (method);
      D.26980 = D.26979->params[1];
      D.26981 = mono_type_is_reference (D.26980);
      if (D.26981 != 0) goto <D.26941>; else goto <D.26943>;
      <D.26941>:
      {
        struct MonoMethod * m;
        struct MonoGenericContext ctx;
        struct MonoType * args[16];
        void * iter;

        try
          {
            iter = 0B;
            goto <D.24298>;
            <D.24297>:
            D.26982 = mono_method_signature (m);
            D.26983 = D.26982->generic_param_count;
            if (D.26983 != 0) goto <D.26984>; else goto <D.26985>;
            <D.26984>:
            D.26986 = m->name;
            D.26903 = method->name;
            D.26987 = strcmp (D.26986, D.26903);
            if (D.26987 == 0) goto <D.24296>; else goto <D.26988>;
            <D.26988>:
            <D.26985>:
            <D.24298>:
            D.26899 = method->klass;
            m = mono_class_get_methods (D.26899, &iter);
            if (m != 0B) goto <D.24297>; else goto <D.24296>;
            <D.24296>:
            D.26989 = m == 0B;
            D.26990 = (long int) D.26989;
            D.26991 = __builtin_expect (D.26990, 0);
            if (D.26991 != 0) goto <D.26992>; else goto <D.26993>;
            <D.26992>:
            monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "aot-runtime.c", 3702, "m");
            <D.26993>:
            memset (&ctx, 0, 16);
            D.26933 = mono_defaults.object_class;
            D.26934 = &D.26933->byval_arg;
            args[0] = D.26934;
            D.26994 = mono_metadata_get_generic_inst (1, &args);
            ctx.method_inst = D.26994;
            D.26995 = mono_class_inflate_generic_method (m, &ctx);
            m = mono_marshal_get_native_wrapper (D.26995, 1, 1);
            if (method == m) goto <D.26996>; else goto <D.26997>;
            <D.26996>:
            D.26833 = 0B;
            return D.26833;
            <D.26997>:
            code = mono_aot_get_method (domain, m);
            if (code != 0B) goto <D.26998>; else goto <D.26999>;
            <D.26998>:
            D.26833 = code;
            return D.26833;
            <D.26999>:
          }
        finally
          {
            ctx = {CLOBBER};
            args = {CLOBBER};
            iter = {CLOBBER};
          }
      }
      <D.26943>:
      <D.26951>:
      <D.26947>:
      <D.26945>:
      if (method_index == 16777215) goto <D.27000>; else goto <D.27001>;
      <D.27000>:
      D.26853 = BIT_FIELD_REF <*method, 64, 256>;
      D.26876 = D.26853 & 2251799813685248;
      if (D.26876 != 0) goto <D.27002>; else goto <D.27003>;
      <D.27002>:
      D.27004 = mono_method_is_generic_sharable_full (method, 0, 1, 0);
      if (D.27004 != 0) goto <D.27005>; else goto <D.27006>;
      <D.27005>:
      {
        struct MonoMethod * shared;

        shared = mini_get_shared_method (method);
        method_index = find_extra_method (shared, &amodule);
        if (method_index != 16777215) goto <D.27007>; else goto <D.27008>;
        <D.27007>:
        method = shared;
        <D.27008>:
      }
      <D.27006>:
      <D.27003>:
      <D.27001>:
      if (method_index == 16777215) goto <D.27009>; else goto <D.27010>;
      <D.27009>:
      D.26853 = BIT_FIELD_REF <*method, 64, 256>;
      D.26876 = D.26853 & 2251799813685248;
      if (D.26876 != 0) goto <D.27011>; else goto <D.27012>;
      <D.27011>:
      D.27013 = mono_method_is_generic_sharable_full (method, 0, 0, 1);
      if (D.27013 != 0) goto <D.27014>; else goto <D.27015>;
      <D.27014>:
      D.27016 = mini_get_shared_method_full (method, 1, 1);
      method_index = find_extra_method (D.27016, &amodule);
      if (method_index != 16777215) goto <D.27017>; else goto <D.27018>;
      <D.27017>:
      method = mini_get_shared_method_full (method, 1, 0);
      <D.27018>:
      <D.27015>:
      <D.27012>:
      <D.27010>:
      if (method_index == 16777215) goto <D.27019>; else goto <D.27020>;
      <D.27019>:
      mono_aot_only.110 = mono_aot_only;
      if (mono_aot_only.110 != 0) goto <D.27021>; else goto <D.27022>;
      <D.27021>:
      D.27023 = mono_trace_is_traced (128, 32);
      if (D.27023 != 0) goto <D.27024>; else goto <D.27025>;
      <D.27024>:
      {
        char * full_name;

        full_name = mono_method_full_name (method, 1);
        mono_trace (128, 32, "AOT NOT FOUND: %s.", full_name);
        monoeg_g_free (full_name);
      }
      <D.27025>:
      <D.27022>:
      D.26833 = 0B;
      return D.26833;
      <D.27020>:
      if (method_index == 16777215) goto <D.27026>; else goto <D.27027>;
      <D.27026>:
      D.26833 = 0B;
      return D.26833;
      <D.27027>:
      {
        int ret;

        ret = pthread_mutex_lock (&aot_mutex.mutex);
        if (ret != 0) goto <D.27028>; else goto <D.27029>;
        <D.27028>:
        monoeg_g_log (0B, 16, "Bad call to mono_mutex_lock result %d", ret);
        <D.27029>:
        D.27030 = ret != 0;
        D.27031 = (long int) D.27030;
        D.27032 = __builtin_expect (D.27031, 0);
        if (D.27032 != 0) goto <D.27033>; else goto <D.27034>;
        <D.27033>:
        monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "aot-runtime.c", 3756, "ret == 0");
        <D.27034>:
      }
      amodule.109 = amodule;
      D.27035 = amodule.109->extra_methods;
      if (D.27035 == 0B) goto <D.27036>; else goto <D.27037>;
      <D.27036>:
      amodule.109 = amodule;
      D.27038 = monoeg_g_hash_table_new (0B, 0B);
      amodule.109->extra_methods = D.27038;
      <D.27037>:
      amodule.109 = amodule;
      D.27035 = amodule.109->extra_methods;
      D.27039 = (long unsigned int) method_index;
      D.27040 = (void *) D.27039;
      monoeg_g_hash_table_insert_replace (D.27035, D.27040, method, 0);
      {
        int ret;

        ret = pthread_mutex_unlock (&aot_mutex.mutex);
        if (ret != 0) goto <D.27041>; else goto <D.27042>;
        <D.27041>:
        monoeg_g_log (0B, 16, "Bad call to mono_mutex_unlock result %d", ret);
        <D.27042>:
        D.27043 = ret != 0;
        D.27044 = (long int) D.27043;
        D.27045 = __builtin_expect (D.27044, 0);
        if (D.27045 != 0) goto <D.27046>; else goto <D.27047>;
        <D.27046>:
        monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "aot-runtime.c", 3760, "ret == 0");
        <D.27047>:
      }
      goto <D.26875>;
      <D.26874>:
      D.26871 = method->token;
      D.26872 = D.26871 & 16777215;
      method_index = D.26872 + 4294967295;
      <D.26875>:
      <D.26866>:
      amodule.109 = amodule;
      D.26828 = klass->image;
      D.26871 = method->token;
      method_index.111 = (int) method_index;
      D.26833 = load_method (domain, amodule.109, D.26828, method, D.26871, method_index.111);
      return D.26833;
    }
  finally
    {
      amodule = {CLOBBER};
    }
}


find_extra_method (struct MonoMethod * method, struct MonoAotModule * * out_amodule)
{
  struct MonoClass * D.27055;
  struct MonoImage * D.27056;
  void * D.27057;
  guint32 D.27060;
  _Bool D.27063;
  long int D.27064;
  long int D.27065;
  struct GHashTable * aot_modules.112;
  _Bool D.27071;
  long int D.27072;
  long int D.27073;
  void * * D.27076;
  long unsigned int D.27077;
  long unsigned int D.27078;
  void * * D.27079;
  unsigned int D.27084;
  unsigned int i.113;
  guint32 index;
  struct GPtrArray * modules;
  int i;

  D.27055 = method->klass;
  D.27056 = D.27055->image;
  D.27057 = D.27056->aot_module;
  *out_amodule = D.27057;
  D.27055 = method->klass;
  D.27056 = D.27055->image;
  D.27057 = D.27056->aot_module;
  index = find_extra_method_in_amodule (D.27057, method);
  if (index != 16777215) goto <D.27058>; else goto <D.27059>;
  <D.27058>:
  D.27060 = index;
  return D.27060;
  <D.27059>:
  modules = monoeg_g_ptr_array_new ();
  {
    int ret;

    ret = pthread_mutex_lock (&aot_mutex.mutex);
    if (ret != 0) goto <D.27061>; else goto <D.27062>;
    <D.27061>:
    monoeg_g_log (0B, 16, "Bad call to mono_mutex_lock result %d", ret);
    <D.27062>:
    D.27063 = ret != 0;
    D.27064 = (long int) D.27063;
    D.27065 = __builtin_expect (D.27064, 0);
    if (D.27065 != 0) goto <D.27066>; else goto <D.27067>;
    <D.27066>:
    monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "aot-runtime.c", 3559, "ret == 0");
    <D.27067>:
  }
  aot_modules.112 = aot_modules;
  monoeg_g_hash_table_foreach (aot_modules.112, add_module_cb, modules);
  {
    int ret;

    ret = pthread_mutex_unlock (&aot_mutex.mutex);
    if (ret != 0) goto <D.27069>; else goto <D.27070>;
    <D.27069>:
    monoeg_g_log (0B, 16, "Bad call to mono_mutex_unlock result %d", ret);
    <D.27070>:
    D.27071 = ret != 0;
    D.27072 = (long int) D.27071;
    D.27073 = __builtin_expect (D.27072, 0);
    if (D.27073 != 0) goto <D.27074>; else goto <D.27075>;
    <D.27074>:
    monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "aot-runtime.c", 3561, "ret == 0");
    <D.27075>:
  }
  index = 16777215;
  i = 0;
  goto <D.24277>;
  <D.24276>:
  {
    struct MonoAotModule * amodule;

    D.27076 = modules->pdata;
    D.27077 = (long unsigned int) i;
    D.27078 = D.27077 * 8;
    D.27079 = D.27076 + D.27078;
    amodule = *D.27079;
    D.27055 = method->klass;
    D.27056 = D.27055->image;
    D.27057 = D.27056->aot_module;
    if (D.27057 != amodule) goto <D.27080>; else goto <D.27081>;
    <D.27080>:
    index = find_extra_method_in_amodule (amodule, method);
    <D.27081>:
    if (index != 16777215) goto <D.27082>; else goto <D.27083>;
    <D.27082>:
    *out_amodule = amodule;
    goto <D.24275>;
    <D.27083>:
  }
  i = i + 1;
  <D.24277>:
  D.27084 = modules->len;
  i.113 = (unsigned int) i;
  if (D.27084 > i.113) goto <D.24276>; else goto <D.24275>;
  <D.24275>:
  monoeg_g_ptr_array_free (modules, 1);
  D.27060 = index;
  return D.27060;
}


add_module_cb (void * key, void * value, void * user_data)
{
  monoeg_g_ptr_array_add (user_data, value);
}


find_extra_method_in_amodule (struct MonoAotModule * amodule, struct MonoMethod * method)
{
  int D.27090;
  guint32 D.27091;
  guint32 * D.27092;
  unsigned int D.27093;
  unsigned int D.27094;
  long unsigned int D.27095;
  long unsigned int D.27096;
  unsigned int D.27097;
  unsigned int D.27100;
  long unsigned int D.27101;
  long unsigned int D.27102;
  guint32 * D.27103;
  guint8 * D.27104;
  sizetype D.27105;
  guint8 * p.114;
  _Bool D.27109;
  long int D.27110;
  long int D.27111;
  struct GHashTable * D.27114;
  struct GHashTable * D.27117;
  guint8 * p.115;
  _Bool D.27121;
  long int D.27122;
  long int D.27123;
  _Bool D.27132;
  long int D.27133;
  long int D.27134;
  _Bool D.27139;
  long int D.27140;
  long int D.27141;
  long unsigned int D.27148;
  long unsigned int D.27149;
  long unsigned int D.27154;
  long unsigned int D.27155;
  struct MonoMethod * D.27158;
  unsigned int n_extra_decodes.116;
  unsigned int n_extra_decodes.117;
  unsigned int D.27166;
  long unsigned int D.27167;
  long unsigned int D.27168;
  guint32 table_size;
  guint32 entry_size;
  guint32 hash;
  guint32 * table;
  guint32 * entry;
  guint32 index;
  static guint32 n_extra_decodes;

  if (amodule == 0B) goto <D.27087>; else goto <D.27089>;
  <D.27089>:
  D.27090 = amodule->out_of_date;
  if (D.27090 != 0) goto <D.27087>; else goto <D.27088>;
  <D.27087>:
  D.27091 = 16777215;
  return D.27091;
  <D.27088>:
  D.27092 = amodule->extra_method_table;
  table_size = *D.27092;
  D.27092 = amodule->extra_method_table;
  table = D.27092 + 4;
  entry_size = 3;
  D.27093 = mono_aot_method_hash (method);
  hash = D.27093 % table_size;
  D.27094 = hash * entry_size;
  D.27095 = (long unsigned int) D.27094;
  D.27096 = D.27095 * 4;
  entry = table + D.27096;
  D.27097 = *entry;
  if (D.27097 == 0) goto <D.27098>; else goto <D.27099>;
  <D.27098>:
  D.27091 = 16777215;
  return D.27091;
  <D.27099>:
  index = 16777215;
  <D.24259>:
  {
    guint32 key;
    guint32 value;
    guint32 next;
    struct MonoMethod * m;
    guint8 * p;
    guint8 * orig_p;

    try
      {
        key = *entry;
        value = MEM[(guint32 *)entry + 4B];
        D.27100 = entry_size + 4294967295;
        D.27101 = (long unsigned int) D.27100;
        D.27102 = D.27101 * 4;
        D.27103 = entry + D.27102;
        next = *D.27103;
        D.27104 = amodule->blob;
        D.27105 = (sizetype) key;
        p.114 = D.27104 + D.27105;
        p = p.114;
        orig_p = p;
        {
          int ret;

          ret = pthread_mutex_lock (&aot_mutex.mutex);
          if (ret != 0) goto <D.27107>; else goto <D.27108>;
          <D.27107>:
          monoeg_g_log (0B, 16, "Bad call to mono_mutex_lock result %d", ret);
          <D.27108>:
          D.27109 = ret != 0;
          D.27110 = (long int) D.27109;
          D.27111 = __builtin_expect (D.27110, 0);
          if (D.27111 != 0) goto <D.27112>; else goto <D.27113>;
          <D.27112>:
          monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "aot-runtime.c", 3479, "ret == 0");
          <D.27113>:
        }
        D.27114 = amodule->method_ref_to_method;
        if (D.27114 == 0B) goto <D.27115>; else goto <D.27116>;
        <D.27115>:
        D.27117 = monoeg_g_hash_table_new (0B, 0B);
        amodule->method_ref_to_method = D.27117;
        <D.27116>:
        D.27114 = amodule->method_ref_to_method;
        p.115 = p;
        m = monoeg_g_hash_table_lookup (D.27114, p.115);
        {
          int ret;

          ret = pthread_mutex_unlock (&aot_mutex.mutex);
          if (ret != 0) goto <D.27119>; else goto <D.27120>;
          <D.27119>:
          monoeg_g_log (0B, 16, "Bad call to mono_mutex_unlock result %d", ret);
          <D.27120>:
          D.27121 = ret != 0;
          D.27122 = (long int) D.27121;
          D.27123 = __builtin_expect (D.27122, 0);
          if (D.27123 != 0) goto <D.27124>; else goto <D.27125>;
          <D.27124>:
          monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "aot-runtime.c", 3483, "ret == 0");
          <D.27125>:
        }
        if (m == 0B) goto <D.27126>; else goto <D.27127>;
        <D.27126>:
        p.115 = p;
        m = decode_resolve_method_ref_with_target (amodule, method, p.115, &p);
        if (m != 0B) goto <D.27128>; else goto <D.27129>;
        <D.27128>:
        {
          int ret;

          ret = pthread_mutex_lock (&aot_mutex.mutex);
          if (ret != 0) goto <D.27130>; else goto <D.27131>;
          <D.27130>:
          monoeg_g_log (0B, 16, "Bad call to mono_mutex_lock result %d", ret);
          <D.27131>:
          D.27132 = ret != 0;
          D.27133 = (long int) D.27132;
          D.27134 = __builtin_expect (D.27133, 0);
          if (D.27134 != 0) goto <D.27135>; else goto <D.27136>;
          <D.27135>:
          monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "aot-runtime.c", 3487, "ret == 0");
          <D.27136>:
        }
        D.27114 = amodule->method_ref_to_method;
        monoeg_g_hash_table_insert_replace (D.27114, orig_p, m, 0);
        {
          int ret;

          ret = pthread_mutex_unlock (&aot_mutex.mutex);
          if (ret != 0) goto <D.27137>; else goto <D.27138>;
          <D.27137>:
          monoeg_g_log (0B, 16, "Bad call to mono_mutex_unlock result %d", ret);
          <D.27138>:
          D.27139 = ret != 0;
          D.27140 = (long int) D.27139;
          D.27141 = __builtin_expect (D.27140, 0);
          if (D.27141 != 0) goto <D.27142>; else goto <D.27143>;
          <D.27142>:
          monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "aot-runtime.c", 3489, "ret == 0");
          <D.27143>:
        }
        <D.27129>:
        <D.27127>:
        if (m == method) goto <D.27144>; else goto <D.27145>;
        <D.27144>:
        index = value;
        goto <D.24256>;
        <D.27145>:
        if (m != 0B) goto <D.27146>; else goto <D.27147>;
        <D.27146>:
        D.27148 = BIT_FIELD_REF <*method, 64, 256>;
        D.27149 = D.27148 & 4467570830351532032;
        if (D.27149 != 0) goto <D.27150>; else goto <D.27151>;
        <D.27150>:
        D.27148 = BIT_FIELD_REF <*method, 64, 256>;
        D.27149 = D.27148 & 4467570830351532032;
        if (D.27149 == 2305843009213693952) goto <D.27152>; else goto <D.27153>;
        <D.27152>:
        {
          struct MonoMethod * w1;
          struct MonoMethod * w2;

          w1 = mono_marshal_method_from_wrapper (method);
          w2 = mono_marshal_method_from_wrapper (m);
          D.27154 = BIT_FIELD_REF <*w1, 64, 256>;
          D.27155 = D.27154 & 2251799813685248;
          if (D.27155 != 0) goto <D.27156>; else goto <D.27157>;
          <D.27156>:
          D.27158 = MEM[(struct MonoMethodInflated *)w1].declaring;
          if (D.27158 == w2) goto <D.27159>; else goto <D.27160>;
          <D.27159>:
          index = value;
          goto <D.24256>;
          <D.27160>:
          <D.27157>:
        }
        <D.27153>:
        <D.27151>:
        <D.27147>:
        if (m != 0B) goto <D.27161>; else goto <D.27162>;
        <D.27161>:
        n_extra_decodes.116 = n_extra_decodes;
        n_extra_decodes.117 = n_extra_decodes.116 + 1;
        n_extra_decodes = n_extra_decodes.117;
        <D.27162>:
        if (next != 0) goto <D.27165>; else goto <D.24256>;
        <D.27165>:
        D.27166 = next * entry_size;
        D.27167 = (long unsigned int) D.27166;
        D.27168 = D.27167 * 4;
        entry = table + D.27168;
      }
    finally
      {
        p = {CLOBBER};
      }
  }
  goto <D.24259>;
  <D.24256>:
  D.27091 = index;
  return D.27091;
}


load_method (struct MonoDomain * domain, struct MonoAotModule * amodule, struct MonoImage * image, struct MonoMethod * method, guint32 token, int method_index)
{
  _Bool D.27172;
  <unnamed type> D.27173;
  unsigned int D.27174;
  void * D.27177;
  struct MonoDomain * D.27178;
  unsigned int D.27181;
  unsigned int D.27182;
  int D.27185;
  gint32 * D.27188;
  long unsigned int D.27189;
  long unsigned int D.27190;
  gint32 * D.27191;
  int D.27192;
  int D.27195;
  guint8 * D.27200;
  sizetype D.27201;
  guint8 * D.27202;
  guint32 * D.27203;
  unsigned int D.27204;
  sizetype D.27205;
  guint8 * D.27206;
  unsigned int D.27211;
  unsigned int D.27212;
  int D.27215;
  _Bool D.27216;
  long int D.27217;
  long int D.27218;
  sizetype D.27221;
  _Bool D.27224;
  long int D.27225;
  long int D.27226;
  guint32 * D.27229;
  unsigned int D.27232;
  unsigned int D.27233;
  unsigned int D.27234;
  long unsigned int D.27235;
  long unsigned int D.27236;
  void * D.27237;
  _Bool D.27240;
  long int D.27241;
  long int D.27242;
  int D.27245;
  long unsigned int D.27246;
  long unsigned int D.27247;
  guint32 * D.27248;
  unsigned int D.27249;
  int D.27250;
  unsigned int D.27251;
  unsigned int D.27252;
  int mono_last_aot_method.118;
  int D.27258;
  int D.27261;
  guint8 * p.119;
  int D.27276;
  struct MonoDomain * D.27277;
  unsigned int D.27278;
  long unsigned int D.27287;
  long unsigned int D.27288;
  void * * D.27289;
  guint32 * got_slots.120;
  long unsigned int D.27291;
  guint32 * D.27292;
  unsigned int D.27293;
  long unsigned int D.27294;
  long unsigned int D.27295;
  void * * D.27296;
  void * D.27297;
  void * D.27300;
  <unnamed type> D.27301;
  void * D.27304;
  struct MonoMethod * D.27307;
  struct MonoDebugOptions * D.27310;
  int D.27311;
  struct MonoAssembly * D.27314;
  struct MonoImage * D.27315;
  int D.27316;
  int D.27323;
  sizetype D.27324;
  guint8 * D.27325;
  _Bool D.27328;
  long int D.27329;
  long int D.27330;
  int D.27333;
  long unsigned int D.27334;
  long unsigned int D.27335;
  guint32 * D.27336;
  unsigned int D.27337;
  int D.27338;
  unsigned int D.27339;
  unsigned int D.27340;
  long unsigned int D.27343;
  long unsigned int D.27344;
  struct GHashTable * D.27347;
  _Bool D.27350;
  long int D.27351;
  long int D.27352;
  <unnamed type> D.27355;
  unsigned int D.27356;
  long int D.27361;
  long int D.27362;
  _Bool D.27365;
  long int D.27366;
  long int D.27367;
  struct MonoGenericContainer * D.27374;
  struct MonoVTable * D.27377;
  struct MonoClass * klass;
  gboolean from_plt;
  struct MonoMemPool * mp;
  int i;
  int pindex;
  int n_patches;
  int used_strings;
  gboolean keep_patches;
  guint8 * p;
  struct MonoJitInfo * jinfo;
  guint8 * code;
  guint8 * info;
  void cleanup = <<< error >>>;

  try
    {
      D.27172 = method == 0B;
      from_plt = (gboolean) D.27172;
      keep_patches = 1;
      jinfo = 0B;
      D.27173 = mono_profiler_get_events ();
      D.27174 = D.27173 & 4096;
      if (D.27174 != 0) goto <D.27175>; else goto <D.27176>;
      <D.27175>:
      D.27177 = 0B;
      return D.27177;
      <D.27176>:
      D.27178 = mono_get_root_domain ();
      if (D.27178 != domain) goto <D.27179>; else goto <D.27180>;
      <D.27179>:
      D.27181 = amodule->info.opts;
      D.27182 = D.27181 & 512;
      if (D.27182 == 0) goto <D.27183>; else goto <D.27184>;
      <D.27183>:
      D.27177 = 0B;
      return D.27177;
      <D.27184>:
      <D.27180>:
      D.27185 = amodule->out_of_date;
      if (D.27185 != 0) goto <D.27186>; else goto <D.27187>;
      <D.27186>:
      D.27177 = 0B;
      return D.27177;
      <D.27187>:
      D.27188 = amodule->code_offsets;
      D.27189 = (long unsigned int) method_index;
      D.27190 = D.27189 * 4;
      D.27191 = D.27188 + D.27190;
      D.27192 = *D.27191;
      if (D.27192 == -1) goto <D.27193>; else goto <D.27194>;
      <D.27193>:
      D.27195 = mono_trace_is_traced (128, 32);
      if (D.27195 != 0) goto <D.27196>; else goto <D.27197>;
      <D.27196>:
      {
        char * full_name;

        if (method == 0B) goto <D.27198>; else goto <D.27199>;
        <D.27198>:
        method = mono_get_method (image, token, 0B);
        <D.27199>:
        full_name = mono_method_full_name (method, 1);
        mono_trace (128, 32, "AOT NOT FOUND: %s.", full_name);
        monoeg_g_free (full_name);
      }
      <D.27197>:
      D.27177 = 0B;
      return D.27177;
      <D.27194>:
      D.27200 = amodule->code;
      D.27188 = amodule->code_offsets;
      D.27189 = (long unsigned int) method_index;
      D.27190 = D.27189 * 4;
      D.27191 = D.27188 + D.27190;
      D.27192 = *D.27191;
      D.27201 = (sizetype) D.27192;
      code = D.27200 + D.27201;
      D.27202 = amodule->blob;
      D.27203 = amodule->method_info_offsets;
      D.27204 = mono_aot_get_offset (D.27203, method_index);
      D.27205 = (sizetype) D.27204;
      info = D.27202 + D.27205;
      D.27206 = amodule->thumb_end;
      if (D.27206 != 0B) goto <D.27207>; else goto <D.27208>;
      <D.27207>:
      D.27206 = amodule->thumb_end;
      if (D.27206 > code) goto <D.27209>; else goto <D.27210>;
      <D.27209>:
      D.27211 = amodule->info.flags;
      D.27212 = D.27211 & 8;
      if (D.27212 == 0) goto <D.27213>; else goto <D.27214>;
      <D.27213>:
      D.27188 = amodule->code_offsets;
      D.27189 = (long unsigned int) method_index;
      D.27190 = D.27189 * 4;
      D.27191 = D.27188 + D.27190;
      D.27192 = *D.27191;
      D.27215 = D.27192 & 1;
      D.27216 = D.27215 != 0;
      D.27217 = (long int) D.27216;
      D.27218 = __builtin_expect (D.27217, 0);
      if (D.27218 != 0) goto <D.27219>; else goto <D.27220>;
      <D.27219>:
      monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "aot-runtime.c", 3299, "(amodule->code_offsets [method_index] & 0x1) == 0");
      <D.27220>:
      D.27200 = amodule->code;
      D.27188 = amodule->code_offsets;
      D.27189 = (long unsigned int) method_index;
      D.27190 = D.27189 * 4;
      D.27191 = D.27188 + D.27190;
      D.27192 = *D.27191;
      D.27201 = (sizetype) D.27192;
      D.27221 = D.27201 + 1;
      code = D.27200 + D.27221;
      <D.27214>:
      <D.27210>:
      <D.27208>:
      {
        int ret;

        ret = pthread_mutex_lock (&aot_mutex.mutex);
        if (ret != 0) goto <D.27222>; else goto <D.27223>;
        <D.27222>:
        monoeg_g_log (0B, 16, "Bad call to mono_mutex_lock result %d", ret);
        <D.27223>:
        D.27224 = ret != 0;
        D.27225 = (long int) D.27224;
        D.27226 = __builtin_expect (D.27225, 0);
        if (D.27226 != 0) goto <D.27227>; else goto <D.27228>;
        <D.27227>:
        monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "aot-runtime.c", 3303, "ret == 0");
        <D.27228>:
      }
      D.27229 = amodule->methods_loaded;
      if (D.27229 == 0B) goto <D.27230>; else goto <D.27231>;
      <D.27230>:
      D.27232 = amodule->info.nmethods;
      D.27233 = D.27232 / 32;
      D.27234 = D.27233 + 1;
      D.27235 = (long unsigned int) D.27234;
      D.27236 = D.27235 * 4;
      D.27237 = monoeg_malloc0 (D.27236);
      amodule->methods_loaded = D.27237;
      <D.27231>:
      {
        int ret;

        ret = pthread_mutex_unlock (&aot_mutex.mutex);
        if (ret != 0) goto <D.27238>; else goto <D.27239>;
        <D.27238>:
        monoeg_g_log (0B, 16, "Bad call to mono_mutex_unlock result %d", ret);
        <D.27239>:
        D.27240 = ret != 0;
        D.27241 = (long int) D.27240;
        D.27242 = __builtin_expect (D.27241, 0);
        if (D.27242 != 0) goto <D.27243>; else goto <D.27244>;
        <D.27243>:
        monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "aot-runtime.c", 3306, "ret == 0");
        <D.27244>:
      }
      D.27229 = amodule->methods_loaded;
      D.27245 = method_index / 32;
      D.27246 = (long unsigned int) D.27245;
      D.27247 = D.27246 * 4;
      D.27248 = D.27229 + D.27247;
      D.27249 = *D.27248;
      D.27250 = method_index % 32;
      D.27251 = D.27249 >> D.27250;
      D.27252 = D.27251 & 1;
      if (D.27252 != 0) goto <D.27253>; else goto <D.27254>;
      <D.27253>:
      D.27177 = code;
      return D.27177;
      <D.27254>:
      mono_last_aot_method.118 = mono_last_aot_method;
      if (mono_last_aot_method.118 != -1) goto <D.27256>; else goto <D.27257>;
      <D.27256>:
      D.27258 = mono_jit_stats.methods_aot;
      mono_last_aot_method.118 = mono_last_aot_method;
      if (D.27258 >= mono_last_aot_method.118) goto <D.27259>; else goto <D.27260>;
      <D.27259>:
      D.27177 = 0B;
      return D.27177;
      <D.27260>:
      D.27258 = mono_jit_stats.methods_aot;
      mono_last_aot_method.118 = mono_last_aot_method;
      D.27261 = mono_last_aot_method.118 + -1;
      if (D.27258 == D.27261) goto <D.27262>; else goto <D.27263>;
      <D.27262>:
      if (method == 0B) goto <D.27264>; else goto <D.27265>;
      <D.27264>:
      method = mono_get_method (image, token, 0B);
      <D.27265>:
      if (method != 0B) goto <D.27266>; else goto <D.27267>;
      <D.27266>:
      {
        char * name;

        name = mono_method_full_name (method, 1);
        printf ("LAST AOT METHOD: %s.\n", name);
        monoeg_g_free (name);
      }
      goto <D.27268>;
      <D.27267>:
      printf ("LAST AOT METHOD: %p %d\n", code, method_index);
      <D.27268>:
      <D.27263>:
      <D.27257>:
      p = info;
      if (method != 0B) goto <D.27269>; else goto <D.27270>;
      <D.27269>:
      klass = method->klass;
      p.119 = p;
      decode_klass_ref (amodule, p.119, &p);
      goto <D.27272>;
      <D.27270>:
      p.119 = p;
      klass = decode_klass_ref (amodule, p.119, &p);
      <D.27272>:
      D.27181 = amodule->info.opts;
      D.27182 = D.27181 & 512;
      if (D.27182 != 0) goto <D.27273>; else goto <D.27274>;
      <D.27273>:
      p.119 = p;
      used_strings = decode_value (p.119, &p);
      goto <D.27275>;
      <D.27274>:
      used_strings = 0;
      <D.27275>:
      i = 0;
      goto <D.24222>;
      <D.24221>:
      {
        guint token;

        p.119 = p;
        D.27276 = decode_value (p.119, &p);
        token = (guint) D.27276;
        D.27277 = mono_get_root_domain ();
        D.27278 = token & 16777215;
        mono_ldstr (D.27277, image, D.27278);
      }
      i = i + 1;
      <D.24222>:
      if (i < used_strings) goto <D.24221>; else goto <D.24223>;
      <D.24223>:
      D.27181 = amodule->info.opts;
      D.27182 = D.27181 & 512;
      if (D.27182 != 0) goto <D.27279>; else goto <D.27280>;
      <D.27279>:
      keep_patches = 0;
      <D.27280>:
      p.119 = p;
      n_patches = decode_value (p.119, &p);
      keep_patches = 0;
      if (n_patches != 0) goto <D.27281>; else goto <D.27282>;
      <D.27281>:
      {
        struct MonoJumpInfo * patches;
        guint32 * got_slots;

        try
          {
            if (keep_patches != 0) goto <D.27283>; else goto <D.27284>;
            <D.27283>:
            mp = domain->mp;
            goto <D.27285>;
            <D.27284>:
            mp = mono_mempool_new ();
            <D.27285>:
            p.119 = p;
            patches = load_patch_info (amodule, mp, n_patches, &got_slots, p.119, &p);
            if (patches == 0B) goto cleanup; else goto <D.27286>;
            <D.27286>:
            pindex = 0;
            goto <D.24229>;
            <D.24228>:
            {
              struct MonoJumpInfo * ji;

              D.27287 = (long unsigned int) pindex;
              D.27288 = D.27287 * 40;
              ji = patches + D.27288;
              D.27289 = amodule->got;
              got_slots.120 = got_slots;
              D.27287 = (long unsigned int) pindex;
              D.27291 = D.27287 * 4;
              D.27292 = got_slots.120 + D.27291;
              D.27293 = *D.27292;
              D.27294 = (long unsigned int) D.27293;
              D.27295 = D.27294 * 8;
              D.27296 = D.27289 + D.27295;
              D.27297 = *D.27296;
              if (D.27297 == 0B) goto <D.27298>; else goto <D.27299>;
              <D.27298>:
              D.27289 = amodule->got;
              got_slots.120 = got_slots;
              D.27287 = (long unsigned int) pindex;
              D.27291 = D.27287 * 4;
              D.27292 = got_slots.120 + D.27291;
              D.27293 = *D.27292;
              D.27294 = (long unsigned int) D.27293;
              D.27295 = D.27294 * 8;
              D.27296 = D.27289 + D.27295;
              D.27300 = mono_resolve_patch_target (method, domain, code, ji, 1);
              *D.27296 = D.27300;
              D.27301 = ji->type;
              if (D.27301 == 4) goto <D.27302>; else goto <D.27303>;
              <D.27302>:
              D.27289 = amodule->got;
              got_slots.120 = got_slots;
              D.27287 = (long unsigned int) pindex;
              D.27291 = D.27287 * 4;
              D.27292 = got_slots.120 + D.27291;
              D.27293 = *D.27292;
              D.27294 = (long unsigned int) D.27293;
              D.27295 = D.27294 * 8;
              D.27296 = D.27289 + D.27295;
              D.27289 = amodule->got;
              got_slots.120 = got_slots;
              D.27287 = (long unsigned int) pindex;
              D.27291 = D.27287 * 4;
              D.27292 = got_slots.120 + D.27291;
              D.27293 = *D.27292;
              D.27294 = (long unsigned int) D.27293;
              D.27295 = D.27294 * 8;
              D.27296 = D.27289 + D.27295;
              D.27297 = *D.27296;
              D.27304 = mono_create_ftnptr (domain, D.27297);
              *D.27296 = D.27304;
              <D.27303>:
              D.27301 = ji->type;
              if (D.27301 == 4) goto <D.27305>; else goto <D.27306>;
              <D.27305>:
              D.27307 = ji->data.method;
              D.27289 = amodule->got;
              got_slots.120 = got_slots;
              D.27287 = (long unsigned int) pindex;
              D.27291 = D.27287 * 4;
              D.27292 = got_slots.120 + D.27291;
              D.27293 = *D.27292;
              D.27294 = (long unsigned int) D.27293;
              D.27295 = D.27294 * 8;
              D.27296 = D.27289 + D.27295;
              register_jump_target_got_slot (domain, D.27307, D.27296);
              <D.27306>:
              <D.27299>:
              ji->type = 51;
            }
            pindex = pindex + 1;
            <D.24229>:
            if (pindex < n_patches) goto <D.24228>; else goto <D.24230>;
            <D.24230>:
            got_slots.120 = got_slots;
            monoeg_g_free (got_slots.120);
            if (keep_patches == 0) goto <D.27308>; else goto <D.27309>;
            <D.27308>:
            mono_mempool_destroy (mp);
            <D.27309>:
          }
        finally
          {
            got_slots = {CLOBBER};
          }
      }
      <D.27282>:
      D.27310 = mini_get_debug_options ();
      D.27311 = D.27310->load_aot_jit_info_eagerly;
      if (D.27311 != 0) goto <D.27312>; else goto <D.27313>;
      <D.27312>:
      D.27314 = amodule->assembly;
      D.27315 = D.27314->image;
      jinfo = mono_aot_find_jit_info (domain, D.27315, code);
      <D.27313>:
      D.27316 = mono_trace_is_traced (128, 32);
      if (D.27316 != 0) goto <D.27317>; else goto <D.27318>;
      <D.27317>:
      {
        char * full_name;

        if (method == 0B) goto <D.27319>; else goto <D.27320>;
        <D.27319>:
        method = mono_get_method (image, token, 0B);
        <D.27320>:
        full_name = mono_method_full_name (method, 1);
        if (jinfo == 0B) goto <D.27321>; else goto <D.27322>;
        <D.27321>:
        D.27314 = amodule->assembly;
        D.27315 = D.27314->image;
        jinfo = mono_aot_find_jit_info (domain, D.27315, code);
        <D.27322>:
        D.27323 = jinfo->code_size;
        D.27324 = (sizetype) D.27323;
        D.27325 = code + D.27324;
        mono_trace (128, 32, "AOT FOUND method %s [%p - %p %p]", full_name, code, D.27325, info);
        monoeg_g_free (full_name);
      }
      <D.27318>:
      {
        int ret;

        ret = pthread_mutex_lock (&aot_mutex.mutex);
        if (ret != 0) goto <D.27326>; else goto <D.27327>;
        <D.27326>:
        monoeg_g_log (0B, 16, "Bad call to mono_mutex_lock result %d", ret);
        <D.27327>:
        D.27328 = ret != 0;
        D.27329 = (long int) D.27328;
        D.27330 = __builtin_expect (D.27329, 0);
        if (D.27330 != 0) goto <D.27331>; else goto <D.27332>;
        <D.27331>:
        monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "aot-runtime.c", 3403, "ret == 0");
        <D.27332>:
      }
      InterlockedIncrement (&mono_jit_stats.methods_aot);
      D.27229 = amodule->methods_loaded;
      D.27333 = method_index / 32;
      D.27334 = (long unsigned int) D.27333;
      D.27335 = D.27334 * 4;
      D.27336 = D.27229 + D.27335;
      D.27229 = amodule->methods_loaded;
      D.27334 = (long unsigned int) D.27333;
      D.27335 = D.27334 * 4;
      D.27336 = D.27229 + D.27335;
      D.27337 = *D.27336;
      D.27250 = method_index % 32;
      D.27338 = 1 << D.27250;
      D.27339 = (unsigned int) D.27338;
      D.27340 = D.27337 | D.27339;
      *D.27336 = D.27340;
      init_plt (amodule);
      if (method != 0B) goto <D.27341>; else goto <D.27342>;
      <D.27341>:
      D.27343 = BIT_FIELD_REF <*method, 64, 256>;
      D.27344 = D.27343 & 4467570830351532032;
      if (D.27344 != 0) goto <D.27345>; else goto <D.27346>;
      <D.27345>:
      D.27347 = amodule->method_to_code;
      monoeg_g_hash_table_insert_replace (D.27347, method, code, 0);
      <D.27346>:
      <D.27342>:
      {
        int ret;

        ret = pthread_mutex_unlock (&aot_mutex.mutex);
        if (ret != 0) goto <D.27348>; else goto <D.27349>;
        <D.27348>:
        monoeg_g_log (0B, 16, "Bad call to mono_mutex_unlock result %d", ret);
        <D.27349>:
        D.27350 = ret != 0;
        D.27351 = (long int) D.27350;
        D.27352 = __builtin_expect (D.27351, 0);
        if (D.27352 != 0) goto <D.27353>; else goto <D.27354>;
        <D.27353>:
        monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "aot-runtime.c", 3414, "ret == 0");
        <D.27354>:
      }
      D.27355 = mono_profiler_get_events ();
      D.27356 = D.27355 & 16;
      if (D.27356 != 0) goto <D.27357>; else goto <D.27358>;
      <D.27357>:
      {
        struct MonoJitInfo * jinfo;

        if (method == 0B) goto <D.27359>; else goto <D.27360>;
        <D.27359>:
        method = mono_get_method (image, token, 0B);
        D.27172 = method == 0B;
        D.27361 = (long int) D.27172;
        D.27362 = __builtin_expect (D.27361, 0);
        if (D.27362 != 0) goto <D.27363>; else goto <D.27364>;
        <D.27363>:
        monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "aot-runtime.c", 3421, "method");
        <D.27364>:
        <D.27360>:
        mono_profiler_method_jit (method);
        jinfo = mono_jit_info_table_find (domain, code);
        D.27365 = jinfo == 0B;
        D.27366 = (long int) D.27365;
        D.27367 = __builtin_expect (D.27366, 0);
        if (D.27367 != 0) goto <D.27368>; else goto <D.27369>;
        <D.27368>:
        monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "aot-runtime.c", 3425, "jinfo");
        <D.27369>:
        mono_profiler_method_end_jit (method, jinfo, 0);
      }
      <D.27358>:
      if (from_plt != 0) goto <D.27370>; else goto <D.27371>;
      <D.27370>:
      if (klass != 0B) goto <D.27372>; else goto <D.27373>;
      <D.27372>:
      D.27374 = klass->generic_container;
      if (D.27374 == 0B) goto <D.27375>; else goto <D.27376>;
      <D.27375>:
      D.27377 = mono_class_vtable (domain, klass);
      mono_runtime_class_init (D.27377);
      <D.27376>:
      <D.27373>:
      <D.27371>:
      D.27177 = code;
      return D.27177;
      cleanup:
      D.27181 = amodule->info.opts;
      D.27182 = D.27181 & 512;
      if (D.27182 != 0) goto <D.27378>; else goto <D.27379>;
      <D.27378>:
      mono_mempool_destroy (mp);
      <D.27379>:
      if (jinfo != 0B) goto <D.27380>; else goto <D.27381>;
      <D.27380>:
      monoeg_g_free (jinfo);
      <D.27381>:
      D.27177 = 0B;
      return D.27177;
    }
  finally
    {
      p = {CLOBBER};
    }
}


__attribute__((__artificial__, __gnu_inline__, __always_inline__))
printf (const char * restrict __fmt)
{
  int D.27386;

  D.27386 = __printf_chk (1, __fmt, __builtin_va_arg_pack ());
  return D.27386;
}


load_patch_info (struct MonoAotModule * aot_module, struct MonoMemPool * mp, int n_patches, guint32 * * got_slots, guint8 * buf, guint8 * * endbuf)
{
  long unsigned int D.27388;
  unsigned int D.27389;
  unsigned int D.27390;
  long unsigned int D.27391;
  void * D.27392;
  long unsigned int D.27393;
  long unsigned int D.27394;
  guint8 * p.121;
  int D.27396;
  void * * D.27397;
  long unsigned int D.27398;
  long unsigned int D.27399;
  void * * D.27400;
  void * D.27401;
  guint8 * D.27405;
  guint32 * D.27406;
  int got_offset.122;
  unsigned int D.27408;
  sizetype D.27409;
  guint8 * shared_p.123;
  guint8 * shared_p.124;
  int D.27412;
  <unnamed type> D.27413;
  guint32 * D.27415;
  long unsigned int D.27416;
  guint32 * D.27417;
  struct MonoJumpInfo * D.27418;
  struct MonoJumpInfo * patches;
  int pindex;
  guint8 * p;
  void cleanup = <<< error >>>;

  try
    {
      p = buf;
      D.27388 = (long unsigned int) n_patches;
      D.27389 = (unsigned int) D.27388;
      D.27390 = D.27389 * 40;
      patches = mono_mempool_alloc0 (mp, D.27390);
      D.27388 = (long unsigned int) n_patches;
      D.27391 = D.27388 * 4;
      D.27392 = monoeg_malloc (D.27391);
      *got_slots = D.27392;
      pindex = 0;
      goto <D.24185>;
      <D.24184>:
      {
        struct MonoJumpInfo * ji;
        guint8 * shared_p;
        gboolean res;
        guint32 got_offset;

        try
          {
            D.27393 = (long unsigned int) pindex;
            D.27394 = D.27393 * 40;
            ji = patches + D.27394;
            p.121 = p;
            D.27396 = decode_value (p.121, &p);
            got_offset = (guint32) D.27396;
            D.27397 = aot_module->got;
            D.27398 = (long unsigned int) got_offset;
            D.27399 = D.27398 * 8;
            D.27400 = D.27397 + D.27399;
            D.27401 = *D.27400;
            if (D.27401 != 0B) goto <D.27402>; else goto <D.27403>;
            <D.27402>:
            goto <D.27404>;
            <D.27403>:
            D.27405 = aot_module->blob;
            D.27406 = aot_module->got_info_offsets;
            got_offset.122 = (int) got_offset;
            D.27408 = mono_aot_get_offset (D.27406, got_offset.122);
            D.27409 = (sizetype) D.27408;
            shared_p.123 = D.27405 + D.27409;
            shared_p = shared_p.123;
            shared_p.124 = shared_p;
            D.27412 = decode_value (shared_p.124, &shared_p);
            D.27413 = (<unnamed type>) D.27412;
            ji->type = D.27413;
            shared_p.124 = shared_p;
            res = decode_patch (aot_module, mp, ji, shared_p.124, &shared_p);
            if (res == 0) goto cleanup; else goto <D.27414>;
            <D.27414>:
            <D.27404>:
            D.27415 = *got_slots;
            D.27393 = (long unsigned int) pindex;
            D.27416 = D.27393 * 4;
            D.27417 = D.27415 + D.27416;
            *D.27417 = got_offset;
          }
        finally
          {
            shared_p = {CLOBBER};
          }
      }
      pindex = pindex + 1;
      <D.24185>:
      if (pindex < n_patches) goto <D.24184>; else goto <D.24186>;
      <D.24186>:
      p.121 = p;
      *endbuf = p.121;
      D.27418 = patches;
      return D.27418;
      cleanup:
      D.27415 = *got_slots;
      monoeg_g_free (D.27415);
      *got_slots = 0B;
      D.27418 = 0B;
      return D.27418;
    }
  finally
    {
      p = {CLOBBER};
    }
}


decode_patch (struct MonoAotModule * aot_module, struct MonoMemPool * mp, struct MonoJumpInfo * ji, guint8 * buf, guint8 * * endbuf)
{
  <unnamed type> D.27423;
  guint8 * p.125;
  struct MonoMethod * D.27428;
  int mono_aot_only.126;
  int D.27432;
  unsigned int D.27435;
  unsigned int D.27436;
  struct MonoDomain * D.27438;
  struct MonoImage * D.27439;
  void * D.27440;
  void * D.27441;
  struct MonoMethod * D.27445;
  struct MonoMethod * D.27446;
  _Bool D.27447;
  long int D.27448;
  long int D.27449;
  struct MonoClass * D.27452;
  int D.27453;
  unsigned int D.27454;
  sizetype D.27455;
  guint8 * p.127;
  struct MonoMethod * D.27457;
  struct MonoClass * D.27459;
  struct MonoClass * D.27460;
  struct MonoClass * D.27462;
  int D.27464;
  struct MonoImage * D.27465;
  struct MonoImage * D.27466;
  struct MonoClassField * D.27468;
  struct MonoClassField * D.27469;
  void * D.27471;
  struct MonoJumpInfoBBTable * D.27472;
  int D.27473;
  struct MonoDomain * D.27474;
  int D.27475;
  long unsigned int D.27476;
  unsigned int D.27477;
  unsigned int D.27478;
  long unsigned int D.27479;
  long unsigned int D.27480;
  void * * D.27481;
  int D.27482;
  long int D.27483;
  void * D.27484;
  struct MonoDomain * D.27485;
  void * D.27486;
  int D.27487;
  unsigned int val.128;
  const void * D.27489;
  guint32 * val.129;
  float D.27491;
  struct MonoDomain * D.27492;
  void * D.27493;
  int D.27494;
  unsigned int D.27495;
  int D.27496;
  unsigned int D.27497;
  unsigned int D.27498;
  long unsigned int D.27499;
  long unsigned int D.27500;
  unsigned int D.27501;
  long unsigned int D.27502;
  long unsigned int v.130;
  guint64 * v.131;
  double D.27505;
  int D.27506;
  int D.27508;
  int D.27509;
  unsigned int D.27510;
  struct MonoJumpInfoToken * D.27511;
  int D.27512;
  int D.27514;
  unsigned int D.27515;
  struct MonoJumpInfoToken * D.27516;
  struct MonoJumpInfoToken * D.27517;
  int D.27518;
  int D.27519;
  struct MonoGenericContext * D.27522;
  struct MonoClass * D.27524;
  const char * D.27526;
  int D.27527;
  long int D.27528;
  int D.27529;
  int D.27530;
  guint8 * D.27531;
  sizetype D.27532;
  guint8 * p2.132;
  guint8 * p2.133;
  struct MonoMethod * D.27535;
  unsigned int D.27536;
  _Bool D.27537;
  int D.27538;
  unsigned int D.27539;
  unsigned int D.27540;
  void * D.27541;
  struct MonoJumpInfo * D.27542;
  unsigned int D.27543;
  unsigned int D.27544;
  struct MonoMethod * D.27546;
  int D.27547;
  struct MonoMethodSignature * D.27548;
  int D.27549;
  long int D.27550;
  const void * D.27551;
  struct MonoMethodSignature * D.27552;
  struct MonoMethodSignature * D.27553;
  _Bool D.27554;
  long int D.27555;
  long int D.27556;
  struct MonoMethod * D.27559;
  struct MonoMethod * D.27560;
  _Bool D.27561;
  long int D.27562;
  long int D.27563;
  struct MonoMethod * D.27566;
  struct MonoMethod * D.27567;
  _Bool D.27568;
  long int D.27569;
  long int D.27570;
  struct GPtrArray * D.27573;
  int D.27574;
  <unnamed type> D.27575;
  <unnamed type> D.27576;
  <unnamed type> D.27577;
  struct MonoType * D.27579;
  struct MonoClassField * D.27580;
  void * D.27581;
  struct GPtrArray * D.27583;
  gboolean D.27584;
  guint8 * p;
  void * * table;
  struct MonoImage * image;
  int i;
  void cleanup = <<< error >>>;

  try
    {
      p = buf;
      D.27423 = ji->type;
      switch (D.27423) <default: <D.24167>, case 3: <D.24095>, case 4: <D.24096>, case 5: <D.24133>, case 6: <D.24107>, case 7: <D.24104>, case 8: <D.24117>, case 10: <D.24132>, case 11: <D.24109>, case 12: <D.24114>, case 13: <D.24115>, case 14: <D.24108>, case 15: <D.24112>, case 16: <D.24116>, case 17: <D.24126>, case 18: <D.24129>, case 19: <D.24130>, case 20: <D.24121>, case 21: <D.24123>, case 23: <D.24110>, case 24: <D.24111>, case 28: <D.24128>, case 29: <D.24127>, case 30: <D.24113>, case 31: <D.24097>, case 32: <D.24105>, case 33: <D.24134>, case 34: <D.24098>, case 35: <D.24141>, case 36: <D.24135>, case 37: <D.24136>, case 38: <D.24137>, case 40: <D.24147>, case 41: <D.24148>, case 42: <D.24138>, case 43: <D.24139>, case 44: <D.24150>, case 45: <D.24152>, case 46: <D.24154>, case 47: <D.24140>, case 48: <D.24151>, case 50: <D.24099>>
      <D.24095>:
      <D.24096>:
      <D.24097>:
      <D.24098>:
      <D.24099>:
      {
        struct MethodRef ref;
        gboolean res;

        try
          {
            p.125 = p;
            res = decode_method_ref (aot_module, &ref, p.125, &p);
            if (res == 0) goto cleanup; else goto <D.27425>;
            <D.27425>:
            D.27428 = ref.method;
            if (D.27428 == 0B) goto <D.27429>; else goto <D.27426>;
            <D.27429>:
            mono_aot_only.126 = mono_aot_only;
            if (mono_aot_only.126 == 0) goto <D.27431>; else goto <D.27426>;
            <D.27431>:
            D.27432 = ref.no_aot_trampoline;
            if (D.27432 == 0) goto <D.27433>; else goto <D.27426>;
            <D.27433>:
            D.27423 = ji->type;
            if (D.27423 == 3) goto <D.27434>; else goto <D.27426>;
            <D.27434>:
            D.27435 = ref.token;
            D.27436 = D.27435 >> 24;
            if (D.27436 == 6) goto <D.27437>; else goto <D.27426>;
            <D.27437>:
            D.27438 = mono_domain_get ();
            D.27439 = ref.image;
            D.27435 = ref.token;
            D.27440 = mono_create_jit_trampoline_from_token (D.27439, D.27435);
            D.27441 = mono_create_ftnptr (D.27438, D.27440);
            ji->data.target = D.27441;
            ji->type = 1;
            goto <D.27427>;
            <D.27426>:
            D.27428 = ref.method;
            if (D.27428 != 0B) goto <D.27442>; else goto <D.27443>;
            <D.27442>:
            D.27428 = ref.method;
            ji->data.method = D.27428;
            goto <D.27444>;
            <D.27443>:
            D.27439 = ref.image;
            D.27435 = ref.token;
            D.27445 = mono_get_method (D.27439, D.27435, 0B);
            ji->data.method = D.27445;
            <D.27444>:
            D.27446 = ji->data.method;
            D.27447 = D.27446 == 0B;
            D.27448 = (long int) D.27447;
            D.27449 = __builtin_expect (D.27448, 0);
            if (D.27449 != 0) goto <D.27450>; else goto <D.27451>;
            <D.27450>:
            monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "aot-runtime.c", 2969, "ji->data.method");
            <D.27451>:
            D.27446 = ji->data.method;
            D.27452 = D.27446->klass;
            mono_class_init (D.27452);
            <D.27427>:
            goto <D.24103>;
          }
        finally
          {
            ref = {CLOBBER};
          }
      }
      <D.24104>:
      <D.24105>:
      {
        guint32 len;

        p.125 = p;
        D.27453 = decode_value (p.125, &p);
        len = (guint32) D.27453;
        p.125 = p;
        ji->data.name = p.125;
        p.125 = p;
        D.27454 = len + 1;
        D.27455 = (sizetype) D.27454;
        p.127 = p.125 + D.27455;
        p = p.127;
        goto <D.24103>;
      }
      <D.24107>:
      p.125 = p;
      D.27457 = decode_resolve_method_ref (aot_module, p.125, &p);
      ji->data.method = D.27457;
      D.27446 = ji->data.method;
      if (D.27446 == 0B) goto cleanup; else goto <D.27458>;
      <D.27458>:
      goto <D.24103>;
      <D.24108>:
      <D.24109>:
      <D.24110>:
      <D.24111>:
      p.125 = p;
      D.27459 = decode_klass_ref (aot_module, p.125, &p);
      ji->data.klass = D.27459;
      D.27460 = ji->data.klass;
      if (D.27460 == 0B) goto cleanup; else goto <D.27461>;
      <D.27461>:
      goto <D.24103>;
      <D.24112>:
      <D.24113>:
      p.125 = p;
      D.27462 = decode_klass_ref (aot_module, p.125, &p);
      ji->data.klass = D.27462;
      D.27460 = ji->data.klass;
      if (D.27460 == 0B) goto cleanup; else goto <D.27463>;
      <D.27463>:
      goto <D.24103>;
      <D.24114>:
      p.125 = p;
      D.27464 = decode_value (p.125, &p);
      D.27465 = load_image (aot_module, D.27464, 1);
      ji->data.image = D.27465;
      D.27466 = ji->data.image;
      if (D.27466 == 0B) goto cleanup; else goto <D.27467>;
      <D.27467>:
      goto <D.24103>;
      <D.24115>:
      <D.24116>:
      p.125 = p;
      D.27468 = decode_field_info (aot_module, p.125, &p);
      ji->data.field = D.27468;
      D.27469 = ji->data.field;
      if (D.27469 == 0B) goto cleanup; else goto <D.27470>;
      <D.27470>:
      goto <D.24103>;
      <D.24117>:
      D.27471 = mono_mempool_alloc0 (mp, 16);
      ji->data.table = D.27471;
      D.27472 = ji->data.table;
      p.125 = p;
      D.27473 = decode_value (p.125, &p);
      D.27472->table_size = D.27473;
      D.27474 = mono_domain_get ();
      D.27472 = ji->data.table;
      D.27475 = D.27472->table_size;
      D.27476 = (long unsigned int) D.27475;
      D.27477 = (unsigned int) D.27476;
      D.27478 = D.27477 * 8;
      table = mono_domain_alloc (D.27474, D.27478);
      D.27472 = ji->data.table;
      D.27472->table = table;
      i = 0;
      goto <D.24119>;
      <D.24118>:
      D.27479 = (long unsigned int) i;
      D.27480 = D.27479 * 8;
      D.27481 = table + D.27480;
      p.125 = p;
      D.27482 = decode_value (p.125, &p);
      D.27483 = (long int) D.27482;
      D.27484 = (void *) D.27483;
      *D.27481 = D.27484;
      i = i + 1;
      <D.24119>:
      D.27472 = ji->data.table;
      D.27475 = D.27472->table_size;
      if (D.27475 > i) goto <D.24118>; else goto <D.24120>;
      <D.24120>:
      goto <D.24103>;
      <D.24121>:
      {
        guint32 val;

        try
          {
            D.27485 = mono_domain_get ();
            D.27486 = mono_domain_alloc0 (D.27485, 4);
            ji->data.target = D.27486;
            p.125 = p;
            D.27487 = decode_value (p.125, &p);
            val.128 = (unsigned int) D.27487;
            val = val.128;
            D.27489 = ji->data.target;
            val.129 = &val;
            D.27491 = MEM[(float *)val.129];
            MEM[(float *)D.27489] = D.27491;
            goto <D.24103>;
          }
        finally
          {
            val = {CLOBBER};
          }
      }
      <D.24123>:
      {
        guint32 val[2];
        guint64 v;

        try
          {
            D.27492 = mono_domain_get ();
            D.27493 = mono_domain_alloc0 (D.27492, 8);
            ji->data.target = D.27493;
            p.125 = p;
            D.27494 = decode_value (p.125, &p);
            D.27495 = (unsigned int) D.27494;
            val[0] = D.27495;
            p.125 = p;
            D.27496 = decode_value (p.125, &p);
            D.27497 = (unsigned int) D.27496;
            val[1] = D.27497;
            D.27498 = val[1];
            D.27499 = (long unsigned int) D.27498;
            D.27500 = D.27499 << 32;
            D.27501 = val[0];
            D.27502 = (long unsigned int) D.27501;
            v.130 = D.27500 | D.27502;
            v = v.130;
            D.27489 = ji->data.target;
            v.131 = &v;
            D.27505 = MEM[(double *)v.131];
            MEM[(double *)D.27489] = D.27505;
            goto <D.24103>;
          }
        finally
          {
            val = {CLOBBER};
            v = {CLOBBER};
          }
      }
      <D.24126>:
      p.125 = p;
      D.27506 = decode_value (p.125, &p);
      image = load_image (aot_module, D.27506, 1);
      if (image == 0B) goto cleanup; else goto <D.27507>;
      <D.27507>:
      p.125 = p;
      D.27508 = decode_value (p.125, &p);
      D.27509 = D.27508 + 1879048192;
      D.27510 = (unsigned int) D.27509;
      D.27511 = mono_jump_info_token_new (mp, image, D.27510);
      ji->data.token = D.27511;
      goto <D.24103>;
      <D.24127>:
      <D.24128>:
      <D.24129>:
      <D.24130>:
      p.125 = p;
      D.27512 = decode_value (p.125, &p);
      image = load_image (aot_module, D.27512, 1);
      if (image == 0B) goto cleanup; else goto <D.27513>;
      <D.27513>:
      p.125 = p;
      D.27514 = decode_value (p.125, &p);
      D.27515 = (unsigned int) D.27514;
      D.27516 = mono_jump_info_token_new (mp, image, D.27515);
      ji->data.token = D.27516;
      D.27517 = ji->data.token;
      p.125 = p;
      D.27518 = decode_value (p.125, &p);
      D.27517->has_context = D.27518;
      D.27517 = ji->data.token;
      D.27519 = D.27517->has_context;
      if (D.27519 != 0) goto <D.27520>; else goto <D.27521>;
      <D.27520>:
      {
        gboolean res;

        D.27517 = ji->data.token;
        D.27522 = &D.27517->context;
        p.125 = p;
        res = decode_generic_context (aot_module, D.27522, p.125, &p);
        if (res == 0) goto cleanup; else goto <D.27523>;
        <D.27523>:
      }
      <D.27521>:
      goto <D.24103>;
      <D.24132>:
      p.125 = p;
      D.27524 = decode_klass_ref (aot_module, p.125, &p);
      ji->data.klass = D.27524;
      D.27460 = ji->data.klass;
      if (D.27460 == 0B) goto cleanup; else goto <D.27525>;
      <D.27525>:
      D.27460 = ji->data.klass;
      D.27526 = D.27460->name;
      ji->data.name = D.27526;
      goto <D.24103>;
      <D.24133>:
      p.125 = p;
      D.27527 = decode_value (p.125, &p);
      D.27528 = (long int) D.27527;
      ji->data.offset = D.27528;
      goto <D.24103>;
      <D.24134>:
      <D.24135>:
      <D.24136>:
      <D.24137>:
      <D.24138>:
      <D.24139>:
      <D.24140>:
      goto <D.24103>;
      <D.24141>:
      {
        gboolean res;
        struct MonoJumpInfoRgctxEntry * entry;
        guint32 offset;
        guint32 val;
        guint8 * p2;

        try
          {
            p.125 = p;
            D.27529 = decode_value (p.125, &p);
            offset = (guint32) D.27529;
            p.125 = p;
            D.27530 = decode_value (p.125, &p);
            val = (guint32) D.27530;
            entry = mono_mempool_alloc0 (mp, 32);
            D.27531 = aot_module->blob;
            D.27532 = (sizetype) offset;
            p2.132 = D.27531 + D.27532;
            p2 = p2.132;
            p2.133 = p2;
            D.27535 = decode_resolve_method_ref (aot_module, p2.133, &p2);
            entry->method = D.27535;
            D.27536 = val & 1;
            D.27537 = D.27536 != 0;
            D.27538 = (int) D.27537;
            entry->in_mrgctx = D.27538;
            D.27539 = val >> 1;
            D.27540 = D.27539 & 255;
            entry->info_type = D.27540;
            D.27541 = mono_mempool_alloc0 (mp, 40);
            entry->data = D.27541;
            D.27542 = entry->data;
            D.27543 = val >> 9;
            D.27544 = D.27543 & 255;
            D.27542->type = D.27544;
            D.27542 = entry->data;
            p.125 = p;
            res = decode_patch (aot_module, mp, D.27542, p.125, &p);
            if (res == 0) goto cleanup; else goto <D.27545>;
            <D.27545>:
            ji->data.rgctx_entry = entry;
            goto <D.24103>;
          }
        finally
          {
            p2 = {CLOBBER};
          }
      }
      <D.24147>:
      goto <D.24103>;
      <D.24148>:
      {
        struct MonoJumpInfoImtTramp * imt_tramp;

        imt_tramp = mono_mempool_alloc0 (mp, 16);
        p.125 = p;
        D.27546 = decode_resolve_method_ref (aot_module, p.125, &p);
        imt_tramp->method = D.27546;
        p.125 = p;
        D.27547 = decode_value (p.125, &p);
        imt_tramp->vt_offset = D.27547;
        ji->data.imt_tramp = imt_tramp;
        goto <D.24103>;
      }
      <D.24150>:
      p.125 = p;
      D.27548 = decode_signature (aot_module, p.125, &p);
      ji->data.target = D.27548;
      goto <D.24103>;
      <D.24151>:
      p.125 = p;
      D.27549 = decode_value (p.125, &p);
      D.27550 = (long int) D.27549;
      D.27551 = (const void *) D.27550;
      ji->data.target = D.27551;
      goto <D.24103>;
      <D.24152>:
      {
        struct MonoJumpInfoGSharedVtCall * info;

        info = monoeg_malloc0 (16);
        p.125 = p;
        D.27552 = decode_signature (aot_module, p.125, &p);
        info->sig = D.27552;
        D.27553 = info->sig;
        D.27554 = D.27553 == 0B;
        D.27555 = (long int) D.27554;
        D.27556 = __builtin_expect (D.27555, 0);
        if (D.27556 != 0) goto <D.27557>; else goto <D.27558>;
        <D.27557>:
        monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "aot-runtime.c", 3126, "info->sig");
        <D.27558>:
        p.125 = p;
        D.27559 = decode_resolve_method_ref (aot_module, p.125, &p);
        info->method = D.27559;
        D.27560 = info->method;
        D.27561 = D.27560 == 0B;
        D.27562 = (long int) D.27561;
        D.27563 = __builtin_expect (D.27562, 0);
        if (D.27563 != 0) goto <D.27564>; else goto <D.27565>;
        <D.27564>:
        monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "aot-runtime.c", 3128, "info->method");
        <D.27565>:
        ji->data.target = info;
        goto <D.24103>;
      }
      <D.24154>:
      {
        struct MonoGSharedVtMethodInfo * info;
        int i;
        int nentries;

        info = monoeg_malloc0 (16);
        p.125 = p;
        D.27566 = decode_resolve_method_ref (aot_module, p.125, &p);
        info->method = D.27566;
        D.27567 = info->method;
        D.27568 = D.27567 == 0B;
        D.27569 = (long int) D.27568;
        D.27570 = __builtin_expect (D.27569, 0);
        if (D.27570 != 0) goto <D.27571>; else goto <D.27572>;
        <D.27571>:
        monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "aot-runtime.c", 3138, "info->method");
        <D.27572>:
        p.125 = p;
        nentries = decode_value (p.125, &p);
        D.27573 = monoeg_g_ptr_array_new ();
        info->entries = D.27573;
        i = 0;
        goto <D.24165>;
        <D.24164>:
        {
          struct MonoRuntimeGenericContextInfoTemplate * template;

          template = monoeg_malloc0 (24);
          p.125 = p;
          D.27574 = decode_value (p.125, &p);
          D.27575 = (<unnamed type>) D.27574;
          template->info_type = D.27575;
          D.27576 = template->info_type;
          D.27577 = mini_rgctx_info_type_to_patch_info_type (D.27576);
          switch (D.27577) <default: <D.24163>, case 11: <D.24159>, case 13: <D.24162>>
          <D.24159>:
          {
            struct MonoClass * klass;

            p.125 = p;
            klass = decode_klass_ref (aot_module, p.125, &p);
            if (klass == 0B) goto cleanup; else goto <D.27578>;
            <D.27578>:
            D.27579 = &klass->byval_arg;
            template->data = D.27579;
            goto <D.24161>;
          }
          <D.24162>:
          p.125 = p;
          D.27580 = decode_field_info (aot_module, p.125, &p);
          template->data = D.27580;
          D.27581 = template->data;
          if (D.27581 == 0B) goto cleanup; else goto <D.27582>;
          <D.27582>:
          goto <D.24161>;
          <D.24163>:
          monoeg_assertion_message ("* Assertion: should not be reached at %s:%d\n", "aot-runtime.c", 3159);
          <D.24161>:
          D.27583 = info->entries;
          monoeg_g_ptr_array_add (D.27583, template);
        }
        i = i + 1;
        <D.24165>:
        if (i < nentries) goto <D.24164>; else goto <D.24166>;
        <D.24166>:
        ji->data.target = info;
        goto <D.24103>;
      }
      <D.24167>:
      D.27423 = ji->type;
      monoeg_g_log (0B, 16, "unhandled type %d", D.27423);
      monoeg_assertion_message ("* Assertion: should not be reached at %s:%d\n", "aot-runtime.c", 3170);
      <D.24103>:
      p.125 = p;
      *endbuf = p.125;
      D.27584 = 1;
      return D.27584;
      cleanup:
      D.27584 = 0;
      return D.27584;
    }
  finally
    {
      p = {CLOBBER};
    }
}


decode_signature (struct MonoAotModule * module, guint8 * buf, guint8 * * endbuf)
{
  struct MonoMethodSignature * D.27594;

  D.27594 = decode_signature_with_target (module, 0B, buf, endbuf);
  return D.27594;
}


decode_field_info (struct MonoAotModule * module, guint8 * buf, guint8 * * endbuf)
{
  guint8 * buf.134;
  struct MonoClassField * D.27599;
  guint8 * p.135;
  int D.27601;
  int D.27602;
  struct MonoClass * klass;
  guint32 token;
  guint8 * p;

  try
    {
      buf.134 = buf;
      klass = decode_klass_ref (module, buf.134, &buf);
      buf.134 = buf;
      p = buf.134;
      if (klass == 0B) goto <D.27597>; else goto <D.27598>;
      <D.27597>:
      D.27599 = 0B;
      return D.27599;
      <D.27598>:
      p.135 = p;
      D.27601 = decode_value (p.135, &p);
      D.27602 = D.27601 + 67108864;
      token = (guint32) D.27602;
      p.135 = p;
      *endbuf = p.135;
      D.27599 = mono_class_get_field (klass, token);
      return D.27599;
    }
  finally
    {
      p = {CLOBBER};
    }
}


register_jump_target_got_slot (struct MonoDomain * domain, struct MonoMethod * method, void * * got_slot)
{
  union mono_mutex_t * D.27605;
  _Bool D.27608;
  long int D.27609;
  long int D.27610;
  struct GHashTable * D.27613;
  struct GHashTable * D.27616;
  _Bool D.27619;
  long int D.27620;
  long int D.27621;
  struct MonoJitDomainInfo * info;
  struct GSList * list;

  info = domain->runtime_info;
  {
    int ret;

    D.27605 = &domain->lock.mutex;
    ret = pthread_mutex_lock (D.27605);
    if (ret != 0) goto <D.27606>; else goto <D.27607>;
    <D.27606>:
    monoeg_g_log (0B, 16, "Bad call to mono_mutex_lock result %d", ret);
    <D.27607>:
    D.27608 = ret != 0;
    D.27609 = (long int) D.27608;
    D.27610 = __builtin_expect (D.27609, 0);
    if (D.27610 != 0) goto <D.27611>; else goto <D.27612>;
    <D.27611>:
    monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "aot-runtime.c", 3242, "ret == 0");
    <D.27612>:
  }
  D.27613 = info->jump_target_got_slot_hash;
  if (D.27613 == 0B) goto <D.27614>; else goto <D.27615>;
  <D.27614>:
  D.27616 = monoeg_g_hash_table_new (0B, 0B);
  info->jump_target_got_slot_hash = D.27616;
  <D.27615>:
  D.27613 = info->jump_target_got_slot_hash;
  list = monoeg_g_hash_table_lookup (D.27613, method);
  list = monoeg_g_slist_prepend (list, got_slot);
  D.27613 = info->jump_target_got_slot_hash;
  monoeg_g_hash_table_insert_replace (D.27613, method, list, 0);
  {
    int ret;

    D.27605 = &domain->lock.mutex;
    ret = pthread_mutex_unlock (D.27605);
    if (ret != 0) goto <D.27617>; else goto <D.27618>;
    <D.27617>:
    monoeg_g_log (0B, 16, "Bad call to mono_mutex_unlock result %d", ret);
    <D.27618>:
    D.27619 = ret != 0;
    D.27620 = (long int) D.27619;
    D.27621 = __builtin_expect (D.27620, 0);
    if (D.27621 != 0) goto <D.27622>; else goto <D.27623>;
    <D.27622>:
    monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "aot-runtime.c", 3248, "ret == 0");
    <D.27623>:
  }
}


InterlockedIncrement (volatile gint32 * val)
{
  gint32 D.27624;
  unsigned int D.27625;

  D.27625 = __sync_add_and_fetch_4 (val, 1);
  D.27624 = (gint32) D.27625;
  return D.27624;
}


init_plt (struct MonoAotModule * amodule)
{
  int D.27627;
  struct MonoDomain * D.27630;
  struct MonoDomain * D.27631;
  void * * D.27632;
  unsigned int D.27633;
  unsigned int i.136;
  unsigned int D.27635;
  long unsigned int D.27636;
  long unsigned int D.27637;
  void * * D.27638;
  unsigned int D.27639;
  int i;
  void * tramp;

  D.27627 = amodule->plt_inited;
  if (D.27627 != 0) goto <D.27628>; else goto <D.27629>;
  <D.27628>:
  return;
  <D.27629>:
  D.27630 = mono_get_root_domain ();
  tramp = mono_create_specific_trampoline (amodule, 6, D.27630, 0B);
  D.27631 = mono_domain_get ();
  tramp = mono_create_ftnptr (D.27631, tramp);
  i = 1;
  goto <D.24362>;
  <D.24361>:
  D.27632 = amodule->got;
  D.27633 = amodule->info.plt_got_offset_base;
  i.136 = (unsigned int) i;
  D.27635 = D.27633 + i.136;
  D.27636 = (long unsigned int) D.27635;
  D.27637 = D.27636 * 8;
  D.27638 = D.27632 + D.27637;
  *D.27638 = tramp;
  i = i + 1;
  <D.24362>:
  D.27639 = amodule->info.plt_size;
  i.136 = (unsigned int) i;
  if (D.27639 > i.136) goto <D.24361>; else goto <D.24363>;
  <D.24363>:
  amodule->plt_inited = 1;
}


__attribute__((visibility ("hidden")))
mono_aot_get_method_from_token (struct MonoDomain * domain, struct MonoImage * image, guint32 token)
{
  void * D.27643;
  unsigned int D.27644;
  unsigned int D.27645;
  struct MonoAotModule * aot_module;
  int method_index;

  aot_module = image->aot_module;
  if (aot_module == 0B) goto <D.27641>; else goto <D.27642>;
  <D.27641>:
  D.27643 = 0B;
  return D.27643;
  <D.27642>:
  D.27644 = token & 16777215;
  D.27645 = D.27644 + 4294967295;
  method_index = (int) D.27645;
  D.27643 = load_method (domain, aot_module, image, 0B, token, method_index);
  return D.27643;
}


__attribute__((visibility ("hidden")))
mono_aot_is_got_entry (guint8 * code, guint8 * addr)
{
  struct GHashTable * aot_modules.137;
  gboolean D.27650;
  _Bool D.27653;
  long int D.27654;
  long int D.27655;
  _Bool D.27660;
  long int D.27661;
  long int D.27662;
  struct IsGotEntryUserData user_data;

  try
    {
      aot_modules.137 = aot_modules;
      if (aot_modules.137 == 0B) goto <D.27648>; else goto <D.27649>;
      <D.27648>:
      D.27650 = 0;
      return D.27650;
      <D.27649>:
      user_data.addr = addr;
      user_data.res = 0;
      {
        int ret;

        ret = pthread_mutex_lock (&aot_mutex.mutex);
        if (ret != 0) goto <D.27651>; else goto <D.27652>;
        <D.27651>:
        monoeg_g_log (0B, 16, "Bad call to mono_mutex_lock result %d", ret);
        <D.27652>:
        D.27653 = ret != 0;
        D.27654 = (long int) D.27653;
        D.27655 = __builtin_expect (D.27654, 0);
        if (D.27655 != 0) goto <D.27656>; else goto <D.27657>;
        <D.27656>:
        monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "aot-runtime.c", 3812, "ret == 0");
        <D.27657>:
      }
      aot_modules.137 = aot_modules;
      monoeg_g_hash_table_foreach (aot_modules.137, check_is_got_entry, &user_data);
      {
        int ret;

        ret = pthread_mutex_unlock (&aot_mutex.mutex);
        if (ret != 0) goto <D.27658>; else goto <D.27659>;
        <D.27658>:
        monoeg_g_log (0B, 16, "Bad call to mono_mutex_unlock result %d", ret);
        <D.27659>:
        D.27660 = ret != 0;
        D.27661 = (long int) D.27660;
        D.27662 = __builtin_expect (D.27661, 0);
        if (D.27662 != 0) goto <D.27663>; else goto <D.27664>;
        <D.27663>:
        monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "aot-runtime.c", 3814, "ret == 0");
        <D.27664>:
      }
      D.27650 = user_data.res;
      return D.27650;
    }
  finally
    {
      user_data = {CLOBBER};
    }
}


check_is_got_entry (void * key, void * value, void * user_data)
{
  void * * D.27667;
  guint8 * D.27670;
  unsigned int D.27673;
  long unsigned int D.27674;
  long unsigned int D.27675;
  void * * D.27676;
  struct IsGotEntryUserData * data;
  struct MonoAotModule * aot_module;

  data = user_data;
  aot_module = value;
  D.27667 = aot_module->got;
  if (D.27667 != 0B) goto <D.27668>; else goto <D.27669>;
  <D.27668>:
  D.27670 = data->addr;
  D.27667 = aot_module->got;
  if (D.27670 >= D.27667) goto <D.27671>; else goto <D.27672>;
  <D.27671>:
  D.27670 = data->addr;
  D.27667 = aot_module->got;
  D.27673 = aot_module->info.got_size;
  D.27674 = (long unsigned int) D.27673;
  D.27675 = D.27674 * 8;
  D.27676 = D.27667 + D.27675;
  if (D.27670 < D.27676) goto <D.27677>; else goto <D.27678>;
  <D.27677>:
  data->res = 1;
  <D.27678>:
  <D.27672>:
  <D.27669>:
}


__attribute__((visibility ("hidden")))
mono_aot_patch_plt_entry (guint8 * code, void * * got, mgreg_t * regs, guint8 * addr)
{
  struct MonoDomain * D.27679;
  struct MonoDomain * D.27680;

  D.27679 = mono_domain_get ();
  D.27680 = mono_get_root_domain ();
  if (D.27679 == D.27680) goto <D.27681>; else goto <D.27682>;
  <D.27681>:
  mono_arch_patch_plt_entry (code, got, regs, addr);
  <D.27682>:
}


__attribute__((visibility ("hidden")))
mono_aot_plt_resolve (void * aot_module, guint32 plt_info_offset, guint8 * code)
{
  void * D.27683;

  monoeg_assertion_message ("* Assertion: should not be reached at %s:%d\n", "aot-runtime.c", 3949);
  D.27683 = 0B;
  return D.27683;
}


__attribute__((visibility ("hidden")))
mono_aot_get_plt_entry (guint8 * code)
{
  guint8 * D.27687;
  guint8 * D.27689;
  guint8 * D.27691;
  struct MonoAotModule * amodule;
  guint8 * target;

  amodule = find_aot_module (code);
  target = 0B;
  if (amodule == 0B) goto <D.27685>; else goto <D.27686>;
  <D.27685>:
  D.27687 = 0B;
  return D.27687;
  <D.27686>:
  monoeg_assertion_message ("* Assertion: should not be reached at %s:%d\n", "aot-runtime.c", 4007);
  D.27689 = amodule->plt;
  if (D.27689 <= target) goto <D.27690>; else goto <D.27688>;
  <D.27690>:
  D.27691 = amodule->plt_end;
  if (D.27691 > target) goto <D.27692>; else goto <D.27688>;
  <D.27692>:
  D.27687 = target;
  return D.27687;
  <D.27688>:
  D.27687 = 0B;
  return D.27687;
}


find_aot_module (guint8 * code)
{
  struct GHashTable * aot_modules.138;
  struct MonoAotModule * D.27697;
  long unsigned int code.139;
  long unsigned int aot_code_low_addr.140;
  long unsigned int aot_code_high_addr.141;
  _Bool D.27706;
  long int D.27707;
  long int D.27708;
  _Bool D.27713;
  long int D.27714;
  long int D.27715;
  struct FindAotModuleUserData user_data;

  try
    {
      aot_modules.138 = aot_modules;
      if (aot_modules.138 == 0B) goto <D.27695>; else goto <D.27696>;
      <D.27695>:
      D.27697 = 0B;
      return D.27697;
      <D.27696>:
      code.139 = (long unsigned int) code;
      aot_code_low_addr.140 = aot_code_low_addr;
      if (code.139 < aot_code_low_addr.140) goto <D.27698>; else goto <D.27702>;
      <D.27702>:
      code.139 = (long unsigned int) code;
      aot_code_high_addr.141 = aot_code_high_addr;
      if (code.139 > aot_code_high_addr.141) goto <D.27698>; else goto <D.27699>;
      <D.27698>:
      D.27697 = 0B;
      return D.27697;
      <D.27699>:
      user_data.addr = code;
      user_data.module = 0B;
      {
        int ret;

        ret = pthread_mutex_lock (&aot_mutex.mutex);
        if (ret != 0) goto <D.27704>; else goto <D.27705>;
        <D.27704>:
        monoeg_g_log (0B, 16, "Bad call to mono_mutex_lock result %d", ret);
        <D.27705>:
        D.27706 = ret != 0;
        D.27707 = (long int) D.27706;
        D.27708 = __builtin_expect (D.27707, 0);
        if (D.27708 != 0) goto <D.27709>; else goto <D.27710>;
        <D.27709>:
        monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "aot-runtime.c", 3849, "ret == 0");
        <D.27710>:
      }
      aot_modules.138 = aot_modules;
      monoeg_g_hash_table_foreach (aot_modules.138, find_aot_module_cb, &user_data);
      {
        int ret;

        ret = pthread_mutex_unlock (&aot_mutex.mutex);
        if (ret != 0) goto <D.27711>; else goto <D.27712>;
        <D.27711>:
        monoeg_g_log (0B, 16, "Bad call to mono_mutex_unlock result %d", ret);
        <D.27712>:
        D.27713 = ret != 0;
        D.27714 = (long int) D.27713;
        D.27715 = __builtin_expect (D.27714, 0);
        if (D.27715 != 0) goto <D.27716>; else goto <D.27717>;
        <D.27716>:
        monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "aot-runtime.c", 3851, "ret == 0");
        <D.27717>:
      }
      D.27697 = user_data.module;
      return D.27697;
    }
  finally
    {
      user_data = {CLOBBER};
    }
}


find_aot_module_cb (void * key, void * value, void * user_data)
{
  guint8 * D.27720;
  guint8 * D.27721;
  guint8 * D.27724;
  struct FindAotModuleUserData * data;
  struct MonoAotModule * aot_module;

  data = user_data;
  aot_module = value;
  D.27720 = data->addr;
  D.27721 = aot_module->code;
  if (D.27720 >= D.27721) goto <D.27722>; else goto <D.27723>;
  <D.27722>:
  D.27720 = data->addr;
  D.27724 = aot_module->code_end;
  if (D.27720 < D.27724) goto <D.27725>; else goto <D.27726>;
  <D.27725>:
  data->module = aot_module;
  <D.27726>:
  <D.27723>:
}


__attribute__((visibility ("hidden")))
mono_aot_get_plt_info_offset (mgreg_t * regs, guint8 * code)
{
  _Bool D.27727;
  long int D.27728;
  long int D.27729;
  guint32 D.27732;
  guint8 * plt_entry;

  plt_entry = mono_aot_get_plt_entry (code);
  D.27727 = plt_entry == 0B;
  D.27728 = (long int) D.27727;
  D.27729 = __builtin_expect (D.27728, 0);
  if (D.27729 != 0) goto <D.27730>; else goto <D.27731>;
  <D.27730>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "aot-runtime.c", 4039, "plt_entry");
  <D.27731>:
  monoeg_assertion_message ("* Assertion: should not be reached at %s:%d\n", "aot-runtime.c", 4045);
  D.27732 = 0;
  return D.27732;
}


__attribute__((visibility ("hidden")))
mono_aot_register_jit_icall (const char * name, void * addr)
{
  struct GHashTable * aot_jit_icall_hash.142;
  struct GHashTable * D.27737;

  aot_jit_icall_hash.142 = aot_jit_icall_hash;
  if (aot_jit_icall_hash.142 == 0B) goto <D.27735>; else goto <D.27736>;
  <D.27735>:
  D.27737 = monoeg_g_hash_table_new (monoeg_g_str_hash, monoeg_g_str_equal);
  aot_jit_icall_hash = D.27737;
  <D.27736>:
  aot_jit_icall_hash.142 = aot_jit_icall_hash;
  monoeg_g_hash_table_insert_replace (aot_jit_icall_hash.142, name, addr, 0);
}


__attribute__((visibility ("hidden")))
mono_aot_get_trampoline_full (const char * name, struct MonoTrampInfo * * out_tinfo)
{
  _Bool D.27738;
  long int D.27739;
  long int D.27740;
  _Bool D.27743;
  long int D.27744;
  long int D.27745;
  void * D.27748;
  void * D.27749;
  struct MonoImage * image;
  struct MonoAotModule * amodule;

  image = mono_defaults.corlib;
  D.27738 = image == 0B;
  D.27739 = (long int) D.27738;
  D.27740 = __builtin_expect (D.27739, 0);
  if (D.27740 != 0) goto <D.27741>; else goto <D.27742>;
  <D.27741>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "aot-runtime.c", 4242, "image");
  <D.27742>:
  amodule = image->aot_module;
  D.27743 = amodule == 0B;
  D.27744 = (long int) D.27743;
  D.27745 = __builtin_expect (D.27744, 0);
  if (D.27745 != 0) goto <D.27746>; else goto <D.27747>;
  <D.27746>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "aot-runtime.c", 4245, "amodule");
  <D.27747>:
  D.27749 = load_function_full (amodule, name, out_tinfo);
  D.27748 = mono_create_ftnptr_malloc (D.27749);
  return D.27748;
}


load_function_full (struct MonoAotModule * amodule, const char * name, struct MonoTrampInfo * * out_tinfo)
{
  struct MonoDl * D.27751;
  void * * D.27752;
  void * code.143;
  char * D.27756;
  guint8 * p.144;
  void * D.27760;
  guint8 * p.145;
  guint8 * D.27764;
  sizetype D.27765;
  guint8 * uw_info.146;
  guint8 * uw_info.147;
  int D.27768;
  guint8 * D.27769;
  sizetype D.27770;
  guint8 * p.148;
  _Bool D.27774;
  long int D.27775;
  long int D.27776;
  long unsigned int D.27779;
  long unsigned int D.27780;
  void * * D.27781;
  guint32 * got_slots.149;
  long unsigned int D.27783;
  guint32 * D.27784;
  unsigned int D.27785;
  long unsigned int D.27786;
  long unsigned int D.27787;
  void * * D.27788;
  void * D.27789;
  <unnamed type> D.27792;
  const char * D.27795;
  int D.27796;
  int D.27800;
  int D.27804;
  int D.27808;
  char * D.27812;
  long unsigned int D.27815;
  const char * D.27816;
  <unnamed type> tramp_type2.150;
  char * D.27819;
  _Bool D.27822;
  long int D.27823;
  long int D.27824;
  unsigned int slot.151;
  long unsigned int D.27828;
  void * D.27829;
  struct MonoDomain * D.27830;
  int D.27832;
  struct MonoDomain * D.27835;
  int D.27837;
  struct MonoDomain * D.27840;
  int D.27842;
  struct MonoDomain * D.27845;
  int D.27847;
  char * D.27851;
  struct GHashTable * aot_jit_icall_hash.152;
  void * D.27859;
  struct _IO_FILE * stderr.153;
  _Bool D.27863;
  long int D.27864;
  long int D.27865;
  char * symbol;
  guint8 * p;
  int n_patches;
  int pindex;
  struct MonoMemPool * mp;
  void * code;
  guint32 info_offset;

  try
    {
      symbol = monoeg_g_strdup_printf ("%s", name);
      D.27751 = amodule->sofile;
      D.27752 = amodule->globals;
      find_symbol (D.27751, D.27752, symbol, &code);
      monoeg_g_free (symbol);
      code.143 = code;
      if (code.143 == 0B) goto <D.27754>; else goto <D.27755>;
      <D.27754>:
      D.27756 = amodule->aot_name;
      monoeg_g_log (0B, 4, "Symbol \'%s\' not found in AOT file \'%s\'.\n", name, D.27756);
      <D.24393>:
      goto <D.24393>;
      <D.27755>:
      D.27756 = amodule->aot_name;
      mono_trace (128, 32, "AOT FOUND function \'%s\' in AOT file \'%s\'.", name, D.27756);
      symbol = monoeg_g_strdup_printf ("%s_p", name);
      D.27751 = amodule->sofile;
      D.27752 = amodule->globals;
      find_symbol (D.27751, D.27752, symbol, &p);
      monoeg_g_free (symbol);
      p.144 = p;
      if (p.144 == 0B) goto <D.27758>; else goto <D.27759>;
      <D.27758>:
      D.27760 = code;
      return D.27760;
      <D.27759>:
      p.144 = p;
      info_offset = MEM[(guint32 *)p.144];
      if (out_tinfo != 0B) goto <D.27761>; else goto <D.27762>;
      <D.27761>:
      {
        struct MonoTrampInfo * tinfo;
        guint32 code_size;
        guint32 uw_info_len;
        guint32 uw_offset;
        guint8 * uw_info;

        try
          {
            p.144 = p;
            p.145 = p.144 + 4;
            p = p.145;
            p.144 = p;
            code_size = MEM[(guint32 *)p.144];
            p.144 = p;
            p.145 = p.144 + 4;
            p = p.145;
            p.144 = p;
            uw_offset = MEM[(guint32 *)p.144];
            D.27764 = amodule->unwind_info;
            D.27765 = (sizetype) uw_offset;
            uw_info.146 = D.27764 + D.27765;
            uw_info = uw_info.146;
            uw_info.147 = uw_info;
            D.27768 = decode_value (uw_info.147, &uw_info);
            uw_info_len = (guint32) D.27768;
            tinfo = monoeg_malloc0 (56);
            code.143 = code;
            tinfo->code = code.143;
            tinfo->code_size = code_size;
            uw_info.147 = uw_info;
            tinfo->uw_info = uw_info.147;
            tinfo->uw_info_len = uw_info_len;
            *out_tinfo = tinfo;
          }
        finally
          {
            uw_info = {CLOBBER};
          }
      }
      <D.27762>:
      D.27769 = amodule->blob;
      D.27770 = (sizetype) info_offset;
      p.148 = D.27769 + D.27770;
      p = p.148;
      p.144 = p;
      n_patches = decode_value (p.144, &p);
      if (n_patches != 0) goto <D.27772>; else goto <D.27773>;
      <D.27772>:
      {
        struct MonoJumpInfo * patches;
        guint32 * got_slots;

        try
          {
            mp = mono_mempool_new ();
            p.144 = p;
            patches = load_patch_info (amodule, mp, n_patches, &got_slots, p.144, &p);
            D.27774 = patches == 0B;
            D.27775 = (long int) D.27774;
            D.27776 = __builtin_expect (D.27775, 0);
            if (D.27776 != 0) goto <D.27777>; else goto <D.27778>;
            <D.27777>:
            monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "aot-runtime.c", 4151, "patches");
            <D.27778>:
            pindex = 0;
            goto <D.24408>;
            <D.24407>:
            {
              struct MonoJumpInfo * ji;
              void * target;

              D.27779 = (long unsigned int) pindex;
              D.27780 = D.27779 * 40;
              ji = patches + D.27780;
              D.27781 = amodule->got;
              got_slots.149 = got_slots;
              D.27779 = (long unsigned int) pindex;
              D.27783 = D.27779 * 4;
              D.27784 = got_slots.149 + D.27783;
              D.27785 = *D.27784;
              D.27786 = (long unsigned int) D.27785;
              D.27787 = D.27786 * 8;
              D.27788 = D.27781 + D.27787;
              D.27789 = *D.27788;
              if (D.27789 != 0B) goto <D.27790>; else goto <D.27791>;
              <D.27790>:
              // predicted unlikely by continue predictor.
              goto <D.24403>;
              <D.27791>:
              D.27792 = ji->type;
              if (D.27792 == 32) goto <D.27793>; else goto <D.27794>;
              <D.27793>:
              D.27795 = ji->data.name;
              D.27796 = strcmp (D.27795, "mono_get_lmf_addr");
              if (D.27796 == 0) goto <D.27797>; else goto <D.27798>;
              <D.27797>:
              target = mono_get_lmf_addr;
              goto <D.27799>;
              <D.27798>:
              D.27795 = ji->data.name;
              D.27800 = strcmp (D.27795, "mono_thread_force_interruption_checkpoint");
              if (D.27800 == 0) goto <D.27801>; else goto <D.27802>;
              <D.27801>:
              target = mono_thread_force_interruption_checkpoint;
              goto <D.27803>;
              <D.27802>:
              D.27795 = ji->data.name;
              D.27804 = strcmp (D.27795, "mono_exception_from_token");
              if (D.27804 == 0) goto <D.27805>; else goto <D.27806>;
              <D.27805>:
              target = mono_exception_from_token;
              goto <D.27807>;
              <D.27806>:
              D.27795 = ji->data.name;
              D.27808 = strcmp (D.27795, "mono_throw_exception");
              if (D.27808 == 0) goto <D.27809>; else goto <D.27810>;
              <D.27809>:
              target = mono_get_throw_exception ();
              goto <D.27811>;
              <D.27810>:
              D.27795 = ji->data.name;
              D.27812 = strstr (D.27795, "trampoline_func_");
              D.27795 = ji->data.name;
              if (D.27812 == D.27795) goto <D.27813>; else goto <D.27814>;
              <D.27813>:
              {
                int tramp_type2;

                D.27795 = ji->data.name;
                D.27815 = __strlen_g ("trampoline_func_");
                D.27816 = D.27795 + D.27815;
                tramp_type2 = atoi (D.27816);
                tramp_type2.150 = (<unnamed type>) tramp_type2;
                target = mono_get_trampoline_func (tramp_type2.150);
              }
              goto <D.27818>;
              <D.27814>:
              D.27795 = ji->data.name;
              D.27819 = strstr (D.27795, "specific_trampoline_lazy_fetch_");
              D.27795 = ji->data.name;
              if (D.27819 == D.27795) goto <D.27820>; else goto <D.27821>;
              <D.27820>:
              {
                guint32 slot;
                int res;

                try
                  {
                    D.27795 = ji->data.name;
                    res = sscanf (D.27795, "specific_trampoline_lazy_fetch_%u", &slot);
                    D.27822 = res != 1;
                    D.27823 = (long int) D.27822;
                    D.27824 = __builtin_expect (D.27823, 0);
                    if (D.27824 != 0) goto <D.27825>; else goto <D.27826>;
                    <D.27825>:
                    monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "aot-runtime.c", 4182, "res == 1");
                    <D.27826>:
                    slot.151 = slot;
                    D.27828 = (long unsigned int) slot.151;
                    D.27829 = (void *) D.27828;
                    D.27830 = mono_get_root_domain ();
                    target = mono_create_specific_trampoline (D.27829, 4, D.27830, 0B);
                    target = mono_create_ftnptr_malloc (target);
                  }
                finally
                  {
                    slot = {CLOBBER};
                  }
              }
              goto <D.27831>;
              <D.27821>:
              D.27795 = ji->data.name;
              D.27832 = strcmp (D.27795, "specific_trampoline_monitor_enter");
              if (D.27832 == 0) goto <D.27833>; else goto <D.27834>;
              <D.27833>:
              D.27835 = mono_get_root_domain ();
              target = mono_create_specific_trampoline (0B, 10, D.27835, 0B);
              target = mono_create_ftnptr_malloc (target);
              goto <D.27836>;
              <D.27834>:
              D.27795 = ji->data.name;
              D.27837 = strcmp (D.27795, "specific_trampoline_monitor_exit");
              if (D.27837 == 0) goto <D.27838>; else goto <D.27839>;
              <D.27838>:
              D.27840 = mono_get_root_domain ();
              target = mono_create_specific_trampoline (0B, 11, D.27840, 0B);
              target = mono_create_ftnptr_malloc (target);
              goto <D.27841>;
              <D.27839>:
              D.27795 = ji->data.name;
              D.27842 = strcmp (D.27795, "specific_trampoline_generic_class_init");
              if (D.27842 == 0) goto <D.27843>; else goto <D.27844>;
              <D.27843>:
              D.27845 = mono_get_root_domain ();
              target = mono_create_specific_trampoline (0B, 3, D.27845, 0B);
              target = mono_create_ftnptr_malloc (target);
              goto <D.27846>;
              <D.27844>:
              D.27795 = ji->data.name;
              D.27847 = strcmp (D.27795, "mono_thread_get_and_clear_pending_exception");
              if (D.27847 == 0) goto <D.27848>; else goto <D.27849>;
              <D.27848>:
              target = mono_thread_get_and_clear_pending_exception;
              goto <D.27850>;
              <D.27849>:
              D.27795 = ji->data.name;
              D.27851 = strstr (D.27795, "generic_trampoline_");
              if (D.27851 != 0B) goto <D.27852>; else goto <D.27853>;
              <D.27852>:
              D.27795 = ji->data.name;
              target = mono_aot_get_trampoline (D.27795);
              goto <D.27854>;
              <D.27853>:
              aot_jit_icall_hash.152 = aot_jit_icall_hash;
              if (aot_jit_icall_hash.152 != 0B) goto <D.27858>; else goto <D.27855>;
              <D.27858>:
              aot_jit_icall_hash.152 = aot_jit_icall_hash;
              D.27795 = ji->data.name;
              D.27859 = monoeg_g_hash_table_lookup (aot_jit_icall_hash.152, D.27795);
              if (D.27859 != 0B) goto <D.27860>; else goto <D.27855>;
              <D.27860>:
              aot_jit_icall_hash.152 = aot_jit_icall_hash;
              D.27795 = ji->data.name;
              target = monoeg_g_hash_table_lookup (aot_jit_icall_hash.152, D.27795);
              goto <D.27856>;
              <D.27855>:
              stderr.153 = stderr;
              D.27795 = ji->data.name;
              fprintf (stderr.153, "Unknown relocation \'%s\'\n", D.27795);
              monoeg_assertion_message ("* Assertion: should not be reached at %s:%d\n", "aot-runtime.c", 4203);
              target = 0B;
              <D.27856>:
              <D.27854>:
              <D.27850>:
              <D.27846>:
              <D.27841>:
              <D.27836>:
              <D.27831>:
              <D.27818>:
              <D.27811>:
              <D.27807>:
              <D.27803>:
              <D.27799>:
              goto <D.27862>;
              <D.27794>:
              code.143 = code;
              target = mono_resolve_patch_target (0B, 0B, code.143, ji, 0);
              D.27863 = target == 0B;
              D.27864 = (long int) D.27863;
              D.27865 = __builtin_expect (D.27864, 0);
              if (D.27865 != 0) goto <D.27866>; else goto <D.27867>;
              <D.27866>:
              monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "aot-runtime.c", 4211, "target");
              <D.27867>:
              <D.27862>:
              D.27781 = amodule->got;
              got_slots.149 = got_slots;
              D.27779 = (long unsigned int) pindex;
              D.27783 = D.27779 * 4;
              D.27784 = got_slots.149 + D.27783;
              D.27785 = *D.27784;
              D.27786 = (long unsigned int) D.27785;
              D.27787 = D.27786 * 8;
              D.27788 = D.27781 + D.27787;
              *D.27788 = target;
            }
            <D.24403>:
            pindex = pindex + 1;
            <D.24408>:
            if (pindex < n_patches) goto <D.24407>; else goto <D.24409>;
            <D.24409>:
            got_slots.149 = got_slots;
            monoeg_g_free (got_slots.149);
            mono_mempool_destroy (mp);
          }
        finally
          {
            got_slots = {CLOBBER};
          }
      }
      <D.27773>:
      D.27760 = code;
      return D.27760;
    }
  finally
    {
      p = {CLOBBER};
      code = {CLOBBER};
    }
}


mono_create_ftnptr_malloc (guint8 * code)
{
  void * D.27870;

  D.27870 = code;
  return D.27870;
}


__attribute__((visibility ("hidden")))
mono_aot_get_trampoline (const char * name)
{
  void * D.27872;

  D.27872 = mono_aot_get_trampoline_full (name, 0B);
  return D.27872;
}


__attribute__((visibility ("hidden")))
mono_aot_create_specific_trampoline (struct MonoImage * image, void * arg1, MonoTrampolineType tramp_type, struct MonoDomain * domain, guint32 * code_len)
{
  int inited.154;
  _Bool D.27879;
  long int D.27880;
  long int D.27881;
  _Bool D.27888;
  long int D.27889;
  long int D.27890;
  unsigned int num_trampolines.155;
  unsigned int num_trampolines.156;
  void * D.27895;
  void * D.27898;
  _Bool D.27899;
  long int D.27900;
  long int D.27901;
  struct MonoAotModule * amodule.157;
  void * * D.27908;
  unsigned int got_offset.158;
  long unsigned int D.27910;
  long unsigned int D.27911;
  void * * D.27912;
  unsigned int D.27913;
  long unsigned int D.27914;
  long unsigned int D.27915;
  void * * D.27916;
  unsigned int tramp_size.159;
  void * D.27920;
  struct MonoAotModule * amodule;
  guint32 got_offset;
  guint32 tramp_size;
  guint8 * code;
  guint8 * tramp;
  static void * generic_trampolines[14];
  static gboolean inited;
  static guint32 num_trampolines;

  try
    {
      inited.154 = inited;
      if (inited.154 == 0) goto <D.27875>; else goto <D.27876>;
      <D.27875>:
      {
        int ret;

        ret = pthread_mutex_lock (&aot_mutex.mutex);
        if (ret != 0) goto <D.27877>; else goto <D.27878>;
        <D.27877>:
        monoeg_g_log (0B, 16, "Bad call to mono_mutex_lock result %d", ret);
        <D.27878>:
        D.27879 = ret != 0;
        D.27880 = (long int) D.27879;
        D.27881 = __builtin_expect (D.27880, 0);
        if (D.27881 != 0) goto <D.27882>; else goto <D.27883>;
        <D.27882>:
        monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "aot-runtime.c", 4494, "ret == 0");
        <D.27883>:
      }
      inited.154 = inited;
      if (inited.154 == 0) goto <D.27884>; else goto <D.27885>;
      <D.27884>:
      mono_counters_register ("Specific trampolines", 256, &num_trampolines);
      inited = 1;
      <D.27885>:
      {
        int ret;

        ret = pthread_mutex_unlock (&aot_mutex.mutex);
        if (ret != 0) goto <D.27886>; else goto <D.27887>;
        <D.27886>:
        monoeg_g_log (0B, 16, "Bad call to mono_mutex_unlock result %d", ret);
        <D.27887>:
        D.27888 = ret != 0;
        D.27889 = (long int) D.27888;
        D.27890 = __builtin_expect (D.27889, 0);
        if (D.27890 != 0) goto <D.27891>; else goto <D.27892>;
        <D.27891>:
        monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "aot-runtime.c", 4501, "ret == 0");
        <D.27892>:
      }
      <D.27876>:
      num_trampolines.155 = num_trampolines;
      num_trampolines.156 = num_trampolines.155 + 1;
      num_trampolines = num_trampolines.156;
      D.27895 = generic_trampolines[tramp_type];
      if (D.27895 == 0B) goto <D.27896>; else goto <D.27897>;
      <D.27896>:
      {
        char * symbol;

        symbol = mono_get_generic_trampoline_name (tramp_type);
        D.27898 = mono_aot_get_trampoline (symbol);
        generic_trampolines[tramp_type] = D.27898;
        monoeg_g_free (symbol);
      }
      <D.27897>:
      tramp = generic_trampolines[tramp_type];
      D.27899 = tramp == 0B;
      D.27900 = (long int) D.27899;
      D.27901 = __builtin_expect (D.27900, 0);
      if (D.27901 != 0) goto <D.27902>; else goto <D.27903>;
      <D.27902>:
      monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "aot-runtime.c", 4515, "tramp");
      <D.27903>:
      if (0 != 0) goto <D.27904>; else goto <D.27905>;
      <D.27904>:
      code = get_new_specific_trampoline_from_page (tramp, arg1);
      tramp_size = 8;
      goto <D.27906>;
      <D.27905>:
      code = get_numerous_trampoline (0, 2, &amodule, &got_offset, &tramp_size);
      amodule.157 = amodule;
      D.27908 = amodule.157->got;
      got_offset.158 = got_offset;
      D.27910 = (long unsigned int) got_offset.158;
      D.27911 = D.27910 * 8;
      D.27912 = D.27908 + D.27911;
      *D.27912 = tramp;
      amodule.157 = amodule;
      D.27908 = amodule.157->got;
      got_offset.158 = got_offset;
      D.27913 = got_offset.158 + 1;
      D.27914 = (long unsigned int) D.27913;
      D.27915 = D.27914 * 8;
      D.27916 = D.27908 + D.27915;
      *D.27916 = arg1;
      <D.27906>:
      if (code_len != 0B) goto <D.27917>; else goto <D.27918>;
      <D.27917>:
      tramp_size.159 = tramp_size;
      *code_len = tramp_size.159;
      <D.27918>:
      D.27920 = code;
      return D.27920;
    }
  finally
    {
      amodule = {CLOBBER};
      got_offset = {CLOBBER};
      tramp_size = {CLOBBER};
    }
}


get_numerous_trampoline (MonoAotTrampoline tramp_type, int n_got_slots, struct MonoAotModule * * out_amodule, guint32 * got_offset, guint32 * out_tramp_size)
{
  _Bool D.27923;
  long int D.27924;
  long int D.27925;
  _Bool D.27930;
  long int D.27931;
  long int D.27932;
  _Bool D.27935;
  long int D.27936;
  long int D.27937;
  unsigned int D.27940;
  unsigned int D.27941;
  char * D.27944;
  unsigned int D.27945;
  unsigned int D.27946;
  _Bool D.27949;
  long int D.27950;
  long int D.27951;
  unsigned int D.27954;
  int D.27955;
  unsigned int D.27956;
  unsigned int D.27957;
  unsigned int D.27958;
  unsigned int tramp_size.160;
  void * D.27962;
  guint8 * D.27963;
  int D.27964;
  sizetype D.27965;
  struct MonoAotModule * amodule;
  int index;
  int tramp_size;
  struct MonoImage * image;

  image = mono_defaults.corlib;
  D.27923 = image == 0B;
  D.27924 = (long int) D.27923;
  D.27925 = __builtin_expect (D.27924, 0);
  if (D.27925 != 0) goto <D.27926>; else goto <D.27927>;
  <D.27926>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "aot-runtime.c", 4448, "image");
  <D.27927>:
  {
    int ret;

    ret = pthread_mutex_lock (&aot_mutex.mutex);
    if (ret != 0) goto <D.27928>; else goto <D.27929>;
    <D.27928>:
    monoeg_g_log (0B, 16, "Bad call to mono_mutex_lock result %d", ret);
    <D.27929>:
    D.27930 = ret != 0;
    D.27931 = (long int) D.27930;
    D.27932 = __builtin_expect (D.27931, 0);
    if (D.27932 != 0) goto <D.27933>; else goto <D.27934>;
    <D.27933>:
    monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "aot-runtime.c", 4450, "ret == 0");
    <D.27934>:
  }
  amodule = image->aot_module;
  D.27935 = amodule == 0B;
  D.27936 = (long int) D.27935;
  D.27937 = __builtin_expect (D.27936, 0);
  if (D.27937 != 0) goto <D.27938>; else goto <D.27939>;
  <D.27938>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "aot-runtime.c", 4453, "amodule");
  <D.27939>:
  *out_amodule = amodule;
  D.27940 = amodule->trampoline_index[tramp_type];
  D.27941 = amodule->info.num_trampolines[tramp_type];
  if (D.27940 == D.27941) goto <D.27942>; else goto <D.27943>;
  <D.27942>:
  D.27944 = image->name;
  D.27941 = amodule->info.num_trampolines[tramp_type];
  monoeg_g_log (0B, 4, "Ran out of trampolines of type %d in \'%s\' (%d)%s\n", tramp_type, D.27944, D.27941, "");
  <D.24462>:
  goto <D.24462>;
  <D.27943>:
  D.27940 = amodule->trampoline_index[tramp_type];
  D.27945 = D.27940;
  D.27946 = D.27945 + 1;
  amodule->trampoline_index[tramp_type] = D.27946;
  index = (int) D.27945;
  {
    int ret;

    ret = pthread_mutex_unlock (&aot_mutex.mutex);
    if (ret != 0) goto <D.27947>; else goto <D.27948>;
    <D.27947>:
    monoeg_g_log (0B, 16, "Bad call to mono_mutex_unlock result %d", ret);
    <D.27948>:
    D.27949 = ret != 0;
    D.27950 = (long int) D.27949;
    D.27951 = __builtin_expect (D.27950, 0);
    if (D.27951 != 0) goto <D.27952>; else goto <D.27953>;
    <D.27952>:
    monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "aot-runtime.c", 4468, "ret == 0");
    <D.27953>:
  }
  D.27954 = amodule->info.trampoline_got_offset_base[tramp_type];
  D.27955 = index * n_got_slots;
  D.27956 = (unsigned int) D.27955;
  D.27957 = D.27954 + D.27956;
  *got_offset = D.27957;
  D.27958 = amodule->info.trampoline_size[tramp_type];
  tramp_size = (int) D.27958;
  if (out_tramp_size != 0B) goto <D.27959>; else goto <D.27960>;
  <D.27959>:
  tramp_size.160 = (unsigned int) tramp_size;
  *out_tramp_size = tramp_size.160;
  <D.27960>:
  D.27963 = amodule->trampolines[tramp_type];
  D.27964 = index * tramp_size;
  D.27965 = (sizetype) D.27964;
  D.27962 = D.27963 + D.27965;
  return D.27962;
}


__attribute__((visibility ("hidden")))
mono_aot_get_static_rgctx_trampoline (void * ctx, void * addr)
{
  struct MonoAotModule * amodule.161;
  void * * D.27971;
  unsigned int got_offset.162;
  long unsigned int D.27973;
  long unsigned int D.27974;
  void * * D.27975;
  unsigned int D.27976;
  long unsigned int D.27977;
  long unsigned int D.27978;
  void * * D.27979;
  void * D.27980;
  struct MonoDomain * D.27981;
  struct MonoAotModule * amodule;
  guint8 * code;
  guint32 got_offset;

  try
    {
      if (0 != 0) goto <D.27967>; else goto <D.27968>;
      <D.27967>:
      code = get_new_rgctx_trampoline_from_page (addr, ctx);
      goto <D.27969>;
      <D.27968>:
      code = get_numerous_trampoline (1, 2, &amodule, &got_offset, 0B);
      amodule.161 = amodule;
      D.27971 = amodule.161->got;
      got_offset.162 = got_offset;
      D.27973 = (long unsigned int) got_offset.162;
      D.27974 = D.27973 * 8;
      D.27975 = D.27971 + D.27974;
      *D.27975 = ctx;
      amodule.161 = amodule;
      D.27971 = amodule.161->got;
      got_offset.162 = got_offset;
      D.27976 = got_offset.162 + 1;
      D.27977 = (long unsigned int) D.27976;
      D.27978 = D.27977 * 8;
      D.27979 = D.27971 + D.27978;
      *D.27979 = addr;
      <D.27969>:
      D.27981 = mono_domain_get ();
      D.27980 = mono_create_ftnptr (D.27981, code);
      return D.27980;
    }
  finally
    {
      amodule = {CLOBBER};
      got_offset = {CLOBBER};
    }
}


__attribute__((visibility ("hidden")))
mono_aot_get_unbox_trampoline (struct MonoMethod * method)
{
  unsigned int D.27984;
  unsigned int D.27985;
  long unsigned int D.27988;
  long unsigned int D.27989;
  int D.27991;
  int D.27995;
  _Bool D.27998;
  long int D.27999;
  long int D.28000;
  struct MonoClass * D.28003;
  struct MonoImage * D.28004;
  void * amodule.163;
  struct MonoAotModule * amodule.164;
  _Bool D.28007;
  long int D.28008;
  long int D.28009;
  long int ut_end.165;
  long int ut.166;
  long int D.28014;
  long int D.28015;
  long int D.28016;
  int D.28017;
  int D.28018;
  long unsigned int D.28019;
  long unsigned int D.28020;
  unsigned int D.28021;
  unsigned int D.28028;
  unsigned int D.28029;
  guint32 * D.28032;
  guint8 * D.28034;
  unsigned int D.28035;
  sizetype D.28036;
  _Bool D.28037;
  long int D.28038;
  long int D.28039;
  void * D.28042;
  struct MonoDomain * D.28043;
  guint32 method_index;
  struct MonoAotModule * amodule;
  void * code;
  guint32 * ut;
  guint32 * ut_end;
  guint32 * entry;
  int low;
  int high;
  int entry_index;

  try
    {
      D.27984 = method->token;
      D.27985 = D.27984 & 16777215;
      method_index = D.27985 + 4294967295;
      D.27988 = BIT_FIELD_REF <*method, 64, 256>;
      D.27989 = D.27988 & 2251799813685248;
      if (D.27989 != 0) goto <D.27990>; else goto <D.27986>;
      <D.27990>:
      D.27991 = mono_method_is_generic_sharable_full (method, 0, 0, 0);
      if (D.27991 == 0) goto <D.27992>; else goto <D.27986>;
      <D.27992>:
      method_index = find_extra_method (method, &amodule);
      if (method_index == 16777215) goto <D.27993>; else goto <D.27994>;
      <D.27993>:
      D.27995 = mono_method_is_generic_sharable_full (method, 0, 0, 1);
      if (D.27995 != 0) goto <D.27996>; else goto <D.27997>;
      <D.27996>:
      {
        struct MonoMethod * shared;

        shared = mini_get_shared_method_full (method, 1, 1);
        method_index = find_extra_method (shared, &amodule);
      }
      <D.27997>:
      <D.27994>:
      D.27998 = method_index == 16777215;
      D.27999 = (long int) D.27998;
      D.28000 = __builtin_expect (D.27999, 0);
      if (D.28000 != 0) goto <D.28001>; else goto <D.28002>;
      <D.28001>:
      monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "aot-runtime.c", 4568, "method_index != 0xffffff");
      <D.28002>:
      goto <D.27987>;
      <D.27986>:
      D.28003 = method->klass;
      D.28004 = D.28003->image;
      amodule.163 = D.28004->aot_module;
      amodule = amodule.163;
      amodule.164 = amodule;
      D.28007 = amodule.164 == 0B;
      D.28008 = (long int) D.28007;
      D.28009 = __builtin_expect (D.28008, 0);
      if (D.28009 != 0) goto <D.28010>; else goto <D.28011>;
      <D.28010>:
      monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "aot-runtime.c", 4571, "amodule");
      <D.28011>:
      <D.27987>:
      amodule.164 = amodule;
      ut = amodule.164->unbox_trampolines;
      amodule.164 = amodule;
      ut_end = amodule.164->unbox_trampolines_end;
      code = 0B;
      low = 0;
      ut_end.165 = (long int) ut_end;
      ut.166 = (long int) ut;
      D.28014 = ut_end.165 - ut.166;
      D.28015 = D.28014 /[ex] 4;
      D.28016 = D.28015 / 2;
      high = (int) D.28016;
      goto <D.24504>;
      <D.24503>:
      D.28017 = low + high;
      entry_index = D.28017 / 2;
      D.28018 = entry_index * 2;
      D.28019 = (long unsigned int) D.28018;
      D.28020 = D.28019 * 4;
      entry = ut + D.28020;
      D.28021 = *entry;
      if (D.28021 < method_index) goto <D.28022>; else goto <D.28023>;
      <D.28022>:
      low = entry_index + 1;
      goto <D.28024>;
      <D.28023>:
      D.28021 = *entry;
      if (D.28021 > method_index) goto <D.28025>; else goto <D.28026>;
      <D.28025>:
      high = entry_index;
      goto <D.28027>;
      <D.28026>:
      amodule.164 = amodule;
      D.28028 = amodule.164->info.flags;
      D.28029 = D.28028 & 8;
      if (D.28029 != 0) goto <D.28030>; else goto <D.28031>;
      <D.28030>:
      D.28032 = entry + 4;
      code = get_arm_bl_target (D.28032);
      goto <D.28033>;
      <D.28031>:
      amodule.164 = amodule;
      D.28034 = amodule.164->code;
      D.28032 = entry + 4;
      D.28035 = *D.28032;
      D.28036 = (sizetype) D.28035;
      code = D.28034 + D.28036;
      <D.28033>:
      goto <D.24502>;
      <D.28027>:
      <D.28024>:
      <D.24504>:
      if (low < high) goto <D.24503>; else goto <D.24502>;
      <D.24502>:
      D.28037 = code == 0B;
      D.28038 = (long int) D.28037;
      D.28039 = __builtin_expect (D.28038, 0);
      if (D.28039 != 0) goto <D.28040>; else goto <D.28041>;
      <D.28040>:
      monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "aot-runtime.c", 4596, "code");
      <D.28041>:
      D.28043 = mono_domain_get ();
      D.28042 = mono_create_ftnptr (D.28043, code);
      return D.28042;
    }
  finally
    {
      amodule = {CLOBBER};
    }
}


get_arm_bl_target (guint32 * ins_addr)
{
  void * D.28046;

  monoeg_assertion_message ("* Assertion: should not be reached at %s:%d\n", "aot-runtime.c", 1540);
  D.28046 = 0B;
  return D.28046;
}


__attribute__((visibility ("hidden")))
mono_aot_get_lazy_fetch_trampoline (guint32 slot)
{
  struct MonoImage * D.28048;
  int count.167;
  int count.168;
  unsigned int D.28051;
  void * addr.169;
  void * addr.170;
  struct MonoDomain * D.28058;
  long unsigned int D.28059;
  void * D.28060;
  void * * D.28061;
  struct MonoDomain * D.28062;
  void * D.28063;
  void * D.28064;
  struct MonoDomain * D.28065;
  int slot.171;
  void * D.28067;
  struct MonoDomain * D.28068;
  char * symbol;
  void * code;
  struct MonoAotModule * amodule;
  guint32 index;
  static int count = 0;

  D.28048 = mono_defaults.corlib;
  amodule = D.28048->aot_module;
  index = slot & 2147483647;
  count.167 = count;
  count.168 = count.167 + 1;
  count = count.168;
  D.28051 = amodule->info.num_rgctx_fetch_trampolines;
  if (D.28051 <= index) goto <D.28052>; else goto <D.28053>;
  <D.28052>:
  {
    static void * addr;
    void * * info;

    addr.169 = addr;
    if (addr.169 == 0B) goto <D.28055>; else goto <D.28056>;
    <D.28055>:
    addr.170 = load_function (amodule, "rgctx_fetch_trampoline_general");
    addr = addr.170;
    <D.28056>:
    D.28058 = mono_get_root_domain ();
    info = mono_domain_alloc0 (D.28058, 16);
    D.28059 = (long unsigned int) slot;
    D.28060 = (void *) D.28059;
    *info = D.28060;
    D.28061 = info + 8;
    D.28059 = (long unsigned int) slot;
    D.28060 = (void *) D.28059;
    D.28062 = mono_get_root_domain ();
    D.28063 = mono_create_specific_trampoline (D.28060, 4, D.28062, 0B);
    *D.28061 = D.28063;
    addr.169 = addr;
    code = mono_aot_get_static_rgctx_trampoline (info, addr.169);
    D.28065 = mono_domain_get ();
    D.28064 = mono_create_ftnptr (D.28065, code);
    return D.28064;
  }
  <D.28053>:
  slot.171 = (int) slot;
  symbol = mono_get_rgctx_fetch_trampoline_name (slot.171);
  D.28048 = mono_defaults.corlib;
  D.28067 = D.28048->aot_module;
  code = load_function (D.28067, symbol);
  monoeg_g_free (symbol);
  D.28068 = mono_domain_get ();
  D.28064 = mono_create_ftnptr (D.28068, code);
  return D.28064;
}


load_function (struct MonoAotModule * amodule, const char * name)
{
  void * D.28070;

  D.28070 = load_function_full (amodule, name, 0B);
  return D.28070;
}


__attribute__((visibility ("hidden")))
mono_aot_get_imt_thunk (struct MonoVTable * vtable, struct MonoDomain * domain, struct MonoIMTCheckItem * * imt_entries, int count, void * fail_tramp)
{
  long unsigned int D.28072;
  long unsigned int D.28073;
  struct MonoIMTCheckItem * * D.28074;
  unsigned char D.28075;
  int D.28078;
  int D.28079;
  long unsigned int D.28080;
  unsigned int D.28081;
  unsigned int D.28082;
  unsigned char D.28083;
  void * D.28086;
  _Bool D.28087;
  long int D.28088;
  long int D.28089;
  int D.28092;
  long unsigned int D.28093;
  long unsigned int D.28094;
  void * * D.28095;
  unsigned char D.28096;
  void * D.28099;
  sizetype D.28100;
  sizetype D.28101;
  sizetype D.28102;
  void * * D.28103;
  int D.28105;
  void * * D.28106;
  struct MonoAotModule * amodule.172;
  void * * D.28111;
  unsigned int got_offset.173;
  long unsigned int D.28113;
  long unsigned int D.28114;
  void * * D.28115;
  void * D.28116;
  guint32 got_offset;
  void * code;
  void * * buf;
  int i;
  int index;
  int real_count;
  struct MonoAotModule * amodule;

  try
    {
      real_count = 0;
      i = 0;
      goto <D.24531>;
      <D.24530>:
      {
        struct MonoIMTCheckItem * item;

        D.28072 = (long unsigned int) i;
        D.28073 = D.28072 * 8;
        D.28074 = imt_entries + D.28073;
        item = *D.28074;
        D.28075 = item->is_equals;
        if (D.28075 != 0) goto <D.28076>; else goto <D.28077>;
        <D.28076>:
        real_count = real_count + 1;
        <D.28077>:
      }
      i = i + 1;
      <D.24531>:
      if (i < count) goto <D.24530>; else goto <D.24532>;
      <D.24532>:
      D.28078 = real_count + 1;
      D.28079 = D.28078 * 2;
      D.28080 = (long unsigned int) D.28079;
      D.28081 = (unsigned int) D.28080;
      D.28082 = D.28081 * 8;
      buf = mono_domain_alloc (domain, D.28082);
      index = 0;
      i = 0;
      goto <D.24537>;
      <D.24536>:
      {
        struct MonoIMTCheckItem * item;

        D.28072 = (long unsigned int) i;
        D.28073 = D.28072 * 8;
        D.28074 = imt_entries + D.28073;
        item = *D.28074;
        D.28083 = item->is_equals;
        if (D.28083 == 0) goto <D.28084>; else goto <D.28085>;
        <D.28084>:
        // predicted unlikely by continue predictor.
        goto <D.24534>;
        <D.28085>:
        D.28086 = item->key;
        D.28087 = D.28086 == 0B;
        D.28088 = (long int) D.28087;
        D.28089 = __builtin_expect (D.28088, 0);
        if (D.28089 != 0) goto <D.28090>; else goto <D.28091>;
        <D.28090>:
        monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "aot-runtime.c", 4661, "item->key");
        <D.28091>:
        D.28092 = index * 2;
        D.28093 = (long unsigned int) D.28092;
        D.28094 = D.28093 * 8;
        D.28095 = buf + D.28094;
        D.28086 = item->key;
        *D.28095 = D.28086;
        D.28096 = item->has_target_code;
        if (D.28096 != 0) goto <D.28097>; else goto <D.28098>;
        <D.28097>:
        {
          void * * p;

          p = mono_domain_alloc (domain, 8);
          D.28099 = item->value.target_code;
          *p = D.28099;
          D.28092 = index * 2;
          D.28100 = (sizetype) D.28092;
          D.28101 = D.28100 + 1;
          D.28102 = D.28101 * 8;
          D.28103 = buf + D.28102;
          *D.28103 = p;
        }
        goto <D.28104>;
        <D.28098>:
        D.28092 = index * 2;
        D.28100 = (sizetype) D.28092;
        D.28101 = D.28100 + 1;
        D.28102 = D.28101 * 8;
        D.28103 = buf + D.28102;
        D.28105 = item->value.vtable_slot;
        D.28106 = &vtable->vtable[D.28105];
        *D.28103 = D.28106;
        <D.28104>:
        index = index + 1;
      }
      <D.24534>:
      i = i + 1;
      <D.24537>:
      if (i < count) goto <D.24536>; else goto <D.24538>;
      <D.24538>:
      D.28092 = index * 2;
      D.28093 = (long unsigned int) D.28092;
      D.28094 = D.28093 * 8;
      D.28095 = buf + D.28094;
      *D.28095 = 0B;
      D.28092 = index * 2;
      D.28100 = (sizetype) D.28092;
      D.28101 = D.28100 + 1;
      D.28102 = D.28101 * 8;
      D.28103 = buf + D.28102;
      *D.28103 = fail_tramp;
      if (0 != 0) goto <D.28107>; else goto <D.28108>;
      <D.28107>:
      code = get_new_imt_trampoline_from_page (buf);
      goto <D.28109>;
      <D.28108>:
      code = get_numerous_trampoline (2, 1, &amodule, &got_offset, 0B);
      amodule.172 = amodule;
      D.28111 = amodule.172->got;
      got_offset.173 = got_offset;
      D.28113 = (long unsigned int) got_offset.173;
      D.28114 = D.28113 * 8;
      D.28115 = D.28111 + D.28114;
      *D.28115 = buf;
      <D.28109>:
      D.28116 = code;
      return D.28116;
    }
  finally
    {
      got_offset = {CLOBBER};
      amodule = {CLOBBER};
    }
}


__attribute__((visibility ("hidden")))
mono_aot_get_gsharedvt_arg_trampoline (void * arg, void * addr)
{
  struct MonoAotModule * amodule.174;
  void * * D.28123;
  unsigned int got_offset.175;
  long unsigned int D.28125;
  long unsigned int D.28126;
  void * * D.28127;
  unsigned int D.28128;
  long unsigned int D.28129;
  long unsigned int D.28130;
  void * * D.28131;
  void * D.28132;
  struct MonoDomain * D.28133;
  struct MonoAotModule * amodule;
  guint8 * code;
  guint32 got_offset;

  try
    {
      if (0 != 0) goto <D.28119>; else goto <D.28120>;
      <D.28119>:
      code = get_new_gsharedvt_arg_trampoline_from_page (addr, arg);
      goto <D.28121>;
      <D.28120>:
      code = get_numerous_trampoline (3, 2, &amodule, &got_offset, 0B);
      amodule.174 = amodule;
      D.28123 = amodule.174->got;
      got_offset.175 = got_offset;
      D.28125 = (long unsigned int) got_offset.175;
      D.28126 = D.28125 * 8;
      D.28127 = D.28123 + D.28126;
      *D.28127 = arg;
      amodule.174 = amodule;
      D.28123 = amodule.174->got;
      got_offset.175 = got_offset;
      D.28128 = got_offset.175 + 1;
      D.28129 = (long unsigned int) D.28128;
      D.28130 = D.28129 * 8;
      D.28131 = D.28123 + D.28130;
      *D.28131 = addr;
      <D.28121>:
      D.28133 = mono_domain_get ();
      D.28132 = mono_create_ftnptr (D.28133, code);
      return D.28132;
    }
  finally
    {
      amodule = {CLOBBER};
      got_offset = {CLOBBER};
    }
}


__attribute__((visibility ("hidden")))
mono_aot_set_make_unreadable (gboolean unreadable)
{
  int make_unreadable.176;
  int inited.177;
  static int inited;

  make_unreadable = unreadable;
  make_unreadable.176 = make_unreadable;
  if (make_unreadable.176 != 0) goto <D.28137>; else goto <D.28138>;
  <D.28137>:
  inited.177 = inited;
  if (inited.177 == 0) goto <D.28140>; else goto <D.28141>;
  <D.28140>:
  mono_counters_register ("AOT pagefaults", 256, &n_pagefaults);
  <D.28141>:
  <D.28138>:
}


__attribute__((visibility ("hidden")))
mono_aot_is_pagefault (void * ptr)
{
  int make_unreadable.178;
  gboolean D.28145;
  struct MonoAotModule * D.28146;
  _Bool D.28147;

  make_unreadable.178 = make_unreadable;
  if (make_unreadable.178 == 0) goto <D.28143>; else goto <D.28144>;
  <D.28143>:
  D.28145 = 0;
  return D.28145;
  <D.28144>:
  D.28146 = find_module_for_addr (ptr);
  D.28147 = D.28146 != 0B;
  D.28145 = (gboolean) D.28147;
  return D.28145;
}


find_module_for_addr (void * ptr)
{
  int make_unreadable.179;
  struct MonoAotModule * D.28152;
  _Bool D.28155;
  long int D.28156;
  long int D.28157;
  struct GHashTable * aot_modules.180;
  _Bool D.28163;
  long int D.28164;
  long int D.28165;
  struct FindMapUserData data;

  try
    {
      make_unreadable.179 = make_unreadable;
      if (make_unreadable.179 == 0) goto <D.28150>; else goto <D.28151>;
      <D.28150>:
      D.28152 = 0B;
      return D.28152;
      <D.28151>:
      data.module = 0B;
      data.ptr = ptr;
      {
        int ret;

        ret = pthread_mutex_lock (&aot_mutex.mutex);
        if (ret != 0) goto <D.28153>; else goto <D.28154>;
        <D.28153>:
        monoeg_g_log (0B, 16, "Bad call to mono_mutex_lock result %d", ret);
        <D.28154>:
        D.28155 = ret != 0;
        D.28156 = (long int) D.28155;
        D.28157 = __builtin_expect (D.28156, 0);
        if (D.28157 != 0) goto <D.28158>; else goto <D.28159>;
        <D.28158>:
        monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "aot-runtime.c", 4752, "ret == 0");
        <D.28159>:
      }
      aot_modules.180 = aot_modules;
      monoeg_g_hash_table_foreach (aot_modules.180, find_map, &data);
      {
        int ret;

        ret = pthread_mutex_unlock (&aot_mutex.mutex);
        if (ret != 0) goto <D.28161>; else goto <D.28162>;
        <D.28161>:
        monoeg_g_log (0B, 16, "Bad call to mono_mutex_unlock result %d", ret);
        <D.28162>:
        D.28163 = ret != 0;
        D.28164 = (long int) D.28163;
        D.28165 = __builtin_expect (D.28164, 0);
        if (D.28165 != 0) goto <D.28166>; else goto <D.28167>;
        <D.28166>:
        monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "aot-runtime.c", 4754, "ret == 0");
        <D.28167>:
      }
      D.28152 = data.module;
      return D.28152;
    }
  finally
    {
      data = {CLOBBER};
    }
}


find_map (void * key, void * value, void * user_data)
{
  struct MonoAotModule * D.28170;
  guint8 * D.28173;
  guint8 * D.28174;
  guint8 * D.28177;
  struct MonoAotModule * module;
  struct FindMapUserData * data;

  module = value;
  data = user_data;
  D.28170 = data->module;
  if (D.28170 == 0B) goto <D.28171>; else goto <D.28172>;
  <D.28171>:
  D.28173 = data->ptr;
  D.28174 = module->mem_begin;
  if (D.28173 >= D.28174) goto <D.28175>; else goto <D.28176>;
  <D.28175>:
  D.28173 = data->ptr;
  D.28177 = module->mem_end;
  if (D.28173 < D.28177) goto <D.28178>; else goto <D.28179>;
  <D.28178>:
  data->module = module;
  <D.28179>:
  <D.28176>:
  <D.28172>:
}


__attribute__((visibility ("hidden")))
mono_aot_handle_pagefault (void * ptr)
{
  int D.28180;
  int D.28181;
  int D.28182;
  long int D.28183;
  long int ptr.181;
  long int D.28185;
  _Bool D.28188;
  long int D.28189;
  long int D.28190;
  int D.28193;
  long unsigned int D.28194;
  _Bool D.28195;
  long int D.28196;
  long int D.28197;
  unsigned int n_pagefaults.182;
  unsigned int D.28201;
  _Bool D.28204;
  long int D.28205;
  long int D.28206;
  guint8 * start;
  int res;

  D.28180 = mono_pagesize ();
  D.28181 = D.28180 + -1;
  D.28182 = ~D.28181;
  D.28183 = (long int) D.28182;
  ptr.181 = (long int) ptr;
  D.28185 = D.28183 & ptr.181;
  start = (guint8 *) D.28185;
  {
    int ret;

    ret = pthread_mutex_lock (&aot_mutex.mutex);
    if (ret != 0) goto <D.28186>; else goto <D.28187>;
    <D.28186>:
    monoeg_g_log (0B, 16, "Bad call to mono_mutex_lock result %d", ret);
    <D.28187>:
    D.28188 = ret != 0;
    D.28189 = (long int) D.28188;
    D.28190 = __builtin_expect (D.28189, 0);
    if (D.28190 != 0) goto <D.28191>; else goto <D.28192>;
    <D.28191>:
    monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "aot-runtime.c", 4790, "ret == 0");
    <D.28192>:
  }
  D.28193 = mono_pagesize ();
  D.28194 = (long unsigned int) D.28193;
  res = mono_mprotect (start, D.28194, 7);
  D.28195 = res != 0;
  D.28196 = (long int) D.28195;
  D.28197 = __builtin_expect (D.28196, 0);
  if (D.28197 != 0) goto <D.28198>; else goto <D.28199>;
  <D.28198>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "aot-runtime.c", 4792, "res == 0");
  <D.28199>:
  n_pagefaults.182 = n_pagefaults;
  D.28201 = n_pagefaults.182 + 1;
  n_pagefaults = D.28201;
  {
    int ret;

    ret = pthread_mutex_unlock (&aot_mutex.mutex);
    if (ret != 0) goto <D.28202>; else goto <D.28203>;
    <D.28202>:
    monoeg_g_log (0B, 16, "Bad call to mono_mutex_unlock result %d", ret);
    <D.28203>:
    D.28204 = ret != 0;
    D.28205 = (long int) D.28204;
    D.28206 = __builtin_expect (D.28205, 0);
    if (D.28206 != 0) goto <D.28207>; else goto <D.28208>;
    <D.28207>:
    monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "aot-runtime.c", 4795, "ret == 0");
    <D.28208>:
  }
}