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.25036;
  _Bool D.25037;
  long int D.25038;
  long int D.25039;
  _Bool D.25042;
  long int D.25043;
  long int D.25044;
  struct GHashTable * aot_modules.0;
  _Bool D.25052;
  long int D.25053;
  long int D.25054;
  struct GHashTable * static_aot_modules.1;
  struct GHashTable * static_aot_modules.2;
  _Bool D.25065;
  long int D.25066;
  long int D.25067;
  void * * globals;
  char * aname;
  struct MonoAotFileInfo * info;

  info = aot_info;
  D.25036 = info->version;
  D.25037 = D.25036 != 97;
  D.25038 = (long int) D.25037;
  D.25039 = __builtin_expect (D.25038, 0);
  if (D.25039 != 0) goto <D.25040>; else goto <D.25041>;
  <D.25040>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "aot-runtime.c", 1889, "info->version == MONO_AOT_FILE_VERSION");
  <D.25041>:
  globals = info->globals;
  D.25042 = globals == 0B;
  D.25043 = (long int) D.25042;
  D.25044 = __builtin_expect (D.25043, 0);
  if (D.25044 != 0) goto <D.25045>; else goto <D.25046>;
  <D.25045>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "aot-runtime.c", 1892, "globals");
  <D.25046>:
  aname = info->assembly_name;
  aot_modules.0 = aot_modules;
  if (aot_modules.0 != 0B) goto <D.25048>; else goto <D.25049>;
  <D.25048>:
  {
    int ret;

    ret = pthread_mutex_lock (&aot_mutex.mutex);
    if (ret != 0) goto <D.25050>; else goto <D.25051>;
    <D.25050>:
    monoeg_g_log (0B, 16, "Bad call to mono_mutex_lock result %d", ret);
    <D.25051>:
    D.25052 = ret != 0;
    D.25053 = (long int) D.25052;
    D.25054 = __builtin_expect (D.25053, 0);
    if (D.25054 != 0) goto <D.25055>; else goto <D.25056>;
    <D.25055>:
    monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "aot-runtime.c", 1898, "ret == 0");
    <D.25056>:
  }
  <D.25049>:
  static_aot_modules.1 = static_aot_modules;
  if (static_aot_modules.1 == 0B) goto <D.25058>; else goto <D.25059>;
  <D.25058>:
  static_aot_modules.2 = monoeg_g_hash_table_new (monoeg_g_str_hash, monoeg_g_str_equal);
  static_aot_modules = static_aot_modules.2;
  <D.25059>:
  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.25061>; else goto <D.25062>;
  <D.25061>:
  {
    int ret;

    ret = pthread_mutex_unlock (&aot_mutex.mutex);
    if (ret != 0) goto <D.25063>; else goto <D.25064>;
    <D.25063>:
    monoeg_g_log (0B, 16, "Bad call to mono_mutex_unlock result %d", ret);
    <D.25064>:
    D.25065 = ret != 0;
    D.25066 = (long int) D.25065;
    D.25067 = __builtin_expect (D.25066, 0);
    if (D.25067 != 0) goto <D.25068>; else goto <D.25069>;
    <D.25068>:
    monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "aot-runtime.c", 1906, "ret == 0");
    <D.25069>:
  }
  <D.25062>:
}


mono_aot_init ()
{
  struct GHashTable * aot_modules.3;
  const gchar * D.25071;
  const gchar * D.25074;
  int mono_last_aot_method.4;
  const gchar * D.25076;

  InitializeCriticalSection (&aot_mutex);
  InitializeCriticalSection (&aot_page_mutex);
  aot_modules.3 = monoeg_g_hash_table_new (0B, 0B);
  aot_modules = aot_modules.3;
  mono_install_assembly_load_hook (load_aot_module, 0B);
  mono_counters_register ("Async JIT info size", 256, &async_jit_info_size);
  D.25071 = monoeg_g_getenv ("MONO_LASTAOT");
  if (D.25071 != 0B) goto <D.25072>; else goto <D.25073>;
  <D.25072>:
  D.25074 = monoeg_g_getenv ("MONO_LASTAOT");
  mono_last_aot_method.4 = atoi (D.25074);
  mono_last_aot_method = mono_last_aot_method.4;
  <D.25073>:
  D.25076 = monoeg_g_getenv ("MONO_AOT_CACHE");
  if (D.25076 != 0B) goto <D.25077>; else goto <D.25078>;
  <D.25077>:
  use_aot_cache = 1;
  <D.25078>:
}


load_aot_module (struct MonoAssembly * assembly, void * user_data)
{
  int mono_compile_aot.5;
  struct MonoImage * D.25082;
  void * D.25083;
  long unsigned int D.25088;
  long unsigned int D.25089;
  int D.25091;
  <unnamed type> D.25092;
  _Bool D.25097;
  long int D.25098;
  long int D.25099;
  struct GHashTable * static_aot_modules.6;
  const char * D.25105;
  void * info.7;
  _Bool D.25110;
  long int D.25111;
  long int D.25112;
  struct MonoAotFileInfo * info.8;
  gchar * aot_name.9;
  char * aot_name.10;
  int use_aot_cache.11;
  char * D.25125;
  gchar * aot_name.12;
  char * err.13;
  int mono_aot_only.14;
  long unsigned int D.25137;
  long unsigned int D.25138;
  struct _IO_FILE * stderr.15;
  char * version_symbol.16;
  _Bool D.25148;
  long int D.25149;
  long int D.25150;
  unsigned int D.25153;
  gchar * msg.17;
  char * msg.18;
  unsigned int D.25165;
  unsigned int align_double.19;
  _Bool D.25167;
  long int D.25168;
  long int D.25169;
  unsigned int D.25172;
  unsigned int align_int64.20;
  _Bool D.25174;
  long int D.25175;
  long int D.25176;
  unsigned int D.25179;
  _Bool D.25180;
  long int D.25181;
  long int D.25182;
  struct MonoAotFileInfo * D.25185;
  void * D.25186;
  void * * D.25187;
  struct GHashTable * D.25188;
  _Bool D.25189;
  long int D.25190;
  long int D.25191;
  long unsigned int D.25194;
  long unsigned int D.25195;
  void * D.25196;
  long unsigned int D.25197;
  void * D.25198;
  void * D.25199;
  struct MonoAssemblyName * D.25200;
  long unsigned int D.25201;
  long unsigned int D.25202;
  gchar * D.25203;
  long unsigned int D.25204;
  sizetype D.25205;
  char * * D.25206;
  long unsigned int D.25207;
  char * * D.25208;
  gchar * D.25209;
  long unsigned int D.25210;
  sizetype D.25211;
  char D.25212;
  gchar * D.25215;
  long unsigned int D.25216;
  sizetype D.25217;
  mono_byte[17] * D.25218;
  long unsigned int D.25219;
  long unsigned int D.25220;
  long unsigned int D.25221;
  sizetype D.25222;
  long int table.21;
  long int D.25224;
  long int D.25225;
  unsigned int D.25226;
  short unsigned int D.25227;
  void * D.25228;
  void * D.25229;
  void * D.25230;
  void * D.25231;
  void * D.25232;
  void * D.25233;
  void * D.25234;
  void * D.25235;
  void * D.25236;
  void * D.25237;
  void * D.25238;
  void * D.25239;
  void * D.25240;
  void * D.25241;
  void * D.25242;
  guint8 * D.25243;
  void * D.25244;
  void * D.25245;
  void * D.25246;
  void * D.25247;
  void * D.25248;
  void * D.25249;
  void * D.25250;
  void * D.25251;
  int make_unreadable.22;
  guint8 * D.25255;
  long int D.25256;
  guint8 * D.25257;
  long int D.25258;
  long int D.25259;
  int D.25260;
  sizetype D.25261;
  int D.25262;
  int D.25263;
  long int D.25264;
  long int addr.23;
  long int D.25266;
  sizetype D.25267;
  sizetype D.25268;
  sizetype D.25269;
  guint8 * D.25270;
  long int D.25271;
  int D.25272;
  int D.25273;
  long int D.25274;
  long int D.25275;
  long int page_end.24;
  long int page_start.25;
  long int D.25280;
  long unsigned int D.25281;
  _Bool D.25282;
  long int D.25283;
  long int D.25284;
  _Bool D.25289;
  long int D.25290;
  long int D.25291;
  long unsigned int D.25294;
  long unsigned int aot_code_low_addr.26;
  long unsigned int aot_code_low_addr.27;
  guint8 * D.25297;
  long unsigned int D.25298;
  long unsigned int aot_code_high_addr.28;
  long unsigned int aot_code_high_addr.29;
  struct GHashTable * aot_modules.30;
  _Bool D.25304;
  long int D.25305;
  long int D.25306;
  struct MonoDl * D.25311;
  void * * D.25312;
  char * code.31;
  _Bool D.25314;
  int D.25315;
  struct MonoImage * D.25316;
  void * * D.25319;
  void * * D.25320;
  int D.25322;
  void * * D.25325;
  struct MonoDomain * D.25326;
  void * D.25327;
  unsigned int i.32;
  unsigned int D.25331;
  int D.25332;
  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.5 = mono_compile_aot;
      if (mono_compile_aot.5 != 0) goto <D.25080>; else goto <D.25081>;
      <D.25080>:
      return;
      <D.25081>:
      D.25082 = assembly->image;
      D.25083 = D.25082->aot_module;
      if (D.25083 != 0B) goto <D.25084>; else goto <D.25085>;
      <D.25084>:
      return;
      <D.25085>:
      D.25082 = assembly->image;
      D.25088 = BIT_FIELD_REF <*D.25082, 64, 192>;
      D.25089 = D.25088 & 34359738368;
      if (D.25089 != 0) goto <D.25086>; else goto <D.25090>;
      <D.25090>:
      D.25091 = assembly->ref_only;
      if (D.25091 != 0) goto <D.25086>; else goto <D.25087>;
      <D.25086>:
      return;
      <D.25087>:
      D.25092 = mono_security_get_mode ();
      if (D.25092 == 2) goto <D.25093>; else goto <D.25094>;
      <D.25093>:
      return;
      <D.25094>:
      {
        int ret;

        ret = pthread_mutex_lock (&aot_mutex.mutex);
        if (ret != 0) goto <D.25095>; else goto <D.25096>;
        <D.25095>:
        monoeg_g_log (0B, 16, "Bad call to mono_mutex_lock result %d", ret);
        <D.25096>:
        D.25097 = ret != 0;
        D.25098 = (long int) D.25097;
        D.25099 = __builtin_expect (D.25098, 0);
        if (D.25099 != 0) goto <D.25100>; else goto <D.25101>;
        <D.25100>:
        monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "aot-runtime.c", 1577, "ret == 0");
        <D.25101>:
      }
      static_aot_modules.6 = static_aot_modules;
      if (static_aot_modules.6 != 0B) goto <D.25103>; else goto <D.25104>;
      <D.25103>:
      static_aot_modules.6 = static_aot_modules;
      D.25105 = assembly->aname.name;
      info.7 = monoeg_g_hash_table_lookup (static_aot_modules.6, D.25105);
      info = info.7;
      goto <D.25107>;
      <D.25104>:
      info = 0B;
      <D.25107>:
      {
        int ret;

        ret = pthread_mutex_unlock (&aot_mutex.mutex);
        if (ret != 0) goto <D.25108>; else goto <D.25109>;
        <D.25108>:
        monoeg_g_log (0B, 16, "Bad call to mono_mutex_unlock result %d", ret);
        <D.25109>:
        D.25110 = ret != 0;
        D.25111 = (long int) D.25110;
        D.25112 = __builtin_expect (D.25111, 0);
        if (D.25112 != 0) goto <D.25113>; else goto <D.25114>;
        <D.25113>:
        monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "aot-runtime.c", 1582, "ret == 0");
        <D.25114>:
      }
      info.8 = info;
      if (info.8 != 0B) goto <D.25116>; else goto <D.25117>;
      <D.25116>:
      sofile = 0B;
      D.25105 = assembly->aname.name;
      aot_name.9 = monoeg_g_strdup_printf ("%s", D.25105);
      aot_name = aot_name.9;
      aot_name.10 = aot_name;
      mono_trace (64, 32, "Found statically linked AOT module \'%s\'.\n", aot_name.10);
      info.8 = info;
      globals = info.8->globals;
      goto <D.25120>;
      <D.25117>:
      use_aot_cache.11 = use_aot_cache;
      if (use_aot_cache.11 != 0) goto <D.25122>; else goto <D.25123>;
      <D.25122>:
      sofile = load_aot_module_from_cache (assembly, &aot_name);
      goto <D.25124>;
      <D.25123>:
      {
        char * err;

        try
          {
            D.25082 = assembly->image;
            D.25125 = D.25082->name;
            aot_name.12 = monoeg_g_strdup_printf ("%s%s", D.25125, ".so");
            aot_name = aot_name.12;
            aot_name.10 = aot_name;
            sofile = mono_dl_open (aot_name.10, 1, &err);
            if (sofile == 0B) goto <D.25127>; else goto <D.25128>;
            <D.25127>:
            aot_name.10 = aot_name;
            err.13 = err;
            mono_trace (64, 32, "AOT module \'%s\' not found: %s\n", aot_name.10, err.13);
            err.13 = err;
            monoeg_g_free (err.13);
            <D.25128>:
          }
        finally
          {
            err = {CLOBBER};
          }
      }
      <D.25124>:
      <D.25120>:
      if (sofile == 0B) goto <D.25130>; else goto <D.25131>;
      <D.25130>:
      if (globals == 0B) goto <D.25132>; else goto <D.25133>;
      <D.25132>:
      mono_aot_only.14 = mono_aot_only;
      if (mono_aot_only.14 != 0) goto <D.25135>; else goto <D.25136>;
      <D.25135>:
      D.25082 = assembly->image;
      D.25137 = BIT_FIELD_REF <*D.25082, 64, 2368>;
      D.25138 = D.25137 & 16777215;
      if (D.25138 != 0) goto <D.25139>; else goto <D.25140>;
      <D.25139>:
      stderr.15 = stderr;
      aot_name.10 = aot_name;
      fprintf (stderr.15, "Failed to load AOT module \'%s\' in aot-only mode.\n", aot_name.10);
      exit (1);
      <D.25140>:
      <D.25136>:
      aot_name.10 = aot_name;
      monoeg_g_free (aot_name.10);
      return;
      <D.25133>:
      <D.25131>:
      info.8 = info;
      if (info.8 == 0B) goto <D.25142>; else goto <D.25143>;
      <D.25142>:
      find_symbol (sofile, globals, "mono_aot_version", &version_symbol);
      find_symbol (sofile, globals, "mono_aot_file_info", &info);
      <D.25143>:
      version_symbol.16 = version_symbol;
      if (version_symbol.16 != 0B) goto <D.25145>; else goto <D.25146>;
      <D.25145>:
      version_symbol.16 = version_symbol;
      version = atoi (version_symbol.16);
      goto <D.25147>;
      <D.25146>:
      info.8 = info;
      D.25148 = info.8 == 0B;
      D.25149 = (long int) D.25148;
      D.25150 = __builtin_expect (D.25149, 0);
      if (D.25150 != 0) goto <D.25151>; else goto <D.25152>;
      <D.25151>:
      monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "aot-runtime.c", 1624, "info");
      <D.25152>:
      info.8 = info;
      D.25153 = info.8->version;
      version = (int) D.25153;
      <D.25147>:
      if (version != 97) goto <D.25154>; else goto <D.25155>;
      <D.25154>:
      msg.17 = monoeg_g_strdup_printf ("wrong file format version (expected %d got %d)", 97, version);
      msg = msg.17;
      usable = 0;
      goto <D.25157>;
      <D.25155>:
      info.8 = info;
      usable = check_usable (assembly, info.8, &msg);
      <D.25157>:
      if (usable == 0) goto <D.25158>; else goto <D.25159>;
      <D.25158>:
      mono_aot_only.14 = mono_aot_only;
      if (mono_aot_only.14 != 0) goto <D.25160>; else goto <D.25161>;
      <D.25160>:
      stderr.15 = stderr;
      aot_name.10 = aot_name;
      msg.18 = msg;
      fprintf (stderr.15, "Failed to load AOT module \'%s\' while running in aot-only mode: %s.\n", aot_name.10, msg.18);
      exit (1);
      <D.25161>:
      aot_name.10 = aot_name;
      msg.18 = msg;
      mono_trace (64, 32, "AOT module %s is unusable: %s.\n", aot_name.10, msg.18);
      msg.18 = msg;
      monoeg_g_free (msg.18);
      aot_name.10 = aot_name;
      monoeg_g_free (aot_name.10);
      if (sofile != 0B) goto <D.25163>; else goto <D.25164>;
      <D.25163>:
      mono_dl_close (sofile);
      <D.25164>:
      D.25082 = assembly->image;
      D.25082->aot_module = 0B;
      return;
      <D.25159>:
      align_double = 8;
      align_int64 = 8;
      info.8 = info;
      D.25165 = info.8->double_align;
      align_double.19 = (unsigned int) align_double;
      D.25167 = D.25165 != align_double.19;
      D.25168 = (long int) D.25167;
      D.25169 = __builtin_expect (D.25168, 0);
      if (D.25169 != 0) goto <D.25170>; else goto <D.25171>;
      <D.25170>:
      monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "aot-runtime.c", 1670, "info->double_align == align_double");
      <D.25171>:
      info.8 = info;
      D.25172 = info.8->long_align;
      align_int64.20 = (unsigned int) align_int64;
      D.25174 = D.25172 != align_int64.20;
      D.25175 = (long int) D.25174;
      D.25176 = __builtin_expect (D.25175, 0);
      if (D.25176 != 0) goto <D.25177>; else goto <D.25178>;
      <D.25177>:
      monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "aot-runtime.c", 1671, "info->long_align == align_int64");
      <D.25178>:
      info.8 = info;
      D.25179 = info.8->generic_tramp_num;
      D.25180 = D.25179 != 14;
      D.25181 = (long int) D.25180;
      D.25182 = __builtin_expect (D.25181, 0);
      if (D.25182 != 0) goto <D.25183>; else goto <D.25184>;
      <D.25183>:
      monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "aot-runtime.c", 1672, "info->generic_tramp_num == MONO_TRAMPOLINE_NUM");
      <D.25184>:
      info.8 = info;
      blob = info.8->blob;
      amodule = monoeg_malloc0 (736);
      aot_name.10 = aot_name;
      amodule->aot_name = aot_name.10;
      amodule->assembly = assembly;
      D.25185 = &amodule->info;
      info.8 = info;
      memcpy (D.25185, info.8, 368);
      D.25186 = amodule->info.got;
      amodule->got = D.25186;
      D.25187 = amodule->got;
      D.25082 = assembly->image;
      *D.25187 = D.25082;
      amodule->globals = globals;
      amodule->sofile = sofile;
      D.25188 = monoeg_g_hash_table_new (mono_aligned_addr_hash, 0B);
      amodule->method_to_code = D.25188;
      amodule->blob = blob;
      {
        guint32 table_len;
        guint32 i;
        char * table;

        table = 0B;
        info.8 = info;
        table = info.8->image_table;
        D.25189 = table == 0B;
        D.25190 = (long int) D.25189;
        D.25191 = __builtin_expect (D.25190, 0);
        if (D.25191 != 0) goto <D.25192>; else goto <D.25193>;
        <D.25192>:
        monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "aot-runtime.c", 1695, "table");
        <D.25193>:
        table_len = MEM[(guint32 *)table];
        table = table + 4;
        D.25194 = (long unsigned int) table_len;
        D.25195 = D.25194 * 8;
        D.25196 = monoeg_malloc0 (D.25195);
        amodule->image_table = D.25196;
        D.25194 = (long unsigned int) table_len;
        D.25197 = D.25194 * 80;
        D.25198 = monoeg_malloc0 (D.25197);
        amodule->image_names = D.25198;
        D.25194 = (long unsigned int) table_len;
        D.25195 = D.25194 * 8;
        D.25199 = monoeg_malloc0 (D.25195);
        amodule->image_guids = D.25199;
        amodule->image_table_len = table_len;
        i = 0;
        goto <D.23981>;
        <D.23980>:
        {
          struct MonoAssemblyName * aname;

          D.25200 = amodule->image_names;
          D.25201 = (long unsigned int) i;
          D.25202 = D.25201 * 80;
          aname = D.25200 + D.25202;
          D.25203 = monoeg_strdup (table);
          aname->name = D.25203;
          D.25204 = strlen (table);
          D.25205 = D.25204 + 1;
          table = table + D.25205;
          D.25206 = amodule->image_guids;
          D.25201 = (long unsigned int) i;
          D.25207 = D.25201 * 8;
          D.25208 = D.25206 + D.25207;
          D.25209 = monoeg_strdup (table);
          *D.25208 = D.25209;
          D.25210 = strlen (table);
          D.25211 = D.25210 + 1;
          table = table + D.25211;
          D.25212 = *table;
          if (D.25212 != 0) goto <D.25213>; else goto <D.25214>;
          <D.25213>:
          D.25215 = monoeg_strdup (table);
          aname->culture = D.25215;
          <D.25214>:
          D.25216 = strlen (table);
          D.25217 = D.25216 + 1;
          table = table + D.25217;
          D.25218 = &aname->public_key_token;
          D.25219 = strlen (table);
          D.25220 = D.25219 + 1;
          memcpy (D.25218, table, D.25220);
          D.25221 = strlen (table);
          D.25222 = D.25221 + 1;
          table = table + D.25222;
          table.21 = (long int) table;
          D.25224 = table.21 + 7;
          D.25225 = D.25224 & -8;
          table = (char *) D.25225;
          D.25226 = MEM[(guint32 *)table];
          aname->flags = D.25226;
          table = table + 4;
          D.25226 = MEM[(guint32 *)table];
          D.25227 = (short unsigned int) D.25226;
          aname->major = D.25227;
          table = table + 4;
          D.25226 = MEM[(guint32 *)table];
          D.25227 = (short unsigned int) D.25226;
          aname->minor = D.25227;
          table = table + 4;
          D.25226 = MEM[(guint32 *)table];
          D.25227 = (short unsigned int) D.25226;
          aname->build = D.25227;
          table = table + 4;
          D.25226 = MEM[(guint32 *)table];
          D.25227 = (short unsigned int) D.25226;
          aname->revision = D.25227;
          table = table + 4;
        }
        i = i + 1;
        <D.23981>:
        if (i < table_len) goto <D.23980>; else goto <D.23982>;
        <D.23982>:
      }
      info.8 = info;
      D.25228 = info.8->code_offsets;
      amodule->code_offsets = D.25228;
      info.8 = info;
      D.25229 = info.8->method_addresses;
      amodule->method_addresses = D.25229;
      info.8 = info;
      D.25230 = info.8->methods;
      amodule->code = D.25230;
      info.8 = info;
      D.25231 = info.8->methods_end;
      amodule->code_end = D.25231;
      info.8 = info;
      D.25232 = info.8->method_info_offsets;
      amodule->method_info_offsets = D.25232;
      info.8 = info;
      D.25233 = info.8->ex_info_offsets;
      amodule->ex_info_offsets = D.25233;
      info.8 = info;
      D.25234 = info.8->class_info_offsets;
      amodule->class_info_offsets = D.25234;
      info.8 = info;
      D.25235 = info.8->class_name_table;
      amodule->class_name_table = D.25235;
      info.8 = info;
      D.25236 = info.8->extra_method_table;
      amodule->extra_method_table = D.25236;
      info.8 = info;
      D.25237 = info.8->extra_method_info_offsets;
      amodule->extra_method_info_offsets = D.25237;
      info.8 = info;
      D.25238 = info.8->unbox_trampolines;
      amodule->unbox_trampolines = D.25238;
      info.8 = info;
      D.25239 = info.8->unbox_trampolines_end;
      amodule->unbox_trampolines_end = D.25239;
      info.8 = info;
      D.25240 = info.8->got_info_offsets;
      amodule->got_info_offsets = D.25240;
      info.8 = info;
      D.25241 = info.8->unwind_info;
      amodule->unwind_info = D.25241;
      info.8 = info;
      D.25242 = info.8->mem_end;
      amodule->mem_end = D.25242;
      D.25243 = amodule->code;
      amodule->mem_begin = D.25243;
      info.8 = info;
      D.25244 = info.8->plt;
      amodule->plt = D.25244;
      info.8 = info;
      D.25245 = info.8->plt_end;
      amodule->plt_end = D.25245;
      info.8 = info;
      D.25246 = info.8->mono_eh_frame;
      amodule->mono_eh_frame = D.25246;
      info.8 = info;
      D.25247 = info.8->specific_trampolines;
      amodule->trampolines[0] = D.25247;
      info.8 = info;
      D.25248 = info.8->static_rgctx_trampolines;
      amodule->trampolines[1] = D.25248;
      info.8 = info;
      D.25249 = info.8->imt_thunks;
      amodule->trampolines[2] = D.25249;
      info.8 = info;
      D.25250 = info.8->gsharedvt_arg_trampolines;
      amodule->trampolines[3] = D.25250;
      info.8 = info;
      D.25251 = info.8->thumb_end;
      amodule->thumb_end = D.25251;
      make_unreadable.22 = make_unreadable;
      if (make_unreadable.22 != 0) goto <D.25253>; else goto <D.25254>;
      <D.25253>:
      {
        guint8 * addr;
        guint8 * page_start;
        guint8 * page_end;
        int err;
        int len;

        addr = amodule->mem_begin;
        D.25255 = amodule->mem_end;
        D.25256 = (long int) D.25255;
        D.25257 = amodule->mem_begin;
        D.25258 = (long int) D.25257;
        D.25259 = D.25256 - D.25258;
        len = (int) D.25259;
        D.25260 = mono_pagesize ();
        D.25261 = (sizetype) D.25260;
        D.25262 = mono_pagesize ();
        D.25263 = -D.25262;
        D.25264 = (long int) D.25263;
        addr.23 = (long int) addr;
        D.25266 = D.25264 & addr.23;
        D.25267 = (sizetype) D.25266;
        D.25268 = D.25261 + D.25267;
        page_start = (guint8 *) D.25268;
        D.25269 = (sizetype) len;
        D.25270 = addr + D.25269;
        D.25271 = (long int) D.25270;
        D.25272 = mono_pagesize ();
        D.25273 = -D.25272;
        D.25274 = (long int) D.25273;
        D.25275 = D.25271 & D.25274;
        page_end = (guint8 *) D.25275;
        if (page_end > page_start) goto <D.25276>; else goto <D.25277>;
        <D.25276>:
        page_end.24 = (long int) page_end;
        page_start.25 = (long int) page_start;
        D.25280 = page_end.24 - page_start.25;
        D.25281 = (long unsigned int) D.25280;
        err = mono_mprotect (page_start, D.25281, 0);
        D.25282 = err != 0;
        D.25283 = (long int) D.25282;
        D.25284 = __builtin_expect (D.25283, 0);
        if (D.25284 != 0) goto <D.25285>; else goto <D.25286>;
        <D.25285>:
        monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "aot-runtime.c", 1789, "err == 0");
        <D.25286>:
        <D.25277>:
      }
      <D.25254>:
      {
        int ret;

        ret = pthread_mutex_lock (&aot_mutex.mutex);
        if (ret != 0) goto <D.25287>; else goto <D.25288>;
        <D.25287>:
        monoeg_g_log (0B, 16, "Bad call to mono_mutex_lock result %d", ret);
        <D.25288>:
        D.25289 = ret != 0;
        D.25290 = (long int) D.25289;
        D.25291 = __builtin_expect (D.25290, 0);
        if (D.25291 != 0) goto <D.25292>; else goto <D.25293>;
        <D.25292>:
        monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "aot-runtime.c", 1794, "ret == 0");
        <D.25293>:
      }
      D.25243 = amodule->code;
      D.25294 = (long unsigned int) D.25243;
      aot_code_low_addr.26 = aot_code_low_addr;
      aot_code_low_addr.27 = MIN_EXPR <D.25294, aot_code_low_addr.26>;
      aot_code_low_addr = aot_code_low_addr.27;
      D.25297 = amodule->code_end;
      D.25298 = (long unsigned int) D.25297;
      aot_code_high_addr.28 = aot_code_high_addr;
      aot_code_high_addr.29 = MAX_EXPR <D.25298, aot_code_high_addr.28>;
      aot_code_high_addr = aot_code_high_addr.29;
      aot_modules.30 = aot_modules;
      monoeg_g_hash_table_insert_replace (aot_modules.30, assembly, amodule, 0);
      {
        int ret;

        ret = pthread_mutex_unlock (&aot_mutex.mutex);
        if (ret != 0) goto <D.25302>; else goto <D.25303>;
        <D.25302>:
        monoeg_g_log (0B, 16, "Bad call to mono_mutex_unlock result %d", ret);
        <D.25303>:
        D.25304 = ret != 0;
        D.25305 = (long int) D.25304;
        D.25306 = __builtin_expect (D.25305, 0);
        if (D.25306 != 0) goto <D.25307>; else goto <D.25308>;
        <D.25307>:
        monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "aot-runtime.c", 1800, "ret == 0");
        <D.25308>:
      }
      D.25082 = assembly->image;
      D.25243 = amodule->code;
      D.25297 = amodule->code_end;
      mono_jit_info_add_aot_module (D.25082, D.25243, D.25297);
      D.25082 = assembly->image;
      D.25082->aot_module = amodule;
      mono_aot_only.14 = mono_aot_only;
      if (mono_aot_only.14 != 0) goto <D.25309>; else goto <D.25310>;
      <D.25309>:
      {
        char * code;

        try
          {
            D.25311 = amodule->sofile;
            D.25312 = amodule->globals;
            find_symbol (D.25311, D.25312, "specific_trampolines_page", &code);
            code.31 = code;
            D.25314 = code.31 != 0B;
            D.25315 = (int) D.25314;
            amodule->use_page_trampolines = D.25315;
            D.25316 = mono_defaults.corlib;
            if (D.25316 != 0B) goto <D.25317>; else goto <D.25318>;
            <D.25317>:
            {
              struct MonoAotModule * mscorlib_amodule;

              D.25316 = mono_defaults.corlib;
              mscorlib_amodule = D.25316->aot_module;
              D.25187 = amodule->got;
              D.25319 = D.25187 + 8;
              D.25320 = mscorlib_amodule->got;
              *D.25319 = D.25320;
            }
            goto <D.25321>;
            <D.25318>:
            D.25187 = amodule->got;
            D.25319 = D.25187 + 8;
            D.25187 = amodule->got;
            *D.25319 = D.25187;
            <D.25321>:
          }
        finally
          {
            code = {CLOBBER};
          }
      }
      <D.25310>:
      D.25322 = mono_gc_is_moving ();
      if (D.25322 != 0) goto <D.25323>; else goto <D.25324>;
      <D.25323>:
      {
        struct MonoJumpInfo ji;

        try
          {
            memset (&ji, 0, 40);
            ji.type = 42;
            D.25187 = amodule->got;
            D.25325 = D.25187 + 16;
            D.25326 = mono_get_root_domain ();
            D.25327 = mono_resolve_patch_target (0B, D.25326, 0B, &ji, 0);
            *D.25325 = D.25327;
          }
        finally
          {
            ji = {CLOBBER};
          }
      }
      <D.25324>:
      if (do_load_image != 0) goto <D.25328>; else goto <D.25329>;
      <D.25328>:
      i = 0;
      goto <D.23994>;
      <D.23993>:
      load_image (amodule, i, 0);
      i = i + 1;
      <D.23994>:
      i.32 = (unsigned int) i;
      D.25331 = amodule->image_table_len;
      if (i.32 < D.25331) goto <D.23993>; else goto <D.23995>;
      <D.23995>:
      <D.25329>:
      D.25332 = amodule->out_of_date;
      if (D.25332 != 0) goto <D.25333>; else goto <D.25334>;
      <D.25333>:
      D.25082 = assembly->image;
      D.25125 = D.25082->name;
      mono_trace (64, 32, "AOT Module %s is unusable because a dependency is out-of-date.\n", D.25125);
      mono_aot_only.14 = mono_aot_only;
      if (mono_aot_only.14 != 0) goto <D.25335>; else goto <D.25336>;
      <D.25335>:
      stderr.15 = stderr;
      aot_name.10 = aot_name;
      fprintf (stderr.15, "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.10);
      exit (1);
      <D.25336>:
      goto <D.25337>;
      <D.25334>:
      D.25082 = assembly->image;
      D.25125 = D.25082->name;
      mono_trace (64, 32, "AOT loaded AOT Module for %s.\n", D.25125);
      <D.25337>:
    }
  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.25341;
  long unsigned int D.25342;
  long unsigned int D.25343;
  struct MonoDl * D.25346;
  const char * D.25347;
  char * D.25348;
  char * D.25351;
  int spawn_compiler.33;
  int D.25356;
  unsigned int D.25357;
  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.25341 = assembly->image;
      D.25342 = BIT_FIELD_REF <*D.25341, 64, 192>;
      D.25343 = D.25342 & 34359738368;
      if (D.25343 != 0) goto <D.25344>; else goto <D.25345>;
      <D.25344>:
      D.25346 = 0B;
      return D.25346;
      <D.25345>:
      create_cache_structure ();
      home = monoeg_g_get_home_dir ();
      D.25341 = assembly->image;
      D.25347 = D.25341->assembly_name;
      D.25341 = assembly->image;
      D.25348 = D.25341->guid;
      tmp2 = monoeg_g_strdup_printf ("%s-%s%s", D.25347, D.25348, ".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.25349>; else goto <D.25350>;
      <D.25349>:
      mono_trace (64, 32, "AOT not found.");
      D.25341 = assembly->image;
      D.25351 = D.25341->name;
      mono_trace (32, 32, "AOT precompiling assembly \'%s\'... ", D.25351);
      aot_options = monoeg_g_strdup_printf ("outfile=%s", fname);
      spawn_compiler.33 = spawn_compiler;
      if (spawn_compiler.33 != 0) goto <D.25353>; else goto <D.25354>;
      <D.25353>:
      D.25341 = assembly->image;
      D.25351 = D.25341->name;
      cmd = monoeg_g_strdup_printf ("mono -O=all --aot=%s %s", aot_options, D.25351);
      res = monoeg_g_spawn_command_line_sync (cmd, &out, &err, &exit_status, 0B);
      monoeg_g_free (cmd);
      goto <D.25355>;
      <D.25354>:
      D.25356 = mono_parse_default_optimizations (0B);
      D.25357 = (unsigned int) D.25356;
      res = mono_compile_assembly (assembly, D.25357, aot_options);
      if (res == 0) goto <D.25358>; else goto <D.25359>;
      <D.25358>:
      mono_trace (32, 32, "AOT failed.");
      goto <D.25360>;
      <D.25359>:
      mono_trace (32, 32, "AOT succeeded.");
      <D.25360>:
      <D.25355>:
      module = mono_dl_open (fname, 1, 0B);
      monoeg_g_free (aot_options);
      <D.25350>:
      D.25346 = module;
      return D.25346;
    }
  finally
    {
      out = {CLOBBER};
      err = {CLOBBER};
      exit_status = {CLOBBER};
    }
}


create_cache_structure ()
{
  int D.25365;
  int * D.25370;
  int D.25371;
  const gchar * D.25372;
  int D.25373;
  const gchar * D.25378;
  const char * home;
  char * tmp;
  int err;

  home = monoeg_g_get_home_dir ();
  if (home == 0B) goto <D.25363>; else goto <D.25364>;
  <D.25363>:
  return;
  <D.25364>:
  tmp = monoeg_g_build_path ("/", home, ".mono", 0B);
  D.25365 = monoeg_g_file_test (tmp, 4);
  if (D.25365 == 0) goto <D.25366>; else goto <D.25367>;
  <D.25366>:
  mono_trace (64, 32, "AOT creating directory %s", tmp);
  err = mkdir (tmp, 511);
  if (err != 0) goto <D.25368>; else goto <D.25369>;
  <D.25368>:
  D.25370 = __errno_location ();
  D.25371 = *D.25370;
  D.25372 = monoeg_g_strerror (D.25371);
  mono_trace (64, 32, "AOT failed: %s", D.25372);
  monoeg_g_free (tmp);
  return;
  <D.25369>:
  <D.25367>:
  monoeg_g_free (tmp);
  tmp = monoeg_g_build_path ("/", home, ".mono", "aot-cache", 0B);
  D.25373 = monoeg_g_file_test (tmp, 4);
  if (D.25373 == 0) goto <D.25374>; else goto <D.25375>;
  <D.25374>:
  mono_trace (64, 32, "AOT creating directory %s", tmp);
  err = mkdir (tmp, 511);
  if (err != 0) goto <D.25376>; else goto <D.25377>;
  <D.25376>:
  D.25370 = __errno_location ();
  D.25371 = *D.25370;
  D.25378 = monoeg_g_strerror (D.25371);
  mono_trace (64, 32, "AOT failed: %s", D.25378);
  monoeg_g_free (tmp);
  return;
  <D.25377>:
  <D.25375>:
  monoeg_g_free (tmp);
}


check_usable (struct MonoAssembly * assembly, struct MonoAotFileInfo * info, char * * out_msg)
{
  int D.23931;
  struct MonoImage * D.25380;
  char * D.25381;
  void * D.25382;
  void * D.25385;
  char D.25386;
  int D.23940;
  unsigned int D.25391;
  int D.25392;
  int mono_aot_only.34;
  struct MonoDebugOptions * D.25402;
  int D.25403;
  unsigned int D.25406;
  unsigned int D.25411;
  unsigned int excluded_cpu_optimizations.35;
  unsigned int D.25413;
  unsigned int D.25418;
  unsigned int D.25419;
  unsigned int D.25420;
  unsigned int D.25421;
  int D.25424;
  sizetype D.25427;
  int D.23951;
  gboolean D.25430;
  char * build_info;
  char * msg;
  gboolean usable;
  gboolean full_aot;
  guint8 * blob;
  guint32 excluded_cpu_optimizations;

  try
    {
      msg = 0B;
      usable = 1;
      {
        size_t __s1_len;
        size_t __s2_len;

        D.25380 = assembly->image;
        D.25381 = D.25380->guid;
        D.25382 = info->assembly_guid;
        D.23931 = __builtin_strcmp (D.25381, D.25382);
      }
      if (D.23931 != 0) goto <D.25383>; else goto <D.25384>;
      <D.25383>:
      msg = monoeg_g_strdup_printf ("doesn\'t match assembly");
      usable = 0;
      <D.25384>:
      build_info = mono_get_runtime_build_info ();
      D.25385 = info->runtime_version;
      D.25386 = MEM[(const char *)D.25385];
      if (D.25386 != 0) goto <D.25387>; else goto <D.25388>;
      <D.25387>:
      {
        size_t __s1_len;
        size_t __s2_len;

        D.25385 = info->runtime_version;
        D.23940 = __builtin_strcmp (D.25385, build_info);
      }
      if (D.23940 != 0) goto <D.25389>; else goto <D.25390>;
      <D.25389>:
      D.25385 = info->runtime_version;
      msg = monoeg_g_strdup_printf ("compiled against runtime version \'%s\' while this runtime has version \'%s\'", D.25385, build_info);
      usable = 0;
      <D.25390>:
      <D.25388>:
      monoeg_g_free (build_info);
      D.25391 = info->flags;
      D.25392 = (int) D.25391;
      full_aot = D.25392 & 2;
      mono_aot_only.34 = mono_aot_only;
      if (mono_aot_only.34 != 0) goto <D.25394>; else goto <D.25395>;
      <D.25394>:
      if (full_aot == 0) goto <D.25396>; else goto <D.25397>;
      <D.25396>:
      msg = monoeg_g_strdup_printf ("not compiled with --aot=full");
      usable = 0;
      <D.25397>:
      <D.25395>:
      mono_aot_only.34 = mono_aot_only;
      if (mono_aot_only.34 == 0) goto <D.25398>; else goto <D.25399>;
      <D.25398>:
      if (full_aot != 0) goto <D.25400>; else goto <D.25401>;
      <D.25400>:
      msg = monoeg_g_strdup_printf ("compiled with --aot=full");
      usable = 0;
      <D.25401>:
      <D.25399>:
      D.25402 = mini_get_debug_options ();
      D.25403 = D.25402->mdb_optimizations;
      if (D.25403 != 0) goto <D.25404>; else goto <D.25405>;
      <D.25404>:
      D.25391 = info->flags;
      D.25406 = D.25391 & 4;
      if (D.25406 == 0) goto <D.25407>; else goto <D.25408>;
      <D.25407>:
      if (full_aot == 0) goto <D.25409>; else goto <D.25410>;
      <D.25409>:
      msg = monoeg_g_strdup_printf ("not compiled for debugging");
      usable = 0;
      <D.25410>:
      <D.25408>:
      <D.25405>:
      mono_arch_cpu_optimizations (&excluded_cpu_optimizations);
      D.25411 = info->opts;
      excluded_cpu_optimizations.35 = excluded_cpu_optimizations;
      D.25413 = D.25411 & excluded_cpu_optimizations.35;
      if (D.25413 != 0) goto <D.25414>; else goto <D.25415>;
      <D.25414>:
      msg = monoeg_g_strdup_printf ("compiled with unsupported CPU optimizations");
      usable = 0;
      <D.25415>:
      mono_aot_only.34 = mono_aot_only;
      if (mono_aot_only.34 == 0) goto <D.25416>; else goto <D.25417>;
      <D.25416>:
      D.25418 = info->simd_opts;
      D.25419 = mono_arch_cpu_enumerate_simd_versions ();
      D.25420 = ~D.25419;
      D.25421 = D.25418 & D.25420;
      if (D.25421 != 0) goto <D.25422>; else goto <D.25423>;
      <D.25422>:
      msg = monoeg_g_strdup_printf ("compiled with unsupported SIMD extensions");
      usable = 0;
      <D.25423>:
      <D.25417>:
      blob = info->blob;
      D.25424 = info->gc_name_index;
      if (D.25424 != -1) goto <D.25425>; else goto <D.25426>;
      <D.25425>:
      {
        char * gc_name;
        const char * current_gc_name;

        D.25424 = info->gc_name_index;
        D.25427 = (sizetype) D.25424;
        gc_name = blob + D.25427;
        current_gc_name = mono_gc_get_gc_name ();
        {
          size_t __s1_len;
          size_t __s2_len;

          D.23951 = __builtin_strcmp (current_gc_name, gc_name);
        }
        if (D.23951 != 0) goto <D.25428>; else goto <D.25429>;
        <D.25428>:
        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.25429>:
      }
      <D.25426>:
      *out_msg = msg;
      D.25430 = usable;
      return D.25430;
    }
  finally
    {
      excluded_cpu_optimizations = {CLOBBER};
    }
}


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

  if (str != 0B) goto <D.25433>; else goto <D.25434>;
  <D.25433>:
  D.25435 = __strdup (str);
  return D.25435;
  <D.25434>:
  D.25435 = 0B;
  return D.25435;
}


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

  D.25438 = __builtin_object_size (__dest, 0);
  D.25437 = __builtin___memcpy_chk (__dest, __src, __len, D.25438);
  return D.25437;
}


find_symbol (struct MonoDl * module, void * * globals, const char * name, void * * value)
{
  unsigned int D.25442;
  unsigned int D.25443;
  unsigned int D.25444;
  long unsigned int D.25445;
  long unsigned int D.25446;
  short unsigned int D.25447;
  int D.25448;
  int D.25449;
  guint16 * D.25450;
  short unsigned int D.25451;
  int D.23907;
  unsigned int D.25452;
  long unsigned int D.25453;
  long unsigned int D.25454;
  void * * D.25455;
  void * D.25456;
  unsigned int D.25460;
  long unsigned int D.25461;
  long unsigned int D.25462;
  int D.25465;
  sizetype D.25466;
  sizetype D.25467;
  sizetype D.25468;
  void * * D.25469;
  void * D.25470;

  if (globals != 0B) goto <D.25440>; else goto <D.25441>;
  <D.25440>:
  {
    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.25442 = mono_metadata_str_hash (symbol);
    D.25443 = (unsigned int) table_size;
    hash = D.25442 % D.25443;
    D.25444 = hash * 2;
    D.25445 = (long unsigned int) D.25444;
    D.25446 = D.25445 * 2;
    entry = table + D.25446;
    global_index = -1;
    goto <D.23910>;
    <D.23909>:
    {
      guint32 index;
      guint32 next;

      D.25447 = *entry;
      D.25448 = (int) D.25447;
      D.25449 = D.25448 + -1;
      index = (guint32) D.25449;
      D.25450 = entry + 2;
      D.25451 = *D.25450;
      next = (guint32) D.25451;
      {
        size_t __s1_len;
        size_t __s2_len;

        D.25452 = index * 2;
        D.25453 = (long unsigned int) D.25452;
        D.25454 = D.25453 * 8;
        D.25455 = globals + D.25454;
        D.25456 = *D.25455;
        D.23907 = __builtin_strcmp (D.25456, symbol);
      }
      if (D.23907 == 0) goto <D.25457>; else goto <D.25458>;
      <D.25457>:
      global_index = (int) index;
      goto <D.23908>;
      <D.25458>:
      if (next != 0) goto <D.25459>; else goto <D.23908>;
      <D.25459>:
      D.25460 = next * 2;
      D.25461 = (long unsigned int) D.25460;
      D.25462 = D.25461 * 2;
      entry = table + D.25462;
    }
    <D.23910>:
    D.25447 = *entry;
    if (D.25447 != 0) goto <D.23909>; else goto <D.23908>;
    <D.23908>:
    if (global_index != -1) goto <D.25463>; else goto <D.25464>;
    <D.25463>:
    D.25465 = global_index * 2;
    D.25466 = (sizetype) D.25465;
    D.25467 = D.25466 + 1;
    D.25468 = D.25467 * 8;
    D.25469 = globals + D.25468;
    D.25470 = *D.25469;
    *value = D.25470;
    goto <D.25471>;
    <D.25464>:
    *value = 0B;
    <D.25471>:
    if (symbol != name) goto <D.25472>; else goto <D.25473>;
    <D.25472>:
    monoeg_g_free (symbol);
    <D.25473>:
  }
  goto <D.25474>;
  <D.25441>:
  {
    char * err;

    err = mono_dl_symbol (module, name, value);
    if (err != 0B) goto <D.25475>; else goto <D.25476>;
    <D.25475>:
    monoeg_g_free (err);
    <D.25476>:
  }
  <D.25474>:
}


memset (void * __dest, int __ch, size_t __len)
{
  int D.25479;
  int D.25484;
  void * D.25486;
  long unsigned int D.25487;

  D.25479 = __builtin_constant_p (__len);
  if (D.25479 != 0) goto <D.25480>; else goto <D.25481>;
  <D.25480>:
  if (__len == 0) goto <D.25482>; else goto <D.25483>;
  <D.25482>:
  D.25484 = __builtin_constant_p (__ch);
  if (D.25484 == 0) goto <D.25477>; else goto <D.25485>;
  <D.25485>:
  if (__ch != 0) goto <D.25477>; else goto <D.25478>;
  <D.25477>:
  __warn_memset_zero_len ();
  D.25486 = __dest;
  return D.25486;
  <D.25478>:
  <D.25483>:
  <D.25481>:
  D.25487 = __builtin_object_size (__dest, 0);
  D.25486 = __builtin___memset_chk (__dest, __ch, __len, D.25487);
  return D.25486;
}


load_image (struct MonoAotModule * amodule, int index, gboolean set_error)
{
  unsigned int index.36;
  unsigned int D.25490;
  _Bool D.25491;
  long int D.25492;
  long int D.25493;
  struct MonoImage * * D.25496;
  long unsigned int D.25497;
  long unsigned int D.25498;
  struct MonoImage * * D.25499;
  struct MonoImage * D.25500;
  struct MonoImage * D.25503;
  int D.25504;
  struct MonoAssemblyName * D.25507;
  long unsigned int D.25508;
  struct MonoAssemblyName * D.25509;
  struct MonoAssembly * D.25510;
  char * D.25511;
  char * D.25514;
  const char * D.25515;
  int D.23526;
  struct MonoImage * D.25518;
  char * D.25519;
  char * * D.25520;
  char * * D.25521;
  char * D.25522;
  struct MonoAssembly * assembly;
  MonoImageOpenStatus status;

  try
    {
      index.36 = (unsigned int) index;
      D.25490 = amodule->image_table_len;
      D.25491 = index.36 >= D.25490;
      D.25492 = (long int) D.25491;
      D.25493 = __builtin_expect (D.25492, 0);
      if (D.25493 != 0) goto <D.25494>; else goto <D.25495>;
      <D.25494>:
      monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "aot-runtime.c", 223, "index < amodule->image_table_len");
      <D.25495>:
      D.25496 = amodule->image_table;
      D.25497 = (long unsigned int) index;
      D.25498 = D.25497 * 8;
      D.25499 = D.25496 + D.25498;
      D.25500 = *D.25499;
      if (D.25500 != 0B) goto <D.25501>; else goto <D.25502>;
      <D.25501>:
      D.25496 = amodule->image_table;
      D.25497 = (long unsigned int) index;
      D.25498 = D.25497 * 8;
      D.25499 = D.25496 + D.25498;
      D.25503 = *D.25499;
      return D.25503;
      <D.25502>:
      D.25504 = amodule->out_of_date;
      if (D.25504 != 0) goto <D.25505>; else goto <D.25506>;
      <D.25505>:
      D.25503 = 0B;
      return D.25503;
      <D.25506>:
      D.25507 = amodule->image_names;
      D.25497 = (long unsigned int) index;
      D.25508 = D.25497 * 80;
      D.25509 = D.25507 + D.25508;
      D.25510 = amodule->assembly;
      D.25511 = D.25510->basedir;
      assembly = mono_assembly_load (D.25509, D.25511, &status);
      if (assembly == 0B) goto <D.25512>; else goto <D.25513>;
      <D.25512>:
      D.25514 = amodule->aot_name;
      D.25507 = amodule->image_names;
      D.25497 = (long unsigned int) index;
      D.25508 = D.25497 * 80;
      D.25509 = D.25507 + D.25508;
      D.25515 = D.25509->name;
      mono_trace (64, 32, "AOT module %s is unusable because dependency %s is not found.\n", D.25514, D.25515);
      amodule->out_of_date = 1;
      if (set_error != 0) goto <D.25516>; else goto <D.25517>;
      <D.25516>:
      {
        char * full_name;

        D.25507 = amodule->image_names;
        D.25497 = (long unsigned int) index;
        D.25508 = D.25497 * 80;
        D.25509 = D.25507 + D.25508;
        full_name = mono_stringify_assembly_name (D.25509);
        mono_loader_set_error_assembly_load (full_name, 0);
        monoeg_g_free (full_name);
      }
      <D.25517>:
      D.25503 = 0B;
      return D.25503;
      <D.25513>:
      {
        size_t __s1_len;
        size_t __s2_len;

        D.25518 = assembly->image;
        D.25519 = D.25518->guid;
        D.25520 = amodule->image_guids;
        D.25497 = (long unsigned int) index;
        D.25498 = D.25497 * 8;
        D.25521 = D.25520 + D.25498;
        D.25522 = *D.25521;
        D.23526 = __builtin_strcmp (D.25519, D.25522);
      }
      if (D.23526 != 0) goto <D.25523>; else goto <D.25524>;
      <D.25523>:
      D.25514 = amodule->aot_name;
      D.25507 = amodule->image_names;
      D.25497 = (long unsigned int) index;
      D.25508 = D.25497 * 80;
      D.25509 = D.25507 + D.25508;
      D.25515 = D.25509->name;
      D.25520 = amodule->image_guids;
      D.25497 = (long unsigned int) index;
      D.25498 = D.25497 * 8;
      D.25521 = D.25520 + D.25498;
      D.25522 = *D.25521;
      D.25518 = assembly->image;
      D.25519 = D.25518->guid;
      mono_trace (64, 32, "AOT module %s is unusable (GUID of dependent assembly %s doesn\'t match (expected \'%s\', got \'%s\').\n", D.25514, D.25515, D.25522, D.25519);
      amodule->out_of_date = 1;
      D.25503 = 0B;
      return D.25503;
      <D.25524>:
      D.25496 = amodule->image_table;
      D.25497 = (long unsigned int) index;
      D.25498 = D.25497 * 8;
      D.25499 = D.25496 + D.25498;
      D.25518 = assembly->image;
      *D.25499 = D.25518;
      D.25503 = assembly->image;
      return D.25503;
    }
  finally
    {
      status = {CLOBBER};
    }
}


fprintf (struct FILE * restrict __stream, const char * restrict __fmt)
{
  int D.25527;

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


atoi (const char * __nptr)
{
  int D.25529;
  long int D.25530;

  D.25530 = strtol (__nptr, 0B, 10);
  D.25529 = (int) D.25530;
  return D.25529;
}


mono_aot_cleanup ()
{
  struct GHashTable * aot_jit_icall_hash.37;
  struct GHashTable * aot_modules.38;

  aot_jit_icall_hash.37 = aot_jit_icall_hash;
  if (aot_jit_icall_hash.37 != 0B) goto <D.25533>; else goto <D.25534>;
  <D.25533>:
  aot_jit_icall_hash.37 = aot_jit_icall_hash;
  monoeg_g_hash_table_destroy (aot_jit_icall_hash.37);
  <D.25534>:
  aot_modules.38 = aot_modules;
  if (aot_modules.38 != 0B) goto <D.25536>; else goto <D.25537>;
  <D.25536>:
  aot_modules.38 = aot_modules;
  monoeg_g_hash_table_destroy (aot_modules.38);
  <D.25537>:
}


mono_aot_get_method_from_vt_slot (struct MonoDomain * domain, struct MonoVTable * vtable, int slot)
{
  struct MonoImage * D.25538;
  unsigned int D.25541;
  unsigned int D.25542;
  unsigned char D.25544;
  unsigned char D.25547;
  void * D.25549;
  guint8 * D.25550;
  guint32 * D.25551;
  unsigned int D.25552;
  unsigned int D.25553;
  unsigned int D.25554;
  int D.25555;
  unsigned int D.25556;
  sizetype D.25557;
  guint8 * p.39;
  int D.25563;
  unsigned int D.25568;
  unsigned int D.25569;
  unsigned int D.25571;
  struct MonoImage * D.25572;
  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.25538 = klass->image;
      amodule = D.25538->aot_module;
      D.25541 = klass->flags;
      D.25542 = D.25541 & 32;
      if (D.25542 != 0) goto <D.25539>; else goto <D.25543>;
      <D.25543>:
      D.25544 = klass->byval_arg.type;
      if (D.25544 == 19) goto <D.25539>; else goto <D.25545>;
      <D.25545>:
      D.25544 = klass->byval_arg.type;
      if (D.25544 == 30) goto <D.25539>; else goto <D.25546>;
      <D.25546>:
      D.25547 = klass->rank;
      if (D.25547 != 0) goto <D.25539>; else goto <D.25548>;
      <D.25548>:
      if (amodule == 0B) goto <D.25539>; else goto <D.25540>;
      <D.25539>:
      D.25549 = 0B;
      return D.25549;
      <D.25540>:
      D.25550 = amodule->blob;
      D.25551 = amodule->class_info_offsets;
      D.25552 = klass->type_token;
      D.25553 = D.25552 & 16777215;
      D.25554 = D.25553 + 4294967295;
      D.25555 = (int) D.25554;
      D.25556 = mono_aot_get_offset (D.25551, D.25555);
      D.25557 = (sizetype) D.25556;
      info = D.25550 + D.25557;
      p = info;
      p.39 = p;
      err = decode_cached_class_info (amodule, &class_info, p.39, &p);
      if (err == 0) goto <D.25559>; else goto <D.25560>;
      <D.25559>:
      D.25549 = 0B;
      return D.25549;
      <D.25560>:
      i = 0;
      goto <D.24037>;
      <D.24036>:
      p.39 = p;
      decode_method_ref (amodule, &ref, p.39, &p);
      i = i + 1;
      <D.24037>:
      if (i < slot) goto <D.24036>; else goto <D.24038>;
      <D.24038>:
      p.39 = p;
      res = decode_method_ref (amodule, &ref, p.39, &p);
      if (res == 0) goto <D.25561>; else goto <D.25562>;
      <D.25561>:
      D.25549 = 0B;
      return D.25549;
      <D.25562>:
      D.25563 = ref.no_aot_trampoline;
      if (D.25563 != 0) goto <D.25564>; else goto <D.25565>;
      <D.25564>:
      D.25549 = 0B;
      return D.25549;
      <D.25565>:
      D.25568 = ref.token;
      D.25569 = D.25568 & 16777215;
      if (D.25569 == 0) goto <D.25566>; else goto <D.25570>;
      <D.25570>:
      D.25568 = ref.token;
      D.25571 = D.25568 >> 24;
      if (D.25571 != 6) goto <D.25566>; else goto <D.25567>;
      <D.25566>:
      D.25549 = 0B;
      return D.25549;
      <D.25567>:
      D.25572 = ref.image;
      D.25568 = ref.token;
      D.25549 = mono_aot_get_method_from_token (domain, D.25572, D.25568);
      return D.25549;
    }
  finally
    {
      p = {CLOBBER};
      class_info = {CLOBBER};
      ref = {CLOBBER};
    }
}


mono_aot_get_offset (guint32 * table, int index)
{
  unsigned int D.25575;
  guint32 * D.25576;
  unsigned int D.25577;
  guint32 * D.25578;
  unsigned int D.25579;
  guint32 * D.25580;
  unsigned int D.25581;
  long unsigned int D.25584;
  long unsigned int D.25585;
  long unsigned int D.25586;
  long unsigned int D.25587;
  guint16 * D.25588;
  short unsigned int D.25589;
  sizetype D.25590;
  guint8 * p.40;
  long unsigned int D.25593;
  long unsigned int D.25594;
  guint32 * D.25595;
  unsigned int D.25596;
  sizetype D.25597;
  guint8 * p.41;
  guint8 * p.42;
  int D.25600;
  int D.25601;
  guint32 D.25602;
  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.25575 = *table;
      noffsets = (int) D.25575;
      D.25576 = table + 4;
      D.25577 = *D.25576;
      group_size = (int) D.25577;
      D.25578 = table + 8;
      D.25579 = *D.25578;
      ngroups = (int) D.25579;
      D.25580 = table + 12;
      D.25581 = *D.25580;
      index_entry_size = (int) D.25581;
      group = index / group_size;
      if (index_entry_size == 2) goto <D.25582>; else goto <D.25583>;
      <D.25582>:
      index16 = table + 16;
      D.25584 = (long unsigned int) ngroups;
      D.25585 = D.25584 * 2;
      data_start = index16 + D.25585;
      D.25586 = (long unsigned int) group;
      D.25587 = D.25586 * 2;
      D.25588 = index16 + D.25587;
      D.25589 = *D.25588;
      D.25590 = (sizetype) D.25589;
      p.40 = data_start + D.25590;
      p = p.40;
      goto <D.25592>;
      <D.25583>:
      index32 = table + 16;
      D.25584 = (long unsigned int) ngroups;
      D.25593 = D.25584 * 4;
      data_start = index32 + D.25593;
      D.25586 = (long unsigned int) group;
      D.25594 = D.25586 * 4;
      D.25595 = index32 + D.25594;
      D.25596 = *D.25595;
      D.25597 = (sizetype) D.25596;
      p.41 = data_start + D.25597;
      p = p.41;
      <D.25592>:
      p.42 = p;
      start_offset = decode_value (p.42, &p);
      offset = start_offset;
      D.25600 = group * group_size;
      i = D.25600 + 1;
      goto <D.23550>;
      <D.23549>:
      p.42 = p;
      D.25601 = decode_value (p.42, &p);
      offset = D.25601 + offset;
      i = i + 1;
      <D.23550>:
      if (i <= index) goto <D.23549>; else goto <D.23551>;
      <D.23551>:
      D.25602 = (guint32) offset;
      return D.25602;
    }
  finally
    {
      p = {CLOBBER};
    }
}


decode_value (guint8 * ptr, guint8 * * rptr)
{
  signed char b.43;
  int D.25609;
  int D.25610;
  int D.25613;
  int D.25614;
  guint8 * D.25615;
  unsigned char D.25616;
  int D.25617;
  int D.25621;
  int D.25622;
  int D.25623;
  int D.25624;
  guint8 * D.25625;
  unsigned char D.25626;
  int D.25627;
  int D.25628;
  int D.25629;
  guint8 * D.25630;
  unsigned char D.25631;
  int D.25632;
  int D.25634;
  int D.25635;
  int D.25636;
  int D.25637;
  int D.25638;
  guint8 * D.25639;
  unsigned char D.25640;
  int D.25641;
  gint32 D.25644;
  guint8 b;
  gint32 len;

  b = *ptr;
  b.43 = (signed char) b;
  if (b.43 >= 0) goto <D.25606>; else goto <D.25607>;
  <D.25606>:
  len = (gint32) b;
  ptr = ptr + 1;
  goto <D.25608>;
  <D.25607>:
  D.25609 = (int) b;
  D.25610 = D.25609 & 64;
  if (D.25610 == 0) goto <D.25611>; else goto <D.25612>;
  <D.25611>:
  D.25609 = (int) b;
  D.25613 = D.25609 & 63;
  D.25614 = D.25613 << 8;
  D.25615 = ptr + 1;
  D.25616 = *D.25615;
  D.25617 = (int) D.25616;
  len = D.25614 | D.25617;
  ptr = ptr + 2;
  goto <D.25618>;
  <D.25612>:
  if (b != 255) goto <D.25619>; else goto <D.25620>;
  <D.25619>:
  D.25609 = (int) b;
  D.25621 = D.25609 & 31;
  D.25622 = D.25621 << 24;
  D.25615 = ptr + 1;
  D.25616 = *D.25615;
  D.25617 = (int) D.25616;
  D.25623 = D.25617 << 16;
  D.25624 = D.25622 | D.25623;
  D.25625 = ptr + 2;
  D.25626 = *D.25625;
  D.25627 = (int) D.25626;
  D.25628 = D.25627 << 8;
  D.25629 = D.25624 | D.25628;
  D.25630 = ptr + 3;
  D.25631 = *D.25630;
  D.25632 = (int) D.25631;
  len = D.25629 | D.25632;
  ptr = ptr + 4;
  goto <D.25633>;
  <D.25620>:
  D.25615 = ptr + 1;
  D.25616 = *D.25615;
  D.25617 = (int) D.25616;
  D.25634 = D.25617 << 24;
  D.25625 = ptr + 2;
  D.25626 = *D.25625;
  D.25627 = (int) D.25626;
  D.25635 = D.25627 << 16;
  D.25636 = D.25634 | D.25635;
  D.25630 = ptr + 3;
  D.25631 = *D.25630;
  D.25632 = (int) D.25631;
  D.25637 = D.25632 << 8;
  D.25638 = D.25636 | D.25637;
  D.25639 = ptr + 4;
  D.25640 = *D.25639;
  D.25641 = (int) D.25640;
  len = D.25638 | D.25641;
  ptr = ptr + 5;
  <D.25633>:
  <D.25618>:
  <D.25608>:
  if (rptr != 0B) goto <D.25642>; else goto <D.25643>;
  <D.25642>:
  *rptr = ptr;
  <D.25643>:
  D.25644 = len;
  return D.25644;
}


decode_cached_class_info (struct MonoAotModule * module, struct MonoCachedClassInfo * info, guint8 * buf, guint8 * * endbuf)
{
  guint8 * buf.44;
  int D.25647;
  unsigned int D.25648;
  unsigned int D.25649;
  gboolean D.25652;
  int D.25653;
  unsigned char D.25654;
  <unnamed-unsigned:1> D.25655;
  unsigned int D.25656;
  unsigned char D.25657;
  <unnamed-unsigned:1> D.25658;
  unsigned int D.25659;
  unsigned char D.25660;
  <unnamed-unsigned:1> D.25661;
  unsigned int D.25662;
  unsigned char D.25663;
  <unnamed-unsigned:1> D.25664;
  unsigned int D.25665;
  unsigned char D.25666;
  <unnamed-unsigned:1> D.25667;
  unsigned int D.25668;
  unsigned char D.25669;
  <unnamed-unsigned:1> D.25670;
  unsigned int D.25671;
  unsigned char D.25672;
  <unnamed-unsigned:1> D.25673;
  unsigned int D.25674;
  unsigned char D.25675;
  <unnamed-unsigned:1> D.25676;
  unsigned int D.25677;
  unsigned char D.25678;
  <unnamed-unsigned:1> D.25679;
  long unsigned int D.25680;
  long unsigned int D.25681;
  unsigned int D.25686;
  long unsigned int D.25687;
  struct MonoImage * D.25692;
  int D.25693;
  unsigned int D.25694;
  int D.25695;
  unsigned int D.25696;
  int D.25697;
  unsigned int D.25698;
  int D.25699;
  unsigned int D.25700;
  guint32 flags;
  struct MethodRef ref;
  gboolean res;

  try
    {
      buf.44 = buf;
      D.25647 = decode_value (buf.44, &buf);
      D.25648 = (unsigned int) D.25647;
      info->vtable_size = D.25648;
      D.25649 = info->vtable_size;
      if (D.25649 == 4294967295) goto <D.25650>; else goto <D.25651>;
      <D.25650>:
      D.25652 = 0;
      return D.25652;
      <D.25651>:
      buf.44 = buf;
      D.25653 = decode_value (buf.44, &buf);
      flags = (guint32) D.25653;
      D.25654 = (unsigned char) flags;
      D.25655 = (<unnamed-unsigned:1>) D.25654;
      info->ghcimpl = D.25655;
      D.25656 = flags >> 1;
      D.25657 = (unsigned char) D.25656;
      D.25658 = (<unnamed-unsigned:1>) D.25657;
      info->has_finalize = D.25658;
      D.25659 = flags >> 2;
      D.25660 = (unsigned char) D.25659;
      D.25661 = (<unnamed-unsigned:1>) D.25660;
      info->has_cctor = D.25661;
      D.25662 = flags >> 3;
      D.25663 = (unsigned char) D.25662;
      D.25664 = (<unnamed-unsigned:1>) D.25663;
      info->has_nested_classes = D.25664;
      D.25665 = flags >> 4;
      D.25666 = (unsigned char) D.25665;
      D.25667 = (<unnamed-unsigned:1>) D.25666;
      info->blittable = D.25667;
      D.25668 = flags >> 5;
      D.25669 = (unsigned char) D.25668;
      D.25670 = (<unnamed-unsigned:1>) D.25669;
      info->has_references = D.25670;
      D.25671 = flags >> 6;
      D.25672 = (unsigned char) D.25671;
      D.25673 = (<unnamed-unsigned:1>) D.25672;
      info->has_static_refs = D.25673;
      D.25674 = flags >> 7;
      D.25675 = (unsigned char) D.25674;
      D.25676 = (<unnamed-unsigned:1>) D.25675;
      info->no_special_static_fields = D.25676;
      D.25677 = flags >> 8;
      D.25678 = (unsigned char) D.25677;
      D.25679 = (<unnamed-unsigned:1>) D.25678;
      info->is_generic_container = D.25679;
      D.25680 = BIT_FIELD_REF <*info, 64, 0>;
      D.25681 = D.25680 & 17179869184;
      if (D.25681 != 0) goto <D.25682>; else goto <D.25683>;
      <D.25682>:
      buf.44 = buf;
      res = decode_method_ref (module, &ref, buf.44, &buf);
      if (res == 0) goto <D.25684>; else goto <D.25685>;
      <D.25684>:
      D.25652 = 0;
      return D.25652;
      <D.25685>:
      D.25686 = ref.token;
      info->cctor_token = D.25686;
      <D.25683>:
      D.25680 = BIT_FIELD_REF <*info, 64, 0>;
      D.25687 = D.25680 & 4294967296;
      if (D.25687 != 0) goto <D.25688>; else goto <D.25689>;
      <D.25688>:
      buf.44 = buf;
      res = decode_method_ref (module, &ref, buf.44, &buf);
      if (res == 0) goto <D.25690>; else goto <D.25691>;
      <D.25690>:
      D.25652 = 0;
      return D.25652;
      <D.25691>:
      D.25692 = ref.image;
      info->finalize_image = D.25692;
      D.25686 = ref.token;
      info->finalize_token = D.25686;
      <D.25689>:
      buf.44 = buf;
      D.25693 = decode_value (buf.44, &buf);
      D.25694 = (unsigned int) D.25693;
      info->instance_size = D.25694;
      buf.44 = buf;
      D.25695 = decode_value (buf.44, &buf);
      D.25696 = (unsigned int) D.25695;
      info->class_size = D.25696;
      buf.44 = buf;
      D.25697 = decode_value (buf.44, &buf);
      D.25698 = (unsigned int) D.25697;
      info->packing_size = D.25698;
      buf.44 = buf;
      D.25699 = decode_value (buf.44, &buf);
      D.25700 = (unsigned int) D.25699;
      info->min_align = D.25700;
      buf.44 = buf;
      *endbuf = buf.44;
      D.25652 = 1;
      return D.25652;
    }
  finally
    {
      ref = {CLOBBER};
    }
}


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

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


decode_method_ref_with_target (struct MonoAotModule * module, struct MethodRef * ref, struct MonoMethod * target, guint8 * buf, guint8 * * endbuf)
{
  guint8 * p.45;
  int D.25706;
  int D.25709;
  long unsigned int D.25716;
  long unsigned int D.25717;
  gboolean D.25720;
  int D.25723;
  <unnamed-unsigned:5> D.25726;
  unsigned int D.25727;
  struct MonoClass * D.25732;
  struct MonoMethod * D.25733;
  struct MonoMethod * D.25736;
  struct MonoType * D.25741;
  struct MonoMethod * D.25742;
  struct MonoMethod * D.25746;
  struct MonoMethod * D.25750;
  struct MonoMethod * D.25754;
  struct MonoMethod * D.25756;
  struct MonoMethod * D.25757;
  struct MonoMethod * D.25758;
  struct MonoMethod * D.25759;
  _Bool D.25760;
  long int D.25761;
  long int D.25762;
  struct MonoMethod * D.25765;
  struct MonoMethod * D.25768;
  _Bool D.25776;
  long int D.25777;
  long int D.25778;
  <unnamed type> D.25783;
  unsigned int subtype.46;
  int D.25786;
  struct MonoMethod * D.25792;
  unsigned int subtype.47;
  unsigned int D.25794;
  struct MonoClass * D.25801;
  int D.23769;
  int iftmp.48;
  int D.23768;
  const char[15] * D.25809;
  unsigned char D.25810;
  int D.25811;
  unsigned char D.25812;
  int D.25813;
  const unsigned char * D.25818;
  unsigned char D.25819;
  int D.25820;
  const unsigned char * D.25821;
  unsigned char D.25822;
  int D.25823;
  const unsigned char * D.25828;
  unsigned char D.25829;
  int D.25830;
  const unsigned char * D.25831;
  unsigned char D.25832;
  int D.25833;
  const unsigned char * D.25838;
  unsigned char D.25839;
  int D.25840;
  const unsigned char * D.25841;
  unsigned char D.25842;
  int D.25843;
  const char * D.25845;
  struct MonoMethod * D.25848;
  int D.23778;
  int iftmp.49;
  int D.23777;
  const char[15] * D.25853;
  unsigned char D.25854;
  int D.25855;
  unsigned char D.25856;
  int D.25857;
  const unsigned char * D.25862;
  unsigned char D.25863;
  int D.25864;
  const unsigned char * D.25865;
  unsigned char D.25866;
  int D.25867;
  const unsigned char * D.25872;
  unsigned char D.25873;
  int D.25874;
  const unsigned char * D.25875;
  unsigned char D.25876;
  int D.25877;
  const unsigned char * D.25882;
  unsigned char D.25883;
  int D.25884;
  const unsigned char * D.25885;
  unsigned char D.25886;
  int D.25887;
  struct MonoMethod * D.25891;
  struct MonoMethod * D.25897;
  struct MonoMethod * D.25903;
  struct MonoMethod * D.25907;
  struct MonoMethod * D.25911;
  struct MonoClass * D.25922;
  _Bool D.25923;
  long int D.25924;
  long int D.25925;
  struct MonoMethod * D.25928;
  struct MonoMethod * D.25931;
  _Bool D.25939;
  long int D.25940;
  long int D.25941;
  <unnamed type> D.25947;
  unsigned int subtype.50;
  struct MonoMethod * D.25950;
  int D.23799;
  struct MonoMethod * D.25963;
  struct MonoMethod * D.25969;
  struct MonoMethod * D.25973;
  int D.23812;
  int iftmp.51;
  int D.23811;
  const char[23] * D.25982;
  unsigned char D.25983;
  int D.25984;
  unsigned char D.25985;
  int D.25986;
  const unsigned char * D.25991;
  unsigned char D.25992;
  int D.25993;
  const unsigned char * D.25994;
  unsigned char D.25995;
  int D.25996;
  const unsigned char * D.26001;
  unsigned char D.26002;
  int D.26003;
  const unsigned char * D.26004;
  unsigned char D.26005;
  int D.26006;
  const unsigned char * D.26011;
  unsigned char D.26012;
  int D.26013;
  const unsigned char * D.26014;
  unsigned char D.26015;
  int D.26016;
  struct MonoMethod * D.26025;
  struct MonoMethod * D.26031;
  _Bool D.26033;
  long int D.26034;
  long int D.26035;
  <unnamed type> D.26038;
  unsigned int subtype.52;
  struct MonoMethodSignature * D.26042;
  _Bool D.26043;
  long int D.26044;
  long int D.26045;
  int D.26048;
  int D.26065;
  <unnamed type> D.26068;
  int D.26074;
  struct MonoMethod * D.26082;
  int D.26086;
  int D.26087;
  unsigned int D.26088;
  int image_index.53;
  int D.26101;
  int D.26102;
  unsigned int D.26103;
  unsigned int D.26106;
  struct MonoMethod * D.26107;
  struct MonoGenericClass * D.26112;
  struct MonoGenericInst * D.26113;
  struct MonoMethod * D.26114;
  int D.26115;
  struct MonoMethod * D.26118;
  unsigned char D.26124;
  int D.26125;
  struct MonoMethod * D.26126;
  int D.26127;
  struct MonoMethod * D.26128;
  struct MonoMethod * D.26129;
  struct MonoMethod * D.26130;
  struct MonoMethod * D.26131;
  int D.26135;
  int D.26136;
  unsigned int D.26137;
  unsigned int D.26138;
  guint32 image_index;
  guint32 value;
  struct MonoImage * image;
  guint8 * p;

  try
    {
      image = 0B;
      p = buf;
      memset (ref, 0, 32);
      p.45 = p;
      D.25706 = decode_value (p.45, &p);
      value = (guint32) D.25706;
      image_index = value >> 24;
      if (image_index == 251) goto <D.25707>; else goto <D.25708>;
      <D.25707>:
      ref->no_aot_trampoline = 1;
      p.45 = p;
      D.25709 = decode_value (p.45, &p);
      value = (guint32) D.25709;
      image_index = value >> 24;
      <D.25708>:
      if (image_index <= 239) goto <D.25710>; else goto <D.25712>;
      <D.25712>:
      if (image_index == 254) goto <D.25710>; else goto <D.25713>;
      <D.25713>:
      if (image_index == 253) goto <D.25710>; else goto <D.25711>;
      <D.25710>:
      if (target != 0B) goto <D.25714>; else goto <D.25715>;
      <D.25714>:
      D.25716 = BIT_FIELD_REF <*target, 64, 256>;
      D.25717 = D.25716 & 124;
      if (D.25717 != 0) goto <D.25718>; else goto <D.25719>;
      <D.25718>:
      D.25720 = 0;
      return D.25720;
      <D.25719>:
      <D.25715>:
      <D.25711>:
      if (image_index == 252) goto <D.25721>; else goto <D.25722>;
      <D.25721>:
      {
        guint32 wrapper_type;

        p.45 = p;
        D.25723 = decode_value (p.45, &p);
        wrapper_type = (guint32) D.25723;
        if (target != 0B) goto <D.25724>; else goto <D.25725>;
        <D.25724>:
        D.25726 = target->wrapper_type;
        D.25727 = (unsigned int) D.25726;
        if (D.25727 != wrapper_type) goto <D.25728>; else goto <D.25729>;
        <D.25728>:
        D.25720 = 0;
        return D.25720;
        <D.25729>:
        <D.25725>:
        image = mono_defaults.corlib;
        switch (wrapper_type) <default: <D.23834>, case 1: <D.23817>, case 2: <D.23818>, case 3: <D.23819>, case 4: <D.23802>, case 5: <D.23831>, case 6: <D.23787>, case 7: <D.23781>, case 9: <D.23735>, case 12: <D.23740>, case 13: <D.23742>, case 14: <D.23745>, case 15: <D.23746>, case 16: <D.23754>, case 18: <D.23743>, case 19: <D.23800>, case 20: <D.23738>, case 21: <D.23750>, case 23: <D.23741>, case 24: <D.23749>, case 25: <D.23756>, case 28: <D.23747>>
        <D.23735>:
        {
          struct MonoMethod * m;

          p.45 = p;
          m = decode_resolve_method_ref (module, p.45, &p);
          if (m == 0B) goto <D.25730>; else goto <D.25731>;
          <D.25730>:
          D.25720 = 0;
          return D.25720;
          <D.25731>:
          D.25732 = m->klass;
          mono_class_init (D.25732);
          D.25733 = mono_marshal_get_remoting_invoke_with_check (m);
          ref->method = D.25733;
          goto <D.23737>;
        }
        <D.23738>:
        {
          struct MonoClass * klass;

          p.45 = p;
          klass = decode_klass_ref (module, p.45, &p);
          if (klass == 0B) goto <D.25734>; else goto <D.25735>;
          <D.25734>:
          D.25720 = 0;
          return D.25720;
          <D.25735>:
          D.25736 = mono_marshal_get_proxy_cancast (klass);
          ref->method = D.25736;
          goto <D.23737>;
        }
        <D.23740>:
        <D.23741>:
        <D.23742>:
        <D.23743>:
        {
          struct MonoClass * klass;

          p.45 = p;
          klass = decode_klass_ref (module, p.45, &p);
          if (klass == 0B) goto <D.25737>; else goto <D.25738>;
          <D.25737>:
          D.25720 = 0;
          return D.25720;
          <D.25738>:
          if (wrapper_type == 12) goto <D.25739>; else goto <D.25740>;
          <D.25739>:
          D.25741 = &klass->byval_arg;
          D.25742 = mono_marshal_get_ldfld_wrapper (D.25741);
          ref->method = D.25742;
          goto <D.25743>;
          <D.25740>:
          if (wrapper_type == 23) goto <D.25744>; else goto <D.25745>;
          <D.25744>:
          D.25741 = &klass->byval_arg;
          D.25746 = mono_marshal_get_ldflda_wrapper (D.25741);
          ref->method = D.25746;
          goto <D.25747>;
          <D.25745>:
          if (wrapper_type == 13) goto <D.25748>; else goto <D.25749>;
          <D.25748>:
          D.25741 = &klass->byval_arg;
          D.25750 = mono_marshal_get_stfld_wrapper (D.25741);
          ref->method = D.25750;
          goto <D.25751>;
          <D.25749>:
          if (wrapper_type == 18) goto <D.25752>; else goto <D.25753>;
          <D.25752>:
          D.25754 = mono_marshal_get_isinst (klass);
          ref->method = D.25754;
          goto <D.25755>;
          <D.25753>:
          monoeg_assertion_message ("* Assertion: should not be reached at %s:%d\n", "aot-runtime.c", 831);
          <D.25755>:
          <D.25751>:
          <D.25747>:
          <D.25743>:
          goto <D.23737>;
        }
        <D.23745>:
        D.25756 = mono_marshal_get_ldfld_remote_wrapper (0B);
        ref->method = D.25756;
        goto <D.23737>;
        <D.23746>:
        D.25757 = mono_marshal_get_stfld_remote_wrapper (0B);
        ref->method = D.25757;
        goto <D.23737>;
        <D.23747>:
        {
          int atype;

          p.45 = p;
          atype = decode_value (p.45, &p);
          D.25758 = mono_gc_get_managed_allocator_by_type (atype);
          ref->method = D.25758;
          D.25759 = ref->method;
          D.25760 = D.25759 == 0B;
          D.25761 = (long int) D.25760;
          D.25762 = __builtin_expect (D.25761, 0);
          if (D.25762 != 0) goto <D.25763>; else goto <D.25764>;
          <D.25763>:
          monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "aot-runtime.c", 845, "ref->method");
          <D.25764>:
          goto <D.23737>;
        }
        <D.23749>:
        D.25765 = mono_gc_get_write_barrier ();
        ref->method = D.25765;
        goto <D.23737>;
        <D.23750>:
        {
          int subtype;

          p.45 = p;
          subtype = decode_value (p.45, &p);
          if (subtype == 0) goto <D.25766>; else goto <D.25767>;
          <D.25766>:
          D.25768 = mono_marshal_get_stelemref ();
          ref->method = D.25768;
          goto <D.25769>;
          <D.25767>:
          if (subtype == 3) goto <D.25770>; else goto <D.25771>;
          <D.25770>:
          {
            int kind;
            struct WrapperInfo * info;

            p.45 = p;
            kind = decode_value (p.45, &p);
            if (target == 0B) goto <D.25772>; else goto <D.25773>;
            <D.25772>:
            D.25720 = 0;
            return D.25720;
            <D.25773>:
            D.25716 = BIT_FIELD_REF <*target, 64, 256>;
            D.25717 = D.25716 & 124;
            if (D.25717 == 84) goto <D.25774>; else goto <D.25775>;
            <D.25774>:
            info = mono_marshal_get_wrapper_info (target);
            D.25776 = info == 0B;
            D.25777 = (long int) D.25776;
            D.25778 = __builtin_expect (D.25777, 0);
            if (D.25778 != 0) goto <D.25779>; else goto <D.25780>;
            <D.25779>:
            monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "aot-runtime.c", 868, "info");
            <D.25780>:
            D.25783 = info->subtype;
            subtype.46 = (unsigned int) subtype;
            if (D.25783 == subtype.46) goto <D.25785>; else goto <D.25781>;
            <D.25785>:
            D.25786 = info->d.virtual_stelemref.kind;
            if (D.25786 == kind) goto <D.25787>; else goto <D.25781>;
            <D.25787>:
            ref->method = target;
            goto <D.25782>;
            <D.25781>:
            D.25720 = 0;
            return D.25720;
            <D.25782>:
            goto <D.25788>;
            <D.25775>:
            D.25720 = 0;
            return D.25720;
            <D.25788>:
          }
          goto <D.25789>;
          <D.25771>:
          monoeg_assertion_message ("* Assertion: should not be reached at %s:%d\n", "aot-runtime.c", 877);
          <D.25789>:
          <D.25769>:
          goto <D.23737>;
        }
        <D.23754>:
        {
          struct MonoMethod * m;

          p.45 = p;
          m = decode_resolve_method_ref (module, p.45, &p);
          if (m == 0B) goto <D.25790>; else goto <D.25791>;
          <D.25790>:
          D.25720 = 0;
          return D.25720;
          <D.25791>:
          D.25792 = mono_marshal_get_synchronized_wrapper (m);
          ref->method = D.25792;
          goto <D.23737>;
        }
        <D.23756>:
        {
          struct MonoMethodDesc * desc;
          struct MonoMethod * orig_method;
          int subtype;

          p.45 = p;
          subtype = decode_value (p.45, &p);
          subtype.47 = (unsigned int) subtype;
          D.25794 = subtype.47 + 4294967289;
          if (D.25794 <= 1) goto <D.25795>; else goto <D.25796>;
          <D.25795>:
          {
            struct MonoClass * klass;

            p.45 = p;
            klass = decode_klass_ref (module, p.45, &p);
            if (klass == 0B) goto <D.25797>; else goto <D.25798>;
            <D.25797>:
            D.25720 = 0;
            return D.25720;
            <D.25798>:
            if (target == 0B) goto <D.25799>; else goto <D.25800>;
            <D.25799>:
            D.25720 = 0;
            return D.25720;
            <D.25800>:
            D.25801 = target->klass;
            if (D.25801 != klass) goto <D.25802>; else goto <D.25803>;
            <D.25802>:
            D.25720 = 0;
            return D.25720;
            <D.25803>:
            if (subtype == 7) goto <D.25804>; else goto <D.25805>;
            <D.25804>:
            {
              size_t __s1_len;
              size_t __s2_len;

              __s2_len = 14;
              if (__s2_len <= 3) goto <D.25807>; else goto <D.25808>;
              <D.25807>:
              {
                const unsigned char * __s2;
                int __result;

                __s2 = target->name;
                D.25809 = "PtrToStructure";
                D.25810 = MEM[(const unsigned char *)D.25809];
                D.25811 = (int) D.25810;
                D.25812 = *__s2;
                D.25813 = (int) D.25812;
                __result = D.25811 - D.25813;
                {
                  if (__s2_len != 0) goto <D.25814>; else goto <D.25815>;
                  <D.25814>:
                  if (__result == 0) goto <D.25816>; else goto <D.25817>;
                  <D.25816>:
                  D.25818 = &MEM[(void *)"PtrToStructure" + 1B];
                  D.25819 = *D.25818;
                  D.25820 = (int) D.25819;
                  D.25821 = __s2 + 1;
                  D.25822 = *D.25821;
                  D.25823 = (int) D.25822;
                  __result = D.25820 - D.25823;
                  if (__s2_len > 1) goto <D.25824>; else goto <D.25825>;
                  <D.25824>:
                  if (__result == 0) goto <D.25826>; else goto <D.25827>;
                  <D.25826>:
                  D.25828 = &MEM[(void *)"PtrToStructure" + 2B];
                  D.25829 = *D.25828;
                  D.25830 = (int) D.25829;
                  D.25831 = __s2 + 2;
                  D.25832 = *D.25831;
                  D.25833 = (int) D.25832;
                  __result = D.25830 - D.25833;
                  if (__s2_len > 2) goto <D.25834>; else goto <D.25835>;
                  <D.25834>:
                  if (__result == 0) goto <D.25836>; else goto <D.25837>;
                  <D.25836>:
                  D.25838 = &MEM[(void *)"PtrToStructure" + 3B];
                  D.25839 = *D.25838;
                  D.25840 = (int) D.25839;
                  D.25841 = __s2 + 3;
                  D.25842 = *D.25841;
                  D.25843 = (int) D.25842;
                  __result = D.25840 - D.25843;
                  <D.25837>:
                  <D.25835>:
                  <D.25827>:
                  <D.25825>:
                  <D.25817>:
                  <D.25815>:
                }
                D.23768 = __result;
              }
              iftmp.48 = -D.23768;
              goto <D.25844>;
              <D.25808>:
              D.25845 = target->name;
              iftmp.48 = __builtin_strcmp (D.25845, "PtrToStructure");
              <D.25844>:
              D.23769 = iftmp.48;
            }
            if (D.23769 != 0) goto <D.25846>; else goto <D.25847>;
            <D.25846>:
            D.25720 = 0;
            return D.25720;
            <D.25847>:
            D.25848 = mono_marshal_get_ptr_to_struct (klass);
            ref->method = D.25848;
            goto <D.25849>;
            <D.25805>:
            {
              size_t __s1_len;
              size_t __s2_len;

              __s2_len = 14;
              if (__s2_len <= 3) goto <D.25851>; else goto <D.25852>;
              <D.25851>:
              {
                const unsigned char * __s2;
                int __result;

                __s2 = target->name;
                D.25853 = "StructureToPtr";
                D.25854 = MEM[(const unsigned char *)D.25853];
                D.25855 = (int) D.25854;
                D.25856 = *__s2;
                D.25857 = (int) D.25856;
                __result = D.25855 - D.25857;
                {
                  if (__s2_len != 0) goto <D.25858>; else goto <D.25859>;
                  <D.25858>:
                  if (__result == 0) goto <D.25860>; else goto <D.25861>;
                  <D.25860>:
                  D.25862 = &MEM[(void *)"StructureToPtr" + 1B];
                  D.25863 = *D.25862;
                  D.25864 = (int) D.25863;
                  D.25865 = __s2 + 1;
                  D.25866 = *D.25865;
                  D.25867 = (int) D.25866;
                  __result = D.25864 - D.25867;
                  if (__s2_len > 1) goto <D.25868>; else goto <D.25869>;
                  <D.25868>:
                  if (__result == 0) goto <D.25870>; else goto <D.25871>;
                  <D.25870>:
                  D.25872 = &MEM[(void *)"StructureToPtr" + 2B];
                  D.25873 = *D.25872;
                  D.25874 = (int) D.25873;
                  D.25875 = __s2 + 2;
                  D.25876 = *D.25875;
                  D.25877 = (int) D.25876;
                  __result = D.25874 - D.25877;
                  if (__s2_len > 2) goto <D.25878>; else goto <D.25879>;
                  <D.25878>:
                  if (__result == 0) goto <D.25880>; else goto <D.25881>;
                  <D.25880>:
                  D.25882 = &MEM[(void *)"StructureToPtr" + 3B];
                  D.25883 = *D.25882;
                  D.25884 = (int) D.25883;
                  D.25885 = __s2 + 3;
                  D.25886 = *D.25885;
                  D.25887 = (int) D.25886;
                  __result = D.25884 - D.25887;
                  <D.25881>:
                  <D.25879>:
                  <D.25871>:
                  <D.25869>:
                  <D.25861>:
                  <D.25859>:
                }
                D.23777 = __result;
              }
              iftmp.49 = -D.23777;
              goto <D.25888>;
              <D.25852>:
              D.25845 = target->name;
              iftmp.49 = __builtin_strcmp (D.25845, "StructureToPtr");
              <D.25888>:
              D.23778 = iftmp.49;
            }
            if (D.23778 != 0) goto <D.25889>; else goto <D.25890>;
            <D.25889>:
            D.25720 = 0;
            return D.25720;
            <D.25890>:
            D.25891 = mono_marshal_get_struct_to_ptr (klass);
            ref->method = D.25891;
            <D.25849>:
          }
          goto <D.25892>;
          <D.25796>:
          if (subtype == 17) goto <D.25893>; else goto <D.25894>;
          <D.25893>:
          {
            struct MonoMethod * m;

            p.45 = p;
            m = decode_resolve_method_ref (module, p.45, &p);
            if (m == 0B) goto <D.25895>; else goto <D.25896>;
            <D.25895>:
            D.25720 = 0;
            return D.25720;
            <D.25896>:
            D.25897 = mono_marshal_get_synchronized_inner_wrapper (m);
            ref->method = D.25897;
          }
          goto <D.25898>;
          <D.25894>:
          if (subtype == 20) goto <D.25899>; else goto <D.25900>;
          <D.25899>:
          {
            struct MonoMethod * m;

            p.45 = p;
            m = decode_resolve_method_ref (module, p.45, &p);
            if (m == 0B) goto <D.25901>; else goto <D.25902>;
            <D.25901>:
            D.25720 = 0;
            return D.25720;
            <D.25902>:
            D.25903 = mono_marshal_get_array_accessor_wrapper (m);
            ref->method = D.25903;
          }
          goto <D.25904>;
          <D.25900>:
          if (subtype == 18) goto <D.25905>; else goto <D.25906>;
          <D.25905>:
          D.25907 = mono_marshal_get_gsharedvt_in_wrapper ();
          ref->method = D.25907;
          goto <D.25908>;
          <D.25906>:
          if (subtype == 19) goto <D.25909>; else goto <D.25910>;
          <D.25909>:
          D.25911 = mono_marshal_get_gsharedvt_out_wrapper ();
          ref->method = D.25911;
          goto <D.25912>;
          <D.25910>:
          if (subtype == 4) goto <D.25913>; else goto <D.25914>;
          <D.25913>:
          desc = mono_method_desc_new ("Monitor:Enter", 0);
          goto <D.25915>;
          <D.25914>:
          if (subtype == 6) goto <D.25916>; else goto <D.25917>;
          <D.25916>:
          desc = mono_method_desc_new ("Monitor:Exit", 0);
          goto <D.25918>;
          <D.25917>:
          if (subtype == 5) goto <D.25919>; else goto <D.25920>;
          <D.25919>:
          desc = mono_method_desc_new ("Monitor:Enter(object,bool&)", 0);
          goto <D.25921>;
          <D.25920>:
          monoeg_assertion_message ("* Assertion: should not be reached at %s:%d\n", "aot-runtime.c", 938);
          <D.25921>:
          <D.25918>:
          <D.25915>:
          D.25922 = mono_defaults.monitor_class;
          orig_method = mono_method_desc_search_in_class (desc, D.25922);
          D.25923 = orig_method == 0B;
          D.25924 = (long int) D.25923;
          D.25925 = __builtin_expect (D.25924, 0);
          if (D.25925 != 0) goto <D.25926>; else goto <D.25927>;
          <D.25926>:
          monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "aot-runtime.c", 940, "orig_method");
          <D.25927>:
          mono_method_desc_free (desc);
          D.25928 = mono_monitor_get_fast_path (orig_method);
          ref->method = D.25928;
          <D.25912>:
          <D.25908>:
          <D.25904>:
          <D.25898>:
          <D.25892>:
          goto <D.23737>;
        }
        <D.23781>:
        {
          int subtype;

          p.45 = p;
          subtype = decode_value (p.45, &p);
          if (subtype == 1) goto <D.25929>; else goto <D.25930>;
          <D.25929>:
          {
            int rank;
            int elem_size;

            p.45 = p;
            rank = decode_value (p.45, &p);
            p.45 = p;
            elem_size = decode_value (p.45, &p);
            D.25931 = mono_marshal_get_array_address (rank, elem_size);
            ref->method = D.25931;
          }
          goto <D.25932>;
          <D.25930>:
          if (subtype == 2) goto <D.25933>; else goto <D.25934>;
          <D.25933>:
          {
            struct WrapperInfo * info;
            struct MonoMethod * m;

            p.45 = p;
            m = decode_resolve_method_ref (module, p.45, &p);
            if (m == 0B) goto <D.25935>; else goto <D.25936>;
            <D.25935>:
            D.25720 = 0;
            return D.25720;
            <D.25936>:
            if (target == 0B) goto <D.25937>; else goto <D.25938>;
            <D.25937>:
            D.25720 = 0;
            return D.25720;
            <D.25938>:
            D.25716 = BIT_FIELD_REF <*target, 64, 256>;
            D.25717 = D.25716 & 124;
            D.25939 = D.25717 != 28;
            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", 964, "target->wrapper_type == MONO_WRAPPER_MANAGED_TO_MANAGED");
            <D.25943>:
            info = mono_marshal_get_wrapper_info (target);
            if (info != 0B) goto <D.25946>; else goto <D.25944>;
            <D.25946>:
            D.25947 = info->subtype;
            subtype.50 = (unsigned int) subtype;
            if (D.25947 == subtype.50) goto <D.25949>; else goto <D.25944>;
            <D.25949>:
            D.25950 = info->d.string_ctor.method;
            if (D.25950 == m) goto <D.25951>; else goto <D.25944>;
            <D.25951>:
            ref->method = target;
            goto <D.25945>;
            <D.25944>:
            D.25720 = 0;
            return D.25720;
            <D.25945>:
          }
          <D.25934>:
          <D.25932>:
          goto <D.23737>;
        }
        <D.23787>:
        {
          struct MonoMethod * m;
          int subtype;
          char * name;

          p.45 = p;
          subtype = decode_value (p.45, &p);
          if (subtype == 15) goto <D.25952>; else goto <D.25953>;
          <D.25952>:
          if (target == 0B) goto <D.25954>; else goto <D.25955>;
          <D.25954>:
          D.25720 = 0;
          return D.25720;
          <D.25955>:
          name = p;
          {
            size_t __s1_len;
            size_t __s2_len;

            D.25845 = target->name;
            D.23799 = __builtin_strcmp (D.25845, name);
          }
          if (D.23799 != 0) goto <D.25956>; else goto <D.25957>;
          <D.25956>:
          D.25720 = 0;
          return D.25720;
          <D.25957>:
          ref->method = target;
          goto <D.25958>;
          <D.25953>:
          p.45 = p;
          m = decode_resolve_method_ref (module, p.45, &p);
          if (m == 0B) goto <D.25959>; else goto <D.25960>;
          <D.25959>:
          D.25720 = 0;
          return D.25720;
          <D.25960>:
          if (target == 0B) goto <D.25961>; else goto <D.25962>;
          <D.25961>:
          D.25720 = 0;
          return D.25720;
          <D.25962>:
          D.25963 = mono_marshal_method_from_wrapper (target);
          if (D.25963 == m) goto <D.25964>; else goto <D.25965>;
          <D.25964>:
          ref->method = target;
          goto <D.25966>;
          <D.25965>:
          D.25720 = 0;
          return D.25720;
          <D.25966>:
          <D.25958>:
          goto <D.23737>;
        }
        <D.23800>:
        {
          int subtype;

          p.45 = p;
          subtype = decode_value (p.45, &p);
          if (subtype == 9) goto <D.25967>; else goto <D.25968>;
          <D.25967>:
          D.25969 = mono_marshal_get_castclass_with_cache ();
          ref->method = D.25969;
          goto <D.25970>;
          <D.25968>:
          if (subtype == 10) goto <D.25971>; else goto <D.25972>;
          <D.25971>:
          D.25973 = mono_marshal_get_isinst_with_cache ();
          ref->method = D.25973;
          goto <D.25974>;
          <D.25972>:
          monoeg_assertion_message ("* Assertion: should not be reached at %s:%d\n", "aot-runtime.c", 1011);
          <D.25974>:
          <D.25970>:
          goto <D.23737>;
        }
        <D.23802>:
        {
          int subtype;

          p.45 = p;
          subtype = decode_value (p.45, &p);
          if (target == 0B) goto <D.25975>; else goto <D.25976>;
          <D.25975>:
          D.25720 = 0;
          return D.25720;
          <D.25976>:
          if (subtype == 12) goto <D.25977>; else goto <D.25978>;
          <D.25977>:
          {
            size_t __s1_len;
            size_t __s2_len;

            __s2_len = 22;
            if (__s2_len <= 3) goto <D.25980>; else goto <D.25981>;
            <D.25980>:
            {
              const unsigned char * __s2;
              int __result;

              __s2 = target->name;
              D.25982 = "runtime_invoke_dynamic";
              D.25983 = MEM[(const unsigned char *)D.25982];
              D.25984 = (int) D.25983;
              D.25985 = *__s2;
              D.25986 = (int) D.25985;
              __result = D.25984 - D.25986;
              {
                if (__s2_len != 0) goto <D.25987>; else goto <D.25988>;
                <D.25987>:
                if (__result == 0) goto <D.25989>; else goto <D.25990>;
                <D.25989>:
                D.25991 = &MEM[(void *)"runtime_invoke_dynamic" + 1B];
                D.25992 = *D.25991;
                D.25993 = (int) D.25992;
                D.25994 = __s2 + 1;
                D.25995 = *D.25994;
                D.25996 = (int) D.25995;
                __result = D.25993 - D.25996;
                if (__s2_len > 1) goto <D.25997>; else goto <D.25998>;
                <D.25997>:
                if (__result == 0) goto <D.25999>; else goto <D.26000>;
                <D.25999>:
                D.26001 = &MEM[(void *)"runtime_invoke_dynamic" + 2B];
                D.26002 = *D.26001;
                D.26003 = (int) D.26002;
                D.26004 = __s2 + 2;
                D.26005 = *D.26004;
                D.26006 = (int) D.26005;
                __result = D.26003 - D.26006;
                if (__s2_len > 2) goto <D.26007>; else goto <D.26008>;
                <D.26007>:
                if (__result == 0) goto <D.26009>; else goto <D.26010>;
                <D.26009>:
                D.26011 = &MEM[(void *)"runtime_invoke_dynamic" + 3B];
                D.26012 = *D.26011;
                D.26013 = (int) D.26012;
                D.26014 = __s2 + 3;
                D.26015 = *D.26014;
                D.26016 = (int) D.26015;
                __result = D.26013 - D.26016;
                <D.26010>:
                <D.26008>:
                <D.26000>:
                <D.25998>:
                <D.25990>:
                <D.25988>:
              }
              D.23811 = __result;
            }
            iftmp.51 = -D.23811;
            goto <D.26017>;
            <D.25981>:
            D.25845 = target->name;
            iftmp.51 = __builtin_strcmp (D.25845, "runtime_invoke_dynamic");
            <D.26017>:
            D.23812 = iftmp.51;
          }
          if (D.23812 != 0) goto <D.26018>; else goto <D.26019>;
          <D.26018>:
          D.25720 = 0;
          return D.25720;
          <D.26019>:
          ref->method = target;
          goto <D.26020>;
          <D.25978>:
          if (subtype == 13) goto <D.26021>; else goto <D.26022>;
          <D.26021>:
          {
            struct MonoMethod * m;

            p.45 = p;
            m = decode_resolve_method_ref (module, p.45, &p);
            if (m == 0B) goto <D.26023>; else goto <D.26024>;
            <D.26023>:
            D.25720 = 0;
            return D.25720;
            <D.26024>:
            D.26025 = mono_marshal_get_runtime_invoke (m, 0);
            ref->method = D.26025;
          }
          goto <D.26026>;
          <D.26022>:
          if (subtype == 14) goto <D.26027>; else goto <D.26028>;
          <D.26027>:
          {
            struct MonoMethod * m;

            p.45 = p;
            m = decode_resolve_method_ref (module, p.45, &p);
            if (m == 0B) goto <D.26029>; else goto <D.26030>;
            <D.26029>:
            D.25720 = 0;
            return D.25720;
            <D.26030>:
            D.26031 = mono_marshal_get_runtime_invoke (m, 1);
            ref->method = D.26031;
          }
          goto <D.26032>;
          <D.26028>:
          {
            struct MonoMethodSignature * sig;
            struct WrapperInfo * info;

            p.45 = p;
            sig = decode_signature_with_target (module, 0B, p.45, &p);
            info = mono_marshal_get_wrapper_info (target);
            D.26033 = info == 0B;
            D.26034 = (long int) D.26033;
            D.26035 = __builtin_expect (D.26034, 0);
            if (D.26035 != 0) goto <D.26036>; else goto <D.26037>;
            <D.26036>:
            monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "aot-runtime.c", 1044, "info");
            <D.26037>:
            D.26038 = info->subtype;
            subtype.52 = (unsigned int) subtype;
            if (D.26038 != subtype.52) goto <D.26040>; else goto <D.26041>;
            <D.26040>:
            D.25720 = 0;
            return D.25720;
            <D.26041>:
            D.26042 = info->d.runtime_invoke.sig;
            D.26043 = D.26042 == 0B;
            D.26044 = (long int) D.26043;
            D.26045 = __builtin_expect (D.26044, 0);
            if (D.26045 != 0) goto <D.26046>; else goto <D.26047>;
            <D.26046>:
            monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "aot-runtime.c", 1048, "info->d.runtime_invoke.sig");
            <D.26047>:
            D.26042 = info->d.runtime_invoke.sig;
            D.26048 = mono_metadata_signature_equal (sig, D.26042);
            if (D.26048 != 0) goto <D.26049>; else goto <D.26050>;
            <D.26049>:
            ref->method = target;
            goto <D.26051>;
            <D.26050>:
            D.25720 = 0;
            return D.25720;
            <D.26051>:
          }
          <D.26032>:
          <D.26026>:
          <D.26020>:
          goto <D.23737>;
        }
        <D.23817>:
        <D.23818>:
        <D.23819>:
        {
          gboolean is_inflated;
          WrapperSubtype subtype;

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

            p.45 = p;
            klass = decode_klass_ref (module, p.45, &p);
            if (klass == 0B) goto <D.26054>; else goto <D.26055>;
            <D.26054>:
            D.25720 = 0;
            return D.25720;
            <D.26055>:
            switch (wrapper_type) <default: <D.23829>, case 1: <D.23825>, case 2: <D.23827>, case 3: <D.23828>>
            <D.23825>:
            invoke = mono_get_delegate_invoke (klass);
            wrapper = mono_marshal_get_delegate_invoke (invoke, 0B);
            goto <D.23826>;
            <D.23827>:
            invoke = mono_get_delegate_begin_invoke (klass);
            wrapper = mono_marshal_get_delegate_begin_invoke (invoke);
            goto <D.23826>;
            <D.23828>:
            invoke = mono_get_delegate_end_invoke (klass);
            wrapper = mono_marshal_get_delegate_end_invoke (invoke);
            goto <D.23826>;
            <D.23829>:
            monoeg_assertion_message ("* Assertion: should not be reached at %s:%d\n", "aot-runtime.c", 1084);
            <D.23826>:
            if (target != 0B) goto <D.26056>; else goto <D.26057>;
            <D.26056>:
            if (wrapper != target) goto <D.26058>; else goto <D.26059>;
            <D.26058>:
            D.25720 = 0;
            return D.25720;
            <D.26059>:
            <D.26057>:
            ref->method = wrapper;
          }
          goto <D.26060>;
          <D.26053>:
          if (target == 0B) goto <D.26061>; else goto <D.26062>;
          <D.26061>:
          D.25720 = 0;
          return D.25720;
          <D.26062>:
          if (wrapper_type == 1) goto <D.26063>; else goto <D.26064>;
          <D.26063>:
          {
            struct WrapperInfo * info;

            p.45 = p;
            D.26065 = decode_value (p.45, &p);
            subtype = (WrapperSubtype) D.26065;
            info = mono_marshal_get_wrapper_info (target);
            if (info != 0B) goto <D.26066>; else goto <D.26067>;
            <D.26066>:
            D.26068 = info->subtype;
            if (D.26068 != subtype) goto <D.26069>; else goto <D.26070>;
            <D.26069>:
            D.25720 = 0;
            return D.25720;
            <D.26070>:
            goto <D.26071>;
            <D.26067>:
            if (subtype != 0) goto <D.26072>; else goto <D.26073>;
            <D.26072>:
            D.25720 = 0;
            return D.25720;
            <D.26073>:
            <D.26071>:
          }
          <D.26064>:
          p.45 = p;
          D.26074 = sig_matches_target (module, target, p.45, &p);
          if (D.26074 != 0) goto <D.26075>; else goto <D.26076>;
          <D.26075>:
          ref->method = target;
          goto <D.26077>;
          <D.26076>:
          D.25720 = 0;
          return D.25720;
          <D.26077>:
          <D.26060>:
          goto <D.23737>;
        }
        <D.23831>:
        {
          struct MonoMethod * m;
          struct MonoClass * klass;

          p.45 = p;
          m = decode_resolve_method_ref (module, p.45, &p);
          if (m == 0B) goto <D.26078>; else goto <D.26079>;
          <D.26078>:
          D.25720 = 0;
          return D.25720;
          <D.26079>:
          p.45 = p;
          klass = decode_klass_ref (module, p.45, &p);
          if (klass == 0B) goto <D.26080>; else goto <D.26081>;
          <D.26080>:
          D.25720 = 0;
          return D.25720;
          <D.26081>:
          D.26082 = mono_marshal_get_managed_wrapper (m, klass, 0);
          ref->method = D.26082;
          goto <D.23737>;
        }
        <D.23834>:
        monoeg_assertion_message ("* Assertion: should not be reached at %s:%d\n", "aot-runtime.c", 1132);
        <D.23737>:
      }
      goto <D.26083>;
      <D.25722>:
      if (image_index == 254) goto <D.26084>; else goto <D.26085>;
      <D.26084>:
      p.45 = p;
      D.26086 = decode_value (p.45, &p);
      image_index = (guint32) D.26086;
      p.45 = p;
      D.26087 = decode_value (p.45, &p);
      D.26088 = (unsigned int) D.26087;
      ref->token = D.26088;
      image_index.53 = (int) image_index;
      image = load_image (module, image_index.53, 1);
      if (image == 0B) goto <D.26090>; else goto <D.26091>;
      <D.26090>:
      D.25720 = 0;
      return D.25720;
      <D.26091>:
      goto <D.26092>;
      <D.26085>:
      if (image_index == 253) goto <D.26093>; else goto <D.26094>;
      <D.26093>:
      {
        struct MonoClass * klass;
        struct MonoGenericContext ctx;

        try
          {
            p.45 = p;
            klass = decode_klass_ref (module, p.45, &p);
            if (klass == 0B) goto <D.26095>; else goto <D.26096>;
            <D.26095>:
            D.25720 = 0;
            return D.25720;
            <D.26096>:
            if (target != 0B) goto <D.26097>; else goto <D.26098>;
            <D.26097>:
            D.25801 = target->klass;
            if (D.25801 != klass) goto <D.26099>; else goto <D.26100>;
            <D.26099>:
            D.25720 = 0;
            return D.25720;
            <D.26100>:
            <D.26098>:
            p.45 = p;
            D.26101 = decode_value (p.45, &p);
            image_index = (guint32) D.26101;
            p.45 = p;
            D.26102 = decode_value (p.45, &p);
            D.26103 = (unsigned int) D.26102;
            ref->token = D.26103;
            image_index.53 = (int) image_index;
            image = load_image (module, image_index.53, 1);
            if (image == 0B) goto <D.26104>; else goto <D.26105>;
            <D.26104>:
            D.25720 = 0;
            return D.25720;
            <D.26105>:
            D.26106 = ref->token;
            D.26107 = mono_get_method_full (image, D.26106, 0B, 0B);
            ref->method = D.26107;
            D.25759 = ref->method;
            if (D.25759 == 0B) goto <D.26108>; else goto <D.26109>;
            <D.26108>:
            D.25720 = 0;
            return D.25720;
            <D.26109>:
            memset (&ctx, 0, 16);
            if (0 != 0) goto <D.26110>; else goto <D.26111>;
            <D.26110>:
            D.26112 = klass->generic_class;
            D.26113 = D.26112->context.class_inst;
            ctx.class_inst = D.26113;
            ctx.method_inst = 0B;
            D.25759 = ref->method;
            D.26114 = mono_class_inflate_generic_method_full (D.25759, klass, &ctx);
            ref->method = D.26114;
            <D.26111>:
            memset (&ctx, 0, 16);
            p.45 = p;
            D.26115 = decode_generic_context (module, &ctx, p.45, &p);
            if (D.26115 == 0) goto <D.26116>; else goto <D.26117>;
            <D.26116>:
            D.25720 = 0;
            return D.25720;
            <D.26117>:
            D.25759 = ref->method;
            D.26118 = mono_class_inflate_generic_method_full (D.25759, klass, &ctx);
            ref->method = D.26118;
          }
        finally
          {
            ctx = {CLOBBER};
          }
      }
      goto <D.26119>;
      <D.26094>:
      if (image_index == 250) goto <D.26120>; else goto <D.26121>;
      <D.26120>:
      {
        struct MonoClass * klass;
        int method_type;

        p.45 = p;
        klass = decode_klass_ref (module, p.45, &p);
        if (klass == 0B) goto <D.26122>; else goto <D.26123>;
        <D.26122>:
        D.25720 = 0;
        return D.25720;
        <D.26123>:
        p.45 = p;
        method_type = decode_value (p.45, &p);
        switch (method_type) <default: <D.23845>, case 0: <D.23839>, case 1: <D.23841>, case 2: <D.23842>, case 3: <D.23843>, case 4: <D.23844>>
        <D.23839>:
        D.26124 = klass->rank;
        D.26125 = (int) D.26124;
        D.26126 = mono_class_get_method_from_name (klass, ".ctor", D.26125);
        ref->method = D.26126;
        goto <D.23840>;
        <D.23841>:
        D.26124 = klass->rank;
        D.26125 = (int) D.26124;
        D.26127 = D.26125 * 2;
        D.26128 = mono_class_get_method_from_name (klass, ".ctor", D.26127);
        ref->method = D.26128;
        goto <D.23840>;
        <D.23842>:
        D.26129 = mono_class_get_method_from_name (klass, "Get", -1);
        ref->method = D.26129;
        goto <D.23840>;
        <D.23843>:
        D.26130 = mono_class_get_method_from_name (klass, "Address", -1);
        ref->method = D.26130;
        goto <D.23840>;
        <D.23844>:
        D.26131 = mono_class_get_method_from_name (klass, "Set", -1);
        ref->method = D.26131;
        goto <D.23840>;
        <D.23845>:
        monoeg_assertion_message ("* Assertion: should not be reached at %s:%d\n", "aot-runtime.c", 1207);
        <D.23840>:
      }
      goto <D.26132>;
      <D.26121>:
      if (image_index == 249) goto <D.26133>; else goto <D.26134>;
      <D.26133>:
      p.45 = p;
      D.26135 = decode_value (p.45, &p);
      image_index = (guint32) D.26135;
      p.45 = p;
      D.26136 = decode_value (p.45, &p);
      value = (guint32) D.26136;
      <D.26134>:
      D.26137 = value & 16777215;
      D.26138 = D.26137 | 100663296;
      ref->token = D.26138;
      image_index.53 = (int) image_index;
      image = load_image (module, image_index.53, 1);
      if (image == 0B) goto <D.26139>; else goto <D.26140>;
      <D.26139>:
      D.25720 = 0;
      return D.25720;
      <D.26140>:
      <D.26132>:
      <D.26119>:
      <D.26092>:
      <D.26083>:
      p.45 = p;
      *endbuf = p.45;
      ref->image = image;
      D.25720 = 1;
      return D.25720;
    }
  finally
    {
      p = {CLOBBER};
    }
}


decode_signature_with_target (struct MonoAotModule * module, struct MonoMethodSignature * target, guint8 * buf, guint8 * * endbuf)
{
  guint8 * p.54;
  unsigned char D.26146;
  guint8 * p.55;
  unsigned int D.26148;
  _Bool D.26149;
  unsigned int D.26150;
  _Bool D.26151;
  unsigned int D.26152;
  _Bool D.26153;
  int flags.56;
  short unsigned int D.26159;
  int D.26160;
  struct MonoMethodSignature * D.26163;
  long unsigned int D.26164;
  long unsigned int D.26165;
  long unsigned int D.26166;
  short unsigned int D.26167;
  unsigned char D.26168;
  <unnamed-unsigned:1> D.26169;
  unsigned char D.26170;
  <unnamed-unsigned:1> D.26171;
  unsigned char D.26172;
  <unnamed-unsigned:6> D.26173;
  struct MonoType * D.26174;
  long unsigned int D.26177;
  long unsigned int D.26178;
  _Bool D.26179;
  long int D.26180;
  long int D.26181;
  short int D.26184;
  struct MonoType * D.26185;
  long unsigned int D.26186;
  short unsigned int D.26189;
  short int D.26190;
  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.54 = p;
      D.26146 = *p.54;
      flags = (guint32) D.26146;
      p.54 = p;
      p.55 = p.54 + 1;
      p = p.55;
      D.26148 = flags & 16;
      D.26149 = D.26148 != 0;
      has_gen_params = (gboolean) D.26149;
      D.26150 = flags & 32;
      D.26151 = D.26150 != 0;
      hasthis = (gboolean) D.26151;
      D.26152 = flags & 64;
      D.26153 = D.26152 != 0;
      explicit_this = (gboolean) D.26153;
      flags.56 = (int) flags;
      call_conv = flags.56 & 15;
      if (has_gen_params != 0) goto <D.26155>; else goto <D.26156>;
      <D.26155>:
      p.54 = p;
      gen_param_count = decode_value (p.54, &p);
      <D.26156>:
      p.54 = p;
      param_count = decode_value (p.54, &p);
      if (target != 0B) goto <D.26157>; else goto <D.26158>;
      <D.26157>:
      D.26159 = target->param_count;
      D.26160 = (int) D.26159;
      if (D.26160 != param_count) goto <D.26161>; else goto <D.26162>;
      <D.26161>:
      D.26163 = 0B;
      return D.26163;
      <D.26162>:
      <D.26158>:
      D.26164 = (long unsigned int) param_count;
      D.26165 = D.26164 + 2;
      D.26166 = D.26165 * 8;
      sig = monoeg_malloc0 (D.26166);
      D.26167 = (short unsigned int) param_count;
      sig->param_count = D.26167;
      sig->sentinelpos = -1;
      D.26168 = (unsigned char) hasthis;
      D.26169 = (<unnamed-unsigned:1>) D.26168;
      sig->hasthis = D.26169;
      D.26170 = (unsigned char) explicit_this;
      D.26171 = (<unnamed-unsigned:1>) D.26170;
      sig->explicit_this = D.26171;
      D.26172 = (unsigned char) call_conv;
      D.26173 = (<unnamed-unsigned:6>) D.26172;
      sig->call_convention = D.26173;
      D.26167 = (short unsigned int) param_count;
      sig->param_count = D.26167;
      p.54 = p;
      D.26174 = decode_type (module, p.54, &p);
      sig->ret = D.26174;
      i = 0;
      goto <D.23701>;
      <D.23700>:
      p.54 = p;
      D.26146 = *p.54;
      if (D.26146 == 65) goto <D.26175>; else goto <D.26176>;
      <D.26175>:
      D.26177 = BIT_FIELD_REF <*sig, 64, 64>;
      D.26178 = D.26177 & 17732923532771328;
      D.26179 = D.26178 != 1407374883553280;
      D.26180 = (long int) D.26179;
      D.26181 = __builtin_expect (D.26180, 0);
      if (D.26181 != 0) goto <D.26182>; else goto <D.26183>;
      <D.26182>:
      monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "aot-runtime.c", 706, "sig->call_convention == MONO_CALL_VARARG");
      <D.26183>:
      D.26184 = (short int) i;
      sig->sentinelpos = D.26184;
      p.54 = p;
      p.55 = p.54 + 1;
      p = p.55;
      <D.26176>:
      p.54 = p;
      D.26185 = decode_type (module, p.54, &p);
      sig->params[i] = D.26185;
      i = i + 1;
      <D.23701>:
      if (i < param_count) goto <D.23700>; else goto <D.23702>;
      <D.23702>:
      D.26177 = BIT_FIELD_REF <*sig, 64, 64>;
      D.26186 = D.26177 & 17732927827673088;
      if (D.26186 == 1407379178455040) goto <D.26187>; else goto <D.26188>;
      <D.26187>:
      D.26189 = sig->param_count;
      D.26190 = (short int) D.26189;
      sig->sentinelpos = D.26190;
      <D.26188>:
      p.54 = p;
      *endbuf = p.54;
      D.26163 = sig;
      return D.26163;
    }
  finally
    {
      p = {CLOBBER};
    }
}


decode_type (struct MonoAotModule * module, guint8 * buf, guint8 * * endbuf)
{
  guint8 * p.57;
  unsigned char D.26194;
  guint8 * p.58;
  unsigned char D.26200;
  int D.26201;
  struct MonoClass * D.26202;
  struct MonoClass * D.26203;
  struct MonoClass * D.26204;
  struct MonoType * D.26207;
  struct MonoType * D.26208;
  struct MonoGenericContainer * D.26211;
  _Bool D.26212;
  long int D.26213;
  long int D.26214;
  struct MonoGenericInst * D.26217;
  struct MonoGenericInst * D.26218;
  struct MonoType * D.26221;
  struct MonoGenericClass * D.26222;
  struct MonoClass * D.26223;
  struct MonoClass * D.26224;
  int D.26227;
  unsigned char D.26228;
  int D.26229;
  unsigned char D.26230;
  unsigned char D.26231;
  long unsigned int D.26234;
  long unsigned int D.26235;
  void * D.26236;
  int * D.26237;
  long unsigned int D.26238;
  long unsigned int D.26239;
  int * D.26240;
  int D.26241;
  int D.26242;
  int D.26243;
  unsigned char D.26244;
  unsigned char D.26245;
  long unsigned int D.26248;
  long unsigned int D.26249;
  void * D.26250;
  int * D.26251;
  int * D.26252;
  int D.26253;
  int D.26254;
  struct MonoGenericParam * D.26257;
  guint8 * p;
  struct MonoType * t;

  try
    {
      p = buf;
      t = monoeg_malloc0 (16);
      <D.23642>:
      p.57 = p;
      D.26194 = *p.57;
      if (D.26194 == 69) goto <D.26195>; else goto <D.26196>;
      <D.26195>:
      t->pinned = 1;
      p.57 = p;
      p.58 = p.57 + 1;
      p = p.58;
      goto <D.26198>;
      <D.26196>:
      p.57 = p;
      D.26194 = *p.57;
      if (D.26194 == 16) goto <D.26199>; else goto <D.23641>;
      <D.26199>:
      t->byref = 1;
      p.57 = p;
      p.58 = p.57 + 1;
      p = p.58;
      <D.26198>:
      goto <D.23642>;
      <D.23641>:
      p.57 = p;
      D.26194 = *p.57;
      t->type = D.26194;
      p.57 = p;
      p.58 = p.57 + 1;
      p = p.58;
      D.26200 = t->type;
      D.26201 = (int) D.26200;
      switch (D.26201) <default: <D.23683>, case 1: <D.23643>, case 2: <D.23644>, case 3: <D.23645>, case 4: <D.23646>, case 5: <D.23647>, case 6: <D.23648>, case 7: <D.23649>, case 8: <D.23650>, case 9: <D.23651>, case 10: <D.23652>, case 11: <D.23653>, case 12: <D.23654>, case 13: <D.23655>, case 14: <D.23658>, case 15: <D.23665>, case 17: <D.23662>, case 18: <D.23663>, case 19: <D.23680>, case 20: <D.23671>, case 21: <D.23666>, case 22: <D.23660>, case 24: <D.23656>, case 25: <D.23657>, case 28: <D.23659>, case 29: <D.23664>, case 30: <D.23681>>
      <D.23643>:
      <D.23644>:
      <D.23645>:
      <D.23646>:
      <D.23647>:
      <D.23648>:
      <D.23649>:
      <D.23650>:
      <D.23651>:
      <D.23652>:
      <D.23653>:
      <D.23654>:
      <D.23655>:
      <D.23656>:
      <D.23657>:
      <D.23658>:
      <D.23659>:
      <D.23660>:
      goto <D.23661>;
      <D.23662>:
      <D.23663>:
      p.57 = p;
      D.26202 = decode_klass_ref (module, p.57, &p);
      t->data.klass = D.26202;
      goto <D.23661>;
      <D.23664>:
      p.57 = p;
      D.26203 = decode_klass_ref (module, p.57, &p);
      t->data.klass = D.26203;
      D.26204 = t->data.klass;
      if (D.26204 == 0B) goto <D.26205>; else goto <D.26206>;
      <D.26205>:
      D.26207 = 0B;
      return D.26207;
      <D.26206>:
      goto <D.23661>;
      <D.23665>:
      p.57 = p;
      D.26208 = decode_type (module, p.57, &p);
      t->data.type = D.26208;
      goto <D.23661>;
      <D.23666>:
      {
        struct MonoClass * gclass;
        struct MonoGenericContext ctx;
        struct MonoType * type;
        struct MonoClass * klass;

        try
          {
            p.57 = p;
            gclass = decode_klass_ref (module, p.57, &p);
            if (gclass == 0B) goto <D.26209>; else goto <D.26210>;
            <D.26209>:
            D.26207 = 0B;
            return D.26207;
            <D.26210>:
            D.26211 = gclass->generic_container;
            D.26212 = D.26211 == 0B;
            D.26213 = (long int) D.26212;
            D.26214 = __builtin_expect (D.26213, 0);
            if (D.26214 != 0) goto <D.26215>; else goto <D.26216>;
            <D.26215>:
            monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "aot-runtime.c", 620, "gclass->generic_container");
            <D.26216>:
            memset (&ctx, 0, 16);
            p.57 = p;
            D.26217 = decode_generic_inst (module, p.57, &p);
            ctx.class_inst = D.26217;
            D.26218 = ctx.class_inst;
            if (D.26218 == 0B) goto <D.26219>; else goto <D.26220>;
            <D.26219>:
            D.26207 = 0B;
            return D.26207;
            <D.26220>:
            D.26221 = &gclass->byval_arg;
            type = mono_class_inflate_generic_type (D.26221, &ctx);
            klass = mono_class_from_mono_type (type);
            D.26222 = klass->generic_class;
            t->data.generic_class = D.26222;
            goto <D.23661>;
          }
        finally
          {
            ctx = {CLOBBER};
          }
      }
      <D.23671>:
      {
        struct MonoArrayType * array;
        int i;

        array = monoeg_malloc0 (32);
        p.57 = p;
        D.26223 = decode_klass_ref (module, p.57, &p);
        array->eklass = D.26223;
        D.26224 = array->eklass;
        if (D.26224 == 0B) goto <D.26225>; else goto <D.26226>;
        <D.26225>:
        D.26207 = 0B;
        return D.26207;
        <D.26226>:
        p.57 = p;
        D.26227 = decode_value (p.57, &p);
        D.26228 = (unsigned char) D.26227;
        array->rank = D.26228;
        p.57 = p;
        D.26229 = decode_value (p.57, &p);
        D.26230 = (unsigned char) D.26229;
        array->numsizes = D.26230;
        D.26231 = array->numsizes;
        if (D.26231 != 0) goto <D.26232>; else goto <D.26233>;
        <D.26232>:
        D.26231 = array->numsizes;
        D.26234 = (long unsigned int) D.26231;
        D.26235 = D.26234 * 4;
        D.26236 = monoeg_malloc0 (D.26235);
        array->sizes = D.26236;
        <D.26233>:
        i = 0;
        goto <D.23675>;
        <D.23674>:
        D.26237 = array->sizes;
        D.26238 = (long unsigned int) i;
        D.26239 = D.26238 * 4;
        D.26240 = D.26237 + D.26239;
        p.57 = p;
        D.26241 = decode_value (p.57, &p);
        *D.26240 = D.26241;
        i = i + 1;
        <D.23675>:
        D.26231 = array->numsizes;
        D.26242 = (int) D.26231;
        if (D.26242 > i) goto <D.23674>; else goto <D.23676>;
        <D.23676>:
        p.57 = p;
        D.26243 = decode_value (p.57, &p);
        D.26244 = (unsigned char) D.26243;
        array->numlobounds = D.26244;
        D.26245 = array->numlobounds;
        if (D.26245 != 0) goto <D.26246>; else goto <D.26247>;
        <D.26246>:
        D.26245 = array->numlobounds;
        D.26248 = (long unsigned int) D.26245;
        D.26249 = D.26248 * 4;
        D.26250 = monoeg_malloc0 (D.26249);
        array->lobounds = D.26250;
        <D.26247>:
        i = 0;
        goto <D.23678>;
        <D.23677>:
        D.26251 = array->lobounds;
        D.26238 = (long unsigned int) i;
        D.26239 = D.26238 * 4;
        D.26252 = D.26251 + D.26239;
        p.57 = p;
        D.26253 = decode_value (p.57, &p);
        *D.26252 = D.26253;
        i = i + 1;
        <D.23678>:
        D.26245 = array->numlobounds;
        D.26254 = (int) D.26245;
        if (D.26254 > i) goto <D.23677>; else goto <D.23679>;
        <D.23679>:
        t->data.array = array;
        goto <D.23661>;
      }
      <D.23680>:
      <D.23681>:
      {
        struct MonoClass * klass;

        p.57 = p;
        klass = decode_klass_ref (module, p.57, &p);
        if (klass == 0B) goto <D.26255>; else goto <D.26256>;
        <D.26255>:
        D.26207 = 0B;
        return D.26207;
        <D.26256>:
        D.26257 = klass->byval_arg.data.generic_param;
        t->data.generic_param = D.26257;
        goto <D.23661>;
      }
      <D.23683>:
      monoeg_assertion_message ("* Assertion: should not be reached at %s:%d\n", "aot-runtime.c", 665);
      <D.23661>:
      p.57 = p;
      *endbuf = p.57;
      D.26207 = t;
      return D.26207;
    }
  finally
    {
      p = {CLOBBER};
    }
}


decode_generic_inst (struct MonoAotModule * module, guint8 * buf, guint8 * * endbuf)
{
  guint8 * p.59;
  long unsigned int D.26264;
  long unsigned int D.26265;
  struct MonoGenericInst * D.26268;
  long unsigned int D.26269;
  long unsigned int D.26270;
  struct MonoType * * D.26271;
  struct MonoType * D.26272;
  int type_argc;
  int i;
  struct MonoType * * type_argv;
  struct MonoGenericInst * inst;
  guint8 * p;

  try
    {
      p = buf;
      p.59 = p;
      type_argc = decode_value (p.59, &p);
      D.26264 = (long unsigned int) type_argc;
      D.26265 = D.26264 * 8;
      type_argv = monoeg_malloc0 (D.26265);
      i = 0;
      goto <D.23576>;
      <D.23575>:
      {
        struct MonoClass * pclass;

        p.59 = p;
        pclass = decode_klass_ref (module, p.59, &p);
        if (pclass == 0B) goto <D.26266>; else goto <D.26267>;
        <D.26266>:
        monoeg_g_free (type_argv);
        D.26268 = 0B;
        return D.26268;
        <D.26267>:
        D.26269 = (long unsigned int) i;
        D.26270 = D.26269 * 8;
        D.26271 = type_argv + D.26270;
        D.26272 = &pclass->byval_arg;
        *D.26271 = D.26272;
      }
      i = i + 1;
      <D.23576>:
      if (i < type_argc) goto <D.23575>; else goto <D.23577>;
      <D.23577>:
      inst = mono_metadata_get_generic_inst (type_argc, type_argv);
      monoeg_g_free (type_argv);
      p.59 = p;
      *endbuf = p.59;
      D.26268 = inst;
      return D.26268;
    }
  finally
    {
      p = {CLOBBER};
    }
}


sig_matches_target (struct MonoAotModule * module, struct MonoMethod * target, guint8 * buf, guint8 * * endbuf)
{
  struct MonoMethodSignature * D.26275;
  guint8 * p.60;
  int iftmp.61;
  struct MonoMethodSignature * D.26281;
  int D.26282;
  gboolean D.26284;
  struct MonoMethodSignature * sig;
  gboolean res;
  guint8 * p;

  try
    {
      p = buf;
      D.26275 = mono_method_signature (target);
      p.60 = p;
      sig = decode_signature_with_target (module, D.26275, p.60, &p);
      if (sig != 0B) goto <D.26280>; else goto <D.26278>;
      <D.26280>:
      D.26281 = mono_method_signature (target);
      D.26282 = mono_metadata_signature_equal (D.26281, sig);
      if (D.26282 != 0) goto <D.26283>; else goto <D.26278>;
      <D.26283>:
      iftmp.61 = 1;
      goto <D.26279>;
      <D.26278>:
      iftmp.61 = 0;
      <D.26279>:
      res = iftmp.61;
      monoeg_g_free (sig);
      p.60 = p;
      *endbuf = p.60;
      D.26284 = res;
      return D.26284;
    }
  finally
    {
      p = {CLOBBER};
    }
}


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

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


decode_resolve_method_ref_with_target (struct MonoAotModule * module, struct MonoMethod * target, guint8 * buf, guint8 * * endbuf)
{
  struct MonoMethod * D.26291;
  struct MonoMethod * D.26292;
  struct MonoImage * D.26295;
  unsigned int D.26298;
  struct MethodRef ref;
  gboolean res;

  try
    {
      res = decode_method_ref_with_target (module, &ref, target, buf, endbuf);
      if (res == 0) goto <D.26289>; else goto <D.26290>;
      <D.26289>:
      D.26291 = 0B;
      return D.26291;
      <D.26290>:
      D.26292 = ref.method;
      if (D.26292 != 0B) goto <D.26293>; else goto <D.26294>;
      <D.26293>:
      D.26291 = ref.method;
      return D.26291;
      <D.26294>:
      D.26295 = ref.image;
      if (D.26295 == 0B) goto <D.26296>; else goto <D.26297>;
      <D.26296>:
      D.26291 = 0B;
      return D.26291;
      <D.26297>:
      D.26295 = ref.image;
      D.26298 = ref.token;
      D.26291 = mono_get_method (D.26295, D.26298, 0B);
      return D.26291;
    }
  finally
    {
      ref = {CLOBBER};
    }
}


decode_generic_context (struct MonoAotModule * module, struct MonoGenericContext * ctx, guint8 * buf, guint8 * * endbuf)
{
  guint8 * p.62;
  struct MonoGenericInst * D.26304;
  struct MonoGenericInst * D.26305;
  gboolean D.26308;
  struct MonoGenericInst * D.26311;
  struct MonoGenericInst * D.26312;
  guint8 * p;
  guint8 * p2;
  int argc;

  try
    {
      p = buf;
      p2 = p;
      p.62 = p;
      argc = decode_value (p.62, &p);
      if (argc != 0) goto <D.26302>; else goto <D.26303>;
      <D.26302>:
      p = p2;
      p.62 = p;
      D.26304 = decode_generic_inst (module, p.62, &p);
      ctx->class_inst = D.26304;
      D.26305 = ctx->class_inst;
      if (D.26305 == 0B) goto <D.26306>; else goto <D.26307>;
      <D.26306>:
      D.26308 = 0;
      return D.26308;
      <D.26307>:
      <D.26303>:
      p2 = p;
      p.62 = p;
      argc = decode_value (p.62, &p);
      if (argc != 0) goto <D.26309>; else goto <D.26310>;
      <D.26309>:
      p = p2;
      p.62 = p;
      D.26311 = decode_generic_inst (module, p.62, &p);
      ctx->method_inst = D.26311;
      D.26312 = ctx->method_inst;
      if (D.26312 == 0B) goto <D.26313>; else goto <D.26314>;
      <D.26313>:
      D.26308 = 0;
      return D.26308;
      <D.26314>:
      <D.26310>:
      p.62 = p;
      *endbuf = p.62;
      D.26308 = 1;
      return D.26308;
    }
  finally
    {
      p = {CLOBBER};
    }
}


decode_klass_ref (struct MonoAotModule * module, guint8 * buf, guint8 * * endbuf)
{
  guint8 * p.63;
  struct MonoClass * D.26320;
  int D.26321;
  unsigned int D.26324;
  int D.26325;
  int D.26326;
  int D.26329;
  struct MonoAssembly * D.26330;
  struct MonoGenericContainer * D.26335;
  _Bool D.26336;
  long int D.26337;
  long int D.26338;
  struct MonoGenericInst * D.26341;
  struct MonoGenericInst * D.26342;
  struct MonoType * D.26345;
  _Bool D.26350;
  long int D.26351;
  long int D.26352;
  _Bool D.26358;
  long int D.26359;
  long int D.26360;
  unsigned char D.26366;
  struct MonoGenericParamFull * D.26369;
  long unsigned int D.26370;
  long unsigned int D.26371;
  struct MonoGenericParam * D.26372;
  _Bool D.26373;
  long int D.26374;
  long int D.26375;
  short unsigned int D.26379;
  short unsigned int D.26380;
  struct MonoImage * D.26381;
  int D.26382;
  int D.26385;
  guint8 * D.26386;
  sizetype D.26387;
  guint8 * p2.64;
  guint8 * p2.65;
  _Bool D.26390;
  long int D.26391;
  long int D.26392;
  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.63 = p;
      reftype = decode_value (p.63, &p);
      if (reftype == 0) goto <D.26318>; else goto <D.26319>;
      <D.26318>:
      p.63 = p;
      *endbuf = p.63;
      D.26320 = 0B;
      return D.26320;
      <D.26319>:
      switch (reftype) <default: <D.23625>, case 1: <D.23600>, case 2: <D.23602>, case 3: <D.23603>, case 4: <D.23604>, case 5: <D.23608>, case 6: <D.23619>, case 7: <D.23622>, case 8: <D.23620>>
      <D.23600>:
      p.63 = p;
      D.26321 = decode_value (p.63, &p);
      idx = (guint32) D.26321;
      image = load_image (module, 0, 1);
      if (image == 0B) goto <D.26322>; else goto <D.26323>;
      <D.26322>:
      D.26320 = 0B;
      return D.26320;
      <D.26323>:
      D.26324 = idx + 33554432;
      klass = mono_class_get (image, D.26324);
      goto <D.23601>;
      <D.23602>:
      p.63 = p;
      D.26325 = decode_value (p.63, &p);
      idx = (guint32) D.26325;
      p.63 = p;
      D.26326 = decode_value (p.63, &p);
      image = load_image (module, D.26326, 1);
      if (image == 0B) goto <D.26327>; else goto <D.26328>;
      <D.26327>:
      D.26320 = 0B;
      return D.26320;
      <D.26328>:
      D.26324 = idx + 33554432;
      klass = mono_class_get (image, D.26324);
      goto <D.23601>;
      <D.23603>:
      p.63 = p;
      D.26329 = decode_value (p.63, &p);
      token = (guint32) D.26329;
      D.26330 = module->assembly;
      image = D.26330->image;
      if (image == 0B) goto <D.26331>; else goto <D.26332>;
      <D.26331>:
      D.26320 = 0B;
      return D.26320;
      <D.26332>:
      klass = mono_class_get (image, token);
      goto <D.23601>;
      <D.23604>:
      {
        struct MonoClass * gclass;
        struct MonoGenericContext ctx;
        struct MonoType * type;

        try
          {
            p.63 = p;
            gclass = decode_klass_ref (module, p.63, &p);
            if (gclass == 0B) goto <D.26333>; else goto <D.26334>;
            <D.26333>:
            D.26320 = 0B;
            return D.26320;
            <D.26334>:
            D.26335 = gclass->generic_container;
            D.26336 = D.26335 == 0B;
            D.26337 = (long int) D.26336;
            D.26338 = __builtin_expect (D.26337, 0);
            if (D.26338 != 0) goto <D.26339>; else goto <D.26340>;
            <D.26339>:
            monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "aot-runtime.c", 435, "gclass->generic_container");
            <D.26340>:
            memset (&ctx, 0, 16);
            p.63 = p;
            D.26341 = decode_generic_inst (module, p.63, &p);
            ctx.class_inst = D.26341;
            D.26342 = ctx.class_inst;
            if (D.26342 == 0B) goto <D.26343>; else goto <D.26344>;
            <D.26343>:
            D.26320 = 0B;
            return D.26320;
            <D.26344>:
            D.26345 = &gclass->byval_arg;
            type = mono_class_inflate_generic_type (D.26345, &ctx);
            klass = mono_class_from_mono_type (type);
            mono_metadata_free_type (type);
            goto <D.23601>;
          }
        finally
          {
            ctx = {CLOBBER};
          }
      }
      <D.23608>:
      {
        struct MonoType * t;
        struct MonoGenericContainer * container;
        int type;
        int num;
        gboolean has_container;
        int serial;

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

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

            D.26350 = type != 30;
            D.26351 = (long int) D.26350;
            D.26352 = __builtin_expect (D.26351, 0);
            if (D.26352 != 0) goto <D.26353>; else goto <D.26354>;
            <D.26353>:
            monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "aot-runtime.c", 459, "type == MONO_TYPE_MVAR");
            <D.26354>:
            p.63 = p;
            method_def = decode_resolve_method_ref (module, p.63, &p);
            if (method_def == 0B) goto <D.26355>; else goto <D.26356>;
            <D.26355>:
            D.26320 = 0B;
            return D.26320;
            <D.26356>:
            container = mono_method_get_generic_container (method_def);
          }
          goto <D.26357>;
          <D.26349>:
          {
            struct MonoClass * class_def;

            D.26358 = type != 19;
            D.26359 = (long int) D.26358;
            D.26360 = __builtin_expect (D.26359, 0);
            if (D.26360 != 0) goto <D.26361>; else goto <D.26362>;
            <D.26361>:
            monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "aot-runtime.c", 467, "type == MONO_TYPE_VAR");
            <D.26362>:
            p.63 = p;
            class_def = decode_klass_ref (module, p.63, &p);
            if (class_def == 0B) goto <D.26363>; else goto <D.26364>;
            <D.26363>:
            D.26320 = 0B;
            return D.26320;
            <D.26364>:
            container = class_def->generic_container;
          }
          <D.26357>:
        }
        goto <D.26365>;
        <D.26347>:
        p.63 = p;
        serial = decode_value (p.63, &p);
        <D.26365>:
        t = monoeg_malloc0 (16);
        D.26366 = (unsigned char) type;
        t->type = D.26366;
        if (container != 0B) goto <D.26367>; else goto <D.26368>;
        <D.26367>:
        D.26369 = container->type_params;
        D.26370 = (long unsigned int) num;
        D.26371 = D.26370 * 56;
        D.26372 = D.26369 + D.26371;
        t->data.generic_param = D.26372;
        D.26373 = serial != 0;
        D.26374 = (long int) D.26373;
        D.26375 = __builtin_expect (D.26374, 0);
        if (D.26375 != 0) goto <D.26376>; else goto <D.26377>;
        <D.26376>:
        monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "aot-runtime.c", 483, "serial == 0");
        <D.26377>:
        goto <D.26378>;
        <D.26368>:
        {
          struct MonoGenericParam * par;

          par = monoeg_malloc0 (56);
          D.26379 = (short unsigned int) num;
          par->num = D.26379;
          D.26380 = (short unsigned int) serial;
          par->serial = D.26380;
          D.26381 = mono_defaults.corlib;
          par->image = D.26381;
          t->data.generic_param = par;
        }
        <D.26378>:
        klass = mono_class_from_mono_type (t);
        monoeg_g_free (t);
        goto <D.23601>;
      }
      <D.23619>:
      p.63 = p;
      D.26382 = decode_value (p.63, &p);
      rank = (guint32) D.26382;
      p.63 = p;
      eklass = decode_klass_ref (module, p.63, &p);
      klass = mono_array_class_get (eklass, rank);
      goto <D.23601>;
      <D.23620>:
      {
        struct MonoType * t;

        p.63 = p;
        t = decode_type (module, p.63, &p);
        if (t == 0B) goto <D.26383>; else goto <D.26384>;
        <D.26383>:
        D.26320 = 0B;
        return D.26320;
        <D.26384>:
        klass = mono_class_from_mono_type (t);
        monoeg_g_free (t);
        goto <D.23601>;
      }
      <D.23622>:
      {
        guint32 offset;
        guint8 * p2;

        try
          {
            p.63 = p;
            D.26385 = decode_value (p.63, &p);
            offset = (guint32) D.26385;
            D.26386 = module->blob;
            D.26387 = (sizetype) offset;
            p2.64 = D.26386 + D.26387;
            p2 = p2.64;
            p2.65 = p2;
            klass = decode_klass_ref (module, p2.65, &p2);
            goto <D.23601>;
          }
        finally
          {
            p2 = {CLOBBER};
          }
      }
      <D.23625>:
      monoeg_assertion_message ("* Assertion: should not be reached at %s:%d\n", "aot-runtime.c", 526);
      <D.23601>:
      D.26390 = klass == 0B;
      D.26391 = (long int) D.26390;
      D.26392 = __builtin_expect (D.26391, 0);
      if (D.26392 != 0) goto <D.26393>; else goto <D.26394>;
      <D.26393>:
      monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "aot-runtime.c", 528, "klass");
      <D.26394>:
      p.63 = p;
      *endbuf = p.63;
      D.26320 = klass;
      return D.26320;
    }
  finally
    {
      p = {CLOBBER};
    }
}


mono_aot_get_cached_class_info (struct MonoClass * klass, struct MonoCachedClassInfo * res)
{
  struct MonoImage * D.26400;
  unsigned char D.26403;
  gboolean D.26405;
  guint8 * D.26406;
  guint32 * D.26407;
  unsigned int D.26408;
  unsigned int D.26409;
  unsigned int D.26410;
  int D.26411;
  unsigned int D.26412;
  sizetype D.26413;
  guint8 * p.66;
  guint8 * p.67;
  struct MonoAotModule * amodule;
  guint8 * p;
  gboolean err;

  try
    {
      D.26400 = klass->image;
      amodule = D.26400->aot_module;
      D.26403 = klass->rank;
      if (D.26403 != 0) goto <D.26401>; else goto <D.26404>;
      <D.26404>:
      if (amodule == 0B) goto <D.26401>; else goto <D.26402>;
      <D.26401>:
      D.26405 = 0;
      return D.26405;
      <D.26402>:
      D.26406 = amodule->blob;
      D.26407 = amodule->class_info_offsets;
      D.26408 = klass->type_token;
      D.26409 = D.26408 & 16777215;
      D.26410 = D.26409 + 4294967295;
      D.26411 = (int) D.26410;
      D.26412 = mono_aot_get_offset (D.26407, D.26411);
      D.26413 = (sizetype) D.26412;
      p.66 = D.26406 + D.26413;
      p = p.66;
      p.67 = p;
      err = decode_cached_class_info (amodule, res, p.67, &p);
      if (err == 0) goto <D.26416>; else goto <D.26417>;
      <D.26416>:
      D.26405 = 0;
      return D.26405;
      <D.26417>:
      D.26405 = 1;
      return D.26405;
    }
  finally
    {
      p = {CLOBBER};
    }
}


mono_aot_get_class_from_name (struct MonoImage * image, const char * name_space, const char * name, struct MonoClass * * klass)
{
  guint16 * D.26423;
  gboolean D.26424;
  _Bool D.26427;
  long int D.26428;
  long int D.26429;
  struct GHashTable * D.26432;
  struct GHashTable * D.26435;
  void * D.26438;
  struct MonoClass * D.26439;
  _Bool D.26444;
  long int D.26445;
  long int D.26446;
  char D.26449;
  long unsigned int D.26453;
  long unsigned int D.26454;
  long unsigned int D.26455;
  unsigned int D.26459;
  unsigned int D.26460;
  unsigned int D.26463;
  long unsigned int D.26464;
  long unsigned int D.26465;
  short unsigned int D.26466;
  guint16 * D.26469;
  short unsigned int D.26470;
  unsigned int name_table_accesses.68;
  unsigned int name_table_accesses.69;
  unsigned int D.26473;
  int D.26474;
  unsigned int D.26475;
  unsigned int D.26476;
  int D.24077;
  int D.24086;
  _Bool D.26483;
  long int D.26484;
  long int D.26485;
  struct MonoClass * D.26488;
  _Bool D.26493;
  long int D.26494;
  long int D.26495;
  _Bool D.26502;
  long int D.26503;
  long int D.26504;
  unsigned int D.26508;
  long unsigned int D.26509;
  long unsigned int D.26510;
  _Bool D.26513;
  long int D.26514;
  long int D.26515;
  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.26420>; else goto <D.26422>;
      <D.26422>:
      D.26423 = amodule->class_name_table;
      if (D.26423 == 0B) goto <D.26420>; else goto <D.26421>;
      <D.26420>:
      D.26424 = 0;
      return D.26424;
      <D.26421>:
      {
        int ret;

        ret = pthread_mutex_lock (&aot_mutex.mutex);
        if (ret != 0) goto <D.26425>; else goto <D.26426>;
        <D.26425>:
        monoeg_g_log (0B, 16, "Bad call to mono_mutex_lock result %d", ret);
        <D.26426>:
        D.26427 = ret != 0;
        D.26428 = (long int) D.26427;
        D.26429 = __builtin_expect (D.26428, 0);
        if (D.26429 != 0) goto <D.26430>; else goto <D.26431>;
        <D.26430>:
        monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "aot-runtime.c", 2065, "ret == 0");
        <D.26431>:
      }
      *klass = 0B;
      D.26432 = amodule->name_cache;
      if (D.26432 == 0B) goto <D.26433>; else goto <D.26434>;
      <D.26433>:
      D.26435 = monoeg_g_hash_table_new (monoeg_g_str_hash, monoeg_g_str_equal);
      amodule->name_cache = D.26435;
      <D.26434>:
      D.26432 = amodule->name_cache;
      nspace_table = monoeg_g_hash_table_lookup (D.26432, name_space);
      if (nspace_table != 0B) goto <D.26436>; else goto <D.26437>;
      <D.26436>:
      D.26438 = monoeg_g_hash_table_lookup (nspace_table, name);
      *klass = D.26438;
      D.26439 = *klass;
      if (D.26439 != 0B) goto <D.26440>; else goto <D.26441>;
      <D.26440>:
      {
        int ret;

        ret = pthread_mutex_unlock (&aot_mutex.mutex);
        if (ret != 0) goto <D.26442>; else goto <D.26443>;
        <D.26442>:
        monoeg_g_log (0B, 16, "Bad call to mono_mutex_unlock result %d", ret);
        <D.26443>:
        D.26444 = ret != 0;
        D.26445 = (long int) D.26444;
        D.26446 = __builtin_expect (D.26445, 0);
        if (D.26446 != 0) goto <D.26447>; else goto <D.26448>;
        <D.26447>:
        monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "aot-runtime.c", 2076, "ret == 0");
        <D.26448>:
      }
      D.26424 = 1;
      return D.26424;
      <D.26441>:
      <D.26437>:
      D.26423 = amodule->class_name_table;
      table_size = *D.26423;
      D.26423 = amodule->class_name_table;
      table = D.26423 + 2;
      D.26449 = *name_space;
      if (D.26449 == 0) goto <D.26450>; else goto <D.26451>;
      <D.26450>:
      full_name = monoeg_g_strdup_printf ("%s", name);
      goto <D.26452>;
      <D.26451>:
      D.26453 = strlen (name_space);
      D.26454 = strlen (name);
      D.26455 = D.26453 + D.26454;
      if (D.26455 <= 999) goto <D.26456>; else goto <D.26457>;
      <D.26456>:
      sprintf (&full_name_buf, "%s.%s", name_space, name);
      full_name = &full_name_buf;
      goto <D.26458>;
      <D.26457>:
      full_name = monoeg_g_strdup_printf ("%s.%s", name_space, name);
      <D.26458>:
      <D.26452>:
      D.26459 = mono_metadata_str_hash (full_name);
      D.26460 = (unsigned int) table_size;
      hash = D.26459 % D.26460;
      if (&full_name_buf != full_name) goto <D.26461>; else goto <D.26462>;
      <D.26461>:
      monoeg_g_free (full_name);
      <D.26462>:
      D.26463 = hash * 2;
      D.26464 = (long unsigned int) D.26463;
      D.26465 = D.26464 * 2;
      entry = table + D.26465;
      D.26466 = *entry;
      if (D.26466 != 0) goto <D.26467>; else goto <D.26468>;
      <D.26467>:
      t = &image->tables[2];
      <D.24091>:
      {
        guint32 index;
        guint32 next;
        guint32 token;

        D.26466 = *entry;
        index = (guint32) D.26466;
        D.26469 = entry + 2;
        D.26470 = *D.26469;
        next = (guint32) D.26470;
        token = index | 33554432;
        name_table_accesses.68 = name_table_accesses;
        name_table_accesses.69 = name_table_accesses.68 + 1;
        name_table_accesses = name_table_accesses.69;
        D.26473 = index + 4294967295;
        D.26474 = (int) D.26473;
        mono_metadata_decode_row (t, D.26474, &cols, 6);
        D.26475 = cols[1];
        name2 = mono_metadata_string_heap (image, D.26475);
        D.26476 = cols[2];
        name_space2 = mono_metadata_string_heap (image, D.26476);
        {
          size_t __s1_len;
          size_t __s2_len;

          D.24077 = __builtin_strcmp (name, name2);
        }
        if (D.24077 == 0) goto <D.26477>; else goto <D.26478>;
        <D.26477>:
        {
          size_t __s1_len;
          size_t __s2_len;

          D.24086 = __builtin_strcmp (name_space, name_space2);
        }
        if (D.24086 == 0) goto <D.26479>; else goto <D.26480>;
        <D.26479>:
        {
          int ret;

          ret = pthread_mutex_unlock (&aot_mutex.mutex);
          if (ret != 0) goto <D.26481>; else goto <D.26482>;
          <D.26481>:
          monoeg_g_log (0B, 16, "Bad call to mono_mutex_unlock result %d", ret);
          <D.26482>:
          D.26483 = ret != 0;
          D.26484 = (long int) D.26483;
          D.26485 = __builtin_expect (D.26484, 0);
          if (D.26485 != 0) goto <D.26486>; else goto <D.26487>;
          <D.26486>:
          monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "aot-runtime.c", 2116, "ret == 0");
          <D.26487>:
        }
        D.26488 = mono_class_get (image, token);
        *klass = D.26488;
        D.26439 = *klass;
        if (D.26439 != 0B) goto <D.26489>; else goto <D.26490>;
        <D.26489>:
        {
          int ret;

          ret = pthread_mutex_lock (&aot_mutex.mutex);
          if (ret != 0) goto <D.26491>; else goto <D.26492>;
          <D.26491>:
          monoeg_g_log (0B, 16, "Bad call to mono_mutex_lock result %d", ret);
          <D.26492>:
          D.26493 = ret != 0;
          D.26494 = (long int) D.26493;
          D.26495 = __builtin_expect (D.26494, 0);
          if (D.26495 != 0) goto <D.26496>; else goto <D.26497>;
          <D.26496>:
          monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "aot-runtime.c", 2121, "ret == 0");
          <D.26497>:
        }
        D.26432 = amodule->name_cache;
        nspace_table = monoeg_g_hash_table_lookup (D.26432, name_space);
        if (nspace_table == 0B) goto <D.26498>; else goto <D.26499>;
        <D.26498>:
        nspace_table = monoeg_g_hash_table_new (monoeg_g_str_hash, monoeg_g_str_equal);
        D.26432 = amodule->name_cache;
        monoeg_g_hash_table_insert_replace (D.26432, name_space2, nspace_table, 0);
        <D.26499>:
        D.26439 = *klass;
        monoeg_g_hash_table_insert_replace (nspace_table, name2, D.26439, 0);
        {
          int ret;

          ret = pthread_mutex_unlock (&aot_mutex.mutex);
          if (ret != 0) goto <D.26500>; else goto <D.26501>;
          <D.26500>:
          monoeg_g_log (0B, 16, "Bad call to mono_mutex_unlock result %d", ret);
          <D.26501>:
          D.26502 = ret != 0;
          D.26503 = (long int) D.26502;
          D.26504 = __builtin_expect (D.26503, 0);
          if (D.26504 != 0) goto <D.26505>; else goto <D.26506>;
          <D.26505>:
          monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "aot-runtime.c", 2128, "ret == 0");
          <D.26506>:
        }
        <D.26490>:
        D.26424 = 1;
        return D.26424;
        <D.26480>:
        <D.26478>:
        if (next != 0) goto <D.26507>; else goto <D.24090>;
        <D.26507>:
        D.26508 = next * 2;
        D.26509 = (long unsigned int) D.26508;
        D.26510 = D.26509 * 2;
        entry = table + D.26510;
      }
      goto <D.24091>;
      <D.24090>:
      <D.26468>:
      {
        int ret;

        ret = pthread_mutex_unlock (&aot_mutex.mutex);
        if (ret != 0) goto <D.26511>; else goto <D.26512>;
        <D.26511>:
        monoeg_g_log (0B, 16, "Bad call to mono_mutex_unlock result %d", ret);
        <D.26512>:
        D.26513 = ret != 0;
        D.26514 = (long int) D.26513;
        D.26515 = __builtin_expect (D.26514, 0);
        if (D.26515 != 0) goto <D.26516>; else goto <D.26517>;
        <D.26516>:
        monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "aot-runtime.c", 2141, "ret == 0");
        <D.26517>:
      }
      D.26424 = 1;
      return D.26424;
    }
  finally
    {
      full_name_buf = {CLOBBER};
      cols = {CLOBBER};
    }
}


sprintf (char * restrict __s, const char * restrict __fmt)
{
  int D.26520;
  long unsigned int D.26521;

  D.26521 = __builtin_object_size (__s, 1);
  D.26520 = __builtin___sprintf_chk (__s, 1, D.26521, __fmt, __builtin_va_arg_pack ());
  return D.26520;
}


mono_aot_get_unwind_info (struct MonoJitInfo * ji, guint32 * unwind_info_len)
{
  long unsigned int D.26523;
  long unsigned int D.26524;
  struct MonoMethod * D.26528;
  struct MonoClass * D.26529;
  struct MonoImage * D.26530;
  _Bool D.26531;
  long int D.26532;
  long int D.26533;
  long unsigned int D.26536;
  _Bool D.26537;
  long int D.26538;
  long int D.26539;
  guint8 * D.26544;
  guint8 * D.26546;
  _Bool D.26549;
  long int D.26550;
  long int D.26551;
  struct GHashTable * ji_to_amodule.70;
  _Bool D.26555;
  long int D.26556;
  long int D.26557;
  int iftmp.71;
  _Bool D.26567;
  long int D.26568;
  long int D.26569;
  _Bool D.26574;
  long int D.26575;
  long int D.26576;
  guint8 * D.26579;
  unsigned int D.26580;
  sizetype D.26581;
  guint8 * p.72;
  guint8 * p.73;
  int D.26584;
  unsigned int D.26585;
  guint8 * D.26586;
  struct MonoAotModule * amodule;
  guint8 * p;
  guint8 * code;

  try
    {
      code = ji->code_start;
      D.26523 = BIT_FIELD_REF <*ji, 64, 256>;
      D.26524 = D.26523 & 16777216;
      if (D.26524 != 0) goto <D.26525>; else goto <D.26526>;
      <D.26525>:
      amodule = ji->d.aot_info;
      goto <D.26527>;
      <D.26526>:
      D.26528 = jinfo_get_method (ji);
      D.26529 = D.26528->klass;
      D.26530 = D.26529->image;
      amodule = D.26530->aot_module;
      <D.26527>:
      D.26531 = amodule == 0B;
      D.26532 = (long int) D.26531;
      D.26533 = __builtin_expect (D.26532, 0);
      if (D.26533 != 0) goto <D.26534>; else goto <D.26535>;
      <D.26534>:
      monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "aot-runtime.c", 2655, "amodule");
      <D.26535>:
      D.26523 = BIT_FIELD_REF <*ji, 64, 256>;
      D.26536 = D.26523 & 1048576;
      D.26537 = D.26536 == 0;
      D.26538 = (long int) D.26537;
      D.26539 = __builtin_expect (D.26538, 0);
      if (D.26539 != 0) goto <D.26540>; else goto <D.26541>;
      <D.26540>:
      monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "aot-runtime.c", 2656, "ji->from_aot");
      <D.26541>:
      D.26544 = amodule->code;
      if (D.26544 > code) goto <D.26542>; else goto <D.26545>;
      <D.26545>:
      D.26546 = amodule->code_end;
      if (D.26546 < code) goto <D.26542>; else goto <D.26543>;
      <D.26542>:
      {
        int ret;

        ret = pthread_mutex_lock (&aot_mutex.mutex);
        if (ret != 0) goto <D.26547>; else goto <D.26548>;
        <D.26547>:
        monoeg_g_log (0B, 16, "Bad call to mono_mutex_lock result %d", ret);
        <D.26548>:
        D.26549 = ret != 0;
        D.26550 = (long int) D.26549;
        D.26551 = __builtin_expect (D.26550, 0);
        if (D.26551 != 0) goto <D.26552>; else goto <D.26553>;
        <D.26552>:
        monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "aot-runtime.c", 2660, "ret == 0");
        <D.26553>:
      }
      ji_to_amodule.70 = ji_to_amodule;
      D.26555 = ji_to_amodule.70 == 0B;
      D.26556 = (long int) D.26555;
      D.26557 = __builtin_expect (D.26556, 0);
      if (D.26557 != 0) goto <D.26558>; else goto <D.26559>;
      <D.26558>:
      monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "aot-runtime.c", 2661, "ji_to_amodule");
      <D.26559>:
      ji_to_amodule.70 = ji_to_amodule;
      amodule = monoeg_g_hash_table_lookup (ji_to_amodule.70, ji);
      D.26531 = amodule == 0B;
      D.26532 = (long int) D.26531;
      D.26533 = __builtin_expect (D.26532, 0);
      if (D.26533 != 0) goto <D.26560>; else goto <D.26561>;
      <D.26560>:
      monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "aot-runtime.c", 2663, "amodule");
      <D.26561>:
      D.26544 = amodule->code;
      if (D.26544 > code) goto <D.26563>; else goto <D.26566>;
      <D.26566>:
      D.26546 = amodule->code_end;
      if (D.26546 < code) goto <D.26563>; else goto <D.26564>;
      <D.26563>:
      iftmp.71 = 1;
      goto <D.26565>;
      <D.26564>:
      iftmp.71 = 0;
      <D.26565>:
      D.26567 = iftmp.71 != 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", 2664, "code >= amodule->code && code <= amodule->code_end");
      <D.26571>:
      {
        int ret;

        ret = pthread_mutex_unlock (&aot_mutex.mutex);
        if (ret != 0) goto <D.26572>; else goto <D.26573>;
        <D.26572>:
        monoeg_g_log (0B, 16, "Bad call to mono_mutex_unlock result %d", ret);
        <D.26573>:
        D.26574 = ret != 0;
        D.26575 = (long int) D.26574;
        D.26576 = __builtin_expect (D.26575, 0);
        if (D.26576 != 0) goto <D.26577>; else goto <D.26578>;
        <D.26577>:
        monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "aot-runtime.c", 2665, "ret == 0");
        <D.26578>:
      }
      <D.26543>:
      D.26579 = amodule->unwind_info;
      D.26580 = ji->used_regs;
      D.26581 = (sizetype) D.26580;
      p.72 = D.26579 + D.26581;
      p = p.72;
      p.73 = p;
      D.26584 = decode_value (p.73, &p);
      D.26585 = (unsigned int) D.26584;
      *unwind_info_len = D.26585;
      D.26586 = p;
      return D.26586;
    }
  finally
    {
      p = {CLOBBER};
    }
}


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

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


mono_aot_find_jit_info (struct MonoDomain * domain, struct MonoImage * image, void * addr)
{
  unsigned int D.26591;
  struct MonoJitInfo * D.26594;
  struct MonoDomain * D.26595;
  long int addr.74;
  guint8 * D.26599;
  long int D.26600;
  long int D.26601;
  gint32 * D.26602;
  int D.26605;
  long unsigned int D.26606;
  long unsigned int D.26607;
  gint32 * D.26608;
  long unsigned int D.26609;
  long unsigned int D.26610;
  gint32 * D.26611;
  int D.26612;
  int D.26615;
  long unsigned int D.26616;
  long unsigned int D.26617;
  gint32 * D.26618;
  sizetype D.26619;
  sizetype D.26620;
  sizetype D.26621;
  gint32 * D.26622;
  int D.26623;
  long unsigned int D.26624;
  long unsigned int D.26625;
  gint32 * D.26626;
  int D.26627;
  int D.26628;
  int D.26629;
  long unsigned int D.26630;
  long unsigned int D.26631;
  gint32 * D.26632;
  int D.26633;
  _Bool D.26634;
  long int D.26635;
  long int D.26636;
  int D.26639;
  gint32 * * D.26640;
  void * D.26641;
  int D.26648;
  long int D.26650;
  guint8 * D.26651;
  long int D.26652;
  long int D.26653;
  int D.26654;
  int D.26655;
  long unsigned int D.26656;
  long unsigned int D.26657;
  gint32 * D.26658;
  int D.26659;
  int D.26663;
  long unsigned int D.26664;
  long unsigned int D.26665;
  gint32 * D.26666;
  int D.26671;
  _Bool D.26672;
  long int D.26673;
  long int D.26674;
  int D.26679;
  _Bool D.26680;
  long int D.26681;
  long int D.26682;
  sizetype D.26685;
  sizetype D.26686;
  sizetype D.26687;
  gint32 * D.26688;
  long unsigned int D.26693;
  struct JitInfoMap * D.26694;
  int D.26695;
  long unsigned int D.26698;
  long unsigned int D.26699;
  gint32 * D.26700;
  int D.26701;
  sizetype D.26702;
  guint8 * D.26703;
  guint32 * D.26704;
  unsigned int D.26705;
  sizetype D.26706;
  long int code.75;
  long int D.26710;
  int iftmp.76;
  sizetype D.26717;
  guint8 * D.26718;
  _Bool D.26719;
  long int D.26720;
  long int D.26721;
  struct GHashTable * D.26726;
  _Bool D.26731;
  long int D.26732;
  long int D.26733;
  const void * D.26736;
  _Bool D.26739;
  long int D.26740;
  long int D.26741;
  <unnamed-unsigned:24> D.26747;
  int D.26748;
  guint32 * D.26751;
  unsigned int D.26752;
  _Bool D.26753;
  long int D.26754;
  long int D.26755;
  guint32 * D.26758;
  unsigned int D.26759;
  unsigned int method_index.77;
  guint32 * D.26765;
  unsigned int D.26766;
  sizetype D.26767;
  guint8 * p.78;
  guint8 * p.79;
  int D.26773;
  int D.26774;
  _Bool D.26775;
  long int D.26776;
  long int D.26777;
  unsigned int code_len.80;
  void * D.26781;
  _Bool D.26782;
  long int D.26783;
  long int D.26784;
  int D.26787;
  sizetype D.26788;
  guint8 * D.26789;
  _Bool D.26790;
  long int D.26791;
  long int D.26792;
  int D.26800;
  unsigned int D.26801;
  unsigned int D.26802;
  int D.26803;
  long unsigned int D.26806;
  long unsigned int D.26807;
  struct JitInfoMap * D.26808;
  struct JitInfoMap * * D.26809;
  void * D.26810;
  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.26591 = amodule->info.nmethods;
      nmethods = (int) D.26591;
      if (amodule == 0B) goto <D.26592>; else goto <D.26593>;
      <D.26592>:
      D.26594 = 0B;
      return D.26594;
      <D.26593>:
      D.26595 = mono_get_root_domain ();
      if (D.26595 != domain) goto <D.26596>; else goto <D.26597>;
      <D.26596>:
      D.26594 = 0B;
      return D.26594;
      <D.26597>:
      async = mono_thread_info_is_async_context ();
      addr.74 = (long int) addr;
      D.26599 = amodule->code;
      D.26600 = (long int) D.26599;
      D.26601 = addr.74 - D.26600;
      offset = (int) D.26601;
      D.26602 = amodule->sorted_code_offsets;
      if (D.26602 == 0B) goto <D.26603>; else goto <D.26604>;
      <D.26603>:
      D.26605 = nmethods * 2;
      D.26606 = (long unsigned int) D.26605;
      D.26607 = D.26606 * 4;
      code_offsets = monoeg_malloc0 (D.26607);
      offsets_len = 0;
      i = 0;
      goto <D.24331>;
      <D.24330>:
      D.26608 = amodule->code_offsets;
      D.26609 = (long unsigned int) i;
      D.26610 = D.26609 * 4;
      D.26611 = D.26608 + D.26610;
      D.26612 = *D.26611;
      if (D.26612 == -1) goto <D.26613>; else goto <D.26614>;
      <D.26613>:
      // predicted unlikely by continue predictor.
      goto <D.24329>;
      <D.26614>:
      D.26615 = offsets_len * 2;
      D.26616 = (long unsigned int) D.26615;
      D.26617 = D.26616 * 4;
      D.26618 = code_offsets + D.26617;
      D.26608 = amodule->code_offsets;
      D.26609 = (long unsigned int) i;
      D.26610 = D.26609 * 4;
      D.26611 = D.26608 + D.26610;
      D.26612 = *D.26611;
      *D.26618 = D.26612;
      D.26615 = offsets_len * 2;
      D.26619 = (sizetype) D.26615;
      D.26620 = D.26619 + 1;
      D.26621 = D.26620 * 4;
      D.26622 = code_offsets + D.26621;
      *D.26622 = i;
      offsets_len = offsets_len + 1;
      <D.24329>:
      i = i + 1;
      <D.24331>:
      if (i < nmethods) goto <D.24330>; else goto <D.24332>;
      <D.24332>:
      msort_code_offsets (code_offsets, offsets_len);
      i = 0;
      goto <D.24334>;
      <D.24333>:
      D.26623 = i * 2;
      D.26624 = (long unsigned int) D.26623;
      D.26625 = D.26624 * 4;
      D.26626 = code_offsets + D.26625;
      D.26627 = *D.26626;
      D.26628 = i + 1;
      D.26629 = D.26628 * 2;
      D.26630 = (long unsigned int) D.26629;
      D.26631 = D.26630 * 4;
      D.26632 = code_offsets + D.26631;
      D.26633 = *D.26632;
      D.26634 = D.26627 > D.26633;
      D.26635 = (long int) D.26634;
      D.26636 = __builtin_expect (D.26635, 0);
      if (D.26636 != 0) goto <D.26637>; else goto <D.26638>;
      <D.26637>:
      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.26638>:
      i = i + 1;
      <D.24334>:
      D.26639 = offsets_len + -1;
      if (D.26639 > i) goto <D.24333>; else goto <D.24335>;
      <D.24335>:
      amodule->sorted_code_offsets_len = offsets_len;
      mono_memory_barrier ();
      D.26640 = &amodule->sorted_code_offsets;
      D.26641 = InterlockedCompareExchangePointer (D.26640, code_offsets, 0B);
      if (D.26641 != 0B) goto <D.26642>; else goto <D.26643>;
      <D.26642>:
      monoeg_g_free (code_offsets);
      <D.26643>:
      <D.26604>:
      code_offsets = amodule->sorted_code_offsets;
      offsets_len = amodule->sorted_code_offsets_len;
      if (offsets_len > 0) goto <D.26646>; else goto <D.26647>;
      <D.26646>:
      D.26648 = *code_offsets;
      if (D.26648 > offset) goto <D.26644>; else goto <D.26649>;
      <D.26649>:
      D.26650 = (long int) offset;
      D.26651 = amodule->code_end;
      D.26652 = (long int) D.26651;
      D.26599 = amodule->code;
      D.26600 = (long int) D.26599;
      D.26653 = D.26652 - D.26600;
      if (D.26650 >= D.26653) goto <D.26644>; else goto <D.26645>;
      <D.26644>:
      D.26594 = 0B;
      return D.26594;
      <D.26645>:
      <D.26647>:
      left = 0;
      right = offsets_len;
      <D.24337>:
      D.26654 = left + right;
      pos = D.26654 / 2;
      D.26655 = pos * 2;
      D.26656 = (long unsigned int) D.26655;
      D.26657 = D.26656 * 4;
      D.26658 = code_offsets + D.26657;
      offset1 = *D.26658;
      D.26659 = pos + 1;
      if (D.26659 == offsets_len) goto <D.26660>; else goto <D.26661>;
      <D.26660>:
      D.26651 = amodule->code_end;
      D.26652 = (long int) D.26651;
      D.26599 = amodule->code;
      D.26600 = (long int) D.26599;
      D.26653 = D.26652 - D.26600;
      offset2 = (int) D.26653;
      goto <D.26662>;
      <D.26661>:
      D.26659 = pos + 1;
      D.26663 = D.26659 * 2;
      D.26664 = (long unsigned int) D.26663;
      D.26665 = D.26664 * 4;
      D.26666 = code_offsets + D.26665;
      offset2 = *D.26666;
      <D.26662>:
      if (offset < offset1) goto <D.26667>; else goto <D.26668>;
      <D.26667>:
      right = pos;
      goto <D.26669>;
      <D.26668>:
      if (offset >= offset2) goto <D.26670>; else goto <D.24336>;
      <D.26670>:
      left = pos + 1;
      <D.26669>:
      goto <D.24337>;
      <D.24336>:
      D.26655 = pos * 2;
      D.26656 = (long unsigned int) D.26655;
      D.26657 = D.26656 * 4;
      D.26658 = code_offsets + D.26657;
      D.26671 = *D.26658;
      D.26672 = D.26671 > offset;
      D.26673 = (long int) D.26672;
      D.26674 = __builtin_expect (D.26673, 0);
      if (D.26674 != 0) goto <D.26675>; else goto <D.26676>;
      <D.26675>:
      monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "aot-runtime.c", 2819, "offset >= code_offsets [(pos * 2)]");
      <D.26676>:
      D.26659 = pos + 1;
      if (D.26659 < offsets_len) goto <D.26677>; else goto <D.26678>;
      <D.26677>:
      D.26659 = pos + 1;
      D.26663 = D.26659 * 2;
      D.26664 = (long unsigned int) D.26663;
      D.26665 = D.26664 * 4;
      D.26666 = code_offsets + D.26665;
      D.26679 = *D.26666;
      D.26680 = D.26679 <= offset;
      D.26681 = (long int) D.26680;
      D.26682 = __builtin_expect (D.26681, 0);
      if (D.26682 != 0) goto <D.26683>; else goto <D.26684>;
      <D.26683>:
      monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "aot-runtime.c", 2821, "offset < code_offsets [((pos + 1) * 2)]");
      <D.26684>:
      <D.26678>:
      D.26655 = pos * 2;
      D.26685 = (sizetype) D.26655;
      D.26686 = D.26685 + 1;
      D.26687 = D.26686 * 4;
      D.26688 = code_offsets + D.26687;
      method_index = *D.26688;
      if (async != 0) goto <D.26689>; else goto <D.26690>;
      <D.26689>:
      {
        struct JitInfoMap * table;
        int len;

        table = amodule->async_jit_info_table;
        if (table != 0B) goto <D.26691>; else goto <D.26692>;
        <D.26691>:
        len = table->method_index;
        i = 1;
        goto <D.24341>;
        <D.24340>:
        D.26609 = (long unsigned int) i;
        D.26693 = D.26609 * 16;
        D.26694 = table + D.26693;
        D.26695 = D.26694->method_index;
        if (D.26695 == method_index) goto <D.26696>; else goto <D.26697>;
        <D.26696>:
        D.26609 = (long unsigned int) i;
        D.26693 = D.26609 * 16;
        D.26694 = table + D.26693;
        D.26594 = D.26694->jinfo;
        return D.26594;
        <D.26697>:
        i = i + 1;
        <D.24341>:
        if (i < len) goto <D.24340>; else goto <D.24342>;
        <D.24342>:
        <D.26692>:
      }
      <D.26690>:
      D.26599 = amodule->code;
      D.26608 = amodule->code_offsets;
      D.26698 = (long unsigned int) method_index;
      D.26699 = D.26698 * 4;
      D.26700 = D.26608 + D.26699;
      D.26701 = *D.26700;
      D.26702 = (sizetype) D.26701;
      code = D.26599 + D.26702;
      D.26703 = amodule->blob;
      D.26704 = amodule->ex_info_offsets;
      D.26705 = mono_aot_get_offset (D.26704, method_index);
      D.26706 = (sizetype) D.26705;
      ex_info = D.26703 + D.26706;
      D.26639 = offsets_len + -1;
      if (D.26639 == pos) goto <D.26707>; else goto <D.26708>;
      <D.26707>:
      D.26651 = amodule->code_end;
      D.26652 = (long int) D.26651;
      code.75 = (long int) code;
      D.26710 = D.26652 - code.75;
      code_len = (int) D.26710;
      goto <D.26711>;
      <D.26708>:
      D.26659 = pos + 1;
      D.26663 = D.26659 * 2;
      D.26664 = (long unsigned int) D.26663;
      D.26665 = D.26664 * 4;
      D.26666 = code_offsets + D.26665;
      D.26679 = *D.26666;
      D.26655 = pos * 2;
      D.26656 = (long unsigned int) D.26655;
      D.26657 = D.26656 * 4;
      D.26658 = code_offsets + D.26657;
      D.26671 = *D.26658;
      code_len = D.26679 - D.26671;
      <D.26711>:
      if (code > addr) goto <D.26713>; else goto <D.26716>;
      <D.26716>:
      D.26717 = (sizetype) code_len;
      D.26718 = code + D.26717;
      if (D.26718 <= addr) goto <D.26713>; else goto <D.26714>;
      <D.26713>:
      iftmp.76 = 1;
      goto <D.26715>;
      <D.26714>:
      iftmp.76 = 0;
      <D.26715>:
      D.26719 = iftmp.76 != 0;
      D.26720 = (long int) D.26719;
      D.26721 = __builtin_expect (D.26720, 0);
      if (D.26721 != 0) goto <D.26722>; else goto <D.26723>;
      <D.26722>:
      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.26723>:
      if (async == 0) goto <D.26724>; else goto <D.26725>;
      <D.26724>:
      D.26726 = amodule->extra_methods;
      if (D.26726 != 0B) goto <D.26727>; else goto <D.26728>;
      <D.26727>:
      {
        int ret;

        ret = pthread_mutex_lock (&aot_mutex.mutex);
        if (ret != 0) goto <D.26729>; else goto <D.26730>;
        <D.26729>:
        monoeg_g_log (0B, 16, "Bad call to mono_mutex_lock result %d", ret);
        <D.26730>:
        D.26731 = ret != 0;
        D.26732 = (long int) D.26731;
        D.26733 = __builtin_expect (D.26732, 0);
        if (D.26733 != 0) goto <D.26734>; else goto <D.26735>;
        <D.26734>:
        monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "aot-runtime.c", 2851, "ret == 0");
        <D.26735>:
      }
      D.26726 = amodule->extra_methods;
      D.26698 = (long unsigned int) method_index;
      D.26736 = (const void *) D.26698;
      method = monoeg_g_hash_table_lookup (D.26726, D.26736);
      {
        int ret;

        ret = pthread_mutex_unlock (&aot_mutex.mutex);
        if (ret != 0) goto <D.26737>; else goto <D.26738>;
        <D.26737>:
        monoeg_g_log (0B, 16, "Bad call to mono_mutex_unlock result %d", ret);
        <D.26738>:
        D.26739 = ret != 0;
        D.26740 = (long int) D.26739;
        D.26741 = __builtin_expect (D.26740, 0);
        if (D.26741 != 0) goto <D.26742>; else goto <D.26743>;
        <D.26742>:
        monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "aot-runtime.c", 2853, "ret == 0");
        <D.26743>:
      }
      goto <D.26744>;
      <D.26728>:
      method = 0B;
      <D.26744>:
      if (method == 0B) goto <D.26745>; else goto <D.26746>;
      <D.26745>:
      D.26747 = image->tables[6].rows;
      D.26748 = (int) D.26747;
      if (D.26748 <= method_index) goto <D.26749>; else goto <D.26750>;
      <D.26749>:
      D.26751 = amodule->extra_method_info_offsets;
      D.26752 = *D.26751;
      table_len = (int) D.26752;
      D.26751 = amodule->extra_method_info_offsets;
      table = D.26751 + 4;
      left = 0;
      right = table_len;
      pos = 0;
      <D.24346>:
      D.26654 = left + right;
      pos = D.26654 / 2;
      D.26753 = pos >= table_len;
      D.26754 = (long int) D.26753;
      D.26755 = __builtin_expect (D.26754, 0);
      if (D.26755 != 0) goto <D.26756>; else goto <D.26757>;
      <D.26756>:
      monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "aot-runtime.c", 2874, "pos < table_len");
      <D.26757>:
      D.26655 = pos * 2;
      D.26656 = (long unsigned int) D.26655;
      D.26657 = D.26656 * 4;
      D.26758 = table + D.26657;
      D.26759 = *D.26758;
      method_index.77 = (unsigned int) method_index;
      if (D.26759 < method_index.77) goto <D.26761>; else goto <D.26762>;
      <D.26761>:
      left = pos + 1;
      goto <D.26763>;
      <D.26762>:
      D.26655 = pos * 2;
      D.26656 = (long unsigned int) D.26655;
      D.26657 = D.26656 * 4;
      D.26758 = table + D.26657;
      D.26759 = *D.26758;
      method_index.77 = (unsigned int) method_index;
      if (D.26759 > method_index.77) goto <D.26764>; else goto <D.24345>;
      <D.26764>:
      right = pos;
      <D.26763>:
      goto <D.24346>;
      <D.24345>:
      D.26703 = amodule->blob;
      D.26655 = pos * 2;
      D.26685 = (sizetype) D.26655;
      D.26686 = D.26685 + 1;
      D.26687 = D.26686 * 4;
      D.26765 = table + D.26687;
      D.26766 = *D.26765;
      D.26767 = (sizetype) D.26766;
      p.78 = D.26703 + D.26767;
      p = p.78;
      p.79 = p;
      method = decode_resolve_method_ref (amodule, p.79, &p);
      if (method == 0B) goto <D.26770>; else goto <D.26771>;
      <D.26770>:
      D.26594 = 0B;
      return D.26594;
      <D.26771>:
      goto <D.26772>;
      <D.26750>:
      D.26773 = method_index + 1;
      D.26774 = D.26773 | 100663296;
      token = (guint32) D.26774;
      method = mono_get_method (image, token, 0B);
      <D.26772>:
      <D.26746>:
      D.26775 = method == 0B;
      D.26776 = (long int) D.26775;
      D.26777 = __builtin_expect (D.26776, 0);
      if (D.26777 != 0) goto <D.26778>; else goto <D.26779>;
      <D.26778>:
      monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "aot-runtime.c", 2895, "method");
      <D.26779>:
      <D.26725>:
      code_len.80 = (unsigned int) code_len;
      jinfo = decode_exception_debug_info (amodule, domain, method, ex_info, addr, code, code_len.80);
      D.26781 = jinfo->code_start;
      D.26782 = D.26781 > addr;
      D.26783 = (long int) D.26782;
      D.26784 = __builtin_expect (D.26783, 0);
      if (D.26784 != 0) goto <D.26785>; else goto <D.26786>;
      <D.26785>:
      monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "aot-runtime.c", 2902, "(guint8*)addr >= (guint8*)jinfo->code_start");
      <D.26786>:
      D.26781 = jinfo->code_start;
      D.26787 = jinfo->code_size;
      D.26788 = (sizetype) D.26787;
      D.26789 = D.26781 + D.26788;
      D.26790 = D.26789 <= addr;
      D.26791 = (long int) D.26790;
      D.26792 = __builtin_expect (D.26791, 0);
      if (D.26792 != 0) goto <D.26793>; else goto <D.26794>;
      <D.26793>:
      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.26794>:
      if (async != 0) goto <D.26795>; else goto <D.26796>;
      <D.26795>:
      {
        struct JitInfoMap * old_table;
        struct JitInfoMap * new_table;
        int len;

        <D.24351>:
        old_table = amodule->async_jit_info_table;
        if (old_table != 0B) goto <D.26797>; else goto <D.26798>;
        <D.26797>:
        len = old_table->method_index;
        goto <D.26799>;
        <D.26798>:
        len = 1;
        <D.26799>:
        D.26800 = len + 1;
        D.26801 = (unsigned int) D.26800;
        D.26802 = D.26801 * 16;
        D.26803 = (int) D.26802;
        new_table = alloc0_jit_info_data (domain, D.26803, async);
        if (old_table != 0B) goto <D.26804>; else goto <D.26805>;
        <D.26804>:
        D.26806 = (long unsigned int) len;
        D.26807 = D.26806 * 16;
        memcpy (new_table, old_table, D.26807);
        <D.26805>:
        D.26800 = len + 1;
        new_table->method_index = D.26800;
        D.26806 = (long unsigned int) len;
        D.26807 = D.26806 * 16;
        D.26808 = new_table + D.26807;
        D.26808->method_index = method_index;
        D.26806 = (long unsigned int) len;
        D.26807 = D.26806 * 16;
        D.26808 = new_table + D.26807;
        D.26808->jinfo = jinfo;
        mono_memory_barrier ();
        D.26809 = &amodule->async_jit_info_table;
        D.26810 = InterlockedCompareExchangePointer (D.26809, new_table, old_table);
        if (D.26810 == old_table) goto <D.24350>; else goto <D.26811>;
        <D.26811>:
        goto <D.24351>;
        <D.24350>:
      }
      goto <D.26812>;
      <D.26796>:
      mono_jit_info_table_add (domain, jinfo);
      <D.26812>:
      D.26594 = jinfo;
      return D.26594;
    }
  finally
    {
      p = {CLOBBER};
    }
}


msort_code_offsets (gint32 * array, int len)
{
  int D.26815;
  long unsigned int D.26816;
  long unsigned int D.26817;
  int D.26818;
  gint32 * scratch;

  D.26815 = len * 2;
  D.26816 = (long unsigned int) D.26815;
  D.26817 = D.26816 * 4;
  scratch = monoeg_malloc (D.26817);
  D.26818 = len + -1;
  msort_code_offsets_internal (array, 0, D.26818, scratch);
  monoeg_g_free (scratch);
}


msort_code_offsets_internal (gint32 * array, int lo, int hi, gint32 * scratch)
{
  int D.26819;
  int D.26822;
  int D.26825;
  long unsigned int D.26826;
  long unsigned int D.26827;
  gint32 * D.26828;
  int D.26829;
  sizetype D.26830;
  sizetype D.26831;
  sizetype D.26832;
  gint32 * D.26833;
  int D.26834;
  int D.26838;
  int D.26839;
  long unsigned int D.26840;
  long unsigned int D.26841;
  gint32 * D.26842;
  int D.26843;
  int D.26844;
  long unsigned int D.26845;
  long unsigned int D.26846;
  gint32 * D.26847;
  int D.26848;
  int D.26856;
  long unsigned int D.26857;
  long unsigned int D.26858;
  gint32 * D.26859;
  int D.26860;
  int D.26861;
  long unsigned int D.26862;
  long unsigned int D.26863;
  gint32 * D.26864;
  int D.26865;
  gint32 * D.26866;
  sizetype D.26867;
  sizetype D.26868;
  gint32 * D.26869;
  sizetype D.26870;
  sizetype D.26871;
  sizetype D.26872;
  gint32 * D.26873;
  int D.26874;
  sizetype D.26875;
  sizetype D.26876;
  sizetype D.26877;
  gint32 * D.26878;
  int D.26879;
  int D.26880;
  gint32 * D.26881;
  int D.26882;
  int mid;
  int i;
  int t_lo;
  int t_hi;

  D.26819 = lo + hi;
  mid = D.26819 / 2;
  if (lo >= hi) goto <D.26820>; else goto <D.26821>;
  <D.26820>:
  return;
  <D.26821>:
  D.26822 = hi - lo;
  if (D.26822 <= 31) goto <D.26823>; else goto <D.26824>;
  <D.26823>:
  i = lo;
  goto <D.24290>;
  <D.24289>:
  D.26825 = i * 2;
  D.26826 = (long unsigned int) D.26825;
  D.26827 = D.26826 * 4;
  D.26828 = array + D.26827;
  D.26829 = *D.26828;
  D.26825 = i * 2;
  D.26830 = (sizetype) D.26825;
  D.26831 = D.26830 + 2;
  D.26832 = D.26831 * 4;
  D.26833 = array + D.26832;
  D.26834 = *D.26833;
  if (D.26829 > D.26834) goto <D.24288>; else goto <D.26835>;
  <D.26835>:
  i = i + 1;
  <D.24290>:
  if (i < hi) goto <D.24289>; else goto <D.24288>;
  <D.24288>:
  if (i == hi) goto <D.26836>; else goto <D.26837>;
  <D.26836>:
  return;
  <D.26837>:
  <D.26824>:
  msort_code_offsets_internal (array, lo, mid, scratch);
  D.26838 = mid + 1;
  msort_code_offsets_internal (array, D.26838, hi, scratch);
  D.26839 = mid * 2;
  D.26840 = (long unsigned int) D.26839;
  D.26841 = D.26840 * 4;
  D.26842 = array + D.26841;
  D.26843 = *D.26842;
  D.26838 = mid + 1;
  D.26844 = D.26838 * 2;
  D.26845 = (long unsigned int) D.26844;
  D.26846 = D.26845 * 4;
  D.26847 = array + D.26846;
  D.26848 = *D.26847;
  if (D.26843 < D.26848) goto <D.26849>; else goto <D.26850>;
  <D.26849>:
  return;
  <D.26850>:
  t_lo = lo;
  t_hi = mid + 1;
  i = lo;
  goto <D.24292>;
  <D.24291>:
  if (t_lo <= mid) goto <D.26854>; else goto <D.26851>;
  <D.26854>:
  if (t_hi > hi) goto <D.26852>; else goto <D.26855>;
  <D.26855>:
  D.26856 = t_lo * 2;
  D.26857 = (long unsigned int) D.26856;
  D.26858 = D.26857 * 4;
  D.26859 = array + D.26858;
  D.26860 = *D.26859;
  D.26861 = t_hi * 2;
  D.26862 = (long unsigned int) D.26861;
  D.26863 = D.26862 * 4;
  D.26864 = array + D.26863;
  D.26865 = *D.26864;
  if (D.26860 < D.26865) goto <D.26852>; else goto <D.26851>;
  <D.26852>:
  D.26825 = i * 2;
  D.26826 = (long unsigned int) D.26825;
  D.26827 = D.26826 * 4;
  D.26866 = scratch + D.26827;
  D.26856 = t_lo * 2;
  D.26857 = (long unsigned int) D.26856;
  D.26858 = D.26857 * 4;
  D.26859 = array + D.26858;
  D.26860 = *D.26859;
  *D.26866 = D.26860;
  D.26825 = i * 2;
  D.26830 = (sizetype) D.26825;
  D.26867 = D.26830 + 1;
  D.26868 = D.26867 * 4;
  D.26869 = scratch + D.26868;
  D.26856 = t_lo * 2;
  D.26870 = (sizetype) D.26856;
  D.26871 = D.26870 + 1;
  D.26872 = D.26871 * 4;
  D.26873 = array + D.26872;
  D.26874 = *D.26873;
  *D.26869 = D.26874;
  t_lo = t_lo + 1;
  goto <D.26853>;
  <D.26851>:
  D.26825 = i * 2;
  D.26826 = (long unsigned int) D.26825;
  D.26827 = D.26826 * 4;
  D.26866 = scratch + D.26827;
  D.26861 = t_hi * 2;
  D.26862 = (long unsigned int) D.26861;
  D.26863 = D.26862 * 4;
  D.26864 = array + D.26863;
  D.26865 = *D.26864;
  *D.26866 = D.26865;
  D.26825 = i * 2;
  D.26830 = (sizetype) D.26825;
  D.26867 = D.26830 + 1;
  D.26868 = D.26867 * 4;
  D.26869 = scratch + D.26868;
  D.26861 = t_hi * 2;
  D.26875 = (sizetype) D.26861;
  D.26876 = D.26875 + 1;
  D.26877 = D.26876 * 4;
  D.26878 = array + D.26877;
  D.26879 = *D.26878;
  *D.26869 = D.26879;
  t_hi = t_hi + 1;
  <D.26853>:
  i = i + 1;
  <D.24292>:
  if (i <= hi) goto <D.24291>; else goto <D.24293>;
  <D.24293>:
  i = lo;
  goto <D.24295>;
  <D.24294>:
  D.26825 = i * 2;
  D.26826 = (long unsigned int) D.26825;
  D.26827 = D.26826 * 4;
  D.26828 = array + D.26827;
  D.26825 = i * 2;
  D.26826 = (long unsigned int) D.26825;
  D.26827 = D.26826 * 4;
  D.26866 = scratch + D.26827;
  D.26880 = *D.26866;
  *D.26828 = D.26880;
  D.26825 = i * 2;
  D.26830 = (sizetype) D.26825;
  D.26867 = D.26830 + 1;
  D.26868 = D.26867 * 4;
  D.26881 = array + D.26868;
  D.26825 = i * 2;
  D.26830 = (sizetype) D.26825;
  D.26867 = D.26830 + 1;
  D.26868 = D.26867 * 4;
  D.26869 = scratch + D.26868;
  D.26882 = *D.26869;
  *D.26881 = D.26882;
  i = i + 1;
  <D.24295>:
  if (i <= hi) goto <D.24294>; else goto <D.24296>;
  <D.24296>:
}


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.81;
  int D.26885;
  unsigned int D.26886;
  _Bool D.26887;
  unsigned int D.26888;
  _Bool D.26889;
  unsigned int D.26890;
  _Bool D.26891;
  unsigned int D.26892;
  _Bool D.26893;
  unsigned int D.26894;
  _Bool D.26895;
  unsigned int D.26896;
  _Bool D.26897;
  unsigned int D.26898;
  _Bool D.26899;
  unsigned int D.26900;
  _Bool D.26901;
  int D.26904;
  _Bool D.26905;
  long int D.26906;
  long int D.26907;
  int D.26911;
  long unsigned int D.26917;
  unsigned int D.26918;
  unsigned int D.26919;
  unsigned int D.26920;
  _Bool D.26930;
  long int D.26931;
  long int D.26932;
  long unsigned int D.26935;
  long unsigned int D.26936;
  long unsigned int D.26937;
  long unsigned int D.26938;
  long unsigned int D.26939;
  int D.26940;
  unsigned int D.26941;
  int D.26942;
  struct MonoClass * D.26945;
  long unsigned int D.26947;
  struct GSList * * D.26948;
  struct GSList * D.26949;
  long int D.26950;
  void * D.26951;
  struct GSList * D.26952;
  int D.26953;
  int D.26954;
  unsigned int D.26956;
  unsigned int D.26957;
  unsigned int generic_info_size.82;
  unsigned int D.26959;
  unsigned int try_holes_info_size.83;
  unsigned int D.26961;
  unsigned int arch_eh_jit_info_size.84;
  unsigned int D.26963;
  unsigned int D.26964;
  short unsigned int D.26965;
  <unnamed-unsigned:15> D.26966;
  int D.26967;
  unsigned int D.26968;
  int D.26969;
  unsigned int D.26970;
  unsigned int D.26971;
  int D.26974;
  sizetype D.26975;
  void * D.26976;
  sizetype D.26982;
  guint8 * p.85;
  struct MonoClass * D.26985;
  int D.26986;
  sizetype D.26987;
  void * D.26988;
  int D.26989;
  sizetype D.26990;
  void * D.26991;
  int D.26992;
  sizetype D.26993;
  void * D.26994;
  <unnamed-unsigned:15> D.26995;
  int D.26996;
  int code_len.86;
  _Bool D.27000;
  long int D.27001;
  long int D.27002;
  short unsigned int D.27005;
  int D.27006;
  short unsigned int D.27007;
  int D.27008;
  short unsigned int D.27009;
  int D.27010;
  unsigned int D.27011;
  int D.27014;
  unsigned int D.27015;
  struct MonoJitInfo * D.27018;
  _Bool D.27021;
  long int D.27022;
  long int D.27023;
  int D.27026;
  int D.27027;
  unsigned int D.27030;
  unsigned int D.27031;
  int D.27032;
  void * D.27033;
  struct MonoDwarfLocListEntry * D.27034;
  long unsigned int D.27035;
  int D.27036;
  int D.27037;
  int D.27038;
  int D.27041;
  int D.27044;
  int D.27045;
  int this_reg.87;
  _Bool D.27050;
  <unnamed-signed:1> D.27051;
  unsigned char D.27052;
  int this_offset.88;
  int D.27055;
  signed char D.27056;
  <unnamed-signed:1> D.27057;
  int D.27058;
  unsigned char D.27059;
  int D.27060;
  sizetype D.27063;
  guint8 * p.89;
  struct MonoMethod * D.27066;
  void * D.27067;
  int D.27068;
  unsigned int n.90;
  unsigned int D.27074;
  int D.27075;
  void * D.27076;
  gboolean * D.27077;
  long unsigned int D.27078;
  long unsigned int D.27079;
  gboolean * D.27080;
  int D.27081;
  void * D.27084;
  gboolean * D.27085;
  gboolean * D.27086;
  int D.27087;
  long unsigned int D.27092;
  long unsigned int D.27093;
  long unsigned int D.27094;
  int D.27095;
  int D.27096;
  int D.27097;
  int D.27098;
  int D.27099;
  long unsigned int D.27100;
  long unsigned int D.27101;
  void * D.27102;
  int * D.27103;
  long unsigned int D.27104;
  long unsigned int D.27105;
  int * D.27106;
  int D.27107;
  union mono_mutex_t * D.27108;
  _Bool D.27111;
  long int D.27112;
  long int D.27113;
  void * D.27116;
  struct GHashTable * D.27117;
  _Bool D.27120;
  long int D.27121;
  long int D.27122;
  unsigned int buf_len.91;
  sizetype D.27128;
  guint8 * p.92;
  guint8 * p.93;
  long unsigned int p.94;
  long unsigned int D.27134;
  sizetype D.27135;
  guint8 * p.95;
  struct MonoMethod * D.27137;
  struct MonoClass * D.27138;
  struct MonoImage * D.27139;
  void * D.27140;
  _Bool D.27145;
  long int D.27146;
  long int D.27147;
  struct GHashTable * ji_to_amodule.96;
  struct GHashTable * ji_to_amodule.97;
  _Bool D.27156;
  long int D.27157;
  long int D.27158;
  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.81 = p;
      D.26885 = decode_value (p.81, &p);
      flags = (guint) D.26885;
      D.26886 = flags & 1;
      D.26887 = D.26886 != 0;
      has_generic_jit_info = (gboolean) D.26887;
      D.26888 = flags & 2;
      D.26889 = D.26888 != 0;
      has_dwarf_unwind_info = (gboolean) D.26889;
      D.26890 = flags & 4;
      D.26891 = D.26890 != 0;
      has_clauses = (gboolean) D.26891;
      D.26892 = flags & 8;
      D.26893 = D.26892 != 0;
      has_seq_points = (gboolean) D.26893;
      D.26894 = flags & 16;
      D.26895 = D.26894 != 0;
      from_llvm = (gboolean) D.26895;
      D.26896 = flags & 32;
      D.26897 = D.26896 != 0;
      has_try_block_holes = (gboolean) D.26897;
      D.26898 = flags & 64;
      D.26899 = D.26898 != 0;
      has_gc_map = (gboolean) D.26899;
      D.26900 = flags & 128;
      D.26901 = D.26900 != 0;
      has_arch_eh_jit_info = (gboolean) D.26901;
      if (has_dwarf_unwind_info != 0) goto <D.26902>; else goto <D.26903>;
      <D.26902>:
      {
        guint32 offset;

        p.81 = p;
        D.26904 = decode_value (p.81, &p);
        offset = (guint32) D.26904;
        D.26905 = offset > 1073741823;
        D.26906 = (long int) D.26905;
        D.26907 = __builtin_expect (D.26906, 0);
        if (D.26907 != 0) goto <D.26908>; else goto <D.26909>;
        <D.26908>:
        monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "aot-runtime.c", 2383, "offset < (1 << 30)");
        <D.26909>:
        used_int_regs = offset;
      }
      goto <D.26910>;
      <D.26903>:
      p.81 = p;
      D.26911 = decode_value (p.81, &p);
      used_int_regs = (guint) D.26911;
      <D.26910>:
      if (has_generic_jit_info != 0) goto <D.26912>; else goto <D.26913>;
      <D.26912>:
      generic_info_size = 32;
      goto <D.26914>;
      <D.26913>:
      generic_info_size = 0;
      <D.26914>:
      if (has_try_block_holes != 0) goto <D.26915>; else goto <D.26916>;
      <D.26915>:
      p.81 = p;
      num_holes = decode_value (p.81, &p);
      D.26917 = (long unsigned int) num_holes;
      D.26918 = (unsigned int) D.26917;
      D.26919 = D.26918 * 8;
      D.26920 = D.26919 + 4;
      try_holes_info_size = (int) D.26920;
      goto <D.26921>;
      <D.26916>:
      try_holes_info_size = 0;
      num_holes = try_holes_info_size;
      <D.26921>:
      if (has_clauses != 0) goto <D.26922>; else goto <D.26923>;
      <D.26922>:
      p.81 = p;
      num_clauses = decode_value (p.81, &p);
      goto <D.26924>;
      <D.26923>:
      num_clauses = 0;
      <D.26924>:
      if (has_arch_eh_jit_info != 0) goto <D.26925>; else goto <D.26926>;
      <D.26925>:
      arch_eh_jit_info_size = 4;
      goto <D.26927>;
      <D.26926>:
      arch_eh_jit_info_size = 0;
      <D.26927>:
      if (from_llvm != 0) goto <D.26928>; else goto <D.26929>;
      <D.26928>:
      {
        struct MonoJitExceptionInfo * clauses;
        struct GSList * * nesting;

        D.26930 = async != 0;
        D.26931 = (long int) D.26930;
        D.26932 = __builtin_expect (D.26931, 0);
        if (D.26932 != 0) goto <D.26933>; else goto <D.26934>;
        <D.26933>:
        monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "aot-runtime.c", 2414, "!async");
        <D.26934>:
        D.26935 = (long unsigned int) num_clauses;
        D.26936 = D.26935 * 40;
        clauses = monoeg_malloc0 (D.26936);
        D.26935 = (long unsigned int) num_clauses;
        D.26937 = D.26935 * 8;
        nesting = monoeg_malloc0 (D.26937);
        i = 0;
        goto <D.24212>;
        <D.24211>:
        {
          struct MonoJitExceptionInfo * ei;

          D.26938 = (long unsigned int) i;
          D.26939 = D.26938 * 40;
          ei = clauses + D.26939;
          p.81 = p;
          D.26940 = decode_value (p.81, &p);
          D.26941 = (unsigned int) D.26940;
          ei->flags = D.26941;
          p.81 = p;
          D.26942 = decode_value (p.81, &p);
          if (D.26942 != 0) goto <D.26943>; else goto <D.26944>;
          <D.26943>:
          p.81 = p;
          D.26945 = decode_klass_ref (amodule, p.81, &p);
          ei->data.catch_class = D.26945;
          <D.26944>:
          <D.24210>:
          {
            int nesting_index;

            p.81 = p;
            nesting_index = decode_value (p.81, &p);
            if (nesting_index == -1) goto <D.24209>; else goto <D.26946>;
            <D.26946>:
            D.26938 = (long unsigned int) i;
            D.26947 = D.26938 * 8;
            D.26948 = nesting + D.26947;
            D.26938 = (long unsigned int) i;
            D.26947 = D.26938 * 8;
            D.26948 = nesting + D.26947;
            D.26949 = *D.26948;
            D.26950 = (long int) nesting_index;
            D.26951 = (void *) D.26950;
            D.26952 = monoeg_g_slist_prepend (D.26949, D.26951);
            *D.26948 = D.26952;
          }
          goto <D.24210>;
          <D.24209>:
        }
        i = i + 1;
        <D.24212>:
        if (i < num_clauses) goto <D.24211>; else goto <D.24213>;
        <D.24213>:
        D.26953 = generic_info_size + try_holes_info_size;
        D.26954 = D.26953 + arch_eh_jit_info_size;
        jinfo = decode_llvm_mono_eh_frame (amodule, domain, method, code, clauses, num_clauses, D.26954, nesting, &this_reg, &this_offset);
        jinfo->from_llvm = -1;
        monoeg_g_free (clauses);
        i = 0;
        goto <D.24215>;
        <D.24214>:
        D.26938 = (long unsigned int) i;
        D.26947 = D.26938 * 8;
        D.26948 = nesting + D.26947;
        D.26949 = *D.26948;
        monoeg_g_slist_free (D.26949);
        i = i + 1;
        <D.24215>:
        if (i < num_clauses) goto <D.24214>; else goto <D.24216>;
        <D.24216>:
        monoeg_g_free (nesting);
      }
      goto <D.26955>;
      <D.26929>:
      D.26935 = (long unsigned int) num_clauses;
      D.26956 = (unsigned int) D.26935;
      D.26957 = D.26956 * 40;
      generic_info_size.82 = (unsigned int) generic_info_size;
      D.26959 = D.26957 + generic_info_size.82;
      try_holes_info_size.83 = (unsigned int) try_holes_info_size;
      D.26961 = D.26959 + try_holes_info_size.83;
      arch_eh_jit_info_size.84 = (unsigned int) arch_eh_jit_info_size;
      D.26963 = D.26961 + arch_eh_jit_info_size.84;
      D.26964 = D.26963 + 48;
      len = (int) D.26964;
      jinfo = alloc0_jit_info_data (domain, len, async);
      D.26965 = (short unsigned int) num_clauses;
      D.26966 = (<unnamed-unsigned:15>) D.26965;
      jinfo->num_clauses = D.26966;
      i = 0;
      goto <D.24220>;
      <D.24219>:
      {
        struct MonoJitExceptionInfo * ei;

        ei = &jinfo->clauses[i];
        p.81 = p;
        D.26967 = decode_value (p.81, &p);
        D.26968 = (unsigned int) D.26967;
        ei->flags = D.26968;
        p.81 = p;
        D.26969 = decode_value (p.81, &p);
        ei->exvar_offset = D.26969;
        D.26970 = ei->flags;
        D.26971 = D.26970 + 4294967295;
        if (D.26971 <= 1) goto <D.26972>; else goto <D.26973>;
        <D.26972>:
        p.81 = p;
        D.26974 = decode_value (p.81, &p);
        D.26975 = (sizetype) D.26974;
        D.26976 = code + D.26975;
        ei->data.filter = D.26976;
        goto <D.26977>;
        <D.26973>:
        {
          int len;

          p.81 = p;
          len = decode_value (p.81, &p);
          if (len > 0) goto <D.26978>; else goto <D.26979>;
          <D.26978>:
          if (async != 0) goto <D.26980>; else goto <D.26981>;
          <D.26980>:
          p.81 = p;
          D.26982 = (sizetype) len;
          p.85 = p.81 + D.26982;
          p = p.85;
          goto <D.26984>;
          <D.26981>:
          p.81 = p;
          D.26985 = decode_klass_ref (amodule, p.81, &p);
          ei->data.catch_class = D.26985;
          <D.26984>:
          <D.26979>:
        }
        <D.26977>:
        p.81 = p;
        D.26986 = decode_value (p.81, &p);
        D.26987 = (sizetype) D.26986;
        D.26988 = code + D.26987;
        ei->try_start = D.26988;
        p.81 = p;
        D.26989 = decode_value (p.81, &p);
        D.26990 = (sizetype) D.26989;
        D.26991 = code + D.26990;
        ei->try_end = D.26991;
        p.81 = p;
        D.26992 = decode_value (p.81, &p);
        D.26993 = (sizetype) D.26992;
        D.26994 = code + D.26993;
        ei->handler_start = D.26994;
      }
      i = i + 1;
      <D.24220>:
      D.26995 = jinfo->num_clauses;
      D.26996 = (int) D.26995;
      if (D.26996 > i) goto <D.24219>; else goto <D.24221>;
      <D.24221>:
      code_len.86 = (int) code_len;
      jinfo->code_size = code_len.86;
      jinfo->used_regs = used_int_regs;
      jinfo->d.method = method;
      jinfo->code_start = code;
      jinfo->domain_neutral = 0;
      jinfo->from_aot = -1;
      <D.26955>:
      if (has_try_block_holes != 0) goto <D.26998>; else goto <D.26999>;
      <D.26998>:
      {
        struct MonoTryBlockHoleTableJitInfo * table;

        jinfo->has_try_block_holes = -1;
        table = mono_jit_info_get_try_block_hole_table_info (jinfo);
        D.27000 = table == 0B;
        D.27001 = (long int) D.27000;
        D.27002 = __builtin_expect (D.27001, 0);
        if (D.27002 != 0) goto <D.27003>; else goto <D.27004>;
        <D.27003>:
        monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "aot-runtime.c", 2491, "table");
        <D.27004>:
        D.27005 = (short unsigned int) num_holes;
        table->num_holes = D.27005;
        i = 0;
        goto <D.24225>;
        <D.24224>:
        {
          struct MonoTryBlockHoleJitInfo * hole;

          hole = &table->holes[i];
          p.81 = p;
          D.27006 = decode_value (p.81, &p);
          D.27007 = (short unsigned int) D.27006;
          hole->clause = D.27007;
          p.81 = p;
          D.27008 = decode_value (p.81, &p);
          D.27009 = (short unsigned int) D.27008;
          hole->length = D.27009;
          p.81 = p;
          D.27010 = decode_value (p.81, &p);
          D.27011 = (unsigned int) D.27010;
          hole->offset = D.27011;
        }
        i = i + 1;
        <D.24225>:
        if (i < num_holes) goto <D.24224>; else goto <D.24226>;
        <D.24226>:
      }
      <D.26999>:
      if (has_arch_eh_jit_info != 0) goto <D.27012>; else goto <D.27013>;
      <D.27012>:
      {
        struct MonoArchEHJitInfo * eh_info;

        jinfo->has_arch_eh_info = -1;
        eh_info = mono_jit_info_get_arch_eh_info (jinfo);
        p.81 = p;
        D.27014 = decode_value (p.81, &p);
        D.27015 = (unsigned int) D.27014;
        eh_info->stack_size = D.27015;
      }
      <D.27013>:
      if (async != 0) goto <D.27016>; else goto <D.27017>;
      <D.27016>:
      jinfo->async = -1;
      jinfo->d.aot_info = amodule;
      D.27018 = jinfo;
      return D.27018;
      <D.27017>:
      if (has_generic_jit_info != 0) goto <D.27019>; else goto <D.27020>;
      <D.27019>:
      {
        struct MonoGenericJitInfo * gi;
        int len;

        jinfo->has_generic_jit_info = -1;
        gi = mono_jit_info_get_generic_jit_info (jinfo);
        D.27021 = gi == 0B;
        D.27022 = (long int) D.27021;
        D.27023 = __builtin_expect (D.27022, 0);
        if (D.27023 != 0) goto <D.27024>; else goto <D.27025>;
        <D.27024>:
        monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "aot-runtime.c", 2526, "gi");
        <D.27025>:
        p.81 = p;
        D.27026 = decode_value (p.81, &p);
        gi->nlocs = D.27026;
        D.27027 = gi->nlocs;
        if (D.27027 != 0) goto <D.27028>; else goto <D.27029>;
        <D.27028>:
        D.27027 = gi->nlocs;
        D.27030 = (unsigned int) D.27027;
        D.27031 = D.27030 * 20;
        D.27032 = (int) D.27031;
        D.27033 = alloc0_jit_info_data (domain, D.27032, async);
        gi->locations = D.27033;
        i = 0;
        goto <D.24232>;
        <D.24231>:
        {
          struct MonoDwarfLocListEntry * entry;

          D.27034 = gi->locations;
          D.26938 = (long unsigned int) i;
          D.27035 = D.26938 * 20;
          entry = D.27034 + D.27035;
          p.81 = p;
          D.27036 = decode_value (p.81, &p);
          entry->is_reg = D.27036;
          p.81 = p;
          D.27037 = decode_value (p.81, &p);
          entry->reg = D.27037;
          D.27038 = entry->is_reg;
          if (D.27038 == 0) goto <D.27039>; else goto <D.27040>;
          <D.27039>:
          p.81 = p;
          D.27041 = decode_value (p.81, &p);
          entry->offset = D.27041;
          <D.27040>:
          if (i > 0) goto <D.27042>; else goto <D.27043>;
          <D.27042>:
          p.81 = p;
          D.27044 = decode_value (p.81, &p);
          entry->from = D.27044;
          <D.27043>:
          p.81 = p;
          D.27045 = decode_value (p.81, &p);
          entry->to = D.27045;
        }
        i = i + 1;
        <D.24232>:
        D.27027 = gi->nlocs;
        if (D.27027 > i) goto <D.24231>; else goto <D.24233>;
        <D.24233>:
        goto <D.27046>;
        <D.27029>:
        if (from_llvm != 0) goto <D.27047>; else goto <D.27048>;
        <D.27047>:
        this_reg.87 = this_reg;
        D.27050 = this_reg.87 != -1;
        D.27051 = (<unnamed-signed:1>) D.27050;
        gi->has_this = D.27051;
        this_reg.87 = this_reg;
        D.27052 = (unsigned char) this_reg.87;
        gi->this_reg = D.27052;
        this_offset.88 = this_offset;
        gi->this_offset = this_offset.88;
        goto <D.27054>;
        <D.27048>:
        p.81 = p;
        D.27055 = decode_value (p.81, &p);
        D.27056 = (signed char) D.27055;
        D.27057 = (<unnamed-signed:1>) D.27056;
        gi->has_this = D.27057;
        p.81 = p;
        D.27058 = decode_value (p.81, &p);
        D.27059 = (unsigned char) D.27058;
        gi->this_reg = D.27059;
        p.81 = p;
        D.27060 = decode_value (p.81, &p);
        gi->this_offset = D.27060;
        <D.27054>:
        <D.27046>:
        p.81 = p;
        len = decode_value (p.81, &p);
        if (async != 0) goto <D.27061>; else goto <D.27062>;
        <D.27061>:
        p.81 = p;
        D.27063 = (sizetype) len;
        p.89 = p.81 + D.27063;
        p = p.89;
        goto <D.27065>;
        <D.27062>:
        p.81 = p;
        D.27066 = decode_resolve_method_ref (amodule, p.81, &p);
        jinfo->d.method = D.27066;
        <D.27065>:
        D.27067 = monoeg_malloc0 (16);
        gi->generic_sharing_context = D.27067;
        p.81 = p;
        D.27068 = decode_value (p.81, &p);
        if (D.27068 != 0) goto <D.27069>; else goto <D.27070>;
        <D.27069>:
        {
          int i;
          int n;
          struct MonoGenericSharingContext * gsctx;

          gsctx = gi->generic_sharing_context;
          p.81 = p;
          n = decode_value (p.81, &p);
          if (n != 0) goto <D.27071>; else goto <D.27072>;
          <D.27071>:
          n.90 = (unsigned int) n;
          D.27074 = n.90 * 4;
          D.27075 = (int) D.27074;
          D.27076 = alloc0_jit_info_data (domain, D.27075, async);
          gsctx->var_is_vt = D.27076;
          i = 0;
          goto <D.24238>;
          <D.24237>:
          D.27077 = gsctx->var_is_vt;
          D.27078 = (long unsigned int) i;
          D.27079 = D.27078 * 4;
          D.27080 = D.27077 + D.27079;
          p.81 = p;
          D.27081 = decode_value (p.81, &p);
          *D.27080 = D.27081;
          i = i + 1;
          <D.24238>:
          if (i < n) goto <D.24237>; else goto <D.24239>;
          <D.24239>:
          <D.27072>:
          p.81 = p;
          n = decode_value (p.81, &p);
          if (n != 0) goto <D.27082>; else goto <D.27083>;
          <D.27082>:
          n.90 = (unsigned int) n;
          D.27074 = n.90 * 4;
          D.27075 = (int) D.27074;
          D.27084 = alloc0_jit_info_data (domain, D.27075, async);
          gsctx->mvar_is_vt = D.27084;
          i = 0;
          goto <D.24241>;
          <D.24240>:
          D.27085 = gsctx->mvar_is_vt;
          D.27078 = (long unsigned int) i;
          D.27079 = D.27078 * 4;
          D.27086 = D.27085 + D.27079;
          p.81 = p;
          D.27087 = decode_value (p.81, &p);
          *D.27086 = D.27087;
          i = i + 1;
          <D.24241>:
          if (i < n) goto <D.24240>; else goto <D.24242>;
          <D.24242>:
          <D.27083>:
        }
        <D.27070>:
      }
      <D.27020>:
      if (method != 0B) goto <D.27088>; else goto <D.27089>;
      <D.27088>:
      if (has_seq_points != 0) goto <D.27090>; else goto <D.27091>;
      <D.27090>:
      {
        struct MonoSeqPointInfo * seq_points;
        int il_offset;
        int native_offset;
        int last_il_offset;
        int last_native_offset;
        int j;
        int len;

        p.81 = p;
        len = decode_value (p.81, &p);
        D.27092 = (long unsigned int) len;
        D.27093 = D.27092 * 32;
        D.27094 = D.27093 + 8;
        seq_points = monoeg_malloc0 (D.27094);
        seq_points->len = len;
        last_native_offset = 0;
        last_il_offset = last_native_offset;
        i = 0;
        goto <D.24255>;
        <D.24254>:
        {
          struct SeqPoint * sp;

          sp = &seq_points->seq_points[i];
          p.81 = p;
          D.27095 = decode_value (p.81, &p);
          il_offset = D.27095 + last_il_offset;
          p.81 = p;
          D.27096 = decode_value (p.81, &p);
          native_offset = D.27096 + last_native_offset;
          sp->il_offset = il_offset;
          sp->native_offset = native_offset;
          p.81 = p;
          D.27097 = decode_value (p.81, &p);
          sp->flags = D.27097;
          p.81 = p;
          D.27098 = decode_value (p.81, &p);
          sp->next_len = D.27098;
          D.27099 = sp->next_len;
          D.27100 = (long unsigned int) D.27099;
          D.27101 = D.27100 * 4;
          D.27102 = monoeg_malloc (D.27101);
          sp->next = D.27102;
          j = 0;
          goto <D.24252>;
          <D.24251>:
          D.27103 = sp->next;
          D.27104 = (long unsigned int) j;
          D.27105 = D.27104 * 4;
          D.27106 = D.27103 + D.27105;
          p.81 = p;
          D.27107 = decode_value (p.81, &p);
          *D.27106 = D.27107;
          j = j + 1;
          <D.24252>:
          D.27099 = sp->next_len;
          if (D.27099 > j) goto <D.24251>; else goto <D.24253>;
          <D.24253>:
          last_il_offset = il_offset;
          last_native_offset = native_offset;
        }
        i = i + 1;
        <D.24255>:
        if (i < len) goto <D.24254>; else goto <D.24256>;
        <D.24256>:
        {
          int ret;

          D.27108 = &domain->lock.mutex;
          ret = pthread_mutex_lock (D.27108);
          if (ret != 0) goto <D.27109>; else goto <D.27110>;
          <D.27109>:
          monoeg_g_log (0B, 16, "Bad call to mono_mutex_lock result %d", ret);
          <D.27110>:
          D.27111 = ret != 0;
          D.27112 = (long int) D.27111;
          D.27113 = __builtin_expect (D.27112, 0);
          if (D.27113 != 0) goto <D.27114>; else goto <D.27115>;
          <D.27114>:
          monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "aot-runtime.c", 2608, "ret == 0");
          <D.27115>:
        }
        D.27116 = domain->runtime_info;
        D.27117 = MEM[(struct MonoJitDomainInfo *)D.27116].seq_points;
        monoeg_g_hash_table_insert_replace (D.27117, method, seq_points, 0);
        {
          int ret;

          D.27108 = &domain->lock.mutex;
          ret = pthread_mutex_unlock (D.27108);
          if (ret != 0) goto <D.27118>; else goto <D.27119>;
          <D.27118>:
          monoeg_g_log (0B, 16, "Bad call to mono_mutex_unlock result %d", ret);
          <D.27119>:
          D.27120 = ret != 0;
          D.27121 = (long int) D.27120;
          D.27122 = __builtin_expect (D.27121, 0);
          if (D.27122 != 0) goto <D.27123>; else goto <D.27124>;
          <D.27123>:
          monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "aot-runtime.c", 2610, "ret == 0");
          <D.27124>:
        }
      }
      <D.27091>:
      <D.27089>:
      p.81 = p;
      buf_len = decode_value (p.81, &p);
      if (async == 0) goto <D.27125>; else goto <D.27126>;
      <D.27125>:
      p.81 = p;
      buf_len.91 = (unsigned int) buf_len;
      mono_debug_add_aot_method (domain, method, code, p.81, buf_len.91);
      <D.27126>:
      p.81 = p;
      D.27128 = (sizetype) buf_len;
      p.92 = p.81 + D.27128;
      p = p.92;
      if (has_gc_map != 0) goto <D.27130>; else goto <D.27131>;
      <D.27130>:
      {
        int map_size;

        p.81 = p;
        map_size = decode_value (p.81, &p);
        goto <D.24261>;
        <D.24260>:
        p.81 = p;
        p.93 = p.81 + 1;
        p = p.93;
        <D.24261>:
        p.81 = p;
        p.94 = (long unsigned int) p.81;
        D.27134 = p.94 & 3;
        if (D.27134 != 0) goto <D.24260>; else goto <D.24262>;
        <D.24262>:
        p.81 = p;
        jinfo->gc_info = p.81;
        p.81 = p;
        D.27135 = (sizetype) map_size;
        p.95 = p.81 + D.27135;
        p = p.95;
      }
      <D.27131>:
      D.27137 = jinfo->d.method;
      D.27138 = D.27137->klass;
      D.27139 = D.27138->image;
      D.27140 = D.27139->aot_module;
      if (D.27140 != amodule) goto <D.27141>; else goto <D.27142>;
      <D.27141>:
      {
        int ret;

        ret = pthread_mutex_lock (&aot_mutex.mutex);
        if (ret != 0) goto <D.27143>; else goto <D.27144>;
        <D.27143>:
        monoeg_g_log (0B, 16, "Bad call to mono_mutex_lock result %d", ret);
        <D.27144>:
        D.27145 = ret != 0;
        D.27146 = (long int) D.27145;
        D.27147 = __builtin_expect (D.27146, 0);
        if (D.27147 != 0) goto <D.27148>; else goto <D.27149>;
        <D.27148>:
        monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "aot-runtime.c", 2629, "ret == 0");
        <D.27149>:
      }
      ji_to_amodule.96 = ji_to_amodule;
      if (ji_to_amodule.96 == 0B) goto <D.27151>; else goto <D.27152>;
      <D.27151>:
      ji_to_amodule.97 = monoeg_g_hash_table_new (0B, 0B);
      ji_to_amodule = ji_to_amodule.97;
      <D.27152>:
      ji_to_amodule.96 = ji_to_amodule;
      monoeg_g_hash_table_insert_replace (ji_to_amodule.96, jinfo, amodule, 0);
      {
        int ret;

        ret = pthread_mutex_unlock (&aot_mutex.mutex);
        if (ret != 0) goto <D.27154>; else goto <D.27155>;
        <D.27154>:
        monoeg_g_log (0B, 16, "Bad call to mono_mutex_unlock result %d", ret);
        <D.27155>:
        D.27156 = ret != 0;
        D.27157 = (long int) D.27156;
        D.27158 = __builtin_expect (D.27157, 0);
        if (D.27158 != 0) goto <D.27159>; else goto <D.27160>;
        <D.27159>:
        monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "aot-runtime.c", 2633, "ret == 0");
        <D.27160>:
      }
      <D.27142>:
      D.27018 = jinfo;
      return D.27018;
    }
  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.27163;
  _Bool D.27164;
  long int D.27165;
  long int D.27166;
  unsigned char D.27169;
  _Bool D.27170;
  long int D.27171;
  long int D.27172;
  long int p.98;
  long int D.27176;
  long int D.27177;
  unsigned int D.27178;
  int D.27179;
  int D.27180;
  sizetype D.27181;
  long int code.99;
  guint8 * D.27183;
  long int D.27184;
  long int D.27185;
  int D.27186;
  int D.27187;
  long unsigned int D.27188;
  long unsigned int D.27189;
  gint32 * D.27190;
  int D.27191;
  _Bool D.27192;
  long int D.27193;
  long int D.27194;
  gint32 * D.27197;
  long unsigned int D.27198;
  long unsigned int D.27199;
  gint32 * D.27200;
  int D.27201;
  guint8 * D.27204;
  long int D.27205;
  long int D.27206;
  int D.27208;
  long unsigned int D.27209;
  long unsigned int D.27210;
  gint32 * D.27211;
  int D.27212;
  _Bool D.27213;
  long int D.27214;
  long int D.27215;
  long unsigned int D.27218;
  long unsigned int D.27219;
  gint32 * D.27220;
  int D.27225;
  sizetype D.27226;
  sizetype D.27229;
  int D.27231;
  sizetype D.27232;
  long int code_end.100;
  long int code_start.101;
  long int D.27235;
  int iftmp.102;
  _Bool D.27241;
  long int D.27242;
  long int D.27243;
  guint8 * D.27246;
  long int D.27251;
  sizetype D.27252;
  sizetype D.27253;
  sizetype D.27254;
  gint32 * D.27255;
  int D.27256;
  sizetype D.27257;
  sizetype D.27258;
  sizetype D.27259;
  sizetype D.27260;
  gint32 * D.27261;
  int D.27262;
  int D.27263;
  int fde_len.103;
  int D.27265;
  int D.27266;
  long unsigned int D.27267;
  long unsigned int D.27268;
  void * * D.27269;
  void * D.27270;
  unsigned int D.27271;
  long unsigned int D.27272;
  long unsigned int D.27273;
  struct GSList * * D.27274;
  void * D.27275;
  long int D.27276;
  long unsigned int D.27277;
  long unsigned int D.27278;
  void * * D.27279;
  void * D.27280;
  unsigned int D.27281;
  unsigned int j.104;
  unsigned int i.105;
  unsigned int D.27286;
  unsigned int D.27287;
  unsigned int extra_size.106;
  unsigned int D.27289;
  unsigned int D.27290;
  guint8 * D.27291;
  unsigned int D.27292;
  unsigned int D.27293;
  short unsigned int D.27294;
  short unsigned int D.27295;
  short unsigned int D.27296;
  <unnamed-unsigned:15> D.27297;
  long unsigned int D.27298;
  long unsigned int D.27299;
  _Bool D.27300;
  long int D.27301;
  long int D.27302;
  unsigned int D.27305;
  struct MonoClass * D.27306;
  long unsigned int D.27307;
  struct MonoJitExceptionInfo * D.27308;
  void * D.27309;
  void * D.27310;
  void * D.27311;
  void * D.27314;
  long int D.27317;
  long int D.27318;
  void * D.27319;
  long unsigned int D.27320;
  long unsigned int D.27321;
  struct GSList * * D.27322;
  void * D.27323;
  long int D.27324;
  struct MonoJitExceptionInfo * D.27327;
  struct MonoJitExceptionInfo * D.27328;
  void * D.27329;
  void * D.27330;
  _Bool D.27331;
  long int D.27332;
  long int D.27333;
  struct MonoJitInfo * D.27336;
  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.27163 = amodule->mono_eh_frame;
      D.27164 = D.27163 == 0B;
      D.27165 = (long int) D.27164;
      D.27166 = __builtin_expect (D.27165, 0);
      if (D.27166 != 0) goto <D.27167>; else goto <D.27168>;
      <D.27167>:
      monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "aot-runtime.c", 2171, "amodule->mono_eh_frame");
      <D.27168>:
      p = amodule->mono_eh_frame;
      D.27169 = *p;
      version = (int) D.27169;
      D.27170 = version != 3;
      D.27171 = (long int) D.27170;
      D.27172 = __builtin_expect (D.27171, 0);
      if (D.27172 != 0) goto <D.27173>; else goto <D.27174>;
      <D.27173>:
      monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "aot-runtime.c", 2179, "version == 3");
      <D.27174>:
      p = p + 1;
      D.27169 = *p;
      func_encoding = (int) D.27169;
      p = p + 1;
      p.98 = (long int) p;
      D.27176 = p.98 + 3;
      D.27177 = D.27176 & -4;
      p = (guint8 *) D.27177;
      D.27178 = MEM[(guint32 *)p];
      fde_count = (int) D.27178;
      p = p + 4;
      table = p;
      D.27179 = fde_count + 1;
      D.27180 = D.27179 * 8;
      D.27181 = (sizetype) D.27180;
      cie = p + D.27181;
      code.99 = (long int) code;
      D.27183 = amodule->code;
      D.27184 = (long int) D.27183;
      D.27185 = code.99 - D.27184;
      offset = (int) D.27185;
      left = 0;
      right = fde_count;
      <D.24132>:
      D.27186 = left + right;
      pos = D.27186 / 2;
      D.27187 = pos * 2;
      D.27188 = (long unsigned int) D.27187;
      D.27189 = D.27188 * 4;
      D.27190 = table + D.27189;
      D.27191 = *D.27190;
      D.27192 = D.27191 == -1;
      D.27193 = (long int) D.27192;
      D.27194 = __builtin_expect (D.27193, 0);
      if (D.27194 != 0) goto <D.27195>; else goto <D.27196>;
      <D.27195>:
      monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "aot-runtime.c", 2200, "table [(pos * 2)] != -1");
      <D.27196>:
      D.27197 = amodule->code_offsets;
      D.27187 = pos * 2;
      D.27188 = (long unsigned int) D.27187;
      D.27189 = D.27188 * 4;
      D.27190 = table + D.27189;
      D.27191 = *D.27190;
      D.27198 = (long unsigned int) D.27191;
      D.27199 = D.27198 * 4;
      D.27200 = D.27197 + D.27199;
      offset1 = *D.27200;
      D.27201 = pos + 1;
      if (D.27201 == fde_count) goto <D.27202>; else goto <D.27203>;
      <D.27202>:
      D.27204 = amodule->code_end;
      D.27205 = (long int) D.27204;
      D.27183 = amodule->code;
      D.27184 = (long int) D.27183;
      D.27206 = D.27205 - D.27184;
      offset2 = (int) D.27206;
      goto <D.27207>;
      <D.27203>:
      D.27201 = pos + 1;
      D.27208 = D.27201 * 2;
      D.27209 = (long unsigned int) D.27208;
      D.27210 = D.27209 * 4;
      D.27211 = table + D.27210;
      D.27212 = *D.27211;
      D.27213 = D.27212 == -1;
      D.27214 = (long int) D.27213;
      D.27215 = __builtin_expect (D.27214, 0);
      if (D.27215 != 0) goto <D.27216>; else goto <D.27217>;
      <D.27216>:
      monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "aot-runtime.c", 2205, "table [(pos + 1) * 2] != -1");
      <D.27217>:
      D.27197 = amodule->code_offsets;
      D.27201 = pos + 1;
      D.27208 = D.27201 * 2;
      D.27209 = (long unsigned int) D.27208;
      D.27210 = D.27209 * 4;
      D.27211 = table + D.27210;
      D.27212 = *D.27211;
      D.27218 = (long unsigned int) D.27212;
      D.27219 = D.27218 * 4;
      D.27220 = D.27197 + D.27219;
      offset2 = *D.27220;
      <D.27207>:
      if (offset < offset1) goto <D.27221>; else goto <D.27222>;
      <D.27221>:
      right = pos;
      goto <D.27223>;
      <D.27222>:
      if (offset >= offset2) goto <D.27224>; else goto <D.24131>;
      <D.27224>:
      left = pos + 1;
      <D.27223>:
      goto <D.24132>;
      <D.24131>:
      D.27183 = amodule->code;
      D.27197 = amodule->code_offsets;
      D.27187 = pos * 2;
      D.27188 = (long unsigned int) D.27187;
      D.27189 = D.27188 * 4;
      D.27190 = table + D.27189;
      D.27191 = *D.27190;
      D.27198 = (long unsigned int) D.27191;
      D.27199 = D.27198 * 4;
      D.27200 = D.27197 + D.27199;
      D.27225 = *D.27200;
      D.27226 = (sizetype) D.27225;
      code_start = D.27183 + D.27226;
      D.27201 = pos + 1;
      if (D.27201 == fde_count) goto <D.27227>; else goto <D.27228>;
      <D.27227>:
      {
        int len;

        D.27201 = pos + 1;
        D.27208 = D.27201 * 2;
        D.27209 = (long unsigned int) D.27208;
        D.27210 = D.27209 * 4;
        D.27211 = table + D.27210;
        len = *D.27211;
        D.27229 = (sizetype) len;
        code_end = code_start + D.27229;
      }
      goto <D.27230>;
      <D.27228>:
      D.27183 = amodule->code;
      D.27197 = amodule->code_offsets;
      D.27201 = pos + 1;
      D.27208 = D.27201 * 2;
      D.27209 = (long unsigned int) D.27208;
      D.27210 = D.27209 * 4;
      D.27211 = table + D.27210;
      D.27212 = *D.27211;
      D.27218 = (long unsigned int) D.27212;
      D.27219 = D.27218 * 4;
      D.27220 = D.27197 + D.27219;
      D.27231 = *D.27220;
      D.27232 = (sizetype) D.27231;
      code_end = D.27183 + D.27232;
      <D.27230>:
      code_end.100 = (long int) code_end;
      code_start.101 = (long int) code_start;
      D.27235 = code_end.100 - code_start.101;
      code_len = (int) D.27235;
      if (code < code_start) goto <D.27237>; else goto <D.27240>;
      <D.27240>:
      if (code >= code_end) goto <D.27237>; else goto <D.27238>;
      <D.27237>:
      iftmp.102 = 1;
      goto <D.27239>;
      <D.27238>:
      iftmp.102 = 0;
      <D.27239>:
      D.27241 = iftmp.102 != 0;
      D.27242 = (long int) D.27241;
      D.27243 = __builtin_expect (D.27242, 0);
      if (D.27243 != 0) goto <D.27244>; else goto <D.27245>;
      <D.27244>:
      monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "aot-runtime.c", 2227, "code >= code_start && code < code_end");
      <D.27245>:
      D.27246 = amodule->thumb_end;
      if (D.27246 != 0B) goto <D.27247>; else goto <D.27248>;
      <D.27247>:
      D.27246 = amodule->thumb_end;
      if (D.27246 > code_start) goto <D.27249>; else goto <D.27250>;
      <D.27249>:
      code_start.101 = (long int) code_start;
      D.27251 = code_start.101 & -2;
      code_start = (guint8 *) D.27251;
      <D.27250>:
      <D.27248>:
      D.27163 = amodule->mono_eh_frame;
      D.27187 = pos * 2;
      D.27252 = (sizetype) D.27187;
      D.27253 = D.27252 + 1;
      D.27254 = D.27253 * 4;
      D.27255 = table + D.27254;
      D.27256 = *D.27255;
      D.27257 = (sizetype) D.27256;
      fde = D.27163 + D.27257;
      D.27201 = pos + 1;
      D.27208 = D.27201 * 2;
      D.27258 = (sizetype) D.27208;
      D.27259 = D.27258 + 1;
      D.27260 = D.27259 * 4;
      D.27261 = table + D.27260;
      D.27262 = *D.27261;
      D.27187 = pos * 2;
      D.27252 = (sizetype) D.27187;
      D.27253 = D.27252 + 1;
      D.27254 = D.27253 * 4;
      D.27255 = table + D.27254;
      D.27256 = *D.27255;
      D.27263 = D.27262 - D.27256;
      fde_len = (guint32) D.27263;
      fde_len.103 = (int) fde_len;
      mono_unwind_decode_llvm_mono_fde (fde, fde_len.103, cie, code_start, &info);
      ei = info.ex_info;
      ei_len = info.ex_info_len;
      type_info = info.type_info;
      D.27265 = info.this_reg;
      *this_reg = D.27265;
      D.27266 = info.this_offset;
      *this_offset = D.27266;
      nested_len = 0;
      i = 0;
      goto <D.24145>;
      <D.24144>:
      {
        gint32 cindex1;
        struct GSList * l;

        D.27267 = (long unsigned int) i;
        D.27268 = D.27267 * 8;
        D.27269 = type_info + D.27268;
        D.27270 = *D.27269;
        D.27271 = MEM[(const guint32 *)D.27270];
        cindex1 = (gint32) D.27271;
        D.27272 = (long unsigned int) cindex1;
        D.27273 = D.27272 * 8;
        D.27274 = nesting + D.27273;
        l = *D.27274;
        goto <D.24142>;
        <D.24141>:
        {
          gint32 nesting_cindex;

          D.27275 = l->data;
          D.27276 = (long int) D.27275;
          nesting_cindex = (gint32) D.27276;
          j = 0;
          goto <D.24139>;
          <D.24138>:
          {
            gint32 cindex2;

            D.27277 = (long unsigned int) j;
            D.27278 = D.27277 * 8;
            D.27279 = type_info + D.27278;
            D.27280 = *D.27279;
            D.27281 = MEM[(const guint32 *)D.27280];
            cindex2 = (gint32) D.27281;
            if (cindex2 == nesting_cindex) goto <D.27282>; else goto <D.27283>;
            <D.27282>:
            nested_len = nested_len + 1;
            <D.27283>:
          }
          j = j + 1;
          <D.24139>:
          j.104 = (unsigned int) j;
          if (j.104 < ei_len) goto <D.24138>; else goto <D.24140>;
          <D.24140>:
        }
        l = l->next;
        <D.24142>:
        if (l != 0B) goto <D.24141>; else goto <D.24143>;
        <D.24143>:
      }
      i = i + 1;
      <D.24145>:
      i.105 = (unsigned int) i;
      if (i.105 < ei_len) goto <D.24144>; else goto <D.24146>;
      <D.24146>:
      D.27286 = ei_len + nested_len;
      D.27287 = D.27286 * 40;
      extra_size.106 = (unsigned int) extra_size;
      D.27289 = D.27287 + extra_size.106;
      D.27290 = D.27289 + 48;
      jinfo = mono_domain_alloc0_lock_free (domain, D.27290);
      jinfo->code_size = code_len;
      D.27291 = info.unw_info;
      D.27292 = info.unw_info_len;
      D.27293 = mono_cache_unwind_info (D.27291, D.27292);
      jinfo->used_regs = D.27293;
      jinfo->d.method = method;
      jinfo->code_start = code;
      jinfo->domain_neutral = 0;
      jinfo->from_aot = 0;
      D.27294 = (short unsigned int) ei_len;
      D.27295 = (short unsigned int) nested_len;
      D.27296 = D.27294 + D.27295;
      D.27297 = (<unnamed-unsigned:15>) D.27296;
      jinfo->num_clauses = D.27297;
      i = 0;
      goto <D.24151>;
      <D.24150>:
      {
        int clause_index;
        struct MonoJitExceptionInfo * jei;
        struct MonoJitExceptionInfo * orig_jei;

        D.27267 = (long unsigned int) i;
        D.27268 = D.27267 * 8;
        D.27269 = type_info + D.27268;
        D.27270 = *D.27269;
        D.27271 = MEM[(const guint32 *)D.27270];
        clause_index = (int) D.27271;
        jei = &jinfo->clauses[i];
        D.27298 = (long unsigned int) clause_index;
        D.27299 = D.27298 * 40;
        orig_jei = clauses + D.27299;
        D.27300 = clause_index >= num_clauses;
        D.27301 = (long int) D.27300;
        D.27302 = __builtin_expect (D.27301, 0);
        if (D.27302 != 0) goto <D.27303>; else goto <D.27304>;
        <D.27303>:
        monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "aot-runtime.c", 2289, "clause_index < num_clauses");
        <D.27304>:
        D.27305 = orig_jei->flags;
        jei->flags = D.27305;
        D.27306 = orig_jei->data.catch_class;
        jei->data.catch_class = D.27306;
        D.27267 = (long unsigned int) i;
        D.27307 = D.27267 * 40;
        D.27308 = ei + D.27307;
        D.27309 = D.27308->try_start;
        jei->try_start = D.27309;
        D.27267 = (long unsigned int) i;
        D.27307 = D.27267 * 40;
        D.27308 = ei + D.27307;
        D.27310 = D.27308->try_end;
        jei->try_end = D.27310;
        D.27267 = (long unsigned int) i;
        D.27307 = D.27267 * 40;
        D.27308 = ei + D.27307;
        D.27311 = D.27308->handler_start;
        jei->handler_start = D.27311;
        D.27246 = amodule->thumb_end;
        if (D.27246 != 0B) goto <D.27312>; else goto <D.27313>;
        <D.27312>:
        D.27314 = jei->handler_start;
        D.27246 = amodule->thumb_end;
        if (D.27314 < D.27246) goto <D.27315>; else goto <D.27316>;
        <D.27315>:
        D.27314 = jei->handler_start;
        D.27317 = (long int) D.27314;
        D.27318 = D.27317 + 1;
        D.27319 = (void *) D.27318;
        jei->handler_start = D.27319;
        <D.27316>:
        <D.27313>:
      }
      i = i + 1;
      <D.24151>:
      i.105 = (unsigned int) i;
      if (i.105 < ei_len) goto <D.24150>; else goto <D.24152>;
      <D.24152>:
      nindex = ei_len;
      i = 0;
      goto <D.24164>;
      <D.24163>:
      {
        gint32 cindex1;
        struct GSList * l;

        D.27267 = (long unsigned int) i;
        D.27268 = D.27267 * 8;
        D.27269 = type_info + D.27268;
        D.27270 = *D.27269;
        D.27271 = MEM[(const guint32 *)D.27270];
        cindex1 = (gint32) D.27271;
        D.27320 = (long unsigned int) cindex1;
        D.27321 = D.27320 * 8;
        D.27322 = nesting + D.27321;
        l = *D.27322;
        goto <D.24161>;
        <D.24160>:
        {
          gint32 nesting_cindex;

          D.27323 = l->data;
          D.27324 = (long int) D.27323;
          nesting_cindex = (gint32) D.27324;
          j = 0;
          goto <D.24158>;
          <D.24157>:
          {
            gint32 cindex2;

            D.27277 = (long unsigned int) j;
            D.27278 = D.27277 * 8;
            D.27279 = type_info + D.27278;
            D.27280 = *D.27279;
            D.27281 = MEM[(const guint32 *)D.27280];
            cindex2 = (gint32) D.27281;
            if (cindex2 == nesting_cindex) goto <D.27325>; else goto <D.27326>;
            <D.27325>:
            D.27327 = &jinfo->clauses[nindex];
            D.27328 = &jinfo->clauses[j];
            memcpy (D.27327, D.27328, 40);
            D.27329 = jinfo->clauses[i].try_start;
            jinfo->clauses[nindex].try_start = D.27329;
            D.27330 = jinfo->clauses[i].try_end;
            jinfo->clauses[nindex].try_end = D.27330;
            nindex = nindex + 1;
            <D.27326>:
          }
          j = j + 1;
          <D.24158>:
          j.104 = (unsigned int) j;
          if (j.104 < ei_len) goto <D.24157>; else goto <D.24159>;
          <D.24159>:
        }
        l = l->next;
        <D.24161>:
        if (l != 0B) goto <D.24160>; else goto <D.24162>;
        <D.24162>:
      }
      i = i + 1;
      <D.24164>:
      i.105 = (unsigned int) i;
      if (i.105 < ei_len) goto <D.24163>; else goto <D.24165>;
      <D.24165>:
      D.27286 = ei_len + nested_len;
      D.27331 = D.27286 != nindex;
      D.27332 = (long int) D.27331;
      D.27333 = __builtin_expect (D.27332, 0);
      if (D.27333 != 0) goto <D.27334>; else goto <D.27335>;
      <D.27334>:
      monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "aot-runtime.c", 2327, "nindex == ei_len + nested_len");
      <D.27335>:
      D.27336 = jinfo;
      return D.27336;
    }
  finally
    {
      info = {CLOBBER};
    }
}


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

  if (async_context != 0) goto <D.27339>; else goto <D.27340>;
  <D.27339>:
  size.107 = (unsigned int) size;
  res = mono_domain_alloc0_lock_free (domain, size.107);
  InterlockedExchangeAdd (&async_jit_info_size, size);
  goto <D.27342>;
  <D.27340>:
  size.107 = (unsigned int) size;
  res = mono_domain_alloc0 (domain, size.107);
  <D.27342>:
  D.27343 = res;
  return D.27343;
}


InterlockedExchangeAdd (volatile gint32 * val, gint32 add)
{
  gint32 D.27345;
  unsigned int add.108;
  unsigned int D.27347;

  add.108 = (unsigned int) add;
  D.27347 = __sync_fetch_and_add_4 (val, add.108);
  D.27345 = (gint32) D.27347;
  return D.27345;
}


mono_memory_barrier ()
{
  __sync_synchronize ();
}


InterlockedCompareExchangePointer (void * volatile * dest, void * exch, void * comp)
{
  void * D.27349;
  long unsigned int comp.109;
  long unsigned int exch.110;
  long unsigned int D.27352;

  comp.109 = (long unsigned int) comp;
  exch.110 = (long unsigned int) exch;
  D.27352 = __sync_val_compare_and_swap_8 (dest, comp.109, exch.110);
  D.27349 = (void *) D.27352;
  return D.27349;
}


mono_aot_get_method (struct MonoDomain * domain, struct MonoMethod * method)
{
  struct MonoImage * D.27354;
  void * amodule.111;
  struct MonoAotModule * amodule.112;
  void * D.27359;
  int D.27360;
  short unsigned int D.27365;
  int D.27366;
  int D.27367;
  short unsigned int D.27369;
  int D.27370;
  int D.27371;
  int D.27373;
  int D.27375;
  int mono_aot_only.113;
  long unsigned int D.27379;
  long unsigned int D.27380;
  struct MonoMethod * D.27383;
  long unsigned int D.27384;
  long unsigned int D.27385;
  _Bool D.27386;
  long int D.27387;
  long int D.27388;
  long unsigned int D.27393;
  int D.27395;
  unsigned int D.27397;
  unsigned int D.27398;
  long unsigned int D.27402;
  _Bool D.27406;
  long int D.27407;
  long int D.27408;
  struct GHashTable * D.27411;
  _Bool D.27414;
  long int D.27415;
  long int D.27416;
  struct MonoClass * D.27425;
  unsigned char D.27426;
  const char * D.27429;
  char * D.27430;
  int D.27435;
  void * D.27438;
  struct MonoClass * D.27443;
  int D.24565;
  int iftmp.114;
  int D.24564;
  const char[20] * D.27449;
  unsigned char D.27450;
  int D.27451;
  unsigned char D.27452;
  int D.27453;
  const unsigned char * D.27458;
  unsigned char D.27459;
  int D.27460;
  const unsigned char * D.27461;
  unsigned char D.27462;
  int D.27463;
  const unsigned char * D.27468;
  unsigned char D.27469;
  int D.27470;
  const unsigned char * D.27471;
  unsigned char D.27472;
  int D.27473;
  const unsigned char * D.27478;
  unsigned char D.27479;
  int D.27480;
  const unsigned char * D.27481;
  unsigned char D.27482;
  int D.27483;
  struct MonoMethodSignature * D.27487;
  struct MonoType * D.27488;
  unsigned char D.27489;
  _Bool D.27492;
  long int D.27493;
  long int D.27494;
  struct MonoClass * D.27497;
  struct MonoType * D.27498;
  struct MonoGenericInst * D.27499;
  struct MonoMethod * D.27500;
  struct MonoImage * D.27512;
  struct MonoImage * D.27513;
  int D.24577;
  int iftmp.115;
  int D.24576;
  const char[17] * D.27519;
  unsigned char D.27520;
  int D.27521;
  unsigned char D.27522;
  int D.27523;
  const unsigned char * D.27528;
  unsigned char D.27529;
  int D.27530;
  const unsigned char * D.27531;
  unsigned char D.27532;
  int D.27533;
  const unsigned char * D.27538;
  unsigned char D.27539;
  int D.27540;
  const unsigned char * D.27541;
  unsigned char D.27542;
  int D.27543;
  const unsigned char * D.27548;
  unsigned char D.27549;
  int D.27550;
  const unsigned char * D.27551;
  unsigned char D.27552;
  int D.27553;
  const char * D.27555;
  int D.24586;
  int iftmp.116;
  int D.24585;
  const char[12] * D.27560;
  unsigned char D.27561;
  int D.27562;
  unsigned char D.27563;
  int D.27564;
  const unsigned char * D.27569;
  unsigned char D.27570;
  int D.27571;
  const unsigned char * D.27572;
  unsigned char D.27573;
  int D.27574;
  const unsigned char * D.27579;
  unsigned char D.27580;
  int D.27581;
  const unsigned char * D.27582;
  unsigned char D.27583;
  int D.27584;
  const unsigned char * D.27589;
  unsigned char D.27590;
  int D.27591;
  const unsigned char * D.27592;
  unsigned char D.27593;
  int D.27594;
  const char * D.27596;
  int D.24595;
  int iftmp.117;
  int D.24594;
  const char[16] * D.27601;
  unsigned char D.27602;
  int D.27603;
  unsigned char D.27604;
  int D.27605;
  const unsigned char * D.27610;
  unsigned char D.27611;
  int D.27612;
  const unsigned char * D.27613;
  unsigned char D.27614;
  int D.27615;
  const unsigned char * D.27620;
  unsigned char D.27621;
  int D.27622;
  const unsigned char * D.27623;
  unsigned char D.27624;
  int D.27625;
  const unsigned char * D.27630;
  unsigned char D.27631;
  int D.27632;
  const unsigned char * D.27633;
  unsigned char D.27634;
  int D.27635;
  int D.24604;
  int iftmp.118;
  int D.24603;
  const char[9] * D.27641;
  unsigned char D.27642;
  int D.27643;
  unsigned char D.27644;
  int D.27645;
  const unsigned char * D.27650;
  unsigned char D.27651;
  int D.27652;
  const unsigned char * D.27653;
  unsigned char D.27654;
  int D.27655;
  const unsigned char * D.27660;
  unsigned char D.27661;
  int D.27662;
  const unsigned char * D.27663;
  unsigned char D.27664;
  int D.27665;
  const unsigned char * D.27670;
  unsigned char D.27671;
  int D.27672;
  const unsigned char * D.27673;
  unsigned char D.27674;
  int D.27675;
  struct MonoMethodSignature * D.27677;
  struct MonoType * D.27678;
  int D.27679;
  int D.24613;
  int iftmp.119;
  int D.24612;
  unsigned char D.27683;
  int D.27684;
  const unsigned char * D.27689;
  unsigned char D.27690;
  int D.27691;
  const unsigned char * D.27696;
  unsigned char D.27697;
  int D.27698;
  const unsigned char * D.27703;
  unsigned char D.27704;
  int D.27705;
  int D.24622;
  int iftmp.120;
  int D.24621;
  const char[9] * D.27711;
  unsigned char D.27712;
  int D.27713;
  unsigned char D.27714;
  int D.27715;
  const unsigned char * D.27720;
  unsigned char D.27721;
  int D.27722;
  const unsigned char * D.27723;
  unsigned char D.27724;
  int D.27725;
  const unsigned char * D.27730;
  unsigned char D.27731;
  int D.27732;
  const unsigned char * D.27733;
  unsigned char D.27734;
  int D.27735;
  const unsigned char * D.27740;
  unsigned char D.27741;
  int D.27742;
  const unsigned char * D.27743;
  unsigned char D.27744;
  int D.27745;
  int D.24631;
  int iftmp.121;
  int D.24630;
  const char[5] * D.27751;
  unsigned char D.27752;
  int D.27753;
  unsigned char D.27754;
  int D.27755;
  const unsigned char * D.27760;
  unsigned char D.27761;
  int D.27762;
  const unsigned char * D.27763;
  unsigned char D.27764;
  int D.27765;
  const unsigned char * D.27770;
  unsigned char D.27771;
  int D.27772;
  const unsigned char * D.27773;
  unsigned char D.27774;
  int D.27775;
  const unsigned char * D.27780;
  unsigned char D.27781;
  int D.27782;
  const unsigned char * D.27783;
  unsigned char D.27784;
  int D.27785;
  struct MonoMethodSignature * D.27788;
  struct MonoType * D.27789;
  int D.27790;
  int D.24640;
  int iftmp.122;
  int D.24639;
  unsigned char D.27794;
  int D.27795;
  const unsigned char * D.27800;
  unsigned char D.27801;
  int D.27802;
  const unsigned char * D.27807;
  unsigned char D.27808;
  int D.27809;
  const unsigned char * D.27814;
  unsigned char D.27815;
  int D.27816;
  int D.24649;
  int iftmp.123;
  int D.24648;
  unsigned char D.27822;
  int D.27823;
  const unsigned char * D.27828;
  unsigned char D.27829;
  int D.27830;
  const unsigned char * D.27835;
  unsigned char D.27836;
  int D.27837;
  const unsigned char * D.27842;
  unsigned char D.27843;
  int D.27844;
  int D.24658;
  int iftmp.124;
  int D.24657;
  const char[6] * D.27850;
  unsigned char D.27851;
  int D.27852;
  unsigned char D.27853;
  int D.27854;
  const unsigned char * D.27859;
  unsigned char D.27860;
  int D.27861;
  const unsigned char * D.27862;
  unsigned char D.27863;
  int D.27864;
  const unsigned char * D.27869;
  unsigned char D.27870;
  int D.27871;
  const unsigned char * D.27872;
  unsigned char D.27873;
  int D.27874;
  const unsigned char * D.27879;
  unsigned char D.27880;
  int D.27881;
  const unsigned char * D.27882;
  unsigned char D.27883;
  int D.27884;
  struct MonoMethodSignature * D.27887;
  struct MonoType * D.27888;
  int D.27889;
  struct MonoMethodSignature * D.27890;
  short unsigned int D.27891;
  int D.24671;
  const char * D.27894;
  _Bool D.27896;
  long int D.27897;
  long int D.27898;
  struct MonoGenericInst * D.27901;
  struct MonoMethod * D.27902;
  int D.27911;
  int D.27920;
  struct MonoMethod * D.27923;
  int D.27930;
  _Bool D.27937;
  long int D.27938;
  long int D.27939;
  struct GHashTable * D.27942;
  struct GHashTable * D.27945;
  long unsigned int D.27946;
  void * D.27947;
  _Bool D.27950;
  long int D.27951;
  long int D.27952;
  int method_index.125;
  struct MonoClass * klass;
  guint32 method_index;
  struct MonoAotModule * amodule;
  guint8 * code;

  try
    {
      klass = method->klass;
      D.27354 = klass->image;
      amodule.111 = D.27354->aot_module;
      amodule = amodule.111;
      amodule.112 = amodule;
      if (amodule.112 == 0B) goto <D.27357>; else goto <D.27358>;
      <D.27357>:
      D.27359 = 0B;
      return D.27359;
      <D.27358>:
      amodule.112 = amodule;
      D.27360 = amodule.112->out_of_date;
      if (D.27360 != 0) goto <D.27361>; else goto <D.27362>;
      <D.27361>:
      D.27359 = 0B;
      return D.27359;
      <D.27362>:
      D.27365 = method->iflags;
      D.27366 = (int) D.27365;
      D.27367 = D.27366 & 4096;
      if (D.27367 != 0) goto <D.27363>; else goto <D.27368>;
      <D.27368>:
      D.27369 = method->flags;
      D.27370 = (int) D.27369;
      D.27371 = D.27370 & 8192;
      if (D.27371 != 0) goto <D.27363>; else goto <D.27372>;
      <D.27372>:
      D.27365 = method->iflags;
      D.27366 = (int) D.27365;
      D.27373 = D.27366 & 3;
      if (D.27373 != 0) goto <D.27363>; else goto <D.27374>;
      <D.27374>:
      D.27369 = method->flags;
      D.27370 = (int) D.27369;
      D.27375 = D.27370 & 1024;
      if (D.27375 != 0) goto <D.27363>; else goto <D.27364>;
      <D.27363>:
      D.27359 = 0B;
      return D.27359;
      <D.27364>:
      mono_aot_only.113 = mono_aot_only;
      if (mono_aot_only.113 != 0) goto <D.27377>; else goto <D.27378>;
      <D.27377>:
      D.27379 = BIT_FIELD_REF <*method, 64, 256>;
      D.27380 = D.27379 & 124;
      if (D.27380 == 36) goto <D.27381>; else goto <D.27382>;
      <D.27381>:
      D.27383 = mono_marshal_method_from_wrapper (method);
      D.27359 = mono_aot_get_method (domain, D.27383);
      return D.27359;
      <D.27382>:
      <D.27378>:
      D.27384 = BIT_FIELD_REF <*klass, 64, 256>;
      D.27385 = D.27384 & 1;
      D.27386 = D.27385 == 0;
      D.27387 = (long int) D.27386;
      D.27388 = __builtin_expect (D.27387, 0);
      if (D.27388 != 0) goto <D.27389>; else goto <D.27390>;
      <D.27389>:
      monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "aot-runtime.c", 3615, "klass->inited");
      <D.27390>:
      method_index = 16777215;
      D.27379 = BIT_FIELD_REF <*method, 64, 256>;
      D.27393 = D.27379 & 4220;
      if (D.27393 == 4096) goto <D.27394>; else goto <D.27391>;
      <D.27394>:
      D.27395 = mono_method_is_generic_sharable_full (method, 0, 0, 0);
      if (D.27395 != 0) goto <D.27396>; else goto <D.27391>;
      <D.27396>:
      method = mono_method_get_declaring_generic_method (method);
      D.27397 = method->token;
      D.27398 = D.27397 & 16777215;
      method_index = D.27398 + 4294967295;
      goto <D.27392>;
      <D.27391>:
      D.27379 = BIT_FIELD_REF <*method, 64, 256>;
      D.27402 = D.27379 & 4096;
      if (D.27402 != 0) goto <D.27399>; else goto <D.27403>;
      <D.27403>:
      D.27397 = method->token;
      if (D.27397 == 0) goto <D.27399>; else goto <D.27400>;
      <D.27399>:
      {
        int ret;

        ret = pthread_mutex_lock (&aot_mutex.mutex);
        if (ret != 0) goto <D.27404>; else goto <D.27405>;
        <D.27404>:
        monoeg_g_log (0B, 16, "Bad call to mono_mutex_lock result %d", ret);
        <D.27405>:
        D.27406 = ret != 0;
        D.27407 = (long int) D.27406;
        D.27408 = __builtin_expect (D.27407, 0);
        if (D.27408 != 0) goto <D.27409>; else goto <D.27410>;
        <D.27409>:
        monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "aot-runtime.c", 3628, "ret == 0");
        <D.27410>:
      }
      amodule.112 = amodule;
      D.27411 = amodule.112->method_to_code;
      code = monoeg_g_hash_table_lookup (D.27411, method);
      {
        int ret;

        ret = pthread_mutex_unlock (&aot_mutex.mutex);
        if (ret != 0) goto <D.27412>; else goto <D.27413>;
        <D.27412>:
        monoeg_g_log (0B, 16, "Bad call to mono_mutex_unlock result %d", ret);
        <D.27413>:
        D.27414 = ret != 0;
        D.27415 = (long int) D.27414;
        D.27416 = __builtin_expect (D.27415, 0);
        if (D.27416 != 0) goto <D.27417>; else goto <D.27418>;
        <D.27417>:
        monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "aot-runtime.c", 3630, "ret == 0");
        <D.27418>:
      }
      if (code != 0B) goto <D.27419>; else goto <D.27420>;
      <D.27419>:
      D.27359 = code;
      return D.27359;
      <D.27420>:
      method_index = find_extra_method (method, &amodule);
      if (method_index == 16777215) goto <D.27421>; else goto <D.27422>;
      <D.27421>:
      D.27379 = BIT_FIELD_REF <*method, 64, 256>;
      D.27380 = D.27379 & 124;
      if (D.27380 == 28) goto <D.27423>; else goto <D.27424>;
      <D.27423>:
      D.27425 = method->klass;
      D.27426 = D.27425->rank;
      if (D.27426 != 0) goto <D.27427>; else goto <D.27428>;
      <D.27427>:
      D.27429 = method->name;
      D.27430 = strstr (D.27429, "System.Collections.Generic");
      if (D.27430 != 0B) goto <D.27431>; else goto <D.27432>;
      <D.27431>:
      {
        struct MonoMethod * m;

        m = mono_aot_get_array_helper_from_wrapper (method);
        code = mono_aot_get_method (domain, m);
        if (code != 0B) goto <D.27433>; else goto <D.27434>;
        <D.27433>:
        D.27435 = mono_method_needs_static_rgctx_invoke (m, 0);
        if (D.27435 != 0) goto <D.27436>; else goto <D.27437>;
        <D.27436>:
        D.27438 = mono_create_ftnptr (domain, code);
        code = mono_create_static_rgctx_trampoline (m, D.27438);
        code = mono_get_addr_from_ftnptr (code);
        <D.27437>:
        D.27359 = code;
        return D.27359;
        <D.27434>:
      }
      <D.27432>:
      <D.27428>:
      <D.27424>:
      <D.27422>:
      if (method_index == 16777215) goto <D.27439>; else goto <D.27440>;
      <D.27439>:
      D.27379 = BIT_FIELD_REF <*method, 64, 256>;
      D.27380 = D.27379 & 124;
      if (D.27380 == 24) goto <D.27441>; else goto <D.27442>;
      <D.27441>:
      D.27425 = method->klass;
      D.27443 = mono_defaults.array_class;
      if (D.27425 == D.27443) goto <D.27444>; else goto <D.27445>;
      <D.27444>:
      {
        size_t __s1_len;
        size_t __s2_len;

        __s2_len = 19;
        if (__s2_len <= 3) goto <D.27447>; else goto <D.27448>;
        <D.27447>:
        {
          const unsigned char * __s2;
          int __result;

          __s2 = method->name;
          D.27449 = "GetGenericValueImpl";
          D.27450 = MEM[(const unsigned char *)D.27449];
          D.27451 = (int) D.27450;
          D.27452 = *__s2;
          D.27453 = (int) D.27452;
          __result = D.27451 - D.27453;
          {
            if (__s2_len != 0) goto <D.27454>; else goto <D.27455>;
            <D.27454>:
            if (__result == 0) goto <D.27456>; else goto <D.27457>;
            <D.27456>:
            D.27458 = &MEM[(void *)"GetGenericValueImpl" + 1B];
            D.27459 = *D.27458;
            D.27460 = (int) D.27459;
            D.27461 = __s2 + 1;
            D.27462 = *D.27461;
            D.27463 = (int) D.27462;
            __result = D.27460 - D.27463;
            if (__s2_len > 1) goto <D.27464>; else goto <D.27465>;
            <D.27464>:
            if (__result == 0) goto <D.27466>; else goto <D.27467>;
            <D.27466>:
            D.27468 = &MEM[(void *)"GetGenericValueImpl" + 2B];
            D.27469 = *D.27468;
            D.27470 = (int) D.27469;
            D.27471 = __s2 + 2;
            D.27472 = *D.27471;
            D.27473 = (int) D.27472;
            __result = D.27470 - D.27473;
            if (__s2_len > 2) goto <D.27474>; else goto <D.27475>;
            <D.27474>:
            if (__result == 0) goto <D.27476>; else goto <D.27477>;
            <D.27476>:
            D.27478 = &MEM[(void *)"GetGenericValueImpl" + 3B];
            D.27479 = *D.27478;
            D.27480 = (int) D.27479;
            D.27481 = __s2 + 3;
            D.27482 = *D.27481;
            D.27483 = (int) D.27482;
            __result = D.27480 - D.27483;
            <D.27477>:
            <D.27475>:
            <D.27467>:
            <D.27465>:
            <D.27457>:
            <D.27455>:
          }
          D.24564 = __result;
        }
        iftmp.114 = -D.24564;
        goto <D.27484>;
        <D.27448>:
        D.27429 = method->name;
        iftmp.114 = __builtin_strcmp (D.27429, "GetGenericValueImpl");
        <D.27484>:
        D.24565 = iftmp.114;
      }
      if (D.24565 == 0) goto <D.27485>; else goto <D.27486>;
      <D.27485>:
      {
        struct MonoMethod * m;
        struct MonoGenericContext ctx;
        struct MonoType * args[16];

        try
          {
            D.27487 = mono_method_signature (method);
            D.27488 = D.27487->params[1];
            D.27489 = D.27488->type;
            if (D.27489 == 28) goto <D.27490>; else goto <D.27491>;
            <D.27490>:
            D.27359 = 0B;
            return D.27359;
            <D.27491>:
            D.27443 = mono_defaults.array_class;
            m = mono_class_get_method_from_name (D.27443, "GetGenericValueImpl", 2);
            D.27492 = m == 0B;
            D.27493 = (long int) D.27492;
            D.27494 = __builtin_expect (D.27493, 0);
            if (D.27494 != 0) goto <D.27495>; else goto <D.27496>;
            <D.27495>:
            monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "aot-runtime.c", 3670, "m");
            <D.27496>:
            memset (&ctx, 0, 16);
            D.27497 = mono_defaults.object_class;
            D.27498 = &D.27497->byval_arg;
            args[0] = D.27498;
            D.27499 = mono_metadata_get_generic_inst (1, &args);
            ctx.method_inst = D.27499;
            D.27500 = mono_class_inflate_generic_method (m, &ctx);
            m = mono_marshal_get_native_wrapper (D.27500, 1, 1);
            code = mono_aot_get_method (domain, m);
            if (code != 0B) goto <D.27501>; else goto <D.27502>;
            <D.27501>:
            D.27359 = code;
            return D.27359;
            <D.27502>:
          }
        finally
          {
            ctx = {CLOBBER};
            args = {CLOBBER};
          }
      }
      <D.27486>:
      <D.27445>:
      <D.27442>:
      <D.27440>:
      if (method_index == 16777215) goto <D.27508>; else goto <D.27509>;
      <D.27508>:
      D.27379 = BIT_FIELD_REF <*method, 64, 256>;
      D.27380 = D.27379 & 124;
      if (D.27380 == 24) goto <D.27510>; else goto <D.27511>;
      <D.27510>:
      D.27425 = method->klass;
      D.27512 = D.27425->image;
      D.27513 = mono_defaults.corlib;
      if (D.27512 == D.27513) goto <D.27514>; else goto <D.27515>;
      <D.27514>:
      {
        size_t __s1_len;
        size_t __s2_len;

        __s2_len = 16;
        if (__s2_len <= 3) goto <D.27517>; else goto <D.27518>;
        <D.27517>:
        {
          const unsigned char * __s2;
          int __result;

          D.27425 = method->klass;
          __s2 = D.27425->name_space;
          D.27519 = "System.Threading";
          D.27520 = MEM[(const unsigned char *)D.27519];
          D.27521 = (int) D.27520;
          D.27522 = *__s2;
          D.27523 = (int) D.27522;
          __result = D.27521 - D.27523;
          {
            if (__s2_len != 0) goto <D.27524>; else goto <D.27525>;
            <D.27524>:
            if (__result == 0) goto <D.27526>; else goto <D.27527>;
            <D.27526>:
            D.27528 = &MEM[(void *)"System.Threading" + 1B];
            D.27529 = *D.27528;
            D.27530 = (int) D.27529;
            D.27531 = __s2 + 1;
            D.27532 = *D.27531;
            D.27533 = (int) D.27532;
            __result = D.27530 - D.27533;
            if (__s2_len > 1) goto <D.27534>; else goto <D.27535>;
            <D.27534>:
            if (__result == 0) goto <D.27536>; else goto <D.27537>;
            <D.27536>:
            D.27538 = &MEM[(void *)"System.Threading" + 2B];
            D.27539 = *D.27538;
            D.27540 = (int) D.27539;
            D.27541 = __s2 + 2;
            D.27542 = *D.27541;
            D.27543 = (int) D.27542;
            __result = D.27540 - D.27543;
            if (__s2_len > 2) goto <D.27544>; else goto <D.27545>;
            <D.27544>:
            if (__result == 0) goto <D.27546>; else goto <D.27547>;
            <D.27546>:
            D.27548 = &MEM[(void *)"System.Threading" + 3B];
            D.27549 = *D.27548;
            D.27550 = (int) D.27549;
            D.27551 = __s2 + 3;
            D.27552 = *D.27551;
            D.27553 = (int) D.27552;
            __result = D.27550 - D.27553;
            <D.27547>:
            <D.27545>:
            <D.27537>:
            <D.27535>:
            <D.27527>:
            <D.27525>:
          }
          D.24576 = __result;
        }
        iftmp.115 = -D.24576;
        goto <D.27554>;
        <D.27518>:
        D.27425 = method->klass;
        D.27555 = D.27425->name_space;
        iftmp.115 = __builtin_strcmp (D.27555, "System.Threading");
        <D.27554>:
        D.24577 = iftmp.115;
      }
      if (D.24577 == 0) goto <D.27556>; else goto <D.27503>;
      <D.27556>:
      {
        size_t __s1_len;
        size_t __s2_len;

        __s2_len = 11;
        if (__s2_len <= 3) goto <D.27558>; else goto <D.27559>;
        <D.27558>:
        {
          const unsigned char * __s2;
          int __result;

          D.27425 = method->klass;
          __s2 = D.27425->name;
          D.27560 = "Interlocked";
          D.27561 = MEM[(const unsigned char *)D.27560];
          D.27562 = (int) D.27561;
          D.27563 = *__s2;
          D.27564 = (int) D.27563;
          __result = D.27562 - D.27564;
          {
            if (__s2_len != 0) goto <D.27565>; else goto <D.27566>;
            <D.27565>:
            if (__result == 0) goto <D.27567>; else goto <D.27568>;
            <D.27567>:
            D.27569 = &MEM[(void *)"Interlocked" + 1B];
            D.27570 = *D.27569;
            D.27571 = (int) D.27570;
            D.27572 = __s2 + 1;
            D.27573 = *D.27572;
            D.27574 = (int) D.27573;
            __result = D.27571 - D.27574;
            if (__s2_len > 1) goto <D.27575>; else goto <D.27576>;
            <D.27575>:
            if (__result == 0) goto <D.27577>; else goto <D.27578>;
            <D.27577>:
            D.27579 = &MEM[(void *)"Interlocked" + 2B];
            D.27580 = *D.27579;
            D.27581 = (int) D.27580;
            D.27582 = __s2 + 2;
            D.27583 = *D.27582;
            D.27584 = (int) D.27583;
            __result = D.27581 - D.27584;
            if (__s2_len > 2) goto <D.27585>; else goto <D.27586>;
            <D.27585>:
            if (__result == 0) goto <D.27587>; else goto <D.27588>;
            <D.27587>:
            D.27589 = &MEM[(void *)"Interlocked" + 3B];
            D.27590 = *D.27589;
            D.27591 = (int) D.27590;
            D.27592 = __s2 + 3;
            D.27593 = *D.27592;
            D.27594 = (int) D.27593;
            __result = D.27591 - D.27594;
            <D.27588>:
            <D.27586>:
            <D.27578>:
            <D.27576>:
            <D.27568>:
            <D.27566>:
          }
          D.24585 = __result;
        }
        iftmp.116 = -D.24585;
        goto <D.27595>;
        <D.27559>:
        D.27425 = method->klass;
        D.27596 = D.27425->name;
        iftmp.116 = __builtin_strcmp (D.27596, "Interlocked");
        <D.27595>:
        D.24586 = iftmp.116;
      }
      if (D.24586 == 0) goto <D.27597>; else goto <D.27503>;
      <D.27597>:
      {
        size_t __s1_len;
        size_t __s2_len;

        __s2_len = 15;
        if (__s2_len <= 3) goto <D.27599>; else goto <D.27600>;
        <D.27599>:
        {
          const unsigned char * __s2;
          int __result;

          __s2 = method->name;
          D.27601 = "CompareExchange";
          D.27602 = MEM[(const unsigned char *)D.27601];
          D.27603 = (int) D.27602;
          D.27604 = *__s2;
          D.27605 = (int) D.27604;
          __result = D.27603 - D.27605;
          {
            if (__s2_len != 0) goto <D.27606>; else goto <D.27607>;
            <D.27606>:
            if (__result == 0) goto <D.27608>; else goto <D.27609>;
            <D.27608>:
            D.27610 = &MEM[(void *)"CompareExchange" + 1B];
            D.27611 = *D.27610;
            D.27612 = (int) D.27611;
            D.27613 = __s2 + 1;
            D.27614 = *D.27613;
            D.27615 = (int) D.27614;
            __result = D.27612 - D.27615;
            if (__s2_len > 1) goto <D.27616>; else goto <D.27617>;
            <D.27616>:
            if (__result == 0) goto <D.27618>; else goto <D.27619>;
            <D.27618>:
            D.27620 = &MEM[(void *)"CompareExchange" + 2B];
            D.27621 = *D.27620;
            D.27622 = (int) D.27621;
            D.27623 = __s2 + 2;
            D.27624 = *D.27623;
            D.27625 = (int) D.27624;
            __result = D.27622 - D.27625;
            if (__s2_len > 2) goto <D.27626>; else goto <D.27627>;
            <D.27626>:
            if (__result == 0) goto <D.27628>; else goto <D.27629>;
            <D.27628>:
            D.27630 = &MEM[(void *)"CompareExchange" + 3B];
            D.27631 = *D.27630;
            D.27632 = (int) D.27631;
            D.27633 = __s2 + 3;
            D.27634 = *D.27633;
            D.27635 = (int) D.27634;
            __result = D.27632 - D.27635;
            <D.27629>:
            <D.27627>:
            <D.27619>:
            <D.27617>:
            <D.27609>:
            <D.27607>:
          }
          D.24594 = __result;
        }
        iftmp.117 = -D.24594;
        goto <D.27636>;
        <D.27600>:
        D.27429 = method->name;
        iftmp.117 = __builtin_strcmp (D.27429, "CompareExchange");
        <D.27636>:
        D.24595 = iftmp.117;
      }
      if (D.24595 == 0) goto <D.27504>; else goto <D.27637>;
      <D.27637>:
      {
        size_t __s1_len;
        size_t __s2_len;

        __s2_len = 8;
        if (__s2_len <= 3) goto <D.27639>; else goto <D.27640>;
        <D.27639>:
        {
          const unsigned char * __s2;
          int __result;

          __s2 = method->name;
          D.27641 = "Exchange";
          D.27642 = MEM[(const unsigned char *)D.27641];
          D.27643 = (int) D.27642;
          D.27644 = *__s2;
          D.27645 = (int) D.27644;
          __result = D.27643 - D.27645;
          {
            if (__s2_len != 0) goto <D.27646>; else goto <D.27647>;
            <D.27646>:
            if (__result == 0) goto <D.27648>; else goto <D.27649>;
            <D.27648>:
            D.27650 = &MEM[(void *)"Exchange" + 1B];
            D.27651 = *D.27650;
            D.27652 = (int) D.27651;
            D.27653 = __s2 + 1;
            D.27654 = *D.27653;
            D.27655 = (int) D.27654;
            __result = D.27652 - D.27655;
            if (__s2_len > 1) goto <D.27656>; else goto <D.27657>;
            <D.27656>:
            if (__result == 0) goto <D.27658>; else goto <D.27659>;
            <D.27658>:
            D.27660 = &MEM[(void *)"Exchange" + 2B];
            D.27661 = *D.27660;
            D.27662 = (int) D.27661;
            D.27663 = __s2 + 2;
            D.27664 = *D.27663;
            D.27665 = (int) D.27664;
            __result = D.27662 - D.27665;
            if (__s2_len > 2) goto <D.27666>; else goto <D.27667>;
            <D.27666>:
            if (__result == 0) goto <D.27668>; else goto <D.27669>;
            <D.27668>:
            D.27670 = &MEM[(void *)"Exchange" + 3B];
            D.27671 = *D.27670;
            D.27672 = (int) D.27671;
            D.27673 = __s2 + 3;
            D.27674 = *D.27673;
            D.27675 = (int) D.27674;
            __result = D.27672 - D.27675;
            <D.27669>:
            <D.27667>:
            <D.27659>:
            <D.27657>:
            <D.27649>:
            <D.27647>:
          }
          D.24603 = __result;
        }
        iftmp.118 = -D.24603;
        goto <D.27676>;
        <D.27640>:
        D.27429 = method->name;
        iftmp.118 = __builtin_strcmp (D.27429, "Exchange");
        <D.27676>:
        D.24604 = iftmp.118;
      }
      if (D.24604 == 0) goto <D.27504>; else goto <D.27503>;
      <D.27504>:
      D.27677 = mono_method_signature (method);
      D.27678 = D.27677->params[1];
      D.27679 = mono_type_is_reference (D.27678);
      if (D.27679 != 0) goto <D.27505>; else goto <D.27503>;
      <D.27503>:
      {
        size_t __s1_len;
        size_t __s2_len;

        __s2_len = 16;
        if (__s2_len <= 3) goto <D.27681>; else goto <D.27682>;
        <D.27681>:
        {
          const unsigned char * __s2;
          int __result;

          D.27425 = method->klass;
          __s2 = D.27425->name_space;
          D.27519 = "System.Threading";
          D.27520 = MEM[(const unsigned char *)D.27519];
          D.27521 = (int) D.27520;
          D.27683 = *__s2;
          D.27684 = (int) D.27683;
          __result = D.27521 - D.27684;
          {
            if (__s2_len != 0) goto <D.27685>; else goto <D.27686>;
            <D.27685>:
            if (__result == 0) goto <D.27687>; else goto <D.27688>;
            <D.27687>:
            D.27528 = &MEM[(void *)"System.Threading" + 1B];
            D.27529 = *D.27528;
            D.27530 = (int) D.27529;
            D.27689 = __s2 + 1;
            D.27690 = *D.27689;
            D.27691 = (int) D.27690;
            __result = D.27530 - D.27691;
            if (__s2_len > 1) goto <D.27692>; else goto <D.27693>;
            <D.27692>:
            if (__result == 0) goto <D.27694>; else goto <D.27695>;
            <D.27694>:
            D.27538 = &MEM[(void *)"System.Threading" + 2B];
            D.27539 = *D.27538;
            D.27540 = (int) D.27539;
            D.27696 = __s2 + 2;
            D.27697 = *D.27696;
            D.27698 = (int) D.27697;
            __result = D.27540 - D.27698;
            if (__s2_len > 2) goto <D.27699>; else goto <D.27700>;
            <D.27699>:
            if (__result == 0) goto <D.27701>; else goto <D.27702>;
            <D.27701>:
            D.27548 = &MEM[(void *)"System.Threading" + 3B];
            D.27549 = *D.27548;
            D.27550 = (int) D.27549;
            D.27703 = __s2 + 3;
            D.27704 = *D.27703;
            D.27705 = (int) D.27704;
            __result = D.27550 - D.27705;
            <D.27702>:
            <D.27700>:
            <D.27695>:
            <D.27693>:
            <D.27688>:
            <D.27686>:
          }
          D.24612 = __result;
        }
        iftmp.119 = -D.24612;
        goto <D.27706>;
        <D.27682>:
        D.27425 = method->klass;
        D.27555 = D.27425->name_space;
        iftmp.119 = __builtin_strcmp (D.27555, "System.Threading");
        <D.27706>:
        D.24613 = iftmp.119;
      }
      if (D.24613 == 0) goto <D.27707>; else goto <D.27506>;
      <D.27707>:
      {
        size_t __s1_len;
        size_t __s2_len;

        __s2_len = 8;
        if (__s2_len <= 3) goto <D.27709>; else goto <D.27710>;
        <D.27709>:
        {
          const unsigned char * __s2;
          int __result;

          D.27425 = method->klass;
          __s2 = D.27425->name;
          D.27711 = "Volatile";
          D.27712 = MEM[(const unsigned char *)D.27711];
          D.27713 = (int) D.27712;
          D.27714 = *__s2;
          D.27715 = (int) D.27714;
          __result = D.27713 - D.27715;
          {
            if (__s2_len != 0) goto <D.27716>; else goto <D.27717>;
            <D.27716>:
            if (__result == 0) goto <D.27718>; else goto <D.27719>;
            <D.27718>:
            D.27720 = &MEM[(void *)"Volatile" + 1B];
            D.27721 = *D.27720;
            D.27722 = (int) D.27721;
            D.27723 = __s2 + 1;
            D.27724 = *D.27723;
            D.27725 = (int) D.27724;
            __result = D.27722 - D.27725;
            if (__s2_len > 1) goto <D.27726>; else goto <D.27727>;
            <D.27726>:
            if (__result == 0) goto <D.27728>; else goto <D.27729>;
            <D.27728>:
            D.27730 = &MEM[(void *)"Volatile" + 2B];
            D.27731 = *D.27730;
            D.27732 = (int) D.27731;
            D.27733 = __s2 + 2;
            D.27734 = *D.27733;
            D.27735 = (int) D.27734;
            __result = D.27732 - D.27735;
            if (__s2_len > 2) goto <D.27736>; else goto <D.27737>;
            <D.27736>:
            if (__result == 0) goto <D.27738>; else goto <D.27739>;
            <D.27738>:
            D.27740 = &MEM[(void *)"Volatile" + 3B];
            D.27741 = *D.27740;
            D.27742 = (int) D.27741;
            D.27743 = __s2 + 3;
            D.27744 = *D.27743;
            D.27745 = (int) D.27744;
            __result = D.27742 - D.27745;
            <D.27739>:
            <D.27737>:
            <D.27729>:
            <D.27727>:
            <D.27719>:
            <D.27717>:
          }
          D.24621 = __result;
        }
        iftmp.120 = -D.24621;
        goto <D.27746>;
        <D.27710>:
        D.27425 = method->klass;
        D.27596 = D.27425->name;
        iftmp.120 = __builtin_strcmp (D.27596, "Volatile");
        <D.27746>:
        D.24622 = iftmp.120;
      }
      if (D.24622 == 0) goto <D.27747>; else goto <D.27506>;
      <D.27747>:
      {
        size_t __s1_len;
        size_t __s2_len;

        __s2_len = 4;
        if (__s2_len <= 3) goto <D.27749>; else goto <D.27750>;
        <D.27749>:
        {
          const unsigned char * __s2;
          int __result;

          __s2 = method->name;
          D.27751 = "Read";
          D.27752 = MEM[(const unsigned char *)D.27751];
          D.27753 = (int) D.27752;
          D.27754 = *__s2;
          D.27755 = (int) D.27754;
          __result = D.27753 - D.27755;
          {
            if (__s2_len != 0) goto <D.27756>; else goto <D.27757>;
            <D.27756>:
            if (__result == 0) goto <D.27758>; else goto <D.27759>;
            <D.27758>:
            D.27760 = &MEM[(void *)"Read" + 1B];
            D.27761 = *D.27760;
            D.27762 = (int) D.27761;
            D.27763 = __s2 + 1;
            D.27764 = *D.27763;
            D.27765 = (int) D.27764;
            __result = D.27762 - D.27765;
            if (__s2_len > 1) goto <D.27766>; else goto <D.27767>;
            <D.27766>:
            if (__result == 0) goto <D.27768>; else goto <D.27769>;
            <D.27768>:
            D.27770 = &MEM[(void *)"Read" + 2B];
            D.27771 = *D.27770;
            D.27772 = (int) D.27771;
            D.27773 = __s2 + 2;
            D.27774 = *D.27773;
            D.27775 = (int) D.27774;
            __result = D.27772 - D.27775;
            if (__s2_len > 2) goto <D.27776>; else goto <D.27777>;
            <D.27776>:
            if (__result == 0) goto <D.27778>; else goto <D.27779>;
            <D.27778>:
            D.27780 = &MEM[(void *)"Read" + 3B];
            D.27781 = *D.27780;
            D.27782 = (int) D.27781;
            D.27783 = __s2 + 3;
            D.27784 = *D.27783;
            D.27785 = (int) D.27784;
            __result = D.27782 - D.27785;
            <D.27779>:
            <D.27777>:
            <D.27769>:
            <D.27767>:
            <D.27759>:
            <D.27757>:
          }
          D.24630 = __result;
        }
        iftmp.121 = -D.24630;
        goto <D.27786>;
        <D.27750>:
        D.27429 = method->name;
        iftmp.121 = __builtin_strcmp (D.27429, "Read");
        <D.27786>:
        D.24631 = iftmp.121;
      }
      if (D.24631 == 0) goto <D.27787>; else goto <D.27506>;
      <D.27787>:
      D.27788 = mono_method_signature (method);
      D.27789 = D.27788->ret;
      D.27790 = mono_type_is_reference (D.27789);
      if (D.27790 != 0) goto <D.27505>; else goto <D.27506>;
      <D.27506>:
      {
        size_t __s1_len;
        size_t __s2_len;

        __s2_len = 16;
        if (__s2_len <= 3) goto <D.27792>; else goto <D.27793>;
        <D.27792>:
        {
          const unsigned char * __s2;
          int __result;

          D.27425 = method->klass;
          __s2 = D.27425->name_space;
          D.27519 = "System.Threading";
          D.27520 = MEM[(const unsigned char *)D.27519];
          D.27521 = (int) D.27520;
          D.27794 = *__s2;
          D.27795 = (int) D.27794;
          __result = D.27521 - D.27795;
          {
            if (__s2_len != 0) goto <D.27796>; else goto <D.27797>;
            <D.27796>:
            if (__result == 0) goto <D.27798>; else goto <D.27799>;
            <D.27798>:
            D.27528 = &MEM[(void *)"System.Threading" + 1B];
            D.27529 = *D.27528;
            D.27530 = (int) D.27529;
            D.27800 = __s2 + 1;
            D.27801 = *D.27800;
            D.27802 = (int) D.27801;
            __result = D.27530 - D.27802;
            if (__s2_len > 1) goto <D.27803>; else goto <D.27804>;
            <D.27803>:
            if (__result == 0) goto <D.27805>; else goto <D.27806>;
            <D.27805>:
            D.27538 = &MEM[(void *)"System.Threading" + 2B];
            D.27539 = *D.27538;
            D.27540 = (int) D.27539;
            D.27807 = __s2 + 2;
            D.27808 = *D.27807;
            D.27809 = (int) D.27808;
            __result = D.27540 - D.27809;
            if (__s2_len > 2) goto <D.27810>; else goto <D.27811>;
            <D.27810>:
            if (__result == 0) goto <D.27812>; else goto <D.27813>;
            <D.27812>:
            D.27548 = &MEM[(void *)"System.Threading" + 3B];
            D.27549 = *D.27548;
            D.27550 = (int) D.27549;
            D.27814 = __s2 + 3;
            D.27815 = *D.27814;
            D.27816 = (int) D.27815;
            __result = D.27550 - D.27816;
            <D.27813>:
            <D.27811>:
            <D.27806>:
            <D.27804>:
            <D.27799>:
            <D.27797>:
          }
          D.24639 = __result;
        }
        iftmp.122 = -D.24639;
        goto <D.27817>;
        <D.27793>:
        D.27425 = method->klass;
        D.27555 = D.27425->name_space;
        iftmp.122 = __builtin_strcmp (D.27555, "System.Threading");
        <D.27817>:
        D.24640 = iftmp.122;
      }
      if (D.24640 == 0) goto <D.27818>; else goto <D.27507>;
      <D.27818>:
      {
        size_t __s1_len;
        size_t __s2_len;

        __s2_len = 8;
        if (__s2_len <= 3) goto <D.27820>; else goto <D.27821>;
        <D.27820>:
        {
          const unsigned char * __s2;
          int __result;

          D.27425 = method->klass;
          __s2 = D.27425->name;
          D.27711 = "Volatile";
          D.27712 = MEM[(const unsigned char *)D.27711];
          D.27713 = (int) D.27712;
          D.27822 = *__s2;
          D.27823 = (int) D.27822;
          __result = D.27713 - D.27823;
          {
            if (__s2_len != 0) goto <D.27824>; else goto <D.27825>;
            <D.27824>:
            if (__result == 0) goto <D.27826>; else goto <D.27827>;
            <D.27826>:
            D.27720 = &MEM[(void *)"Volatile" + 1B];
            D.27721 = *D.27720;
            D.27722 = (int) D.27721;
            D.27828 = __s2 + 1;
            D.27829 = *D.27828;
            D.27830 = (int) D.27829;
            __result = D.27722 - D.27830;
            if (__s2_len > 1) goto <D.27831>; else goto <D.27832>;
            <D.27831>:
            if (__result == 0) goto <D.27833>; else goto <D.27834>;
            <D.27833>:
            D.27730 = &MEM[(void *)"Volatile" + 2B];
            D.27731 = *D.27730;
            D.27732 = (int) D.27731;
            D.27835 = __s2 + 2;
            D.27836 = *D.27835;
            D.27837 = (int) D.27836;
            __result = D.27732 - D.27837;
            if (__s2_len > 2) goto <D.27838>; else goto <D.27839>;
            <D.27838>:
            if (__result == 0) goto <D.27840>; else goto <D.27841>;
            <D.27840>:
            D.27740 = &MEM[(void *)"Volatile" + 3B];
            D.27741 = *D.27740;
            D.27742 = (int) D.27741;
            D.27842 = __s2 + 3;
            D.27843 = *D.27842;
            D.27844 = (int) D.27843;
            __result = D.27742 - D.27844;
            <D.27841>:
            <D.27839>:
            <D.27834>:
            <D.27832>:
            <D.27827>:
            <D.27825>:
          }
          D.24648 = __result;
        }
        iftmp.123 = -D.24648;
        goto <D.27845>;
        <D.27821>:
        D.27425 = method->klass;
        D.27596 = D.27425->name;
        iftmp.123 = __builtin_strcmp (D.27596, "Volatile");
        <D.27845>:
        D.24649 = iftmp.123;
      }
      if (D.24649 == 0) goto <D.27846>; else goto <D.27507>;
      <D.27846>:
      {
        size_t __s1_len;
        size_t __s2_len;

        __s2_len = 5;
        if (__s2_len <= 3) goto <D.27848>; else goto <D.27849>;
        <D.27848>:
        {
          const unsigned char * __s2;
          int __result;

          __s2 = method->name;
          D.27850 = "Write";
          D.27851 = MEM[(const unsigned char *)D.27850];
          D.27852 = (int) D.27851;
          D.27853 = *__s2;
          D.27854 = (int) D.27853;
          __result = D.27852 - D.27854;
          {
            if (__s2_len != 0) goto <D.27855>; else goto <D.27856>;
            <D.27855>:
            if (__result == 0) goto <D.27857>; else goto <D.27858>;
            <D.27857>:
            D.27859 = &MEM[(void *)"Write" + 1B];
            D.27860 = *D.27859;
            D.27861 = (int) D.27860;
            D.27862 = __s2 + 1;
            D.27863 = *D.27862;
            D.27864 = (int) D.27863;
            __result = D.27861 - D.27864;
            if (__s2_len > 1) goto <D.27865>; else goto <D.27866>;
            <D.27865>:
            if (__result == 0) goto <D.27867>; else goto <D.27868>;
            <D.27867>:
            D.27869 = &MEM[(void *)"Write" + 2B];
            D.27870 = *D.27869;
            D.27871 = (int) D.27870;
            D.27872 = __s2 + 2;
            D.27873 = *D.27872;
            D.27874 = (int) D.27873;
            __result = D.27871 - D.27874;
            if (__s2_len > 2) goto <D.27875>; else goto <D.27876>;
            <D.27875>:
            if (__result == 0) goto <D.27877>; else goto <D.27878>;
            <D.27877>:
            D.27879 = &MEM[(void *)"Write" + 3B];
            D.27880 = *D.27879;
            D.27881 = (int) D.27880;
            D.27882 = __s2 + 3;
            D.27883 = *D.27882;
            D.27884 = (int) D.27883;
            __result = D.27881 - D.27884;
            <D.27878>:
            <D.27876>:
            <D.27868>:
            <D.27866>:
            <D.27858>:
            <D.27856>:
          }
          D.24657 = __result;
        }
        iftmp.124 = -D.24657;
        goto <D.27885>;
        <D.27849>:
        D.27429 = method->name;
        iftmp.124 = __builtin_strcmp (D.27429, "Write");
        <D.27885>:
        D.24658 = iftmp.124;
      }
      if (D.24658 == 0) goto <D.27886>; else goto <D.27507>;
      <D.27886>:
      D.27887 = mono_method_signature (method);
      D.27888 = D.27887->params[1];
      D.27889 = mono_type_is_reference (D.27888);
      if (D.27889 != 0) goto <D.27505>; else goto <D.27507>;
      <D.27505>:
      {
        struct MonoMethod * m;
        struct MonoGenericContext ctx;
        struct MonoType * args[16];
        void * iter;

        try
          {
            iter = 0B;
            goto <D.24674>;
            <D.24673>:
            D.27890 = mono_method_signature (m);
            D.27891 = D.27890->generic_param_count;
            if (D.27891 != 0) goto <D.27892>; else goto <D.27893>;
            <D.27892>:
            {
              size_t __s1_len;
              size_t __s2_len;

              D.27894 = m->name;
              D.27429 = method->name;
              D.24671 = __builtin_strcmp (D.27894, D.27429);
            }
            if (D.24671 == 0) goto <D.24672>; else goto <D.27895>;
            <D.27895>:
            <D.27893>:
            <D.24674>:
            D.27425 = method->klass;
            m = mono_class_get_methods (D.27425, &iter);
            if (m != 0B) goto <D.24673>; else goto <D.24672>;
            <D.24672>:
            D.27896 = m == 0B;
            D.27897 = (long int) D.27896;
            D.27898 = __builtin_expect (D.27897, 0);
            if (D.27898 != 0) goto <D.27899>; else goto <D.27900>;
            <D.27899>:
            monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "aot-runtime.c", 3702, "m");
            <D.27900>:
            memset (&ctx, 0, 16);
            D.27497 = mono_defaults.object_class;
            D.27498 = &D.27497->byval_arg;
            args[0] = D.27498;
            D.27901 = mono_metadata_get_generic_inst (1, &args);
            ctx.method_inst = D.27901;
            D.27902 = mono_class_inflate_generic_method (m, &ctx);
            m = mono_marshal_get_native_wrapper (D.27902, 1, 1);
            if (method == m) goto <D.27903>; else goto <D.27904>;
            <D.27903>:
            D.27359 = 0B;
            return D.27359;
            <D.27904>:
            code = mono_aot_get_method (domain, m);
            if (code != 0B) goto <D.27905>; else goto <D.27906>;
            <D.27905>:
            D.27359 = code;
            return D.27359;
            <D.27906>:
          }
        finally
          {
            ctx = {CLOBBER};
            args = {CLOBBER};
            iter = {CLOBBER};
          }
      }
      <D.27507>:
      <D.27515>:
      <D.27511>:
      <D.27509>:
      if (method_index == 16777215) goto <D.27907>; else goto <D.27908>;
      <D.27907>:
      D.27379 = BIT_FIELD_REF <*method, 64, 256>;
      D.27402 = D.27379 & 4096;
      if (D.27402 != 0) goto <D.27909>; else goto <D.27910>;
      <D.27909>:
      D.27911 = mono_method_is_generic_sharable_full (method, 0, 1, 0);
      if (D.27911 != 0) goto <D.27912>; else goto <D.27913>;
      <D.27912>:
      {
        struct MonoMethod * shared;

        shared = mini_get_shared_method (method);
        method_index = find_extra_method (shared, &amodule);
        if (method_index != 16777215) goto <D.27914>; else goto <D.27915>;
        <D.27914>:
        method = shared;
        <D.27915>:
      }
      <D.27913>:
      <D.27910>:
      <D.27908>:
      if (method_index == 16777215) goto <D.27916>; else goto <D.27917>;
      <D.27916>:
      D.27379 = BIT_FIELD_REF <*method, 64, 256>;
      D.27402 = D.27379 & 4096;
      if (D.27402 != 0) goto <D.27918>; else goto <D.27919>;
      <D.27918>:
      D.27920 = mono_method_is_generic_sharable_full (method, 0, 0, 1);
      if (D.27920 != 0) goto <D.27921>; else goto <D.27922>;
      <D.27921>:
      D.27923 = mini_get_shared_method_full (method, 1, 1);
      method_index = find_extra_method (D.27923, &amodule);
      if (method_index != 16777215) goto <D.27924>; else goto <D.27925>;
      <D.27924>:
      method = mini_get_shared_method_full (method, 1, 0);
      <D.27925>:
      <D.27922>:
      <D.27919>:
      <D.27917>:
      if (method_index == 16777215) goto <D.27926>; else goto <D.27927>;
      <D.27926>:
      mono_aot_only.113 = mono_aot_only;
      if (mono_aot_only.113 != 0) goto <D.27928>; else goto <D.27929>;
      <D.27928>:
      D.27930 = mono_trace_is_traced (128, 32);
      if (D.27930 != 0) goto <D.27931>; else goto <D.27932>;
      <D.27931>:
      {
        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.27932>:
      <D.27929>:
      D.27359 = 0B;
      return D.27359;
      <D.27927>:
      if (method_index == 16777215) goto <D.27933>; else goto <D.27934>;
      <D.27933>:
      D.27359 = 0B;
      return D.27359;
      <D.27934>:
      {
        int ret;

        ret = pthread_mutex_lock (&aot_mutex.mutex);
        if (ret != 0) goto <D.27935>; else goto <D.27936>;
        <D.27935>:
        monoeg_g_log (0B, 16, "Bad call to mono_mutex_lock result %d", ret);
        <D.27936>:
        D.27937 = ret != 0;
        D.27938 = (long int) D.27937;
        D.27939 = __builtin_expect (D.27938, 0);
        if (D.27939 != 0) goto <D.27940>; else goto <D.27941>;
        <D.27940>:
        monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "aot-runtime.c", 3756, "ret == 0");
        <D.27941>:
      }
      amodule.112 = amodule;
      D.27942 = amodule.112->extra_methods;
      if (D.27942 == 0B) goto <D.27943>; else goto <D.27944>;
      <D.27943>:
      amodule.112 = amodule;
      D.27945 = monoeg_g_hash_table_new (0B, 0B);
      amodule.112->extra_methods = D.27945;
      <D.27944>:
      amodule.112 = amodule;
      D.27942 = amodule.112->extra_methods;
      D.27946 = (long unsigned int) method_index;
      D.27947 = (void *) D.27946;
      monoeg_g_hash_table_insert_replace (D.27942, D.27947, method, 0);
      {
        int ret;

        ret = pthread_mutex_unlock (&aot_mutex.mutex);
        if (ret != 0) goto <D.27948>; else goto <D.27949>;
        <D.27948>:
        monoeg_g_log (0B, 16, "Bad call to mono_mutex_unlock result %d", ret);
        <D.27949>:
        D.27950 = ret != 0;
        D.27951 = (long int) D.27950;
        D.27952 = __builtin_expect (D.27951, 0);
        if (D.27952 != 0) goto <D.27953>; else goto <D.27954>;
        <D.27953>:
        monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "aot-runtime.c", 3760, "ret == 0");
        <D.27954>:
      }
      goto <D.27401>;
      <D.27400>:
      D.27397 = method->token;
      D.27398 = D.27397 & 16777215;
      method_index = D.27398 + 4294967295;
      <D.27401>:
      <D.27392>:
      amodule.112 = amodule;
      D.27354 = klass->image;
      D.27397 = method->token;
      method_index.125 = (int) method_index;
      D.27359 = load_method (domain, amodule.112, D.27354, method, D.27397, method_index.125);
      return D.27359;
    }
  finally
    {
      amodule = {CLOBBER};
    }
}


find_extra_method (struct MonoMethod * method, struct MonoAotModule * * out_amodule)
{
  struct MonoClass * D.27962;
  struct MonoImage * D.27963;
  void * D.27964;
  guint32 D.27967;
  _Bool D.27970;
  long int D.27971;
  long int D.27972;
  struct GHashTable * aot_modules.126;
  _Bool D.27978;
  long int D.27979;
  long int D.27980;
  void * * D.27983;
  long unsigned int D.27984;
  long unsigned int D.27985;
  void * * D.27986;
  unsigned int i.127;
  unsigned int D.27992;
  guint32 index;
  struct GPtrArray * modules;
  int i;

  D.27962 = method->klass;
  D.27963 = D.27962->image;
  D.27964 = D.27963->aot_module;
  *out_amodule = D.27964;
  D.27962 = method->klass;
  D.27963 = D.27962->image;
  D.27964 = D.27963->aot_module;
  index = find_extra_method_in_amodule (D.27964, method);
  if (index != 16777215) goto <D.27965>; else goto <D.27966>;
  <D.27965>:
  D.27967 = index;
  return D.27967;
  <D.27966>:
  modules = monoeg_g_ptr_array_new ();
  {
    int ret;

    ret = pthread_mutex_lock (&aot_mutex.mutex);
    if (ret != 0) goto <D.27968>; else goto <D.27969>;
    <D.27968>:
    monoeg_g_log (0B, 16, "Bad call to mono_mutex_lock result %d", ret);
    <D.27969>:
    D.27970 = ret != 0;
    D.27971 = (long int) D.27970;
    D.27972 = __builtin_expect (D.27971, 0);
    if (D.27972 != 0) goto <D.27973>; else goto <D.27974>;
    <D.27973>:
    monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "aot-runtime.c", 3559, "ret == 0");
    <D.27974>:
  }
  aot_modules.126 = aot_modules;
  monoeg_g_hash_table_foreach (aot_modules.126, add_module_cb, modules);
  {
    int ret;

    ret = pthread_mutex_unlock (&aot_mutex.mutex);
    if (ret != 0) goto <D.27976>; else goto <D.27977>;
    <D.27976>:
    monoeg_g_log (0B, 16, "Bad call to mono_mutex_unlock result %d", ret);
    <D.27977>:
    D.27978 = ret != 0;
    D.27979 = (long int) D.27978;
    D.27980 = __builtin_expect (D.27979, 0);
    if (D.27980 != 0) goto <D.27981>; else goto <D.27982>;
    <D.27981>:
    monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "aot-runtime.c", 3561, "ret == 0");
    <D.27982>:
  }
  index = 16777215;
  i = 0;
  goto <D.24545>;
  <D.24544>:
  {
    struct MonoAotModule * amodule;

    D.27983 = modules->pdata;
    D.27984 = (long unsigned int) i;
    D.27985 = D.27984 * 8;
    D.27986 = D.27983 + D.27985;
    amodule = *D.27986;
    D.27962 = method->klass;
    D.27963 = D.27962->image;
    D.27964 = D.27963->aot_module;
    if (D.27964 != amodule) goto <D.27987>; else goto <D.27988>;
    <D.27987>:
    index = find_extra_method_in_amodule (amodule, method);
    <D.27988>:
    if (index != 16777215) goto <D.27989>; else goto <D.27990>;
    <D.27989>:
    *out_amodule = amodule;
    goto <D.24543>;
    <D.27990>:
  }
  i = i + 1;
  <D.24545>:
  i.127 = (unsigned int) i;
  D.27992 = modules->len;
  if (i.127 < D.27992) goto <D.24544>; else goto <D.24543>;
  <D.24543>:
  monoeg_g_ptr_array_free (modules, 1);
  D.27967 = index;
  return D.27967;
}


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.27997;
  guint32 D.27998;
  guint32 * D.27999;
  unsigned int D.28000;
  unsigned int D.28001;
  long unsigned int D.28002;
  long unsigned int D.28003;
  unsigned int D.28004;
  unsigned int D.28007;
  long unsigned int D.28008;
  long unsigned int D.28009;
  guint32 * D.28010;
  guint8 * D.28011;
  sizetype D.28012;
  guint8 * p.128;
  _Bool D.28016;
  long int D.28017;
  long int D.28018;
  struct GHashTable * D.28021;
  struct GHashTable * D.28024;
  guint8 * p.129;
  _Bool D.28028;
  long int D.28029;
  long int D.28030;
  _Bool D.28039;
  long int D.28040;
  long int D.28041;
  _Bool D.28046;
  long int D.28047;
  long int D.28048;
  long unsigned int D.28055;
  long unsigned int D.28056;
  long unsigned int D.28061;
  long unsigned int D.28062;
  struct MonoMethod * D.28065;
  unsigned int n_extra_decodes.130;
  unsigned int n_extra_decodes.131;
  unsigned int D.28073;
  long unsigned int D.28074;
  long unsigned int D.28075;
  guint32 table_size;
  guint32 entry_size;
  guint32 hash;
  guint32 * table;
  guint32 * entry;
  guint32 index;
  static guint32 n_extra_decodes;

  if (amodule == 0B) goto <D.27994>; else goto <D.27996>;
  <D.27996>:
  D.27997 = amodule->out_of_date;
  if (D.27997 != 0) goto <D.27994>; else goto <D.27995>;
  <D.27994>:
  D.27998 = 16777215;
  return D.27998;
  <D.27995>:
  D.27999 = amodule->extra_method_table;
  table_size = *D.27999;
  D.27999 = amodule->extra_method_table;
  table = D.27999 + 4;
  entry_size = 3;
  D.28000 = mono_aot_method_hash (method);
  hash = D.28000 % table_size;
  D.28001 = hash * entry_size;
  D.28002 = (long unsigned int) D.28001;
  D.28003 = D.28002 * 4;
  entry = table + D.28003;
  D.28004 = *entry;
  if (D.28004 == 0) goto <D.28005>; else goto <D.28006>;
  <D.28005>:
  D.27998 = 16777215;
  return D.27998;
  <D.28006>:
  index = 16777215;
  <D.24527>:
  {
    guint32 key;
    guint32 value;
    guint32 next;
    struct MonoMethod * m;
    guint8 * p;
    guint8 * orig_p;

    try
      {
        key = *entry;
        value = MEM[(guint32 *)entry + 4B];
        D.28007 = entry_size + 4294967295;
        D.28008 = (long unsigned int) D.28007;
        D.28009 = D.28008 * 4;
        D.28010 = entry + D.28009;
        next = *D.28010;
        D.28011 = amodule->blob;
        D.28012 = (sizetype) key;
        p.128 = D.28011 + D.28012;
        p = p.128;
        orig_p = p;
        {
          int ret;

          ret = pthread_mutex_lock (&aot_mutex.mutex);
          if (ret != 0) goto <D.28014>; else goto <D.28015>;
          <D.28014>:
          monoeg_g_log (0B, 16, "Bad call to mono_mutex_lock result %d", ret);
          <D.28015>:
          D.28016 = ret != 0;
          D.28017 = (long int) D.28016;
          D.28018 = __builtin_expect (D.28017, 0);
          if (D.28018 != 0) goto <D.28019>; else goto <D.28020>;
          <D.28019>:
          monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "aot-runtime.c", 3479, "ret == 0");
          <D.28020>:
        }
        D.28021 = amodule->method_ref_to_method;
        if (D.28021 == 0B) goto <D.28022>; else goto <D.28023>;
        <D.28022>:
        D.28024 = monoeg_g_hash_table_new (0B, 0B);
        amodule->method_ref_to_method = D.28024;
        <D.28023>:
        D.28021 = amodule->method_ref_to_method;
        p.129 = p;
        m = monoeg_g_hash_table_lookup (D.28021, p.129);
        {
          int ret;

          ret = pthread_mutex_unlock (&aot_mutex.mutex);
          if (ret != 0) goto <D.28026>; else goto <D.28027>;
          <D.28026>:
          monoeg_g_log (0B, 16, "Bad call to mono_mutex_unlock result %d", ret);
          <D.28027>:
          D.28028 = ret != 0;
          D.28029 = (long int) D.28028;
          D.28030 = __builtin_expect (D.28029, 0);
          if (D.28030 != 0) goto <D.28031>; else goto <D.28032>;
          <D.28031>:
          monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "aot-runtime.c", 3483, "ret == 0");
          <D.28032>:
        }
        if (m == 0B) goto <D.28033>; else goto <D.28034>;
        <D.28033>:
        p.129 = p;
        m = decode_resolve_method_ref_with_target (amodule, method, p.129, &p);
        if (m != 0B) goto <D.28035>; else goto <D.28036>;
        <D.28035>:
        {
          int ret;

          ret = pthread_mutex_lock (&aot_mutex.mutex);
          if (ret != 0) goto <D.28037>; else goto <D.28038>;
          <D.28037>:
          monoeg_g_log (0B, 16, "Bad call to mono_mutex_lock result %d", ret);
          <D.28038>:
          D.28039 = ret != 0;
          D.28040 = (long int) D.28039;
          D.28041 = __builtin_expect (D.28040, 0);
          if (D.28041 != 0) goto <D.28042>; else goto <D.28043>;
          <D.28042>:
          monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "aot-runtime.c", 3487, "ret == 0");
          <D.28043>:
        }
        D.28021 = amodule->method_ref_to_method;
        monoeg_g_hash_table_insert_replace (D.28021, orig_p, m, 0);
        {
          int ret;

          ret = pthread_mutex_unlock (&aot_mutex.mutex);
          if (ret != 0) goto <D.28044>; else goto <D.28045>;
          <D.28044>:
          monoeg_g_log (0B, 16, "Bad call to mono_mutex_unlock result %d", ret);
          <D.28045>:
          D.28046 = ret != 0;
          D.28047 = (long int) D.28046;
          D.28048 = __builtin_expect (D.28047, 0);
          if (D.28048 != 0) goto <D.28049>; else goto <D.28050>;
          <D.28049>:
          monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "aot-runtime.c", 3489, "ret == 0");
          <D.28050>:
        }
        <D.28036>:
        <D.28034>:
        if (m == method) goto <D.28051>; else goto <D.28052>;
        <D.28051>:
        index = value;
        goto <D.24524>;
        <D.28052>:
        if (m != 0B) goto <D.28053>; else goto <D.28054>;
        <D.28053>:
        D.28055 = BIT_FIELD_REF <*method, 64, 256>;
        D.28056 = D.28055 & 124;
        if (D.28056 != 0) goto <D.28057>; else goto <D.28058>;
        <D.28057>:
        D.28055 = BIT_FIELD_REF <*method, 64, 256>;
        D.28056 = D.28055 & 124;
        if (D.28056 == 64) goto <D.28059>; else goto <D.28060>;
        <D.28059>:
        {
          struct MonoMethod * w1;
          struct MonoMethod * w2;

          w1 = mono_marshal_method_from_wrapper (method);
          w2 = mono_marshal_method_from_wrapper (m);
          D.28061 = BIT_FIELD_REF <*w1, 64, 256>;
          D.28062 = D.28061 & 4096;
          if (D.28062 != 0) goto <D.28063>; else goto <D.28064>;
          <D.28063>:
          D.28065 = MEM[(struct MonoMethodInflated *)w1].declaring;
          if (D.28065 == w2) goto <D.28066>; else goto <D.28067>;
          <D.28066>:
          index = value;
          goto <D.24524>;
          <D.28067>:
          <D.28064>:
        }
        <D.28060>:
        <D.28058>:
        <D.28054>:
        if (m != 0B) goto <D.28068>; else goto <D.28069>;
        <D.28068>:
        n_extra_decodes.130 = n_extra_decodes;
        n_extra_decodes.131 = n_extra_decodes.130 + 1;
        n_extra_decodes = n_extra_decodes.131;
        <D.28069>:
        if (next != 0) goto <D.28072>; else goto <D.24524>;
        <D.28072>:
        D.28073 = next * entry_size;
        D.28074 = (long unsigned int) D.28073;
        D.28075 = D.28074 * 4;
        entry = table + D.28075;
      }
    finally
      {
        p = {CLOBBER};
      }
  }
  goto <D.24527>;
  <D.24524>:
  D.27998 = index;
  return D.27998;
}


load_method (struct MonoDomain * domain, struct MonoAotModule * amodule, struct MonoImage * image, struct MonoMethod * method, guint32 token, int method_index)
{
  _Bool D.28079;
  <unnamed type> D.28080;
  unsigned int D.28081;
  void * D.28084;
  struct MonoDomain * D.28085;
  unsigned int D.28088;
  unsigned int D.28089;
  int D.28092;
  gint32 * D.28095;
  long unsigned int D.28096;
  long unsigned int D.28097;
  gint32 * D.28098;
  int D.28099;
  int D.28102;
  guint8 * D.28107;
  sizetype D.28108;
  guint8 * D.28109;
  guint32 * D.28110;
  unsigned int D.28111;
  sizetype D.28112;
  guint8 * D.28113;
  unsigned int D.28118;
  unsigned int D.28119;
  int D.28122;
  _Bool D.28123;
  long int D.28124;
  long int D.28125;
  sizetype D.28128;
  _Bool D.28131;
  long int D.28132;
  long int D.28133;
  guint32 * D.28136;
  unsigned int D.28139;
  unsigned int D.28140;
  unsigned int D.28141;
  long unsigned int D.28142;
  long unsigned int D.28143;
  void * D.28144;
  _Bool D.28147;
  long int D.28148;
  long int D.28149;
  int D.28152;
  long unsigned int D.28153;
  long unsigned int D.28154;
  guint32 * D.28155;
  unsigned int D.28156;
  int D.28157;
  unsigned int D.28158;
  unsigned int D.28159;
  int mono_last_aot_method.132;
  int D.28165;
  int D.28168;
  guint8 * p.133;
  int D.28183;
  struct MonoDomain * D.28184;
  unsigned int D.28185;
  long unsigned int D.28194;
  long unsigned int D.28195;
  void * * D.28196;
  guint32 * got_slots.134;
  long unsigned int D.28198;
  guint32 * D.28199;
  unsigned int D.28200;
  long unsigned int D.28201;
  long unsigned int D.28202;
  void * * D.28203;
  void * D.28204;
  void * D.28207;
  <unnamed type> D.28208;
  void * D.28211;
  struct MonoMethod * D.28214;
  struct MonoDebugOptions * D.28217;
  int D.28218;
  struct MonoAssembly * D.28221;
  struct MonoImage * D.28222;
  int D.28223;
  int D.28230;
  sizetype D.28231;
  guint8 * D.28232;
  _Bool D.28235;
  long int D.28236;
  long int D.28237;
  int D.28240;
  long unsigned int D.28241;
  long unsigned int D.28242;
  guint32 * D.28243;
  unsigned int D.28244;
  int D.28245;
  unsigned int D.28246;
  unsigned int D.28247;
  long unsigned int D.28250;
  long unsigned int D.28251;
  struct GHashTable * D.28254;
  _Bool D.28257;
  long int D.28258;
  long int D.28259;
  <unnamed type> D.28262;
  unsigned int D.28263;
  long int D.28268;
  long int D.28269;
  _Bool D.28272;
  long int D.28273;
  long int D.28274;
  struct MonoGenericContainer * D.28281;
  struct MonoVTable * D.28284;
  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.28079 = method == 0B;
      from_plt = (gboolean) D.28079;
      keep_patches = 1;
      jinfo = 0B;
      D.28080 = mono_profiler_get_events ();
      D.28081 = D.28080 & 4096;
      if (D.28081 != 0) goto <D.28082>; else goto <D.28083>;
      <D.28082>:
      D.28084 = 0B;
      return D.28084;
      <D.28083>:
      D.28085 = mono_get_root_domain ();
      if (D.28085 != domain) goto <D.28086>; else goto <D.28087>;
      <D.28086>:
      D.28088 = amodule->info.opts;
      D.28089 = D.28088 & 512;
      if (D.28089 == 0) goto <D.28090>; else goto <D.28091>;
      <D.28090>:
      D.28084 = 0B;
      return D.28084;
      <D.28091>:
      <D.28087>:
      D.28092 = amodule->out_of_date;
      if (D.28092 != 0) goto <D.28093>; else goto <D.28094>;
      <D.28093>:
      D.28084 = 0B;
      return D.28084;
      <D.28094>:
      D.28095 = amodule->code_offsets;
      D.28096 = (long unsigned int) method_index;
      D.28097 = D.28096 * 4;
      D.28098 = D.28095 + D.28097;
      D.28099 = *D.28098;
      if (D.28099 == -1) goto <D.28100>; else goto <D.28101>;
      <D.28100>:
      D.28102 = mono_trace_is_traced (128, 32);
      if (D.28102 != 0) goto <D.28103>; else goto <D.28104>;
      <D.28103>:
      {
        char * full_name;

        if (method == 0B) goto <D.28105>; else goto <D.28106>;
        <D.28105>:
        method = mono_get_method (image, token, 0B);
        <D.28106>:
        full_name = mono_method_full_name (method, 1);
        mono_trace (128, 32, "AOT NOT FOUND: %s.", full_name);
        monoeg_g_free (full_name);
      }
      <D.28104>:
      D.28084 = 0B;
      return D.28084;
      <D.28101>:
      D.28107 = amodule->code;
      D.28095 = amodule->code_offsets;
      D.28096 = (long unsigned int) method_index;
      D.28097 = D.28096 * 4;
      D.28098 = D.28095 + D.28097;
      D.28099 = *D.28098;
      D.28108 = (sizetype) D.28099;
      code = D.28107 + D.28108;
      D.28109 = amodule->blob;
      D.28110 = amodule->method_info_offsets;
      D.28111 = mono_aot_get_offset (D.28110, method_index);
      D.28112 = (sizetype) D.28111;
      info = D.28109 + D.28112;
      D.28113 = amodule->thumb_end;
      if (D.28113 != 0B) goto <D.28114>; else goto <D.28115>;
      <D.28114>:
      D.28113 = amodule->thumb_end;
      if (D.28113 > code) goto <D.28116>; else goto <D.28117>;
      <D.28116>:
      D.28118 = amodule->info.flags;
      D.28119 = D.28118 & 8;
      if (D.28119 == 0) goto <D.28120>; else goto <D.28121>;
      <D.28120>:
      D.28095 = amodule->code_offsets;
      D.28096 = (long unsigned int) method_index;
      D.28097 = D.28096 * 4;
      D.28098 = D.28095 + D.28097;
      D.28099 = *D.28098;
      D.28122 = D.28099 & 1;
      D.28123 = D.28122 != 0;
      D.28124 = (long int) D.28123;
      D.28125 = __builtin_expect (D.28124, 0);
      if (D.28125 != 0) goto <D.28126>; else goto <D.28127>;
      <D.28126>:
      monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "aot-runtime.c", 3299, "(amodule->code_offsets [method_index] & 0x1) == 0");
      <D.28127>:
      D.28107 = amodule->code;
      D.28095 = amodule->code_offsets;
      D.28096 = (long unsigned int) method_index;
      D.28097 = D.28096 * 4;
      D.28098 = D.28095 + D.28097;
      D.28099 = *D.28098;
      D.28108 = (sizetype) D.28099;
      D.28128 = D.28108 + 1;
      code = D.28107 + D.28128;
      <D.28121>:
      <D.28117>:
      <D.28115>:
      {
        int ret;

        ret = pthread_mutex_lock (&aot_mutex.mutex);
        if (ret != 0) goto <D.28129>; else goto <D.28130>;
        <D.28129>:
        monoeg_g_log (0B, 16, "Bad call to mono_mutex_lock result %d", ret);
        <D.28130>:
        D.28131 = ret != 0;
        D.28132 = (long int) D.28131;
        D.28133 = __builtin_expect (D.28132, 0);
        if (D.28133 != 0) goto <D.28134>; else goto <D.28135>;
        <D.28134>:
        monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "aot-runtime.c", 3303, "ret == 0");
        <D.28135>:
      }
      D.28136 = amodule->methods_loaded;
      if (D.28136 == 0B) goto <D.28137>; else goto <D.28138>;
      <D.28137>:
      D.28139 = amodule->info.nmethods;
      D.28140 = D.28139 / 32;
      D.28141 = D.28140 + 1;
      D.28142 = (long unsigned int) D.28141;
      D.28143 = D.28142 * 4;
      D.28144 = monoeg_malloc0 (D.28143);
      amodule->methods_loaded = D.28144;
      <D.28138>:
      {
        int ret;

        ret = pthread_mutex_unlock (&aot_mutex.mutex);
        if (ret != 0) goto <D.28145>; else goto <D.28146>;
        <D.28145>:
        monoeg_g_log (0B, 16, "Bad call to mono_mutex_unlock result %d", ret);
        <D.28146>:
        D.28147 = ret != 0;
        D.28148 = (long int) D.28147;
        D.28149 = __builtin_expect (D.28148, 0);
        if (D.28149 != 0) goto <D.28150>; else goto <D.28151>;
        <D.28150>:
        monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "aot-runtime.c", 3306, "ret == 0");
        <D.28151>:
      }
      D.28136 = amodule->methods_loaded;
      D.28152 = method_index / 32;
      D.28153 = (long unsigned int) D.28152;
      D.28154 = D.28153 * 4;
      D.28155 = D.28136 + D.28154;
      D.28156 = *D.28155;
      D.28157 = method_index % 32;
      D.28158 = D.28156 >> D.28157;
      D.28159 = D.28158 & 1;
      if (D.28159 != 0) goto <D.28160>; else goto <D.28161>;
      <D.28160>:
      D.28084 = code;
      return D.28084;
      <D.28161>:
      mono_last_aot_method.132 = mono_last_aot_method;
      if (mono_last_aot_method.132 != -1) goto <D.28163>; else goto <D.28164>;
      <D.28163>:
      D.28165 = mono_jit_stats.methods_aot;
      mono_last_aot_method.132 = mono_last_aot_method;
      if (D.28165 >= mono_last_aot_method.132) goto <D.28166>; else goto <D.28167>;
      <D.28166>:
      D.28084 = 0B;
      return D.28084;
      <D.28167>:
      D.28165 = mono_jit_stats.methods_aot;
      mono_last_aot_method.132 = mono_last_aot_method;
      D.28168 = mono_last_aot_method.132 + -1;
      if (D.28165 == D.28168) goto <D.28169>; else goto <D.28170>;
      <D.28169>:
      if (method == 0B) goto <D.28171>; else goto <D.28172>;
      <D.28171>:
      method = mono_get_method (image, token, 0B);
      <D.28172>:
      if (method != 0B) goto <D.28173>; else goto <D.28174>;
      <D.28173>:
      {
        char * name;

        name = mono_method_full_name (method, 1);
        printf ("LAST AOT METHOD: %s.\n", name);
        monoeg_g_free (name);
      }
      goto <D.28175>;
      <D.28174>:
      printf ("LAST AOT METHOD: %p %d\n", code, method_index);
      <D.28175>:
      <D.28170>:
      <D.28164>:
      p = info;
      if (method != 0B) goto <D.28176>; else goto <D.28177>;
      <D.28176>:
      klass = method->klass;
      p.133 = p;
      decode_klass_ref (amodule, p.133, &p);
      goto <D.28179>;
      <D.28177>:
      p.133 = p;
      klass = decode_klass_ref (amodule, p.133, &p);
      <D.28179>:
      D.28088 = amodule->info.opts;
      D.28089 = D.28088 & 512;
      if (D.28089 != 0) goto <D.28180>; else goto <D.28181>;
      <D.28180>:
      p.133 = p;
      used_strings = decode_value (p.133, &p);
      goto <D.28182>;
      <D.28181>:
      used_strings = 0;
      <D.28182>:
      i = 0;
      goto <D.24490>;
      <D.24489>:
      {
        guint token;

        p.133 = p;
        D.28183 = decode_value (p.133, &p);
        token = (guint) D.28183;
        D.28184 = mono_get_root_domain ();
        D.28185 = token & 16777215;
        mono_ldstr (D.28184, image, D.28185);
      }
      i = i + 1;
      <D.24490>:
      if (i < used_strings) goto <D.24489>; else goto <D.24491>;
      <D.24491>:
      D.28088 = amodule->info.opts;
      D.28089 = D.28088 & 512;
      if (D.28089 != 0) goto <D.28186>; else goto <D.28187>;
      <D.28186>:
      keep_patches = 0;
      <D.28187>:
      p.133 = p;
      n_patches = decode_value (p.133, &p);
      keep_patches = 0;
      if (n_patches != 0) goto <D.28188>; else goto <D.28189>;
      <D.28188>:
      {
        struct MonoJumpInfo * patches;
        guint32 * got_slots;

        try
          {
            if (keep_patches != 0) goto <D.28190>; else goto <D.28191>;
            <D.28190>:
            mp = domain->mp;
            goto <D.28192>;
            <D.28191>:
            mp = mono_mempool_new ();
            <D.28192>:
            p.133 = p;
            patches = load_patch_info (amodule, mp, n_patches, &got_slots, p.133, &p);
            if (patches == 0B) goto cleanup; else goto <D.28193>;
            <D.28193>:
            pindex = 0;
            goto <D.24497>;
            <D.24496>:
            {
              struct MonoJumpInfo * ji;

              D.28194 = (long unsigned int) pindex;
              D.28195 = D.28194 * 40;
              ji = patches + D.28195;
              D.28196 = amodule->got;
              got_slots.134 = got_slots;
              D.28194 = (long unsigned int) pindex;
              D.28198 = D.28194 * 4;
              D.28199 = got_slots.134 + D.28198;
              D.28200 = *D.28199;
              D.28201 = (long unsigned int) D.28200;
              D.28202 = D.28201 * 8;
              D.28203 = D.28196 + D.28202;
              D.28204 = *D.28203;
              if (D.28204 == 0B) goto <D.28205>; else goto <D.28206>;
              <D.28205>:
              D.28196 = amodule->got;
              got_slots.134 = got_slots;
              D.28194 = (long unsigned int) pindex;
              D.28198 = D.28194 * 4;
              D.28199 = got_slots.134 + D.28198;
              D.28200 = *D.28199;
              D.28201 = (long unsigned int) D.28200;
              D.28202 = D.28201 * 8;
              D.28203 = D.28196 + D.28202;
              D.28207 = mono_resolve_patch_target (method, domain, code, ji, 1);
              *D.28203 = D.28207;
              D.28208 = ji->type;
              if (D.28208 == 4) goto <D.28209>; else goto <D.28210>;
              <D.28209>:
              D.28196 = amodule->got;
              got_slots.134 = got_slots;
              D.28194 = (long unsigned int) pindex;
              D.28198 = D.28194 * 4;
              D.28199 = got_slots.134 + D.28198;
              D.28200 = *D.28199;
              D.28201 = (long unsigned int) D.28200;
              D.28202 = D.28201 * 8;
              D.28203 = D.28196 + D.28202;
              D.28196 = amodule->got;
              got_slots.134 = got_slots;
              D.28194 = (long unsigned int) pindex;
              D.28198 = D.28194 * 4;
              D.28199 = got_slots.134 + D.28198;
              D.28200 = *D.28199;
              D.28201 = (long unsigned int) D.28200;
              D.28202 = D.28201 * 8;
              D.28203 = D.28196 + D.28202;
              D.28204 = *D.28203;
              D.28211 = mono_create_ftnptr (domain, D.28204);
              *D.28203 = D.28211;
              <D.28210>:
              D.28208 = ji->type;
              if (D.28208 == 4) goto <D.28212>; else goto <D.28213>;
              <D.28212>:
              D.28214 = ji->data.method;
              D.28196 = amodule->got;
              got_slots.134 = got_slots;
              D.28194 = (long unsigned int) pindex;
              D.28198 = D.28194 * 4;
              D.28199 = got_slots.134 + D.28198;
              D.28200 = *D.28199;
              D.28201 = (long unsigned int) D.28200;
              D.28202 = D.28201 * 8;
              D.28203 = D.28196 + D.28202;
              register_jump_target_got_slot (domain, D.28214, D.28203);
              <D.28213>:
              <D.28206>:
              ji->type = 51;
            }
            pindex = pindex + 1;
            <D.24497>:
            if (pindex < n_patches) goto <D.24496>; else goto <D.24498>;
            <D.24498>:
            got_slots.134 = got_slots;
            monoeg_g_free (got_slots.134);
            if (keep_patches == 0) goto <D.28215>; else goto <D.28216>;
            <D.28215>:
            mono_mempool_destroy (mp);
            <D.28216>:
          }
        finally
          {
            got_slots = {CLOBBER};
          }
      }
      <D.28189>:
      D.28217 = mini_get_debug_options ();
      D.28218 = D.28217->load_aot_jit_info_eagerly;
      if (D.28218 != 0) goto <D.28219>; else goto <D.28220>;
      <D.28219>:
      D.28221 = amodule->assembly;
      D.28222 = D.28221->image;
      jinfo = mono_aot_find_jit_info (domain, D.28222, code);
      <D.28220>:
      D.28223 = mono_trace_is_traced (128, 32);
      if (D.28223 != 0) goto <D.28224>; else goto <D.28225>;
      <D.28224>:
      {
        char * full_name;

        if (method == 0B) goto <D.28226>; else goto <D.28227>;
        <D.28226>:
        method = mono_get_method (image, token, 0B);
        <D.28227>:
        full_name = mono_method_full_name (method, 1);
        if (jinfo == 0B) goto <D.28228>; else goto <D.28229>;
        <D.28228>:
        D.28221 = amodule->assembly;
        D.28222 = D.28221->image;
        jinfo = mono_aot_find_jit_info (domain, D.28222, code);
        <D.28229>:
        D.28230 = jinfo->code_size;
        D.28231 = (sizetype) D.28230;
        D.28232 = code + D.28231;
        mono_trace (128, 32, "AOT FOUND method %s [%p - %p %p]", full_name, code, D.28232, info);
        monoeg_g_free (full_name);
      }
      <D.28225>:
      {
        int ret;

        ret = pthread_mutex_lock (&aot_mutex.mutex);
        if (ret != 0) goto <D.28233>; else goto <D.28234>;
        <D.28233>:
        monoeg_g_log (0B, 16, "Bad call to mono_mutex_lock result %d", ret);
        <D.28234>:
        D.28235 = ret != 0;
        D.28236 = (long int) D.28235;
        D.28237 = __builtin_expect (D.28236, 0);
        if (D.28237 != 0) goto <D.28238>; else goto <D.28239>;
        <D.28238>:
        monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "aot-runtime.c", 3403, "ret == 0");
        <D.28239>:
      }
      InterlockedIncrement (&mono_jit_stats.methods_aot);
      D.28136 = amodule->methods_loaded;
      D.28240 = method_index / 32;
      D.28241 = (long unsigned int) D.28240;
      D.28242 = D.28241 * 4;
      D.28243 = D.28136 + D.28242;
      D.28136 = amodule->methods_loaded;
      D.28241 = (long unsigned int) D.28240;
      D.28242 = D.28241 * 4;
      D.28243 = D.28136 + D.28242;
      D.28244 = *D.28243;
      D.28157 = method_index % 32;
      D.28245 = 1 << D.28157;
      D.28246 = (unsigned int) D.28245;
      D.28247 = D.28244 | D.28246;
      *D.28243 = D.28247;
      init_plt (amodule);
      if (method != 0B) goto <D.28248>; else goto <D.28249>;
      <D.28248>:
      D.28250 = BIT_FIELD_REF <*method, 64, 256>;
      D.28251 = D.28250 & 124;
      if (D.28251 != 0) goto <D.28252>; else goto <D.28253>;
      <D.28252>:
      D.28254 = amodule->method_to_code;
      monoeg_g_hash_table_insert_replace (D.28254, method, code, 0);
      <D.28253>:
      <D.28249>:
      {
        int ret;

        ret = pthread_mutex_unlock (&aot_mutex.mutex);
        if (ret != 0) goto <D.28255>; else goto <D.28256>;
        <D.28255>:
        monoeg_g_log (0B, 16, "Bad call to mono_mutex_unlock result %d", ret);
        <D.28256>:
        D.28257 = ret != 0;
        D.28258 = (long int) D.28257;
        D.28259 = __builtin_expect (D.28258, 0);
        if (D.28259 != 0) goto <D.28260>; else goto <D.28261>;
        <D.28260>:
        monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "aot-runtime.c", 3414, "ret == 0");
        <D.28261>:
      }
      D.28262 = mono_profiler_get_events ();
      D.28263 = D.28262 & 16;
      if (D.28263 != 0) goto <D.28264>; else goto <D.28265>;
      <D.28264>:
      {
        struct MonoJitInfo * jinfo;

        if (method == 0B) goto <D.28266>; else goto <D.28267>;
        <D.28266>:
        method = mono_get_method (image, token, 0B);
        D.28079 = method == 0B;
        D.28268 = (long int) D.28079;
        D.28269 = __builtin_expect (D.28268, 0);
        if (D.28269 != 0) goto <D.28270>; else goto <D.28271>;
        <D.28270>:
        monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "aot-runtime.c", 3421, "method");
        <D.28271>:
        <D.28267>:
        mono_profiler_method_jit (method);
        jinfo = mono_jit_info_table_find (domain, code);
        D.28272 = jinfo == 0B;
        D.28273 = (long int) D.28272;
        D.28274 = __builtin_expect (D.28273, 0);
        if (D.28274 != 0) goto <D.28275>; else goto <D.28276>;
        <D.28275>:
        monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "aot-runtime.c", 3425, "jinfo");
        <D.28276>:
        mono_profiler_method_end_jit (method, jinfo, 0);
      }
      <D.28265>:
      if (from_plt != 0) goto <D.28277>; else goto <D.28278>;
      <D.28277>:
      if (klass != 0B) goto <D.28279>; else goto <D.28280>;
      <D.28279>:
      D.28281 = klass->generic_container;
      if (D.28281 == 0B) goto <D.28282>; else goto <D.28283>;
      <D.28282>:
      D.28284 = mono_class_vtable (domain, klass);
      mono_runtime_class_init (D.28284);
      <D.28283>:
      <D.28280>:
      <D.28278>:
      D.28084 = code;
      return D.28084;
      cleanup:
      D.28088 = amodule->info.opts;
      D.28089 = D.28088 & 512;
      if (D.28089 != 0) goto <D.28285>; else goto <D.28286>;
      <D.28285>:
      mono_mempool_destroy (mp);
      <D.28286>:
      if (jinfo != 0B) goto <D.28287>; else goto <D.28288>;
      <D.28287>:
      monoeg_g_free (jinfo);
      <D.28288>:
      D.28084 = 0B;
      return D.28084;
    }
  finally
    {
      p = {CLOBBER};
    }
}


printf (const char * restrict __fmt)
{
  int D.28293;

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


load_patch_info (struct MonoAotModule * aot_module, struct MonoMemPool * mp, int n_patches, guint32 * * got_slots, guint8 * buf, guint8 * * endbuf)
{
  long unsigned int D.28295;
  unsigned int D.28296;
  unsigned int D.28297;
  long unsigned int D.28298;
  void * D.28299;
  long unsigned int D.28300;
  long unsigned int D.28301;
  guint8 * p.135;
  int D.28303;
  void * * D.28304;
  long unsigned int D.28305;
  long unsigned int D.28306;
  void * * D.28307;
  void * D.28308;
  guint8 * D.28312;
  guint32 * D.28313;
  int got_offset.136;
  unsigned int D.28315;
  sizetype D.28316;
  guint8 * shared_p.137;
  guint8 * shared_p.138;
  int D.28319;
  <unnamed type> D.28320;
  guint32 * D.28322;
  long unsigned int D.28323;
  guint32 * D.28324;
  struct MonoJumpInfo * D.28325;
  struct MonoJumpInfo * patches;
  int pindex;
  guint8 * p;
  void cleanup = <<< error >>>;

  try
    {
      p = buf;
      D.28295 = (long unsigned int) n_patches;
      D.28296 = (unsigned int) D.28295;
      D.28297 = D.28296 * 40;
      patches = mono_mempool_alloc0 (mp, D.28297);
      D.28295 = (long unsigned int) n_patches;
      D.28298 = D.28295 * 4;
      D.28299 = monoeg_malloc (D.28298);
      *got_slots = D.28299;
      pindex = 0;
      goto <D.24453>;
      <D.24452>:
      {
        struct MonoJumpInfo * ji;
        guint8 * shared_p;
        gboolean res;
        guint32 got_offset;

        try
          {
            D.28300 = (long unsigned int) pindex;
            D.28301 = D.28300 * 40;
            ji = patches + D.28301;
            p.135 = p;
            D.28303 = decode_value (p.135, &p);
            got_offset = (guint32) D.28303;
            D.28304 = aot_module->got;
            D.28305 = (long unsigned int) got_offset;
            D.28306 = D.28305 * 8;
            D.28307 = D.28304 + D.28306;
            D.28308 = *D.28307;
            if (D.28308 != 0B) goto <D.28309>; else goto <D.28310>;
            <D.28309>:
            goto <D.28311>;
            <D.28310>:
            D.28312 = aot_module->blob;
            D.28313 = aot_module->got_info_offsets;
            got_offset.136 = (int) got_offset;
            D.28315 = mono_aot_get_offset (D.28313, got_offset.136);
            D.28316 = (sizetype) D.28315;
            shared_p.137 = D.28312 + D.28316;
            shared_p = shared_p.137;
            shared_p.138 = shared_p;
            D.28319 = decode_value (shared_p.138, &shared_p);
            D.28320 = (<unnamed type>) D.28319;
            ji->type = D.28320;
            shared_p.138 = shared_p;
            res = decode_patch (aot_module, mp, ji, shared_p.138, &shared_p);
            if (res == 0) goto cleanup; else goto <D.28321>;
            <D.28321>:
            <D.28311>:
            D.28322 = *got_slots;
            D.28300 = (long unsigned int) pindex;
            D.28323 = D.28300 * 4;
            D.28324 = D.28322 + D.28323;
            *D.28324 = got_offset;
          }
        finally
          {
            shared_p = {CLOBBER};
          }
      }
      pindex = pindex + 1;
      <D.24453>:
      if (pindex < n_patches) goto <D.24452>; else goto <D.24454>;
      <D.24454>:
      p.135 = p;
      *endbuf = p.135;
      D.28325 = patches;
      return D.28325;
      cleanup:
      D.28322 = *got_slots;
      monoeg_g_free (D.28322);
      *got_slots = 0B;
      D.28325 = 0B;
      return D.28325;
    }
  finally
    {
      p = {CLOBBER};
    }
}


decode_patch (struct MonoAotModule * aot_module, struct MonoMemPool * mp, struct MonoJumpInfo * ji, guint8 * buf, guint8 * * endbuf)
{
  <unnamed type> D.28330;
  guint8 * p.139;
  struct MonoMethod * D.28335;
  int mono_aot_only.140;
  int D.28339;
  unsigned int D.28342;
  unsigned int D.28343;
  struct MonoDomain * D.28345;
  struct MonoImage * D.28346;
  void * D.28347;
  void * D.28348;
  struct MonoMethod * D.28352;
  struct MonoMethod * D.28353;
  _Bool D.28354;
  long int D.28355;
  long int D.28356;
  struct MonoClass * D.28359;
  int D.28360;
  unsigned int D.28361;
  sizetype D.28362;
  guint8 * p.141;
  struct MonoMethod * D.28364;
  struct MonoClass * D.28366;
  struct MonoClass * D.28367;
  struct MonoClass * D.28369;
  int D.28371;
  struct MonoImage * D.28372;
  struct MonoImage * D.28373;
  struct MonoClassField * D.28375;
  struct MonoClassField * D.28376;
  void * D.28378;
  struct MonoJumpInfoBBTable * D.28379;
  int D.28380;
  struct MonoDomain * D.28381;
  int D.28382;
  long unsigned int D.28383;
  unsigned int D.28384;
  unsigned int D.28385;
  long unsigned int D.28386;
  long unsigned int D.28387;
  void * * D.28388;
  int D.28389;
  long int D.28390;
  void * D.28391;
  struct MonoDomain * D.28392;
  void * D.28393;
  int D.28394;
  unsigned int val.142;
  const void * D.28396;
  guint32 * val.143;
  float D.28398;
  struct MonoDomain * D.28399;
  void * D.28400;
  int D.28401;
  unsigned int D.28402;
  int D.28403;
  unsigned int D.28404;
  unsigned int D.28405;
  long unsigned int D.28406;
  long unsigned int D.28407;
  unsigned int D.28408;
  long unsigned int D.28409;
  long unsigned int v.144;
  guint64 * v.145;
  double D.28412;
  int D.28413;
  int D.28415;
  int D.28416;
  unsigned int D.28417;
  struct MonoJumpInfoToken * D.28418;
  int D.28419;
  int D.28421;
  unsigned int D.28422;
  struct MonoJumpInfoToken * D.28423;
  struct MonoJumpInfoToken * D.28424;
  int D.28425;
  int D.28426;
  struct MonoGenericContext * D.28429;
  struct MonoClass * D.28431;
  const char * D.28433;
  int D.28434;
  long int D.28435;
  int D.28436;
  int D.28437;
  guint8 * D.28438;
  sizetype D.28439;
  guint8 * p2.146;
  guint8 * p2.147;
  struct MonoMethod * D.28442;
  unsigned int D.28443;
  _Bool D.28444;
  int D.28445;
  unsigned int D.28446;
  unsigned int D.28447;
  void * D.28448;
  struct MonoJumpInfo * D.28449;
  unsigned int D.28450;
  unsigned int D.28451;
  struct MonoMethod * D.28453;
  int D.28454;
  struct MonoMethodSignature * D.28455;
  int D.28456;
  long int D.28457;
  const void * D.28458;
  struct MonoMethodSignature * D.28459;
  struct MonoMethodSignature * D.28460;
  _Bool D.28461;
  long int D.28462;
  long int D.28463;
  struct MonoMethod * D.28466;
  struct MonoMethod * D.28467;
  _Bool D.28468;
  long int D.28469;
  long int D.28470;
  struct MonoMethod * D.28473;
  struct MonoMethod * D.28474;
  _Bool D.28475;
  long int D.28476;
  long int D.28477;
  struct GPtrArray * D.28480;
  int D.28481;
  <unnamed type> D.28482;
  <unnamed type> D.28483;
  <unnamed type> D.28484;
  struct MonoType * D.28486;
  struct MonoClassField * D.28487;
  void * D.28488;
  struct GPtrArray * D.28490;
  gboolean D.28491;
  guint8 * p;
  void * * table;
  struct MonoImage * image;
  int i;
  void cleanup = <<< error >>>;

  try
    {
      p = buf;
      D.28330 = ji->type;
      switch (D.28330) <default: <D.24435>, case 3: <D.24363>, case 4: <D.24364>, case 5: <D.24401>, case 6: <D.24375>, case 7: <D.24372>, case 8: <D.24385>, case 10: <D.24400>, case 11: <D.24377>, case 12: <D.24382>, case 13: <D.24383>, case 14: <D.24376>, case 15: <D.24380>, case 16: <D.24384>, case 17: <D.24394>, case 18: <D.24397>, case 19: <D.24398>, case 20: <D.24389>, case 21: <D.24391>, case 23: <D.24378>, case 24: <D.24379>, case 28: <D.24396>, case 29: <D.24395>, case 30: <D.24381>, case 31: <D.24365>, case 32: <D.24373>, case 33: <D.24402>, case 34: <D.24366>, case 35: <D.24409>, case 36: <D.24403>, case 37: <D.24404>, case 38: <D.24405>, case 40: <D.24415>, case 41: <D.24416>, case 42: <D.24406>, case 43: <D.24407>, case 44: <D.24418>, case 45: <D.24420>, case 46: <D.24422>, case 47: <D.24408>, case 48: <D.24419>, case 50: <D.24367>>
      <D.24363>:
      <D.24364>:
      <D.24365>:
      <D.24366>:
      <D.24367>:
      {
        struct MethodRef ref;
        gboolean res;

        try
          {
            p.139 = p;
            res = decode_method_ref (aot_module, &ref, p.139, &p);
            if (res == 0) goto cleanup; else goto <D.28332>;
            <D.28332>:
            D.28335 = ref.method;
            if (D.28335 == 0B) goto <D.28336>; else goto <D.28333>;
            <D.28336>:
            mono_aot_only.140 = mono_aot_only;
            if (mono_aot_only.140 == 0) goto <D.28338>; else goto <D.28333>;
            <D.28338>:
            D.28339 = ref.no_aot_trampoline;
            if (D.28339 == 0) goto <D.28340>; else goto <D.28333>;
            <D.28340>:
            D.28330 = ji->type;
            if (D.28330 == 3) goto <D.28341>; else goto <D.28333>;
            <D.28341>:
            D.28342 = ref.token;
            D.28343 = D.28342 >> 24;
            if (D.28343 == 6) goto <D.28344>; else goto <D.28333>;
            <D.28344>:
            D.28345 = mono_domain_get ();
            D.28346 = ref.image;
            D.28342 = ref.token;
            D.28347 = mono_create_jit_trampoline_from_token (D.28346, D.28342);
            D.28348 = mono_create_ftnptr (D.28345, D.28347);
            ji->data.target = D.28348;
            ji->type = 1;
            goto <D.28334>;
            <D.28333>:
            D.28335 = ref.method;
            if (D.28335 != 0B) goto <D.28349>; else goto <D.28350>;
            <D.28349>:
            D.28335 = ref.method;
            ji->data.method = D.28335;
            goto <D.28351>;
            <D.28350>:
            D.28346 = ref.image;
            D.28342 = ref.token;
            D.28352 = mono_get_method (D.28346, D.28342, 0B);
            ji->data.method = D.28352;
            <D.28351>:
            D.28353 = ji->data.method;
            D.28354 = D.28353 == 0B;
            D.28355 = (long int) D.28354;
            D.28356 = __builtin_expect (D.28355, 0);
            if (D.28356 != 0) goto <D.28357>; else goto <D.28358>;
            <D.28357>:
            monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "aot-runtime.c", 2969, "ji->data.method");
            <D.28358>:
            D.28353 = ji->data.method;
            D.28359 = D.28353->klass;
            mono_class_init (D.28359);
            <D.28334>:
            goto <D.24371>;
          }
        finally
          {
            ref = {CLOBBER};
          }
      }
      <D.24372>:
      <D.24373>:
      {
        guint32 len;

        p.139 = p;
        D.28360 = decode_value (p.139, &p);
        len = (guint32) D.28360;
        p.139 = p;
        ji->data.name = p.139;
        p.139 = p;
        D.28361 = len + 1;
        D.28362 = (sizetype) D.28361;
        p.141 = p.139 + D.28362;
        p = p.141;
        goto <D.24371>;
      }
      <D.24375>:
      p.139 = p;
      D.28364 = decode_resolve_method_ref (aot_module, p.139, &p);
      ji->data.method = D.28364;
      D.28353 = ji->data.method;
      if (D.28353 == 0B) goto cleanup; else goto <D.28365>;
      <D.28365>:
      goto <D.24371>;
      <D.24376>:
      <D.24377>:
      <D.24378>:
      <D.24379>:
      p.139 = p;
      D.28366 = decode_klass_ref (aot_module, p.139, &p);
      ji->data.klass = D.28366;
      D.28367 = ji->data.klass;
      if (D.28367 == 0B) goto cleanup; else goto <D.28368>;
      <D.28368>:
      goto <D.24371>;
      <D.24380>:
      <D.24381>:
      p.139 = p;
      D.28369 = decode_klass_ref (aot_module, p.139, &p);
      ji->data.klass = D.28369;
      D.28367 = ji->data.klass;
      if (D.28367 == 0B) goto cleanup; else goto <D.28370>;
      <D.28370>:
      goto <D.24371>;
      <D.24382>:
      p.139 = p;
      D.28371 = decode_value (p.139, &p);
      D.28372 = load_image (aot_module, D.28371, 1);
      ji->data.image = D.28372;
      D.28373 = ji->data.image;
      if (D.28373 == 0B) goto cleanup; else goto <D.28374>;
      <D.28374>:
      goto <D.24371>;
      <D.24383>:
      <D.24384>:
      p.139 = p;
      D.28375 = decode_field_info (aot_module, p.139, &p);
      ji->data.field = D.28375;
      D.28376 = ji->data.field;
      if (D.28376 == 0B) goto cleanup; else goto <D.28377>;
      <D.28377>:
      goto <D.24371>;
      <D.24385>:
      D.28378 = mono_mempool_alloc0 (mp, 16);
      ji->data.table = D.28378;
      D.28379 = ji->data.table;
      p.139 = p;
      D.28380 = decode_value (p.139, &p);
      D.28379->table_size = D.28380;
      D.28381 = mono_domain_get ();
      D.28379 = ji->data.table;
      D.28382 = D.28379->table_size;
      D.28383 = (long unsigned int) D.28382;
      D.28384 = (unsigned int) D.28383;
      D.28385 = D.28384 * 8;
      table = mono_domain_alloc (D.28381, D.28385);
      D.28379 = ji->data.table;
      D.28379->table = table;
      i = 0;
      goto <D.24387>;
      <D.24386>:
      D.28386 = (long unsigned int) i;
      D.28387 = D.28386 * 8;
      D.28388 = table + D.28387;
      p.139 = p;
      D.28389 = decode_value (p.139, &p);
      D.28390 = (long int) D.28389;
      D.28391 = (void *) D.28390;
      *D.28388 = D.28391;
      i = i + 1;
      <D.24387>:
      D.28379 = ji->data.table;
      D.28382 = D.28379->table_size;
      if (D.28382 > i) goto <D.24386>; else goto <D.24388>;
      <D.24388>:
      goto <D.24371>;
      <D.24389>:
      {
        guint32 val;

        try
          {
            D.28392 = mono_domain_get ();
            D.28393 = mono_domain_alloc0 (D.28392, 4);
            ji->data.target = D.28393;
            p.139 = p;
            D.28394 = decode_value (p.139, &p);
            val.142 = (unsigned int) D.28394;
            val = val.142;
            D.28396 = ji->data.target;
            val.143 = &val;
            D.28398 = MEM[(float *)val.143];
            MEM[(float *)D.28396] = D.28398;
            goto <D.24371>;
          }
        finally
          {
            val = {CLOBBER};
          }
      }
      <D.24391>:
      {
        guint32 val[2];
        guint64 v;

        try
          {
            D.28399 = mono_domain_get ();
            D.28400 = mono_domain_alloc0 (D.28399, 8);
            ji->data.target = D.28400;
            p.139 = p;
            D.28401 = decode_value (p.139, &p);
            D.28402 = (unsigned int) D.28401;
            val[0] = D.28402;
            p.139 = p;
            D.28403 = decode_value (p.139, &p);
            D.28404 = (unsigned int) D.28403;
            val[1] = D.28404;
            D.28405 = val[1];
            D.28406 = (long unsigned int) D.28405;
            D.28407 = D.28406 << 32;
            D.28408 = val[0];
            D.28409 = (long unsigned int) D.28408;
            v.144 = D.28407 | D.28409;
            v = v.144;
            D.28396 = ji->data.target;
            v.145 = &v;
            D.28412 = MEM[(double *)v.145];
            MEM[(double *)D.28396] = D.28412;
            goto <D.24371>;
          }
        finally
          {
            val = {CLOBBER};
            v = {CLOBBER};
          }
      }
      <D.24394>:
      p.139 = p;
      D.28413 = decode_value (p.139, &p);
      image = load_image (aot_module, D.28413, 1);
      if (image == 0B) goto cleanup; else goto <D.28414>;
      <D.28414>:
      p.139 = p;
      D.28415 = decode_value (p.139, &p);
      D.28416 = D.28415 + 1879048192;
      D.28417 = (unsigned int) D.28416;
      D.28418 = mono_jump_info_token_new (mp, image, D.28417);
      ji->data.token = D.28418;
      goto <D.24371>;
      <D.24395>:
      <D.24396>:
      <D.24397>:
      <D.24398>:
      p.139 = p;
      D.28419 = decode_value (p.139, &p);
      image = load_image (aot_module, D.28419, 1);
      if (image == 0B) goto cleanup; else goto <D.28420>;
      <D.28420>:
      p.139 = p;
      D.28421 = decode_value (p.139, &p);
      D.28422 = (unsigned int) D.28421;
      D.28423 = mono_jump_info_token_new (mp, image, D.28422);
      ji->data.token = D.28423;
      D.28424 = ji->data.token;
      p.139 = p;
      D.28425 = decode_value (p.139, &p);
      D.28424->has_context = D.28425;
      D.28424 = ji->data.token;
      D.28426 = D.28424->has_context;
      if (D.28426 != 0) goto <D.28427>; else goto <D.28428>;
      <D.28427>:
      {
        gboolean res;

        D.28424 = ji->data.token;
        D.28429 = &D.28424->context;
        p.139 = p;
        res = decode_generic_context (aot_module, D.28429, p.139, &p);
        if (res == 0) goto cleanup; else goto <D.28430>;
        <D.28430>:
      }
      <D.28428>:
      goto <D.24371>;
      <D.24400>:
      p.139 = p;
      D.28431 = decode_klass_ref (aot_module, p.139, &p);
      ji->data.klass = D.28431;
      D.28367 = ji->data.klass;
      if (D.28367 == 0B) goto cleanup; else goto <D.28432>;
      <D.28432>:
      D.28367 = ji->data.klass;
      D.28433 = D.28367->name;
      ji->data.name = D.28433;
      goto <D.24371>;
      <D.24401>:
      p.139 = p;
      D.28434 = decode_value (p.139, &p);
      D.28435 = (long int) D.28434;
      ji->data.offset = D.28435;
      goto <D.24371>;
      <D.24402>:
      <D.24403>:
      <D.24404>:
      <D.24405>:
      <D.24406>:
      <D.24407>:
      <D.24408>:
      goto <D.24371>;
      <D.24409>:
      {
        gboolean res;
        struct MonoJumpInfoRgctxEntry * entry;
        guint32 offset;
        guint32 val;
        guint8 * p2;

        try
          {
            p.139 = p;
            D.28436 = decode_value (p.139, &p);
            offset = (guint32) D.28436;
            p.139 = p;
            D.28437 = decode_value (p.139, &p);
            val = (guint32) D.28437;
            entry = mono_mempool_alloc0 (mp, 32);
            D.28438 = aot_module->blob;
            D.28439 = (sizetype) offset;
            p2.146 = D.28438 + D.28439;
            p2 = p2.146;
            p2.147 = p2;
            D.28442 = decode_resolve_method_ref (aot_module, p2.147, &p2);
            entry->method = D.28442;
            D.28443 = val & 1;
            D.28444 = D.28443 != 0;
            D.28445 = (int) D.28444;
            entry->in_mrgctx = D.28445;
            D.28446 = val >> 1;
            D.28447 = D.28446 & 255;
            entry->info_type = D.28447;
            D.28448 = mono_mempool_alloc0 (mp, 40);
            entry->data = D.28448;
            D.28449 = entry->data;
            D.28450 = val >> 9;
            D.28451 = D.28450 & 255;
            D.28449->type = D.28451;
            D.28449 = entry->data;
            p.139 = p;
            res = decode_patch (aot_module, mp, D.28449, p.139, &p);
            if (res == 0) goto cleanup; else goto <D.28452>;
            <D.28452>:
            ji->data.rgctx_entry = entry;
            goto <D.24371>;
          }
        finally
          {
            p2 = {CLOBBER};
          }
      }
      <D.24415>:
      goto <D.24371>;
      <D.24416>:
      {
        struct MonoJumpInfoImtTramp * imt_tramp;

        imt_tramp = mono_mempool_alloc0 (mp, 16);
        p.139 = p;
        D.28453 = decode_resolve_method_ref (aot_module, p.139, &p);
        imt_tramp->method = D.28453;
        p.139 = p;
        D.28454 = decode_value (p.139, &p);
        imt_tramp->vt_offset = D.28454;
        ji->data.imt_tramp = imt_tramp;
        goto <D.24371>;
      }
      <D.24418>:
      p.139 = p;
      D.28455 = decode_signature (aot_module, p.139, &p);
      ji->data.target = D.28455;
      goto <D.24371>;
      <D.24419>:
      p.139 = p;
      D.28456 = decode_value (p.139, &p);
      D.28457 = (long int) D.28456;
      D.28458 = (const void *) D.28457;
      ji->data.target = D.28458;
      goto <D.24371>;
      <D.24420>:
      {
        struct MonoJumpInfoGSharedVtCall * info;

        info = monoeg_malloc0 (16);
        p.139 = p;
        D.28459 = decode_signature (aot_module, p.139, &p);
        info->sig = D.28459;
        D.28460 = info->sig;
        D.28461 = D.28460 == 0B;
        D.28462 = (long int) D.28461;
        D.28463 = __builtin_expect (D.28462, 0);
        if (D.28463 != 0) goto <D.28464>; else goto <D.28465>;
        <D.28464>:
        monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "aot-runtime.c", 3126, "info->sig");
        <D.28465>:
        p.139 = p;
        D.28466 = decode_resolve_method_ref (aot_module, p.139, &p);
        info->method = D.28466;
        D.28467 = info->method;
        D.28468 = D.28467 == 0B;
        D.28469 = (long int) D.28468;
        D.28470 = __builtin_expect (D.28469, 0);
        if (D.28470 != 0) goto <D.28471>; else goto <D.28472>;
        <D.28471>:
        monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "aot-runtime.c", 3128, "info->method");
        <D.28472>:
        ji->data.target = info;
        goto <D.24371>;
      }
      <D.24422>:
      {
        struct MonoGSharedVtMethodInfo * info;
        int i;
        int nentries;

        info = monoeg_malloc0 (16);
        p.139 = p;
        D.28473 = decode_resolve_method_ref (aot_module, p.139, &p);
        info->method = D.28473;
        D.28474 = info->method;
        D.28475 = D.28474 == 0B;
        D.28476 = (long int) D.28475;
        D.28477 = __builtin_expect (D.28476, 0);
        if (D.28477 != 0) goto <D.28478>; else goto <D.28479>;
        <D.28478>:
        monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "aot-runtime.c", 3138, "info->method");
        <D.28479>:
        p.139 = p;
        nentries = decode_value (p.139, &p);
        D.28480 = monoeg_g_ptr_array_new ();
        info->entries = D.28480;
        i = 0;
        goto <D.24433>;
        <D.24432>:
        {
          struct MonoRuntimeGenericContextInfoTemplate * template;

          template = monoeg_malloc0 (24);
          p.139 = p;
          D.28481 = decode_value (p.139, &p);
          D.28482 = (<unnamed type>) D.28481;
          template->info_type = D.28482;
          D.28483 = template->info_type;
          D.28484 = mini_rgctx_info_type_to_patch_info_type (D.28483);
          switch (D.28484) <default: <D.24431>, case 11: <D.24427>, case 13: <D.24430>>
          <D.24427>:
          {
            struct MonoClass * klass;

            p.139 = p;
            klass = decode_klass_ref (aot_module, p.139, &p);
            if (klass == 0B) goto cleanup; else goto <D.28485>;
            <D.28485>:
            D.28486 = &klass->byval_arg;
            template->data = D.28486;
            goto <D.24429>;
          }
          <D.24430>:
          p.139 = p;
          D.28487 = decode_field_info (aot_module, p.139, &p);
          template->data = D.28487;
          D.28488 = template->data;
          if (D.28488 == 0B) goto cleanup; else goto <D.28489>;
          <D.28489>:
          goto <D.24429>;
          <D.24431>:
          monoeg_assertion_message ("* Assertion: should not be reached at %s:%d\n", "aot-runtime.c", 3159);
          <D.24429>:
          D.28490 = info->entries;
          monoeg_g_ptr_array_add (D.28490, template);
        }
        i = i + 1;
        <D.24433>:
        if (i < nentries) goto <D.24432>; else goto <D.24434>;
        <D.24434>:
        ji->data.target = info;
        goto <D.24371>;
      }
      <D.24435>:
      D.28330 = ji->type;
      monoeg_g_log (0B, 16, "unhandled type %d", D.28330);
      monoeg_assertion_message ("* Assertion: should not be reached at %s:%d\n", "aot-runtime.c", 3170);
      <D.24371>:
      p.139 = p;
      *endbuf = p.139;
      D.28491 = 1;
      return D.28491;
      cleanup:
      D.28491 = 0;
      return D.28491;
    }
  finally
    {
      p = {CLOBBER};
    }
}


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

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


decode_field_info (struct MonoAotModule * module, guint8 * buf, guint8 * * endbuf)
{
  guint8 * buf.148;
  struct MonoClassField * D.28506;
  guint8 * p.149;
  int D.28508;
  int D.28509;
  struct MonoClass * klass;
  guint32 token;
  guint8 * p;

  try
    {
      buf.148 = buf;
      klass = decode_klass_ref (module, buf.148, &buf);
      buf.148 = buf;
      p = buf.148;
      if (klass == 0B) goto <D.28504>; else goto <D.28505>;
      <D.28504>:
      D.28506 = 0B;
      return D.28506;
      <D.28505>:
      p.149 = p;
      D.28508 = decode_value (p.149, &p);
      D.28509 = D.28508 + 67108864;
      token = (guint32) D.28509;
      p.149 = p;
      *endbuf = p.149;
      D.28506 = mono_class_get_field (klass, token);
      return D.28506;
    }
  finally
    {
      p = {CLOBBER};
    }
}


register_jump_target_got_slot (struct MonoDomain * domain, struct MonoMethod * method, void * * got_slot)
{
  union mono_mutex_t * D.28512;
  _Bool D.28515;
  long int D.28516;
  long int D.28517;
  struct GHashTable * D.28520;
  struct GHashTable * D.28523;
  _Bool D.28526;
  long int D.28527;
  long int D.28528;
  struct MonoJitDomainInfo * info;
  struct GSList * list;

  info = domain->runtime_info;
  {
    int ret;

    D.28512 = &domain->lock.mutex;
    ret = pthread_mutex_lock (D.28512);
    if (ret != 0) goto <D.28513>; else goto <D.28514>;
    <D.28513>:
    monoeg_g_log (0B, 16, "Bad call to mono_mutex_lock result %d", ret);
    <D.28514>:
    D.28515 = ret != 0;
    D.28516 = (long int) D.28515;
    D.28517 = __builtin_expect (D.28516, 0);
    if (D.28517 != 0) goto <D.28518>; else goto <D.28519>;
    <D.28518>:
    monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "aot-runtime.c", 3242, "ret == 0");
    <D.28519>:
  }
  D.28520 = info->jump_target_got_slot_hash;
  if (D.28520 == 0B) goto <D.28521>; else goto <D.28522>;
  <D.28521>:
  D.28523 = monoeg_g_hash_table_new (0B, 0B);
  info->jump_target_got_slot_hash = D.28523;
  <D.28522>:
  D.28520 = info->jump_target_got_slot_hash;
  list = monoeg_g_hash_table_lookup (D.28520, method);
  list = monoeg_g_slist_prepend (list, got_slot);
  D.28520 = info->jump_target_got_slot_hash;
  monoeg_g_hash_table_insert_replace (D.28520, method, list, 0);
  {
    int ret;

    D.28512 = &domain->lock.mutex;
    ret = pthread_mutex_unlock (D.28512);
    if (ret != 0) goto <D.28524>; else goto <D.28525>;
    <D.28524>:
    monoeg_g_log (0B, 16, "Bad call to mono_mutex_unlock result %d", ret);
    <D.28525>:
    D.28526 = ret != 0;
    D.28527 = (long int) D.28526;
    D.28528 = __builtin_expect (D.28527, 0);
    if (D.28528 != 0) goto <D.28529>; else goto <D.28530>;
    <D.28529>:
    monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "aot-runtime.c", 3248, "ret == 0");
    <D.28530>:
  }
}


InterlockedIncrement (volatile gint32 * val)
{
  gint32 D.28531;
  unsigned int D.28532;

  D.28532 = __sync_add_and_fetch_4 (val, 1);
  D.28531 = (gint32) D.28532;
  return D.28531;
}


init_plt (struct MonoAotModule * amodule)
{
  int D.28534;
  struct MonoDomain * D.28537;
  struct MonoDomain * D.28538;
  void * * D.28539;
  unsigned int D.28540;
  unsigned int i.150;
  unsigned int D.28542;
  long unsigned int D.28543;
  long unsigned int D.28544;
  void * * D.28545;
  unsigned int D.28546;
  int i;
  void * tramp;

  D.28534 = amodule->plt_inited;
  if (D.28534 != 0) goto <D.28535>; else goto <D.28536>;
  <D.28535>:
  return;
  <D.28536>:
  D.28537 = mono_get_root_domain ();
  tramp = mono_create_specific_trampoline (amodule, 6, D.28537, 0B);
  D.28538 = mono_domain_get ();
  tramp = mono_create_ftnptr (D.28538, tramp);
  i = 1;
  goto <D.24747>;
  <D.24746>:
  D.28539 = amodule->got;
  D.28540 = amodule->info.plt_got_offset_base;
  i.150 = (unsigned int) i;
  D.28542 = D.28540 + i.150;
  D.28543 = (long unsigned int) D.28542;
  D.28544 = D.28543 * 8;
  D.28545 = D.28539 + D.28544;
  *D.28545 = tramp;
  i = i + 1;
  <D.24747>:
  i.150 = (unsigned int) i;
  D.28546 = amodule->info.plt_size;
  if (i.150 < D.28546) goto <D.24746>; else goto <D.24748>;
  <D.24748>:
  amodule->plt_inited = 1;
}


mono_aot_get_method_from_token (struct MonoDomain * domain, struct MonoImage * image, guint32 token)
{
  void * D.28550;
  unsigned int D.28551;
  unsigned int D.28552;
  struct MonoAotModule * aot_module;
  int method_index;

  aot_module = image->aot_module;
  if (aot_module == 0B) goto <D.28548>; else goto <D.28549>;
  <D.28548>:
  D.28550 = 0B;
  return D.28550;
  <D.28549>:
  D.28551 = token & 16777215;
  D.28552 = D.28551 + 4294967295;
  method_index = (int) D.28552;
  D.28550 = load_method (domain, aot_module, image, 0B, token, method_index);
  return D.28550;
}


mono_aot_is_got_entry (guint8 * code, guint8 * addr)
{
  struct GHashTable * aot_modules.151;
  gboolean D.28557;
  _Bool D.28560;
  long int D.28561;
  long int D.28562;
  _Bool D.28567;
  long int D.28568;
  long int D.28569;
  struct IsGotEntryUserData user_data;

  try
    {
      aot_modules.151 = aot_modules;
      if (aot_modules.151 == 0B) goto <D.28555>; else goto <D.28556>;
      <D.28555>:
      D.28557 = 0;
      return D.28557;
      <D.28556>:
      user_data.addr = addr;
      user_data.res = 0;
      {
        int ret;

        ret = pthread_mutex_lock (&aot_mutex.mutex);
        if (ret != 0) goto <D.28558>; else goto <D.28559>;
        <D.28558>:
        monoeg_g_log (0B, 16, "Bad call to mono_mutex_lock result %d", ret);
        <D.28559>:
        D.28560 = ret != 0;
        D.28561 = (long int) D.28560;
        D.28562 = __builtin_expect (D.28561, 0);
        if (D.28562 != 0) goto <D.28563>; else goto <D.28564>;
        <D.28563>:
        monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "aot-runtime.c", 3812, "ret == 0");
        <D.28564>:
      }
      aot_modules.151 = aot_modules;
      monoeg_g_hash_table_foreach (aot_modules.151, check_is_got_entry, &user_data);
      {
        int ret;

        ret = pthread_mutex_unlock (&aot_mutex.mutex);
        if (ret != 0) goto <D.28565>; else goto <D.28566>;
        <D.28565>:
        monoeg_g_log (0B, 16, "Bad call to mono_mutex_unlock result %d", ret);
        <D.28566>:
        D.28567 = ret != 0;
        D.28568 = (long int) D.28567;
        D.28569 = __builtin_expect (D.28568, 0);
        if (D.28569 != 0) goto <D.28570>; else goto <D.28571>;
        <D.28570>:
        monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "aot-runtime.c", 3814, "ret == 0");
        <D.28571>:
      }
      D.28557 = user_data.res;
      return D.28557;
    }
  finally
    {
      user_data = {CLOBBER};
    }
}


check_is_got_entry (void * key, void * value, void * user_data)
{
  void * * D.28574;
  guint8 * D.28577;
  unsigned int D.28580;
  long unsigned int D.28581;
  long unsigned int D.28582;
  guint8 * D.28583;
  struct IsGotEntryUserData * data;
  struct MonoAotModule * aot_module;

  data = user_data;
  aot_module = value;
  D.28574 = aot_module->got;
  if (D.28574 != 0B) goto <D.28575>; else goto <D.28576>;
  <D.28575>:
  D.28577 = data->addr;
  D.28574 = aot_module->got;
  if (D.28577 >= D.28574) goto <D.28578>; else goto <D.28579>;
  <D.28578>:
  D.28577 = data->addr;
  D.28574 = aot_module->got;
  D.28580 = aot_module->info.got_size;
  D.28581 = (long unsigned int) D.28580;
  D.28582 = D.28581 * 8;
  D.28583 = D.28574 + D.28582;
  if (D.28577 < D.28583) goto <D.28584>; else goto <D.28585>;
  <D.28584>:
  data->res = 1;
  <D.28585>:
  <D.28579>:
  <D.28576>:
}


mono_aot_patch_plt_entry (guint8 * code, void * * got, mgreg_t * regs, guint8 * addr)
{
  struct MonoDomain * D.28586;
  struct MonoDomain * D.28587;

  D.28586 = mono_domain_get ();
  D.28587 = mono_get_root_domain ();
  if (D.28586 == D.28587) goto <D.28588>; else goto <D.28589>;
  <D.28588>:
  mono_arch_patch_plt_entry (code, got, regs, addr);
  <D.28589>:
}


mono_aot_plt_resolve (void * aot_module, guint32 plt_info_offset, guint8 * code)
{
  guint8 * D.28590;
  sizetype D.28591;
  guint8 * p.152;
  guint8 * p.153;
  int D.28594;
  <unnamed type> D.28595;
  void * D.28598;
  int mono_aot_only.154;
  <unnamed type> D.28603;
  struct MonoMethod * D.28605;
  long unsigned int D.28606;
  long unsigned int D.28607;
  int D.28609;
  short unsigned int D.28611;
  int D.28612;
  int D.28613;
  int D.28615;
  struct MonoDomain * D.28618;
  void * * D.28633;
  void * D.28634;
  _Bool D.28635;
  long int D.28636;
  long int D.28637;
  _Bool D.28642;
  long int D.28643;
  long int D.28644;
  struct MonoDomain * D.28647;
  _Bool D.28648;
  long int D.28649;
  long int D.28650;
  void * * D.28653;
  guint8 * p;
  guint8 * target;
  guint8 * plt_entry;
  struct MonoJumpInfo ji;
  struct MonoAotModule * module;
  gboolean res;
  gboolean no_ftnptr;
  struct MonoMemPool * mp;
  gboolean using_gsharedvt;

  try
    {
      module = aot_module;
      no_ftnptr = 0;
      using_gsharedvt = 0;
      D.28590 = module->blob;
      D.28591 = (sizetype) plt_info_offset;
      p.152 = D.28590 + D.28591;
      p = p.152;
      p.153 = p;
      D.28594 = decode_value (p.153, &p);
      D.28595 = (<unnamed type>) D.28594;
      ji.type = D.28595;
      mp = mono_mempool_new_size (512);
      p.153 = p;
      res = decode_patch (module, mp, &ji, p.153, &p);
      if (res == 0) goto <D.28596>; else goto <D.28597>;
      <D.28596>:
      mono_mempool_destroy (mp);
      D.28598 = 0B;
      return D.28598;
      <D.28597>:
      mono_aot_only.154 = mono_aot_only;
      if (mono_aot_only.154 != 0) goto <D.28602>; else goto <D.28599>;
      <D.28602>:
      D.28603 = ji.type;
      if (D.28603 == 3) goto <D.28604>; else goto <D.28599>;
      <D.28604>:
      D.28605 = ji.data.method;
      D.28606 = BIT_FIELD_REF <*D.28605, 64, 256>;
      D.28607 = D.28606 & 2048;
      if (D.28607 == 0) goto <D.28608>; else goto <D.28599>;
      <D.28608>:
      D.28605 = ji.data.method;
      D.28609 = mono_method_check_context_used (D.28605);
      if (D.28609 == 0) goto <D.28610>; else goto <D.28599>;
      <D.28610>:
      D.28605 = ji.data.method;
      D.28611 = D.28605->iflags;
      D.28612 = (int) D.28611;
      D.28613 = D.28612 & 32;
      if (D.28613 == 0) goto <D.28614>; else goto <D.28599>;
      <D.28614>:
      D.28605 = ji.data.method;
      D.28615 = mono_method_needs_static_rgctx_invoke (D.28605, 0);
      if (D.28615 == 0) goto <D.28616>; else goto <D.28599>;
      <D.28616>:
      if (using_gsharedvt == 0) goto <D.28617>; else goto <D.28599>;
      <D.28617>:
      D.28605 = ji.data.method;
      target = mono_jit_compile_method (D.28605);
      no_ftnptr = 1;
      goto <D.28600>;
      <D.28599>:
      D.28618 = mono_domain_get ();
      target = mono_resolve_patch_target (0B, D.28618, 0B, &ji, 1);
      <D.28600>:
      D.28603 = ji.type;
      if (D.28603 == 1) goto <D.28619>; else goto <D.28622>;
      <D.28622>:
      D.28603 = ji.type;
      if (D.28603 == 7) goto <D.28619>; else goto <D.28623>;
      <D.28623>:
      D.28603 = ji.type;
      if (D.28603 == 15) goto <D.28619>; else goto <D.28624>;
      <D.28624>:
      D.28603 = ji.type;
      if (D.28603 == 31) goto <D.28619>; else goto <D.28625>;
      <D.28625>:
      D.28603 = ji.type;
      if (D.28603 == 32) goto <D.28619>; else goto <D.28626>;
      <D.28626>:
      D.28603 = ji.type;
      if (D.28603 == 35) goto <D.28619>; else goto <D.28620>;
      <D.28619>:
      D.28603 = ji.type;
      if (D.28603 != 7) goto <D.28627>; else goto <D.28628>;
      <D.28627>:
      D.28603 = ji.type;
      if (D.28603 != 32) goto <D.28629>; else goto <D.28630>;
      <D.28629>:
      D.28603 = ji.type;
      if (D.28603 != 31) goto <D.28631>; else goto <D.28632>;
      <D.28631>:
      D.28633 = target + 16;
      D.28634 = *D.28633;
      D.28635 = D.28634 != 0B;
      D.28636 = (long int) D.28635;
      D.28637 = __builtin_expect (D.28636, 0);
      if (D.28637 != 0) goto <D.28638>; else goto <D.28639>;
      <D.28638>:
      monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "aot-runtime.c", 3930, "((gpointer*)target) [2] == 0");
      <D.28639>:
      <D.28632>:
      <D.28630>:
      <D.28628>:
      goto <D.28621>;
      <D.28620>:
      if (no_ftnptr == 0) goto <D.28640>; else goto <D.28641>;
      <D.28640>:
      D.28633 = target + 16;
      D.28634 = *D.28633;
      D.28642 = D.28634 == 0B;
      D.28643 = (long int) D.28642;
      D.28644 = __builtin_expect (D.28643, 0);
      if (D.28644 != 0) goto <D.28645>; else goto <D.28646>;
      <D.28645>:
      monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "aot-runtime.c", 3935, "((gpointer*)target) [2] != 0");
      <D.28646>:
      D.28647 = mono_domain_get ();
      target = mono_create_ftnptr (D.28647, target);
      <D.28641>:
      <D.28621>:
      mono_mempool_destroy (mp);
      plt_entry = mono_aot_get_plt_entry (code);
      D.28648 = plt_entry == 0B;
      D.28649 = (long int) D.28648;
      D.28650 = __builtin_expect (D.28649, 0);
      if (D.28650 != 0) goto <D.28651>; else goto <D.28652>;
      <D.28651>:
      monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "aot-runtime.c", 3944, "plt_entry");
      <D.28652>:
      D.28653 = module->got;
      mono_aot_patch_plt_entry (plt_entry, D.28653, 0B, target);
      D.28598 = target;
      return D.28598;
    }
  finally
    {
      p = {CLOBBER};
      ji = {CLOBBER};
    }
}


mono_aot_get_plt_entry (guint8 * code)
{
  guint8 * D.28658;
  guint8 * D.28660;
  guint8 * D.28662;
  struct MonoAotModule * amodule;
  guint8 * target;

  amodule = find_aot_module (code);
  target = 0B;
  if (amodule == 0B) goto <D.28656>; else goto <D.28657>;
  <D.28656>:
  D.28658 = 0B;
  return D.28658;
  <D.28657>:
  target = mono_arch_get_call_target (code);
  D.28660 = amodule->plt;
  if (D.28660 <= target) goto <D.28661>; else goto <D.28659>;
  <D.28661>:
  D.28662 = amodule->plt_end;
  if (D.28662 > target) goto <D.28663>; else goto <D.28659>;
  <D.28663>:
  D.28658 = target;
  return D.28658;
  <D.28659>:
  D.28658 = 0B;
  return D.28658;
}


find_aot_module (guint8 * code)
{
  struct GHashTable * aot_modules.155;
  struct MonoAotModule * D.28668;
  long unsigned int code.156;
  long unsigned int aot_code_low_addr.157;
  long unsigned int aot_code_high_addr.158;
  _Bool D.28677;
  long int D.28678;
  long int D.28679;
  _Bool D.28684;
  long int D.28685;
  long int D.28686;
  struct FindAotModuleUserData user_data;

  try
    {
      aot_modules.155 = aot_modules;
      if (aot_modules.155 == 0B) goto <D.28666>; else goto <D.28667>;
      <D.28666>:
      D.28668 = 0B;
      return D.28668;
      <D.28667>:
      code.156 = (long unsigned int) code;
      aot_code_low_addr.157 = aot_code_low_addr;
      if (code.156 < aot_code_low_addr.157) goto <D.28669>; else goto <D.28673>;
      <D.28673>:
      code.156 = (long unsigned int) code;
      aot_code_high_addr.158 = aot_code_high_addr;
      if (code.156 > aot_code_high_addr.158) goto <D.28669>; else goto <D.28670>;
      <D.28669>:
      D.28668 = 0B;
      return D.28668;
      <D.28670>:
      user_data.addr = code;
      user_data.module = 0B;
      {
        int ret;

        ret = pthread_mutex_lock (&aot_mutex.mutex);
        if (ret != 0) goto <D.28675>; else goto <D.28676>;
        <D.28675>:
        monoeg_g_log (0B, 16, "Bad call to mono_mutex_lock result %d", ret);
        <D.28676>:
        D.28677 = ret != 0;
        D.28678 = (long int) D.28677;
        D.28679 = __builtin_expect (D.28678, 0);
        if (D.28679 != 0) goto <D.28680>; else goto <D.28681>;
        <D.28680>:
        monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "aot-runtime.c", 3849, "ret == 0");
        <D.28681>:
      }
      aot_modules.155 = aot_modules;
      monoeg_g_hash_table_foreach (aot_modules.155, find_aot_module_cb, &user_data);
      {
        int ret;

        ret = pthread_mutex_unlock (&aot_mutex.mutex);
        if (ret != 0) goto <D.28682>; else goto <D.28683>;
        <D.28682>:
        monoeg_g_log (0B, 16, "Bad call to mono_mutex_unlock result %d", ret);
        <D.28683>:
        D.28684 = ret != 0;
        D.28685 = (long int) D.28684;
        D.28686 = __builtin_expect (D.28685, 0);
        if (D.28686 != 0) goto <D.28687>; else goto <D.28688>;
        <D.28687>:
        monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "aot-runtime.c", 3851, "ret == 0");
        <D.28688>:
      }
      D.28668 = user_data.module;
      return D.28668;
    }
  finally
    {
      user_data = {CLOBBER};
    }
}


find_aot_module_cb (void * key, void * value, void * user_data)
{
  guint8 * D.28691;
  guint8 * D.28692;
  guint8 * D.28695;
  struct FindAotModuleUserData * data;
  struct MonoAotModule * aot_module;

  data = user_data;
  aot_module = value;
  D.28691 = data->addr;
  D.28692 = aot_module->code;
  if (D.28691 >= D.28692) goto <D.28693>; else goto <D.28694>;
  <D.28693>:
  D.28691 = data->addr;
  D.28695 = aot_module->code_end;
  if (D.28691 < D.28695) goto <D.28696>; else goto <D.28697>;
  <D.28696>:
  data->module = aot_module;
  <D.28697>:
  <D.28694>:
}


mono_aot_get_plt_info_offset (mgreg_t * regs, guint8 * code)
{
  _Bool D.28698;
  long int D.28699;
  long int D.28700;
  guint32 D.28703;
  guint8 * plt_entry;

  plt_entry = mono_aot_get_plt_entry (code);
  D.28698 = plt_entry == 0B;
  D.28699 = (long int) D.28698;
  D.28700 = __builtin_expect (D.28699, 0);
  if (D.28700 != 0) goto <D.28701>; else goto <D.28702>;
  <D.28701>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "aot-runtime.c", 4039, "plt_entry");
  <D.28702>:
  D.28703 = mono_arch_get_plt_info_offset (plt_entry, regs, code);
  return D.28703;
}


mono_aot_register_jit_icall (const char * name, void * addr)
{
  struct GHashTable * aot_jit_icall_hash.159;
  struct GHashTable * aot_jit_icall_hash.160;

  aot_jit_icall_hash.159 = aot_jit_icall_hash;
  if (aot_jit_icall_hash.159 == 0B) goto <D.28706>; else goto <D.28707>;
  <D.28706>:
  aot_jit_icall_hash.160 = monoeg_g_hash_table_new (monoeg_g_str_hash, monoeg_g_str_equal);
  aot_jit_icall_hash = aot_jit_icall_hash.160;
  <D.28707>:
  aot_jit_icall_hash.159 = aot_jit_icall_hash;
  monoeg_g_hash_table_insert_replace (aot_jit_icall_hash.159, name, addr, 0);
}


mono_aot_get_trampoline_full (const char * name, struct MonoTrampInfo * * out_tinfo)
{
  _Bool D.28709;
  long int D.28710;
  long int D.28711;
  _Bool D.28714;
  long int D.28715;
  long int D.28716;
  void * D.28719;
  void * D.28720;
  struct MonoImage * image;
  struct MonoAotModule * amodule;

  image = mono_defaults.corlib;
  D.28709 = image == 0B;
  D.28710 = (long int) D.28709;
  D.28711 = __builtin_expect (D.28710, 0);
  if (D.28711 != 0) goto <D.28712>; else goto <D.28713>;
  <D.28712>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "aot-runtime.c", 4242, "image");
  <D.28713>:
  amodule = image->aot_module;
  D.28714 = amodule == 0B;
  D.28715 = (long int) D.28714;
  D.28716 = __builtin_expect (D.28715, 0);
  if (D.28716 != 0) goto <D.28717>; else goto <D.28718>;
  <D.28717>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "aot-runtime.c", 4245, "amodule");
  <D.28718>:
  D.28720 = load_function_full (amodule, name, out_tinfo);
  D.28719 = mono_create_ftnptr_malloc (D.28720);
  return D.28719;
}


load_function_full (struct MonoAotModule * amodule, const char * name, struct MonoTrampInfo * * out_tinfo)
{
  struct MonoDl * D.28722;
  void * * D.28723;
  void * code.161;
  char * D.28727;
  guint8 * p.162;
  void * D.28731;
  guint8 * p.163;
  guint8 * D.28735;
  sizetype D.28736;
  guint8 * uw_info.164;
  guint8 * uw_info.165;
  int D.28739;
  guint8 * D.28740;
  sizetype D.28741;
  guint8 * p.166;
  _Bool D.28745;
  long int D.28746;
  long int D.28747;
  long unsigned int D.28750;
  long unsigned int D.28751;
  void * * D.28752;
  guint32 * got_slots.167;
  long unsigned int D.28754;
  guint32 * D.28755;
  unsigned int D.28756;
  long unsigned int D.28757;
  long unsigned int D.28758;
  void * * D.28759;
  void * D.28760;
  <unnamed type> D.28763;
  int D.24798;
  int iftmp.168;
  int D.24797;
  const char[18] * D.28769;
  unsigned char D.28770;
  int D.28771;
  unsigned char D.28772;
  int D.28773;
  const unsigned char * D.28778;
  unsigned char D.28779;
  int D.28780;
  const unsigned char * D.28781;
  unsigned char D.28782;
  int D.28783;
  const unsigned char * D.28788;
  unsigned char D.28789;
  int D.28790;
  const unsigned char * D.28791;
  unsigned char D.28792;
  int D.28793;
  const unsigned char * D.28798;
  unsigned char D.28799;
  int D.28800;
  const unsigned char * D.28801;
  unsigned char D.28802;
  int D.28803;
  const char * D.28805;
  int D.24807;
  int iftmp.169;
  int D.24806;
  const char[42] * D.28812;
  unsigned char D.28813;
  int D.28814;
  unsigned char D.28815;
  int D.28816;
  const unsigned char * D.28821;
  unsigned char D.28822;
  int D.28823;
  const unsigned char * D.28824;
  unsigned char D.28825;
  int D.28826;
  const unsigned char * D.28831;
  unsigned char D.28832;
  int D.28833;
  const unsigned char * D.28834;
  unsigned char D.28835;
  int D.28836;
  const unsigned char * D.28841;
  unsigned char D.28842;
  int D.28843;
  const unsigned char * D.28844;
  unsigned char D.28845;
  int D.28846;
  int D.24816;
  int iftmp.170;
  int D.24815;
  const char[26] * D.28854;
  unsigned char D.28855;
  int D.28856;
  unsigned char D.28857;
  int D.28858;
  const unsigned char * D.28863;
  unsigned char D.28864;
  int D.28865;
  const unsigned char * D.28866;
  unsigned char D.28867;
  int D.28868;
  const unsigned char * D.28873;
  unsigned char D.28874;
  int D.28875;
  const unsigned char * D.28876;
  unsigned char D.28877;
  int D.28878;
  const unsigned char * D.28883;
  unsigned char D.28884;
  int D.28885;
  const unsigned char * D.28886;
  unsigned char D.28887;
  int D.28888;
  int D.24825;
  int iftmp.171;
  int D.24824;
  const char[21] * D.28896;
  unsigned char D.28897;
  int D.28898;
  unsigned char D.28899;
  int D.28900;
  const unsigned char * D.28905;
  unsigned char D.28906;
  int D.28907;
  const unsigned char * D.28908;
  unsigned char D.28909;
  int D.28910;
  const unsigned char * D.28915;
  unsigned char D.28916;
  int D.28917;
  const unsigned char * D.28918;
  unsigned char D.28919;
  int D.28920;
  const unsigned char * D.28925;
  unsigned char D.28926;
  int D.28927;
  const unsigned char * D.28928;
  unsigned char D.28929;
  int D.28930;
  char * D.28935;
  const char * D.28938;
  <unnamed type> tramp_type2.172;
  char * D.28941;
  _Bool D.28944;
  long int D.28945;
  long int D.28946;
  unsigned int slot.173;
  long unsigned int D.28950;
  void * D.28951;
  struct MonoDomain * D.28952;
  int D.24837;
  int iftmp.174;
  int D.24836;
  const char[34] * D.28957;
  unsigned char D.28958;
  int D.28959;
  unsigned char D.28960;
  int D.28961;
  const unsigned char * D.28966;
  unsigned char D.28967;
  int D.28968;
  const unsigned char * D.28969;
  unsigned char D.28970;
  int D.28971;
  const unsigned char * D.28976;
  unsigned char D.28977;
  int D.28978;
  const unsigned char * D.28979;
  unsigned char D.28980;
  int D.28981;
  const unsigned char * D.28986;
  unsigned char D.28987;
  int D.28988;
  const unsigned char * D.28989;
  unsigned char D.28990;
  int D.28991;
  struct MonoDomain * D.28995;
  int D.24846;
  int iftmp.175;
  int D.24845;
  const char[33] * D.29000;
  unsigned char D.29001;
  int D.29002;
  unsigned char D.29003;
  int D.29004;
  const unsigned char * D.29009;
  unsigned char D.29010;
  int D.29011;
  const unsigned char * D.29012;
  unsigned char D.29013;
  int D.29014;
  const unsigned char * D.29019;
  unsigned char D.29020;
  int D.29021;
  const unsigned char * D.29022;
  unsigned char D.29023;
  int D.29024;
  const unsigned char * D.29029;
  unsigned char D.29030;
  int D.29031;
  const unsigned char * D.29032;
  unsigned char D.29033;
  int D.29034;
  struct MonoDomain * D.29038;
  int D.24855;
  int iftmp.176;
  int D.24854;
  const char[39] * D.29043;
  unsigned char D.29044;
  int D.29045;
  unsigned char D.29046;
  int D.29047;
  const unsigned char * D.29052;
  unsigned char D.29053;
  int D.29054;
  const unsigned char * D.29055;
  unsigned char D.29056;
  int D.29057;
  const unsigned char * D.29062;
  unsigned char D.29063;
  int D.29064;
  const unsigned char * D.29065;
  unsigned char D.29066;
  int D.29067;
  const unsigned char * D.29072;
  unsigned char D.29073;
  int D.29074;
  const unsigned char * D.29075;
  unsigned char D.29076;
  int D.29077;
  struct MonoDomain * D.29081;
  int D.24864;
  int iftmp.177;
  int D.24863;
  const char[44] * D.29086;
  unsigned char D.29087;
  int D.29088;
  unsigned char D.29089;
  int D.29090;
  const unsigned char * D.29095;
  unsigned char D.29096;
  int D.29097;
  const unsigned char * D.29098;
  unsigned char D.29099;
  int D.29100;
  const unsigned char * D.29105;
  unsigned char D.29106;
  int D.29107;
  const unsigned char * D.29108;
  unsigned char D.29109;
  int D.29110;
  const unsigned char * D.29115;
  unsigned char D.29116;
  int D.29117;
  const unsigned char * D.29118;
  unsigned char D.29119;
  int D.29120;
  char * D.29125;
  struct GHashTable * aot_jit_icall_hash.178;
  void * D.29133;
  struct _IO_FILE * stderr.179;
  _Bool D.29137;
  long int D.29138;
  long int D.29139;
  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.28722 = amodule->sofile;
      D.28723 = amodule->globals;
      find_symbol (D.28722, D.28723, symbol, &code);
      monoeg_g_free (symbol);
      code.161 = code;
      if (code.161 == 0B) goto <D.28725>; else goto <D.28726>;
      <D.28725>:
      D.28727 = amodule->aot_name;
      monoeg_g_log (0B, 4, "Symbol \'%s\' not found in AOT file \'%s\'.\n", name, D.28727);
      <D.24779>:
      goto <D.24779>;
      <D.28726>:
      D.28727 = amodule->aot_name;
      mono_trace (128, 32, "AOT FOUND function \'%s\' in AOT file \'%s\'.", name, D.28727);
      symbol = monoeg_g_strdup_printf ("%s_p", name);
      D.28722 = amodule->sofile;
      D.28723 = amodule->globals;
      find_symbol (D.28722, D.28723, symbol, &p);
      monoeg_g_free (symbol);
      p.162 = p;
      if (p.162 == 0B) goto <D.28729>; else goto <D.28730>;
      <D.28729>:
      D.28731 = code;
      return D.28731;
      <D.28730>:
      p.162 = p;
      info_offset = MEM[(guint32 *)p.162];
      if (out_tinfo != 0B) goto <D.28732>; else goto <D.28733>;
      <D.28732>:
      {
        struct MonoTrampInfo * tinfo;
        guint32 code_size;
        guint32 uw_info_len;
        guint32 uw_offset;
        guint8 * uw_info;

        try
          {
            p.162 = p;
            p.163 = p.162 + 4;
            p = p.163;
            p.162 = p;
            code_size = MEM[(guint32 *)p.162];
            p.162 = p;
            p.163 = p.162 + 4;
            p = p.163;
            p.162 = p;
            uw_offset = MEM[(guint32 *)p.162];
            D.28735 = amodule->unwind_info;
            D.28736 = (sizetype) uw_offset;
            uw_info.164 = D.28735 + D.28736;
            uw_info = uw_info.164;
            uw_info.165 = uw_info;
            D.28739 = decode_value (uw_info.165, &uw_info);
            uw_info_len = (guint32) D.28739;
            tinfo = monoeg_malloc0 (56);
            code.161 = code;
            tinfo->code = code.161;
            tinfo->code_size = code_size;
            uw_info.165 = uw_info;
            tinfo->uw_info = uw_info.165;
            tinfo->uw_info_len = uw_info_len;
            *out_tinfo = tinfo;
          }
        finally
          {
            uw_info = {CLOBBER};
          }
      }
      <D.28733>:
      D.28740 = amodule->blob;
      D.28741 = (sizetype) info_offset;
      p.166 = D.28740 + D.28741;
      p = p.166;
      p.162 = p;
      n_patches = decode_value (p.162, &p);
      if (n_patches != 0) goto <D.28743>; else goto <D.28744>;
      <D.28743>:
      {
        struct MonoJumpInfo * patches;
        guint32 * got_slots;

        try
          {
            mp = mono_mempool_new ();
            p.162 = p;
            patches = load_patch_info (amodule, mp, n_patches, &got_slots, p.162, &p);
            D.28745 = patches == 0B;
            D.28746 = (long int) D.28745;
            D.28747 = __builtin_expect (D.28746, 0);
            if (D.28747 != 0) goto <D.28748>; else goto <D.28749>;
            <D.28748>:
            monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "aot-runtime.c", 4151, "patches");
            <D.28749>:
            pindex = 0;
            goto <D.24866>;
            <D.24865>:
            {
              struct MonoJumpInfo * ji;
              void * target;

              D.28750 = (long unsigned int) pindex;
              D.28751 = D.28750 * 40;
              ji = patches + D.28751;
              D.28752 = amodule->got;
              got_slots.167 = got_slots;
              D.28750 = (long unsigned int) pindex;
              D.28754 = D.28750 * 4;
              D.28755 = got_slots.167 + D.28754;
              D.28756 = *D.28755;
              D.28757 = (long unsigned int) D.28756;
              D.28758 = D.28757 * 8;
              D.28759 = D.28752 + D.28758;
              D.28760 = *D.28759;
              if (D.28760 != 0B) goto <D.28761>; else goto <D.28762>;
              <D.28761>:
              // predicted unlikely by continue predictor.
              goto <D.24789>;
              <D.28762>:
              D.28763 = ji->type;
              if (D.28763 == 32) goto <D.28764>; else goto <D.28765>;
              <D.28764>:
              {
                size_t __s1_len;
                size_t __s2_len;

                __s2_len = 17;
                if (__s2_len <= 3) goto <D.28767>; else goto <D.28768>;
                <D.28767>:
                {
                  const unsigned char * __s2;
                  int __result;

                  __s2 = ji->data.name;
                  D.28769 = "mono_get_lmf_addr";
                  D.28770 = MEM[(const unsigned char *)D.28769];
                  D.28771 = (int) D.28770;
                  D.28772 = *__s2;
                  D.28773 = (int) D.28772;
                  __result = D.28771 - D.28773;
                  {
                    if (__s2_len != 0) goto <D.28774>; else goto <D.28775>;
                    <D.28774>:
                    if (__result == 0) goto <D.28776>; else goto <D.28777>;
                    <D.28776>:
                    D.28778 = &MEM[(void *)"mono_get_lmf_addr" + 1B];
                    D.28779 = *D.28778;
                    D.28780 = (int) D.28779;
                    D.28781 = __s2 + 1;
                    D.28782 = *D.28781;
                    D.28783 = (int) D.28782;
                    __result = D.28780 - D.28783;
                    if (__s2_len > 1) goto <D.28784>; else goto <D.28785>;
                    <D.28784>:
                    if (__result == 0) goto <D.28786>; else goto <D.28787>;
                    <D.28786>:
                    D.28788 = &MEM[(void *)"mono_get_lmf_addr" + 2B];
                    D.28789 = *D.28788;
                    D.28790 = (int) D.28789;
                    D.28791 = __s2 + 2;
                    D.28792 = *D.28791;
                    D.28793 = (int) D.28792;
                    __result = D.28790 - D.28793;
                    if (__s2_len > 2) goto <D.28794>; else goto <D.28795>;
                    <D.28794>:
                    if (__result == 0) goto <D.28796>; else goto <D.28797>;
                    <D.28796>:
                    D.28798 = &MEM[(void *)"mono_get_lmf_addr" + 3B];
                    D.28799 = *D.28798;
                    D.28800 = (int) D.28799;
                    D.28801 = __s2 + 3;
                    D.28802 = *D.28801;
                    D.28803 = (int) D.28802;
                    __result = D.28800 - D.28803;
                    <D.28797>:
                    <D.28795>:
                    <D.28787>:
                    <D.28785>:
                    <D.28777>:
                    <D.28775>:
                  }
                  D.24797 = __result;
                }
                iftmp.168 = -D.24797;
                goto <D.28804>;
                <D.28768>:
                D.28805 = ji->data.name;
                iftmp.168 = __builtin_strcmp (D.28805, "mono_get_lmf_addr");
                <D.28804>:
                D.24798 = iftmp.168;
              }
              if (D.24798 == 0) goto <D.28806>; else goto <D.28807>;
              <D.28806>:
              target = mono_get_lmf_addr;
              goto <D.28808>;
              <D.28807>:
              {
                size_t __s1_len;
                size_t __s2_len;

                __s2_len = 41;
                if (__s2_len <= 3) goto <D.28810>; else goto <D.28811>;
                <D.28810>:
                {
                  const unsigned char * __s2;
                  int __result;

                  __s2 = ji->data.name;
                  D.28812 = "mono_thread_force_interruption_checkpoint";
                  D.28813 = MEM[(const unsigned char *)D.28812];
                  D.28814 = (int) D.28813;
                  D.28815 = *__s2;
                  D.28816 = (int) D.28815;
                  __result = D.28814 - D.28816;
                  {
                    if (__s2_len != 0) goto <D.28817>; else goto <D.28818>;
                    <D.28817>:
                    if (__result == 0) goto <D.28819>; else goto <D.28820>;
                    <D.28819>:
                    D.28821 = &MEM[(void *)"mono_thread_force_interruption_checkpoint" + 1B];
                    D.28822 = *D.28821;
                    D.28823 = (int) D.28822;
                    D.28824 = __s2 + 1;
                    D.28825 = *D.28824;
                    D.28826 = (int) D.28825;
                    __result = D.28823 - D.28826;
                    if (__s2_len > 1) goto <D.28827>; else goto <D.28828>;
                    <D.28827>:
                    if (__result == 0) goto <D.28829>; else goto <D.28830>;
                    <D.28829>:
                    D.28831 = &MEM[(void *)"mono_thread_force_interruption_checkpoint" + 2B];
                    D.28832 = *D.28831;
                    D.28833 = (int) D.28832;
                    D.28834 = __s2 + 2;
                    D.28835 = *D.28834;
                    D.28836 = (int) D.28835;
                    __result = D.28833 - D.28836;
                    if (__s2_len > 2) goto <D.28837>; else goto <D.28838>;
                    <D.28837>:
                    if (__result == 0) goto <D.28839>; else goto <D.28840>;
                    <D.28839>:
                    D.28841 = &MEM[(void *)"mono_thread_force_interruption_checkpoint" + 3B];
                    D.28842 = *D.28841;
                    D.28843 = (int) D.28842;
                    D.28844 = __s2 + 3;
                    D.28845 = *D.28844;
                    D.28846 = (int) D.28845;
                    __result = D.28843 - D.28846;
                    <D.28840>:
                    <D.28838>:
                    <D.28830>:
                    <D.28828>:
                    <D.28820>:
                    <D.28818>:
                  }
                  D.24806 = __result;
                }
                iftmp.169 = -D.24806;
                goto <D.28847>;
                <D.28811>:
                D.28805 = ji->data.name;
                iftmp.169 = __builtin_strcmp (D.28805, "mono_thread_force_interruption_checkpoint");
                <D.28847>:
                D.24807 = iftmp.169;
              }
              if (D.24807 == 0) goto <D.28848>; else goto <D.28849>;
              <D.28848>:
              target = mono_thread_force_interruption_checkpoint;
              goto <D.28850>;
              <D.28849>:
              {
                size_t __s1_len;
                size_t __s2_len;

                __s2_len = 25;
                if (__s2_len <= 3) goto <D.28852>; else goto <D.28853>;
                <D.28852>:
                {
                  const unsigned char * __s2;
                  int __result;

                  __s2 = ji->data.name;
                  D.28854 = "mono_exception_from_token";
                  D.28855 = MEM[(const unsigned char *)D.28854];
                  D.28856 = (int) D.28855;
                  D.28857 = *__s2;
                  D.28858 = (int) D.28857;
                  __result = D.28856 - D.28858;
                  {
                    if (__s2_len != 0) goto <D.28859>; else goto <D.28860>;
                    <D.28859>:
                    if (__result == 0) goto <D.28861>; else goto <D.28862>;
                    <D.28861>:
                    D.28863 = &MEM[(void *)"mono_exception_from_token" + 1B];
                    D.28864 = *D.28863;
                    D.28865 = (int) D.28864;
                    D.28866 = __s2 + 1;
                    D.28867 = *D.28866;
                    D.28868 = (int) D.28867;
                    __result = D.28865 - D.28868;
                    if (__s2_len > 1) goto <D.28869>; else goto <D.28870>;
                    <D.28869>:
                    if (__result == 0) goto <D.28871>; else goto <D.28872>;
                    <D.28871>:
                    D.28873 = &MEM[(void *)"mono_exception_from_token" + 2B];
                    D.28874 = *D.28873;
                    D.28875 = (int) D.28874;
                    D.28876 = __s2 + 2;
                    D.28877 = *D.28876;
                    D.28878 = (int) D.28877;
                    __result = D.28875 - D.28878;
                    if (__s2_len > 2) goto <D.28879>; else goto <D.28880>;
                    <D.28879>:
                    if (__result == 0) goto <D.28881>; else goto <D.28882>;
                    <D.28881>:
                    D.28883 = &MEM[(void *)"mono_exception_from_token" + 3B];
                    D.28884 = *D.28883;
                    D.28885 = (int) D.28884;
                    D.28886 = __s2 + 3;
                    D.28887 = *D.28886;
                    D.28888 = (int) D.28887;
                    __result = D.28885 - D.28888;
                    <D.28882>:
                    <D.28880>:
                    <D.28872>:
                    <D.28870>:
                    <D.28862>:
                    <D.28860>:
                  }
                  D.24815 = __result;
                }
                iftmp.170 = -D.24815;
                goto <D.28889>;
                <D.28853>:
                D.28805 = ji->data.name;
                iftmp.170 = __builtin_strcmp (D.28805, "mono_exception_from_token");
                <D.28889>:
                D.24816 = iftmp.170;
              }
              if (D.24816 == 0) goto <D.28890>; else goto <D.28891>;
              <D.28890>:
              target = mono_exception_from_token;
              goto <D.28892>;
              <D.28891>:
              {
                size_t __s1_len;
                size_t __s2_len;

                __s2_len = 20;
                if (__s2_len <= 3) goto <D.28894>; else goto <D.28895>;
                <D.28894>:
                {
                  const unsigned char * __s2;
                  int __result;

                  __s2 = ji->data.name;
                  D.28896 = "mono_throw_exception";
                  D.28897 = MEM[(const unsigned char *)D.28896];
                  D.28898 = (int) D.28897;
                  D.28899 = *__s2;
                  D.28900 = (int) D.28899;
                  __result = D.28898 - D.28900;
                  {
                    if (__s2_len != 0) goto <D.28901>; else goto <D.28902>;
                    <D.28901>:
                    if (__result == 0) goto <D.28903>; else goto <D.28904>;
                    <D.28903>:
                    D.28905 = &MEM[(void *)"mono_throw_exception" + 1B];
                    D.28906 = *D.28905;
                    D.28907 = (int) D.28906;
                    D.28908 = __s2 + 1;
                    D.28909 = *D.28908;
                    D.28910 = (int) D.28909;
                    __result = D.28907 - D.28910;
                    if (__s2_len > 1) goto <D.28911>; else goto <D.28912>;
                    <D.28911>:
                    if (__result == 0) goto <D.28913>; else goto <D.28914>;
                    <D.28913>:
                    D.28915 = &MEM[(void *)"mono_throw_exception" + 2B];
                    D.28916 = *D.28915;
                    D.28917 = (int) D.28916;
                    D.28918 = __s2 + 2;
                    D.28919 = *D.28918;
                    D.28920 = (int) D.28919;
                    __result = D.28917 - D.28920;
                    if (__s2_len > 2) goto <D.28921>; else goto <D.28922>;
                    <D.28921>:
                    if (__result == 0) goto <D.28923>; else goto <D.28924>;
                    <D.28923>:
                    D.28925 = &MEM[(void *)"mono_throw_exception" + 3B];
                    D.28926 = *D.28925;
                    D.28927 = (int) D.28926;
                    D.28928 = __s2 + 3;
                    D.28929 = *D.28928;
                    D.28930 = (int) D.28929;
                    __result = D.28927 - D.28930;
                    <D.28924>:
                    <D.28922>:
                    <D.28914>:
                    <D.28912>:
                    <D.28904>:
                    <D.28902>:
                  }
                  D.24824 = __result;
                }
                iftmp.171 = -D.24824;
                goto <D.28931>;
                <D.28895>:
                D.28805 = ji->data.name;
                iftmp.171 = __builtin_strcmp (D.28805, "mono_throw_exception");
                <D.28931>:
                D.24825 = iftmp.171;
              }
              if (D.24825 == 0) goto <D.28932>; else goto <D.28933>;
              <D.28932>:
              target = mono_get_throw_exception ();
              goto <D.28934>;
              <D.28933>:
              D.28805 = ji->data.name;
              D.28935 = strstr (D.28805, "trampoline_func_");
              D.28805 = ji->data.name;
              if (D.28935 == D.28805) goto <D.28936>; else goto <D.28937>;
              <D.28936>:
              {
                int tramp_type2;

                D.28805 = ji->data.name;
                D.28938 = D.28805 + 16;
                tramp_type2 = atoi (D.28938);
                tramp_type2.172 = (<unnamed type>) tramp_type2;
                target = mono_get_trampoline_func (tramp_type2.172);
              }
              goto <D.28940>;
              <D.28937>:
              D.28805 = ji->data.name;
              D.28941 = strstr (D.28805, "specific_trampoline_lazy_fetch_");
              D.28805 = ji->data.name;
              if (D.28941 == D.28805) goto <D.28942>; else goto <D.28943>;
              <D.28942>:
              {
                guint32 slot;
                int res;

                try
                  {
                    D.28805 = ji->data.name;
                    res = sscanf (D.28805, "specific_trampoline_lazy_fetch_%u", &slot);
                    D.28944 = res != 1;
                    D.28945 = (long int) D.28944;
                    D.28946 = __builtin_expect (D.28945, 0);
                    if (D.28946 != 0) goto <D.28947>; else goto <D.28948>;
                    <D.28947>:
                    monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "aot-runtime.c", 4182, "res == 1");
                    <D.28948>:
                    slot.173 = slot;
                    D.28950 = (long unsigned int) slot.173;
                    D.28951 = (void *) D.28950;
                    D.28952 = mono_get_root_domain ();
                    target = mono_create_specific_trampoline (D.28951, 4, D.28952, 0B);
                    target = mono_create_ftnptr_malloc (target);
                  }
                finally
                  {
                    slot = {CLOBBER};
                  }
              }
              goto <D.28953>;
              <D.28943>:
              {
                size_t __s1_len;
                size_t __s2_len;

                __s2_len = 33;
                if (__s2_len <= 3) goto <D.28955>; else goto <D.28956>;
                <D.28955>:
                {
                  const unsigned char * __s2;
                  int __result;

                  __s2 = ji->data.name;
                  D.28957 = "specific_trampoline_monitor_enter";
                  D.28958 = MEM[(const unsigned char *)D.28957];
                  D.28959 = (int) D.28958;
                  D.28960 = *__s2;
                  D.28961 = (int) D.28960;
                  __result = D.28959 - D.28961;
                  {
                    if (__s2_len != 0) goto <D.28962>; else goto <D.28963>;
                    <D.28962>:
                    if (__result == 0) goto <D.28964>; else goto <D.28965>;
                    <D.28964>:
                    D.28966 = &MEM[(void *)"specific_trampoline_monitor_enter" + 1B];
                    D.28967 = *D.28966;
                    D.28968 = (int) D.28967;
                    D.28969 = __s2 + 1;
                    D.28970 = *D.28969;
                    D.28971 = (int) D.28970;
                    __result = D.28968 - D.28971;
                    if (__s2_len > 1) goto <D.28972>; else goto <D.28973>;
                    <D.28972>:
                    if (__result == 0) goto <D.28974>; else goto <D.28975>;
                    <D.28974>:
                    D.28976 = &MEM[(void *)"specific_trampoline_monitor_enter" + 2B];
                    D.28977 = *D.28976;
                    D.28978 = (int) D.28977;
                    D.28979 = __s2 + 2;
                    D.28980 = *D.28979;
                    D.28981 = (int) D.28980;
                    __result = D.28978 - D.28981;
                    if (__s2_len > 2) goto <D.28982>; else goto <D.28983>;
                    <D.28982>:
                    if (__result == 0) goto <D.28984>; else goto <D.28985>;
                    <D.28984>:
                    D.28986 = &MEM[(void *)"specific_trampoline_monitor_enter" + 3B];
                    D.28987 = *D.28986;
                    D.28988 = (int) D.28987;
                    D.28989 = __s2 + 3;
                    D.28990 = *D.28989;
                    D.28991 = (int) D.28990;
                    __result = D.28988 - D.28991;
                    <D.28985>:
                    <D.28983>:
                    <D.28975>:
                    <D.28973>:
                    <D.28965>:
                    <D.28963>:
                  }
                  D.24836 = __result;
                }
                iftmp.174 = -D.24836;
                goto <D.28992>;
                <D.28956>:
                D.28805 = ji->data.name;
                iftmp.174 = __builtin_strcmp (D.28805, "specific_trampoline_monitor_enter");
                <D.28992>:
                D.24837 = iftmp.174;
              }
              if (D.24837 == 0) goto <D.28993>; else goto <D.28994>;
              <D.28993>:
              D.28995 = mono_get_root_domain ();
              target = mono_create_specific_trampoline (0B, 10, D.28995, 0B);
              target = mono_create_ftnptr_malloc (target);
              goto <D.28996>;
              <D.28994>:
              {
                size_t __s1_len;
                size_t __s2_len;

                __s2_len = 32;
                if (__s2_len <= 3) goto <D.28998>; else goto <D.28999>;
                <D.28998>:
                {
                  const unsigned char * __s2;
                  int __result;

                  __s2 = ji->data.name;
                  D.29000 = "specific_trampoline_monitor_exit";
                  D.29001 = MEM[(const unsigned char *)D.29000];
                  D.29002 = (int) D.29001;
                  D.29003 = *__s2;
                  D.29004 = (int) D.29003;
                  __result = D.29002 - D.29004;
                  {
                    if (__s2_len != 0) goto <D.29005>; else goto <D.29006>;
                    <D.29005>:
                    if (__result == 0) goto <D.29007>; else goto <D.29008>;
                    <D.29007>:
                    D.29009 = &MEM[(void *)"specific_trampoline_monitor_exit" + 1B];
                    D.29010 = *D.29009;
                    D.29011 = (int) D.29010;
                    D.29012 = __s2 + 1;
                    D.29013 = *D.29012;
                    D.29014 = (int) D.29013;
                    __result = D.29011 - D.29014;
                    if (__s2_len > 1) goto <D.29015>; else goto <D.29016>;
                    <D.29015>:
                    if (__result == 0) goto <D.29017>; else goto <D.29018>;
                    <D.29017>:
                    D.29019 = &MEM[(void *)"specific_trampoline_monitor_exit" + 2B];
                    D.29020 = *D.29019;
                    D.29021 = (int) D.29020;
                    D.29022 = __s2 + 2;
                    D.29023 = *D.29022;
                    D.29024 = (int) D.29023;
                    __result = D.29021 - D.29024;
                    if (__s2_len > 2) goto <D.29025>; else goto <D.29026>;
                    <D.29025>:
                    if (__result == 0) goto <D.29027>; else goto <D.29028>;
                    <D.29027>:
                    D.29029 = &MEM[(void *)"specific_trampoline_monitor_exit" + 3B];
                    D.29030 = *D.29029;
                    D.29031 = (int) D.29030;
                    D.29032 = __s2 + 3;
                    D.29033 = *D.29032;
                    D.29034 = (int) D.29033;
                    __result = D.29031 - D.29034;
                    <D.29028>:
                    <D.29026>:
                    <D.29018>:
                    <D.29016>:
                    <D.29008>:
                    <D.29006>:
                  }
                  D.24845 = __result;
                }
                iftmp.175 = -D.24845;
                goto <D.29035>;
                <D.28999>:
                D.28805 = ji->data.name;
                iftmp.175 = __builtin_strcmp (D.28805, "specific_trampoline_monitor_exit");
                <D.29035>:
                D.24846 = iftmp.175;
              }
              if (D.24846 == 0) goto <D.29036>; else goto <D.29037>;
              <D.29036>:
              D.29038 = mono_get_root_domain ();
              target = mono_create_specific_trampoline (0B, 11, D.29038, 0B);
              target = mono_create_ftnptr_malloc (target);
              goto <D.29039>;
              <D.29037>:
              {
                size_t __s1_len;
                size_t __s2_len;

                __s2_len = 38;
                if (__s2_len <= 3) goto <D.29041>; else goto <D.29042>;
                <D.29041>:
                {
                  const unsigned char * __s2;
                  int __result;

                  __s2 = ji->data.name;
                  D.29043 = "specific_trampoline_generic_class_init";
                  D.29044 = MEM[(const unsigned char *)D.29043];
                  D.29045 = (int) D.29044;
                  D.29046 = *__s2;
                  D.29047 = (int) D.29046;
                  __result = D.29045 - D.29047;
                  {
                    if (__s2_len != 0) goto <D.29048>; else goto <D.29049>;
                    <D.29048>:
                    if (__result == 0) goto <D.29050>; else goto <D.29051>;
                    <D.29050>:
                    D.29052 = &MEM[(void *)"specific_trampoline_generic_class_init" + 1B];
                    D.29053 = *D.29052;
                    D.29054 = (int) D.29053;
                    D.29055 = __s2 + 1;
                    D.29056 = *D.29055;
                    D.29057 = (int) D.29056;
                    __result = D.29054 - D.29057;
                    if (__s2_len > 1) goto <D.29058>; else goto <D.29059>;
                    <D.29058>:
                    if (__result == 0) goto <D.29060>; else goto <D.29061>;
                    <D.29060>:
                    D.29062 = &MEM[(void *)"specific_trampoline_generic_class_init" + 2B];
                    D.29063 = *D.29062;
                    D.29064 = (int) D.29063;
                    D.29065 = __s2 + 2;
                    D.29066 = *D.29065;
                    D.29067 = (int) D.29066;
                    __result = D.29064 - D.29067;
                    if (__s2_len > 2) goto <D.29068>; else goto <D.29069>;
                    <D.29068>:
                    if (__result == 0) goto <D.29070>; else goto <D.29071>;
                    <D.29070>:
                    D.29072 = &MEM[(void *)"specific_trampoline_generic_class_init" + 3B];
                    D.29073 = *D.29072;
                    D.29074 = (int) D.29073;
                    D.29075 = __s2 + 3;
                    D.29076 = *D.29075;
                    D.29077 = (int) D.29076;
                    __result = D.29074 - D.29077;
                    <D.29071>:
                    <D.29069>:
                    <D.29061>:
                    <D.29059>:
                    <D.29051>:
                    <D.29049>:
                  }
                  D.24854 = __result;
                }
                iftmp.176 = -D.24854;
                goto <D.29078>;
                <D.29042>:
                D.28805 = ji->data.name;
                iftmp.176 = __builtin_strcmp (D.28805, "specific_trampoline_generic_class_init");
                <D.29078>:
                D.24855 = iftmp.176;
              }
              if (D.24855 == 0) goto <D.29079>; else goto <D.29080>;
              <D.29079>:
              D.29081 = mono_get_root_domain ();
              target = mono_create_specific_trampoline (0B, 3, D.29081, 0B);
              target = mono_create_ftnptr_malloc (target);
              goto <D.29082>;
              <D.29080>:
              {
                size_t __s1_len;
                size_t __s2_len;

                __s2_len = 43;
                if (__s2_len <= 3) goto <D.29084>; else goto <D.29085>;
                <D.29084>:
                {
                  const unsigned char * __s2;
                  int __result;

                  __s2 = ji->data.name;
                  D.29086 = "mono_thread_get_and_clear_pending_exception";
                  D.29087 = MEM[(const unsigned char *)D.29086];
                  D.29088 = (int) D.29087;
                  D.29089 = *__s2;
                  D.29090 = (int) D.29089;
                  __result = D.29088 - D.29090;
                  {
                    if (__s2_len != 0) goto <D.29091>; else goto <D.29092>;
                    <D.29091>:
                    if (__result == 0) goto <D.29093>; else goto <D.29094>;
                    <D.29093>:
                    D.29095 = &MEM[(void *)"mono_thread_get_and_clear_pending_exception" + 1B];
                    D.29096 = *D.29095;
                    D.29097 = (int) D.29096;
                    D.29098 = __s2 + 1;
                    D.29099 = *D.29098;
                    D.29100 = (int) D.29099;
                    __result = D.29097 - D.29100;
                    if (__s2_len > 1) goto <D.29101>; else goto <D.29102>;
                    <D.29101>:
                    if (__result == 0) goto <D.29103>; else goto <D.29104>;
                    <D.29103>:
                    D.29105 = &MEM[(void *)"mono_thread_get_and_clear_pending_exception" + 2B];
                    D.29106 = *D.29105;
                    D.29107 = (int) D.29106;
                    D.29108 = __s2 + 2;
                    D.29109 = *D.29108;
                    D.29110 = (int) D.29109;
                    __result = D.29107 - D.29110;
                    if (__s2_len > 2) goto <D.29111>; else goto <D.29112>;
                    <D.29111>:
                    if (__result == 0) goto <D.29113>; else goto <D.29114>;
                    <D.29113>:
                    D.29115 = &MEM[(void *)"mono_thread_get_and_clear_pending_exception" + 3B];
                    D.29116 = *D.29115;
                    D.29117 = (int) D.29116;
                    D.29118 = __s2 + 3;
                    D.29119 = *D.29118;
                    D.29120 = (int) D.29119;
                    __result = D.29117 - D.29120;
                    <D.29114>:
                    <D.29112>:
                    <D.29104>:
                    <D.29102>:
                    <D.29094>:
                    <D.29092>:
                  }
                  D.24863 = __result;
                }
                iftmp.177 = -D.24863;
                goto <D.29121>;
                <D.29085>:
                D.28805 = ji->data.name;
                iftmp.177 = __builtin_strcmp (D.28805, "mono_thread_get_and_clear_pending_exception");
                <D.29121>:
                D.24864 = iftmp.177;
              }
              if (D.24864 == 0) goto <D.29122>; else goto <D.29123>;
              <D.29122>:
              target = mono_thread_get_and_clear_pending_exception;
              goto <D.29124>;
              <D.29123>:
              D.28805 = ji->data.name;
              D.29125 = strstr (D.28805, "generic_trampoline_");
              if (D.29125 != 0B) goto <D.29126>; else goto <D.29127>;
              <D.29126>:
              D.28805 = ji->data.name;
              target = mono_aot_get_trampoline (D.28805);
              goto <D.29128>;
              <D.29127>:
              aot_jit_icall_hash.178 = aot_jit_icall_hash;
              if (aot_jit_icall_hash.178 != 0B) goto <D.29132>; else goto <D.29129>;
              <D.29132>:
              aot_jit_icall_hash.178 = aot_jit_icall_hash;
              D.28805 = ji->data.name;
              D.29133 = monoeg_g_hash_table_lookup (aot_jit_icall_hash.178, D.28805);
              if (D.29133 != 0B) goto <D.29134>; else goto <D.29129>;
              <D.29134>:
              aot_jit_icall_hash.178 = aot_jit_icall_hash;
              D.28805 = ji->data.name;
              target = monoeg_g_hash_table_lookup (aot_jit_icall_hash.178, D.28805);
              goto <D.29130>;
              <D.29129>:
              stderr.179 = stderr;
              D.28805 = ji->data.name;
              fprintf (stderr.179, "Unknown relocation \'%s\'\n", D.28805);
              monoeg_assertion_message ("* Assertion: should not be reached at %s:%d\n", "aot-runtime.c", 4203);
              target = 0B;
              <D.29130>:
              <D.29128>:
              <D.29124>:
              <D.29082>:
              <D.29039>:
              <D.28996>:
              <D.28953>:
              <D.28940>:
              <D.28934>:
              <D.28892>:
              <D.28850>:
              <D.28808>:
              goto <D.29136>;
              <D.28765>:
              code.161 = code;
              target = mono_resolve_patch_target (0B, 0B, code.161, ji, 0);
              D.29137 = target == 0B;
              D.29138 = (long int) D.29137;
              D.29139 = __builtin_expect (D.29138, 0);
              if (D.29139 != 0) goto <D.29140>; else goto <D.29141>;
              <D.29140>:
              monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "aot-runtime.c", 4211, "target");
              <D.29141>:
              <D.29136>:
              D.28752 = amodule->got;
              got_slots.167 = got_slots;
              D.28750 = (long unsigned int) pindex;
              D.28754 = D.28750 * 4;
              D.28755 = got_slots.167 + D.28754;
              D.28756 = *D.28755;
              D.28757 = (long unsigned int) D.28756;
              D.28758 = D.28757 * 8;
              D.28759 = D.28752 + D.28758;
              *D.28759 = target;
            }
            <D.24789>:
            pindex = pindex + 1;
            <D.24866>:
            if (pindex < n_patches) goto <D.24865>; else goto <D.24867>;
            <D.24867>:
            got_slots.167 = got_slots;
            monoeg_g_free (got_slots.167);
            mono_mempool_destroy (mp);
          }
        finally
          {
            got_slots = {CLOBBER};
          }
      }
      <D.28744>:
      D.28731 = code;
      return D.28731;
    }
  finally
    {
      p = {CLOBBER};
      code = {CLOBBER};
    }
}


mono_create_ftnptr_malloc (guint8 * code)
{
  void * D.29144;
  struct MonoPPCFunctionDescriptor * ftnptr;

  ftnptr = monoeg_malloc0 (24);
  ftnptr->code = code;
  ftnptr->toc = 0B;
  ftnptr->env = 0B;
  D.29144 = ftnptr;
  return D.29144;
}


mono_aot_get_trampoline (const char * name)
{
  void * D.29146;

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


mono_aot_create_specific_trampoline (struct MonoImage * image, void * arg1, MonoTrampolineType tramp_type, struct MonoDomain * domain, guint32 * code_len)
{
  int inited.180;
  _Bool D.29153;
  long int D.29154;
  long int D.29155;
  _Bool D.29162;
  long int D.29163;
  long int D.29164;
  unsigned int num_trampolines.181;
  unsigned int num_trampolines.182;
  void * D.29169;
  void * D.29172;
  _Bool D.29173;
  long int D.29174;
  long int D.29175;
  struct MonoAotModule * amodule.183;
  void * * D.29182;
  unsigned int got_offset.184;
  long unsigned int D.29184;
  long unsigned int D.29185;
  void * * D.29186;
  unsigned int D.29187;
  long unsigned int D.29188;
  long unsigned int D.29189;
  void * * D.29190;
  unsigned int tramp_size.185;
  void * D.29194;
  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.180 = inited;
      if (inited.180 == 0) goto <D.29149>; else goto <D.29150>;
      <D.29149>:
      {
        int ret;

        ret = pthread_mutex_lock (&aot_mutex.mutex);
        if (ret != 0) goto <D.29151>; else goto <D.29152>;
        <D.29151>:
        monoeg_g_log (0B, 16, "Bad call to mono_mutex_lock result %d", ret);
        <D.29152>:
        D.29153 = ret != 0;
        D.29154 = (long int) D.29153;
        D.29155 = __builtin_expect (D.29154, 0);
        if (D.29155 != 0) goto <D.29156>; else goto <D.29157>;
        <D.29156>:
        monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "aot-runtime.c", 4494, "ret == 0");
        <D.29157>:
      }
      inited.180 = inited;
      if (inited.180 == 0) goto <D.29158>; else goto <D.29159>;
      <D.29158>:
      mono_counters_register ("Specific trampolines", 256, &num_trampolines);
      inited = 1;
      <D.29159>:
      {
        int ret;

        ret = pthread_mutex_unlock (&aot_mutex.mutex);
        if (ret != 0) goto <D.29160>; else goto <D.29161>;
        <D.29160>:
        monoeg_g_log (0B, 16, "Bad call to mono_mutex_unlock result %d", ret);
        <D.29161>:
        D.29162 = ret != 0;
        D.29163 = (long int) D.29162;
        D.29164 = __builtin_expect (D.29163, 0);
        if (D.29164 != 0) goto <D.29165>; else goto <D.29166>;
        <D.29165>:
        monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "aot-runtime.c", 4501, "ret == 0");
        <D.29166>:
      }
      <D.29150>:
      num_trampolines.181 = num_trampolines;
      num_trampolines.182 = num_trampolines.181 + 1;
      num_trampolines = num_trampolines.182;
      D.29169 = generic_trampolines[tramp_type];
      if (D.29169 == 0B) goto <D.29170>; else goto <D.29171>;
      <D.29170>:
      {
        char * symbol;

        symbol = mono_get_generic_trampoline_name (tramp_type);
        D.29172 = mono_aot_get_trampoline (symbol);
        generic_trampolines[tramp_type] = D.29172;
        monoeg_g_free (symbol);
      }
      <D.29171>:
      tramp = generic_trampolines[tramp_type];
      D.29173 = tramp == 0B;
      D.29174 = (long int) D.29173;
      D.29175 = __builtin_expect (D.29174, 0);
      if (D.29175 != 0) goto <D.29176>; else goto <D.29177>;
      <D.29176>:
      monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "aot-runtime.c", 4515, "tramp");
      <D.29177>:
      if (0 != 0) goto <D.29178>; else goto <D.29179>;
      <D.29178>:
      code = get_new_specific_trampoline_from_page (tramp, arg1);
      tramp_size = 8;
      goto <D.29180>;
      <D.29179>:
      code = get_numerous_trampoline (0, 2, &amodule, &got_offset, &tramp_size);
      amodule.183 = amodule;
      D.29182 = amodule.183->got;
      got_offset.184 = got_offset;
      D.29184 = (long unsigned int) got_offset.184;
      D.29185 = D.29184 * 8;
      D.29186 = D.29182 + D.29185;
      *D.29186 = tramp;
      amodule.183 = amodule;
      D.29182 = amodule.183->got;
      got_offset.184 = got_offset;
      D.29187 = got_offset.184 + 1;
      D.29188 = (long unsigned int) D.29187;
      D.29189 = D.29188 * 8;
      D.29190 = D.29182 + D.29189;
      *D.29190 = arg1;
      <D.29180>:
      if (code_len != 0B) goto <D.29191>; else goto <D.29192>;
      <D.29191>:
      tramp_size.185 = tramp_size;
      *code_len = tramp_size.185;
      <D.29192>:
      D.29194 = code;
      return D.29194;
    }
  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.29197;
  long int D.29198;
  long int D.29199;
  _Bool D.29204;
  long int D.29205;
  long int D.29206;
  _Bool D.29209;
  long int D.29210;
  long int D.29211;
  unsigned int D.29214;
  unsigned int D.29215;
  char * D.29218;
  unsigned int D.29219;
  unsigned int D.29220;
  _Bool D.29223;
  long int D.29224;
  long int D.29225;
  unsigned int D.29228;
  int D.29229;
  unsigned int D.29230;
  unsigned int D.29231;
  unsigned int D.29232;
  unsigned int tramp_size.186;
  void * D.29236;
  guint8 * D.29237;
  int D.29238;
  sizetype D.29239;
  struct MonoAotModule * amodule;
  int index;
  int tramp_size;
  struct MonoImage * image;

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

    ret = pthread_mutex_lock (&aot_mutex.mutex);
    if (ret != 0) goto <D.29202>; else goto <D.29203>;
    <D.29202>:
    monoeg_g_log (0B, 16, "Bad call to mono_mutex_lock result %d", ret);
    <D.29203>:
    D.29204 = ret != 0;
    D.29205 = (long int) D.29204;
    D.29206 = __builtin_expect (D.29205, 0);
    if (D.29206 != 0) goto <D.29207>; else goto <D.29208>;
    <D.29207>:
    monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "aot-runtime.c", 4450, "ret == 0");
    <D.29208>:
  }
  amodule = image->aot_module;
  D.29209 = amodule == 0B;
  D.29210 = (long int) D.29209;
  D.29211 = __builtin_expect (D.29210, 0);
  if (D.29211 != 0) goto <D.29212>; else goto <D.29213>;
  <D.29212>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "aot-runtime.c", 4453, "amodule");
  <D.29213>:
  *out_amodule = amodule;
  D.29214 = amodule->trampoline_index[tramp_type];
  D.29215 = amodule->info.num_trampolines[tramp_type];
  if (D.29214 == D.29215) goto <D.29216>; else goto <D.29217>;
  <D.29216>:
  D.29218 = image->name;
  D.29215 = 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.29218, D.29215, "");
  <D.24920>:
  goto <D.24920>;
  <D.29217>:
  D.29214 = amodule->trampoline_index[tramp_type];
  D.29219 = D.29214;
  D.29220 = D.29219 + 1;
  amodule->trampoline_index[tramp_type] = D.29220;
  index = (int) D.29219;
  {
    int ret;

    ret = pthread_mutex_unlock (&aot_mutex.mutex);
    if (ret != 0) goto <D.29221>; else goto <D.29222>;
    <D.29221>:
    monoeg_g_log (0B, 16, "Bad call to mono_mutex_unlock result %d", ret);
    <D.29222>:
    D.29223 = ret != 0;
    D.29224 = (long int) D.29223;
    D.29225 = __builtin_expect (D.29224, 0);
    if (D.29225 != 0) goto <D.29226>; else goto <D.29227>;
    <D.29226>:
    monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "aot-runtime.c", 4468, "ret == 0");
    <D.29227>:
  }
  D.29228 = amodule->info.trampoline_got_offset_base[tramp_type];
  D.29229 = index * n_got_slots;
  D.29230 = (unsigned int) D.29229;
  D.29231 = D.29228 + D.29230;
  *got_offset = D.29231;
  D.29232 = amodule->info.trampoline_size[tramp_type];
  tramp_size = (int) D.29232;
  if (out_tramp_size != 0B) goto <D.29233>; else goto <D.29234>;
  <D.29233>:
  tramp_size.186 = (unsigned int) tramp_size;
  *out_tramp_size = tramp_size.186;
  <D.29234>:
  D.29237 = amodule->trampolines[tramp_type];
  D.29238 = index * tramp_size;
  D.29239 = (sizetype) D.29238;
  D.29236 = D.29237 + D.29239;
  return D.29236;
}


mono_aot_get_static_rgctx_trampoline (void * ctx, void * addr)
{
  struct MonoAotModule * amodule.187;
  void * * D.29245;
  unsigned int got_offset.188;
  long unsigned int D.29247;
  long unsigned int D.29248;
  void * * D.29249;
  unsigned int D.29250;
  long unsigned int D.29251;
  long unsigned int D.29252;
  void * * D.29253;
  void * D.29254;
  struct MonoDomain * D.29255;
  struct MonoAotModule * amodule;
  guint8 * code;
  guint32 got_offset;

  try
    {
      if (0 != 0) goto <D.29241>; else goto <D.29242>;
      <D.29241>:
      code = get_new_rgctx_trampoline_from_page (addr, ctx);
      goto <D.29243>;
      <D.29242>:
      code = get_numerous_trampoline (1, 2, &amodule, &got_offset, 0B);
      amodule.187 = amodule;
      D.29245 = amodule.187->got;
      got_offset.188 = got_offset;
      D.29247 = (long unsigned int) got_offset.188;
      D.29248 = D.29247 * 8;
      D.29249 = D.29245 + D.29248;
      *D.29249 = ctx;
      amodule.187 = amodule;
      D.29245 = amodule.187->got;
      got_offset.188 = got_offset;
      D.29250 = got_offset.188 + 1;
      D.29251 = (long unsigned int) D.29250;
      D.29252 = D.29251 * 8;
      D.29253 = D.29245 + D.29252;
      *D.29253 = addr;
      <D.29243>:
      D.29255 = mono_domain_get ();
      D.29254 = mono_create_ftnptr (D.29255, code);
      return D.29254;
    }
  finally
    {
      amodule = {CLOBBER};
      got_offset = {CLOBBER};
    }
}


mono_aot_get_unbox_trampoline (struct MonoMethod * method)
{
  unsigned int D.29258;
  unsigned int D.29259;
  long unsigned int D.29262;
  long unsigned int D.29263;
  int D.29265;
  int D.29269;
  _Bool D.29272;
  long int D.29273;
  long int D.29274;
  struct MonoClass * D.29277;
  struct MonoImage * D.29278;
  void * amodule.189;
  struct MonoAotModule * amodule.190;
  _Bool D.29281;
  long int D.29282;
  long int D.29283;
  long int ut_end.191;
  long int ut.192;
  long int D.29288;
  long int D.29289;
  long int D.29290;
  int D.29291;
  int D.29292;
  long unsigned int D.29293;
  long unsigned int D.29294;
  unsigned int D.29295;
  unsigned int D.29302;
  unsigned int D.29303;
  guint32 * D.29306;
  guint8 * D.29308;
  unsigned int D.29309;
  sizetype D.29310;
  _Bool D.29311;
  long int D.29312;
  long int D.29313;
  void * D.29316;
  struct MonoDomain * D.29317;
  guint32 method_index;
  struct MonoAotModule * amodule;
  void * code;
  guint32 * ut;
  guint32 * ut_end;
  guint32 * entry;
  int low;
  int high;
  int entry_index;

  try
    {
      D.29258 = method->token;
      D.29259 = D.29258 & 16777215;
      method_index = D.29259 + 4294967295;
      D.29262 = BIT_FIELD_REF <*method, 64, 256>;
      D.29263 = D.29262 & 4096;
      if (D.29263 != 0) goto <D.29264>; else goto <D.29260>;
      <D.29264>:
      D.29265 = mono_method_is_generic_sharable_full (method, 0, 0, 0);
      if (D.29265 == 0) goto <D.29266>; else goto <D.29260>;
      <D.29266>:
      method_index = find_extra_method (method, &amodule);
      if (method_index == 16777215) goto <D.29267>; else goto <D.29268>;
      <D.29267>:
      D.29269 = mono_method_is_generic_sharable_full (method, 0, 0, 1);
      if (D.29269 != 0) goto <D.29270>; else goto <D.29271>;
      <D.29270>:
      {
        struct MonoMethod * shared;

        shared = mini_get_shared_method_full (method, 1, 1);
        method_index = find_extra_method (shared, &amodule);
      }
      <D.29271>:
      <D.29268>:
      D.29272 = method_index == 16777215;
      D.29273 = (long int) D.29272;
      D.29274 = __builtin_expect (D.29273, 0);
      if (D.29274 != 0) goto <D.29275>; else goto <D.29276>;
      <D.29275>:
      monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "aot-runtime.c", 4568, "method_index != 0xffffff");
      <D.29276>:
      goto <D.29261>;
      <D.29260>:
      D.29277 = method->klass;
      D.29278 = D.29277->image;
      amodule.189 = D.29278->aot_module;
      amodule = amodule.189;
      amodule.190 = amodule;
      D.29281 = amodule.190 == 0B;
      D.29282 = (long int) D.29281;
      D.29283 = __builtin_expect (D.29282, 0);
      if (D.29283 != 0) goto <D.29284>; else goto <D.29285>;
      <D.29284>:
      monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "aot-runtime.c", 4571, "amodule");
      <D.29285>:
      <D.29261>:
      amodule.190 = amodule;
      ut = amodule.190->unbox_trampolines;
      amodule.190 = amodule;
      ut_end = amodule.190->unbox_trampolines_end;
      code = 0B;
      low = 0;
      ut_end.191 = (long int) ut_end;
      ut.192 = (long int) ut;
      D.29288 = ut_end.191 - ut.192;
      D.29289 = D.29288 /[ex] 4;
      D.29290 = D.29289 / 2;
      high = (int) D.29290;
      goto <D.24962>;
      <D.24961>:
      D.29291 = low + high;
      entry_index = D.29291 / 2;
      D.29292 = entry_index * 2;
      D.29293 = (long unsigned int) D.29292;
      D.29294 = D.29293 * 4;
      entry = ut + D.29294;
      D.29295 = *entry;
      if (D.29295 < method_index) goto <D.29296>; else goto <D.29297>;
      <D.29296>:
      low = entry_index + 1;
      goto <D.29298>;
      <D.29297>:
      D.29295 = *entry;
      if (D.29295 > method_index) goto <D.29299>; else goto <D.29300>;
      <D.29299>:
      high = entry_index;
      goto <D.29301>;
      <D.29300>:
      amodule.190 = amodule;
      D.29302 = amodule.190->info.flags;
      D.29303 = D.29302 & 8;
      if (D.29303 != 0) goto <D.29304>; else goto <D.29305>;
      <D.29304>:
      D.29306 = entry + 4;
      code = get_arm_bl_target (D.29306);
      goto <D.29307>;
      <D.29305>:
      amodule.190 = amodule;
      D.29308 = amodule.190->code;
      D.29306 = entry + 4;
      D.29309 = *D.29306;
      D.29310 = (sizetype) D.29309;
      code = D.29308 + D.29310;
      <D.29307>:
      goto <D.24960>;
      <D.29301>:
      <D.29298>:
      <D.24962>:
      if (low < high) goto <D.24961>; else goto <D.24960>;
      <D.24960>:
      D.29311 = code == 0B;
      D.29312 = (long int) D.29311;
      D.29313 = __builtin_expect (D.29312, 0);
      if (D.29313 != 0) goto <D.29314>; else goto <D.29315>;
      <D.29314>:
      monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "aot-runtime.c", 4596, "code");
      <D.29315>:
      D.29317 = mono_domain_get ();
      D.29316 = mono_create_ftnptr (D.29317, code);
      return D.29316;
    }
  finally
    {
      amodule = {CLOBBER};
    }
}


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

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


mono_aot_get_lazy_fetch_trampoline (guint32 slot)
{
  struct MonoImage * D.29322;
  int count.193;
  int count.194;
  unsigned int D.29325;
  void * addr.195;
  void * addr.196;
  struct MonoDomain * D.29332;
  long unsigned int D.29333;
  void * D.29334;
  void * * D.29335;
  struct MonoDomain * D.29336;
  void * D.29337;
  void * D.29338;
  struct MonoDomain * D.29339;
  int slot.197;
  void * D.29341;
  struct MonoDomain * D.29342;
  char * symbol;
  void * code;
  struct MonoAotModule * amodule;
  guint32 index;
  static int count = 0;

  D.29322 = mono_defaults.corlib;
  amodule = D.29322->aot_module;
  index = slot & 2147483647;
  count.193 = count;
  count.194 = count.193 + 1;
  count = count.194;
  D.29325 = amodule->info.num_rgctx_fetch_trampolines;
  if (D.29325 <= index) goto <D.29326>; else goto <D.29327>;
  <D.29326>:
  {
    static void * addr;
    void * * info;

    addr.195 = addr;
    if (addr.195 == 0B) goto <D.29329>; else goto <D.29330>;
    <D.29329>:
    addr.196 = load_function (amodule, "rgctx_fetch_trampoline_general");
    addr = addr.196;
    <D.29330>:
    D.29332 = mono_get_root_domain ();
    info = mono_domain_alloc0 (D.29332, 16);
    D.29333 = (long unsigned int) slot;
    D.29334 = (void *) D.29333;
    *info = D.29334;
    D.29335 = info + 8;
    D.29333 = (long unsigned int) slot;
    D.29334 = (void *) D.29333;
    D.29336 = mono_get_root_domain ();
    D.29337 = mono_create_specific_trampoline (D.29334, 4, D.29336, 0B);
    *D.29335 = D.29337;
    addr.195 = addr;
    code = mono_aot_get_static_rgctx_trampoline (info, addr.195);
    D.29339 = mono_domain_get ();
    D.29338 = mono_create_ftnptr (D.29339, code);
    return D.29338;
  }
  <D.29327>:
  slot.197 = (int) slot;
  symbol = mono_get_rgctx_fetch_trampoline_name (slot.197);
  D.29322 = mono_defaults.corlib;
  D.29341 = D.29322->aot_module;
  code = load_function (D.29341, symbol);
  monoeg_g_free (symbol);
  D.29342 = mono_domain_get ();
  D.29338 = mono_create_ftnptr (D.29342, code);
  return D.29338;
}


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

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


mono_aot_get_imt_thunk (struct MonoVTable * vtable, struct MonoDomain * domain, struct MonoIMTCheckItem * * imt_entries, int count, void * fail_tramp)
{
  long unsigned int D.29346;
  long unsigned int D.29347;
  struct MonoIMTCheckItem * * D.29348;
  unsigned char D.29349;
  int D.29352;
  int D.29353;
  long unsigned int D.29354;
  unsigned int D.29355;
  unsigned int D.29356;
  unsigned char D.29357;
  void * D.29360;
  _Bool D.29361;
  long int D.29362;
  long int D.29363;
  int D.29366;
  long unsigned int D.29367;
  long unsigned int D.29368;
  void * * D.29369;
  unsigned char D.29370;
  void * D.29373;
  sizetype D.29374;
  sizetype D.29375;
  sizetype D.29376;
  void * * D.29377;
  int D.29379;
  void * * D.29380;
  struct MonoAotModule * amodule.198;
  void * * D.29385;
  unsigned int got_offset.199;
  long unsigned int D.29387;
  long unsigned int D.29388;
  void * * D.29389;
  void * D.29390;
  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.24989>;
      <D.24988>:
      {
        struct MonoIMTCheckItem * item;

        D.29346 = (long unsigned int) i;
        D.29347 = D.29346 * 8;
        D.29348 = imt_entries + D.29347;
        item = *D.29348;
        D.29349 = item->is_equals;
        if (D.29349 != 0) goto <D.29350>; else goto <D.29351>;
        <D.29350>:
        real_count = real_count + 1;
        <D.29351>:
      }
      i = i + 1;
      <D.24989>:
      if (i < count) goto <D.24988>; else goto <D.24990>;
      <D.24990>:
      D.29352 = real_count + 1;
      D.29353 = D.29352 * 2;
      D.29354 = (long unsigned int) D.29353;
      D.29355 = (unsigned int) D.29354;
      D.29356 = D.29355 * 8;
      buf = mono_domain_alloc (domain, D.29356);
      index = 0;
      i = 0;
      goto <D.24995>;
      <D.24994>:
      {
        struct MonoIMTCheckItem * item;

        D.29346 = (long unsigned int) i;
        D.29347 = D.29346 * 8;
        D.29348 = imt_entries + D.29347;
        item = *D.29348;
        D.29357 = item->is_equals;
        if (D.29357 == 0) goto <D.29358>; else goto <D.29359>;
        <D.29358>:
        // predicted unlikely by continue predictor.
        goto <D.24992>;
        <D.29359>:
        D.29360 = item->key;
        D.29361 = D.29360 == 0B;
        D.29362 = (long int) D.29361;
        D.29363 = __builtin_expect (D.29362, 0);
        if (D.29363 != 0) goto <D.29364>; else goto <D.29365>;
        <D.29364>:
        monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "aot-runtime.c", 4661, "item->key");
        <D.29365>:
        D.29366 = index * 2;
        D.29367 = (long unsigned int) D.29366;
        D.29368 = D.29367 * 8;
        D.29369 = buf + D.29368;
        D.29360 = item->key;
        *D.29369 = D.29360;
        D.29370 = item->has_target_code;
        if (D.29370 != 0) goto <D.29371>; else goto <D.29372>;
        <D.29371>:
        {
          void * * p;

          p = mono_domain_alloc (domain, 8);
          D.29373 = item->value.target_code;
          *p = D.29373;
          D.29366 = index * 2;
          D.29374 = (sizetype) D.29366;
          D.29375 = D.29374 + 1;
          D.29376 = D.29375 * 8;
          D.29377 = buf + D.29376;
          *D.29377 = p;
        }
        goto <D.29378>;
        <D.29372>:
        D.29366 = index * 2;
        D.29374 = (sizetype) D.29366;
        D.29375 = D.29374 + 1;
        D.29376 = D.29375 * 8;
        D.29377 = buf + D.29376;
        D.29379 = item->value.vtable_slot;
        D.29380 = &vtable->vtable[D.29379];
        *D.29377 = D.29380;
        <D.29378>:
        index = index + 1;
      }
      <D.24992>:
      i = i + 1;
      <D.24995>:
      if (i < count) goto <D.24994>; else goto <D.24996>;
      <D.24996>:
      D.29366 = index * 2;
      D.29367 = (long unsigned int) D.29366;
      D.29368 = D.29367 * 8;
      D.29369 = buf + D.29368;
      *D.29369 = 0B;
      D.29366 = index * 2;
      D.29374 = (sizetype) D.29366;
      D.29375 = D.29374 + 1;
      D.29376 = D.29375 * 8;
      D.29377 = buf + D.29376;
      *D.29377 = fail_tramp;
      if (0 != 0) goto <D.29381>; else goto <D.29382>;
      <D.29381>:
      code = get_new_imt_trampoline_from_page (buf);
      goto <D.29383>;
      <D.29382>:
      code = get_numerous_trampoline (2, 1, &amodule, &got_offset, 0B);
      amodule.198 = amodule;
      D.29385 = amodule.198->got;
      got_offset.199 = got_offset;
      D.29387 = (long unsigned int) got_offset.199;
      D.29388 = D.29387 * 8;
      D.29389 = D.29385 + D.29388;
      *D.29389 = buf;
      <D.29383>:
      D.29390 = code;
      return D.29390;
    }
  finally
    {
      got_offset = {CLOBBER};
      amodule = {CLOBBER};
    }
}


mono_aot_get_gsharedvt_arg_trampoline (void * arg, void * addr)
{
  struct MonoAotModule * amodule.200;
  void * * D.29397;
  unsigned int got_offset.201;
  long unsigned int D.29399;
  long unsigned int D.29400;
  void * * D.29401;
  unsigned int D.29402;
  long unsigned int D.29403;
  long unsigned int D.29404;
  void * * D.29405;
  void * D.29406;
  struct MonoDomain * D.29407;
  struct MonoAotModule * amodule;
  guint8 * code;
  guint32 got_offset;

  try
    {
      if (0 != 0) goto <D.29393>; else goto <D.29394>;
      <D.29393>:
      code = get_new_gsharedvt_arg_trampoline_from_page (addr, arg);
      goto <D.29395>;
      <D.29394>:
      code = get_numerous_trampoline (3, 2, &amodule, &got_offset, 0B);
      amodule.200 = amodule;
      D.29397 = amodule.200->got;
      got_offset.201 = got_offset;
      D.29399 = (long unsigned int) got_offset.201;
      D.29400 = D.29399 * 8;
      D.29401 = D.29397 + D.29400;
      *D.29401 = arg;
      amodule.200 = amodule;
      D.29397 = amodule.200->got;
      got_offset.201 = got_offset;
      D.29402 = got_offset.201 + 1;
      D.29403 = (long unsigned int) D.29402;
      D.29404 = D.29403 * 8;
      D.29405 = D.29397 + D.29404;
      *D.29405 = addr;
      <D.29395>:
      D.29407 = mono_domain_get ();
      D.29406 = mono_create_ftnptr (D.29407, code);
      return D.29406;
    }
  finally
    {
      amodule = {CLOBBER};
      got_offset = {CLOBBER};
    }
}


mono_aot_set_make_unreadable (gboolean unreadable)
{
  int make_unreadable.202;
  int inited.203;
  static int inited;

  make_unreadable = unreadable;
  make_unreadable.202 = make_unreadable;
  if (make_unreadable.202 != 0) goto <D.29411>; else goto <D.29412>;
  <D.29411>:
  inited.203 = inited;
  if (inited.203 == 0) goto <D.29414>; else goto <D.29415>;
  <D.29414>:
  mono_counters_register ("AOT pagefaults", 256, &n_pagefaults);
  <D.29415>:
  <D.29412>:
}


mono_aot_is_pagefault (void * ptr)
{
  int make_unreadable.204;
  gboolean D.29419;
  struct MonoAotModule * D.29420;
  _Bool D.29421;

  make_unreadable.204 = make_unreadable;
  if (make_unreadable.204 == 0) goto <D.29417>; else goto <D.29418>;
  <D.29417>:
  D.29419 = 0;
  return D.29419;
  <D.29418>:
  D.29420 = find_module_for_addr (ptr);
  D.29421 = D.29420 != 0B;
  D.29419 = (gboolean) D.29421;
  return D.29419;
}


find_module_for_addr (void * ptr)
{
  int make_unreadable.205;
  struct MonoAotModule * D.29426;
  _Bool D.29429;
  long int D.29430;
  long int D.29431;
  struct GHashTable * aot_modules.206;
  _Bool D.29437;
  long int D.29438;
  long int D.29439;
  struct FindMapUserData data;

  try
    {
      make_unreadable.205 = make_unreadable;
      if (make_unreadable.205 == 0) goto <D.29424>; else goto <D.29425>;
      <D.29424>:
      D.29426 = 0B;
      return D.29426;
      <D.29425>:
      data.module = 0B;
      data.ptr = ptr;
      {
        int ret;

        ret = pthread_mutex_lock (&aot_mutex.mutex);
        if (ret != 0) goto <D.29427>; else goto <D.29428>;
        <D.29427>:
        monoeg_g_log (0B, 16, "Bad call to mono_mutex_lock result %d", ret);
        <D.29428>:
        D.29429 = ret != 0;
        D.29430 = (long int) D.29429;
        D.29431 = __builtin_expect (D.29430, 0);
        if (D.29431 != 0) goto <D.29432>; else goto <D.29433>;
        <D.29432>:
        monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "aot-runtime.c", 4752, "ret == 0");
        <D.29433>:
      }
      aot_modules.206 = aot_modules;
      monoeg_g_hash_table_foreach (aot_modules.206, find_map, &data);
      {
        int ret;

        ret = pthread_mutex_unlock (&aot_mutex.mutex);
        if (ret != 0) goto <D.29435>; else goto <D.29436>;
        <D.29435>:
        monoeg_g_log (0B, 16, "Bad call to mono_mutex_unlock result %d", ret);
        <D.29436>:
        D.29437 = ret != 0;
        D.29438 = (long int) D.29437;
        D.29439 = __builtin_expect (D.29438, 0);
        if (D.29439 != 0) goto <D.29440>; else goto <D.29441>;
        <D.29440>:
        monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "aot-runtime.c", 4754, "ret == 0");
        <D.29441>:
      }
      D.29426 = data.module;
      return D.29426;
    }
  finally
    {
      data = {CLOBBER};
    }
}


find_map (void * key, void * value, void * user_data)
{
  struct MonoAotModule * D.29444;
  guint8 * D.29447;
  guint8 * D.29448;
  guint8 * D.29451;
  struct MonoAotModule * module;
  struct FindMapUserData * data;

  module = value;
  data = user_data;
  D.29444 = data->module;
  if (D.29444 == 0B) goto <D.29445>; else goto <D.29446>;
  <D.29445>:
  D.29447 = data->ptr;
  D.29448 = module->mem_begin;
  if (D.29447 >= D.29448) goto <D.29449>; else goto <D.29450>;
  <D.29449>:
  D.29447 = data->ptr;
  D.29451 = module->mem_end;
  if (D.29447 < D.29451) goto <D.29452>; else goto <D.29453>;
  <D.29452>:
  data->module = module;
  <D.29453>:
  <D.29450>:
  <D.29446>:
}


mono_aot_handle_pagefault (void * ptr)
{
  int D.29454;
  int D.29455;
  long int D.29456;
  long int ptr.207;
  long int D.29458;
  _Bool D.29461;
  long int D.29462;
  long int D.29463;
  int D.29466;
  long unsigned int D.29467;
  _Bool D.29468;
  long int D.29469;
  long int D.29470;
  unsigned int n_pagefaults.208;
  unsigned int n_pagefaults.209;
  _Bool D.29477;
  long int D.29478;
  long int D.29479;
  guint8 * start;
  int res;

  D.29454 = mono_pagesize ();
  D.29455 = -D.29454;
  D.29456 = (long int) D.29455;
  ptr.207 = (long int) ptr;
  D.29458 = D.29456 & ptr.207;
  start = (guint8 *) D.29458;
  {
    int ret;

    ret = pthread_mutex_lock (&aot_mutex.mutex);
    if (ret != 0) goto <D.29459>; else goto <D.29460>;
    <D.29459>:
    monoeg_g_log (0B, 16, "Bad call to mono_mutex_lock result %d", ret);
    <D.29460>:
    D.29461 = ret != 0;
    D.29462 = (long int) D.29461;
    D.29463 = __builtin_expect (D.29462, 0);
    if (D.29463 != 0) goto <D.29464>; else goto <D.29465>;
    <D.29464>:
    monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "aot-runtime.c", 4790, "ret == 0");
    <D.29465>:
  }
  D.29466 = mono_pagesize ();
  D.29467 = (long unsigned int) D.29466;
  res = mono_mprotect (start, D.29467, 7);
  D.29468 = res != 0;
  D.29469 = (long int) D.29468;
  D.29470 = __builtin_expect (D.29469, 0);
  if (D.29470 != 0) goto <D.29471>; else goto <D.29472>;
  <D.29471>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "aot-runtime.c", 4792, "res == 0");
  <D.29472>:
  n_pagefaults.208 = n_pagefaults;
  n_pagefaults.209 = n_pagefaults.208 + 1;
  n_pagefaults = n_pagefaults.209;
  {
    int ret;

    ret = pthread_mutex_unlock (&aot_mutex.mutex);
    if (ret != 0) goto <D.29475>; else goto <D.29476>;
    <D.29475>:
    monoeg_g_log (0B, 16, "Bad call to mono_mutex_unlock result %d", ret);
    <D.29476>:
    D.29477 = ret != 0;
    D.29478 = (long int) D.29477;
    D.29479 = __builtin_expect (D.29478, 0);
    if (D.29479 != 0) goto <D.29480>; else goto <D.29481>;
    <D.29480>:
    monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "aot-runtime.c", 4795, "ret == 0");
    <D.29481>:
  }
}