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.27032;
  _Bool D.27033;
  long int D.27034;
  long int D.27035;
  _Bool D.27038;
  long int D.27039;
  long int D.27040;
  struct GHashTable * aot_modules.0;
  _Bool D.27048;
  long int D.27049;
  long int D.27050;
  struct GHashTable * static_aot_modules.1;
  struct GHashTable * static_aot_modules.2;
  _Bool D.27061;
  long int D.27062;
  long int D.27063;
  void * * globals;
  char * aname;
  struct MonoAotFileInfo * info;

  info = aot_info;
  D.27032 = info->version;
  D.27033 = D.27032 != 97;
  D.27034 = (long int) D.27033;
  D.27035 = __builtin_expect (D.27034, 0);
  if (D.27035 != 0) goto <D.27036>; else goto <D.27037>;
  <D.27036>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "aot-runtime.c", 1889, "info->version == MONO_AOT_FILE_VERSION");
  <D.27037>:
  globals = info->globals;
  D.27038 = globals == 0B;
  D.27039 = (long int) D.27038;
  D.27040 = __builtin_expect (D.27039, 0);
  if (D.27040 != 0) goto <D.27041>; else goto <D.27042>;
  <D.27041>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "aot-runtime.c", 1892, "globals");
  <D.27042>:
  aname = info->assembly_name;
  aot_modules.0 = aot_modules;
  if (aot_modules.0 != 0B) goto <D.27044>; else goto <D.27045>;
  <D.27044>:
  {
    int ret;

    ret = pthread_mutex_lock (&aot_mutex.mutex);
    if (ret != 0) goto <D.27046>; else goto <D.27047>;
    <D.27046>:
    monoeg_g_log (0B, 16, "Bad call to mono_mutex_lock result %d", ret);
    <D.27047>:
    D.27048 = ret != 0;
    D.27049 = (long int) D.27048;
    D.27050 = __builtin_expect (D.27049, 0);
    if (D.27050 != 0) goto <D.27051>; else goto <D.27052>;
    <D.27051>:
    monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "aot-runtime.c", 1898, "ret == 0");
    <D.27052>:
  }
  <D.27045>:
  static_aot_modules.1 = static_aot_modules;
  if (static_aot_modules.1 == 0B) goto <D.27054>; else goto <D.27055>;
  <D.27054>:
  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.27055>:
  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.27057>; else goto <D.27058>;
  <D.27057>:
  {
    int ret;

    ret = pthread_mutex_unlock (&aot_mutex.mutex);
    if (ret != 0) goto <D.27059>; else goto <D.27060>;
    <D.27059>:
    monoeg_g_log (0B, 16, "Bad call to mono_mutex_unlock result %d", ret);
    <D.27060>:
    D.27061 = ret != 0;
    D.27062 = (long int) D.27061;
    D.27063 = __builtin_expect (D.27062, 0);
    if (D.27063 != 0) goto <D.27064>; else goto <D.27065>;
    <D.27064>:
    monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "aot-runtime.c", 1906, "ret == 0");
    <D.27065>:
  }
  <D.27058>:
}


mono_aot_init ()
{
  struct GHashTable * aot_modules.3;
  const gchar * D.27067;
  const gchar * D.27070;
  int mono_last_aot_method.4;
  const gchar * D.27072;

  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.27067 = monoeg_g_getenv ("MONO_LASTAOT");
  if (D.27067 != 0B) goto <D.27068>; else goto <D.27069>;
  <D.27068>:
  D.27070 = monoeg_g_getenv ("MONO_LASTAOT");
  mono_last_aot_method.4 = atoi (D.27070);
  mono_last_aot_method = mono_last_aot_method.4;
  <D.27069>:
  D.27072 = monoeg_g_getenv ("MONO_AOT_CACHE");
  if (D.27072 != 0B) goto <D.27073>; else goto <D.27074>;
  <D.27073>:
  use_aot_cache = 1;
  <D.27074>:
}


load_aot_module (struct MonoAssembly * assembly, void * user_data)
{
  int mono_compile_aot.5;
  struct MonoImage * D.27078;
  void * D.27079;
  unsigned char D.27084;
  unsigned char D.27085;
  int D.27087;
  <unnamed type> D.27088;
  _Bool D.27093;
  long int D.27094;
  long int D.27095;
  struct GHashTable * static_aot_modules.6;
  const char * D.27101;
  void * info.7;
  _Bool D.27106;
  long int D.27107;
  long int D.27108;
  struct MonoAotFileInfo * info.8;
  gchar * aot_name.9;
  char * aot_name.10;
  int use_aot_cache.11;
  char * D.27121;
  gchar * aot_name.12;
  char * err.13;
  _Bool D.27126;
  _Bool D.27127;
  _Bool D.27128;
  int mono_aot_only.14;
  unsigned int D.27134;
  unsigned int D.27135;
  struct _IO_FILE * stderr.15;
  char * version_symbol.16;
  _Bool D.27145;
  long int D.27146;
  long int D.27147;
  unsigned int D.27150;
  gchar * msg.17;
  char * msg.18;
  unsigned int D.27162;
  unsigned int align_double.19;
  _Bool D.27164;
  long int D.27165;
  long int D.27166;
  unsigned int D.27169;
  unsigned int align_int64.20;
  _Bool D.27171;
  long int D.27172;
  long int D.27173;
  unsigned int D.27176;
  _Bool D.27177;
  long int D.27178;
  long int D.27179;
  struct MonoAotFileInfo * D.27182;
  void * D.27183;
  void * * D.27184;
  struct GHashTable * D.27185;
  _Bool D.27186;
  long int D.27187;
  long int D.27188;
  unsigned int D.27191;
  void * D.27192;
  unsigned int D.27193;
  void * D.27194;
  void * D.27195;
  struct MonoAssemblyName * D.27196;
  unsigned int D.27197;
  gchar * D.27198;
  unsigned int D.27199;
  sizetype D.27200;
  char * * D.27201;
  unsigned int D.27202;
  char * * D.27203;
  gchar * D.27204;
  unsigned int D.27205;
  sizetype D.27206;
  char D.27207;
  gchar * D.27210;
  unsigned int D.27211;
  sizetype D.27212;
  mono_byte[17] * D.27213;
  unsigned int D.27214;
  unsigned int D.27215;
  unsigned int D.27216;
  sizetype D.27217;
  int table.21;
  int D.27219;
  int D.27220;
  unsigned int D.27221;
  short unsigned int D.27222;
  void * D.27223;
  void * D.27224;
  void * D.27225;
  guint8 * D.27226;
  int D.27227;
  int D.27228;
  guint8 * D.27229;
  void * D.27230;
  void * D.27231;
  void * D.27232;
  void * D.27233;
  void * D.27234;
  void * D.27235;
  void * D.27236;
  void * D.27237;
  void * D.27238;
  void * D.27239;
  void * D.27240;
  void * D.27241;
  void * D.27242;
  void * D.27243;
  void * D.27244;
  void * D.27245;
  void * D.27246;
  void * D.27247;
  void * D.27248;
  void * D.27249;
  int make_unreadable.22;
  guint8 * D.27253;
  int D.27254;
  guint8 * D.27255;
  int D.27256;
  int D.27257;
  sizetype D.27258;
  int D.27259;
  int D.27260;
  int addr.23;
  int D.27262;
  sizetype D.27263;
  sizetype D.27264;
  sizetype len.24;
  guint8 * D.27266;
  int D.27267;
  int D.27268;
  int D.27269;
  int D.27270;
  int page_end.25;
  int page_start.26;
  int D.27275;
  unsigned int D.27276;
  _Bool D.27277;
  long int D.27278;
  long int D.27279;
  _Bool D.27284;
  long int D.27285;
  long int D.27286;
  unsigned int D.27289;
  unsigned int aot_code_low_addr.27;
  unsigned int aot_code_low_addr.28;
  guint8 * D.27292;
  unsigned int D.27293;
  unsigned int aot_code_high_addr.29;
  unsigned int aot_code_high_addr.30;
  struct GHashTable * aot_modules.31;
  _Bool D.27299;
  long int D.27300;
  long int D.27301;
  struct MonoDl * D.27306;
  void * * D.27307;
  char * code.32;
  _Bool D.27309;
  int D.27310;
  struct MonoImage * D.27311;
  void * * D.27314;
  void * * D.27315;
  int D.27317;
  void * * D.27320;
  struct MonoDomain * D.27321;
  void * D.27322;
  unsigned int i.33;
  unsigned int D.27326;
  int D.27327;
  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.27076>; else goto <D.27077>;
      <D.27076>:
      return;
      <D.27077>:
      D.27078 = assembly->image;
      D.27079 = D.27078->aot_module;
      if (D.27079 != 0B) goto <D.27080>; else goto <D.27081>;
      <D.27080>:
      return;
      <D.27081>:
      D.27078 = assembly->image;
      D.27084 = BIT_FIELD_REF <*D.27078, 8, 128>;
      D.27085 = D.27084 & 8;
      if (D.27085 != 0) goto <D.27082>; else goto <D.27086>;
      <D.27086>:
      D.27087 = assembly->ref_only;
      if (D.27087 != 0) goto <D.27082>; else goto <D.27083>;
      <D.27082>:
      return;
      <D.27083>:
      D.27088 = mono_security_get_mode ();
      if (D.27088 == 2) goto <D.27089>; else goto <D.27090>;
      <D.27089>:
      return;
      <D.27090>:
      {
        int ret;

        ret = pthread_mutex_lock (&aot_mutex.mutex);
        if (ret != 0) goto <D.27091>; else goto <D.27092>;
        <D.27091>:
        monoeg_g_log (0B, 16, "Bad call to mono_mutex_lock result %d", ret);
        <D.27092>:
        D.27093 = ret != 0;
        D.27094 = (long int) D.27093;
        D.27095 = __builtin_expect (D.27094, 0);
        if (D.27095 != 0) goto <D.27096>; else goto <D.27097>;
        <D.27096>:
        monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "aot-runtime.c", 1577, "ret == 0");
        <D.27097>:
      }
      static_aot_modules.6 = static_aot_modules;
      if (static_aot_modules.6 != 0B) goto <D.27099>; else goto <D.27100>;
      <D.27099>:
      static_aot_modules.6 = static_aot_modules;
      D.27101 = assembly->aname.name;
      info.7 = monoeg_g_hash_table_lookup (static_aot_modules.6, D.27101);
      info = info.7;
      goto <D.27103>;
      <D.27100>:
      info = 0B;
      <D.27103>:
      {
        int ret;

        ret = pthread_mutex_unlock (&aot_mutex.mutex);
        if (ret != 0) goto <D.27104>; else goto <D.27105>;
        <D.27104>:
        monoeg_g_log (0B, 16, "Bad call to mono_mutex_unlock result %d", ret);
        <D.27105>:
        D.27106 = ret != 0;
        D.27107 = (long int) D.27106;
        D.27108 = __builtin_expect (D.27107, 0);
        if (D.27108 != 0) goto <D.27109>; else goto <D.27110>;
        <D.27109>:
        monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "aot-runtime.c", 1582, "ret == 0");
        <D.27110>:
      }
      info.8 = info;
      if (info.8 != 0B) goto <D.27112>; else goto <D.27113>;
      <D.27112>:
      sofile = 0B;
      D.27101 = assembly->aname.name;
      aot_name.9 = monoeg_g_strdup_printf ("%s", D.27101);
      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.27116>;
      <D.27113>:
      use_aot_cache.11 = use_aot_cache;
      if (use_aot_cache.11 != 0) goto <D.27118>; else goto <D.27119>;
      <D.27118>:
      sofile = load_aot_module_from_cache (assembly, &aot_name);
      goto <D.27120>;
      <D.27119>:
      {
        char * err;

        try
          {
            D.27078 = assembly->image;
            D.27121 = D.27078->name;
            aot_name.12 = monoeg_g_strdup_printf ("%s%s", D.27121, ".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.27123>; else goto <D.27124>;
            <D.27123>:
            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.27124>:
          }
        finally
          {
            err = {CLOBBER};
          }
      }
      <D.27120>:
      <D.27116>:
      D.27126 = sofile == 0B;
      D.27127 = globals == 0B;
      D.27128 = D.27126 & D.27127;
      if (D.27128 != 0) goto <D.27129>; else goto <D.27130>;
      <D.27129>:
      mono_aot_only.14 = mono_aot_only;
      if (mono_aot_only.14 != 0) goto <D.27132>; else goto <D.27133>;
      <D.27132>:
      D.27078 = assembly->image;
      D.27134 = BIT_FIELD_REF <*D.27078, 32, 1408>;
      D.27135 = D.27134 & 16777215;
      if (D.27135 != 0) goto <D.27136>; else goto <D.27137>;
      <D.27136>:
      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.27137>:
      <D.27133>:
      aot_name.10 = aot_name;
      monoeg_g_free (aot_name.10);
      return;
      <D.27130>:
      info.8 = info;
      if (info.8 == 0B) goto <D.27139>; else goto <D.27140>;
      <D.27139>:
      find_symbol (sofile, globals, "mono_aot_version", &version_symbol);
      find_symbol (sofile, globals, "mono_aot_file_info", &info);
      <D.27140>:
      version_symbol.16 = version_symbol;
      if (version_symbol.16 != 0B) goto <D.27142>; else goto <D.27143>;
      <D.27142>:
      version_symbol.16 = version_symbol;
      version = atoi (version_symbol.16);
      goto <D.27144>;
      <D.27143>:
      info.8 = info;
      D.27145 = info.8 == 0B;
      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", 1624, "info");
      <D.27149>:
      info.8 = info;
      D.27150 = info.8->version;
      version = (int) D.27150;
      <D.27144>:
      if (version != 97) goto <D.27151>; else goto <D.27152>;
      <D.27151>:
      msg.17 = monoeg_g_strdup_printf ("wrong file format version (expected %d got %d)", 97, version);
      msg = msg.17;
      usable = 0;
      goto <D.27154>;
      <D.27152>:
      info.8 = info;
      usable = check_usable (assembly, info.8, &msg);
      <D.27154>:
      if (usable == 0) goto <D.27155>; else goto <D.27156>;
      <D.27155>:
      mono_aot_only.14 = mono_aot_only;
      if (mono_aot_only.14 != 0) goto <D.27157>; else goto <D.27158>;
      <D.27157>:
      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.27158>:
      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.27160>; else goto <D.27161>;
      <D.27160>:
      mono_dl_close (sofile);
      <D.27161>:
      D.27078 = assembly->image;
      D.27078->aot_module = 0B;
      return;
      <D.27156>:
      align_double = 8;
      align_int64 = 8;
      info.8 = info;
      D.27162 = info.8->double_align;
      align_double.19 = (unsigned int) align_double;
      D.27164 = D.27162 != align_double.19;
      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", 1670, "info->double_align == align_double");
      <D.27168>:
      info.8 = info;
      D.27169 = info.8->long_align;
      align_int64.20 = (unsigned int) align_int64;
      D.27171 = D.27169 != align_int64.20;
      D.27172 = (long int) D.27171;
      D.27173 = __builtin_expect (D.27172, 0);
      if (D.27173 != 0) goto <D.27174>; else goto <D.27175>;
      <D.27174>:
      monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "aot-runtime.c", 1671, "info->long_align == align_int64");
      <D.27175>:
      info.8 = info;
      D.27176 = info.8->generic_tramp_num;
      D.27177 = D.27176 != 14;
      D.27178 = (long int) D.27177;
      D.27179 = __builtin_expect (D.27178, 0);
      if (D.27179 != 0) goto <D.27180>; else goto <D.27181>;
      <D.27180>:
      monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "aot-runtime.c", 1672, "info->generic_tramp_num == MONO_TRAMPOLINE_NUM");
      <D.27181>:
      info.8 = info;
      blob = info.8->blob;
      amodule = monoeg_malloc0 (440);
      aot_name.10 = aot_name;
      amodule->aot_name = aot_name.10;
      amodule->assembly = assembly;
      D.27182 = &amodule->info;
      info.8 = info;
      memcpy (D.27182, info.8, 244);
      D.27183 = amodule->info.got;
      amodule->got = D.27183;
      D.27184 = amodule->got;
      D.27078 = assembly->image;
      *D.27184 = D.27078;
      amodule->globals = globals;
      amodule->sofile = sofile;
      D.27185 = monoeg_g_hash_table_new (mono_aligned_addr_hash, 0B);
      amodule->method_to_code = D.27185;
      amodule->blob = blob;
      {
        guint32 table_len;
        guint32 i;
        char * table;

        table = 0B;
        info.8 = info;
        table = info.8->image_table;
        D.27186 = table == 0B;
        D.27187 = (long int) D.27186;
        D.27188 = __builtin_expect (D.27187, 0);
        if (D.27188 != 0) goto <D.27189>; else goto <D.27190>;
        <D.27189>:
        monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "aot-runtime.c", 1695, "table");
        <D.27190>:
        table_len = MEM[(guint32 *)table];
        table = table + 4;
        D.27191 = table_len * 4;
        D.27192 = monoeg_malloc0 (D.27191);
        amodule->image_table = D.27192;
        D.27193 = table_len * 60;
        D.27194 = monoeg_malloc0 (D.27193);
        amodule->image_names = D.27194;
        D.27191 = table_len * 4;
        D.27195 = monoeg_malloc0 (D.27191);
        amodule->image_guids = D.27195;
        amodule->image_table_len = table_len;
        i = 0;
        goto <D.25976>;
        <D.25975>:
        {
          struct MonoAssemblyName * aname;

          D.27196 = amodule->image_names;
          D.27197 = i * 60;
          aname = D.27196 + D.27197;
          D.27198 = monoeg_strdup (table);
          aname->name = D.27198;
          D.27199 = strlen (table);
          D.27200 = D.27199 + 1;
          table = table + D.27200;
          D.27201 = amodule->image_guids;
          D.27202 = i * 4;
          D.27203 = D.27201 + D.27202;
          D.27204 = monoeg_strdup (table);
          *D.27203 = D.27204;
          D.27205 = strlen (table);
          D.27206 = D.27205 + 1;
          table = table + D.27206;
          D.27207 = *table;
          if (D.27207 != 0) goto <D.27208>; else goto <D.27209>;
          <D.27208>:
          D.27210 = monoeg_strdup (table);
          aname->culture = D.27210;
          <D.27209>:
          D.27211 = strlen (table);
          D.27212 = D.27211 + 1;
          table = table + D.27212;
          D.27213 = &aname->public_key_token;
          D.27214 = strlen (table);
          D.27215 = D.27214 + 1;
          memcpy (D.27213, table, D.27215);
          D.27216 = strlen (table);
          D.27217 = D.27216 + 1;
          table = table + D.27217;
          table.21 = (int) table;
          D.27219 = table.21 + 7;
          D.27220 = D.27219 & -8;
          table = (char *) D.27220;
          D.27221 = MEM[(guint32 *)table];
          aname->flags = D.27221;
          table = table + 4;
          D.27221 = MEM[(guint32 *)table];
          D.27222 = (short unsigned int) D.27221;
          aname->major = D.27222;
          table = table + 4;
          D.27221 = MEM[(guint32 *)table];
          D.27222 = (short unsigned int) D.27221;
          aname->minor = D.27222;
          table = table + 4;
          D.27221 = MEM[(guint32 *)table];
          D.27222 = (short unsigned int) D.27221;
          aname->build = D.27222;
          table = table + 4;
          D.27221 = MEM[(guint32 *)table];
          D.27222 = (short unsigned int) D.27221;
          aname->revision = D.27222;
          table = table + 4;
        }
        i = i + 1;
        <D.25976>:
        if (i < table_len) goto <D.25975>; else goto <D.25977>;
        <D.25977>:
      }
      info.8 = info;
      D.27223 = info.8->code_offsets;
      amodule->code_offsets = D.27223;
      info.8 = info;
      D.27224 = info.8->method_addresses;
      amodule->method_addresses = D.27224;
      info.8 = info;
      D.27225 = info.8->methods;
      amodule->code = D.27225;
      D.27226 = amodule->code;
      D.27227 = (int) D.27226;
      D.27228 = D.27227 & -2;
      D.27229 = (guint8 *) D.27228;
      amodule->code = D.27229;
      info.8 = info;
      D.27230 = info.8->methods_end;
      amodule->code_end = D.27230;
      info.8 = info;
      D.27231 = info.8->method_info_offsets;
      amodule->method_info_offsets = D.27231;
      info.8 = info;
      D.27232 = info.8->ex_info_offsets;
      amodule->ex_info_offsets = D.27232;
      info.8 = info;
      D.27233 = info.8->class_info_offsets;
      amodule->class_info_offsets = D.27233;
      info.8 = info;
      D.27234 = info.8->class_name_table;
      amodule->class_name_table = D.27234;
      info.8 = info;
      D.27235 = info.8->extra_method_table;
      amodule->extra_method_table = D.27235;
      info.8 = info;
      D.27236 = info.8->extra_method_info_offsets;
      amodule->extra_method_info_offsets = D.27236;
      info.8 = info;
      D.27237 = info.8->unbox_trampolines;
      amodule->unbox_trampolines = D.27237;
      info.8 = info;
      D.27238 = info.8->unbox_trampolines_end;
      amodule->unbox_trampolines_end = D.27238;
      info.8 = info;
      D.27239 = info.8->got_info_offsets;
      amodule->got_info_offsets = D.27239;
      info.8 = info;
      D.27240 = info.8->unwind_info;
      amodule->unwind_info = D.27240;
      info.8 = info;
      D.27241 = info.8->mem_end;
      amodule->mem_end = D.27241;
      D.27226 = amodule->code;
      amodule->mem_begin = D.27226;
      info.8 = info;
      D.27242 = info.8->plt;
      amodule->plt = D.27242;
      info.8 = info;
      D.27243 = info.8->plt_end;
      amodule->plt_end = D.27243;
      info.8 = info;
      D.27244 = info.8->mono_eh_frame;
      amodule->mono_eh_frame = D.27244;
      info.8 = info;
      D.27245 = info.8->specific_trampolines;
      amodule->trampolines[0] = D.27245;
      info.8 = info;
      D.27246 = info.8->static_rgctx_trampolines;
      amodule->trampolines[1] = D.27246;
      info.8 = info;
      D.27247 = info.8->imt_thunks;
      amodule->trampolines[2] = D.27247;
      info.8 = info;
      D.27248 = info.8->gsharedvt_arg_trampolines;
      amodule->trampolines[3] = D.27248;
      info.8 = info;
      D.27249 = info.8->thumb_end;
      amodule->thumb_end = D.27249;
      make_unreadable.22 = make_unreadable;
      if (make_unreadable.22 != 0) goto <D.27251>; else goto <D.27252>;
      <D.27251>:
      {
        guint8 * addr;
        guint8 * page_start;
        guint8 * page_end;
        int err;
        int len;

        addr = amodule->mem_begin;
        D.27253 = amodule->mem_end;
        D.27254 = (int) D.27253;
        D.27255 = amodule->mem_begin;
        D.27256 = (int) D.27255;
        len = D.27254 - D.27256;
        D.27257 = mono_pagesize ();
        D.27258 = (sizetype) D.27257;
        D.27259 = mono_pagesize ();
        D.27260 = -D.27259;
        addr.23 = (int) addr;
        D.27262 = D.27260 & addr.23;
        D.27263 = (sizetype) D.27262;
        D.27264 = D.27258 + D.27263;
        page_start = (guint8 *) D.27264;
        len.24 = (sizetype) len;
        D.27266 = addr + len.24;
        D.27267 = (int) D.27266;
        D.27268 = mono_pagesize ();
        D.27269 = -D.27268;
        D.27270 = D.27267 & D.27269;
        page_end = (guint8 *) D.27270;
        if (page_end > page_start) goto <D.27271>; else goto <D.27272>;
        <D.27271>:
        page_end.25 = (int) page_end;
        page_start.26 = (int) page_start;
        D.27275 = page_end.25 - page_start.26;
        D.27276 = (unsigned int) D.27275;
        err = mono_mprotect (page_start, D.27276, 0);
        D.27277 = err != 0;
        D.27278 = (long int) D.27277;
        D.27279 = __builtin_expect (D.27278, 0);
        if (D.27279 != 0) goto <D.27280>; else goto <D.27281>;
        <D.27280>:
        monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "aot-runtime.c", 1789, "err == 0");
        <D.27281>:
        <D.27272>:
      }
      <D.27252>:
      {
        int ret;

        ret = pthread_mutex_lock (&aot_mutex.mutex);
        if (ret != 0) goto <D.27282>; else goto <D.27283>;
        <D.27282>:
        monoeg_g_log (0B, 16, "Bad call to mono_mutex_lock result %d", ret);
        <D.27283>:
        D.27284 = ret != 0;
        D.27285 = (long int) D.27284;
        D.27286 = __builtin_expect (D.27285, 0);
        if (D.27286 != 0) goto <D.27287>; else goto <D.27288>;
        <D.27287>:
        monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "aot-runtime.c", 1794, "ret == 0");
        <D.27288>:
      }
      D.27226 = amodule->code;
      D.27289 = (unsigned int) D.27226;
      aot_code_low_addr.27 = aot_code_low_addr;
      aot_code_low_addr.28 = MIN_EXPR <D.27289, aot_code_low_addr.27>;
      aot_code_low_addr = aot_code_low_addr.28;
      D.27292 = amodule->code_end;
      D.27293 = (unsigned int) D.27292;
      aot_code_high_addr.29 = aot_code_high_addr;
      aot_code_high_addr.30 = MAX_EXPR <D.27293, aot_code_high_addr.29>;
      aot_code_high_addr = aot_code_high_addr.30;
      aot_modules.31 = aot_modules;
      monoeg_g_hash_table_insert_replace (aot_modules.31, assembly, amodule, 0);
      {
        int ret;

        ret = pthread_mutex_unlock (&aot_mutex.mutex);
        if (ret != 0) goto <D.27297>; else goto <D.27298>;
        <D.27297>:
        monoeg_g_log (0B, 16, "Bad call to mono_mutex_unlock result %d", ret);
        <D.27298>:
        D.27299 = ret != 0;
        D.27300 = (long int) D.27299;
        D.27301 = __builtin_expect (D.27300, 0);
        if (D.27301 != 0) goto <D.27302>; else goto <D.27303>;
        <D.27302>:
        monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "aot-runtime.c", 1800, "ret == 0");
        <D.27303>:
      }
      D.27078 = assembly->image;
      D.27226 = amodule->code;
      D.27292 = amodule->code_end;
      mono_jit_info_add_aot_module (D.27078, D.27226, D.27292);
      D.27078 = assembly->image;
      D.27078->aot_module = amodule;
      mono_aot_only.14 = mono_aot_only;
      if (mono_aot_only.14 != 0) goto <D.27304>; else goto <D.27305>;
      <D.27304>:
      {
        char * code;

        try
          {
            D.27306 = amodule->sofile;
            D.27307 = amodule->globals;
            find_symbol (D.27306, D.27307, "specific_trampolines_page", &code);
            code.32 = code;
            D.27309 = code.32 != 0B;
            D.27310 = (int) D.27309;
            amodule->use_page_trampolines = D.27310;
            D.27311 = mono_defaults.corlib;
            if (D.27311 != 0B) goto <D.27312>; else goto <D.27313>;
            <D.27312>:
            {
              struct MonoAotModule * mscorlib_amodule;

              D.27311 = mono_defaults.corlib;
              mscorlib_amodule = D.27311->aot_module;
              D.27184 = amodule->got;
              D.27314 = D.27184 + 4;
              D.27315 = mscorlib_amodule->got;
              *D.27314 = D.27315;
            }
            goto <D.27316>;
            <D.27313>:
            D.27184 = amodule->got;
            D.27314 = D.27184 + 4;
            D.27184 = amodule->got;
            *D.27314 = D.27184;
            <D.27316>:
          }
        finally
          {
            code = {CLOBBER};
          }
      }
      <D.27305>:
      D.27317 = mono_gc_is_moving ();
      if (D.27317 != 0) goto <D.27318>; else goto <D.27319>;
      <D.27318>:
      {
        struct MonoJumpInfo ji;

        try
          {
            memset (&ji, 0, 20);
            ji.type = 42;
            D.27184 = amodule->got;
            D.27320 = D.27184 + 8;
            D.27321 = mono_get_root_domain ();
            D.27322 = mono_resolve_patch_target (0B, D.27321, 0B, &ji, 0);
            *D.27320 = D.27322;
          }
        finally
          {
            ji = {CLOBBER};
          }
      }
      <D.27319>:
      if (do_load_image != 0) goto <D.27323>; else goto <D.27324>;
      <D.27323>:
      i = 0;
      goto <D.25989>;
      <D.25988>:
      load_image (amodule, i, 0);
      i = i + 1;
      <D.25989>:
      i.33 = (unsigned int) i;
      D.27326 = amodule->image_table_len;
      if (i.33 < D.27326) goto <D.25988>; else goto <D.25990>;
      <D.25990>:
      <D.27324>:
      D.27327 = amodule->out_of_date;
      if (D.27327 != 0) goto <D.27328>; else goto <D.27329>;
      <D.27328>:
      D.27078 = assembly->image;
      D.27121 = D.27078->name;
      mono_trace (64, 32, "AOT Module %s is unusable because a dependency is out-of-date.\n", D.27121);
      mono_aot_only.14 = mono_aot_only;
      if (mono_aot_only.14 != 0) goto <D.27330>; else goto <D.27331>;
      <D.27330>:
      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.27331>:
      goto <D.27332>;
      <D.27329>:
      D.27078 = assembly->image;
      D.27121 = D.27078->name;
      mono_trace (64, 32, "AOT loaded AOT Module for %s.\n", D.27121);
      <D.27332>:
    }
  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.27336;
  unsigned char D.27337;
  unsigned char D.27338;
  struct MonoDl * D.27341;
  const char * D.27342;
  char * D.27343;
  char * D.27346;
  int spawn_compiler.34;
  int exit_status.35;
  int D.27355;
  int D.27357;
  int D.27358;
  gchar * err.36;
  gchar * out.37;
  int D.27363;
  unsigned int D.27364;
  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.27336 = assembly->image;
      D.27337 = BIT_FIELD_REF <*D.27336, 8, 128>;
      D.27338 = D.27337 & 8;
      if (D.27338 != 0) goto <D.27339>; else goto <D.27340>;
      <D.27339>:
      D.27341 = 0B;
      return D.27341;
      <D.27340>:
      create_cache_structure ();
      home = monoeg_g_get_home_dir ();
      D.27336 = assembly->image;
      D.27342 = D.27336->assembly_name;
      D.27336 = assembly->image;
      D.27343 = D.27336->guid;
      tmp2 = monoeg_g_strdup_printf ("%s-%s%s", D.27342, D.27343, ".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.27344>; else goto <D.27345>;
      <D.27344>:
      mono_trace (64, 32, "AOT not found.");
      D.27336 = assembly->image;
      D.27346 = D.27336->name;
      mono_trace (32, 32, "AOT precompiling assembly \'%s\'... ", D.27346);
      aot_options = monoeg_g_strdup_printf ("outfile=%s", fname);
      spawn_compiler.34 = spawn_compiler;
      if (spawn_compiler.34 != 0) goto <D.27348>; else goto <D.27349>;
      <D.27348>:
      D.27336 = assembly->image;
      D.27346 = D.27336->name;
      cmd = monoeg_g_strdup_printf ("mono -O=all --aot=%s %s", aot_options, D.27346);
      res = monoeg_g_spawn_command_line_sync (cmd, &out, &err, &exit_status, 0B);
      if (res != 0) goto <D.27350>; else goto <D.27351>;
      <D.27350>:
      exit_status.35 = exit_status;
      D.27355 = exit_status.35 & 127;
      if (D.27355 != 0) goto <D.27356>; else goto <D.27352>;
      <D.27356>:
      exit_status.35 = exit_status;
      D.27357 = exit_status.35 & 65280;
      D.27358 = D.27357 >> 8;
      if (D.27358 == 0) goto <D.27359>; else goto <D.27352>;
      <D.27359>:
      err.36 = err;
      mono_trace (32, 32, "AOT failed: %s.", err.36);
      goto <D.27353>;
      <D.27352>:
      mono_trace (32, 32, "AOT succeeded.");
      <D.27353>:
      out.37 = out;
      monoeg_g_free (out.37);
      err.36 = err;
      monoeg_g_free (err.36);
      <D.27351>:
      monoeg_g_free (cmd);
      goto <D.27362>;
      <D.27349>:
      D.27363 = mono_parse_default_optimizations (0B);
      D.27364 = (unsigned int) D.27363;
      res = mono_compile_assembly (assembly, D.27364, aot_options);
      if (res == 0) goto <D.27365>; else goto <D.27366>;
      <D.27365>:
      mono_trace (32, 32, "AOT failed.");
      goto <D.27367>;
      <D.27366>:
      mono_trace (32, 32, "AOT succeeded.");
      <D.27367>:
      <D.27362>:
      module = mono_dl_open (fname, 1, 0B);
      monoeg_g_free (aot_options);
      <D.27345>:
      D.27341 = module;
      return D.27341;
    }
  finally
    {
      out = {CLOBBER};
      err = {CLOBBER};
      exit_status = {CLOBBER};
    }
}


create_cache_structure ()
{
  int D.27372;
  int * D.27377;
  int D.27378;
  const gchar * D.27379;
  int D.27380;
  const gchar * D.27385;
  const char * home;
  char * tmp;
  int err;

  home = monoeg_g_get_home_dir ();
  if (home == 0B) goto <D.27370>; else goto <D.27371>;
  <D.27370>:
  return;
  <D.27371>:
  tmp = monoeg_g_build_path ("/", home, ".mono", 0B);
  D.27372 = monoeg_g_file_test (tmp, 4);
  if (D.27372 == 0) goto <D.27373>; else goto <D.27374>;
  <D.27373>:
  mono_trace (64, 32, "AOT creating directory %s", tmp);
  err = mkdir (tmp, 511);
  if (err != 0) goto <D.27375>; else goto <D.27376>;
  <D.27375>:
  D.27377 = __errno_location ();
  D.27378 = *D.27377;
  D.27379 = monoeg_g_strerror (D.27378);
  mono_trace (64, 32, "AOT failed: %s", D.27379);
  monoeg_g_free (tmp);
  return;
  <D.27376>:
  <D.27374>:
  monoeg_g_free (tmp);
  tmp = monoeg_g_build_path ("/", home, ".mono", "aot-cache", 0B);
  D.27380 = monoeg_g_file_test (tmp, 4);
  if (D.27380 == 0) goto <D.27381>; else goto <D.27382>;
  <D.27381>:
  mono_trace (64, 32, "AOT creating directory %s", tmp);
  err = mkdir (tmp, 511);
  if (err != 0) goto <D.27383>; else goto <D.27384>;
  <D.27383>:
  D.27377 = __errno_location ();
  D.27378 = *D.27377;
  D.27385 = monoeg_g_strerror (D.27378);
  mono_trace (64, 32, "AOT failed: %s", D.27385);
  monoeg_g_free (tmp);
  return;
  <D.27384>:
  <D.27382>:
  monoeg_g_free (tmp);
}


check_usable (struct MonoAssembly * assembly, struct MonoAotFileInfo * info, char * * out_msg)
{
  int D.25924;
  struct MonoImage * D.27387;
  char * D.27388;
  void * D.27389;
  void * D.27392;
  char D.27393;
  int D.25933;
  unsigned int D.27398;
  int D.27399;
  int mono_aot_only.38;
  unsigned int D.27409;
  int mono_use_llvm.39;
  struct MonoDebugOptions * D.27419;
  int D.27420;
  unsigned int D.27423;
  unsigned int D.27428;
  unsigned int excluded_cpu_optimizations.40;
  unsigned int D.27430;
  unsigned int D.27435;
  unsigned int D.27436;
  unsigned int D.27437;
  unsigned int D.27438;
  int D.27441;
  sizetype D.27444;
  int D.25944;
  gboolean D.27447;
  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.27387 = assembly->image;
        D.27388 = D.27387->guid;
        D.27389 = info->assembly_guid;
        D.25924 = __builtin_strcmp (D.27388, D.27389);
      }
      if (D.25924 != 0) goto <D.27390>; else goto <D.27391>;
      <D.27390>:
      msg = monoeg_g_strdup_printf ("doesn\'t match assembly");
      usable = 0;
      <D.27391>:
      build_info = mono_get_runtime_build_info ();
      D.27392 = info->runtime_version;
      D.27393 = MEM[(const char *)D.27392];
      if (D.27393 != 0) goto <D.27394>; else goto <D.27395>;
      <D.27394>:
      {
        size_t __s1_len;
        size_t __s2_len;

        D.27392 = info->runtime_version;
        D.25933 = __builtin_strcmp (D.27392, build_info);
      }
      if (D.25933 != 0) goto <D.27396>; else goto <D.27397>;
      <D.27396>:
      D.27392 = info->runtime_version;
      msg = monoeg_g_strdup_printf ("compiled against runtime version \'%s\' while this runtime has version \'%s\'", D.27392, build_info);
      usable = 0;
      <D.27397>:
      <D.27395>:
      monoeg_g_free (build_info);
      D.27398 = info->flags;
      D.27399 = (int) D.27398;
      full_aot = D.27399 & 2;
      mono_aot_only.38 = mono_aot_only;
      if (mono_aot_only.38 != 0) goto <D.27401>; else goto <D.27402>;
      <D.27401>:
      if (full_aot == 0) goto <D.27403>; else goto <D.27404>;
      <D.27403>:
      msg = monoeg_g_strdup_printf ("not compiled with --aot=full");
      usable = 0;
      <D.27404>:
      <D.27402>:
      mono_aot_only.38 = mono_aot_only;
      if (mono_aot_only.38 == 0) goto <D.27405>; else goto <D.27406>;
      <D.27405>:
      if (full_aot != 0) goto <D.27407>; else goto <D.27408>;
      <D.27407>:
      msg = monoeg_g_strdup_printf ("compiled with --aot=full");
      usable = 0;
      <D.27408>:
      <D.27406>:
      D.27398 = info->flags;
      D.27409 = D.27398 & 1;
      if (D.27409 != 0) goto <D.27410>; else goto <D.27411>;
      <D.27410>:
      mono_use_llvm.39 = mono_use_llvm;
      if (mono_use_llvm.39 == 0) goto <D.27413>; else goto <D.27414>;
      <D.27413>:
      msg = monoeg_g_strdup_printf ("compiled against LLVM");
      usable = 0;
      <D.27414>:
      <D.27411>:
      D.27398 = info->flags;
      D.27409 = D.27398 & 1;
      if (D.27409 == 0) goto <D.27415>; else goto <D.27416>;
      <D.27415>:
      mono_use_llvm.39 = mono_use_llvm;
      if (mono_use_llvm.39 != 0) goto <D.27417>; else goto <D.27418>;
      <D.27417>:
      msg = monoeg_g_strdup_printf ("not compiled against LLVM");
      usable = 0;
      <D.27418>:
      <D.27416>:
      D.27419 = mini_get_debug_options ();
      D.27420 = D.27419->mdb_optimizations;
      if (D.27420 != 0) goto <D.27421>; else goto <D.27422>;
      <D.27421>:
      D.27398 = info->flags;
      D.27423 = D.27398 & 4;
      if (D.27423 == 0) goto <D.27424>; else goto <D.27425>;
      <D.27424>:
      if (full_aot == 0) goto <D.27426>; else goto <D.27427>;
      <D.27426>:
      msg = monoeg_g_strdup_printf ("not compiled for debugging");
      usable = 0;
      <D.27427>:
      <D.27425>:
      <D.27422>:
      mono_arch_cpu_optimizations (&excluded_cpu_optimizations);
      D.27428 = info->opts;
      excluded_cpu_optimizations.40 = excluded_cpu_optimizations;
      D.27430 = D.27428 & excluded_cpu_optimizations.40;
      if (D.27430 != 0) goto <D.27431>; else goto <D.27432>;
      <D.27431>:
      msg = monoeg_g_strdup_printf ("compiled with unsupported CPU optimizations");
      usable = 0;
      <D.27432>:
      mono_aot_only.38 = mono_aot_only;
      if (mono_aot_only.38 == 0) goto <D.27433>; else goto <D.27434>;
      <D.27433>:
      D.27435 = info->simd_opts;
      D.27436 = mono_arch_cpu_enumerate_simd_versions ();
      D.27437 = ~D.27436;
      D.27438 = D.27435 & D.27437;
      if (D.27438 != 0) goto <D.27439>; else goto <D.27440>;
      <D.27439>:
      msg = monoeg_g_strdup_printf ("compiled with unsupported SIMD extensions");
      usable = 0;
      <D.27440>:
      <D.27434>:
      blob = info->blob;
      D.27441 = info->gc_name_index;
      if (D.27441 != -1) goto <D.27442>; else goto <D.27443>;
      <D.27442>:
      {
        char * gc_name;
        const char * current_gc_name;

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

          D.25944 = __builtin_strcmp (current_gc_name, gc_name);
        }
        if (D.25944 != 0) goto <D.27445>; else goto <D.27446>;
        <D.27445>:
        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.27446>:
      }
      <D.27443>:
      *out_msg = msg;
      D.27447 = usable;
      return D.27447;
    }
  finally
    {
      excluded_cpu_optimizations = {CLOBBER};
    }
}


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

  if (str != 0B) goto <D.27450>; else goto <D.27451>;
  <D.27450>:
  D.27452 = __strdup (str);
  return D.27452;
  <D.27451>:
  D.27452 = 0B;
  return D.27452;
}


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

  D.27455 = __builtin_object_size (__dest, 0);
  D.27454 = __builtin___memcpy_chk (__dest, __src, __len, D.27455);
  return D.27454;
}


find_symbol (struct MonoDl * module, void * * globals, const char * name, void * * value)
{
  unsigned int D.27459;
  unsigned int D.27460;
  unsigned int D.27461;
  short unsigned int D.27462;
  int D.27463;
  int D.27464;
  guint16 * D.27465;
  short unsigned int D.27466;
  int D.25900;
  unsigned int D.27467;
  void * * D.27468;
  void * D.27469;
  unsigned int D.27473;
  sizetype global_index.41;
  sizetype D.27477;
  sizetype D.27478;
  void * * D.27479;
  void * D.27480;

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

    symbol = name;
    table = *globals;
    globals = globals + 4;
    table_size = *table;
    table = table + 2;
    D.27459 = mono_metadata_str_hash (symbol);
    D.27460 = (unsigned int) table_size;
    hash = D.27459 % D.27460;
    D.27461 = hash * 4;
    entry = table + D.27461;
    global_index = -1;
    goto <D.25903>;
    <D.25902>:
    {
      guint32 index;
      guint32 next;

      D.27462 = *entry;
      D.27463 = (int) D.27462;
      D.27464 = D.27463 + -1;
      index = (guint32) D.27464;
      D.27465 = entry + 2;
      D.27466 = *D.27465;
      next = (guint32) D.27466;
      {
        size_t __s1_len;
        size_t __s2_len;

        D.27467 = index * 8;
        D.27468 = globals + D.27467;
        D.27469 = *D.27468;
        D.25900 = __builtin_strcmp (D.27469, symbol);
      }
      if (D.25900 == 0) goto <D.27470>; else goto <D.27471>;
      <D.27470>:
      global_index = (int) index;
      goto <D.25901>;
      <D.27471>:
      if (next != 0) goto <D.27472>; else goto <D.25901>;
      <D.27472>:
      D.27473 = next * 4;
      entry = table + D.27473;
    }
    <D.25903>:
    D.27462 = *entry;
    if (D.27462 != 0) goto <D.25902>; else goto <D.25901>;
    <D.25901>:
    if (global_index != -1) goto <D.27474>; else goto <D.27475>;
    <D.27474>:
    global_index.41 = (sizetype) global_index;
    D.27477 = global_index.41 * 8;
    D.27478 = D.27477 + 4;
    D.27479 = globals + D.27478;
    D.27480 = *D.27479;
    *value = D.27480;
    goto <D.27481>;
    <D.27475>:
    *value = 0B;
    <D.27481>:
    if (symbol != name) goto <D.27482>; else goto <D.27483>;
    <D.27482>:
    monoeg_g_free (symbol);
    <D.27483>:
  }
  goto <D.27484>;
  <D.27458>:
  {
    char * err;

    err = mono_dl_symbol (module, name, value);
    if (err != 0B) goto <D.27485>; else goto <D.27486>;
    <D.27485>:
    monoeg_g_free (err);
    <D.27486>:
  }
  <D.27484>:
}


memset (void * __dest, int __ch, size_t __len)
{
  int D.27489;
  int D.27494;
  void * D.27496;
  unsigned int D.27497;

  D.27489 = __builtin_constant_p (__len);
  if (D.27489 != 0) goto <D.27490>; else goto <D.27491>;
  <D.27490>:
  if (__len == 0) goto <D.27492>; else goto <D.27493>;
  <D.27492>:
  D.27494 = __builtin_constant_p (__ch);
  if (D.27494 == 0) goto <D.27487>; else goto <D.27495>;
  <D.27495>:
  if (__ch != 0) goto <D.27487>; else goto <D.27488>;
  <D.27487>:
  __warn_memset_zero_len ();
  D.27496 = __dest;
  return D.27496;
  <D.27488>:
  <D.27493>:
  <D.27491>:
  D.27497 = __builtin_object_size (__dest, 0);
  D.27496 = __builtin___memset_chk (__dest, __ch, __len, D.27497);
  return D.27496;
}


load_image (struct MonoAotModule * amodule, int index, gboolean set_error)
{
  unsigned int index.42;
  unsigned int D.27500;
  _Bool D.27501;
  long int D.27502;
  long int D.27503;
  struct MonoImage * * D.27506;
  unsigned int index.43;
  unsigned int D.27508;
  struct MonoImage * * D.27509;
  struct MonoImage * D.27510;
  struct MonoImage * D.27513;
  int D.27514;
  struct MonoAssemblyName * D.27517;
  unsigned int D.27518;
  struct MonoAssemblyName * D.27519;
  struct MonoAssembly * D.27520;
  char * D.27521;
  char * D.27524;
  const char * D.27525;
  int D.25519;
  struct MonoImage * D.27528;
  char * D.27529;
  char * * D.27530;
  char * * D.27531;
  char * D.27532;
  struct MonoAssembly * assembly;
  MonoImageOpenStatus status;

  try
    {
      index.42 = (unsigned int) index;
      D.27500 = amodule->image_table_len;
      D.27501 = index.42 >= D.27500;
      D.27502 = (long int) D.27501;
      D.27503 = __builtin_expect (D.27502, 0);
      if (D.27503 != 0) goto <D.27504>; else goto <D.27505>;
      <D.27504>:
      monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "aot-runtime.c", 223, "index < amodule->image_table_len");
      <D.27505>:
      D.27506 = amodule->image_table;
      index.43 = (unsigned int) index;
      D.27508 = index.43 * 4;
      D.27509 = D.27506 + D.27508;
      D.27510 = *D.27509;
      if (D.27510 != 0B) goto <D.27511>; else goto <D.27512>;
      <D.27511>:
      D.27506 = amodule->image_table;
      index.43 = (unsigned int) index;
      D.27508 = index.43 * 4;
      D.27509 = D.27506 + D.27508;
      D.27513 = *D.27509;
      return D.27513;
      <D.27512>:
      D.27514 = amodule->out_of_date;
      if (D.27514 != 0) goto <D.27515>; else goto <D.27516>;
      <D.27515>:
      D.27513 = 0B;
      return D.27513;
      <D.27516>:
      D.27517 = amodule->image_names;
      index.43 = (unsigned int) index;
      D.27518 = index.43 * 60;
      D.27519 = D.27517 + D.27518;
      D.27520 = amodule->assembly;
      D.27521 = D.27520->basedir;
      assembly = mono_assembly_load (D.27519, D.27521, &status);
      if (assembly == 0B) goto <D.27522>; else goto <D.27523>;
      <D.27522>:
      D.27524 = amodule->aot_name;
      D.27517 = amodule->image_names;
      index.43 = (unsigned int) index;
      D.27518 = index.43 * 60;
      D.27519 = D.27517 + D.27518;
      D.27525 = D.27519->name;
      mono_trace (64, 32, "AOT module %s is unusable because dependency %s is not found.\n", D.27524, D.27525);
      amodule->out_of_date = 1;
      if (set_error != 0) goto <D.27526>; else goto <D.27527>;
      <D.27526>:
      {
        char * full_name;

        D.27517 = amodule->image_names;
        index.43 = (unsigned int) index;
        D.27518 = index.43 * 60;
        D.27519 = D.27517 + D.27518;
        full_name = mono_stringify_assembly_name (D.27519);
        mono_loader_set_error_assembly_load (full_name, 0);
        monoeg_g_free (full_name);
      }
      <D.27527>:
      D.27513 = 0B;
      return D.27513;
      <D.27523>:
      {
        size_t __s1_len;
        size_t __s2_len;

        D.27528 = assembly->image;
        D.27529 = D.27528->guid;
        D.27530 = amodule->image_guids;
        index.43 = (unsigned int) index;
        D.27508 = index.43 * 4;
        D.27531 = D.27530 + D.27508;
        D.27532 = *D.27531;
        D.25519 = __builtin_strcmp (D.27529, D.27532);
      }
      if (D.25519 != 0) goto <D.27533>; else goto <D.27534>;
      <D.27533>:
      D.27524 = amodule->aot_name;
      D.27517 = amodule->image_names;
      index.43 = (unsigned int) index;
      D.27518 = index.43 * 60;
      D.27519 = D.27517 + D.27518;
      D.27525 = D.27519->name;
      D.27530 = amodule->image_guids;
      index.43 = (unsigned int) index;
      D.27508 = index.43 * 4;
      D.27531 = D.27530 + D.27508;
      D.27532 = *D.27531;
      D.27528 = assembly->image;
      D.27529 = D.27528->guid;
      mono_trace (64, 32, "AOT module %s is unusable (GUID of dependent assembly %s doesn\'t match (expected \'%s\', got \'%s\').\n", D.27524, D.27525, D.27532, D.27529);
      amodule->out_of_date = 1;
      D.27513 = 0B;
      return D.27513;
      <D.27534>:
      D.27506 = amodule->image_table;
      index.43 = (unsigned int) index;
      D.27508 = index.43 * 4;
      D.27509 = D.27506 + D.27508;
      D.27528 = assembly->image;
      *D.27509 = D.27528;
      D.27513 = assembly->image;
      return D.27513;
    }
  finally
    {
      status = {CLOBBER};
    }
}


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

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


atoi (const char * __nptr)
{
  int D.27539;

  D.27539 = strtol (__nptr, 0B, 10);
  return D.27539;
}


mono_aot_cleanup ()
{
  struct GHashTable * aot_jit_icall_hash.44;
  struct GHashTable * aot_modules.45;

  aot_jit_icall_hash.44 = aot_jit_icall_hash;
  if (aot_jit_icall_hash.44 != 0B) goto <D.27542>; else goto <D.27543>;
  <D.27542>:
  aot_jit_icall_hash.44 = aot_jit_icall_hash;
  monoeg_g_hash_table_destroy (aot_jit_icall_hash.44);
  <D.27543>:
  aot_modules.45 = aot_modules;
  if (aot_modules.45 != 0B) goto <D.27545>; else goto <D.27546>;
  <D.27545>:
  aot_modules.45 = aot_modules;
  monoeg_g_hash_table_destroy (aot_modules.45);
  <D.27546>:
}


mono_aot_get_method_from_vt_slot (struct MonoDomain * domain, struct MonoVTable * vtable, int slot)
{
  struct MonoImage * D.27547;
  unsigned int D.27550;
  unsigned int D.27551;
  unsigned char D.27553;
  unsigned char D.27556;
  void * D.27558;
  guint8 * D.27559;
  guint32 * D.27560;
  unsigned int D.27561;
  unsigned int D.27562;
  unsigned int D.27563;
  int D.27564;
  unsigned int D.27565;
  guint8 * p.46;
  int D.27571;
  unsigned int D.27576;
  unsigned int D.27577;
  unsigned int D.27579;
  struct MonoImage * D.27580;
  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.27547 = klass->image;
      amodule = D.27547->aot_module;
      D.27550 = klass->flags;
      D.27551 = D.27550 & 32;
      if (D.27551 != 0) goto <D.27548>; else goto <D.27552>;
      <D.27552>:
      D.27553 = klass->byval_arg.type;
      if (D.27553 == 19) goto <D.27548>; else goto <D.27554>;
      <D.27554>:
      D.27553 = klass->byval_arg.type;
      if (D.27553 == 30) goto <D.27548>; else goto <D.27555>;
      <D.27555>:
      D.27556 = klass->rank;
      if (D.27556 != 0) goto <D.27548>; else goto <D.27557>;
      <D.27557>:
      if (amodule == 0B) goto <D.27548>; else goto <D.27549>;
      <D.27548>:
      D.27558 = 0B;
      return D.27558;
      <D.27549>:
      D.27559 = amodule->blob;
      D.27560 = amodule->class_info_offsets;
      D.27561 = klass->type_token;
      D.27562 = D.27561 & 16777215;
      D.27563 = D.27562 + 4294967295;
      D.27564 = (int) D.27563;
      D.27565 = mono_aot_get_offset (D.27560, D.27564);
      info = D.27559 + D.27565;
      p = info;
      p.46 = p;
      err = decode_cached_class_info (amodule, &class_info, p.46, &p);
      if (err == 0) goto <D.27567>; else goto <D.27568>;
      <D.27567>:
      D.27558 = 0B;
      return D.27558;
      <D.27568>:
      i = 0;
      goto <D.26032>;
      <D.26031>:
      p.46 = p;
      decode_method_ref (amodule, &ref, p.46, &p);
      i = i + 1;
      <D.26032>:
      if (i < slot) goto <D.26031>; else goto <D.26033>;
      <D.26033>:
      p.46 = p;
      res = decode_method_ref (amodule, &ref, p.46, &p);
      if (res == 0) goto <D.27569>; else goto <D.27570>;
      <D.27569>:
      D.27558 = 0B;
      return D.27558;
      <D.27570>:
      D.27571 = ref.no_aot_trampoline;
      if (D.27571 != 0) goto <D.27572>; else goto <D.27573>;
      <D.27572>:
      D.27558 = 0B;
      return D.27558;
      <D.27573>:
      D.27576 = ref.token;
      D.27577 = D.27576 & 16777215;
      if (D.27577 == 0) goto <D.27574>; else goto <D.27578>;
      <D.27578>:
      D.27576 = ref.token;
      D.27579 = D.27576 >> 24;
      if (D.27579 != 6) goto <D.27574>; else goto <D.27575>;
      <D.27574>:
      D.27558 = 0B;
      return D.27558;
      <D.27575>:
      D.27580 = ref.image;
      D.27576 = ref.token;
      D.27558 = mono_aot_get_method_from_token (domain, D.27580, D.27576);
      return D.27558;
    }
  finally
    {
      p = {CLOBBER};
      class_info = {CLOBBER};
      ref = {CLOBBER};
    }
}


mono_aot_get_offset (guint32 * table, int index)
{
  unsigned int D.27583;
  guint32 * D.27584;
  unsigned int D.27585;
  guint32 * D.27586;
  unsigned int D.27587;
  guint32 * D.27588;
  unsigned int D.27589;
  unsigned int ngroups.47;
  unsigned int D.27593;
  unsigned int group.48;
  unsigned int D.27595;
  guint16 * D.27596;
  short unsigned int D.27597;
  sizetype D.27598;
  guint8 * p.49;
  unsigned int D.27601;
  unsigned int D.27602;
  guint32 * D.27603;
  unsigned int D.27604;
  guint8 * p.50;
  guint8 * p.51;
  int D.27607;
  int D.27608;
  guint32 D.27609;
  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.27583 = *table;
      noffsets = (int) D.27583;
      D.27584 = table + 4;
      D.27585 = *D.27584;
      group_size = (int) D.27585;
      D.27586 = table + 8;
      D.27587 = *D.27586;
      ngroups = (int) D.27587;
      D.27588 = table + 12;
      D.27589 = *D.27588;
      index_entry_size = (int) D.27589;
      group = index / group_size;
      if (index_entry_size == 2) goto <D.27590>; else goto <D.27591>;
      <D.27590>:
      index16 = table + 16;
      ngroups.47 = (unsigned int) ngroups;
      D.27593 = ngroups.47 * 2;
      data_start = index16 + D.27593;
      group.48 = (unsigned int) group;
      D.27595 = group.48 * 2;
      D.27596 = index16 + D.27595;
      D.27597 = *D.27596;
      D.27598 = (sizetype) D.27597;
      p.49 = data_start + D.27598;
      p = p.49;
      goto <D.27600>;
      <D.27591>:
      index32 = table + 16;
      ngroups.47 = (unsigned int) ngroups;
      D.27601 = ngroups.47 * 4;
      data_start = index32 + D.27601;
      group.48 = (unsigned int) group;
      D.27602 = group.48 * 4;
      D.27603 = index32 + D.27602;
      D.27604 = *D.27603;
      p.50 = data_start + D.27604;
      p = p.50;
      <D.27600>:
      p.51 = p;
      start_offset = decode_value (p.51, &p);
      offset = start_offset;
      D.27607 = group * group_size;
      i = D.27607 + 1;
      goto <D.25543>;
      <D.25542>:
      p.51 = p;
      D.27608 = decode_value (p.51, &p);
      offset = D.27608 + offset;
      i = i + 1;
      <D.25543>:
      if (i <= index) goto <D.25542>; else goto <D.25544>;
      <D.25544>:
      D.27609 = (guint32) offset;
      return D.27609;
    }
  finally
    {
      p = {CLOBBER};
    }
}


decode_value (guint8 * ptr, guint8 * * rptr)
{
  signed char b.52;
  int D.27616;
  int D.27617;
  int D.27620;
  int D.27621;
  guint8 * D.27622;
  unsigned char D.27623;
  int D.27624;
  int D.27628;
  int D.27629;
  int D.27630;
  int D.27631;
  guint8 * D.27632;
  unsigned char D.27633;
  int D.27634;
  int D.27635;
  int D.27636;
  guint8 * D.27637;
  unsigned char D.27638;
  int D.27639;
  int D.27641;
  int D.27642;
  int D.27643;
  int D.27644;
  int D.27645;
  guint8 * D.27646;
  unsigned char D.27647;
  int D.27648;
  gint32 D.27651;
  guint8 b;
  gint32 len;

  b = *ptr;
  b.52 = (signed char) b;
  if (b.52 >= 0) goto <D.27613>; else goto <D.27614>;
  <D.27613>:
  len = (gint32) b;
  ptr = ptr + 1;
  goto <D.27615>;
  <D.27614>:
  D.27616 = (int) b;
  D.27617 = D.27616 & 64;
  if (D.27617 == 0) goto <D.27618>; else goto <D.27619>;
  <D.27618>:
  D.27616 = (int) b;
  D.27620 = D.27616 & 63;
  D.27621 = D.27620 << 8;
  D.27622 = ptr + 1;
  D.27623 = *D.27622;
  D.27624 = (int) D.27623;
  len = D.27621 | D.27624;
  ptr = ptr + 2;
  goto <D.27625>;
  <D.27619>:
  if (b != 255) goto <D.27626>; else goto <D.27627>;
  <D.27626>:
  D.27616 = (int) b;
  D.27628 = D.27616 & 31;
  D.27629 = D.27628 << 24;
  D.27622 = ptr + 1;
  D.27623 = *D.27622;
  D.27624 = (int) D.27623;
  D.27630 = D.27624 << 16;
  D.27631 = D.27629 | D.27630;
  D.27632 = ptr + 2;
  D.27633 = *D.27632;
  D.27634 = (int) D.27633;
  D.27635 = D.27634 << 8;
  D.27636 = D.27631 | D.27635;
  D.27637 = ptr + 3;
  D.27638 = *D.27637;
  D.27639 = (int) D.27638;
  len = D.27636 | D.27639;
  ptr = ptr + 4;
  goto <D.27640>;
  <D.27627>:
  D.27622 = ptr + 1;
  D.27623 = *D.27622;
  D.27624 = (int) D.27623;
  D.27641 = D.27624 << 24;
  D.27632 = ptr + 2;
  D.27633 = *D.27632;
  D.27634 = (int) D.27633;
  D.27642 = D.27634 << 16;
  D.27643 = D.27641 | D.27642;
  D.27637 = ptr + 3;
  D.27638 = *D.27637;
  D.27639 = (int) D.27638;
  D.27644 = D.27639 << 8;
  D.27645 = D.27643 | D.27644;
  D.27646 = ptr + 4;
  D.27647 = *D.27646;
  D.27648 = (int) D.27647;
  len = D.27645 | D.27648;
  ptr = ptr + 5;
  <D.27640>:
  <D.27625>:
  <D.27615>:
  if (rptr != 0B) goto <D.27649>; else goto <D.27650>;
  <D.27649>:
  *rptr = ptr;
  <D.27650>:
  D.27651 = len;
  return D.27651;
}


decode_cached_class_info (struct MonoAotModule * module, struct MonoCachedClassInfo * info, guint8 * buf, guint8 * * endbuf)
{
  guint8 * buf.53;
  int D.27654;
  unsigned int D.27655;
  unsigned int D.27656;
  gboolean D.27659;
  int D.27660;
  unsigned char D.27661;
  <unnamed-unsigned:1> D.27662;
  unsigned int D.27663;
  unsigned char D.27664;
  <unnamed-unsigned:1> D.27665;
  unsigned int D.27666;
  unsigned char D.27667;
  <unnamed-unsigned:1> D.27668;
  unsigned int D.27669;
  unsigned char D.27670;
  <unnamed-unsigned:1> D.27671;
  unsigned int D.27672;
  unsigned char D.27673;
  <unnamed-unsigned:1> D.27674;
  unsigned int D.27675;
  unsigned char D.27676;
  <unnamed-unsigned:1> D.27677;
  unsigned int D.27678;
  unsigned char D.27679;
  <unnamed-unsigned:1> D.27680;
  unsigned int D.27681;
  unsigned char D.27682;
  <unnamed-unsigned:1> D.27683;
  unsigned int D.27684;
  unsigned char D.27685;
  <unnamed-unsigned:1> D.27686;
  unsigned char D.27687;
  unsigned char D.27688;
  unsigned int D.27693;
  unsigned char D.27694;
  struct MonoImage * D.27699;
  int D.27700;
  unsigned int D.27701;
  int D.27702;
  unsigned int D.27703;
  int D.27704;
  unsigned int D.27705;
  int D.27706;
  unsigned int D.27707;
  guint32 flags;
  struct MethodRef ref;
  gboolean res;

  try
    {
      buf.53 = buf;
      D.27654 = decode_value (buf.53, &buf);
      D.27655 = (unsigned int) D.27654;
      info->vtable_size = D.27655;
      D.27656 = info->vtable_size;
      if (D.27656 == 4294967295) goto <D.27657>; else goto <D.27658>;
      <D.27657>:
      D.27659 = 0;
      return D.27659;
      <D.27658>:
      buf.53 = buf;
      D.27660 = decode_value (buf.53, &buf);
      flags = (guint32) D.27660;
      D.27661 = (unsigned char) flags;
      D.27662 = (<unnamed-unsigned:1>) D.27661;
      info->ghcimpl = D.27662;
      D.27663 = flags >> 1;
      D.27664 = (unsigned char) D.27663;
      D.27665 = (<unnamed-unsigned:1>) D.27664;
      info->has_finalize = D.27665;
      D.27666 = flags >> 2;
      D.27667 = (unsigned char) D.27666;
      D.27668 = (<unnamed-unsigned:1>) D.27667;
      info->has_cctor = D.27668;
      D.27669 = flags >> 3;
      D.27670 = (unsigned char) D.27669;
      D.27671 = (<unnamed-unsigned:1>) D.27670;
      info->has_nested_classes = D.27671;
      D.27672 = flags >> 4;
      D.27673 = (unsigned char) D.27672;
      D.27674 = (<unnamed-unsigned:1>) D.27673;
      info->blittable = D.27674;
      D.27675 = flags >> 5;
      D.27676 = (unsigned char) D.27675;
      D.27677 = (<unnamed-unsigned:1>) D.27676;
      info->has_references = D.27677;
      D.27678 = flags >> 6;
      D.27679 = (unsigned char) D.27678;
      D.27680 = (<unnamed-unsigned:1>) D.27679;
      info->has_static_refs = D.27680;
      D.27681 = flags >> 7;
      D.27682 = (unsigned char) D.27681;
      D.27683 = (<unnamed-unsigned:1>) D.27682;
      info->no_special_static_fields = D.27683;
      D.27684 = flags >> 8;
      D.27685 = (unsigned char) D.27684;
      D.27686 = (<unnamed-unsigned:1>) D.27685;
      info->is_generic_container = D.27686;
      D.27687 = BIT_FIELD_REF <*info, 8, 32>;
      D.27688 = D.27687 & 4;
      if (D.27688 != 0) goto <D.27689>; else goto <D.27690>;
      <D.27689>:
      buf.53 = buf;
      res = decode_method_ref (module, &ref, buf.53, &buf);
      if (res == 0) goto <D.27691>; else goto <D.27692>;
      <D.27691>:
      D.27659 = 0;
      return D.27659;
      <D.27692>:
      D.27693 = ref.token;
      info->cctor_token = D.27693;
      <D.27690>:
      D.27687 = BIT_FIELD_REF <*info, 8, 32>;
      D.27694 = D.27687 & 1;
      if (D.27694 != 0) goto <D.27695>; else goto <D.27696>;
      <D.27695>:
      buf.53 = buf;
      res = decode_method_ref (module, &ref, buf.53, &buf);
      if (res == 0) goto <D.27697>; else goto <D.27698>;
      <D.27697>:
      D.27659 = 0;
      return D.27659;
      <D.27698>:
      D.27699 = ref.image;
      info->finalize_image = D.27699;
      D.27693 = ref.token;
      info->finalize_token = D.27693;
      <D.27696>:
      buf.53 = buf;
      D.27700 = decode_value (buf.53, &buf);
      D.27701 = (unsigned int) D.27700;
      info->instance_size = D.27701;
      buf.53 = buf;
      D.27702 = decode_value (buf.53, &buf);
      D.27703 = (unsigned int) D.27702;
      info->class_size = D.27703;
      buf.53 = buf;
      D.27704 = decode_value (buf.53, &buf);
      D.27705 = (unsigned int) D.27704;
      info->packing_size = D.27705;
      buf.53 = buf;
      D.27706 = decode_value (buf.53, &buf);
      D.27707 = (unsigned int) D.27706;
      info->min_align = D.27707;
      buf.53 = buf;
      *endbuf = buf.53;
      D.27659 = 1;
      return D.27659;
    }
  finally
    {
      ref = {CLOBBER};
    }
}


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

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


decode_method_ref_with_target (struct MonoAotModule * module, struct MethodRef * ref, struct MonoMethod * target, guint8 * buf, guint8 * * endbuf)
{
  guint8 * p.54;
  int D.27713;
  int D.27716;
  _Bool D.27719;
  _Bool D.27720;
  _Bool D.27721;
  unsigned char D.27725;
  unsigned char D.27726;
  gboolean D.27729;
  int D.27732;
  <unnamed-unsigned:5> D.27735;
  unsigned int D.27736;
  struct MonoClass * D.27741;
  struct MonoMethod * D.27742;
  struct MonoMethod * D.27745;
  struct MonoType * D.27750;
  struct MonoMethod * D.27751;
  struct MonoMethod * D.27755;
  struct MonoMethod * D.27759;
  struct MonoMethod * D.27763;
  struct MonoMethod * D.27765;
  struct MonoMethod * D.27766;
  struct MonoMethod * D.27767;
  struct MonoMethod * D.27768;
  _Bool D.27769;
  long int D.27770;
  long int D.27771;
  struct MonoMethod * D.27774;
  struct MonoMethod * D.27777;
  _Bool D.27785;
  long int D.27786;
  long int D.27787;
  <unnamed type> D.27792;
  unsigned int subtype.55;
  int D.27795;
  struct MonoMethod * D.27801;
  unsigned int subtype.56;
  unsigned int D.27803;
  struct MonoClass * D.27810;
  int D.25762;
  int iftmp.57;
  int D.25761;
  const char[15] * D.27818;
  unsigned char D.27819;
  int D.27820;
  unsigned char D.27821;
  int D.27822;
  _Bool D.27823;
  _Bool D.27824;
  _Bool D.27825;
  const unsigned char * D.27828;
  unsigned char D.27829;
  int D.27830;
  const unsigned char * D.27831;
  unsigned char D.27832;
  int D.27833;
  _Bool D.27834;
  _Bool D.27835;
  const unsigned char * D.27838;
  unsigned char D.27839;
  int D.27840;
  const unsigned char * D.27841;
  unsigned char D.27842;
  int D.27843;
  _Bool D.27844;
  _Bool D.27845;
  const unsigned char * D.27848;
  unsigned char D.27849;
  int D.27850;
  const unsigned char * D.27851;
  unsigned char D.27852;
  int D.27853;
  const char * D.27855;
  struct MonoMethod * D.27858;
  int D.25771;
  int iftmp.58;
  int D.25770;
  const char[15] * D.27863;
  unsigned char D.27864;
  int D.27865;
  unsigned char D.27866;
  int D.27867;
  _Bool D.27868;
  _Bool D.27869;
  _Bool D.27870;
  const unsigned char * D.27873;
  unsigned char D.27874;
  int D.27875;
  const unsigned char * D.27876;
  unsigned char D.27877;
  int D.27878;
  _Bool D.27879;
  _Bool D.27880;
  const unsigned char * D.27883;
  unsigned char D.27884;
  int D.27885;
  const unsigned char * D.27886;
  unsigned char D.27887;
  int D.27888;
  _Bool D.27889;
  _Bool D.27890;
  const unsigned char * D.27893;
  unsigned char D.27894;
  int D.27895;
  const unsigned char * D.27896;
  unsigned char D.27897;
  int D.27898;
  struct MonoMethod * D.27902;
  struct MonoMethod * D.27908;
  struct MonoMethod * D.27914;
  struct MonoMethod * D.27918;
  struct MonoMethod * D.27922;
  struct MonoClass * D.27933;
  _Bool D.27934;
  long int D.27935;
  long int D.27936;
  struct MonoMethod * D.27939;
  struct MonoMethod * D.27942;
  _Bool D.27950;
  long int D.27951;
  long int D.27952;
  <unnamed type> D.27958;
  unsigned int subtype.59;
  struct MonoMethod * D.27961;
  int D.25792;
  struct MonoMethod * D.27974;
  struct MonoMethod * D.27980;
  struct MonoMethod * D.27984;
  int D.25805;
  int iftmp.60;
  int D.25804;
  const char[23] * D.27993;
  unsigned char D.27994;
  int D.27995;
  unsigned char D.27996;
  int D.27997;
  _Bool D.27998;
  _Bool D.27999;
  _Bool D.28000;
  const unsigned char * D.28003;
  unsigned char D.28004;
  int D.28005;
  const unsigned char * D.28006;
  unsigned char D.28007;
  int D.28008;
  _Bool D.28009;
  _Bool D.28010;
  const unsigned char * D.28013;
  unsigned char D.28014;
  int D.28015;
  const unsigned char * D.28016;
  unsigned char D.28017;
  int D.28018;
  _Bool D.28019;
  _Bool D.28020;
  const unsigned char * D.28023;
  unsigned char D.28024;
  int D.28025;
  const unsigned char * D.28026;
  unsigned char D.28027;
  int D.28028;
  struct MonoMethod * D.28037;
  struct MonoMethod * D.28043;
  _Bool D.28045;
  long int D.28046;
  long int D.28047;
  <unnamed type> D.28050;
  unsigned int subtype.61;
  struct MonoMethodSignature * D.28054;
  _Bool D.28055;
  long int D.28056;
  long int D.28057;
  int D.28060;
  _Bool D.28068;
  _Bool D.28069;
  _Bool D.28070;
  int D.28078;
  <unnamed type> D.28081;
  int D.28087;
  struct MonoMethod * D.28095;
  int D.28099;
  int D.28100;
  unsigned int D.28101;
  int image_index.62;
  int D.28114;
  int D.28115;
  unsigned int D.28116;
  unsigned int D.28119;
  struct MonoMethod * D.28120;
  struct MonoGenericClass * D.28125;
  struct MonoGenericInst * D.28126;
  struct MonoMethod * D.28127;
  int D.28128;
  struct MonoMethod * D.28131;
  unsigned char D.28137;
  int D.28138;
  struct MonoMethod * D.28139;
  int D.28140;
  struct MonoMethod * D.28141;
  struct MonoMethod * D.28142;
  struct MonoMethod * D.28143;
  struct MonoMethod * D.28144;
  int D.28148;
  int D.28149;
  unsigned int D.28150;
  unsigned int D.28151;
  guint32 image_index;
  guint32 value;
  struct MonoImage * image;
  guint8 * p;

  try
    {
      image = 0B;
      p = buf;
      memset (ref, 0, 16);
      p.54 = p;
      D.27713 = decode_value (p.54, &p);
      value = (guint32) D.27713;
      image_index = value >> 24;
      if (image_index == 251) goto <D.27714>; else goto <D.27715>;
      <D.27714>:
      ref->no_aot_trampoline = 1;
      p.54 = p;
      D.27716 = decode_value (p.54, &p);
      value = (guint32) D.27716;
      image_index = value >> 24;
      <D.27715>:
      D.27719 = image_index <= 239;
      D.27720 = image_index == 254;
      D.27721 = D.27719 | D.27720;
      if (D.27721 != 0) goto <D.27717>; else goto <D.27722>;
      <D.27722>:
      if (image_index == 253) goto <D.27717>; else goto <D.27718>;
      <D.27717>:
      if (target != 0B) goto <D.27723>; else goto <D.27724>;
      <D.27723>:
      D.27725 = BIT_FIELD_REF <*target, 8, 160>;
      D.27726 = D.27725 & 124;
      if (D.27726 != 0) goto <D.27727>; else goto <D.27728>;
      <D.27727>:
      D.27729 = 0;
      return D.27729;
      <D.27728>:
      <D.27724>:
      <D.27718>:
      if (image_index == 252) goto <D.27730>; else goto <D.27731>;
      <D.27730>:
      {
        guint32 wrapper_type;

        p.54 = p;
        D.27732 = decode_value (p.54, &p);
        wrapper_type = (guint32) D.27732;
        if (target != 0B) goto <D.27733>; else goto <D.27734>;
        <D.27733>:
        D.27735 = target->wrapper_type;
        D.27736 = (unsigned int) D.27735;
        if (D.27736 != wrapper_type) goto <D.27737>; else goto <D.27738>;
        <D.27737>:
        D.27729 = 0;
        return D.27729;
        <D.27738>:
        <D.27734>:
        image = mono_defaults.corlib;
        switch (wrapper_type) <default: <D.25827>, case 1: <D.25810>, case 2: <D.25811>, case 3: <D.25812>, case 4: <D.25795>, case 5: <D.25824>, case 6: <D.25780>, case 7: <D.25774>, case 9: <D.25728>, case 12: <D.25733>, case 13: <D.25735>, case 14: <D.25738>, case 15: <D.25739>, case 16: <D.25747>, case 18: <D.25736>, case 19: <D.25793>, case 20: <D.25731>, case 21: <D.25743>, case 23: <D.25734>, case 24: <D.25742>, case 25: <D.25749>, case 28: <D.25740>>
        <D.25728>:
        {
          struct MonoMethod * m;

          p.54 = p;
          m = decode_resolve_method_ref (module, p.54, &p);
          if (m == 0B) goto <D.27739>; else goto <D.27740>;
          <D.27739>:
          D.27729 = 0;
          return D.27729;
          <D.27740>:
          D.27741 = m->klass;
          mono_class_init (D.27741);
          D.27742 = mono_marshal_get_remoting_invoke_with_check (m);
          ref->method = D.27742;
          goto <D.25730>;
        }
        <D.25731>:
        {
          struct MonoClass * klass;

          p.54 = p;
          klass = decode_klass_ref (module, p.54, &p);
          if (klass == 0B) goto <D.27743>; else goto <D.27744>;
          <D.27743>:
          D.27729 = 0;
          return D.27729;
          <D.27744>:
          D.27745 = mono_marshal_get_proxy_cancast (klass);
          ref->method = D.27745;
          goto <D.25730>;
        }
        <D.25733>:
        <D.25734>:
        <D.25735>:
        <D.25736>:
        {
          struct MonoClass * klass;

          p.54 = p;
          klass = decode_klass_ref (module, p.54, &p);
          if (klass == 0B) goto <D.27746>; else goto <D.27747>;
          <D.27746>:
          D.27729 = 0;
          return D.27729;
          <D.27747>:
          if (wrapper_type == 12) goto <D.27748>; else goto <D.27749>;
          <D.27748>:
          D.27750 = &klass->byval_arg;
          D.27751 = mono_marshal_get_ldfld_wrapper (D.27750);
          ref->method = D.27751;
          goto <D.27752>;
          <D.27749>:
          if (wrapper_type == 23) goto <D.27753>; else goto <D.27754>;
          <D.27753>:
          D.27750 = &klass->byval_arg;
          D.27755 = mono_marshal_get_ldflda_wrapper (D.27750);
          ref->method = D.27755;
          goto <D.27756>;
          <D.27754>:
          if (wrapper_type == 13) goto <D.27757>; else goto <D.27758>;
          <D.27757>:
          D.27750 = &klass->byval_arg;
          D.27759 = mono_marshal_get_stfld_wrapper (D.27750);
          ref->method = D.27759;
          goto <D.27760>;
          <D.27758>:
          if (wrapper_type == 18) goto <D.27761>; else goto <D.27762>;
          <D.27761>:
          D.27763 = mono_marshal_get_isinst (klass);
          ref->method = D.27763;
          goto <D.27764>;
          <D.27762>:
          monoeg_assertion_message ("* Assertion: should not be reached at %s:%d\n", "aot-runtime.c", 831);
          <D.27764>:
          <D.27760>:
          <D.27756>:
          <D.27752>:
          goto <D.25730>;
        }
        <D.25738>:
        D.27765 = mono_marshal_get_ldfld_remote_wrapper (0B);
        ref->method = D.27765;
        goto <D.25730>;
        <D.25739>:
        D.27766 = mono_marshal_get_stfld_remote_wrapper (0B);
        ref->method = D.27766;
        goto <D.25730>;
        <D.25740>:
        {
          int atype;

          p.54 = p;
          atype = decode_value (p.54, &p);
          D.27767 = mono_gc_get_managed_allocator_by_type (atype);
          ref->method = D.27767;
          D.27768 = ref->method;
          D.27769 = D.27768 == 0B;
          D.27770 = (long int) D.27769;
          D.27771 = __builtin_expect (D.27770, 0);
          if (D.27771 != 0) goto <D.27772>; else goto <D.27773>;
          <D.27772>:
          monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "aot-runtime.c", 845, "ref->method");
          <D.27773>:
          goto <D.25730>;
        }
        <D.25742>:
        D.27774 = mono_gc_get_write_barrier ();
        ref->method = D.27774;
        goto <D.25730>;
        <D.25743>:
        {
          int subtype;

          p.54 = p;
          subtype = decode_value (p.54, &p);
          if (subtype == 0) goto <D.27775>; else goto <D.27776>;
          <D.27775>:
          D.27777 = mono_marshal_get_stelemref ();
          ref->method = D.27777;
          goto <D.27778>;
          <D.27776>:
          if (subtype == 3) goto <D.27779>; else goto <D.27780>;
          <D.27779>:
          {
            int kind;
            struct WrapperInfo * info;

            p.54 = p;
            kind = decode_value (p.54, &p);
            if (target == 0B) goto <D.27781>; else goto <D.27782>;
            <D.27781>:
            D.27729 = 0;
            return D.27729;
            <D.27782>:
            D.27725 = BIT_FIELD_REF <*target, 8, 160>;
            D.27726 = D.27725 & 124;
            if (D.27726 == 84) goto <D.27783>; else goto <D.27784>;
            <D.27783>:
            info = mono_marshal_get_wrapper_info (target);
            D.27785 = info == 0B;
            D.27786 = (long int) D.27785;
            D.27787 = __builtin_expect (D.27786, 0);
            if (D.27787 != 0) goto <D.27788>; else goto <D.27789>;
            <D.27788>:
            monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "aot-runtime.c", 868, "info");
            <D.27789>:
            D.27792 = info->subtype;
            subtype.55 = (unsigned int) subtype;
            if (D.27792 == subtype.55) goto <D.27794>; else goto <D.27790>;
            <D.27794>:
            D.27795 = info->d.virtual_stelemref.kind;
            if (D.27795 == kind) goto <D.27796>; else goto <D.27790>;
            <D.27796>:
            ref->method = target;
            goto <D.27791>;
            <D.27790>:
            D.27729 = 0;
            return D.27729;
            <D.27791>:
            goto <D.27797>;
            <D.27784>:
            D.27729 = 0;
            return D.27729;
            <D.27797>:
          }
          goto <D.27798>;
          <D.27780>:
          monoeg_assertion_message ("* Assertion: should not be reached at %s:%d\n", "aot-runtime.c", 877);
          <D.27798>:
          <D.27778>:
          goto <D.25730>;
        }
        <D.25747>:
        {
          struct MonoMethod * m;

          p.54 = p;
          m = decode_resolve_method_ref (module, p.54, &p);
          if (m == 0B) goto <D.27799>; else goto <D.27800>;
          <D.27799>:
          D.27729 = 0;
          return D.27729;
          <D.27800>:
          D.27801 = mono_marshal_get_synchronized_wrapper (m);
          ref->method = D.27801;
          goto <D.25730>;
        }
        <D.25749>:
        {
          struct MonoMethodDesc * desc;
          struct MonoMethod * orig_method;
          int subtype;

          p.54 = p;
          subtype = decode_value (p.54, &p);
          subtype.56 = (unsigned int) subtype;
          D.27803 = subtype.56 + 4294967289;
          if (D.27803 <= 1) goto <D.27804>; else goto <D.27805>;
          <D.27804>:
          {
            struct MonoClass * klass;

            p.54 = p;
            klass = decode_klass_ref (module, p.54, &p);
            if (klass == 0B) goto <D.27806>; else goto <D.27807>;
            <D.27806>:
            D.27729 = 0;
            return D.27729;
            <D.27807>:
            if (target == 0B) goto <D.27808>; else goto <D.27809>;
            <D.27808>:
            D.27729 = 0;
            return D.27729;
            <D.27809>:
            D.27810 = target->klass;
            if (D.27810 != klass) goto <D.27811>; else goto <D.27812>;
            <D.27811>:
            D.27729 = 0;
            return D.27729;
            <D.27812>:
            if (subtype == 7) goto <D.27813>; else goto <D.27814>;
            <D.27813>:
            {
              size_t __s1_len;
              size_t __s2_len;

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

                __s2 = target->name;
                D.27818 = "PtrToStructure";
                D.27819 = MEM[(const unsigned char *)D.27818];
                D.27820 = (int) D.27819;
                D.27821 = *__s2;
                D.27822 = (int) D.27821;
                __result = D.27820 - D.27822;
                {
                  D.27823 = __s2_len != 0;
                  D.27824 = __result == 0;
                  D.27825 = D.27823 & D.27824;
                  if (D.27825 != 0) goto <D.27826>; else goto <D.27827>;
                  <D.27826>:
                  D.27828 = &MEM[(void *)"PtrToStructure" + 1B];
                  D.27829 = *D.27828;
                  D.27830 = (int) D.27829;
                  D.27831 = __s2 + 1;
                  D.27832 = *D.27831;
                  D.27833 = (int) D.27832;
                  __result = D.27830 - D.27833;
                  D.27834 = __s2_len > 1;
                  D.27824 = __result == 0;
                  D.27835 = D.27834 & D.27824;
                  if (D.27835 != 0) goto <D.27836>; else goto <D.27837>;
                  <D.27836>:
                  D.27838 = &MEM[(void *)"PtrToStructure" + 2B];
                  D.27839 = *D.27838;
                  D.27840 = (int) D.27839;
                  D.27841 = __s2 + 2;
                  D.27842 = *D.27841;
                  D.27843 = (int) D.27842;
                  __result = D.27840 - D.27843;
                  D.27844 = __s2_len > 2;
                  D.27824 = __result == 0;
                  D.27845 = D.27844 & D.27824;
                  if (D.27845 != 0) goto <D.27846>; else goto <D.27847>;
                  <D.27846>:
                  D.27848 = &MEM[(void *)"PtrToStructure" + 3B];
                  D.27849 = *D.27848;
                  D.27850 = (int) D.27849;
                  D.27851 = __s2 + 3;
                  D.27852 = *D.27851;
                  D.27853 = (int) D.27852;
                  __result = D.27850 - D.27853;
                  <D.27847>:
                  <D.27837>:
                  <D.27827>:
                }
                D.25761 = __result;
              }
              iftmp.57 = -D.25761;
              goto <D.27854>;
              <D.27817>:
              D.27855 = target->name;
              iftmp.57 = __builtin_strcmp (D.27855, "PtrToStructure");
              <D.27854>:
              D.25762 = iftmp.57;
            }
            if (D.25762 != 0) goto <D.27856>; else goto <D.27857>;
            <D.27856>:
            D.27729 = 0;
            return D.27729;
            <D.27857>:
            D.27858 = mono_marshal_get_ptr_to_struct (klass);
            ref->method = D.27858;
            goto <D.27859>;
            <D.27814>:
            {
              size_t __s1_len;
              size_t __s2_len;

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

                __s2 = target->name;
                D.27863 = "StructureToPtr";
                D.27864 = MEM[(const unsigned char *)D.27863];
                D.27865 = (int) D.27864;
                D.27866 = *__s2;
                D.27867 = (int) D.27866;
                __result = D.27865 - D.27867;
                {
                  D.27868 = __s2_len != 0;
                  D.27869 = __result == 0;
                  D.27870 = D.27868 & D.27869;
                  if (D.27870 != 0) goto <D.27871>; else goto <D.27872>;
                  <D.27871>:
                  D.27873 = &MEM[(void *)"StructureToPtr" + 1B];
                  D.27874 = *D.27873;
                  D.27875 = (int) D.27874;
                  D.27876 = __s2 + 1;
                  D.27877 = *D.27876;
                  D.27878 = (int) D.27877;
                  __result = D.27875 - D.27878;
                  D.27879 = __s2_len > 1;
                  D.27869 = __result == 0;
                  D.27880 = D.27879 & D.27869;
                  if (D.27880 != 0) goto <D.27881>; else goto <D.27882>;
                  <D.27881>:
                  D.27883 = &MEM[(void *)"StructureToPtr" + 2B];
                  D.27884 = *D.27883;
                  D.27885 = (int) D.27884;
                  D.27886 = __s2 + 2;
                  D.27887 = *D.27886;
                  D.27888 = (int) D.27887;
                  __result = D.27885 - D.27888;
                  D.27889 = __s2_len > 2;
                  D.27869 = __result == 0;
                  D.27890 = D.27889 & D.27869;
                  if (D.27890 != 0) goto <D.27891>; else goto <D.27892>;
                  <D.27891>:
                  D.27893 = &MEM[(void *)"StructureToPtr" + 3B];
                  D.27894 = *D.27893;
                  D.27895 = (int) D.27894;
                  D.27896 = __s2 + 3;
                  D.27897 = *D.27896;
                  D.27898 = (int) D.27897;
                  __result = D.27895 - D.27898;
                  <D.27892>:
                  <D.27882>:
                  <D.27872>:
                }
                D.25770 = __result;
              }
              iftmp.58 = -D.25770;
              goto <D.27899>;
              <D.27862>:
              D.27855 = target->name;
              iftmp.58 = __builtin_strcmp (D.27855, "StructureToPtr");
              <D.27899>:
              D.25771 = iftmp.58;
            }
            if (D.25771 != 0) goto <D.27900>; else goto <D.27901>;
            <D.27900>:
            D.27729 = 0;
            return D.27729;
            <D.27901>:
            D.27902 = mono_marshal_get_struct_to_ptr (klass);
            ref->method = D.27902;
            <D.27859>:
          }
          goto <D.27903>;
          <D.27805>:
          if (subtype == 17) goto <D.27904>; else goto <D.27905>;
          <D.27904>:
          {
            struct MonoMethod * m;

            p.54 = p;
            m = decode_resolve_method_ref (module, p.54, &p);
            if (m == 0B) goto <D.27906>; else goto <D.27907>;
            <D.27906>:
            D.27729 = 0;
            return D.27729;
            <D.27907>:
            D.27908 = mono_marshal_get_synchronized_inner_wrapper (m);
            ref->method = D.27908;
          }
          goto <D.27909>;
          <D.27905>:
          if (subtype == 20) goto <D.27910>; else goto <D.27911>;
          <D.27910>:
          {
            struct MonoMethod * m;

            p.54 = p;
            m = decode_resolve_method_ref (module, p.54, &p);
            if (m == 0B) goto <D.27912>; else goto <D.27913>;
            <D.27912>:
            D.27729 = 0;
            return D.27729;
            <D.27913>:
            D.27914 = mono_marshal_get_array_accessor_wrapper (m);
            ref->method = D.27914;
          }
          goto <D.27915>;
          <D.27911>:
          if (subtype == 18) goto <D.27916>; else goto <D.27917>;
          <D.27916>:
          D.27918 = mono_marshal_get_gsharedvt_in_wrapper ();
          ref->method = D.27918;
          goto <D.27919>;
          <D.27917>:
          if (subtype == 19) goto <D.27920>; else goto <D.27921>;
          <D.27920>:
          D.27922 = mono_marshal_get_gsharedvt_out_wrapper ();
          ref->method = D.27922;
          goto <D.27923>;
          <D.27921>:
          if (subtype == 4) goto <D.27924>; else goto <D.27925>;
          <D.27924>:
          desc = mono_method_desc_new ("Monitor:Enter", 0);
          goto <D.27926>;
          <D.27925>:
          if (subtype == 6) goto <D.27927>; else goto <D.27928>;
          <D.27927>:
          desc = mono_method_desc_new ("Monitor:Exit", 0);
          goto <D.27929>;
          <D.27928>:
          if (subtype == 5) goto <D.27930>; else goto <D.27931>;
          <D.27930>:
          desc = mono_method_desc_new ("Monitor:Enter(object,bool&)", 0);
          goto <D.27932>;
          <D.27931>:
          monoeg_assertion_message ("* Assertion: should not be reached at %s:%d\n", "aot-runtime.c", 938);
          <D.27932>:
          <D.27929>:
          <D.27926>:
          D.27933 = mono_defaults.monitor_class;
          orig_method = mono_method_desc_search_in_class (desc, D.27933);
          D.27934 = orig_method == 0B;
          D.27935 = (long int) D.27934;
          D.27936 = __builtin_expect (D.27935, 0);
          if (D.27936 != 0) goto <D.27937>; else goto <D.27938>;
          <D.27937>:
          monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "aot-runtime.c", 940, "orig_method");
          <D.27938>:
          mono_method_desc_free (desc);
          D.27939 = mono_monitor_get_fast_path (orig_method);
          ref->method = D.27939;
          <D.27923>:
          <D.27919>:
          <D.27915>:
          <D.27909>:
          <D.27903>:
          goto <D.25730>;
        }
        <D.25774>:
        {
          int subtype;

          p.54 = p;
          subtype = decode_value (p.54, &p);
          if (subtype == 1) goto <D.27940>; else goto <D.27941>;
          <D.27940>:
          {
            int rank;
            int elem_size;

            p.54 = p;
            rank = decode_value (p.54, &p);
            p.54 = p;
            elem_size = decode_value (p.54, &p);
            D.27942 = mono_marshal_get_array_address (rank, elem_size);
            ref->method = D.27942;
          }
          goto <D.27943>;
          <D.27941>:
          if (subtype == 2) goto <D.27944>; else goto <D.27945>;
          <D.27944>:
          {
            struct WrapperInfo * info;
            struct MonoMethod * m;

            p.54 = p;
            m = decode_resolve_method_ref (module, p.54, &p);
            if (m == 0B) goto <D.27946>; else goto <D.27947>;
            <D.27946>:
            D.27729 = 0;
            return D.27729;
            <D.27947>:
            if (target == 0B) goto <D.27948>; else goto <D.27949>;
            <D.27948>:
            D.27729 = 0;
            return D.27729;
            <D.27949>:
            D.27725 = BIT_FIELD_REF <*target, 8, 160>;
            D.27726 = D.27725 & 124;
            D.27950 = D.27726 != 28;
            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", 964, "target->wrapper_type == MONO_WRAPPER_MANAGED_TO_MANAGED");
            <D.27954>:
            info = mono_marshal_get_wrapper_info (target);
            if (info != 0B) goto <D.27957>; else goto <D.27955>;
            <D.27957>:
            D.27958 = info->subtype;
            subtype.59 = (unsigned int) subtype;
            if (D.27958 == subtype.59) goto <D.27960>; else goto <D.27955>;
            <D.27960>:
            D.27961 = info->d.string_ctor.method;
            if (D.27961 == m) goto <D.27962>; else goto <D.27955>;
            <D.27962>:
            ref->method = target;
            goto <D.27956>;
            <D.27955>:
            D.27729 = 0;
            return D.27729;
            <D.27956>:
          }
          <D.27945>:
          <D.27943>:
          goto <D.25730>;
        }
        <D.25780>:
        {
          struct MonoMethod * m;
          int subtype;
          char * name;

          p.54 = p;
          subtype = decode_value (p.54, &p);
          if (subtype == 15) goto <D.27963>; else goto <D.27964>;
          <D.27963>:
          if (target == 0B) goto <D.27965>; else goto <D.27966>;
          <D.27965>:
          D.27729 = 0;
          return D.27729;
          <D.27966>:
          name = p;
          {
            size_t __s1_len;
            size_t __s2_len;

            D.27855 = target->name;
            D.25792 = __builtin_strcmp (D.27855, name);
          }
          if (D.25792 != 0) goto <D.27967>; else goto <D.27968>;
          <D.27967>:
          D.27729 = 0;
          return D.27729;
          <D.27968>:
          ref->method = target;
          goto <D.27969>;
          <D.27964>:
          p.54 = p;
          m = decode_resolve_method_ref (module, p.54, &p);
          if (m == 0B) goto <D.27970>; else goto <D.27971>;
          <D.27970>:
          D.27729 = 0;
          return D.27729;
          <D.27971>:
          if (target == 0B) goto <D.27972>; else goto <D.27973>;
          <D.27972>:
          D.27729 = 0;
          return D.27729;
          <D.27973>:
          D.27974 = mono_marshal_method_from_wrapper (target);
          if (D.27974 == m) goto <D.27975>; else goto <D.27976>;
          <D.27975>:
          ref->method = target;
          goto <D.27977>;
          <D.27976>:
          D.27729 = 0;
          return D.27729;
          <D.27977>:
          <D.27969>:
          goto <D.25730>;
        }
        <D.25793>:
        {
          int subtype;

          p.54 = p;
          subtype = decode_value (p.54, &p);
          if (subtype == 9) goto <D.27978>; else goto <D.27979>;
          <D.27978>:
          D.27980 = mono_marshal_get_castclass_with_cache ();
          ref->method = D.27980;
          goto <D.27981>;
          <D.27979>:
          if (subtype == 10) goto <D.27982>; else goto <D.27983>;
          <D.27982>:
          D.27984 = mono_marshal_get_isinst_with_cache ();
          ref->method = D.27984;
          goto <D.27985>;
          <D.27983>:
          monoeg_assertion_message ("* Assertion: should not be reached at %s:%d\n", "aot-runtime.c", 1011);
          <D.27985>:
          <D.27981>:
          goto <D.25730>;
        }
        <D.25795>:
        {
          int subtype;

          p.54 = p;
          subtype = decode_value (p.54, &p);
          if (target == 0B) goto <D.27986>; else goto <D.27987>;
          <D.27986>:
          D.27729 = 0;
          return D.27729;
          <D.27987>:
          if (subtype == 12) goto <D.27988>; else goto <D.27989>;
          <D.27988>:
          {
            size_t __s1_len;
            size_t __s2_len;

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

              __s2 = target->name;
              D.27993 = "runtime_invoke_dynamic";
              D.27994 = MEM[(const unsigned char *)D.27993];
              D.27995 = (int) D.27994;
              D.27996 = *__s2;
              D.27997 = (int) D.27996;
              __result = D.27995 - D.27997;
              {
                D.27998 = __s2_len != 0;
                D.27999 = __result == 0;
                D.28000 = D.27998 & D.27999;
                if (D.28000 != 0) goto <D.28001>; else goto <D.28002>;
                <D.28001>:
                D.28003 = &MEM[(void *)"runtime_invoke_dynamic" + 1B];
                D.28004 = *D.28003;
                D.28005 = (int) D.28004;
                D.28006 = __s2 + 1;
                D.28007 = *D.28006;
                D.28008 = (int) D.28007;
                __result = D.28005 - D.28008;
                D.28009 = __s2_len > 1;
                D.27999 = __result == 0;
                D.28010 = D.28009 & D.27999;
                if (D.28010 != 0) goto <D.28011>; else goto <D.28012>;
                <D.28011>:
                D.28013 = &MEM[(void *)"runtime_invoke_dynamic" + 2B];
                D.28014 = *D.28013;
                D.28015 = (int) D.28014;
                D.28016 = __s2 + 2;
                D.28017 = *D.28016;
                D.28018 = (int) D.28017;
                __result = D.28015 - D.28018;
                D.28019 = __s2_len > 2;
                D.27999 = __result == 0;
                D.28020 = D.28019 & D.27999;
                if (D.28020 != 0) goto <D.28021>; else goto <D.28022>;
                <D.28021>:
                D.28023 = &MEM[(void *)"runtime_invoke_dynamic" + 3B];
                D.28024 = *D.28023;
                D.28025 = (int) D.28024;
                D.28026 = __s2 + 3;
                D.28027 = *D.28026;
                D.28028 = (int) D.28027;
                __result = D.28025 - D.28028;
                <D.28022>:
                <D.28012>:
                <D.28002>:
              }
              D.25804 = __result;
            }
            iftmp.60 = -D.25804;
            goto <D.28029>;
            <D.27992>:
            D.27855 = target->name;
            iftmp.60 = __builtin_strcmp (D.27855, "runtime_invoke_dynamic");
            <D.28029>:
            D.25805 = iftmp.60;
          }
          if (D.25805 != 0) goto <D.28030>; else goto <D.28031>;
          <D.28030>:
          D.27729 = 0;
          return D.27729;
          <D.28031>:
          ref->method = target;
          goto <D.28032>;
          <D.27989>:
          if (subtype == 13) goto <D.28033>; else goto <D.28034>;
          <D.28033>:
          {
            struct MonoMethod * m;

            p.54 = p;
            m = decode_resolve_method_ref (module, p.54, &p);
            if (m == 0B) goto <D.28035>; else goto <D.28036>;
            <D.28035>:
            D.27729 = 0;
            return D.27729;
            <D.28036>:
            D.28037 = mono_marshal_get_runtime_invoke (m, 0);
            ref->method = D.28037;
          }
          goto <D.28038>;
          <D.28034>:
          if (subtype == 14) goto <D.28039>; else goto <D.28040>;
          <D.28039>:
          {
            struct MonoMethod * m;

            p.54 = p;
            m = decode_resolve_method_ref (module, p.54, &p);
            if (m == 0B) goto <D.28041>; else goto <D.28042>;
            <D.28041>:
            D.27729 = 0;
            return D.27729;
            <D.28042>:
            D.28043 = mono_marshal_get_runtime_invoke (m, 1);
            ref->method = D.28043;
          }
          goto <D.28044>;
          <D.28040>:
          {
            struct MonoMethodSignature * sig;
            struct WrapperInfo * info;

            p.54 = p;
            sig = decode_signature_with_target (module, 0B, p.54, &p);
            info = mono_marshal_get_wrapper_info (target);
            D.28045 = info == 0B;
            D.28046 = (long int) D.28045;
            D.28047 = __builtin_expect (D.28046, 0);
            if (D.28047 != 0) goto <D.28048>; else goto <D.28049>;
            <D.28048>:
            monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "aot-runtime.c", 1044, "info");
            <D.28049>:
            D.28050 = info->subtype;
            subtype.61 = (unsigned int) subtype;
            if (D.28050 != subtype.61) goto <D.28052>; else goto <D.28053>;
            <D.28052>:
            D.27729 = 0;
            return D.27729;
            <D.28053>:
            D.28054 = info->d.runtime_invoke.sig;
            D.28055 = D.28054 == 0B;
            D.28056 = (long int) D.28055;
            D.28057 = __builtin_expect (D.28056, 0);
            if (D.28057 != 0) goto <D.28058>; else goto <D.28059>;
            <D.28058>:
            monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "aot-runtime.c", 1048, "info->d.runtime_invoke.sig");
            <D.28059>:
            D.28054 = info->d.runtime_invoke.sig;
            D.28060 = mono_metadata_signature_equal (sig, D.28054);
            if (D.28060 != 0) goto <D.28061>; else goto <D.28062>;
            <D.28061>:
            ref->method = target;
            goto <D.28063>;
            <D.28062>:
            D.27729 = 0;
            return D.27729;
            <D.28063>:
          }
          <D.28044>:
          <D.28038>:
          <D.28032>:
          goto <D.25730>;
        }
        <D.25810>:
        <D.25811>:
        <D.25812>:
        {
          gboolean is_inflated;
          WrapperSubtype subtype;

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

            p.54 = p;
            klass = decode_klass_ref (module, p.54, &p);
            if (klass == 0B) goto <D.28066>; else goto <D.28067>;
            <D.28066>:
            D.27729 = 0;
            return D.27729;
            <D.28067>:
            switch (wrapper_type) <default: <D.25822>, case 1: <D.25818>, case 2: <D.25820>, case 3: <D.25821>>
            <D.25818>:
            invoke = mono_get_delegate_invoke (klass);
            wrapper = mono_marshal_get_delegate_invoke (invoke, 0B);
            goto <D.25819>;
            <D.25820>:
            invoke = mono_get_delegate_begin_invoke (klass);
            wrapper = mono_marshal_get_delegate_begin_invoke (invoke);
            goto <D.25819>;
            <D.25821>:
            invoke = mono_get_delegate_end_invoke (klass);
            wrapper = mono_marshal_get_delegate_end_invoke (invoke);
            goto <D.25819>;
            <D.25822>:
            monoeg_assertion_message ("* Assertion: should not be reached at %s:%d\n", "aot-runtime.c", 1084);
            <D.25819>:
            D.28068 = target != 0B;
            D.28069 = wrapper != target;
            D.28070 = D.28068 & D.28069;
            if (D.28070 != 0) goto <D.28071>; else goto <D.28072>;
            <D.28071>:
            D.27729 = 0;
            return D.27729;
            <D.28072>:
            ref->method = wrapper;
          }
          goto <D.28073>;
          <D.28065>:
          if (target == 0B) goto <D.28074>; else goto <D.28075>;
          <D.28074>:
          D.27729 = 0;
          return D.27729;
          <D.28075>:
          if (wrapper_type == 1) goto <D.28076>; else goto <D.28077>;
          <D.28076>:
          {
            struct WrapperInfo * info;

            p.54 = p;
            D.28078 = decode_value (p.54, &p);
            subtype = (WrapperSubtype) D.28078;
            info = mono_marshal_get_wrapper_info (target);
            if (info != 0B) goto <D.28079>; else goto <D.28080>;
            <D.28079>:
            D.28081 = info->subtype;
            if (D.28081 != subtype) goto <D.28082>; else goto <D.28083>;
            <D.28082>:
            D.27729 = 0;
            return D.27729;
            <D.28083>:
            goto <D.28084>;
            <D.28080>:
            if (subtype != 0) goto <D.28085>; else goto <D.28086>;
            <D.28085>:
            D.27729 = 0;
            return D.27729;
            <D.28086>:
            <D.28084>:
          }
          <D.28077>:
          p.54 = p;
          D.28087 = sig_matches_target (module, target, p.54, &p);
          if (D.28087 != 0) goto <D.28088>; else goto <D.28089>;
          <D.28088>:
          ref->method = target;
          goto <D.28090>;
          <D.28089>:
          D.27729 = 0;
          return D.27729;
          <D.28090>:
          <D.28073>:
          goto <D.25730>;
        }
        <D.25824>:
        {
          struct MonoMethod * m;
          struct MonoClass * klass;

          p.54 = p;
          m = decode_resolve_method_ref (module, p.54, &p);
          if (m == 0B) goto <D.28091>; else goto <D.28092>;
          <D.28091>:
          D.27729 = 0;
          return D.27729;
          <D.28092>:
          p.54 = p;
          klass = decode_klass_ref (module, p.54, &p);
          if (klass == 0B) goto <D.28093>; else goto <D.28094>;
          <D.28093>:
          D.27729 = 0;
          return D.27729;
          <D.28094>:
          D.28095 = mono_marshal_get_managed_wrapper (m, klass, 0);
          ref->method = D.28095;
          goto <D.25730>;
        }
        <D.25827>:
        monoeg_assertion_message ("* Assertion: should not be reached at %s:%d\n", "aot-runtime.c", 1132);
        <D.25730>:
      }
      goto <D.28096>;
      <D.27731>:
      if (image_index == 254) goto <D.28097>; else goto <D.28098>;
      <D.28097>:
      p.54 = p;
      D.28099 = decode_value (p.54, &p);
      image_index = (guint32) D.28099;
      p.54 = p;
      D.28100 = decode_value (p.54, &p);
      D.28101 = (unsigned int) D.28100;
      ref->token = D.28101;
      image_index.62 = (int) image_index;
      image = load_image (module, image_index.62, 1);
      if (image == 0B) goto <D.28103>; else goto <D.28104>;
      <D.28103>:
      D.27729 = 0;
      return D.27729;
      <D.28104>:
      goto <D.28105>;
      <D.28098>:
      if (image_index == 253) goto <D.28106>; else goto <D.28107>;
      <D.28106>:
      {
        struct MonoClass * klass;
        struct MonoGenericContext ctx;

        try
          {
            p.54 = p;
            klass = decode_klass_ref (module, p.54, &p);
            if (klass == 0B) goto <D.28108>; else goto <D.28109>;
            <D.28108>:
            D.27729 = 0;
            return D.27729;
            <D.28109>:
            if (target != 0B) goto <D.28110>; else goto <D.28111>;
            <D.28110>:
            D.27810 = target->klass;
            if (D.27810 != klass) goto <D.28112>; else goto <D.28113>;
            <D.28112>:
            D.27729 = 0;
            return D.27729;
            <D.28113>:
            <D.28111>:
            p.54 = p;
            D.28114 = decode_value (p.54, &p);
            image_index = (guint32) D.28114;
            p.54 = p;
            D.28115 = decode_value (p.54, &p);
            D.28116 = (unsigned int) D.28115;
            ref->token = D.28116;
            image_index.62 = (int) image_index;
            image = load_image (module, image_index.62, 1);
            if (image == 0B) goto <D.28117>; else goto <D.28118>;
            <D.28117>:
            D.27729 = 0;
            return D.27729;
            <D.28118>:
            D.28119 = ref->token;
            D.28120 = mono_get_method_full (image, D.28119, 0B, 0B);
            ref->method = D.28120;
            D.27768 = ref->method;
            if (D.27768 == 0B) goto <D.28121>; else goto <D.28122>;
            <D.28121>:
            D.27729 = 0;
            return D.27729;
            <D.28122>:
            memset (&ctx, 0, 8);
            if (0 != 0) goto <D.28123>; else goto <D.28124>;
            <D.28123>:
            D.28125 = klass->generic_class;
            D.28126 = D.28125->context.class_inst;
            ctx.class_inst = D.28126;
            ctx.method_inst = 0B;
            D.27768 = ref->method;
            D.28127 = mono_class_inflate_generic_method_full (D.27768, klass, &ctx);
            ref->method = D.28127;
            <D.28124>:
            memset (&ctx, 0, 8);
            p.54 = p;
            D.28128 = decode_generic_context (module, &ctx, p.54, &p);
            if (D.28128 == 0) goto <D.28129>; else goto <D.28130>;
            <D.28129>:
            D.27729 = 0;
            return D.27729;
            <D.28130>:
            D.27768 = ref->method;
            D.28131 = mono_class_inflate_generic_method_full (D.27768, klass, &ctx);
            ref->method = D.28131;
          }
        finally
          {
            ctx = {CLOBBER};
          }
      }
      goto <D.28132>;
      <D.28107>:
      if (image_index == 250) goto <D.28133>; else goto <D.28134>;
      <D.28133>:
      {
        struct MonoClass * klass;
        int method_type;

        p.54 = p;
        klass = decode_klass_ref (module, p.54, &p);
        if (klass == 0B) goto <D.28135>; else goto <D.28136>;
        <D.28135>:
        D.27729 = 0;
        return D.27729;
        <D.28136>:
        p.54 = p;
        method_type = decode_value (p.54, &p);
        switch (method_type) <default: <D.25838>, case 0: <D.25832>, case 1: <D.25834>, case 2: <D.25835>, case 3: <D.25836>, case 4: <D.25837>>
        <D.25832>:
        D.28137 = klass->rank;
        D.28138 = (int) D.28137;
        D.28139 = mono_class_get_method_from_name (klass, ".ctor", D.28138);
        ref->method = D.28139;
        goto <D.25833>;
        <D.25834>:
        D.28137 = klass->rank;
        D.28138 = (int) D.28137;
        D.28140 = D.28138 * 2;
        D.28141 = mono_class_get_method_from_name (klass, ".ctor", D.28140);
        ref->method = D.28141;
        goto <D.25833>;
        <D.25835>:
        D.28142 = mono_class_get_method_from_name (klass, "Get", -1);
        ref->method = D.28142;
        goto <D.25833>;
        <D.25836>:
        D.28143 = mono_class_get_method_from_name (klass, "Address", -1);
        ref->method = D.28143;
        goto <D.25833>;
        <D.25837>:
        D.28144 = mono_class_get_method_from_name (klass, "Set", -1);
        ref->method = D.28144;
        goto <D.25833>;
        <D.25838>:
        monoeg_assertion_message ("* Assertion: should not be reached at %s:%d\n", "aot-runtime.c", 1207);
        <D.25833>:
      }
      goto <D.28145>;
      <D.28134>:
      if (image_index == 249) goto <D.28146>; else goto <D.28147>;
      <D.28146>:
      p.54 = p;
      D.28148 = decode_value (p.54, &p);
      image_index = (guint32) D.28148;
      p.54 = p;
      D.28149 = decode_value (p.54, &p);
      value = (guint32) D.28149;
      <D.28147>:
      D.28150 = value & 16777215;
      D.28151 = D.28150 | 100663296;
      ref->token = D.28151;
      image_index.62 = (int) image_index;
      image = load_image (module, image_index.62, 1);
      if (image == 0B) goto <D.28152>; else goto <D.28153>;
      <D.28152>:
      D.27729 = 0;
      return D.27729;
      <D.28153>:
      <D.28145>:
      <D.28132>:
      <D.28105>:
      <D.28096>:
      p.54 = p;
      *endbuf = p.54;
      ref->image = image;
      D.27729 = 1;
      return D.27729;
    }
  finally
    {
      p = {CLOBBER};
    }
}


decode_signature_with_target (struct MonoAotModule * module, struct MonoMethodSignature * target, guint8 * buf, guint8 * * endbuf)
{
  guint8 * p.63;
  unsigned char D.28159;
  guint8 * p.64;
  unsigned int D.28161;
  _Bool D.28162;
  unsigned int D.28163;
  _Bool D.28164;
  unsigned int D.28165;
  _Bool D.28166;
  int flags.65;
  short unsigned int D.28172;
  int D.28173;
  struct MonoMethodSignature * D.28176;
  unsigned int param_count.66;
  unsigned int D.28178;
  unsigned int D.28179;
  short unsigned int D.28180;
  unsigned char D.28181;
  <unnamed-unsigned:1> D.28182;
  unsigned char D.28183;
  <unnamed-unsigned:1> D.28184;
  unsigned char D.28185;
  <unnamed-unsigned:6> D.28186;
  struct MonoType * D.28187;
  unsigned char D.28190;
  unsigned char D.28191;
  _Bool D.28192;
  long int D.28193;
  long int D.28194;
  short int D.28197;
  struct MonoType * D.28198;
  short int D.28201;
  short unsigned int D.28204;
  short int D.28205;
  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.63 = p;
      D.28159 = *p.63;
      flags = (guint32) D.28159;
      p.63 = p;
      p.64 = p.63 + 1;
      p = p.64;
      D.28161 = flags & 16;
      D.28162 = D.28161 != 0;
      has_gen_params = (gboolean) D.28162;
      D.28163 = flags & 32;
      D.28164 = D.28163 != 0;
      hasthis = (gboolean) D.28164;
      D.28165 = flags & 64;
      D.28166 = D.28165 != 0;
      explicit_this = (gboolean) D.28166;
      flags.65 = (int) flags;
      call_conv = flags.65 & 15;
      if (has_gen_params != 0) goto <D.28168>; else goto <D.28169>;
      <D.28168>:
      p.63 = p;
      gen_param_count = decode_value (p.63, &p);
      <D.28169>:
      p.63 = p;
      param_count = decode_value (p.63, &p);
      if (target != 0B) goto <D.28170>; else goto <D.28171>;
      <D.28170>:
      D.28172 = target->param_count;
      D.28173 = (int) D.28172;
      if (D.28173 != param_count) goto <D.28174>; else goto <D.28175>;
      <D.28174>:
      D.28176 = 0B;
      return D.28176;
      <D.28175>:
      <D.28171>:
      param_count.66 = (unsigned int) param_count;
      D.28178 = param_count.66 + 3;
      D.28179 = D.28178 * 4;
      sig = monoeg_malloc0 (D.28179);
      D.28180 = (short unsigned int) param_count;
      sig->param_count = D.28180;
      sig->sentinelpos = -1;
      D.28181 = (unsigned char) hasthis;
      D.28182 = (<unnamed-unsigned:1>) D.28181;
      sig->hasthis = D.28182;
      D.28183 = (unsigned char) explicit_this;
      D.28184 = (<unnamed-unsigned:1>) D.28183;
      sig->explicit_this = D.28184;
      D.28185 = (unsigned char) call_conv;
      D.28186 = (<unnamed-unsigned:6>) D.28185;
      sig->call_convention = D.28186;
      D.28180 = (short unsigned int) param_count;
      sig->param_count = D.28180;
      p.63 = p;
      D.28187 = decode_type (module, p.63, &p);
      sig->ret = D.28187;
      i = 0;
      goto <D.25694>;
      <D.25693>:
      p.63 = p;
      D.28159 = *p.63;
      if (D.28159 == 65) goto <D.28188>; else goto <D.28189>;
      <D.28188>:
      D.28190 = BIT_FIELD_REF <*sig, 8, 80>;
      D.28191 = D.28190 & 63;
      D.28192 = D.28191 != 5;
      D.28193 = (long int) D.28192;
      D.28194 = __builtin_expect (D.28193, 0);
      if (D.28194 != 0) goto <D.28195>; else goto <D.28196>;
      <D.28195>:
      monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "aot-runtime.c", 706, "sig->call_convention == MONO_CALL_VARARG");
      <D.28196>:
      D.28197 = (short int) i;
      sig->sentinelpos = D.28197;
      p.63 = p;
      p.64 = p.63 + 1;
      p = p.64;
      <D.28189>:
      p.63 = p;
      D.28198 = decode_type (module, p.63, &p);
      sig->params[i] = D.28198;
      i = i + 1;
      <D.25694>:
      if (i < param_count) goto <D.25693>; else goto <D.25695>;
      <D.25695>:
      D.28190 = BIT_FIELD_REF <*sig, 8, 80>;
      D.28191 = D.28190 & 63;
      if (D.28191 == 5) goto <D.28199>; else goto <D.28200>;
      <D.28199>:
      D.28201 = sig->sentinelpos;
      if (D.28201 == -1) goto <D.28202>; else goto <D.28203>;
      <D.28202>:
      D.28204 = sig->param_count;
      D.28205 = (short int) D.28204;
      sig->sentinelpos = D.28205;
      <D.28203>:
      <D.28200>:
      p.63 = p;
      *endbuf = p.63;
      D.28176 = sig;
      return D.28176;
    }
  finally
    {
      p = {CLOBBER};
    }
}


decode_type (struct MonoAotModule * module, guint8 * buf, guint8 * * endbuf)
{
  guint8 * p.67;
  unsigned char D.28209;
  guint8 * p.68;
  unsigned char D.28215;
  int D.28216;
  struct MonoClass * D.28217;
  struct MonoClass * D.28218;
  struct MonoClass * D.28219;
  struct MonoType * D.28222;
  struct MonoType * D.28223;
  struct MonoGenericContainer * D.28226;
  _Bool D.28227;
  long int D.28228;
  long int D.28229;
  struct MonoGenericInst * D.28232;
  struct MonoGenericInst * D.28233;
  struct MonoType * D.28236;
  struct MonoGenericClass * D.28237;
  struct MonoClass * D.28238;
  struct MonoClass * D.28239;
  int D.28242;
  unsigned char D.28243;
  int D.28244;
  unsigned char D.28245;
  unsigned char D.28246;
  unsigned int D.28249;
  unsigned int D.28250;
  void * D.28251;
  int * D.28252;
  unsigned int i.69;
  unsigned int D.28254;
  int * D.28255;
  int D.28256;
  int D.28257;
  int D.28258;
  unsigned char D.28259;
  unsigned char D.28260;
  unsigned int D.28263;
  unsigned int D.28264;
  void * D.28265;
  int * D.28266;
  int * D.28267;
  int D.28268;
  int D.28269;
  struct MonoGenericParam * D.28272;
  guint8 * p;
  struct MonoType * t;

  try
    {
      p = buf;
      t = monoeg_malloc0 (8);
      <D.25635>:
      p.67 = p;
      D.28209 = *p.67;
      if (D.28209 == 69) goto <D.28210>; else goto <D.28211>;
      <D.28210>:
      t->pinned = 1;
      p.67 = p;
      p.68 = p.67 + 1;
      p = p.68;
      goto <D.28213>;
      <D.28211>:
      p.67 = p;
      D.28209 = *p.67;
      if (D.28209 == 16) goto <D.28214>; else goto <D.25634>;
      <D.28214>:
      t->byref = 1;
      p.67 = p;
      p.68 = p.67 + 1;
      p = p.68;
      <D.28213>:
      goto <D.25635>;
      <D.25634>:
      p.67 = p;
      D.28209 = *p.67;
      t->type = D.28209;
      p.67 = p;
      p.68 = p.67 + 1;
      p = p.68;
      D.28215 = t->type;
      D.28216 = (int) D.28215;
      switch (D.28216) <default: <D.25676>, case 1: <D.25636>, case 2: <D.25637>, case 3: <D.25638>, case 4: <D.25639>, case 5: <D.25640>, case 6: <D.25641>, case 7: <D.25642>, case 8: <D.25643>, case 9: <D.25644>, case 10: <D.25645>, case 11: <D.25646>, case 12: <D.25647>, case 13: <D.25648>, case 14: <D.25651>, case 15: <D.25658>, case 17: <D.25655>, case 18: <D.25656>, case 19: <D.25673>, case 20: <D.25664>, case 21: <D.25659>, case 22: <D.25653>, case 24: <D.25649>, case 25: <D.25650>, case 28: <D.25652>, case 29: <D.25657>, case 30: <D.25674>>
      <D.25636>:
      <D.25637>:
      <D.25638>:
      <D.25639>:
      <D.25640>:
      <D.25641>:
      <D.25642>:
      <D.25643>:
      <D.25644>:
      <D.25645>:
      <D.25646>:
      <D.25647>:
      <D.25648>:
      <D.25649>:
      <D.25650>:
      <D.25651>:
      <D.25652>:
      <D.25653>:
      goto <D.25654>;
      <D.25655>:
      <D.25656>:
      p.67 = p;
      D.28217 = decode_klass_ref (module, p.67, &p);
      t->data.klass = D.28217;
      goto <D.25654>;
      <D.25657>:
      p.67 = p;
      D.28218 = decode_klass_ref (module, p.67, &p);
      t->data.klass = D.28218;
      D.28219 = t->data.klass;
      if (D.28219 == 0B) goto <D.28220>; else goto <D.28221>;
      <D.28220>:
      D.28222 = 0B;
      return D.28222;
      <D.28221>:
      goto <D.25654>;
      <D.25658>:
      p.67 = p;
      D.28223 = decode_type (module, p.67, &p);
      t->data.type = D.28223;
      goto <D.25654>;
      <D.25659>:
      {
        struct MonoClass * gclass;
        struct MonoGenericContext ctx;
        struct MonoType * type;
        struct MonoClass * klass;

        try
          {
            p.67 = p;
            gclass = decode_klass_ref (module, p.67, &p);
            if (gclass == 0B) goto <D.28224>; else goto <D.28225>;
            <D.28224>:
            D.28222 = 0B;
            return D.28222;
            <D.28225>:
            D.28226 = gclass->generic_container;
            D.28227 = D.28226 == 0B;
            D.28228 = (long int) D.28227;
            D.28229 = __builtin_expect (D.28228, 0);
            if (D.28229 != 0) goto <D.28230>; else goto <D.28231>;
            <D.28230>:
            monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "aot-runtime.c", 620, "gclass->generic_container");
            <D.28231>:
            memset (&ctx, 0, 8);
            p.67 = p;
            D.28232 = decode_generic_inst (module, p.67, &p);
            ctx.class_inst = D.28232;
            D.28233 = ctx.class_inst;
            if (D.28233 == 0B) goto <D.28234>; else goto <D.28235>;
            <D.28234>:
            D.28222 = 0B;
            return D.28222;
            <D.28235>:
            D.28236 = &gclass->byval_arg;
            type = mono_class_inflate_generic_type (D.28236, &ctx);
            klass = mono_class_from_mono_type (type);
            D.28237 = klass->generic_class;
            t->data.generic_class = D.28237;
            goto <D.25654>;
          }
        finally
          {
            ctx = {CLOBBER};
          }
      }
      <D.25664>:
      {
        struct MonoArrayType * array;
        int i;

        array = monoeg_malloc0 (16);
        p.67 = p;
        D.28238 = decode_klass_ref (module, p.67, &p);
        array->eklass = D.28238;
        D.28239 = array->eklass;
        if (D.28239 == 0B) goto <D.28240>; else goto <D.28241>;
        <D.28240>:
        D.28222 = 0B;
        return D.28222;
        <D.28241>:
        p.67 = p;
        D.28242 = decode_value (p.67, &p);
        D.28243 = (unsigned char) D.28242;
        array->rank = D.28243;
        p.67 = p;
        D.28244 = decode_value (p.67, &p);
        D.28245 = (unsigned char) D.28244;
        array->numsizes = D.28245;
        D.28246 = array->numsizes;
        if (D.28246 != 0) goto <D.28247>; else goto <D.28248>;
        <D.28247>:
        D.28246 = array->numsizes;
        D.28249 = (unsigned int) D.28246;
        D.28250 = D.28249 * 4;
        D.28251 = monoeg_malloc0 (D.28250);
        array->sizes = D.28251;
        <D.28248>:
        i = 0;
        goto <D.25668>;
        <D.25667>:
        D.28252 = array->sizes;
        i.69 = (unsigned int) i;
        D.28254 = i.69 * 4;
        D.28255 = D.28252 + D.28254;
        p.67 = p;
        D.28256 = decode_value (p.67, &p);
        *D.28255 = D.28256;
        i = i + 1;
        <D.25668>:
        D.28246 = array->numsizes;
        D.28257 = (int) D.28246;
        if (D.28257 > i) goto <D.25667>; else goto <D.25669>;
        <D.25669>:
        p.67 = p;
        D.28258 = decode_value (p.67, &p);
        D.28259 = (unsigned char) D.28258;
        array->numlobounds = D.28259;
        D.28260 = array->numlobounds;
        if (D.28260 != 0) goto <D.28261>; else goto <D.28262>;
        <D.28261>:
        D.28260 = array->numlobounds;
        D.28263 = (unsigned int) D.28260;
        D.28264 = D.28263 * 4;
        D.28265 = monoeg_malloc0 (D.28264);
        array->lobounds = D.28265;
        <D.28262>:
        i = 0;
        goto <D.25671>;
        <D.25670>:
        D.28266 = array->lobounds;
        i.69 = (unsigned int) i;
        D.28254 = i.69 * 4;
        D.28267 = D.28266 + D.28254;
        p.67 = p;
        D.28268 = decode_value (p.67, &p);
        *D.28267 = D.28268;
        i = i + 1;
        <D.25671>:
        D.28260 = array->numlobounds;
        D.28269 = (int) D.28260;
        if (D.28269 > i) goto <D.25670>; else goto <D.25672>;
        <D.25672>:
        t->data.array = array;
        goto <D.25654>;
      }
      <D.25673>:
      <D.25674>:
      {
        struct MonoClass * klass;

        p.67 = p;
        klass = decode_klass_ref (module, p.67, &p);
        if (klass == 0B) goto <D.28270>; else goto <D.28271>;
        <D.28270>:
        D.28222 = 0B;
        return D.28222;
        <D.28271>:
        D.28272 = klass->byval_arg.data.generic_param;
        t->data.generic_param = D.28272;
        goto <D.25654>;
      }
      <D.25676>:
      monoeg_assertion_message ("* Assertion: should not be reached at %s:%d\n", "aot-runtime.c", 665);
      <D.25654>:
      p.67 = p;
      *endbuf = p.67;
      D.28222 = t;
      return D.28222;
    }
  finally
    {
      p = {CLOBBER};
    }
}


decode_generic_inst (struct MonoAotModule * module, guint8 * buf, guint8 * * endbuf)
{
  guint8 * p.70;
  unsigned int type_argc.71;
  unsigned int D.28280;
  struct MonoGenericInst * D.28283;
  unsigned int i.72;
  unsigned int D.28285;
  struct MonoType * * D.28286;
  struct MonoType * D.28287;
  int type_argc;
  int i;
  struct MonoType * * type_argv;
  struct MonoGenericInst * inst;
  guint8 * p;

  try
    {
      p = buf;
      p.70 = p;
      type_argc = decode_value (p.70, &p);
      type_argc.71 = (unsigned int) type_argc;
      D.28280 = type_argc.71 * 4;
      type_argv = monoeg_malloc0 (D.28280);
      i = 0;
      goto <D.25569>;
      <D.25568>:
      {
        struct MonoClass * pclass;

        p.70 = p;
        pclass = decode_klass_ref (module, p.70, &p);
        if (pclass == 0B) goto <D.28281>; else goto <D.28282>;
        <D.28281>:
        monoeg_g_free (type_argv);
        D.28283 = 0B;
        return D.28283;
        <D.28282>:
        i.72 = (unsigned int) i;
        D.28285 = i.72 * 4;
        D.28286 = type_argv + D.28285;
        D.28287 = &pclass->byval_arg;
        *D.28286 = D.28287;
      }
      i = i + 1;
      <D.25569>:
      if (i < type_argc) goto <D.25568>; else goto <D.25570>;
      <D.25570>:
      inst = mono_metadata_get_generic_inst (type_argc, type_argv);
      monoeg_g_free (type_argv);
      p.70 = p;
      *endbuf = p.70;
      D.28283 = inst;
      return D.28283;
    }
  finally
    {
      p = {CLOBBER};
    }
}


sig_matches_target (struct MonoAotModule * module, struct MonoMethod * target, guint8 * buf, guint8 * * endbuf)
{
  struct MonoMethodSignature * D.28290;
  guint8 * p.73;
  int iftmp.74;
  struct MonoMethodSignature * D.28296;
  int D.28297;
  gboolean D.28299;
  struct MonoMethodSignature * sig;
  gboolean res;
  guint8 * p;

  try
    {
      p = buf;
      D.28290 = mono_method_signature (target);
      p.73 = p;
      sig = decode_signature_with_target (module, D.28290, p.73, &p);
      if (sig != 0B) goto <D.28295>; else goto <D.28293>;
      <D.28295>:
      D.28296 = mono_method_signature (target);
      D.28297 = mono_metadata_signature_equal (D.28296, sig);
      if (D.28297 != 0) goto <D.28298>; else goto <D.28293>;
      <D.28298>:
      iftmp.74 = 1;
      goto <D.28294>;
      <D.28293>:
      iftmp.74 = 0;
      <D.28294>:
      res = iftmp.74;
      monoeg_g_free (sig);
      p.73 = p;
      *endbuf = p.73;
      D.28299 = res;
      return D.28299;
    }
  finally
    {
      p = {CLOBBER};
    }
}


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

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


decode_resolve_method_ref_with_target (struct MonoAotModule * module, struct MonoMethod * target, guint8 * buf, guint8 * * endbuf)
{
  struct MonoMethod * D.28306;
  struct MonoMethod * D.28307;
  struct MonoImage * D.28310;
  unsigned int D.28313;
  struct MethodRef ref;
  gboolean res;

  try
    {
      res = decode_method_ref_with_target (module, &ref, target, buf, endbuf);
      if (res == 0) goto <D.28304>; else goto <D.28305>;
      <D.28304>:
      D.28306 = 0B;
      return D.28306;
      <D.28305>:
      D.28307 = ref.method;
      if (D.28307 != 0B) goto <D.28308>; else goto <D.28309>;
      <D.28308>:
      D.28306 = ref.method;
      return D.28306;
      <D.28309>:
      D.28310 = ref.image;
      if (D.28310 == 0B) goto <D.28311>; else goto <D.28312>;
      <D.28311>:
      D.28306 = 0B;
      return D.28306;
      <D.28312>:
      D.28310 = ref.image;
      D.28313 = ref.token;
      D.28306 = mono_get_method (D.28310, D.28313, 0B);
      return D.28306;
    }
  finally
    {
      ref = {CLOBBER};
    }
}


decode_generic_context (struct MonoAotModule * module, struct MonoGenericContext * ctx, guint8 * buf, guint8 * * endbuf)
{
  guint8 * p.75;
  struct MonoGenericInst * D.28319;
  struct MonoGenericInst * D.28320;
  gboolean D.28323;
  struct MonoGenericInst * D.28326;
  struct MonoGenericInst * D.28327;
  guint8 * p;
  guint8 * p2;
  int argc;

  try
    {
      p = buf;
      p2 = p;
      p.75 = p;
      argc = decode_value (p.75, &p);
      if (argc != 0) goto <D.28317>; else goto <D.28318>;
      <D.28317>:
      p = p2;
      p.75 = p;
      D.28319 = decode_generic_inst (module, p.75, &p);
      ctx->class_inst = D.28319;
      D.28320 = ctx->class_inst;
      if (D.28320 == 0B) goto <D.28321>; else goto <D.28322>;
      <D.28321>:
      D.28323 = 0;
      return D.28323;
      <D.28322>:
      <D.28318>:
      p2 = p;
      p.75 = p;
      argc = decode_value (p.75, &p);
      if (argc != 0) goto <D.28324>; else goto <D.28325>;
      <D.28324>:
      p = p2;
      p.75 = p;
      D.28326 = decode_generic_inst (module, p.75, &p);
      ctx->method_inst = D.28326;
      D.28327 = ctx->method_inst;
      if (D.28327 == 0B) goto <D.28328>; else goto <D.28329>;
      <D.28328>:
      D.28323 = 0;
      return D.28323;
      <D.28329>:
      <D.28325>:
      p.75 = p;
      *endbuf = p.75;
      D.28323 = 1;
      return D.28323;
    }
  finally
    {
      p = {CLOBBER};
    }
}


decode_klass_ref (struct MonoAotModule * module, guint8 * buf, guint8 * * endbuf)
{
  guint8 * p.76;
  struct MonoClass * D.28335;
  int D.28336;
  unsigned int D.28339;
  int D.28340;
  int D.28341;
  int D.28344;
  struct MonoAssembly * D.28345;
  struct MonoGenericContainer * D.28350;
  _Bool D.28351;
  long int D.28352;
  long int D.28353;
  struct MonoGenericInst * D.28356;
  struct MonoGenericInst * D.28357;
  struct MonoType * D.28360;
  _Bool D.28365;
  long int D.28366;
  long int D.28367;
  _Bool D.28373;
  long int D.28374;
  long int D.28375;
  unsigned char D.28381;
  struct MonoGenericParamFull * D.28384;
  unsigned int num.77;
  unsigned int D.28386;
  struct MonoGenericParam * D.28387;
  _Bool D.28388;
  long int D.28389;
  long int D.28390;
  short unsigned int D.28394;
  short unsigned int D.28395;
  struct MonoImage * D.28396;
  int D.28397;
  int D.28400;
  guint8 * D.28401;
  guint8 * p2.78;
  guint8 * p2.79;
  _Bool D.28404;
  long int D.28405;
  long int D.28406;
  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.76 = p;
      reftype = decode_value (p.76, &p);
      if (reftype == 0) goto <D.28333>; else goto <D.28334>;
      <D.28333>:
      p.76 = p;
      *endbuf = p.76;
      D.28335 = 0B;
      return D.28335;
      <D.28334>:
      switch (reftype) <default: <D.25618>, case 1: <D.25593>, case 2: <D.25595>, case 3: <D.25596>, case 4: <D.25597>, case 5: <D.25601>, case 6: <D.25612>, case 7: <D.25615>, case 8: <D.25613>>
      <D.25593>:
      p.76 = p;
      D.28336 = decode_value (p.76, &p);
      idx = (guint32) D.28336;
      image = load_image (module, 0, 1);
      if (image == 0B) goto <D.28337>; else goto <D.28338>;
      <D.28337>:
      D.28335 = 0B;
      return D.28335;
      <D.28338>:
      D.28339 = idx + 33554432;
      klass = mono_class_get (image, D.28339);
      goto <D.25594>;
      <D.25595>:
      p.76 = p;
      D.28340 = decode_value (p.76, &p);
      idx = (guint32) D.28340;
      p.76 = p;
      D.28341 = decode_value (p.76, &p);
      image = load_image (module, D.28341, 1);
      if (image == 0B) goto <D.28342>; else goto <D.28343>;
      <D.28342>:
      D.28335 = 0B;
      return D.28335;
      <D.28343>:
      D.28339 = idx + 33554432;
      klass = mono_class_get (image, D.28339);
      goto <D.25594>;
      <D.25596>:
      p.76 = p;
      D.28344 = decode_value (p.76, &p);
      token = (guint32) D.28344;
      D.28345 = module->assembly;
      image = D.28345->image;
      if (image == 0B) goto <D.28346>; else goto <D.28347>;
      <D.28346>:
      D.28335 = 0B;
      return D.28335;
      <D.28347>:
      klass = mono_class_get (image, token);
      goto <D.25594>;
      <D.25597>:
      {
        struct MonoClass * gclass;
        struct MonoGenericContext ctx;
        struct MonoType * type;

        try
          {
            p.76 = p;
            gclass = decode_klass_ref (module, p.76, &p);
            if (gclass == 0B) goto <D.28348>; else goto <D.28349>;
            <D.28348>:
            D.28335 = 0B;
            return D.28335;
            <D.28349>:
            D.28350 = gclass->generic_container;
            D.28351 = D.28350 == 0B;
            D.28352 = (long int) D.28351;
            D.28353 = __builtin_expect (D.28352, 0);
            if (D.28353 != 0) goto <D.28354>; else goto <D.28355>;
            <D.28354>:
            monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "aot-runtime.c", 435, "gclass->generic_container");
            <D.28355>:
            memset (&ctx, 0, 8);
            p.76 = p;
            D.28356 = decode_generic_inst (module, p.76, &p);
            ctx.class_inst = D.28356;
            D.28357 = ctx.class_inst;
            if (D.28357 == 0B) goto <D.28358>; else goto <D.28359>;
            <D.28358>:
            D.28335 = 0B;
            return D.28335;
            <D.28359>:
            D.28360 = &gclass->byval_arg;
            type = mono_class_inflate_generic_type (D.28360, &ctx);
            klass = mono_class_from_mono_type (type);
            mono_metadata_free_type (type);
            goto <D.25594>;
          }
        finally
          {
            ctx = {CLOBBER};
          }
      }
      <D.25601>:
      {
        struct MonoType * t;
        struct MonoGenericContainer * container;
        int type;
        int num;
        gboolean has_container;
        int serial;

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

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

            D.28365 = type != 30;
            D.28366 = (long int) D.28365;
            D.28367 = __builtin_expect (D.28366, 0);
            if (D.28367 != 0) goto <D.28368>; else goto <D.28369>;
            <D.28368>:
            monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "aot-runtime.c", 459, "type == MONO_TYPE_MVAR");
            <D.28369>:
            p.76 = p;
            method_def = decode_resolve_method_ref (module, p.76, &p);
            if (method_def == 0B) goto <D.28370>; else goto <D.28371>;
            <D.28370>:
            D.28335 = 0B;
            return D.28335;
            <D.28371>:
            container = mono_method_get_generic_container (method_def);
          }
          goto <D.28372>;
          <D.28364>:
          {
            struct MonoClass * class_def;

            D.28373 = type != 19;
            D.28374 = (long int) D.28373;
            D.28375 = __builtin_expect (D.28374, 0);
            if (D.28375 != 0) goto <D.28376>; else goto <D.28377>;
            <D.28376>:
            monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "aot-runtime.c", 467, "type == MONO_TYPE_VAR");
            <D.28377>:
            p.76 = p;
            class_def = decode_klass_ref (module, p.76, &p);
            if (class_def == 0B) goto <D.28378>; else goto <D.28379>;
            <D.28378>:
            D.28335 = 0B;
            return D.28335;
            <D.28379>:
            container = class_def->generic_container;
          }
          <D.28372>:
        }
        goto <D.28380>;
        <D.28362>:
        p.76 = p;
        serial = decode_value (p.76, &p);
        <D.28380>:
        t = monoeg_malloc0 (8);
        D.28381 = (unsigned char) type;
        t->type = D.28381;
        if (container != 0B) goto <D.28382>; else goto <D.28383>;
        <D.28382>:
        D.28384 = container->type_params;
        num.77 = (unsigned int) num;
        D.28386 = num.77 * 32;
        D.28387 = D.28384 + D.28386;
        t->data.generic_param = D.28387;
        D.28388 = serial != 0;
        D.28389 = (long int) D.28388;
        D.28390 = __builtin_expect (D.28389, 0);
        if (D.28390 != 0) goto <D.28391>; else goto <D.28392>;
        <D.28391>:
        monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "aot-runtime.c", 483, "serial == 0");
        <D.28392>:
        goto <D.28393>;
        <D.28383>:
        {
          struct MonoGenericParam * par;

          par = monoeg_malloc0 (32);
          D.28394 = (short unsigned int) num;
          par->num = D.28394;
          D.28395 = (short unsigned int) serial;
          par->serial = D.28395;
          D.28396 = mono_defaults.corlib;
          par->image = D.28396;
          t->data.generic_param = par;
        }
        <D.28393>:
        klass = mono_class_from_mono_type (t);
        monoeg_g_free (t);
        goto <D.25594>;
      }
      <D.25612>:
      p.76 = p;
      D.28397 = decode_value (p.76, &p);
      rank = (guint32) D.28397;
      p.76 = p;
      eklass = decode_klass_ref (module, p.76, &p);
      klass = mono_array_class_get (eklass, rank);
      goto <D.25594>;
      <D.25613>:
      {
        struct MonoType * t;

        p.76 = p;
        t = decode_type (module, p.76, &p);
        if (t == 0B) goto <D.28398>; else goto <D.28399>;
        <D.28398>:
        D.28335 = 0B;
        return D.28335;
        <D.28399>:
        klass = mono_class_from_mono_type (t);
        monoeg_g_free (t);
        goto <D.25594>;
      }
      <D.25615>:
      {
        guint32 offset;
        guint8 * p2;

        try
          {
            p.76 = p;
            D.28400 = decode_value (p.76, &p);
            offset = (guint32) D.28400;
            D.28401 = module->blob;
            p2.78 = D.28401 + offset;
            p2 = p2.78;
            p2.79 = p2;
            klass = decode_klass_ref (module, p2.79, &p2);
            goto <D.25594>;
          }
        finally
          {
            p2 = {CLOBBER};
          }
      }
      <D.25618>:
      monoeg_assertion_message ("* Assertion: should not be reached at %s:%d\n", "aot-runtime.c", 526);
      <D.25594>:
      D.28404 = klass == 0B;
      D.28405 = (long int) D.28404;
      D.28406 = __builtin_expect (D.28405, 0);
      if (D.28406 != 0) goto <D.28407>; else goto <D.28408>;
      <D.28407>:
      monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "aot-runtime.c", 528, "klass");
      <D.28408>:
      p.76 = p;
      *endbuf = p.76;
      D.28335 = klass;
      return D.28335;
    }
  finally
    {
      p = {CLOBBER};
    }
}


mono_aot_get_cached_class_info (struct MonoClass * klass, struct MonoCachedClassInfo * res)
{
  struct MonoImage * D.28414;
  unsigned char D.28417;
  gboolean D.28419;
  guint8 * D.28420;
  guint32 * D.28421;
  unsigned int D.28422;
  unsigned int D.28423;
  unsigned int D.28424;
  int D.28425;
  unsigned int D.28426;
  guint8 * p.80;
  guint8 * p.81;
  struct MonoAotModule * amodule;
  guint8 * p;
  gboolean err;

  try
    {
      D.28414 = klass->image;
      amodule = D.28414->aot_module;
      D.28417 = klass->rank;
      if (D.28417 != 0) goto <D.28415>; else goto <D.28418>;
      <D.28418>:
      if (amodule == 0B) goto <D.28415>; else goto <D.28416>;
      <D.28415>:
      D.28419 = 0;
      return D.28419;
      <D.28416>:
      D.28420 = amodule->blob;
      D.28421 = amodule->class_info_offsets;
      D.28422 = klass->type_token;
      D.28423 = D.28422 & 16777215;
      D.28424 = D.28423 + 4294967295;
      D.28425 = (int) D.28424;
      D.28426 = mono_aot_get_offset (D.28421, D.28425);
      p.80 = D.28420 + D.28426;
      p = p.80;
      p.81 = p;
      err = decode_cached_class_info (amodule, res, p.81, &p);
      if (err == 0) goto <D.28429>; else goto <D.28430>;
      <D.28429>:
      D.28419 = 0;
      return D.28419;
      <D.28430>:
      D.28419 = 1;
      return D.28419;
    }
  finally
    {
      p = {CLOBBER};
    }
}


mono_aot_get_class_from_name (struct MonoImage * image, const char * name_space, const char * name, struct MonoClass * * klass)
{
  guint16 * D.28436;
  gboolean D.28437;
  _Bool D.28440;
  long int D.28441;
  long int D.28442;
  struct GHashTable * D.28445;
  struct GHashTable * D.28448;
  void * D.28451;
  struct MonoClass * D.28452;
  _Bool D.28457;
  long int D.28458;
  long int D.28459;
  char D.28462;
  unsigned int D.28466;
  unsigned int D.28467;
  unsigned int D.28468;
  unsigned int D.28472;
  unsigned int D.28473;
  unsigned int D.28476;
  short unsigned int D.28477;
  guint16 * D.28480;
  short unsigned int D.28481;
  unsigned int name_table_accesses.82;
  unsigned int name_table_accesses.83;
  unsigned int D.28484;
  int D.28485;
  unsigned int D.28486;
  unsigned int D.28487;
  int D.26072;
  int D.26081;
  _Bool D.28494;
  long int D.28495;
  long int D.28496;
  struct MonoClass * D.28499;
  _Bool D.28504;
  long int D.28505;
  long int D.28506;
  _Bool D.28513;
  long int D.28514;
  long int D.28515;
  unsigned int D.28519;
  _Bool D.28522;
  long int D.28523;
  long int D.28524;
  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.28433>; else goto <D.28435>;
      <D.28435>:
      D.28436 = amodule->class_name_table;
      if (D.28436 == 0B) goto <D.28433>; else goto <D.28434>;
      <D.28433>:
      D.28437 = 0;
      return D.28437;
      <D.28434>:
      {
        int ret;

        ret = pthread_mutex_lock (&aot_mutex.mutex);
        if (ret != 0) goto <D.28438>; else goto <D.28439>;
        <D.28438>:
        monoeg_g_log (0B, 16, "Bad call to mono_mutex_lock result %d", ret);
        <D.28439>:
        D.28440 = ret != 0;
        D.28441 = (long int) D.28440;
        D.28442 = __builtin_expect (D.28441, 0);
        if (D.28442 != 0) goto <D.28443>; else goto <D.28444>;
        <D.28443>:
        monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "aot-runtime.c", 2065, "ret == 0");
        <D.28444>:
      }
      *klass = 0B;
      D.28445 = amodule->name_cache;
      if (D.28445 == 0B) goto <D.28446>; else goto <D.28447>;
      <D.28446>:
      D.28448 = monoeg_g_hash_table_new (monoeg_g_str_hash, monoeg_g_str_equal);
      amodule->name_cache = D.28448;
      <D.28447>:
      D.28445 = amodule->name_cache;
      nspace_table = monoeg_g_hash_table_lookup (D.28445, name_space);
      if (nspace_table != 0B) goto <D.28449>; else goto <D.28450>;
      <D.28449>:
      D.28451 = monoeg_g_hash_table_lookup (nspace_table, name);
      *klass = D.28451;
      D.28452 = *klass;
      if (D.28452 != 0B) goto <D.28453>; else goto <D.28454>;
      <D.28453>:
      {
        int ret;

        ret = pthread_mutex_unlock (&aot_mutex.mutex);
        if (ret != 0) goto <D.28455>; else goto <D.28456>;
        <D.28455>:
        monoeg_g_log (0B, 16, "Bad call to mono_mutex_unlock result %d", ret);
        <D.28456>:
        D.28457 = ret != 0;
        D.28458 = (long int) D.28457;
        D.28459 = __builtin_expect (D.28458, 0);
        if (D.28459 != 0) goto <D.28460>; else goto <D.28461>;
        <D.28460>:
        monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "aot-runtime.c", 2076, "ret == 0");
        <D.28461>:
      }
      D.28437 = 1;
      return D.28437;
      <D.28454>:
      <D.28450>:
      D.28436 = amodule->class_name_table;
      table_size = *D.28436;
      D.28436 = amodule->class_name_table;
      table = D.28436 + 2;
      D.28462 = *name_space;
      if (D.28462 == 0) goto <D.28463>; else goto <D.28464>;
      <D.28463>:
      full_name = monoeg_g_strdup_printf ("%s", name);
      goto <D.28465>;
      <D.28464>:
      D.28466 = strlen (name_space);
      D.28467 = strlen (name);
      D.28468 = D.28466 + D.28467;
      if (D.28468 <= 999) goto <D.28469>; else goto <D.28470>;
      <D.28469>:
      sprintf (&full_name_buf, "%s.%s", name_space, name);
      full_name = &full_name_buf;
      goto <D.28471>;
      <D.28470>:
      full_name = monoeg_g_strdup_printf ("%s.%s", name_space, name);
      <D.28471>:
      <D.28465>:
      D.28472 = mono_metadata_str_hash (full_name);
      D.28473 = (unsigned int) table_size;
      hash = D.28472 % D.28473;
      if (&full_name_buf != full_name) goto <D.28474>; else goto <D.28475>;
      <D.28474>:
      monoeg_g_free (full_name);
      <D.28475>:
      D.28476 = hash * 4;
      entry = table + D.28476;
      D.28477 = *entry;
      if (D.28477 != 0) goto <D.28478>; else goto <D.28479>;
      <D.28478>:
      t = &image->tables[2];
      <D.26086>:
      {
        guint32 index;
        guint32 next;
        guint32 token;

        D.28477 = *entry;
        index = (guint32) D.28477;
        D.28480 = entry + 2;
        D.28481 = *D.28480;
        next = (guint32) D.28481;
        token = index | 33554432;
        name_table_accesses.82 = name_table_accesses;
        name_table_accesses.83 = name_table_accesses.82 + 1;
        name_table_accesses = name_table_accesses.83;
        D.28484 = index + 4294967295;
        D.28485 = (int) D.28484;
        mono_metadata_decode_row (t, D.28485, &cols, 6);
        D.28486 = cols[1];
        name2 = mono_metadata_string_heap (image, D.28486);
        D.28487 = cols[2];
        name_space2 = mono_metadata_string_heap (image, D.28487);
        {
          size_t __s1_len;
          size_t __s2_len;

          D.26072 = __builtin_strcmp (name, name2);
        }
        if (D.26072 == 0) goto <D.28488>; else goto <D.28489>;
        <D.28488>:
        {
          size_t __s1_len;
          size_t __s2_len;

          D.26081 = __builtin_strcmp (name_space, name_space2);
        }
        if (D.26081 == 0) goto <D.28490>; else goto <D.28491>;
        <D.28490>:
        {
          int ret;

          ret = pthread_mutex_unlock (&aot_mutex.mutex);
          if (ret != 0) goto <D.28492>; else goto <D.28493>;
          <D.28492>:
          monoeg_g_log (0B, 16, "Bad call to mono_mutex_unlock result %d", ret);
          <D.28493>:
          D.28494 = ret != 0;
          D.28495 = (long int) D.28494;
          D.28496 = __builtin_expect (D.28495, 0);
          if (D.28496 != 0) goto <D.28497>; else goto <D.28498>;
          <D.28497>:
          monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "aot-runtime.c", 2116, "ret == 0");
          <D.28498>:
        }
        D.28499 = mono_class_get (image, token);
        *klass = D.28499;
        D.28452 = *klass;
        if (D.28452 != 0B) goto <D.28500>; else goto <D.28501>;
        <D.28500>:
        {
          int ret;

          ret = pthread_mutex_lock (&aot_mutex.mutex);
          if (ret != 0) goto <D.28502>; else goto <D.28503>;
          <D.28502>:
          monoeg_g_log (0B, 16, "Bad call to mono_mutex_lock result %d", ret);
          <D.28503>:
          D.28504 = ret != 0;
          D.28505 = (long int) D.28504;
          D.28506 = __builtin_expect (D.28505, 0);
          if (D.28506 != 0) goto <D.28507>; else goto <D.28508>;
          <D.28507>:
          monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "aot-runtime.c", 2121, "ret == 0");
          <D.28508>:
        }
        D.28445 = amodule->name_cache;
        nspace_table = monoeg_g_hash_table_lookup (D.28445, name_space);
        if (nspace_table == 0B) goto <D.28509>; else goto <D.28510>;
        <D.28509>:
        nspace_table = monoeg_g_hash_table_new (monoeg_g_str_hash, monoeg_g_str_equal);
        D.28445 = amodule->name_cache;
        monoeg_g_hash_table_insert_replace (D.28445, name_space2, nspace_table, 0);
        <D.28510>:
        D.28452 = *klass;
        monoeg_g_hash_table_insert_replace (nspace_table, name2, D.28452, 0);
        {
          int ret;

          ret = pthread_mutex_unlock (&aot_mutex.mutex);
          if (ret != 0) goto <D.28511>; else goto <D.28512>;
          <D.28511>:
          monoeg_g_log (0B, 16, "Bad call to mono_mutex_unlock result %d", ret);
          <D.28512>:
          D.28513 = ret != 0;
          D.28514 = (long int) D.28513;
          D.28515 = __builtin_expect (D.28514, 0);
          if (D.28515 != 0) goto <D.28516>; else goto <D.28517>;
          <D.28516>:
          monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "aot-runtime.c", 2128, "ret == 0");
          <D.28517>:
        }
        <D.28501>:
        D.28437 = 1;
        return D.28437;
        <D.28491>:
        <D.28489>:
        if (next != 0) goto <D.28518>; else goto <D.26085>;
        <D.28518>:
        D.28519 = next * 4;
        entry = table + D.28519;
      }
      goto <D.26086>;
      <D.26085>:
      <D.28479>:
      {
        int ret;

        ret = pthread_mutex_unlock (&aot_mutex.mutex);
        if (ret != 0) goto <D.28520>; else goto <D.28521>;
        <D.28520>:
        monoeg_g_log (0B, 16, "Bad call to mono_mutex_unlock result %d", ret);
        <D.28521>:
        D.28522 = ret != 0;
        D.28523 = (long int) D.28522;
        D.28524 = __builtin_expect (D.28523, 0);
        if (D.28524 != 0) goto <D.28525>; else goto <D.28526>;
        <D.28525>:
        monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "aot-runtime.c", 2141, "ret == 0");
        <D.28526>:
      }
      D.28437 = 1;
      return D.28437;
    }
  finally
    {
      full_name_buf = {CLOBBER};
      cols = {CLOBBER};
    }
}


sprintf (char * restrict __s, const char * restrict __fmt)
{
  int D.28529;
  unsigned int D.28530;

  D.28530 = __builtin_object_size (__s, 1);
  D.28529 = __builtin___sprintf_chk (__s, 1, D.28530, __fmt, __builtin_va_arg_pack ());
  return D.28529;
}


mono_aot_get_unwind_info (struct MonoJitInfo * ji, guint32 * unwind_info_len)
{
  unsigned char D.28532;
  unsigned char D.28533;
  struct MonoMethod * D.28537;
  struct MonoClass * D.28538;
  struct MonoImage * D.28539;
  _Bool D.28540;
  long int D.28541;
  long int D.28542;
  unsigned char D.28545;
  unsigned char D.28546;
  _Bool D.28547;
  long int D.28548;
  long int D.28549;
  guint8 * D.28554;
  guint8 * D.28556;
  _Bool D.28559;
  long int D.28560;
  long int D.28561;
  struct GHashTable * ji_to_amodule.84;
  _Bool D.28565;
  long int D.28566;
  long int D.28567;
  int iftmp.85;
  _Bool D.28577;
  long int D.28578;
  long int D.28579;
  _Bool D.28584;
  long int D.28585;
  long int D.28586;
  guint8 * D.28589;
  unsigned int D.28590;
  guint8 * p.86;
  guint8 * p.87;
  int D.28593;
  unsigned int D.28594;
  guint8 * D.28595;
  struct MonoAotModule * amodule;
  guint8 * p;
  guint8 * code;

  try
    {
      code = ji->code_start;
      D.28532 = BIT_FIELD_REF <*ji, 8, 184>;
      D.28533 = D.28532 & 1;
      if (D.28533 != 0) goto <D.28534>; else goto <D.28535>;
      <D.28534>:
      amodule = ji->d.aot_info;
      goto <D.28536>;
      <D.28535>:
      D.28537 = jinfo_get_method (ji);
      D.28538 = D.28537->klass;
      D.28539 = D.28538->image;
      amodule = D.28539->aot_module;
      <D.28536>:
      D.28540 = amodule == 0B;
      D.28541 = (long int) D.28540;
      D.28542 = __builtin_expect (D.28541, 0);
      if (D.28542 != 0) goto <D.28543>; else goto <D.28544>;
      <D.28543>:
      monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "aot-runtime.c", 2655, "amodule");
      <D.28544>:
      D.28545 = BIT_FIELD_REF <*ji, 8, 176>;
      D.28546 = D.28545 & 16;
      D.28547 = D.28546 == 0;
      D.28548 = (long int) D.28547;
      D.28549 = __builtin_expect (D.28548, 0);
      if (D.28549 != 0) goto <D.28550>; else goto <D.28551>;
      <D.28550>:
      monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "aot-runtime.c", 2656, "ji->from_aot");
      <D.28551>:
      D.28554 = amodule->code;
      if (D.28554 > code) goto <D.28552>; else goto <D.28555>;
      <D.28555>:
      D.28556 = amodule->code_end;
      if (D.28556 < code) goto <D.28552>; else goto <D.28553>;
      <D.28552>:
      {
        int ret;

        ret = pthread_mutex_lock (&aot_mutex.mutex);
        if (ret != 0) goto <D.28557>; else goto <D.28558>;
        <D.28557>:
        monoeg_g_log (0B, 16, "Bad call to mono_mutex_lock result %d", ret);
        <D.28558>:
        D.28559 = ret != 0;
        D.28560 = (long int) D.28559;
        D.28561 = __builtin_expect (D.28560, 0);
        if (D.28561 != 0) goto <D.28562>; else goto <D.28563>;
        <D.28562>:
        monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "aot-runtime.c", 2660, "ret == 0");
        <D.28563>:
      }
      ji_to_amodule.84 = ji_to_amodule;
      D.28565 = ji_to_amodule.84 == 0B;
      D.28566 = (long int) D.28565;
      D.28567 = __builtin_expect (D.28566, 0);
      if (D.28567 != 0) goto <D.28568>; else goto <D.28569>;
      <D.28568>:
      monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "aot-runtime.c", 2661, "ji_to_amodule");
      <D.28569>:
      ji_to_amodule.84 = ji_to_amodule;
      amodule = monoeg_g_hash_table_lookup (ji_to_amodule.84, ji);
      D.28540 = amodule == 0B;
      D.28541 = (long int) D.28540;
      D.28542 = __builtin_expect (D.28541, 0);
      if (D.28542 != 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", 2663, "amodule");
      <D.28571>:
      D.28554 = amodule->code;
      if (D.28554 > code) goto <D.28573>; else goto <D.28576>;
      <D.28576>:
      D.28556 = amodule->code_end;
      if (D.28556 < code) goto <D.28573>; else goto <D.28574>;
      <D.28573>:
      iftmp.85 = 1;
      goto <D.28575>;
      <D.28574>:
      iftmp.85 = 0;
      <D.28575>:
      D.28577 = iftmp.85 != 0;
      D.28578 = (long int) D.28577;
      D.28579 = __builtin_expect (D.28578, 0);
      if (D.28579 != 0) goto <D.28580>; else goto <D.28581>;
      <D.28580>:
      monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "aot-runtime.c", 2664, "code >= amodule->code && code <= amodule->code_end");
      <D.28581>:
      {
        int ret;

        ret = pthread_mutex_unlock (&aot_mutex.mutex);
        if (ret != 0) goto <D.28582>; else goto <D.28583>;
        <D.28582>:
        monoeg_g_log (0B, 16, "Bad call to mono_mutex_unlock result %d", ret);
        <D.28583>:
        D.28584 = ret != 0;
        D.28585 = (long int) D.28584;
        D.28586 = __builtin_expect (D.28585, 0);
        if (D.28586 != 0) goto <D.28587>; else goto <D.28588>;
        <D.28587>:
        monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "aot-runtime.c", 2665, "ret == 0");
        <D.28588>:
      }
      <D.28553>:
      D.28589 = amodule->unwind_info;
      D.28590 = ji->used_regs;
      p.86 = D.28589 + D.28590;
      p = p.86;
      p.87 = p;
      D.28593 = decode_value (p.87, &p);
      D.28594 = (unsigned int) D.28593;
      *unwind_info_len = D.28594;
      D.28595 = p;
      return D.28595;
    }
  finally
    {
      p = {CLOBBER};
    }
}


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

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


mono_aot_find_jit_info (struct MonoDomain * domain, struct MonoImage * image, void * addr)
{
  unsigned int D.28600;
  struct MonoJitInfo * D.28603;
  struct MonoDomain * D.28604;
  int addr.88;
  guint8 * D.28608;
  int D.28609;
  gint32 * D.28610;
  unsigned int nmethods.89;
  unsigned int D.28614;
  gint32 * D.28615;
  unsigned int i.90;
  unsigned int D.28617;
  gint32 * D.28618;
  int D.28619;
  unsigned int offsets_len.91;
  unsigned int D.28623;
  gint32 * D.28624;
  sizetype offsets_len.92;
  sizetype D.28626;
  sizetype D.28627;
  gint32 * D.28628;
  unsigned int D.28629;
  gint32 * D.28630;
  int D.28631;
  int D.28632;
  unsigned int D.28633;
  unsigned int D.28634;
  gint32 * D.28635;
  int D.28636;
  _Bool D.28637;
  long int D.28638;
  long int D.28639;
  int D.28642;
  gint32 * * D.28643;
  void * D.28644;
  int D.28651;
  guint8 * D.28653;
  int D.28654;
  int D.28655;
  int D.28656;
  unsigned int pos.93;
  unsigned int D.28658;
  gint32 * D.28659;
  int D.28660;
  unsigned int D.28664;
  unsigned int D.28665;
  gint32 * D.28666;
  int D.28671;
  _Bool D.28672;
  long int D.28673;
  long int D.28674;
  int D.28679;
  _Bool D.28680;
  long int D.28681;
  long int D.28682;
  sizetype pos.94;
  sizetype D.28686;
  sizetype D.28687;
  gint32 * D.28688;
  struct JitInfoMap * D.28693;
  int D.28694;
  unsigned int method_index.95;
  unsigned int D.28698;
  gint32 * D.28699;
  int D.28700;
  sizetype D.28701;
  guint8 * D.28702;
  guint32 * D.28703;
  unsigned int D.28704;
  int code.96;
  int iftmp.97;
  sizetype code_len.98;
  guint8 * D.28715;
  _Bool D.28716;
  long int D.28717;
  long int D.28718;
  struct GHashTable * D.28723;
  _Bool D.28728;
  long int D.28729;
  long int D.28730;
  const void * method_index.99;
  _Bool D.28736;
  long int D.28737;
  long int D.28738;
  <unnamed-unsigned:24> D.28744;
  int D.28745;
  guint32 * D.28748;
  unsigned int D.28749;
  _Bool D.28750;
  long int D.28751;
  long int D.28752;
  guint32 * D.28755;
  unsigned int D.28756;
  unsigned int method_index.100;
  guint32 * D.28762;
  unsigned int D.28763;
  guint8 * p.101;
  guint8 * p.102;
  int D.28769;
  int D.28770;
  _Bool D.28771;
  long int D.28772;
  long int D.28773;
  unsigned int code_len.103;
  void * D.28777;
  _Bool D.28778;
  long int D.28779;
  long int D.28780;
  int D.28783;
  sizetype D.28784;
  guint8 * D.28785;
  _Bool D.28786;
  long int D.28787;
  long int D.28788;
  int D.28796;
  unsigned int D.28797;
  unsigned int D.28798;
  int D.28799;
  unsigned int len.104;
  unsigned int D.28803;
  struct JitInfoMap * D.28804;
  struct JitInfoMap * * D.28805;
  void * D.28806;
  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.28600 = amodule->info.nmethods;
      nmethods = (int) D.28600;
      if (amodule == 0B) goto <D.28601>; else goto <D.28602>;
      <D.28601>:
      D.28603 = 0B;
      return D.28603;
      <D.28602>:
      D.28604 = mono_get_root_domain ();
      if (D.28604 != domain) goto <D.28605>; else goto <D.28606>;
      <D.28605>:
      D.28603 = 0B;
      return D.28603;
      <D.28606>:
      async = mono_thread_info_is_async_context ();
      addr.88 = (int) addr;
      D.28608 = amodule->code;
      D.28609 = (int) D.28608;
      offset = addr.88 - D.28609;
      D.28610 = amodule->sorted_code_offsets;
      if (D.28610 == 0B) goto <D.28611>; else goto <D.28612>;
      <D.28611>:
      nmethods.89 = (unsigned int) nmethods;
      D.28614 = nmethods.89 * 8;
      code_offsets = monoeg_malloc0 (D.28614);
      offsets_len = 0;
      i = 0;
      goto <D.26326>;
      <D.26325>:
      D.28615 = amodule->code_offsets;
      i.90 = (unsigned int) i;
      D.28617 = i.90 * 4;
      D.28618 = D.28615 + D.28617;
      D.28619 = *D.28618;
      if (D.28619 == -1) goto <D.28620>; else goto <D.28621>;
      <D.28620>:
      // predicted unlikely by continue predictor.
      goto <D.26324>;
      <D.28621>:
      offsets_len.91 = (unsigned int) offsets_len;
      D.28623 = offsets_len.91 * 8;
      D.28624 = code_offsets + D.28623;
      D.28615 = amodule->code_offsets;
      i.90 = (unsigned int) i;
      D.28617 = i.90 * 4;
      D.28618 = D.28615 + D.28617;
      D.28619 = *D.28618;
      *D.28624 = D.28619;
      offsets_len.92 = (sizetype) offsets_len;
      D.28626 = offsets_len.92 * 8;
      D.28627 = D.28626 + 4;
      D.28628 = code_offsets + D.28627;
      *D.28628 = i;
      offsets_len = offsets_len + 1;
      <D.26324>:
      i = i + 1;
      <D.26326>:
      if (i < nmethods) goto <D.26325>; else goto <D.26327>;
      <D.26327>:
      msort_code_offsets (code_offsets, offsets_len);
      i = 0;
      goto <D.26329>;
      <D.26328>:
      i.90 = (unsigned int) i;
      D.28629 = i.90 * 8;
      D.28630 = code_offsets + D.28629;
      D.28631 = *D.28630;
      D.28632 = i + 1;
      D.28633 = (unsigned int) D.28632;
      D.28634 = D.28633 * 8;
      D.28635 = code_offsets + D.28634;
      D.28636 = *D.28635;
      D.28637 = D.28631 > D.28636;
      D.28638 = (long int) D.28637;
      D.28639 = __builtin_expect (D.28638, 0);
      if (D.28639 != 0) goto <D.28640>; else goto <D.28641>;
      <D.28640>:
      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.28641>:
      i = i + 1;
      <D.26329>:
      D.28642 = offsets_len + -1;
      if (D.28642 > i) goto <D.26328>; else goto <D.26330>;
      <D.26330>:
      amodule->sorted_code_offsets_len = offsets_len;
      mono_memory_barrier ();
      D.28643 = &amodule->sorted_code_offsets;
      D.28644 = InterlockedCompareExchangePointer (D.28643, code_offsets, 0B);
      if (D.28644 != 0B) goto <D.28645>; else goto <D.28646>;
      <D.28645>:
      monoeg_g_free (code_offsets);
      <D.28646>:
      <D.28612>:
      code_offsets = amodule->sorted_code_offsets;
      offsets_len = amodule->sorted_code_offsets_len;
      if (offsets_len > 0) goto <D.28649>; else goto <D.28650>;
      <D.28649>:
      D.28651 = *code_offsets;
      if (D.28651 > offset) goto <D.28647>; else goto <D.28652>;
      <D.28652>:
      D.28653 = amodule->code_end;
      D.28654 = (int) D.28653;
      D.28608 = amodule->code;
      D.28609 = (int) D.28608;
      D.28655 = D.28654 - D.28609;
      if (D.28655 <= offset) goto <D.28647>; else goto <D.28648>;
      <D.28647>:
      D.28603 = 0B;
      return D.28603;
      <D.28648>:
      <D.28650>:
      left = 0;
      right = offsets_len;
      <D.26332>:
      D.28656 = left + right;
      pos = D.28656 / 2;
      pos.93 = (unsigned int) pos;
      D.28658 = pos.93 * 8;
      D.28659 = code_offsets + D.28658;
      offset1 = *D.28659;
      D.28660 = pos + 1;
      if (D.28660 == offsets_len) goto <D.28661>; else goto <D.28662>;
      <D.28661>:
      D.28653 = amodule->code_end;
      D.28654 = (int) D.28653;
      D.28608 = amodule->code;
      D.28609 = (int) D.28608;
      offset2 = D.28654 - D.28609;
      goto <D.28663>;
      <D.28662>:
      D.28660 = pos + 1;
      D.28664 = (unsigned int) D.28660;
      D.28665 = D.28664 * 8;
      D.28666 = code_offsets + D.28665;
      offset2 = *D.28666;
      <D.28663>:
      if (offset < offset1) goto <D.28667>; else goto <D.28668>;
      <D.28667>:
      right = pos;
      goto <D.28669>;
      <D.28668>:
      if (offset >= offset2) goto <D.28670>; else goto <D.26331>;
      <D.28670>:
      left = pos + 1;
      <D.28669>:
      goto <D.26332>;
      <D.26331>:
      pos.93 = (unsigned int) pos;
      D.28658 = pos.93 * 8;
      D.28659 = code_offsets + D.28658;
      D.28671 = *D.28659;
      D.28672 = D.28671 > offset;
      D.28673 = (long int) D.28672;
      D.28674 = __builtin_expect (D.28673, 0);
      if (D.28674 != 0) goto <D.28675>; else goto <D.28676>;
      <D.28675>:
      monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "aot-runtime.c", 2819, "offset >= code_offsets [(pos * 2)]");
      <D.28676>:
      D.28660 = pos + 1;
      if (D.28660 < offsets_len) goto <D.28677>; else goto <D.28678>;
      <D.28677>:
      D.28660 = pos + 1;
      D.28664 = (unsigned int) D.28660;
      D.28665 = D.28664 * 8;
      D.28666 = code_offsets + D.28665;
      D.28679 = *D.28666;
      D.28680 = D.28679 <= offset;
      D.28681 = (long int) D.28680;
      D.28682 = __builtin_expect (D.28681, 0);
      if (D.28682 != 0) goto <D.28683>; else goto <D.28684>;
      <D.28683>:
      monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "aot-runtime.c", 2821, "offset < code_offsets [((pos + 1) * 2)]");
      <D.28684>:
      <D.28678>:
      pos.94 = (sizetype) pos;
      D.28686 = pos.94 * 8;
      D.28687 = D.28686 + 4;
      D.28688 = code_offsets + D.28687;
      method_index = *D.28688;
      if (async != 0) goto <D.28689>; else goto <D.28690>;
      <D.28689>:
      {
        struct JitInfoMap * table;
        int len;

        table = amodule->async_jit_info_table;
        if (table != 0B) goto <D.28691>; else goto <D.28692>;
        <D.28691>:
        len = table->method_index;
        i = 1;
        goto <D.26336>;
        <D.26335>:
        i.90 = (unsigned int) i;
        D.28629 = i.90 * 8;
        D.28693 = table + D.28629;
        D.28694 = D.28693->method_index;
        if (D.28694 == method_index) goto <D.28695>; else goto <D.28696>;
        <D.28695>:
        i.90 = (unsigned int) i;
        D.28629 = i.90 * 8;
        D.28693 = table + D.28629;
        D.28603 = D.28693->jinfo;
        return D.28603;
        <D.28696>:
        i = i + 1;
        <D.26336>:
        if (i < len) goto <D.26335>; else goto <D.26337>;
        <D.26337>:
        <D.28692>:
      }
      <D.28690>:
      D.28608 = amodule->code;
      D.28615 = amodule->code_offsets;
      method_index.95 = (unsigned int) method_index;
      D.28698 = method_index.95 * 4;
      D.28699 = D.28615 + D.28698;
      D.28700 = *D.28699;
      D.28701 = (sizetype) D.28700;
      code = D.28608 + D.28701;
      D.28702 = amodule->blob;
      D.28703 = amodule->ex_info_offsets;
      D.28704 = mono_aot_get_offset (D.28703, method_index);
      ex_info = D.28702 + D.28704;
      D.28642 = offsets_len + -1;
      if (D.28642 == pos) goto <D.28705>; else goto <D.28706>;
      <D.28705>:
      D.28653 = amodule->code_end;
      D.28654 = (int) D.28653;
      code.96 = (int) code;
      code_len = D.28654 - code.96;
      goto <D.28708>;
      <D.28706>:
      D.28660 = pos + 1;
      D.28664 = (unsigned int) D.28660;
      D.28665 = D.28664 * 8;
      D.28666 = code_offsets + D.28665;
      D.28679 = *D.28666;
      pos.93 = (unsigned int) pos;
      D.28658 = pos.93 * 8;
      D.28659 = code_offsets + D.28658;
      D.28671 = *D.28659;
      code_len = D.28679 - D.28671;
      <D.28708>:
      if (code > addr) goto <D.28710>; else goto <D.28713>;
      <D.28713>:
      code_len.98 = (sizetype) code_len;
      D.28715 = code + code_len.98;
      if (D.28715 <= addr) goto <D.28710>; else goto <D.28711>;
      <D.28710>:
      iftmp.97 = 1;
      goto <D.28712>;
      <D.28711>:
      iftmp.97 = 0;
      <D.28712>:
      D.28716 = iftmp.97 != 0;
      D.28717 = (long int) D.28716;
      D.28718 = __builtin_expect (D.28717, 0);
      if (D.28718 != 0) goto <D.28719>; else goto <D.28720>;
      <D.28719>:
      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.28720>:
      if (async == 0) goto <D.28721>; else goto <D.28722>;
      <D.28721>:
      D.28723 = amodule->extra_methods;
      if (D.28723 != 0B) goto <D.28724>; else goto <D.28725>;
      <D.28724>:
      {
        int ret;

        ret = pthread_mutex_lock (&aot_mutex.mutex);
        if (ret != 0) goto <D.28726>; else goto <D.28727>;
        <D.28726>:
        monoeg_g_log (0B, 16, "Bad call to mono_mutex_lock result %d", ret);
        <D.28727>:
        D.28728 = ret != 0;
        D.28729 = (long int) D.28728;
        D.28730 = __builtin_expect (D.28729, 0);
        if (D.28730 != 0) goto <D.28731>; else goto <D.28732>;
        <D.28731>:
        monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "aot-runtime.c", 2851, "ret == 0");
        <D.28732>:
      }
      D.28723 = amodule->extra_methods;
      method_index.99 = (const void *) method_index;
      method = monoeg_g_hash_table_lookup (D.28723, method_index.99);
      {
        int ret;

        ret = pthread_mutex_unlock (&aot_mutex.mutex);
        if (ret != 0) goto <D.28734>; else goto <D.28735>;
        <D.28734>:
        monoeg_g_log (0B, 16, "Bad call to mono_mutex_unlock result %d", ret);
        <D.28735>:
        D.28736 = ret != 0;
        D.28737 = (long int) D.28736;
        D.28738 = __builtin_expect (D.28737, 0);
        if (D.28738 != 0) goto <D.28739>; else goto <D.28740>;
        <D.28739>:
        monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "aot-runtime.c", 2853, "ret == 0");
        <D.28740>:
      }
      goto <D.28741>;
      <D.28725>:
      method = 0B;
      <D.28741>:
      if (method == 0B) goto <D.28742>; else goto <D.28743>;
      <D.28742>:
      D.28744 = image->tables[6].rows;
      D.28745 = (int) D.28744;
      if (D.28745 <= method_index) goto <D.28746>; else goto <D.28747>;
      <D.28746>:
      D.28748 = amodule->extra_method_info_offsets;
      D.28749 = *D.28748;
      table_len = (int) D.28749;
      D.28748 = amodule->extra_method_info_offsets;
      table = D.28748 + 4;
      left = 0;
      right = table_len;
      pos = 0;
      <D.26341>:
      D.28656 = left + right;
      pos = D.28656 / 2;
      D.28750 = pos >= table_len;
      D.28751 = (long int) D.28750;
      D.28752 = __builtin_expect (D.28751, 0);
      if (D.28752 != 0) goto <D.28753>; else goto <D.28754>;
      <D.28753>:
      monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "aot-runtime.c", 2874, "pos < table_len");
      <D.28754>:
      pos.93 = (unsigned int) pos;
      D.28658 = pos.93 * 8;
      D.28755 = table + D.28658;
      D.28756 = *D.28755;
      method_index.100 = (unsigned int) method_index;
      if (D.28756 < method_index.100) goto <D.28758>; else goto <D.28759>;
      <D.28758>:
      left = pos + 1;
      goto <D.28760>;
      <D.28759>:
      pos.93 = (unsigned int) pos;
      D.28658 = pos.93 * 8;
      D.28755 = table + D.28658;
      D.28756 = *D.28755;
      method_index.100 = (unsigned int) method_index;
      if (D.28756 > method_index.100) goto <D.28761>; else goto <D.26340>;
      <D.28761>:
      right = pos;
      <D.28760>:
      goto <D.26341>;
      <D.26340>:
      D.28702 = amodule->blob;
      pos.94 = (sizetype) pos;
      D.28686 = pos.94 * 8;
      D.28687 = D.28686 + 4;
      D.28762 = table + D.28687;
      D.28763 = *D.28762;
      p.101 = D.28702 + D.28763;
      p = p.101;
      p.102 = p;
      method = decode_resolve_method_ref (amodule, p.102, &p);
      if (method == 0B) goto <D.28766>; else goto <D.28767>;
      <D.28766>:
      D.28603 = 0B;
      return D.28603;
      <D.28767>:
      goto <D.28768>;
      <D.28747>:
      D.28769 = method_index + 1;
      D.28770 = D.28769 | 100663296;
      token = (guint32) D.28770;
      method = mono_get_method (image, token, 0B);
      <D.28768>:
      <D.28743>:
      D.28771 = method == 0B;
      D.28772 = (long int) D.28771;
      D.28773 = __builtin_expect (D.28772, 0);
      if (D.28773 != 0) goto <D.28774>; else goto <D.28775>;
      <D.28774>:
      monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "aot-runtime.c", 2895, "method");
      <D.28775>:
      <D.28722>:
      code_len.103 = (unsigned int) code_len;
      jinfo = decode_exception_debug_info (amodule, domain, method, ex_info, addr, code, code_len.103);
      D.28777 = jinfo->code_start;
      D.28778 = D.28777 > addr;
      D.28779 = (long int) D.28778;
      D.28780 = __builtin_expect (D.28779, 0);
      if (D.28780 != 0) goto <D.28781>; else goto <D.28782>;
      <D.28781>:
      monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "aot-runtime.c", 2902, "(guint8*)addr >= (guint8*)jinfo->code_start");
      <D.28782>:
      D.28777 = jinfo->code_start;
      D.28783 = jinfo->code_size;
      D.28784 = (sizetype) D.28783;
      D.28785 = D.28777 + D.28784;
      D.28786 = D.28785 <= addr;
      D.28787 = (long int) D.28786;
      D.28788 = __builtin_expect (D.28787, 0);
      if (D.28788 != 0) goto <D.28789>; else goto <D.28790>;
      <D.28789>:
      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.28790>:
      if (async != 0) goto <D.28791>; else goto <D.28792>;
      <D.28791>:
      {
        struct JitInfoMap * old_table;
        struct JitInfoMap * new_table;
        int len;

        <D.26346>:
        old_table = amodule->async_jit_info_table;
        if (old_table != 0B) goto <D.28793>; else goto <D.28794>;
        <D.28793>:
        len = old_table->method_index;
        goto <D.28795>;
        <D.28794>:
        len = 1;
        <D.28795>:
        D.28796 = len + 1;
        D.28797 = (unsigned int) D.28796;
        D.28798 = D.28797 * 8;
        D.28799 = (int) D.28798;
        new_table = alloc0_jit_info_data (domain, D.28799, async);
        if (old_table != 0B) goto <D.28800>; else goto <D.28801>;
        <D.28800>:
        len.104 = (unsigned int) len;
        D.28803 = len.104 * 8;
        memcpy (new_table, old_table, D.28803);
        <D.28801>:
        D.28796 = len + 1;
        new_table->method_index = D.28796;
        len.104 = (unsigned int) len;
        D.28803 = len.104 * 8;
        D.28804 = new_table + D.28803;
        D.28804->method_index = method_index;
        len.104 = (unsigned int) len;
        D.28803 = len.104 * 8;
        D.28804 = new_table + D.28803;
        D.28804->jinfo = jinfo;
        mono_memory_barrier ();
        D.28805 = &amodule->async_jit_info_table;
        D.28806 = InterlockedCompareExchangePointer (D.28805, new_table, old_table);
        if (D.28806 == old_table) goto <D.26345>; else goto <D.28807>;
        <D.28807>:
        goto <D.26346>;
        <D.26345>:
      }
      goto <D.28808>;
      <D.28792>:
      mono_jit_info_table_add (domain, jinfo);
      <D.28808>:
      D.28603 = jinfo;
      return D.28603;
    }
  finally
    {
      p = {CLOBBER};
    }
}


msort_code_offsets (gint32 * array, int len)
{
  unsigned int len.105;
  unsigned int D.28812;
  int D.28813;
  gint32 * scratch;

  len.105 = (unsigned int) len;
  D.28812 = len.105 * 8;
  scratch = monoeg_malloc (D.28812);
  D.28813 = len + -1;
  msort_code_offsets_internal (array, 0, D.28813, scratch);
  monoeg_g_free (scratch);
}


msort_code_offsets_internal (gint32 * array, int lo, int hi, gint32 * scratch)
{
  int D.28814;
  int D.28817;
  unsigned int i.106;
  unsigned int D.28821;
  gint32 * D.28822;
  int D.28823;
  sizetype i.107;
  sizetype D.28825;
  sizetype D.28826;
  gint32 * D.28827;
  int D.28828;
  int D.28832;
  unsigned int mid.108;
  unsigned int D.28834;
  gint32 * D.28835;
  int D.28836;
  unsigned int D.28837;
  unsigned int D.28838;
  gint32 * D.28839;
  int D.28840;
  unsigned int t_lo.109;
  unsigned int D.28849;
  gint32 * D.28850;
  int D.28851;
  unsigned int t_hi.110;
  unsigned int D.28853;
  gint32 * D.28854;
  int D.28855;
  gint32 * D.28856;
  sizetype D.28857;
  sizetype D.28858;
  gint32 * D.28859;
  sizetype t_lo.111;
  sizetype D.28861;
  sizetype D.28862;
  gint32 * D.28863;
  int D.28864;
  sizetype t_hi.112;
  sizetype D.28866;
  sizetype D.28867;
  gint32 * D.28868;
  int D.28869;
  int D.28870;
  gint32 * D.28871;
  int D.28872;
  int mid;
  int i;
  int t_lo;
  int t_hi;

  D.28814 = lo + hi;
  mid = D.28814 / 2;
  if (lo >= hi) goto <D.28815>; else goto <D.28816>;
  <D.28815>:
  return;
  <D.28816>:
  D.28817 = hi - lo;
  if (D.28817 <= 31) goto <D.28818>; else goto <D.28819>;
  <D.28818>:
  i = lo;
  goto <D.26285>;
  <D.26284>:
  i.106 = (unsigned int) i;
  D.28821 = i.106 * 8;
  D.28822 = array + D.28821;
  D.28823 = *D.28822;
  i.107 = (sizetype) i;
  D.28825 = i.107 + 1;
  D.28826 = D.28825 * 8;
  D.28827 = array + D.28826;
  D.28828 = *D.28827;
  if (D.28823 > D.28828) goto <D.26283>; else goto <D.28829>;
  <D.28829>:
  i = i + 1;
  <D.26285>:
  if (i < hi) goto <D.26284>; else goto <D.26283>;
  <D.26283>:
  if (i == hi) goto <D.28830>; else goto <D.28831>;
  <D.28830>:
  return;
  <D.28831>:
  <D.28819>:
  msort_code_offsets_internal (array, lo, mid, scratch);
  D.28832 = mid + 1;
  msort_code_offsets_internal (array, D.28832, hi, scratch);
  mid.108 = (unsigned int) mid;
  D.28834 = mid.108 * 8;
  D.28835 = array + D.28834;
  D.28836 = *D.28835;
  D.28832 = mid + 1;
  D.28837 = (unsigned int) D.28832;
  D.28838 = D.28837 * 8;
  D.28839 = array + D.28838;
  D.28840 = *D.28839;
  if (D.28836 < D.28840) goto <D.28841>; else goto <D.28842>;
  <D.28841>:
  return;
  <D.28842>:
  t_lo = lo;
  t_hi = mid + 1;
  i = lo;
  goto <D.26287>;
  <D.26286>:
  if (t_lo <= mid) goto <D.28846>; else goto <D.28843>;
  <D.28846>:
  if (t_hi > hi) goto <D.28844>; else goto <D.28847>;
  <D.28847>:
  t_lo.109 = (unsigned int) t_lo;
  D.28849 = t_lo.109 * 8;
  D.28850 = array + D.28849;
  D.28851 = *D.28850;
  t_hi.110 = (unsigned int) t_hi;
  D.28853 = t_hi.110 * 8;
  D.28854 = array + D.28853;
  D.28855 = *D.28854;
  if (D.28851 < D.28855) goto <D.28844>; else goto <D.28843>;
  <D.28844>:
  i.106 = (unsigned int) i;
  D.28821 = i.106 * 8;
  D.28856 = scratch + D.28821;
  t_lo.109 = (unsigned int) t_lo;
  D.28849 = t_lo.109 * 8;
  D.28850 = array + D.28849;
  D.28851 = *D.28850;
  *D.28856 = D.28851;
  i.107 = (sizetype) i;
  D.28857 = i.107 * 8;
  D.28858 = D.28857 + 4;
  D.28859 = scratch + D.28858;
  t_lo.111 = (sizetype) t_lo;
  D.28861 = t_lo.111 * 8;
  D.28862 = D.28861 + 4;
  D.28863 = array + D.28862;
  D.28864 = *D.28863;
  *D.28859 = D.28864;
  t_lo = t_lo + 1;
  goto <D.28845>;
  <D.28843>:
  i.106 = (unsigned int) i;
  D.28821 = i.106 * 8;
  D.28856 = scratch + D.28821;
  t_hi.110 = (unsigned int) t_hi;
  D.28853 = t_hi.110 * 8;
  D.28854 = array + D.28853;
  D.28855 = *D.28854;
  *D.28856 = D.28855;
  i.107 = (sizetype) i;
  D.28857 = i.107 * 8;
  D.28858 = D.28857 + 4;
  D.28859 = scratch + D.28858;
  t_hi.112 = (sizetype) t_hi;
  D.28866 = t_hi.112 * 8;
  D.28867 = D.28866 + 4;
  D.28868 = array + D.28867;
  D.28869 = *D.28868;
  *D.28859 = D.28869;
  t_hi = t_hi + 1;
  <D.28845>:
  i = i + 1;
  <D.26287>:
  if (i <= hi) goto <D.26286>; else goto <D.26288>;
  <D.26288>:
  i = lo;
  goto <D.26290>;
  <D.26289>:
  i.106 = (unsigned int) i;
  D.28821 = i.106 * 8;
  D.28822 = array + D.28821;
  i.106 = (unsigned int) i;
  D.28821 = i.106 * 8;
  D.28856 = scratch + D.28821;
  D.28870 = *D.28856;
  *D.28822 = D.28870;
  i.107 = (sizetype) i;
  D.28857 = i.107 * 8;
  D.28858 = D.28857 + 4;
  D.28871 = array + D.28858;
  i.107 = (sizetype) i;
  D.28857 = i.107 * 8;
  D.28858 = D.28857 + 4;
  D.28859 = scratch + D.28858;
  D.28872 = *D.28859;
  *D.28871 = D.28872;
  i = i + 1;
  <D.26290>:
  if (i <= hi) goto <D.26289>; else goto <D.26291>;
  <D.26291>:
}


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.113;
  int D.28875;
  unsigned int D.28876;
  _Bool D.28877;
  unsigned int D.28878;
  _Bool D.28879;
  unsigned int D.28880;
  _Bool D.28881;
  unsigned int D.28882;
  _Bool D.28883;
  unsigned int D.28884;
  _Bool D.28885;
  unsigned int D.28886;
  _Bool D.28887;
  unsigned int D.28888;
  _Bool D.28889;
  unsigned int D.28890;
  _Bool D.28891;
  int D.28894;
  _Bool D.28895;
  long int D.28896;
  long int D.28897;
  int D.28901;
  unsigned int num_holes.114;
  unsigned int D.28908;
  unsigned int D.28909;
  _Bool D.28919;
  long int D.28920;
  long int D.28921;
  unsigned int num_clauses.115;
  unsigned int D.28925;
  unsigned int D.28926;
  unsigned int i.116;
  unsigned int D.28928;
  int D.28929;
  unsigned int D.28930;
  int D.28931;
  struct MonoClass * D.28934;
  unsigned int D.28936;
  struct GSList * * D.28937;
  struct GSList * D.28938;
  void * nesting_index.117;
  struct GSList * D.28940;
  int D.28941;
  int D.28942;
  unsigned int generic_info_size.118;
  unsigned int D.28945;
  unsigned int try_holes_info_size.119;
  unsigned int D.28947;
  unsigned int arch_eh_jit_info_size.120;
  unsigned int D.28949;
  unsigned int D.28950;
  short unsigned int D.28951;
  <unnamed-unsigned:15> D.28952;
  int D.28953;
  unsigned int D.28954;
  int D.28955;
  unsigned int D.28956;
  unsigned int D.28957;
  int D.28960;
  sizetype D.28961;
  void * D.28962;
  sizetype len.121;
  guint8 * p.122;
  struct MonoClass * D.28971;
  int D.28972;
  sizetype D.28973;
  void * D.28974;
  int D.28975;
  sizetype D.28976;
  void * D.28977;
  int D.28978;
  sizetype D.28979;
  void * D.28980;
  <unnamed-unsigned:15> D.28981;
  int D.28982;
  int code_len.123;
  _Bool D.28986;
  long int D.28987;
  long int D.28988;
  short unsigned int D.28991;
  int D.28992;
  short unsigned int D.28993;
  int D.28994;
  short unsigned int D.28995;
  int D.28996;
  unsigned int D.28997;
  int D.29000;
  unsigned int D.29001;
  struct MonoJitInfo * D.29004;
  _Bool D.29007;
  long int D.29008;
  long int D.29009;
  int D.29012;
  int D.29013;
  unsigned int D.29016;
  unsigned int D.29017;
  int D.29018;
  void * D.29019;
  struct MonoDwarfLocListEntry * D.29020;
  unsigned int D.29021;
  int D.29022;
  int D.29023;
  int D.29024;
  int D.29027;
  int D.29030;
  int D.29031;
  int this_reg.124;
  _Bool D.29036;
  <unnamed-signed:1> D.29037;
  unsigned char D.29038;
  int this_offset.125;
  int D.29041;
  signed char D.29042;
  <unnamed-signed:1> D.29043;
  int D.29044;
  unsigned char D.29045;
  int D.29046;
  sizetype len.126;
  guint8 * p.127;
  struct MonoMethod * D.29052;
  void * D.29053;
  int D.29054;
  unsigned int n.128;
  unsigned int D.29060;
  int D.29061;
  void * D.29062;
  gboolean * D.29063;
  unsigned int i.129;
  unsigned int D.29065;
  gboolean * D.29066;
  int D.29067;
  void * D.29070;
  gboolean * D.29071;
  gboolean * D.29072;
  int D.29073;
  _Bool D.29074;
  _Bool D.29075;
  _Bool D.29076;
  unsigned int len.130;
  unsigned int D.29080;
  unsigned int D.29081;
  int D.29082;
  int D.29083;
  int D.29084;
  int D.29085;
  int D.29086;
  unsigned int D.29087;
  unsigned int D.29088;
  void * D.29089;
  int * D.29090;
  unsigned int j.131;
  unsigned int D.29092;
  int * D.29093;
  int D.29094;
  union mono_mutex_t * D.29095;
  _Bool D.29098;
  long int D.29099;
  long int D.29100;
  void * D.29103;
  struct GHashTable * D.29104;
  _Bool D.29107;
  long int D.29108;
  long int D.29109;
  unsigned int buf_len.132;
  sizetype buf_len.133;
  guint8 * p.134;
  guint8 * p.135;
  unsigned int p.136;
  unsigned int D.29121;
  sizetype map_size.137;
  guint8 * p.138;
  struct MonoMethod * D.29124;
  struct MonoClass * D.29125;
  struct MonoImage * D.29126;
  void * D.29127;
  _Bool D.29132;
  long int D.29133;
  long int D.29134;
  struct GHashTable * ji_to_amodule.139;
  struct GHashTable * ji_to_amodule.140;
  _Bool D.29143;
  long int D.29144;
  long int D.29145;
  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.113 = p;
      D.28875 = decode_value (p.113, &p);
      flags = (guint) D.28875;
      D.28876 = flags & 1;
      D.28877 = D.28876 != 0;
      has_generic_jit_info = (gboolean) D.28877;
      D.28878 = flags & 2;
      D.28879 = D.28878 != 0;
      has_dwarf_unwind_info = (gboolean) D.28879;
      D.28880 = flags & 4;
      D.28881 = D.28880 != 0;
      has_clauses = (gboolean) D.28881;
      D.28882 = flags & 8;
      D.28883 = D.28882 != 0;
      has_seq_points = (gboolean) D.28883;
      D.28884 = flags & 16;
      D.28885 = D.28884 != 0;
      from_llvm = (gboolean) D.28885;
      D.28886 = flags & 32;
      D.28887 = D.28886 != 0;
      has_try_block_holes = (gboolean) D.28887;
      D.28888 = flags & 64;
      D.28889 = D.28888 != 0;
      has_gc_map = (gboolean) D.28889;
      D.28890 = flags & 128;
      D.28891 = D.28890 != 0;
      has_arch_eh_jit_info = (gboolean) D.28891;
      if (has_dwarf_unwind_info != 0) goto <D.28892>; else goto <D.28893>;
      <D.28892>:
      {
        guint32 offset;

        p.113 = p;
        D.28894 = decode_value (p.113, &p);
        offset = (guint32) D.28894;
        D.28895 = offset > 1073741823;
        D.28896 = (long int) D.28895;
        D.28897 = __builtin_expect (D.28896, 0);
        if (D.28897 != 0) goto <D.28898>; else goto <D.28899>;
        <D.28898>:
        monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "aot-runtime.c", 2383, "offset < (1 << 30)");
        <D.28899>:
        used_int_regs = offset;
      }
      goto <D.28900>;
      <D.28893>:
      p.113 = p;
      D.28901 = decode_value (p.113, &p);
      used_int_regs = (guint) D.28901;
      <D.28900>:
      if (has_generic_jit_info != 0) goto <D.28902>; else goto <D.28903>;
      <D.28902>:
      generic_info_size = 20;
      goto <D.28904>;
      <D.28903>:
      generic_info_size = 0;
      <D.28904>:
      if (has_try_block_holes != 0) goto <D.28905>; else goto <D.28906>;
      <D.28905>:
      p.113 = p;
      num_holes = decode_value (p.113, &p);
      num_holes.114 = (unsigned int) num_holes;
      D.28908 = num_holes.114 * 8;
      D.28909 = D.28908 + 4;
      try_holes_info_size = (int) D.28909;
      goto <D.28910>;
      <D.28906>:
      try_holes_info_size = 0;
      num_holes = try_holes_info_size;
      <D.28910>:
      if (has_clauses != 0) goto <D.28911>; else goto <D.28912>;
      <D.28911>:
      p.113 = p;
      num_clauses = decode_value (p.113, &p);
      goto <D.28913>;
      <D.28912>:
      num_clauses = 0;
      <D.28913>:
      if (has_arch_eh_jit_info != 0) goto <D.28914>; else goto <D.28915>;
      <D.28914>:
      arch_eh_jit_info_size = 4;
      goto <D.28916>;
      <D.28915>:
      arch_eh_jit_info_size = 0;
      <D.28916>:
      if (from_llvm != 0) goto <D.28917>; else goto <D.28918>;
      <D.28917>:
      {
        struct MonoJitExceptionInfo * clauses;
        struct GSList * * nesting;

        D.28919 = async != 0;
        D.28920 = (long int) D.28919;
        D.28921 = __builtin_expect (D.28920, 0);
        if (D.28921 != 0) goto <D.28922>; else goto <D.28923>;
        <D.28922>:
        monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "aot-runtime.c", 2414, "!async");
        <D.28923>:
        num_clauses.115 = (unsigned int) num_clauses;
        D.28925 = num_clauses.115 * 24;
        clauses = monoeg_malloc0 (D.28925);
        num_clauses.115 = (unsigned int) num_clauses;
        D.28926 = num_clauses.115 * 4;
        nesting = monoeg_malloc0 (D.28926);
        i = 0;
        goto <D.26207>;
        <D.26206>:
        {
          struct MonoJitExceptionInfo * ei;

          i.116 = (unsigned int) i;
          D.28928 = i.116 * 24;
          ei = clauses + D.28928;
          p.113 = p;
          D.28929 = decode_value (p.113, &p);
          D.28930 = (unsigned int) D.28929;
          ei->flags = D.28930;
          p.113 = p;
          D.28931 = decode_value (p.113, &p);
          if (D.28931 != 0) goto <D.28932>; else goto <D.28933>;
          <D.28932>:
          p.113 = p;
          D.28934 = decode_klass_ref (amodule, p.113, &p);
          ei->data.catch_class = D.28934;
          <D.28933>:
          <D.26205>:
          {
            int nesting_index;

            p.113 = p;
            nesting_index = decode_value (p.113, &p);
            if (nesting_index == -1) goto <D.26204>; else goto <D.28935>;
            <D.28935>:
            i.116 = (unsigned int) i;
            D.28936 = i.116 * 4;
            D.28937 = nesting + D.28936;
            i.116 = (unsigned int) i;
            D.28936 = i.116 * 4;
            D.28937 = nesting + D.28936;
            D.28938 = *D.28937;
            nesting_index.117 = (void *) nesting_index;
            D.28940 = monoeg_g_slist_prepend (D.28938, nesting_index.117);
            *D.28937 = D.28940;
          }
          goto <D.26205>;
          <D.26204>:
        }
        i = i + 1;
        <D.26207>:
        if (i < num_clauses) goto <D.26206>; else goto <D.26208>;
        <D.26208>:
        D.28941 = generic_info_size + try_holes_info_size;
        D.28942 = D.28941 + arch_eh_jit_info_size;
        jinfo = decode_llvm_mono_eh_frame (amodule, domain, method, code, clauses, num_clauses, D.28942, nesting, &this_reg, &this_offset);
        jinfo->from_llvm = -1;
        monoeg_g_free (clauses);
        i = 0;
        goto <D.26210>;
        <D.26209>:
        i.116 = (unsigned int) i;
        D.28936 = i.116 * 4;
        D.28937 = nesting + D.28936;
        D.28938 = *D.28937;
        monoeg_g_slist_free (D.28938);
        i = i + 1;
        <D.26210>:
        if (i < num_clauses) goto <D.26209>; else goto <D.26211>;
        <D.26211>:
        monoeg_g_free (nesting);
      }
      goto <D.28943>;
      <D.28918>:
      num_clauses.115 = (unsigned int) num_clauses;
      D.28925 = num_clauses.115 * 24;
      generic_info_size.118 = (unsigned int) generic_info_size;
      D.28945 = D.28925 + generic_info_size.118;
      try_holes_info_size.119 = (unsigned int) try_holes_info_size;
      D.28947 = D.28945 + try_holes_info_size.119;
      arch_eh_jit_info_size.120 = (unsigned int) arch_eh_jit_info_size;
      D.28949 = D.28947 + arch_eh_jit_info_size.120;
      D.28950 = D.28949 + 28;
      len = (int) D.28950;
      jinfo = alloc0_jit_info_data (domain, len, async);
      D.28951 = (short unsigned int) num_clauses;
      D.28952 = (<unnamed-unsigned:15>) D.28951;
      jinfo->num_clauses = D.28952;
      i = 0;
      goto <D.26215>;
      <D.26214>:
      {
        struct MonoJitExceptionInfo * ei;

        ei = &jinfo->clauses[i];
        p.113 = p;
        D.28953 = decode_value (p.113, &p);
        D.28954 = (unsigned int) D.28953;
        ei->flags = D.28954;
        p.113 = p;
        D.28955 = decode_value (p.113, &p);
        ei->exvar_offset = D.28955;
        D.28956 = ei->flags;
        D.28957 = D.28956 + 4294967295;
        if (D.28957 <= 1) goto <D.28958>; else goto <D.28959>;
        <D.28958>:
        p.113 = p;
        D.28960 = decode_value (p.113, &p);
        D.28961 = (sizetype) D.28960;
        D.28962 = code + D.28961;
        ei->data.filter = D.28962;
        goto <D.28963>;
        <D.28959>:
        {
          int len;

          p.113 = p;
          len = decode_value (p.113, &p);
          if (len > 0) goto <D.28964>; else goto <D.28965>;
          <D.28964>:
          if (async != 0) goto <D.28966>; else goto <D.28967>;
          <D.28966>:
          p.113 = p;
          len.121 = (sizetype) len;
          p.122 = p.113 + len.121;
          p = p.122;
          goto <D.28970>;
          <D.28967>:
          p.113 = p;
          D.28971 = decode_klass_ref (amodule, p.113, &p);
          ei->data.catch_class = D.28971;
          <D.28970>:
          <D.28965>:
        }
        <D.28963>:
        p.113 = p;
        D.28972 = decode_value (p.113, &p);
        D.28973 = (sizetype) D.28972;
        D.28974 = code + D.28973;
        ei->try_start = D.28974;
        p.113 = p;
        D.28975 = decode_value (p.113, &p);
        D.28976 = (sizetype) D.28975;
        D.28977 = code + D.28976;
        ei->try_end = D.28977;
        p.113 = p;
        D.28978 = decode_value (p.113, &p);
        D.28979 = (sizetype) D.28978;
        D.28980 = code + D.28979;
        ei->handler_start = D.28980;
      }
      i = i + 1;
      <D.26215>:
      D.28981 = jinfo->num_clauses;
      D.28982 = (int) D.28981;
      if (D.28982 > i) goto <D.26214>; else goto <D.26216>;
      <D.26216>:
      code_len.123 = (int) code_len;
      jinfo->code_size = code_len.123;
      jinfo->used_regs = used_int_regs;
      jinfo->d.method = method;
      jinfo->code_start = code;
      jinfo->domain_neutral = 0;
      jinfo->from_aot = -1;
      <D.28943>:
      if (has_try_block_holes != 0) goto <D.28984>; else goto <D.28985>;
      <D.28984>:
      {
        struct MonoTryBlockHoleTableJitInfo * table;

        jinfo->has_try_block_holes = -1;
        table = mono_jit_info_get_try_block_hole_table_info (jinfo);
        D.28986 = table == 0B;
        D.28987 = (long int) D.28986;
        D.28988 = __builtin_expect (D.28987, 0);
        if (D.28988 != 0) goto <D.28989>; else goto <D.28990>;
        <D.28989>:
        monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "aot-runtime.c", 2491, "table");
        <D.28990>:
        D.28991 = (short unsigned int) num_holes;
        table->num_holes = D.28991;
        i = 0;
        goto <D.26220>;
        <D.26219>:
        {
          struct MonoTryBlockHoleJitInfo * hole;

          hole = &table->holes[i];
          p.113 = p;
          D.28992 = decode_value (p.113, &p);
          D.28993 = (short unsigned int) D.28992;
          hole->clause = D.28993;
          p.113 = p;
          D.28994 = decode_value (p.113, &p);
          D.28995 = (short unsigned int) D.28994;
          hole->length = D.28995;
          p.113 = p;
          D.28996 = decode_value (p.113, &p);
          D.28997 = (unsigned int) D.28996;
          hole->offset = D.28997;
        }
        i = i + 1;
        <D.26220>:
        if (i < num_holes) goto <D.26219>; else goto <D.26221>;
        <D.26221>:
      }
      <D.28985>:
      if (has_arch_eh_jit_info != 0) goto <D.28998>; else goto <D.28999>;
      <D.28998>:
      {
        struct MonoArchEHJitInfo * eh_info;

        jinfo->has_arch_eh_info = -1;
        eh_info = mono_jit_info_get_arch_eh_info (jinfo);
        p.113 = p;
        D.29000 = decode_value (p.113, &p);
        D.29001 = (unsigned int) D.29000;
        eh_info->stack_size = D.29001;
      }
      <D.28999>:
      if (async != 0) goto <D.29002>; else goto <D.29003>;
      <D.29002>:
      jinfo->async = -1;
      jinfo->d.aot_info = amodule;
      D.29004 = jinfo;
      return D.29004;
      <D.29003>:
      if (has_generic_jit_info != 0) goto <D.29005>; else goto <D.29006>;
      <D.29005>:
      {
        struct MonoGenericJitInfo * gi;
        int len;

        jinfo->has_generic_jit_info = -1;
        gi = mono_jit_info_get_generic_jit_info (jinfo);
        D.29007 = gi == 0B;
        D.29008 = (long int) D.29007;
        D.29009 = __builtin_expect (D.29008, 0);
        if (D.29009 != 0) goto <D.29010>; else goto <D.29011>;
        <D.29010>:
        monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "aot-runtime.c", 2526, "gi");
        <D.29011>:
        p.113 = p;
        D.29012 = decode_value (p.113, &p);
        gi->nlocs = D.29012;
        D.29013 = gi->nlocs;
        if (D.29013 != 0) goto <D.29014>; else goto <D.29015>;
        <D.29014>:
        D.29013 = gi->nlocs;
        D.29016 = (unsigned int) D.29013;
        D.29017 = D.29016 * 20;
        D.29018 = (int) D.29017;
        D.29019 = alloc0_jit_info_data (domain, D.29018, async);
        gi->locations = D.29019;
        i = 0;
        goto <D.26227>;
        <D.26226>:
        {
          struct MonoDwarfLocListEntry * entry;

          D.29020 = gi->locations;
          i.116 = (unsigned int) i;
          D.29021 = i.116 * 20;
          entry = D.29020 + D.29021;
          p.113 = p;
          D.29022 = decode_value (p.113, &p);
          entry->is_reg = D.29022;
          p.113 = p;
          D.29023 = decode_value (p.113, &p);
          entry->reg = D.29023;
          D.29024 = entry->is_reg;
          if (D.29024 == 0) goto <D.29025>; else goto <D.29026>;
          <D.29025>:
          p.113 = p;
          D.29027 = decode_value (p.113, &p);
          entry->offset = D.29027;
          <D.29026>:
          if (i > 0) goto <D.29028>; else goto <D.29029>;
          <D.29028>:
          p.113 = p;
          D.29030 = decode_value (p.113, &p);
          entry->from = D.29030;
          <D.29029>:
          p.113 = p;
          D.29031 = decode_value (p.113, &p);
          entry->to = D.29031;
        }
        i = i + 1;
        <D.26227>:
        D.29013 = gi->nlocs;
        if (D.29013 > i) goto <D.26226>; else goto <D.26228>;
        <D.26228>:
        goto <D.29032>;
        <D.29015>:
        if (from_llvm != 0) goto <D.29033>; else goto <D.29034>;
        <D.29033>:
        this_reg.124 = this_reg;
        D.29036 = this_reg.124 != -1;
        D.29037 = (<unnamed-signed:1>) D.29036;
        gi->has_this = D.29037;
        this_reg.124 = this_reg;
        D.29038 = (unsigned char) this_reg.124;
        gi->this_reg = D.29038;
        this_offset.125 = this_offset;
        gi->this_offset = this_offset.125;
        goto <D.29040>;
        <D.29034>:
        p.113 = p;
        D.29041 = decode_value (p.113, &p);
        D.29042 = (signed char) D.29041;
        D.29043 = (<unnamed-signed:1>) D.29042;
        gi->has_this = D.29043;
        p.113 = p;
        D.29044 = decode_value (p.113, &p);
        D.29045 = (unsigned char) D.29044;
        gi->this_reg = D.29045;
        p.113 = p;
        D.29046 = decode_value (p.113, &p);
        gi->this_offset = D.29046;
        <D.29040>:
        <D.29032>:
        p.113 = p;
        len = decode_value (p.113, &p);
        if (async != 0) goto <D.29047>; else goto <D.29048>;
        <D.29047>:
        p.113 = p;
        len.126 = (sizetype) len;
        p.127 = p.113 + len.126;
        p = p.127;
        goto <D.29051>;
        <D.29048>:
        p.113 = p;
        D.29052 = decode_resolve_method_ref (amodule, p.113, &p);
        jinfo->d.method = D.29052;
        <D.29051>:
        D.29053 = monoeg_malloc0 (8);
        gi->generic_sharing_context = D.29053;
        p.113 = p;
        D.29054 = decode_value (p.113, &p);
        if (D.29054 != 0) goto <D.29055>; else goto <D.29056>;
        <D.29055>:
        {
          int i;
          int n;
          struct MonoGenericSharingContext * gsctx;

          gsctx = gi->generic_sharing_context;
          p.113 = p;
          n = decode_value (p.113, &p);
          if (n != 0) goto <D.29057>; else goto <D.29058>;
          <D.29057>:
          n.128 = (unsigned int) n;
          D.29060 = n.128 * 4;
          D.29061 = (int) D.29060;
          D.29062 = alloc0_jit_info_data (domain, D.29061, async);
          gsctx->var_is_vt = D.29062;
          i = 0;
          goto <D.26233>;
          <D.26232>:
          D.29063 = gsctx->var_is_vt;
          i.129 = (unsigned int) i;
          D.29065 = i.129 * 4;
          D.29066 = D.29063 + D.29065;
          p.113 = p;
          D.29067 = decode_value (p.113, &p);
          *D.29066 = D.29067;
          i = i + 1;
          <D.26233>:
          if (i < n) goto <D.26232>; else goto <D.26234>;
          <D.26234>:
          <D.29058>:
          p.113 = p;
          n = decode_value (p.113, &p);
          if (n != 0) goto <D.29068>; else goto <D.29069>;
          <D.29068>:
          n.128 = (unsigned int) n;
          D.29060 = n.128 * 4;
          D.29061 = (int) D.29060;
          D.29070 = alloc0_jit_info_data (domain, D.29061, async);
          gsctx->mvar_is_vt = D.29070;
          i = 0;
          goto <D.26236>;
          <D.26235>:
          D.29071 = gsctx->mvar_is_vt;
          i.129 = (unsigned int) i;
          D.29065 = i.129 * 4;
          D.29072 = D.29071 + D.29065;
          p.113 = p;
          D.29073 = decode_value (p.113, &p);
          *D.29072 = D.29073;
          i = i + 1;
          <D.26236>:
          if (i < n) goto <D.26235>; else goto <D.26237>;
          <D.26237>:
          <D.29069>:
        }
        <D.29056>:
      }
      <D.29006>:
      D.29074 = method != 0B;
      D.29075 = has_seq_points != 0;
      D.29076 = D.29074 & D.29075;
      if (D.29076 != 0) goto <D.29077>; else goto <D.29078>;
      <D.29077>:
      {
        struct MonoSeqPointInfo * seq_points;
        int il_offset;
        int native_offset;
        int last_il_offset;
        int last_native_offset;
        int j;
        int len;

        p.113 = p;
        len = decode_value (p.113, &p);
        len.130 = (unsigned int) len;
        D.29080 = len.130 * 20;
        D.29081 = D.29080 + 4;
        seq_points = monoeg_malloc0 (D.29081);
        seq_points->len = len;
        last_native_offset = 0;
        last_il_offset = last_native_offset;
        i = 0;
        goto <D.26250>;
        <D.26249>:
        {
          struct SeqPoint * sp;

          sp = &seq_points->seq_points[i];
          p.113 = p;
          D.29082 = decode_value (p.113, &p);
          il_offset = D.29082 + last_il_offset;
          p.113 = p;
          D.29083 = decode_value (p.113, &p);
          native_offset = D.29083 + last_native_offset;
          sp->il_offset = il_offset;
          sp->native_offset = native_offset;
          p.113 = p;
          D.29084 = decode_value (p.113, &p);
          sp->flags = D.29084;
          p.113 = p;
          D.29085 = decode_value (p.113, &p);
          sp->next_len = D.29085;
          D.29086 = sp->next_len;
          D.29087 = (unsigned int) D.29086;
          D.29088 = D.29087 * 4;
          D.29089 = monoeg_malloc (D.29088);
          sp->next = D.29089;
          j = 0;
          goto <D.26247>;
          <D.26246>:
          D.29090 = sp->next;
          j.131 = (unsigned int) j;
          D.29092 = j.131 * 4;
          D.29093 = D.29090 + D.29092;
          p.113 = p;
          D.29094 = decode_value (p.113, &p);
          *D.29093 = D.29094;
          j = j + 1;
          <D.26247>:
          D.29086 = sp->next_len;
          if (D.29086 > j) goto <D.26246>; else goto <D.26248>;
          <D.26248>:
          last_il_offset = il_offset;
          last_native_offset = native_offset;
        }
        i = i + 1;
        <D.26250>:
        if (i < len) goto <D.26249>; else goto <D.26251>;
        <D.26251>:
        {
          int ret;

          D.29095 = &domain->lock.mutex;
          ret = pthread_mutex_lock (D.29095);
          if (ret != 0) goto <D.29096>; else goto <D.29097>;
          <D.29096>:
          monoeg_g_log (0B, 16, "Bad call to mono_mutex_lock result %d", ret);
          <D.29097>:
          D.29098 = ret != 0;
          D.29099 = (long int) D.29098;
          D.29100 = __builtin_expect (D.29099, 0);
          if (D.29100 != 0) goto <D.29101>; else goto <D.29102>;
          <D.29101>:
          monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "aot-runtime.c", 2608, "ret == 0");
          <D.29102>:
        }
        D.29103 = domain->runtime_info;
        D.29104 = MEM[(struct MonoJitDomainInfo *)D.29103].seq_points;
        monoeg_g_hash_table_insert_replace (D.29104, method, seq_points, 0);
        {
          int ret;

          D.29095 = &domain->lock.mutex;
          ret = pthread_mutex_unlock (D.29095);
          if (ret != 0) goto <D.29105>; else goto <D.29106>;
          <D.29105>:
          monoeg_g_log (0B, 16, "Bad call to mono_mutex_unlock result %d", ret);
          <D.29106>:
          D.29107 = ret != 0;
          D.29108 = (long int) D.29107;
          D.29109 = __builtin_expect (D.29108, 0);
          if (D.29109 != 0) goto <D.29110>; else goto <D.29111>;
          <D.29110>:
          monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "aot-runtime.c", 2610, "ret == 0");
          <D.29111>:
        }
      }
      <D.29078>:
      p.113 = p;
      buf_len = decode_value (p.113, &p);
      if (async == 0) goto <D.29112>; else goto <D.29113>;
      <D.29112>:
      p.113 = p;
      buf_len.132 = (unsigned int) buf_len;
      mono_debug_add_aot_method (domain, method, code, p.113, buf_len.132);
      <D.29113>:
      p.113 = p;
      buf_len.133 = (sizetype) buf_len;
      p.134 = p.113 + buf_len.133;
      p = p.134;
      if (has_gc_map != 0) goto <D.29117>; else goto <D.29118>;
      <D.29117>:
      {
        int map_size;

        p.113 = p;
        map_size = decode_value (p.113, &p);
        goto <D.26256>;
        <D.26255>:
        p.113 = p;
        p.135 = p.113 + 1;
        p = p.135;
        <D.26256>:
        p.113 = p;
        p.136 = (unsigned int) p.113;
        D.29121 = p.136 & 3;
        if (D.29121 != 0) goto <D.26255>; else goto <D.26257>;
        <D.26257>:
        p.113 = p;
        jinfo->gc_info = p.113;
        p.113 = p;
        map_size.137 = (sizetype) map_size;
        p.138 = p.113 + map_size.137;
        p = p.138;
      }
      <D.29118>:
      D.29124 = jinfo->d.method;
      D.29125 = D.29124->klass;
      D.29126 = D.29125->image;
      D.29127 = D.29126->aot_module;
      if (D.29127 != amodule) goto <D.29128>; else goto <D.29129>;
      <D.29128>:
      {
        int ret;

        ret = pthread_mutex_lock (&aot_mutex.mutex);
        if (ret != 0) goto <D.29130>; else goto <D.29131>;
        <D.29130>:
        monoeg_g_log (0B, 16, "Bad call to mono_mutex_lock result %d", ret);
        <D.29131>:
        D.29132 = ret != 0;
        D.29133 = (long int) D.29132;
        D.29134 = __builtin_expect (D.29133, 0);
        if (D.29134 != 0) goto <D.29135>; else goto <D.29136>;
        <D.29135>:
        monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "aot-runtime.c", 2629, "ret == 0");
        <D.29136>:
      }
      ji_to_amodule.139 = ji_to_amodule;
      if (ji_to_amodule.139 == 0B) goto <D.29138>; else goto <D.29139>;
      <D.29138>:
      ji_to_amodule.140 = monoeg_g_hash_table_new (0B, 0B);
      ji_to_amodule = ji_to_amodule.140;
      <D.29139>:
      ji_to_amodule.139 = ji_to_amodule;
      monoeg_g_hash_table_insert_replace (ji_to_amodule.139, jinfo, amodule, 0);
      {
        int ret;

        ret = pthread_mutex_unlock (&aot_mutex.mutex);
        if (ret != 0) goto <D.29141>; else goto <D.29142>;
        <D.29141>:
        monoeg_g_log (0B, 16, "Bad call to mono_mutex_unlock result %d", ret);
        <D.29142>:
        D.29143 = ret != 0;
        D.29144 = (long int) D.29143;
        D.29145 = __builtin_expect (D.29144, 0);
        if (D.29145 != 0) goto <D.29146>; else goto <D.29147>;
        <D.29146>:
        monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "aot-runtime.c", 2633, "ret == 0");
        <D.29147>:
      }
      <D.29129>:
      D.29004 = jinfo;
      return D.29004;
    }
  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.29150;
  _Bool D.29151;
  long int D.29152;
  long int D.29153;
  unsigned char D.29156;
  _Bool D.29157;
  long int D.29158;
  long int D.29159;
  int p.141;
  int D.29163;
  int D.29164;
  unsigned int D.29165;
  int D.29166;
  int D.29167;
  sizetype D.29168;
  int code.142;
  guint8 * D.29170;
  int D.29171;
  int D.29172;
  unsigned int pos.143;
  unsigned int D.29174;
  gint32 * D.29175;
  int D.29176;
  _Bool D.29177;
  long int D.29178;
  long int D.29179;
  gint32 * D.29182;
  unsigned int D.29183;
  unsigned int D.29184;
  gint32 * D.29185;
  int D.29186;
  guint8 * D.29189;
  int D.29190;
  unsigned int D.29192;
  unsigned int D.29193;
  gint32 * D.29194;
  int D.29195;
  _Bool D.29196;
  long int D.29197;
  long int D.29198;
  unsigned int D.29201;
  unsigned int D.29202;
  gint32 * D.29203;
  int D.29208;
  sizetype D.29209;
  sizetype len.144;
  int D.29214;
  sizetype D.29215;
  int code_end.145;
  int code_start.146;
  _Bool D.29218;
  _Bool D.29219;
  _Bool D.29220;
  int D.29221;
  _Bool D.29222;
  long int D.29223;
  long int D.29224;
  guint8 * D.29227;
  int D.29232;
  sizetype pos.147;
  sizetype D.29234;
  sizetype D.29235;
  gint32 * D.29236;
  int D.29237;
  sizetype D.29238;
  sizetype D.29239;
  gint32 * D.29240;
  int D.29241;
  int D.29242;
  int fde_len.148;
  int D.29244;
  int D.29245;
  unsigned int i.149;
  unsigned int D.29247;
  void * * D.29248;
  void * D.29249;
  unsigned int D.29250;
  unsigned int cindex1.150;
  unsigned int D.29252;
  struct GSList * * D.29253;
  void * D.29254;
  unsigned int j.151;
  unsigned int D.29256;
  void * * D.29257;
  void * D.29258;
  unsigned int D.29259;
  unsigned int j.152;
  unsigned int i.153;
  unsigned int D.29264;
  unsigned int D.29265;
  unsigned int extra_size.154;
  unsigned int D.29267;
  unsigned int D.29268;
  guint8 * D.29269;
  unsigned int D.29270;
  unsigned int D.29271;
  short unsigned int D.29272;
  short unsigned int D.29273;
  short unsigned int D.29274;
  <unnamed-unsigned:15> D.29275;
  unsigned int D.29276;
  unsigned int clause_index.155;
  unsigned int D.29278;
  _Bool D.29279;
  long int D.29280;
  long int D.29281;
  unsigned int D.29284;
  struct MonoClass * D.29285;
  unsigned int D.29286;
  struct MonoJitExceptionInfo * D.29287;
  void * D.29288;
  void * D.29289;
  void * D.29290;
  void * D.29293;
  int D.29296;
  int D.29297;
  void * D.29298;
  unsigned int D.29299;
  unsigned int cindex1.156;
  unsigned int D.29301;
  struct GSList * * D.29302;
  void * D.29303;
  unsigned int D.29304;
  struct MonoJitExceptionInfo * D.29307;
  struct MonoJitExceptionInfo * D.29308;
  void * D.29309;
  void * D.29310;
  _Bool D.29311;
  long int D.29312;
  long int D.29313;
  struct MonoJitInfo * D.29316;
  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.29150 = amodule->mono_eh_frame;
      D.29151 = D.29150 == 0B;
      D.29152 = (long int) D.29151;
      D.29153 = __builtin_expect (D.29152, 0);
      if (D.29153 != 0) goto <D.29154>; else goto <D.29155>;
      <D.29154>:
      monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "aot-runtime.c", 2171, "amodule->mono_eh_frame");
      <D.29155>:
      p = amodule->mono_eh_frame;
      D.29156 = *p;
      version = (int) D.29156;
      D.29157 = version != 3;
      D.29158 = (long int) D.29157;
      D.29159 = __builtin_expect (D.29158, 0);
      if (D.29159 != 0) goto <D.29160>; else goto <D.29161>;
      <D.29160>:
      monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "aot-runtime.c", 2179, "version == 3");
      <D.29161>:
      p = p + 1;
      D.29156 = *p;
      func_encoding = (int) D.29156;
      p = p + 1;
      p.141 = (int) p;
      D.29163 = p.141 + 3;
      D.29164 = D.29163 & -4;
      p = (guint8 *) D.29164;
      D.29165 = MEM[(guint32 *)p];
      fde_count = (int) D.29165;
      p = p + 4;
      table = p;
      D.29166 = fde_count + 1;
      D.29167 = D.29166 * 8;
      D.29168 = (sizetype) D.29167;
      cie = p + D.29168;
      code.142 = (int) code;
      D.29170 = amodule->code;
      D.29171 = (int) D.29170;
      offset = code.142 - D.29171;
      left = 0;
      right = fde_count;
      <D.26127>:
      D.29172 = left + right;
      pos = D.29172 / 2;
      pos.143 = (unsigned int) pos;
      D.29174 = pos.143 * 8;
      D.29175 = table + D.29174;
      D.29176 = *D.29175;
      D.29177 = D.29176 == -1;
      D.29178 = (long int) D.29177;
      D.29179 = __builtin_expect (D.29178, 0);
      if (D.29179 != 0) goto <D.29180>; else goto <D.29181>;
      <D.29180>:
      monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "aot-runtime.c", 2200, "table [(pos * 2)] != -1");
      <D.29181>:
      D.29182 = amodule->code_offsets;
      pos.143 = (unsigned int) pos;
      D.29174 = pos.143 * 8;
      D.29175 = table + D.29174;
      D.29176 = *D.29175;
      D.29183 = (unsigned int) D.29176;
      D.29184 = D.29183 * 4;
      D.29185 = D.29182 + D.29184;
      offset1 = *D.29185;
      D.29186 = pos + 1;
      if (D.29186 == fde_count) goto <D.29187>; else goto <D.29188>;
      <D.29187>:
      D.29189 = amodule->code_end;
      D.29190 = (int) D.29189;
      D.29170 = amodule->code;
      D.29171 = (int) D.29170;
      offset2 = D.29190 - D.29171;
      goto <D.29191>;
      <D.29188>:
      D.29186 = pos + 1;
      D.29192 = (unsigned int) D.29186;
      D.29193 = D.29192 * 8;
      D.29194 = table + D.29193;
      D.29195 = *D.29194;
      D.29196 = D.29195 == -1;
      D.29197 = (long int) D.29196;
      D.29198 = __builtin_expect (D.29197, 0);
      if (D.29198 != 0) goto <D.29199>; else goto <D.29200>;
      <D.29199>:
      monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "aot-runtime.c", 2205, "table [(pos + 1) * 2] != -1");
      <D.29200>:
      D.29182 = amodule->code_offsets;
      D.29186 = pos + 1;
      D.29192 = (unsigned int) D.29186;
      D.29193 = D.29192 * 8;
      D.29194 = table + D.29193;
      D.29195 = *D.29194;
      D.29201 = (unsigned int) D.29195;
      D.29202 = D.29201 * 4;
      D.29203 = D.29182 + D.29202;
      offset2 = *D.29203;
      <D.29191>:
      if (offset < offset1) goto <D.29204>; else goto <D.29205>;
      <D.29204>:
      right = pos;
      goto <D.29206>;
      <D.29205>:
      if (offset >= offset2) goto <D.29207>; else goto <D.26126>;
      <D.29207>:
      left = pos + 1;
      <D.29206>:
      goto <D.26127>;
      <D.26126>:
      D.29170 = amodule->code;
      D.29182 = amodule->code_offsets;
      pos.143 = (unsigned int) pos;
      D.29174 = pos.143 * 8;
      D.29175 = table + D.29174;
      D.29176 = *D.29175;
      D.29183 = (unsigned int) D.29176;
      D.29184 = D.29183 * 4;
      D.29185 = D.29182 + D.29184;
      D.29208 = *D.29185;
      D.29209 = (sizetype) D.29208;
      code_start = D.29170 + D.29209;
      D.29186 = pos + 1;
      if (D.29186 == fde_count) goto <D.29210>; else goto <D.29211>;
      <D.29210>:
      {
        int len;

        D.29186 = pos + 1;
        D.29192 = (unsigned int) D.29186;
        D.29193 = D.29192 * 8;
        D.29194 = table + D.29193;
        len = *D.29194;
        len.144 = (sizetype) len;
        code_end = code_start + len.144;
      }
      goto <D.29213>;
      <D.29211>:
      D.29170 = amodule->code;
      D.29182 = amodule->code_offsets;
      D.29186 = pos + 1;
      D.29192 = (unsigned int) D.29186;
      D.29193 = D.29192 * 8;
      D.29194 = table + D.29193;
      D.29195 = *D.29194;
      D.29201 = (unsigned int) D.29195;
      D.29202 = D.29201 * 4;
      D.29203 = D.29182 + D.29202;
      D.29214 = *D.29203;
      D.29215 = (sizetype) D.29214;
      code_end = D.29170 + D.29215;
      <D.29213>:
      code_end.145 = (int) code_end;
      code_start.146 = (int) code_start;
      code_len = code_end.145 - code_start.146;
      D.29218 = code < code_start;
      D.29219 = code >= code_end;
      D.29220 = D.29218 | D.29219;
      D.29221 = (int) D.29220;
      D.29222 = D.29221 != 0;
      D.29223 = (long int) D.29222;
      D.29224 = __builtin_expect (D.29223, 0);
      if (D.29224 != 0) goto <D.29225>; else goto <D.29226>;
      <D.29225>:
      monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "aot-runtime.c", 2227, "code >= code_start && code < code_end");
      <D.29226>:
      D.29227 = amodule->thumb_end;
      if (D.29227 != 0B) goto <D.29228>; else goto <D.29229>;
      <D.29228>:
      D.29227 = amodule->thumb_end;
      if (D.29227 > code_start) goto <D.29230>; else goto <D.29231>;
      <D.29230>:
      code_start.146 = (int) code_start;
      D.29232 = code_start.146 & -2;
      code_start = (guint8 *) D.29232;
      <D.29231>:
      <D.29229>:
      D.29150 = amodule->mono_eh_frame;
      pos.147 = (sizetype) pos;
      D.29234 = pos.147 * 8;
      D.29235 = D.29234 + 4;
      D.29236 = table + D.29235;
      D.29237 = *D.29236;
      D.29238 = (sizetype) D.29237;
      fde = D.29150 + D.29238;
      pos.147 = (sizetype) pos;
      D.29234 = pos.147 * 8;
      D.29239 = D.29234 + 12;
      D.29240 = table + D.29239;
      D.29241 = *D.29240;
      pos.147 = (sizetype) pos;
      D.29234 = pos.147 * 8;
      D.29235 = D.29234 + 4;
      D.29236 = table + D.29235;
      D.29237 = *D.29236;
      D.29242 = D.29241 - D.29237;
      fde_len = (guint32) D.29242;
      fde_len.148 = (int) fde_len;
      mono_unwind_decode_llvm_mono_fde (fde, fde_len.148, cie, code_start, &info);
      ei = info.ex_info;
      ei_len = info.ex_info_len;
      type_info = info.type_info;
      D.29244 = info.this_reg;
      *this_reg = D.29244;
      D.29245 = info.this_offset;
      *this_offset = D.29245;
      nested_len = 0;
      i = 0;
      goto <D.26140>;
      <D.26139>:
      {
        gint32 cindex1;
        struct GSList * l;

        i.149 = (unsigned int) i;
        D.29247 = i.149 * 4;
        D.29248 = type_info + D.29247;
        D.29249 = *D.29248;
        D.29250 = mono_read32 (D.29249);
        cindex1 = (gint32) D.29250;
        cindex1.150 = (unsigned int) cindex1;
        D.29252 = cindex1.150 * 4;
        D.29253 = nesting + D.29252;
        l = *D.29253;
        goto <D.26137>;
        <D.26136>:
        {
          gint32 nesting_cindex;

          D.29254 = l->data;
          nesting_cindex = (gint32) D.29254;
          j = 0;
          goto <D.26134>;
          <D.26133>:
          {
            gint32 cindex2;

            j.151 = (unsigned int) j;
            D.29256 = j.151 * 4;
            D.29257 = type_info + D.29256;
            D.29258 = *D.29257;
            D.29259 = mono_read32 (D.29258);
            cindex2 = (gint32) D.29259;
            if (cindex2 == nesting_cindex) goto <D.29260>; else goto <D.29261>;
            <D.29260>:
            nested_len = nested_len + 1;
            <D.29261>:
          }
          j = j + 1;
          <D.26134>:
          j.152 = (unsigned int) j;
          if (j.152 < ei_len) goto <D.26133>; else goto <D.26135>;
          <D.26135>:
        }
        l = l->next;
        <D.26137>:
        if (l != 0B) goto <D.26136>; else goto <D.26138>;
        <D.26138>:
      }
      i = i + 1;
      <D.26140>:
      i.153 = (unsigned int) i;
      if (i.153 < ei_len) goto <D.26139>; else goto <D.26141>;
      <D.26141>:
      D.29264 = ei_len + nested_len;
      D.29265 = D.29264 * 24;
      extra_size.154 = (unsigned int) extra_size;
      D.29267 = D.29265 + extra_size.154;
      D.29268 = D.29267 + 28;
      jinfo = mono_domain_alloc0_lock_free (domain, D.29268);
      jinfo->code_size = code_len;
      D.29269 = info.unw_info;
      D.29270 = info.unw_info_len;
      D.29271 = mono_cache_unwind_info (D.29269, D.29270);
      jinfo->used_regs = D.29271;
      jinfo->d.method = method;
      jinfo->code_start = code;
      jinfo->domain_neutral = 0;
      jinfo->from_aot = 0;
      D.29272 = (short unsigned int) ei_len;
      D.29273 = (short unsigned int) nested_len;
      D.29274 = D.29272 + D.29273;
      D.29275 = (<unnamed-unsigned:15>) D.29274;
      jinfo->num_clauses = D.29275;
      i = 0;
      goto <D.26146>;
      <D.26145>:
      {
        int clause_index;
        struct MonoJitExceptionInfo * jei;
        struct MonoJitExceptionInfo * orig_jei;

        i.149 = (unsigned int) i;
        D.29247 = i.149 * 4;
        D.29248 = type_info + D.29247;
        D.29249 = *D.29248;
        D.29276 = mono_read32 (D.29249);
        clause_index = (int) D.29276;
        jei = &jinfo->clauses[i];
        clause_index.155 = (unsigned int) clause_index;
        D.29278 = clause_index.155 * 24;
        orig_jei = clauses + D.29278;
        D.29279 = clause_index >= num_clauses;
        D.29280 = (long int) D.29279;
        D.29281 = __builtin_expect (D.29280, 0);
        if (D.29281 != 0) goto <D.29282>; else goto <D.29283>;
        <D.29282>:
        monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "aot-runtime.c", 2289, "clause_index < num_clauses");
        <D.29283>:
        D.29284 = orig_jei->flags;
        jei->flags = D.29284;
        D.29285 = orig_jei->data.catch_class;
        jei->data.catch_class = D.29285;
        i.149 = (unsigned int) i;
        D.29286 = i.149 * 24;
        D.29287 = ei + D.29286;
        D.29288 = D.29287->try_start;
        jei->try_start = D.29288;
        i.149 = (unsigned int) i;
        D.29286 = i.149 * 24;
        D.29287 = ei + D.29286;
        D.29289 = D.29287->try_end;
        jei->try_end = D.29289;
        i.149 = (unsigned int) i;
        D.29286 = i.149 * 24;
        D.29287 = ei + D.29286;
        D.29290 = D.29287->handler_start;
        jei->handler_start = D.29290;
        D.29227 = amodule->thumb_end;
        if (D.29227 != 0B) goto <D.29291>; else goto <D.29292>;
        <D.29291>:
        D.29293 = jei->handler_start;
        D.29227 = amodule->thumb_end;
        if (D.29293 < D.29227) goto <D.29294>; else goto <D.29295>;
        <D.29294>:
        D.29293 = jei->handler_start;
        D.29296 = (int) D.29293;
        D.29297 = D.29296 + 1;
        D.29298 = (void *) D.29297;
        jei->handler_start = D.29298;
        <D.29295>:
        <D.29292>:
      }
      i = i + 1;
      <D.26146>:
      i.153 = (unsigned int) i;
      if (i.153 < ei_len) goto <D.26145>; else goto <D.26147>;
      <D.26147>:
      nindex = ei_len;
      i = 0;
      goto <D.26159>;
      <D.26158>:
      {
        gint32 cindex1;
        struct GSList * l;

        i.149 = (unsigned int) i;
        D.29247 = i.149 * 4;
        D.29248 = type_info + D.29247;
        D.29249 = *D.29248;
        D.29299 = mono_read32 (D.29249);
        cindex1 = (gint32) D.29299;
        cindex1.156 = (unsigned int) cindex1;
        D.29301 = cindex1.156 * 4;
        D.29302 = nesting + D.29301;
        l = *D.29302;
        goto <D.26156>;
        <D.26155>:
        {
          gint32 nesting_cindex;

          D.29303 = l->data;
          nesting_cindex = (gint32) D.29303;
          j = 0;
          goto <D.26153>;
          <D.26152>:
          {
            gint32 cindex2;

            j.151 = (unsigned int) j;
            D.29256 = j.151 * 4;
            D.29257 = type_info + D.29256;
            D.29258 = *D.29257;
            D.29304 = mono_read32 (D.29258);
            cindex2 = (gint32) D.29304;
            if (cindex2 == nesting_cindex) goto <D.29305>; else goto <D.29306>;
            <D.29305>:
            D.29307 = &jinfo->clauses[nindex];
            D.29308 = &jinfo->clauses[j];
            memcpy (D.29307, D.29308, 24);
            D.29309 = jinfo->clauses[i].try_start;
            jinfo->clauses[nindex].try_start = D.29309;
            D.29310 = jinfo->clauses[i].try_end;
            jinfo->clauses[nindex].try_end = D.29310;
            nindex = nindex + 1;
            <D.29306>:
          }
          j = j + 1;
          <D.26153>:
          j.152 = (unsigned int) j;
          if (j.152 < ei_len) goto <D.26152>; else goto <D.26154>;
          <D.26154>:
        }
        l = l->next;
        <D.26156>:
        if (l != 0B) goto <D.26155>; else goto <D.26157>;
        <D.26157>:
      }
      i = i + 1;
      <D.26159>:
      i.153 = (unsigned int) i;
      if (i.153 < ei_len) goto <D.26158>; else goto <D.26160>;
      <D.26160>:
      D.29264 = ei_len + nested_len;
      D.29311 = D.29264 != nindex;
      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", 2327, "nindex == ei_len + nested_len");
      <D.29315>:
      D.29316 = jinfo;
      return D.29316;
    }
  finally
    {
      info = {CLOBBER};
    }
}


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

  if (async_context != 0) goto <D.29319>; else goto <D.29320>;
  <D.29319>:
  size.157 = (unsigned int) size;
  res = mono_domain_alloc0_lock_free (domain, size.157);
  InterlockedExchangeAdd (&async_jit_info_size, size);
  goto <D.29322>;
  <D.29320>:
  size.157 = (unsigned int) size;
  res = mono_domain_alloc0 (domain, size.157);
  <D.29322>:
  D.29323 = res;
  return D.29323;
}


InterlockedExchangeAdd (volatile gint32 * val, gint32 add)
{
  gint32 D.29325;
  unsigned int add.158;
  unsigned int D.29327;

  add.158 = (unsigned int) add;
  D.29327 = __sync_fetch_and_add_4 (val, add.158);
  D.29325 = (gint32) D.29327;
  return D.29325;
}


mono_memory_barrier ()
{
  __sync_synchronize ();
}


InterlockedCompareExchangePointer (void * volatile * dest, void * exch, void * comp)
{
  void * D.29329;
  unsigned int comp.159;
  unsigned int exch.160;
  unsigned int D.29332;

  comp.159 = (unsigned int) comp;
  exch.160 = (unsigned int) exch;
  D.29332 = __sync_val_compare_and_swap_4 (dest, comp.159, exch.160);
  D.29329 = (void *) D.29332;
  return D.29329;
}


mono_aot_get_method (struct MonoDomain * domain, struct MonoMethod * method)
{
  struct MonoImage * D.29334;
  void * amodule.161;
  struct MonoAotModule * amodule.162;
  void * D.29339;
  int D.29340;
  short unsigned int D.29345;
  int D.29346;
  int D.29347;
  short unsigned int D.29349;
  int D.29350;
  int D.29351;
  int D.29353;
  int D.29355;
  int mono_aot_only.163;
  unsigned char D.29359;
  unsigned char D.29360;
  struct MonoMethod * D.29363;
  unsigned char D.29364;
  unsigned char D.29365;
  _Bool D.29366;
  long int D.29367;
  long int D.29368;
  short unsigned int D.29373;
  short unsigned int D.29374;
  int D.29376;
  unsigned int D.29378;
  unsigned int D.29379;
  unsigned char D.29383;
  unsigned char D.29384;
  _Bool D.29388;
  long int D.29389;
  long int D.29390;
  struct GHashTable * D.29393;
  _Bool D.29396;
  long int D.29397;
  long int D.29398;
  struct MonoClass * D.29407;
  unsigned char D.29408;
  const char * D.29411;
  char * D.29412;
  int D.29417;
  void * D.29420;
  struct MonoClass * D.29425;
  int D.26560;
  int iftmp.164;
  int D.26559;
  const char[20] * D.29431;
  unsigned char D.29432;
  int D.29433;
  unsigned char D.29434;
  int D.29435;
  _Bool D.29436;
  _Bool D.29437;
  _Bool D.29438;
  const unsigned char * D.29441;
  unsigned char D.29442;
  int D.29443;
  const unsigned char * D.29444;
  unsigned char D.29445;
  int D.29446;
  _Bool D.29447;
  _Bool D.29448;
  const unsigned char * D.29451;
  unsigned char D.29452;
  int D.29453;
  const unsigned char * D.29454;
  unsigned char D.29455;
  int D.29456;
  _Bool D.29457;
  _Bool D.29458;
  const unsigned char * D.29461;
  unsigned char D.29462;
  int D.29463;
  const unsigned char * D.29464;
  unsigned char D.29465;
  int D.29466;
  struct MonoMethodSignature * D.29470;
  struct MonoType * D.29471;
  unsigned char D.29472;
  _Bool D.29475;
  long int D.29476;
  long int D.29477;
  struct MonoClass * D.29480;
  struct MonoType * D.29481;
  struct MonoGenericInst * D.29482;
  struct MonoMethod * D.29483;
  struct MonoImage * D.29495;
  struct MonoImage * D.29496;
  int D.26572;
  int iftmp.165;
  int D.26571;
  const char[17] * D.29502;
  unsigned char D.29503;
  int D.29504;
  unsigned char D.29505;
  int D.29506;
  _Bool D.29507;
  _Bool D.29508;
  _Bool D.29509;
  const unsigned char * D.29512;
  unsigned char D.29513;
  int D.29514;
  const unsigned char * D.29515;
  unsigned char D.29516;
  int D.29517;
  _Bool D.29518;
  _Bool D.29519;
  const unsigned char * D.29522;
  unsigned char D.29523;
  int D.29524;
  const unsigned char * D.29525;
  unsigned char D.29526;
  int D.29527;
  _Bool D.29528;
  _Bool D.29529;
  const unsigned char * D.29532;
  unsigned char D.29533;
  int D.29534;
  const unsigned char * D.29535;
  unsigned char D.29536;
  int D.29537;
  const char * D.29539;
  int D.26581;
  int iftmp.166;
  int D.26580;
  const char[12] * D.29544;
  unsigned char D.29545;
  int D.29546;
  unsigned char D.29547;
  int D.29548;
  _Bool D.29549;
  _Bool D.29550;
  _Bool D.29551;
  const unsigned char * D.29554;
  unsigned char D.29555;
  int D.29556;
  const unsigned char * D.29557;
  unsigned char D.29558;
  int D.29559;
  _Bool D.29560;
  _Bool D.29561;
  const unsigned char * D.29564;
  unsigned char D.29565;
  int D.29566;
  const unsigned char * D.29567;
  unsigned char D.29568;
  int D.29569;
  _Bool D.29570;
  _Bool D.29571;
  const unsigned char * D.29574;
  unsigned char D.29575;
  int D.29576;
  const unsigned char * D.29577;
  unsigned char D.29578;
  int D.29579;
  const char * D.29581;
  int D.26590;
  int iftmp.167;
  int D.26589;
  const char[16] * D.29586;
  unsigned char D.29587;
  int D.29588;
  unsigned char D.29589;
  int D.29590;
  _Bool D.29591;
  _Bool D.29592;
  _Bool D.29593;
  const unsigned char * D.29596;
  unsigned char D.29597;
  int D.29598;
  const unsigned char * D.29599;
  unsigned char D.29600;
  int D.29601;
  _Bool D.29602;
  _Bool D.29603;
  const unsigned char * D.29606;
  unsigned char D.29607;
  int D.29608;
  const unsigned char * D.29609;
  unsigned char D.29610;
  int D.29611;
  _Bool D.29612;
  _Bool D.29613;
  const unsigned char * D.29616;
  unsigned char D.29617;
  int D.29618;
  const unsigned char * D.29619;
  unsigned char D.29620;
  int D.29621;
  int D.26599;
  int iftmp.168;
  int D.26598;
  const char[9] * D.29627;
  unsigned char D.29628;
  int D.29629;
  unsigned char D.29630;
  int D.29631;
  _Bool D.29632;
  _Bool D.29633;
  _Bool D.29634;
  const unsigned char * D.29637;
  unsigned char D.29638;
  int D.29639;
  const unsigned char * D.29640;
  unsigned char D.29641;
  int D.29642;
  _Bool D.29643;
  _Bool D.29644;
  const unsigned char * D.29647;
  unsigned char D.29648;
  int D.29649;
  const unsigned char * D.29650;
  unsigned char D.29651;
  int D.29652;
  _Bool D.29653;
  _Bool D.29654;
  const unsigned char * D.29657;
  unsigned char D.29658;
  int D.29659;
  const unsigned char * D.29660;
  unsigned char D.29661;
  int D.29662;
  struct MonoMethodSignature * D.29664;
  struct MonoType * D.29665;
  int D.29666;
  int D.26608;
  int iftmp.169;
  int D.26607;
  unsigned char D.29670;
  int D.29671;
  _Bool D.29672;
  _Bool D.29673;
  _Bool D.29674;
  const unsigned char * D.29677;
  unsigned char D.29678;
  int D.29679;
  _Bool D.29680;
  _Bool D.29681;
  const unsigned char * D.29684;
  unsigned char D.29685;
  int D.29686;
  _Bool D.29687;
  _Bool D.29688;
  const unsigned char * D.29691;
  unsigned char D.29692;
  int D.29693;
  int D.26617;
  int iftmp.170;
  int D.26616;
  const char[9] * D.29699;
  unsigned char D.29700;
  int D.29701;
  unsigned char D.29702;
  int D.29703;
  _Bool D.29704;
  _Bool D.29705;
  _Bool D.29706;
  const unsigned char * D.29709;
  unsigned char D.29710;
  int D.29711;
  const unsigned char * D.29712;
  unsigned char D.29713;
  int D.29714;
  _Bool D.29715;
  _Bool D.29716;
  const unsigned char * D.29719;
  unsigned char D.29720;
  int D.29721;
  const unsigned char * D.29722;
  unsigned char D.29723;
  int D.29724;
  _Bool D.29725;
  _Bool D.29726;
  const unsigned char * D.29729;
  unsigned char D.29730;
  int D.29731;
  const unsigned char * D.29732;
  unsigned char D.29733;
  int D.29734;
  int D.26626;
  int iftmp.171;
  int D.26625;
  const char[5] * D.29740;
  unsigned char D.29741;
  int D.29742;
  unsigned char D.29743;
  int D.29744;
  _Bool D.29745;
  _Bool D.29746;
  _Bool D.29747;
  const unsigned char * D.29750;
  unsigned char D.29751;
  int D.29752;
  const unsigned char * D.29753;
  unsigned char D.29754;
  int D.29755;
  _Bool D.29756;
  _Bool D.29757;
  const unsigned char * D.29760;
  unsigned char D.29761;
  int D.29762;
  const unsigned char * D.29763;
  unsigned char D.29764;
  int D.29765;
  _Bool D.29766;
  _Bool D.29767;
  const unsigned char * D.29770;
  unsigned char D.29771;
  int D.29772;
  const unsigned char * D.29773;
  unsigned char D.29774;
  int D.29775;
  struct MonoMethodSignature * D.29778;
  struct MonoType * D.29779;
  int D.29780;
  int D.26635;
  int iftmp.172;
  int D.26634;
  unsigned char D.29784;
  int D.29785;
  _Bool D.29786;
  _Bool D.29787;
  _Bool D.29788;
  const unsigned char * D.29791;
  unsigned char D.29792;
  int D.29793;
  _Bool D.29794;
  _Bool D.29795;
  const unsigned char * D.29798;
  unsigned char D.29799;
  int D.29800;
  _Bool D.29801;
  _Bool D.29802;
  const unsigned char * D.29805;
  unsigned char D.29806;
  int D.29807;
  int D.26644;
  int iftmp.173;
  int D.26643;
  unsigned char D.29813;
  int D.29814;
  _Bool D.29815;
  _Bool D.29816;
  _Bool D.29817;
  const unsigned char * D.29820;
  unsigned char D.29821;
  int D.29822;
  _Bool D.29823;
  _Bool D.29824;
  const unsigned char * D.29827;
  unsigned char D.29828;
  int D.29829;
  _Bool D.29830;
  _Bool D.29831;
  const unsigned char * D.29834;
  unsigned char D.29835;
  int D.29836;
  int D.26653;
  int iftmp.174;
  int D.26652;
  const char[6] * D.29842;
  unsigned char D.29843;
  int D.29844;
  unsigned char D.29845;
  int D.29846;
  _Bool D.29847;
  _Bool D.29848;
  _Bool D.29849;
  const unsigned char * D.29852;
  unsigned char D.29853;
  int D.29854;
  const unsigned char * D.29855;
  unsigned char D.29856;
  int D.29857;
  _Bool D.29858;
  _Bool D.29859;
  const unsigned char * D.29862;
  unsigned char D.29863;
  int D.29864;
  const unsigned char * D.29865;
  unsigned char D.29866;
  int D.29867;
  _Bool D.29868;
  _Bool D.29869;
  const unsigned char * D.29872;
  unsigned char D.29873;
  int D.29874;
  const unsigned char * D.29875;
  unsigned char D.29876;
  int D.29877;
  struct MonoMethodSignature * D.29880;
  struct MonoType * D.29881;
  int D.29882;
  struct MonoMethodSignature * D.29883;
  short unsigned int D.29884;
  int D.26666;
  const char * D.29887;
  _Bool D.29889;
  long int D.29890;
  long int D.29891;
  struct MonoGenericInst * D.29894;
  struct MonoMethod * D.29895;
  int D.29904;
  int D.29913;
  struct MonoMethod * D.29916;
  int D.29923;
  _Bool D.29930;
  long int D.29931;
  long int D.29932;
  struct GHashTable * D.29935;
  struct GHashTable * D.29938;
  void * method_index.175;
  _Bool D.29942;
  long int D.29943;
  long int D.29944;
  int method_index.176;
  struct MonoClass * klass;
  guint32 method_index;
  struct MonoAotModule * amodule;
  guint8 * code;

  try
    {
      klass = method->klass;
      D.29334 = klass->image;
      amodule.161 = D.29334->aot_module;
      amodule = amodule.161;
      amodule.162 = amodule;
      if (amodule.162 == 0B) goto <D.29337>; else goto <D.29338>;
      <D.29337>:
      D.29339 = 0B;
      return D.29339;
      <D.29338>:
      amodule.162 = amodule;
      D.29340 = amodule.162->out_of_date;
      if (D.29340 != 0) goto <D.29341>; else goto <D.29342>;
      <D.29341>:
      D.29339 = 0B;
      return D.29339;
      <D.29342>:
      D.29345 = method->iflags;
      D.29346 = (int) D.29345;
      D.29347 = D.29346 & 4096;
      if (D.29347 != 0) goto <D.29343>; else goto <D.29348>;
      <D.29348>:
      D.29349 = method->flags;
      D.29350 = (int) D.29349;
      D.29351 = D.29350 & 8192;
      if (D.29351 != 0) goto <D.29343>; else goto <D.29352>;
      <D.29352>:
      D.29345 = method->iflags;
      D.29346 = (int) D.29345;
      D.29353 = D.29346 & 3;
      if (D.29353 != 0) goto <D.29343>; else goto <D.29354>;
      <D.29354>:
      D.29349 = method->flags;
      D.29350 = (int) D.29349;
      D.29355 = D.29350 & 1024;
      if (D.29355 != 0) goto <D.29343>; else goto <D.29344>;
      <D.29343>:
      D.29339 = 0B;
      return D.29339;
      <D.29344>:
      mono_aot_only.163 = mono_aot_only;
      if (mono_aot_only.163 != 0) goto <D.29357>; else goto <D.29358>;
      <D.29357>:
      D.29359 = BIT_FIELD_REF <*method, 8, 160>;
      D.29360 = D.29359 & 124;
      if (D.29360 == 36) goto <D.29361>; else goto <D.29362>;
      <D.29361>:
      D.29363 = mono_marshal_method_from_wrapper (method);
      D.29339 = mono_aot_get_method (domain, D.29363);
      return D.29339;
      <D.29362>:
      <D.29358>:
      D.29364 = BIT_FIELD_REF <*klass, 8, 160>;
      D.29365 = D.29364 & 1;
      D.29366 = D.29365 == 0;
      D.29367 = (long int) D.29366;
      D.29368 = __builtin_expect (D.29367, 0);
      if (D.29368 != 0) goto <D.29369>; else goto <D.29370>;
      <D.29369>:
      monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "aot-runtime.c", 3615, "klass->inited");
      <D.29370>:
      method_index = 16777215;
      D.29373 = BIT_FIELD_REF <*method, 16, 160>;
      D.29374 = D.29373 & 4220;
      if (D.29374 == 4096) goto <D.29375>; else goto <D.29371>;
      <D.29375>:
      D.29376 = mono_method_is_generic_sharable_full (method, 0, 0, 0);
      if (D.29376 != 0) goto <D.29377>; else goto <D.29371>;
      <D.29377>:
      method = mono_method_get_declaring_generic_method (method);
      D.29378 = method->token;
      D.29379 = D.29378 & 16777215;
      method_index = D.29379 + 4294967295;
      goto <D.29372>;
      <D.29371>:
      D.29383 = BIT_FIELD_REF <*method, 8, 168>;
      D.29384 = D.29383 & 16;
      if (D.29384 != 0) goto <D.29380>; else goto <D.29385>;
      <D.29385>:
      D.29378 = method->token;
      if (D.29378 == 0) goto <D.29380>; else goto <D.29381>;
      <D.29380>:
      {
        int ret;

        ret = pthread_mutex_lock (&aot_mutex.mutex);
        if (ret != 0) goto <D.29386>; else goto <D.29387>;
        <D.29386>:
        monoeg_g_log (0B, 16, "Bad call to mono_mutex_lock result %d", ret);
        <D.29387>:
        D.29388 = ret != 0;
        D.29389 = (long int) D.29388;
        D.29390 = __builtin_expect (D.29389, 0);
        if (D.29390 != 0) goto <D.29391>; else goto <D.29392>;
        <D.29391>:
        monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "aot-runtime.c", 3628, "ret == 0");
        <D.29392>:
      }
      amodule.162 = amodule;
      D.29393 = amodule.162->method_to_code;
      code = monoeg_g_hash_table_lookup (D.29393, method);
      {
        int ret;

        ret = pthread_mutex_unlock (&aot_mutex.mutex);
        if (ret != 0) goto <D.29394>; else goto <D.29395>;
        <D.29394>:
        monoeg_g_log (0B, 16, "Bad call to mono_mutex_unlock result %d", ret);
        <D.29395>:
        D.29396 = ret != 0;
        D.29397 = (long int) D.29396;
        D.29398 = __builtin_expect (D.29397, 0);
        if (D.29398 != 0) goto <D.29399>; else goto <D.29400>;
        <D.29399>:
        monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "aot-runtime.c", 3630, "ret == 0");
        <D.29400>:
      }
      if (code != 0B) goto <D.29401>; else goto <D.29402>;
      <D.29401>:
      D.29339 = code;
      return D.29339;
      <D.29402>:
      method_index = find_extra_method (method, &amodule);
      if (method_index == 16777215) goto <D.29403>; else goto <D.29404>;
      <D.29403>:
      D.29359 = BIT_FIELD_REF <*method, 8, 160>;
      D.29360 = D.29359 & 124;
      if (D.29360 == 28) goto <D.29405>; else goto <D.29406>;
      <D.29405>:
      D.29407 = method->klass;
      D.29408 = D.29407->rank;
      if (D.29408 != 0) goto <D.29409>; else goto <D.29410>;
      <D.29409>:
      D.29411 = method->name;
      D.29412 = strstr (D.29411, "System.Collections.Generic");
      if (D.29412 != 0B) goto <D.29413>; else goto <D.29414>;
      <D.29413>:
      {
        struct MonoMethod * m;

        m = mono_aot_get_array_helper_from_wrapper (method);
        code = mono_aot_get_method (domain, m);
        if (code != 0B) goto <D.29415>; else goto <D.29416>;
        <D.29415>:
        D.29417 = mono_method_needs_static_rgctx_invoke (m, 0);
        if (D.29417 != 0) goto <D.29418>; else goto <D.29419>;
        <D.29418>:
        D.29420 = mono_create_ftnptr (domain, code);
        code = mono_create_static_rgctx_trampoline (m, D.29420);
        code = mono_get_addr_from_ftnptr (code);
        <D.29419>:
        D.29339 = code;
        return D.29339;
        <D.29416>:
      }
      <D.29414>:
      <D.29410>:
      <D.29406>:
      <D.29404>:
      if (method_index == 16777215) goto <D.29421>; else goto <D.29422>;
      <D.29421>:
      D.29359 = BIT_FIELD_REF <*method, 8, 160>;
      D.29360 = D.29359 & 124;
      if (D.29360 == 24) goto <D.29423>; else goto <D.29424>;
      <D.29423>:
      D.29407 = method->klass;
      D.29425 = mono_defaults.array_class;
      if (D.29407 == D.29425) goto <D.29426>; else goto <D.29427>;
      <D.29426>:
      {
        size_t __s1_len;
        size_t __s2_len;

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

          __s2 = method->name;
          D.29431 = "GetGenericValueImpl";
          D.29432 = MEM[(const unsigned char *)D.29431];
          D.29433 = (int) D.29432;
          D.29434 = *__s2;
          D.29435 = (int) D.29434;
          __result = D.29433 - D.29435;
          {
            D.29436 = __s2_len != 0;
            D.29437 = __result == 0;
            D.29438 = D.29436 & D.29437;
            if (D.29438 != 0) goto <D.29439>; else goto <D.29440>;
            <D.29439>:
            D.29441 = &MEM[(void *)"GetGenericValueImpl" + 1B];
            D.29442 = *D.29441;
            D.29443 = (int) D.29442;
            D.29444 = __s2 + 1;
            D.29445 = *D.29444;
            D.29446 = (int) D.29445;
            __result = D.29443 - D.29446;
            D.29447 = __s2_len > 1;
            D.29437 = __result == 0;
            D.29448 = D.29447 & D.29437;
            if (D.29448 != 0) goto <D.29449>; else goto <D.29450>;
            <D.29449>:
            D.29451 = &MEM[(void *)"GetGenericValueImpl" + 2B];
            D.29452 = *D.29451;
            D.29453 = (int) D.29452;
            D.29454 = __s2 + 2;
            D.29455 = *D.29454;
            D.29456 = (int) D.29455;
            __result = D.29453 - D.29456;
            D.29457 = __s2_len > 2;
            D.29437 = __result == 0;
            D.29458 = D.29457 & D.29437;
            if (D.29458 != 0) goto <D.29459>; else goto <D.29460>;
            <D.29459>:
            D.29461 = &MEM[(void *)"GetGenericValueImpl" + 3B];
            D.29462 = *D.29461;
            D.29463 = (int) D.29462;
            D.29464 = __s2 + 3;
            D.29465 = *D.29464;
            D.29466 = (int) D.29465;
            __result = D.29463 - D.29466;
            <D.29460>:
            <D.29450>:
            <D.29440>:
          }
          D.26559 = __result;
        }
        iftmp.164 = -D.26559;
        goto <D.29467>;
        <D.29430>:
        D.29411 = method->name;
        iftmp.164 = __builtin_strcmp (D.29411, "GetGenericValueImpl");
        <D.29467>:
        D.26560 = iftmp.164;
      }
      if (D.26560 == 0) goto <D.29468>; else goto <D.29469>;
      <D.29468>:
      {
        struct MonoMethod * m;
        struct MonoGenericContext ctx;
        struct MonoType * args[16];

        try
          {
            D.29470 = mono_method_signature (method);
            D.29471 = D.29470->params[1];
            D.29472 = D.29471->type;
            if (D.29472 == 28) goto <D.29473>; else goto <D.29474>;
            <D.29473>:
            D.29339 = 0B;
            return D.29339;
            <D.29474>:
            D.29425 = mono_defaults.array_class;
            m = mono_class_get_method_from_name (D.29425, "GetGenericValueImpl", 2);
            D.29475 = m == 0B;
            D.29476 = (long int) D.29475;
            D.29477 = __builtin_expect (D.29476, 0);
            if (D.29477 != 0) goto <D.29478>; else goto <D.29479>;
            <D.29478>:
            monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "aot-runtime.c", 3670, "m");
            <D.29479>:
            memset (&ctx, 0, 8);
            D.29480 = mono_defaults.object_class;
            D.29481 = &D.29480->byval_arg;
            args[0] = D.29481;
            D.29482 = mono_metadata_get_generic_inst (1, &args);
            ctx.method_inst = D.29482;
            D.29483 = mono_class_inflate_generic_method (m, &ctx);
            m = mono_marshal_get_native_wrapper (D.29483, 1, 1);
            code = mono_aot_get_method (domain, m);
            if (code != 0B) goto <D.29484>; else goto <D.29485>;
            <D.29484>:
            D.29339 = code;
            return D.29339;
            <D.29485>:
          }
        finally
          {
            ctx = {CLOBBER};
            args = {CLOBBER};
          }
      }
      <D.29469>:
      <D.29427>:
      <D.29424>:
      <D.29422>:
      if (method_index == 16777215) goto <D.29491>; else goto <D.29492>;
      <D.29491>:
      D.29359 = BIT_FIELD_REF <*method, 8, 160>;
      D.29360 = D.29359 & 124;
      if (D.29360 == 24) goto <D.29493>; else goto <D.29494>;
      <D.29493>:
      D.29407 = method->klass;
      D.29495 = D.29407->image;
      D.29496 = mono_defaults.corlib;
      if (D.29495 == D.29496) goto <D.29497>; else goto <D.29498>;
      <D.29497>:
      {
        size_t __s1_len;
        size_t __s2_len;

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

          D.29407 = method->klass;
          __s2 = D.29407->name_space;
          D.29502 = "System.Threading";
          D.29503 = MEM[(const unsigned char *)D.29502];
          D.29504 = (int) D.29503;
          D.29505 = *__s2;
          D.29506 = (int) D.29505;
          __result = D.29504 - D.29506;
          {
            D.29507 = __s2_len != 0;
            D.29508 = __result == 0;
            D.29509 = D.29507 & D.29508;
            if (D.29509 != 0) goto <D.29510>; else goto <D.29511>;
            <D.29510>:
            D.29512 = &MEM[(void *)"System.Threading" + 1B];
            D.29513 = *D.29512;
            D.29514 = (int) D.29513;
            D.29515 = __s2 + 1;
            D.29516 = *D.29515;
            D.29517 = (int) D.29516;
            __result = D.29514 - D.29517;
            D.29518 = __s2_len > 1;
            D.29508 = __result == 0;
            D.29519 = D.29518 & D.29508;
            if (D.29519 != 0) goto <D.29520>; else goto <D.29521>;
            <D.29520>:
            D.29522 = &MEM[(void *)"System.Threading" + 2B];
            D.29523 = *D.29522;
            D.29524 = (int) D.29523;
            D.29525 = __s2 + 2;
            D.29526 = *D.29525;
            D.29527 = (int) D.29526;
            __result = D.29524 - D.29527;
            D.29528 = __s2_len > 2;
            D.29508 = __result == 0;
            D.29529 = D.29528 & D.29508;
            if (D.29529 != 0) goto <D.29530>; else goto <D.29531>;
            <D.29530>:
            D.29532 = &MEM[(void *)"System.Threading" + 3B];
            D.29533 = *D.29532;
            D.29534 = (int) D.29533;
            D.29535 = __s2 + 3;
            D.29536 = *D.29535;
            D.29537 = (int) D.29536;
            __result = D.29534 - D.29537;
            <D.29531>:
            <D.29521>:
            <D.29511>:
          }
          D.26571 = __result;
        }
        iftmp.165 = -D.26571;
        goto <D.29538>;
        <D.29501>:
        D.29407 = method->klass;
        D.29539 = D.29407->name_space;
        iftmp.165 = __builtin_strcmp (D.29539, "System.Threading");
        <D.29538>:
        D.26572 = iftmp.165;
      }
      if (D.26572 == 0) goto <D.29540>; else goto <D.29486>;
      <D.29540>:
      {
        size_t __s1_len;
        size_t __s2_len;

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

          D.29407 = method->klass;
          __s2 = D.29407->name;
          D.29544 = "Interlocked";
          D.29545 = MEM[(const unsigned char *)D.29544];
          D.29546 = (int) D.29545;
          D.29547 = *__s2;
          D.29548 = (int) D.29547;
          __result = D.29546 - D.29548;
          {
            D.29549 = __s2_len != 0;
            D.29550 = __result == 0;
            D.29551 = D.29549 & D.29550;
            if (D.29551 != 0) goto <D.29552>; else goto <D.29553>;
            <D.29552>:
            D.29554 = &MEM[(void *)"Interlocked" + 1B];
            D.29555 = *D.29554;
            D.29556 = (int) D.29555;
            D.29557 = __s2 + 1;
            D.29558 = *D.29557;
            D.29559 = (int) D.29558;
            __result = D.29556 - D.29559;
            D.29560 = __s2_len > 1;
            D.29550 = __result == 0;
            D.29561 = D.29560 & D.29550;
            if (D.29561 != 0) goto <D.29562>; else goto <D.29563>;
            <D.29562>:
            D.29564 = &MEM[(void *)"Interlocked" + 2B];
            D.29565 = *D.29564;
            D.29566 = (int) D.29565;
            D.29567 = __s2 + 2;
            D.29568 = *D.29567;
            D.29569 = (int) D.29568;
            __result = D.29566 - D.29569;
            D.29570 = __s2_len > 2;
            D.29550 = __result == 0;
            D.29571 = D.29570 & D.29550;
            if (D.29571 != 0) goto <D.29572>; else goto <D.29573>;
            <D.29572>:
            D.29574 = &MEM[(void *)"Interlocked" + 3B];
            D.29575 = *D.29574;
            D.29576 = (int) D.29575;
            D.29577 = __s2 + 3;
            D.29578 = *D.29577;
            D.29579 = (int) D.29578;
            __result = D.29576 - D.29579;
            <D.29573>:
            <D.29563>:
            <D.29553>:
          }
          D.26580 = __result;
        }
        iftmp.166 = -D.26580;
        goto <D.29580>;
        <D.29543>:
        D.29407 = method->klass;
        D.29581 = D.29407->name;
        iftmp.166 = __builtin_strcmp (D.29581, "Interlocked");
        <D.29580>:
        D.26581 = iftmp.166;
      }
      if (D.26581 == 0) goto <D.29582>; else goto <D.29486>;
      <D.29582>:
      {
        size_t __s1_len;
        size_t __s2_len;

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

          __s2 = method->name;
          D.29586 = "CompareExchange";
          D.29587 = MEM[(const unsigned char *)D.29586];
          D.29588 = (int) D.29587;
          D.29589 = *__s2;
          D.29590 = (int) D.29589;
          __result = D.29588 - D.29590;
          {
            D.29591 = __s2_len != 0;
            D.29592 = __result == 0;
            D.29593 = D.29591 & D.29592;
            if (D.29593 != 0) goto <D.29594>; else goto <D.29595>;
            <D.29594>:
            D.29596 = &MEM[(void *)"CompareExchange" + 1B];
            D.29597 = *D.29596;
            D.29598 = (int) D.29597;
            D.29599 = __s2 + 1;
            D.29600 = *D.29599;
            D.29601 = (int) D.29600;
            __result = D.29598 - D.29601;
            D.29602 = __s2_len > 1;
            D.29592 = __result == 0;
            D.29603 = D.29602 & D.29592;
            if (D.29603 != 0) goto <D.29604>; else goto <D.29605>;
            <D.29604>:
            D.29606 = &MEM[(void *)"CompareExchange" + 2B];
            D.29607 = *D.29606;
            D.29608 = (int) D.29607;
            D.29609 = __s2 + 2;
            D.29610 = *D.29609;
            D.29611 = (int) D.29610;
            __result = D.29608 - D.29611;
            D.29612 = __s2_len > 2;
            D.29592 = __result == 0;
            D.29613 = D.29612 & D.29592;
            if (D.29613 != 0) goto <D.29614>; else goto <D.29615>;
            <D.29614>:
            D.29616 = &MEM[(void *)"CompareExchange" + 3B];
            D.29617 = *D.29616;
            D.29618 = (int) D.29617;
            D.29619 = __s2 + 3;
            D.29620 = *D.29619;
            D.29621 = (int) D.29620;
            __result = D.29618 - D.29621;
            <D.29615>:
            <D.29605>:
            <D.29595>:
          }
          D.26589 = __result;
        }
        iftmp.167 = -D.26589;
        goto <D.29622>;
        <D.29585>:
        D.29411 = method->name;
        iftmp.167 = __builtin_strcmp (D.29411, "CompareExchange");
        <D.29622>:
        D.26590 = iftmp.167;
      }
      if (D.26590 == 0) goto <D.29487>; else goto <D.29623>;
      <D.29623>:
      {
        size_t __s1_len;
        size_t __s2_len;

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

          __s2 = method->name;
          D.29627 = "Exchange";
          D.29628 = MEM[(const unsigned char *)D.29627];
          D.29629 = (int) D.29628;
          D.29630 = *__s2;
          D.29631 = (int) D.29630;
          __result = D.29629 - D.29631;
          {
            D.29632 = __s2_len != 0;
            D.29633 = __result == 0;
            D.29634 = D.29632 & D.29633;
            if (D.29634 != 0) goto <D.29635>; else goto <D.29636>;
            <D.29635>:
            D.29637 = &MEM[(void *)"Exchange" + 1B];
            D.29638 = *D.29637;
            D.29639 = (int) D.29638;
            D.29640 = __s2 + 1;
            D.29641 = *D.29640;
            D.29642 = (int) D.29641;
            __result = D.29639 - D.29642;
            D.29643 = __s2_len > 1;
            D.29633 = __result == 0;
            D.29644 = D.29643 & D.29633;
            if (D.29644 != 0) goto <D.29645>; else goto <D.29646>;
            <D.29645>:
            D.29647 = &MEM[(void *)"Exchange" + 2B];
            D.29648 = *D.29647;
            D.29649 = (int) D.29648;
            D.29650 = __s2 + 2;
            D.29651 = *D.29650;
            D.29652 = (int) D.29651;
            __result = D.29649 - D.29652;
            D.29653 = __s2_len > 2;
            D.29633 = __result == 0;
            D.29654 = D.29653 & D.29633;
            if (D.29654 != 0) goto <D.29655>; else goto <D.29656>;
            <D.29655>:
            D.29657 = &MEM[(void *)"Exchange" + 3B];
            D.29658 = *D.29657;
            D.29659 = (int) D.29658;
            D.29660 = __s2 + 3;
            D.29661 = *D.29660;
            D.29662 = (int) D.29661;
            __result = D.29659 - D.29662;
            <D.29656>:
            <D.29646>:
            <D.29636>:
          }
          D.26598 = __result;
        }
        iftmp.168 = -D.26598;
        goto <D.29663>;
        <D.29626>:
        D.29411 = method->name;
        iftmp.168 = __builtin_strcmp (D.29411, "Exchange");
        <D.29663>:
        D.26599 = iftmp.168;
      }
      if (D.26599 == 0) goto <D.29487>; else goto <D.29486>;
      <D.29487>:
      D.29664 = mono_method_signature (method);
      D.29665 = D.29664->params[1];
      D.29666 = mono_type_is_reference (D.29665);
      if (D.29666 != 0) goto <D.29488>; else goto <D.29486>;
      <D.29486>:
      {
        size_t __s1_len;
        size_t __s2_len;

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

          D.29407 = method->klass;
          __s2 = D.29407->name_space;
          D.29502 = "System.Threading";
          D.29503 = MEM[(const unsigned char *)D.29502];
          D.29504 = (int) D.29503;
          D.29670 = *__s2;
          D.29671 = (int) D.29670;
          __result = D.29504 - D.29671;
          {
            D.29672 = __s2_len != 0;
            D.29673 = __result == 0;
            D.29674 = D.29672 & D.29673;
            if (D.29674 != 0) goto <D.29675>; else goto <D.29676>;
            <D.29675>:
            D.29512 = &MEM[(void *)"System.Threading" + 1B];
            D.29513 = *D.29512;
            D.29514 = (int) D.29513;
            D.29677 = __s2 + 1;
            D.29678 = *D.29677;
            D.29679 = (int) D.29678;
            __result = D.29514 - D.29679;
            D.29680 = __s2_len > 1;
            D.29673 = __result == 0;
            D.29681 = D.29680 & D.29673;
            if (D.29681 != 0) goto <D.29682>; else goto <D.29683>;
            <D.29682>:
            D.29522 = &MEM[(void *)"System.Threading" + 2B];
            D.29523 = *D.29522;
            D.29524 = (int) D.29523;
            D.29684 = __s2 + 2;
            D.29685 = *D.29684;
            D.29686 = (int) D.29685;
            __result = D.29524 - D.29686;
            D.29687 = __s2_len > 2;
            D.29673 = __result == 0;
            D.29688 = D.29687 & D.29673;
            if (D.29688 != 0) goto <D.29689>; else goto <D.29690>;
            <D.29689>:
            D.29532 = &MEM[(void *)"System.Threading" + 3B];
            D.29533 = *D.29532;
            D.29534 = (int) D.29533;
            D.29691 = __s2 + 3;
            D.29692 = *D.29691;
            D.29693 = (int) D.29692;
            __result = D.29534 - D.29693;
            <D.29690>:
            <D.29683>:
            <D.29676>:
          }
          D.26607 = __result;
        }
        iftmp.169 = -D.26607;
        goto <D.29694>;
        <D.29669>:
        D.29407 = method->klass;
        D.29539 = D.29407->name_space;
        iftmp.169 = __builtin_strcmp (D.29539, "System.Threading");
        <D.29694>:
        D.26608 = iftmp.169;
      }
      if (D.26608 == 0) goto <D.29695>; else goto <D.29489>;
      <D.29695>:
      {
        size_t __s1_len;
        size_t __s2_len;

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

          D.29407 = method->klass;
          __s2 = D.29407->name;
          D.29699 = "Volatile";
          D.29700 = MEM[(const unsigned char *)D.29699];
          D.29701 = (int) D.29700;
          D.29702 = *__s2;
          D.29703 = (int) D.29702;
          __result = D.29701 - D.29703;
          {
            D.29704 = __s2_len != 0;
            D.29705 = __result == 0;
            D.29706 = D.29704 & D.29705;
            if (D.29706 != 0) goto <D.29707>; else goto <D.29708>;
            <D.29707>:
            D.29709 = &MEM[(void *)"Volatile" + 1B];
            D.29710 = *D.29709;
            D.29711 = (int) D.29710;
            D.29712 = __s2 + 1;
            D.29713 = *D.29712;
            D.29714 = (int) D.29713;
            __result = D.29711 - D.29714;
            D.29715 = __s2_len > 1;
            D.29705 = __result == 0;
            D.29716 = D.29715 & D.29705;
            if (D.29716 != 0) goto <D.29717>; else goto <D.29718>;
            <D.29717>:
            D.29719 = &MEM[(void *)"Volatile" + 2B];
            D.29720 = *D.29719;
            D.29721 = (int) D.29720;
            D.29722 = __s2 + 2;
            D.29723 = *D.29722;
            D.29724 = (int) D.29723;
            __result = D.29721 - D.29724;
            D.29725 = __s2_len > 2;
            D.29705 = __result == 0;
            D.29726 = D.29725 & D.29705;
            if (D.29726 != 0) goto <D.29727>; else goto <D.29728>;
            <D.29727>:
            D.29729 = &MEM[(void *)"Volatile" + 3B];
            D.29730 = *D.29729;
            D.29731 = (int) D.29730;
            D.29732 = __s2 + 3;
            D.29733 = *D.29732;
            D.29734 = (int) D.29733;
            __result = D.29731 - D.29734;
            <D.29728>:
            <D.29718>:
            <D.29708>:
          }
          D.26616 = __result;
        }
        iftmp.170 = -D.26616;
        goto <D.29735>;
        <D.29698>:
        D.29407 = method->klass;
        D.29581 = D.29407->name;
        iftmp.170 = __builtin_strcmp (D.29581, "Volatile");
        <D.29735>:
        D.26617 = iftmp.170;
      }
      if (D.26617 == 0) goto <D.29736>; else goto <D.29489>;
      <D.29736>:
      {
        size_t __s1_len;
        size_t __s2_len;

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

          __s2 = method->name;
          D.29740 = "Read";
          D.29741 = MEM[(const unsigned char *)D.29740];
          D.29742 = (int) D.29741;
          D.29743 = *__s2;
          D.29744 = (int) D.29743;
          __result = D.29742 - D.29744;
          {
            D.29745 = __s2_len != 0;
            D.29746 = __result == 0;
            D.29747 = D.29745 & D.29746;
            if (D.29747 != 0) goto <D.29748>; else goto <D.29749>;
            <D.29748>:
            D.29750 = &MEM[(void *)"Read" + 1B];
            D.29751 = *D.29750;
            D.29752 = (int) D.29751;
            D.29753 = __s2 + 1;
            D.29754 = *D.29753;
            D.29755 = (int) D.29754;
            __result = D.29752 - D.29755;
            D.29756 = __s2_len > 1;
            D.29746 = __result == 0;
            D.29757 = D.29756 & D.29746;
            if (D.29757 != 0) goto <D.29758>; else goto <D.29759>;
            <D.29758>:
            D.29760 = &MEM[(void *)"Read" + 2B];
            D.29761 = *D.29760;
            D.29762 = (int) D.29761;
            D.29763 = __s2 + 2;
            D.29764 = *D.29763;
            D.29765 = (int) D.29764;
            __result = D.29762 - D.29765;
            D.29766 = __s2_len > 2;
            D.29746 = __result == 0;
            D.29767 = D.29766 & D.29746;
            if (D.29767 != 0) goto <D.29768>; else goto <D.29769>;
            <D.29768>:
            D.29770 = &MEM[(void *)"Read" + 3B];
            D.29771 = *D.29770;
            D.29772 = (int) D.29771;
            D.29773 = __s2 + 3;
            D.29774 = *D.29773;
            D.29775 = (int) D.29774;
            __result = D.29772 - D.29775;
            <D.29769>:
            <D.29759>:
            <D.29749>:
          }
          D.26625 = __result;
        }
        iftmp.171 = -D.26625;
        goto <D.29776>;
        <D.29739>:
        D.29411 = method->name;
        iftmp.171 = __builtin_strcmp (D.29411, "Read");
        <D.29776>:
        D.26626 = iftmp.171;
      }
      if (D.26626 == 0) goto <D.29777>; else goto <D.29489>;
      <D.29777>:
      D.29778 = mono_method_signature (method);
      D.29779 = D.29778->ret;
      D.29780 = mono_type_is_reference (D.29779);
      if (D.29780 != 0) goto <D.29488>; else goto <D.29489>;
      <D.29489>:
      {
        size_t __s1_len;
        size_t __s2_len;

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

          D.29407 = method->klass;
          __s2 = D.29407->name_space;
          D.29502 = "System.Threading";
          D.29503 = MEM[(const unsigned char *)D.29502];
          D.29504 = (int) D.29503;
          D.29784 = *__s2;
          D.29785 = (int) D.29784;
          __result = D.29504 - D.29785;
          {
            D.29786 = __s2_len != 0;
            D.29787 = __result == 0;
            D.29788 = D.29786 & D.29787;
            if (D.29788 != 0) goto <D.29789>; else goto <D.29790>;
            <D.29789>:
            D.29512 = &MEM[(void *)"System.Threading" + 1B];
            D.29513 = *D.29512;
            D.29514 = (int) D.29513;
            D.29791 = __s2 + 1;
            D.29792 = *D.29791;
            D.29793 = (int) D.29792;
            __result = D.29514 - D.29793;
            D.29794 = __s2_len > 1;
            D.29787 = __result == 0;
            D.29795 = D.29794 & D.29787;
            if (D.29795 != 0) goto <D.29796>; else goto <D.29797>;
            <D.29796>:
            D.29522 = &MEM[(void *)"System.Threading" + 2B];
            D.29523 = *D.29522;
            D.29524 = (int) D.29523;
            D.29798 = __s2 + 2;
            D.29799 = *D.29798;
            D.29800 = (int) D.29799;
            __result = D.29524 - D.29800;
            D.29801 = __s2_len > 2;
            D.29787 = __result == 0;
            D.29802 = D.29801 & D.29787;
            if (D.29802 != 0) goto <D.29803>; else goto <D.29804>;
            <D.29803>:
            D.29532 = &MEM[(void *)"System.Threading" + 3B];
            D.29533 = *D.29532;
            D.29534 = (int) D.29533;
            D.29805 = __s2 + 3;
            D.29806 = *D.29805;
            D.29807 = (int) D.29806;
            __result = D.29534 - D.29807;
            <D.29804>:
            <D.29797>:
            <D.29790>:
          }
          D.26634 = __result;
        }
        iftmp.172 = -D.26634;
        goto <D.29808>;
        <D.29783>:
        D.29407 = method->klass;
        D.29539 = D.29407->name_space;
        iftmp.172 = __builtin_strcmp (D.29539, "System.Threading");
        <D.29808>:
        D.26635 = iftmp.172;
      }
      if (D.26635 == 0) goto <D.29809>; else goto <D.29490>;
      <D.29809>:
      {
        size_t __s1_len;
        size_t __s2_len;

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

          D.29407 = method->klass;
          __s2 = D.29407->name;
          D.29699 = "Volatile";
          D.29700 = MEM[(const unsigned char *)D.29699];
          D.29701 = (int) D.29700;
          D.29813 = *__s2;
          D.29814 = (int) D.29813;
          __result = D.29701 - D.29814;
          {
            D.29815 = __s2_len != 0;
            D.29816 = __result == 0;
            D.29817 = D.29815 & D.29816;
            if (D.29817 != 0) goto <D.29818>; else goto <D.29819>;
            <D.29818>:
            D.29709 = &MEM[(void *)"Volatile" + 1B];
            D.29710 = *D.29709;
            D.29711 = (int) D.29710;
            D.29820 = __s2 + 1;
            D.29821 = *D.29820;
            D.29822 = (int) D.29821;
            __result = D.29711 - D.29822;
            D.29823 = __s2_len > 1;
            D.29816 = __result == 0;
            D.29824 = D.29823 & D.29816;
            if (D.29824 != 0) goto <D.29825>; else goto <D.29826>;
            <D.29825>:
            D.29719 = &MEM[(void *)"Volatile" + 2B];
            D.29720 = *D.29719;
            D.29721 = (int) D.29720;
            D.29827 = __s2 + 2;
            D.29828 = *D.29827;
            D.29829 = (int) D.29828;
            __result = D.29721 - D.29829;
            D.29830 = __s2_len > 2;
            D.29816 = __result == 0;
            D.29831 = D.29830 & D.29816;
            if (D.29831 != 0) goto <D.29832>; else goto <D.29833>;
            <D.29832>:
            D.29729 = &MEM[(void *)"Volatile" + 3B];
            D.29730 = *D.29729;
            D.29731 = (int) D.29730;
            D.29834 = __s2 + 3;
            D.29835 = *D.29834;
            D.29836 = (int) D.29835;
            __result = D.29731 - D.29836;
            <D.29833>:
            <D.29826>:
            <D.29819>:
          }
          D.26643 = __result;
        }
        iftmp.173 = -D.26643;
        goto <D.29837>;
        <D.29812>:
        D.29407 = method->klass;
        D.29581 = D.29407->name;
        iftmp.173 = __builtin_strcmp (D.29581, "Volatile");
        <D.29837>:
        D.26644 = iftmp.173;
      }
      if (D.26644 == 0) goto <D.29838>; else goto <D.29490>;
      <D.29838>:
      {
        size_t __s1_len;
        size_t __s2_len;

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

          __s2 = method->name;
          D.29842 = "Write";
          D.29843 = MEM[(const unsigned char *)D.29842];
          D.29844 = (int) D.29843;
          D.29845 = *__s2;
          D.29846 = (int) D.29845;
          __result = D.29844 - D.29846;
          {
            D.29847 = __s2_len != 0;
            D.29848 = __result == 0;
            D.29849 = D.29847 & D.29848;
            if (D.29849 != 0) goto <D.29850>; else goto <D.29851>;
            <D.29850>:
            D.29852 = &MEM[(void *)"Write" + 1B];
            D.29853 = *D.29852;
            D.29854 = (int) D.29853;
            D.29855 = __s2 + 1;
            D.29856 = *D.29855;
            D.29857 = (int) D.29856;
            __result = D.29854 - D.29857;
            D.29858 = __s2_len > 1;
            D.29848 = __result == 0;
            D.29859 = D.29858 & D.29848;
            if (D.29859 != 0) goto <D.29860>; else goto <D.29861>;
            <D.29860>:
            D.29862 = &MEM[(void *)"Write" + 2B];
            D.29863 = *D.29862;
            D.29864 = (int) D.29863;
            D.29865 = __s2 + 2;
            D.29866 = *D.29865;
            D.29867 = (int) D.29866;
            __result = D.29864 - D.29867;
            D.29868 = __s2_len > 2;
            D.29848 = __result == 0;
            D.29869 = D.29868 & D.29848;
            if (D.29869 != 0) goto <D.29870>; else goto <D.29871>;
            <D.29870>:
            D.29872 = &MEM[(void *)"Write" + 3B];
            D.29873 = *D.29872;
            D.29874 = (int) D.29873;
            D.29875 = __s2 + 3;
            D.29876 = *D.29875;
            D.29877 = (int) D.29876;
            __result = D.29874 - D.29877;
            <D.29871>:
            <D.29861>:
            <D.29851>:
          }
          D.26652 = __result;
        }
        iftmp.174 = -D.26652;
        goto <D.29878>;
        <D.29841>:
        D.29411 = method->name;
        iftmp.174 = __builtin_strcmp (D.29411, "Write");
        <D.29878>:
        D.26653 = iftmp.174;
      }
      if (D.26653 == 0) goto <D.29879>; else goto <D.29490>;
      <D.29879>:
      D.29880 = mono_method_signature (method);
      D.29881 = D.29880->params[1];
      D.29882 = mono_type_is_reference (D.29881);
      if (D.29882 != 0) goto <D.29488>; else goto <D.29490>;
      <D.29488>:
      {
        struct MonoMethod * m;
        struct MonoGenericContext ctx;
        struct MonoType * args[16];
        void * iter;

        try
          {
            iter = 0B;
            goto <D.26669>;
            <D.26668>:
            D.29883 = mono_method_signature (m);
            D.29884 = D.29883->generic_param_count;
            if (D.29884 != 0) goto <D.29885>; else goto <D.29886>;
            <D.29885>:
            {
              size_t __s1_len;
              size_t __s2_len;

              D.29887 = m->name;
              D.29411 = method->name;
              D.26666 = __builtin_strcmp (D.29887, D.29411);
            }
            if (D.26666 == 0) goto <D.26667>; else goto <D.29888>;
            <D.29888>:
            <D.29886>:
            <D.26669>:
            D.29407 = method->klass;
            m = mono_class_get_methods (D.29407, &iter);
            if (m != 0B) goto <D.26668>; else goto <D.26667>;
            <D.26667>:
            D.29889 = m == 0B;
            D.29890 = (long int) D.29889;
            D.29891 = __builtin_expect (D.29890, 0);
            if (D.29891 != 0) goto <D.29892>; else goto <D.29893>;
            <D.29892>:
            monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "aot-runtime.c", 3702, "m");
            <D.29893>:
            memset (&ctx, 0, 8);
            D.29480 = mono_defaults.object_class;
            D.29481 = &D.29480->byval_arg;
            args[0] = D.29481;
            D.29894 = mono_metadata_get_generic_inst (1, &args);
            ctx.method_inst = D.29894;
            D.29895 = mono_class_inflate_generic_method (m, &ctx);
            m = mono_marshal_get_native_wrapper (D.29895, 1, 1);
            if (method == m) goto <D.29896>; else goto <D.29897>;
            <D.29896>:
            D.29339 = 0B;
            return D.29339;
            <D.29897>:
            code = mono_aot_get_method (domain, m);
            if (code != 0B) goto <D.29898>; else goto <D.29899>;
            <D.29898>:
            D.29339 = code;
            return D.29339;
            <D.29899>:
          }
        finally
          {
            ctx = {CLOBBER};
            args = {CLOBBER};
            iter = {CLOBBER};
          }
      }
      <D.29490>:
      <D.29498>:
      <D.29494>:
      <D.29492>:
      if (method_index == 16777215) goto <D.29900>; else goto <D.29901>;
      <D.29900>:
      D.29383 = BIT_FIELD_REF <*method, 8, 168>;
      D.29384 = D.29383 & 16;
      if (D.29384 != 0) goto <D.29902>; else goto <D.29903>;
      <D.29902>:
      D.29904 = mono_method_is_generic_sharable_full (method, 0, 1, 0);
      if (D.29904 != 0) goto <D.29905>; else goto <D.29906>;
      <D.29905>:
      {
        struct MonoMethod * shared;

        shared = mini_get_shared_method (method);
        method_index = find_extra_method (shared, &amodule);
        if (method_index != 16777215) goto <D.29907>; else goto <D.29908>;
        <D.29907>:
        method = shared;
        <D.29908>:
      }
      <D.29906>:
      <D.29903>:
      <D.29901>:
      if (method_index == 16777215) goto <D.29909>; else goto <D.29910>;
      <D.29909>:
      D.29383 = BIT_FIELD_REF <*method, 8, 168>;
      D.29384 = D.29383 & 16;
      if (D.29384 != 0) goto <D.29911>; else goto <D.29912>;
      <D.29911>:
      D.29913 = mono_method_is_generic_sharable_full (method, 0, 0, 1);
      if (D.29913 != 0) goto <D.29914>; else goto <D.29915>;
      <D.29914>:
      D.29916 = mini_get_shared_method_full (method, 1, 1);
      method_index = find_extra_method (D.29916, &amodule);
      if (method_index != 16777215) goto <D.29917>; else goto <D.29918>;
      <D.29917>:
      method = mini_get_shared_method_full (method, 1, 0);
      <D.29918>:
      <D.29915>:
      <D.29912>:
      <D.29910>:
      if (method_index == 16777215) goto <D.29919>; else goto <D.29920>;
      <D.29919>:
      mono_aot_only.163 = mono_aot_only;
      if (mono_aot_only.163 != 0) goto <D.29921>; else goto <D.29922>;
      <D.29921>:
      D.29923 = mono_trace_is_traced (128, 32);
      if (D.29923 != 0) goto <D.29924>; else goto <D.29925>;
      <D.29924>:
      {
        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.29925>:
      <D.29922>:
      D.29339 = 0B;
      return D.29339;
      <D.29920>:
      if (method_index == 16777215) goto <D.29926>; else goto <D.29927>;
      <D.29926>:
      D.29339 = 0B;
      return D.29339;
      <D.29927>:
      {
        int ret;

        ret = pthread_mutex_lock (&aot_mutex.mutex);
        if (ret != 0) goto <D.29928>; else goto <D.29929>;
        <D.29928>:
        monoeg_g_log (0B, 16, "Bad call to mono_mutex_lock result %d", ret);
        <D.29929>:
        D.29930 = ret != 0;
        D.29931 = (long int) D.29930;
        D.29932 = __builtin_expect (D.29931, 0);
        if (D.29932 != 0) goto <D.29933>; else goto <D.29934>;
        <D.29933>:
        monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "aot-runtime.c", 3756, "ret == 0");
        <D.29934>:
      }
      amodule.162 = amodule;
      D.29935 = amodule.162->extra_methods;
      if (D.29935 == 0B) goto <D.29936>; else goto <D.29937>;
      <D.29936>:
      amodule.162 = amodule;
      D.29938 = monoeg_g_hash_table_new (0B, 0B);
      amodule.162->extra_methods = D.29938;
      <D.29937>:
      amodule.162 = amodule;
      D.29935 = amodule.162->extra_methods;
      method_index.175 = (void *) method_index;
      monoeg_g_hash_table_insert_replace (D.29935, method_index.175, method, 0);
      {
        int ret;

        ret = pthread_mutex_unlock (&aot_mutex.mutex);
        if (ret != 0) goto <D.29940>; else goto <D.29941>;
        <D.29940>:
        monoeg_g_log (0B, 16, "Bad call to mono_mutex_unlock result %d", ret);
        <D.29941>:
        D.29942 = ret != 0;
        D.29943 = (long int) D.29942;
        D.29944 = __builtin_expect (D.29943, 0);
        if (D.29944 != 0) goto <D.29945>; else goto <D.29946>;
        <D.29945>:
        monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "aot-runtime.c", 3760, "ret == 0");
        <D.29946>:
      }
      goto <D.29382>;
      <D.29381>:
      D.29378 = method->token;
      D.29379 = D.29378 & 16777215;
      method_index = D.29379 + 4294967295;
      <D.29382>:
      <D.29372>:
      amodule.162 = amodule;
      D.29334 = klass->image;
      D.29378 = method->token;
      method_index.176 = (int) method_index;
      D.29339 = load_method (domain, amodule.162, D.29334, method, D.29378, method_index.176);
      return D.29339;
    }
  finally
    {
      amodule = {CLOBBER};
    }
}


find_extra_method (struct MonoMethod * method, struct MonoAotModule * * out_amodule)
{
  struct MonoClass * D.29954;
  struct MonoImage * D.29955;
  void * D.29956;
  guint32 D.29959;
  _Bool D.29962;
  long int D.29963;
  long int D.29964;
  struct GHashTable * aot_modules.177;
  _Bool D.29970;
  long int D.29971;
  long int D.29972;
  void * * D.29975;
  unsigned int i.178;
  unsigned int D.29977;
  void * * D.29978;
  unsigned int i.179;
  unsigned int D.29984;
  guint32 index;
  struct GPtrArray * modules;
  int i;

  D.29954 = method->klass;
  D.29955 = D.29954->image;
  D.29956 = D.29955->aot_module;
  *out_amodule = D.29956;
  D.29954 = method->klass;
  D.29955 = D.29954->image;
  D.29956 = D.29955->aot_module;
  index = find_extra_method_in_amodule (D.29956, method);
  if (index != 16777215) goto <D.29957>; else goto <D.29958>;
  <D.29957>:
  D.29959 = index;
  return D.29959;
  <D.29958>:
  modules = monoeg_g_ptr_array_new ();
  {
    int ret;

    ret = pthread_mutex_lock (&aot_mutex.mutex);
    if (ret != 0) goto <D.29960>; else goto <D.29961>;
    <D.29960>:
    monoeg_g_log (0B, 16, "Bad call to mono_mutex_lock result %d", ret);
    <D.29961>:
    D.29962 = ret != 0;
    D.29963 = (long int) D.29962;
    D.29964 = __builtin_expect (D.29963, 0);
    if (D.29964 != 0) goto <D.29965>; else goto <D.29966>;
    <D.29965>:
    monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "aot-runtime.c", 3559, "ret == 0");
    <D.29966>:
  }
  aot_modules.177 = aot_modules;
  monoeg_g_hash_table_foreach (aot_modules.177, add_module_cb, modules);
  {
    int ret;

    ret = pthread_mutex_unlock (&aot_mutex.mutex);
    if (ret != 0) goto <D.29968>; else goto <D.29969>;
    <D.29968>:
    monoeg_g_log (0B, 16, "Bad call to mono_mutex_unlock result %d", ret);
    <D.29969>:
    D.29970 = ret != 0;
    D.29971 = (long int) D.29970;
    D.29972 = __builtin_expect (D.29971, 0);
    if (D.29972 != 0) goto <D.29973>; else goto <D.29974>;
    <D.29973>:
    monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "aot-runtime.c", 3561, "ret == 0");
    <D.29974>:
  }
  index = 16777215;
  i = 0;
  goto <D.26540>;
  <D.26539>:
  {
    struct MonoAotModule * amodule;

    D.29975 = modules->pdata;
    i.178 = (unsigned int) i;
    D.29977 = i.178 * 4;
    D.29978 = D.29975 + D.29977;
    amodule = *D.29978;
    D.29954 = method->klass;
    D.29955 = D.29954->image;
    D.29956 = D.29955->aot_module;
    if (D.29956 != amodule) goto <D.29979>; else goto <D.29980>;
    <D.29979>:
    index = find_extra_method_in_amodule (amodule, method);
    <D.29980>:
    if (index != 16777215) goto <D.29981>; else goto <D.29982>;
    <D.29981>:
    *out_amodule = amodule;
    goto <D.26538>;
    <D.29982>:
  }
  i = i + 1;
  <D.26540>:
  i.179 = (unsigned int) i;
  D.29984 = modules->len;
  if (i.179 < D.29984) goto <D.26539>; else goto <D.26538>;
  <D.26538>:
  monoeg_g_ptr_array_free (modules, 1);
  D.29959 = index;
  return D.29959;
}


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.29989;
  guint32 D.29990;
  guint32 * D.29991;
  unsigned int D.29992;
  unsigned int D.29993;
  unsigned int D.29994;
  unsigned int D.29995;
  sizetype D.29998;
  sizetype D.29999;
  guint32 * D.30000;
  guint8 * D.30001;
  guint8 * p.180;
  _Bool D.30005;
  long int D.30006;
  long int D.30007;
  struct GHashTable * D.30010;
  struct GHashTable * D.30013;
  guint8 * p.181;
  _Bool D.30017;
  long int D.30018;
  long int D.30019;
  _Bool D.30028;
  long int D.30029;
  long int D.30030;
  _Bool D.30035;
  long int D.30036;
  long int D.30037;
  unsigned char D.30044;
  unsigned char D.30045;
  unsigned char D.30050;
  unsigned char D.30051;
  struct MonoMethod * D.30054;
  unsigned int n_extra_decodes.182;
  unsigned int n_extra_decodes.183;
  unsigned int D.30062;
  unsigned int D.30063;
  guint32 table_size;
  guint32 entry_size;
  guint32 hash;
  guint32 * table;
  guint32 * entry;
  guint32 index;
  static guint32 n_extra_decodes;

  if (amodule == 0B) goto <D.29986>; else goto <D.29988>;
  <D.29988>:
  D.29989 = amodule->out_of_date;
  if (D.29989 != 0) goto <D.29986>; else goto <D.29987>;
  <D.29986>:
  D.29990 = 16777215;
  return D.29990;
  <D.29987>:
  D.29991 = amodule->extra_method_table;
  table_size = *D.29991;
  D.29991 = amodule->extra_method_table;
  table = D.29991 + 4;
  entry_size = 3;
  D.29992 = mono_aot_method_hash (method);
  hash = D.29992 % table_size;
  D.29993 = hash * entry_size;
  D.29994 = D.29993 * 4;
  entry = table + D.29994;
  D.29995 = *entry;
  if (D.29995 == 0) goto <D.29996>; else goto <D.29997>;
  <D.29996>:
  D.29990 = 16777215;
  return D.29990;
  <D.29997>:
  index = 16777215;
  <D.26522>:
  {
    guint32 key;
    guint32 value;
    guint32 next;
    struct MonoMethod * m;
    guint8 * p;
    guint8 * orig_p;

    try
      {
        key = *entry;
        value = MEM[(guint32 *)entry + 4B];
        D.29998 = entry_size + 1073741823;
        D.29999 = D.29998 * 4;
        D.30000 = entry + D.29999;
        next = *D.30000;
        D.30001 = amodule->blob;
        p.180 = D.30001 + key;
        p = p.180;
        orig_p = p;
        {
          int ret;

          ret = pthread_mutex_lock (&aot_mutex.mutex);
          if (ret != 0) goto <D.30003>; else goto <D.30004>;
          <D.30003>:
          monoeg_g_log (0B, 16, "Bad call to mono_mutex_lock result %d", ret);
          <D.30004>:
          D.30005 = ret != 0;
          D.30006 = (long int) D.30005;
          D.30007 = __builtin_expect (D.30006, 0);
          if (D.30007 != 0) goto <D.30008>; else goto <D.30009>;
          <D.30008>:
          monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "aot-runtime.c", 3479, "ret == 0");
          <D.30009>:
        }
        D.30010 = amodule->method_ref_to_method;
        if (D.30010 == 0B) goto <D.30011>; else goto <D.30012>;
        <D.30011>:
        D.30013 = monoeg_g_hash_table_new (0B, 0B);
        amodule->method_ref_to_method = D.30013;
        <D.30012>:
        D.30010 = amodule->method_ref_to_method;
        p.181 = p;
        m = monoeg_g_hash_table_lookup (D.30010, p.181);
        {
          int ret;

          ret = pthread_mutex_unlock (&aot_mutex.mutex);
          if (ret != 0) goto <D.30015>; else goto <D.30016>;
          <D.30015>:
          monoeg_g_log (0B, 16, "Bad call to mono_mutex_unlock result %d", ret);
          <D.30016>:
          D.30017 = ret != 0;
          D.30018 = (long int) D.30017;
          D.30019 = __builtin_expect (D.30018, 0);
          if (D.30019 != 0) goto <D.30020>; else goto <D.30021>;
          <D.30020>:
          monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "aot-runtime.c", 3483, "ret == 0");
          <D.30021>:
        }
        if (m == 0B) goto <D.30022>; else goto <D.30023>;
        <D.30022>:
        p.181 = p;
        m = decode_resolve_method_ref_with_target (amodule, method, p.181, &p);
        if (m != 0B) goto <D.30024>; else goto <D.30025>;
        <D.30024>:
        {
          int ret;

          ret = pthread_mutex_lock (&aot_mutex.mutex);
          if (ret != 0) goto <D.30026>; else goto <D.30027>;
          <D.30026>:
          monoeg_g_log (0B, 16, "Bad call to mono_mutex_lock result %d", ret);
          <D.30027>:
          D.30028 = ret != 0;
          D.30029 = (long int) D.30028;
          D.30030 = __builtin_expect (D.30029, 0);
          if (D.30030 != 0) goto <D.30031>; else goto <D.30032>;
          <D.30031>:
          monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "aot-runtime.c", 3487, "ret == 0");
          <D.30032>:
        }
        D.30010 = amodule->method_ref_to_method;
        monoeg_g_hash_table_insert_replace (D.30010, orig_p, m, 0);
        {
          int ret;

          ret = pthread_mutex_unlock (&aot_mutex.mutex);
          if (ret != 0) goto <D.30033>; else goto <D.30034>;
          <D.30033>:
          monoeg_g_log (0B, 16, "Bad call to mono_mutex_unlock result %d", ret);
          <D.30034>:
          D.30035 = ret != 0;
          D.30036 = (long int) D.30035;
          D.30037 = __builtin_expect (D.30036, 0);
          if (D.30037 != 0) goto <D.30038>; else goto <D.30039>;
          <D.30038>:
          monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "aot-runtime.c", 3489, "ret == 0");
          <D.30039>:
        }
        <D.30025>:
        <D.30023>:
        if (m == method) goto <D.30040>; else goto <D.30041>;
        <D.30040>:
        index = value;
        goto <D.26519>;
        <D.30041>:
        if (m != 0B) goto <D.30042>; else goto <D.30043>;
        <D.30042>:
        D.30044 = BIT_FIELD_REF <*method, 8, 160>;
        D.30045 = D.30044 & 124;
        if (D.30045 != 0) goto <D.30046>; else goto <D.30047>;
        <D.30046>:
        D.30044 = BIT_FIELD_REF <*method, 8, 160>;
        D.30045 = D.30044 & 124;
        if (D.30045 == 64) goto <D.30048>; else goto <D.30049>;
        <D.30048>:
        {
          struct MonoMethod * w1;
          struct MonoMethod * w2;

          w1 = mono_marshal_method_from_wrapper (method);
          w2 = mono_marshal_method_from_wrapper (m);
          D.30050 = BIT_FIELD_REF <*w1, 8, 168>;
          D.30051 = D.30050 & 16;
          if (D.30051 != 0) goto <D.30052>; else goto <D.30053>;
          <D.30052>:
          D.30054 = MEM[(struct MonoMethodInflated *)w1].declaring;
          if (D.30054 == w2) goto <D.30055>; else goto <D.30056>;
          <D.30055>:
          index = value;
          goto <D.26519>;
          <D.30056>:
          <D.30053>:
        }
        <D.30049>:
        <D.30047>:
        <D.30043>:
        if (m != 0B) goto <D.30057>; else goto <D.30058>;
        <D.30057>:
        n_extra_decodes.182 = n_extra_decodes;
        n_extra_decodes.183 = n_extra_decodes.182 + 1;
        n_extra_decodes = n_extra_decodes.183;
        <D.30058>:
        if (next != 0) goto <D.30061>; else goto <D.26519>;
        <D.30061>:
        D.30062 = next * entry_size;
        D.30063 = D.30062 * 4;
        entry = table + D.30063;
      }
    finally
      {
        p = {CLOBBER};
      }
  }
  goto <D.26522>;
  <D.26519>:
  D.29990 = index;
  return D.29990;
}


load_method (struct MonoDomain * domain, struct MonoAotModule * amodule, struct MonoImage * image, struct MonoMethod * method, guint32 token, int method_index)
{
  _Bool D.30067;
  <unnamed type> D.30068;
  unsigned int D.30069;
  void * D.30072;
  struct MonoDomain * D.30073;
  unsigned int D.30076;
  unsigned int D.30077;
  int D.30080;
  gint32 * D.30083;
  unsigned int method_index.184;
  unsigned int D.30085;
  gint32 * D.30086;
  int D.30087;
  int D.30090;
  guint8 * D.30095;
  sizetype D.30096;
  guint8 * D.30097;
  guint32 * D.30098;
  unsigned int D.30099;
  guint8 * D.30100;
  unsigned int D.30105;
  unsigned int D.30106;
  int D.30109;
  _Bool D.30110;
  long int D.30111;
  long int D.30112;
  sizetype D.30115;
  _Bool D.30118;
  long int D.30119;
  long int D.30120;
  guint32 * D.30123;
  unsigned int D.30126;
  unsigned int D.30127;
  unsigned int D.30128;
  unsigned int D.30129;
  void * D.30130;
  _Bool D.30133;
  long int D.30134;
  long int D.30135;
  int D.30138;
  unsigned int D.30139;
  unsigned int D.30140;
  guint32 * D.30141;
  unsigned int D.30142;
  int D.30143;
  unsigned int D.30144;
  unsigned int D.30145;
  int mono_last_aot_method.185;
  int D.30151;
  int D.30154;
  guint8 * p.186;
  int D.30169;
  struct MonoDomain * D.30170;
  unsigned int D.30171;
  unsigned int pindex.187;
  unsigned int D.30181;
  void * * D.30182;
  guint32 * got_slots.188;
  unsigned int D.30184;
  guint32 * D.30185;
  unsigned int D.30186;
  unsigned int D.30187;
  void * * D.30188;
  void * D.30189;
  void * D.30192;
  <unnamed type> D.30193;
  void * D.30196;
  struct MonoMethod * D.30199;
  struct MonoDebugOptions * D.30202;
  int D.30203;
  struct MonoAssembly * D.30206;
  struct MonoImage * D.30207;
  int D.30208;
  int D.30215;
  sizetype D.30216;
  guint8 * D.30217;
  _Bool D.30220;
  long int D.30221;
  long int D.30222;
  int D.30225;
  unsigned int D.30226;
  unsigned int D.30227;
  guint32 * D.30228;
  unsigned int D.30229;
  int D.30230;
  unsigned int D.30231;
  unsigned int D.30232;
  unsigned char D.30235;
  unsigned char D.30236;
  struct GHashTable * D.30239;
  _Bool D.30242;
  long int D.30243;
  long int D.30244;
  <unnamed type> D.30247;
  unsigned int D.30248;
  long int D.30253;
  long int D.30254;
  _Bool D.30257;
  long int D.30258;
  long int D.30259;
  _Bool D.30262;
  _Bool D.30263;
  _Bool D.30264;
  struct MonoGenericContainer * D.30267;
  struct MonoVTable * D.30270;
  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.30067 = method == 0B;
      from_plt = (gboolean) D.30067;
      keep_patches = 1;
      jinfo = 0B;
      D.30068 = mono_profiler_get_events ();
      D.30069 = D.30068 & 4096;
      if (D.30069 != 0) goto <D.30070>; else goto <D.30071>;
      <D.30070>:
      D.30072 = 0B;
      return D.30072;
      <D.30071>:
      D.30073 = mono_get_root_domain ();
      if (D.30073 != domain) goto <D.30074>; else goto <D.30075>;
      <D.30074>:
      D.30076 = amodule->info.opts;
      D.30077 = D.30076 & 512;
      if (D.30077 == 0) goto <D.30078>; else goto <D.30079>;
      <D.30078>:
      D.30072 = 0B;
      return D.30072;
      <D.30079>:
      <D.30075>:
      D.30080 = amodule->out_of_date;
      if (D.30080 != 0) goto <D.30081>; else goto <D.30082>;
      <D.30081>:
      D.30072 = 0B;
      return D.30072;
      <D.30082>:
      D.30083 = amodule->code_offsets;
      method_index.184 = (unsigned int) method_index;
      D.30085 = method_index.184 * 4;
      D.30086 = D.30083 + D.30085;
      D.30087 = *D.30086;
      if (D.30087 == -1) goto <D.30088>; else goto <D.30089>;
      <D.30088>:
      D.30090 = mono_trace_is_traced (128, 32);
      if (D.30090 != 0) goto <D.30091>; else goto <D.30092>;
      <D.30091>:
      {
        char * full_name;

        if (method == 0B) goto <D.30093>; else goto <D.30094>;
        <D.30093>:
        method = mono_get_method (image, token, 0B);
        <D.30094>:
        full_name = mono_method_full_name (method, 1);
        mono_trace (128, 32, "AOT NOT FOUND: %s.", full_name);
        monoeg_g_free (full_name);
      }
      <D.30092>:
      D.30072 = 0B;
      return D.30072;
      <D.30089>:
      D.30095 = amodule->code;
      D.30083 = amodule->code_offsets;
      method_index.184 = (unsigned int) method_index;
      D.30085 = method_index.184 * 4;
      D.30086 = D.30083 + D.30085;
      D.30087 = *D.30086;
      D.30096 = (sizetype) D.30087;
      code = D.30095 + D.30096;
      D.30097 = amodule->blob;
      D.30098 = amodule->method_info_offsets;
      D.30099 = mono_aot_get_offset (D.30098, method_index);
      info = D.30097 + D.30099;
      D.30100 = amodule->thumb_end;
      if (D.30100 != 0B) goto <D.30101>; else goto <D.30102>;
      <D.30101>:
      D.30100 = amodule->thumb_end;
      if (D.30100 > code) goto <D.30103>; else goto <D.30104>;
      <D.30103>:
      D.30105 = amodule->info.flags;
      D.30106 = D.30105 & 8;
      if (D.30106 == 0) goto <D.30107>; else goto <D.30108>;
      <D.30107>:
      D.30083 = amodule->code_offsets;
      method_index.184 = (unsigned int) method_index;
      D.30085 = method_index.184 * 4;
      D.30086 = D.30083 + D.30085;
      D.30087 = *D.30086;
      D.30109 = D.30087 & 1;
      D.30110 = D.30109 != 0;
      D.30111 = (long int) D.30110;
      D.30112 = __builtin_expect (D.30111, 0);
      if (D.30112 != 0) goto <D.30113>; else goto <D.30114>;
      <D.30113>:
      monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "aot-runtime.c", 3299, "(amodule->code_offsets [method_index] & 0x1) == 0");
      <D.30114>:
      D.30095 = amodule->code;
      D.30083 = amodule->code_offsets;
      method_index.184 = (unsigned int) method_index;
      D.30085 = method_index.184 * 4;
      D.30086 = D.30083 + D.30085;
      D.30087 = *D.30086;
      D.30096 = (sizetype) D.30087;
      D.30115 = D.30096 + 1;
      code = D.30095 + D.30115;
      <D.30108>:
      <D.30104>:
      <D.30102>:
      {
        int ret;

        ret = pthread_mutex_lock (&aot_mutex.mutex);
        if (ret != 0) goto <D.30116>; else goto <D.30117>;
        <D.30116>:
        monoeg_g_log (0B, 16, "Bad call to mono_mutex_lock result %d", ret);
        <D.30117>:
        D.30118 = ret != 0;
        D.30119 = (long int) D.30118;
        D.30120 = __builtin_expect (D.30119, 0);
        if (D.30120 != 0) goto <D.30121>; else goto <D.30122>;
        <D.30121>:
        monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "aot-runtime.c", 3303, "ret == 0");
        <D.30122>:
      }
      D.30123 = amodule->methods_loaded;
      if (D.30123 == 0B) goto <D.30124>; else goto <D.30125>;
      <D.30124>:
      D.30126 = amodule->info.nmethods;
      D.30127 = D.30126 / 32;
      D.30128 = D.30127 + 1;
      D.30129 = D.30128 * 4;
      D.30130 = monoeg_malloc0 (D.30129);
      amodule->methods_loaded = D.30130;
      <D.30125>:
      {
        int ret;

        ret = pthread_mutex_unlock (&aot_mutex.mutex);
        if (ret != 0) goto <D.30131>; else goto <D.30132>;
        <D.30131>:
        monoeg_g_log (0B, 16, "Bad call to mono_mutex_unlock result %d", ret);
        <D.30132>:
        D.30133 = ret != 0;
        D.30134 = (long int) D.30133;
        D.30135 = __builtin_expect (D.30134, 0);
        if (D.30135 != 0) goto <D.30136>; else goto <D.30137>;
        <D.30136>:
        monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "aot-runtime.c", 3306, "ret == 0");
        <D.30137>:
      }
      D.30123 = amodule->methods_loaded;
      D.30138 = method_index / 32;
      D.30139 = (unsigned int) D.30138;
      D.30140 = D.30139 * 4;
      D.30141 = D.30123 + D.30140;
      D.30142 = *D.30141;
      D.30143 = method_index % 32;
      D.30144 = D.30142 >> D.30143;
      D.30145 = D.30144 & 1;
      if (D.30145 != 0) goto <D.30146>; else goto <D.30147>;
      <D.30146>:
      D.30072 = code;
      return D.30072;
      <D.30147>:
      mono_last_aot_method.185 = mono_last_aot_method;
      if (mono_last_aot_method.185 != -1) goto <D.30149>; else goto <D.30150>;
      <D.30149>:
      D.30151 = mono_jit_stats.methods_aot;
      mono_last_aot_method.185 = mono_last_aot_method;
      if (D.30151 >= mono_last_aot_method.185) goto <D.30152>; else goto <D.30153>;
      <D.30152>:
      D.30072 = 0B;
      return D.30072;
      <D.30153>:
      D.30151 = mono_jit_stats.methods_aot;
      mono_last_aot_method.185 = mono_last_aot_method;
      D.30154 = mono_last_aot_method.185 + -1;
      if (D.30151 == D.30154) goto <D.30155>; else goto <D.30156>;
      <D.30155>:
      if (method == 0B) goto <D.30157>; else goto <D.30158>;
      <D.30157>:
      method = mono_get_method (image, token, 0B);
      <D.30158>:
      if (method != 0B) goto <D.30159>; else goto <D.30160>;
      <D.30159>:
      {
        char * name;

        name = mono_method_full_name (method, 1);
        printf ("LAST AOT METHOD: %s.\n", name);
        monoeg_g_free (name);
      }
      goto <D.30161>;
      <D.30160>:
      printf ("LAST AOT METHOD: %p %d\n", code, method_index);
      <D.30161>:
      <D.30156>:
      <D.30150>:
      p = info;
      if (method != 0B) goto <D.30162>; else goto <D.30163>;
      <D.30162>:
      klass = method->klass;
      p.186 = p;
      decode_klass_ref (amodule, p.186, &p);
      goto <D.30165>;
      <D.30163>:
      p.186 = p;
      klass = decode_klass_ref (amodule, p.186, &p);
      <D.30165>:
      D.30076 = amodule->info.opts;
      D.30077 = D.30076 & 512;
      if (D.30077 != 0) goto <D.30166>; else goto <D.30167>;
      <D.30166>:
      p.186 = p;
      used_strings = decode_value (p.186, &p);
      goto <D.30168>;
      <D.30167>:
      used_strings = 0;
      <D.30168>:
      i = 0;
      goto <D.26485>;
      <D.26484>:
      {
        guint token;

        p.186 = p;
        D.30169 = decode_value (p.186, &p);
        token = (guint) D.30169;
        D.30170 = mono_get_root_domain ();
        D.30171 = token & 16777215;
        mono_ldstr (D.30170, image, D.30171);
      }
      i = i + 1;
      <D.26485>:
      if (i < used_strings) goto <D.26484>; else goto <D.26486>;
      <D.26486>:
      D.30076 = amodule->info.opts;
      D.30077 = D.30076 & 512;
      if (D.30077 != 0) goto <D.30172>; else goto <D.30173>;
      <D.30172>:
      keep_patches = 0;
      <D.30173>:
      p.186 = p;
      n_patches = decode_value (p.186, &p);
      keep_patches = 0;
      if (n_patches != 0) goto <D.30174>; else goto <D.30175>;
      <D.30174>:
      {
        struct MonoJumpInfo * patches;
        guint32 * got_slots;

        try
          {
            if (keep_patches != 0) goto <D.30176>; else goto <D.30177>;
            <D.30176>:
            mp = domain->mp;
            goto <D.30178>;
            <D.30177>:
            mp = mono_mempool_new ();
            <D.30178>:
            p.186 = p;
            patches = load_patch_info (amodule, mp, n_patches, &got_slots, p.186, &p);
            if (patches == 0B) goto cleanup; else goto <D.30179>;
            <D.30179>:
            pindex = 0;
            goto <D.26492>;
            <D.26491>:
            {
              struct MonoJumpInfo * ji;

              pindex.187 = (unsigned int) pindex;
              D.30181 = pindex.187 * 20;
              ji = patches + D.30181;
              D.30182 = amodule->got;
              got_slots.188 = got_slots;
              pindex.187 = (unsigned int) pindex;
              D.30184 = pindex.187 * 4;
              D.30185 = got_slots.188 + D.30184;
              D.30186 = *D.30185;
              D.30187 = D.30186 * 4;
              D.30188 = D.30182 + D.30187;
              D.30189 = *D.30188;
              if (D.30189 == 0B) goto <D.30190>; else goto <D.30191>;
              <D.30190>:
              D.30182 = amodule->got;
              got_slots.188 = got_slots;
              pindex.187 = (unsigned int) pindex;
              D.30184 = pindex.187 * 4;
              D.30185 = got_slots.188 + D.30184;
              D.30186 = *D.30185;
              D.30187 = D.30186 * 4;
              D.30188 = D.30182 + D.30187;
              D.30192 = mono_resolve_patch_target (method, domain, code, ji, 1);
              *D.30188 = D.30192;
              D.30193 = ji->type;
              if (D.30193 == 4) goto <D.30194>; else goto <D.30195>;
              <D.30194>:
              D.30182 = amodule->got;
              got_slots.188 = got_slots;
              pindex.187 = (unsigned int) pindex;
              D.30184 = pindex.187 * 4;
              D.30185 = got_slots.188 + D.30184;
              D.30186 = *D.30185;
              D.30187 = D.30186 * 4;
              D.30188 = D.30182 + D.30187;
              D.30182 = amodule->got;
              got_slots.188 = got_slots;
              pindex.187 = (unsigned int) pindex;
              D.30184 = pindex.187 * 4;
              D.30185 = got_slots.188 + D.30184;
              D.30186 = *D.30185;
              D.30187 = D.30186 * 4;
              D.30188 = D.30182 + D.30187;
              D.30189 = *D.30188;
              D.30196 = mono_create_ftnptr (domain, D.30189);
              *D.30188 = D.30196;
              <D.30195>:
              D.30193 = ji->type;
              if (D.30193 == 4) goto <D.30197>; else goto <D.30198>;
              <D.30197>:
              D.30199 = ji->data.method;
              D.30182 = amodule->got;
              got_slots.188 = got_slots;
              pindex.187 = (unsigned int) pindex;
              D.30184 = pindex.187 * 4;
              D.30185 = got_slots.188 + D.30184;
              D.30186 = *D.30185;
              D.30187 = D.30186 * 4;
              D.30188 = D.30182 + D.30187;
              register_jump_target_got_slot (domain, D.30199, D.30188);
              <D.30198>:
              <D.30191>:
              ji->type = 51;
            }
            pindex = pindex + 1;
            <D.26492>:
            if (pindex < n_patches) goto <D.26491>; else goto <D.26493>;
            <D.26493>:
            got_slots.188 = got_slots;
            monoeg_g_free (got_slots.188);
            if (keep_patches == 0) goto <D.30200>; else goto <D.30201>;
            <D.30200>:
            mono_mempool_destroy (mp);
            <D.30201>:
          }
        finally
          {
            got_slots = {CLOBBER};
          }
      }
      <D.30175>:
      D.30202 = mini_get_debug_options ();
      D.30203 = D.30202->load_aot_jit_info_eagerly;
      if (D.30203 != 0) goto <D.30204>; else goto <D.30205>;
      <D.30204>:
      D.30206 = amodule->assembly;
      D.30207 = D.30206->image;
      jinfo = mono_aot_find_jit_info (domain, D.30207, code);
      <D.30205>:
      D.30208 = mono_trace_is_traced (128, 32);
      if (D.30208 != 0) goto <D.30209>; else goto <D.30210>;
      <D.30209>:
      {
        char * full_name;

        if (method == 0B) goto <D.30211>; else goto <D.30212>;
        <D.30211>:
        method = mono_get_method (image, token, 0B);
        <D.30212>:
        full_name = mono_method_full_name (method, 1);
        if (jinfo == 0B) goto <D.30213>; else goto <D.30214>;
        <D.30213>:
        D.30206 = amodule->assembly;
        D.30207 = D.30206->image;
        jinfo = mono_aot_find_jit_info (domain, D.30207, code);
        <D.30214>:
        D.30215 = jinfo->code_size;
        D.30216 = (sizetype) D.30215;
        D.30217 = code + D.30216;
        mono_trace (128, 32, "AOT FOUND method %s [%p - %p %p]", full_name, code, D.30217, info);
        monoeg_g_free (full_name);
      }
      <D.30210>:
      {
        int ret;

        ret = pthread_mutex_lock (&aot_mutex.mutex);
        if (ret != 0) goto <D.30218>; else goto <D.30219>;
        <D.30218>:
        monoeg_g_log (0B, 16, "Bad call to mono_mutex_lock result %d", ret);
        <D.30219>:
        D.30220 = ret != 0;
        D.30221 = (long int) D.30220;
        D.30222 = __builtin_expect (D.30221, 0);
        if (D.30222 != 0) goto <D.30223>; else goto <D.30224>;
        <D.30223>:
        monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "aot-runtime.c", 3403, "ret == 0");
        <D.30224>:
      }
      InterlockedIncrement (&mono_jit_stats.methods_aot);
      D.30123 = amodule->methods_loaded;
      D.30225 = method_index / 32;
      D.30226 = (unsigned int) D.30225;
      D.30227 = D.30226 * 4;
      D.30228 = D.30123 + D.30227;
      D.30123 = amodule->methods_loaded;
      D.30226 = (unsigned int) D.30225;
      D.30227 = D.30226 * 4;
      D.30228 = D.30123 + D.30227;
      D.30229 = *D.30228;
      D.30143 = method_index % 32;
      D.30230 = 1 << D.30143;
      D.30231 = (unsigned int) D.30230;
      D.30232 = D.30229 | D.30231;
      *D.30228 = D.30232;
      init_plt (amodule);
      if (method != 0B) goto <D.30233>; else goto <D.30234>;
      <D.30233>:
      D.30235 = BIT_FIELD_REF <*method, 8, 160>;
      D.30236 = D.30235 & 124;
      if (D.30236 != 0) goto <D.30237>; else goto <D.30238>;
      <D.30237>:
      D.30239 = amodule->method_to_code;
      monoeg_g_hash_table_insert_replace (D.30239, method, code, 0);
      <D.30238>:
      <D.30234>:
      {
        int ret;

        ret = pthread_mutex_unlock (&aot_mutex.mutex);
        if (ret != 0) goto <D.30240>; else goto <D.30241>;
        <D.30240>:
        monoeg_g_log (0B, 16, "Bad call to mono_mutex_unlock result %d", ret);
        <D.30241>:
        D.30242 = ret != 0;
        D.30243 = (long int) D.30242;
        D.30244 = __builtin_expect (D.30243, 0);
        if (D.30244 != 0) goto <D.30245>; else goto <D.30246>;
        <D.30245>:
        monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "aot-runtime.c", 3414, "ret == 0");
        <D.30246>:
      }
      D.30247 = mono_profiler_get_events ();
      D.30248 = D.30247 & 16;
      if (D.30248 != 0) goto <D.30249>; else goto <D.30250>;
      <D.30249>:
      {
        struct MonoJitInfo * jinfo;

        if (method == 0B) goto <D.30251>; else goto <D.30252>;
        <D.30251>:
        method = mono_get_method (image, token, 0B);
        D.30067 = method == 0B;
        D.30253 = (long int) D.30067;
        D.30254 = __builtin_expect (D.30253, 0);
        if (D.30254 != 0) goto <D.30255>; else goto <D.30256>;
        <D.30255>:
        monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "aot-runtime.c", 3421, "method");
        <D.30256>:
        <D.30252>:
        mono_profiler_method_jit (method);
        jinfo = mono_jit_info_table_find (domain, code);
        D.30257 = jinfo == 0B;
        D.30258 = (long int) D.30257;
        D.30259 = __builtin_expect (D.30258, 0);
        if (D.30259 != 0) goto <D.30260>; else goto <D.30261>;
        <D.30260>:
        monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "aot-runtime.c", 3425, "jinfo");
        <D.30261>:
        mono_profiler_method_end_jit (method, jinfo, 0);
      }
      <D.30250>:
      D.30262 = from_plt != 0;
      D.30263 = klass != 0B;
      D.30264 = D.30262 & D.30263;
      if (D.30264 != 0) goto <D.30265>; else goto <D.30266>;
      <D.30265>:
      D.30267 = klass->generic_container;
      if (D.30267 == 0B) goto <D.30268>; else goto <D.30269>;
      <D.30268>:
      D.30270 = mono_class_vtable (domain, klass);
      mono_runtime_class_init (D.30270);
      <D.30269>:
      <D.30266>:
      D.30072 = code;
      return D.30072;
      cleanup:
      D.30076 = amodule->info.opts;
      D.30077 = D.30076 & 512;
      if (D.30077 != 0) goto <D.30271>; else goto <D.30272>;
      <D.30271>:
      mono_mempool_destroy (mp);
      <D.30272>:
      if (jinfo != 0B) goto <D.30273>; else goto <D.30274>;
      <D.30273>:
      monoeg_g_free (jinfo);
      <D.30274>:
      D.30072 = 0B;
      return D.30072;
    }
  finally
    {
      p = {CLOBBER};
    }
}


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

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


load_patch_info (struct MonoAotModule * aot_module, struct MonoMemPool * mp, int n_patches, guint32 * * got_slots, guint8 * buf, guint8 * * endbuf)
{
  unsigned int n_patches.189;
  unsigned int D.30282;
  unsigned int D.30283;
  void * D.30284;
  unsigned int pindex.190;
  unsigned int D.30286;
  guint8 * p.191;
  int D.30288;
  void * * D.30289;
  unsigned int D.30290;
  void * * D.30291;
  void * D.30292;
  guint8 * D.30296;
  guint32 * D.30297;
  int got_offset.192;
  unsigned int D.30299;
  guint8 * shared_p.193;
  guint8 * shared_p.194;
  int D.30302;
  <unnamed type> D.30303;
  guint32 * D.30305;
  unsigned int D.30306;
  guint32 * D.30307;
  struct MonoJumpInfo * D.30308;
  struct MonoJumpInfo * patches;
  int pindex;
  guint8 * p;
  void cleanup = <<< error >>>;

  try
    {
      p = buf;
      n_patches.189 = (unsigned int) n_patches;
      D.30282 = n_patches.189 * 20;
      patches = mono_mempool_alloc0 (mp, D.30282);
      n_patches.189 = (unsigned int) n_patches;
      D.30283 = n_patches.189 * 4;
      D.30284 = monoeg_malloc (D.30283);
      *got_slots = D.30284;
      pindex = 0;
      goto <D.26448>;
      <D.26447>:
      {
        struct MonoJumpInfo * ji;
        guint8 * shared_p;
        gboolean res;
        guint32 got_offset;

        try
          {
            pindex.190 = (unsigned int) pindex;
            D.30286 = pindex.190 * 20;
            ji = patches + D.30286;
            p.191 = p;
            D.30288 = decode_value (p.191, &p);
            got_offset = (guint32) D.30288;
            D.30289 = aot_module->got;
            D.30290 = got_offset * 4;
            D.30291 = D.30289 + D.30290;
            D.30292 = *D.30291;
            if (D.30292 != 0B) goto <D.30293>; else goto <D.30294>;
            <D.30293>:
            goto <D.30295>;
            <D.30294>:
            D.30296 = aot_module->blob;
            D.30297 = aot_module->got_info_offsets;
            got_offset.192 = (int) got_offset;
            D.30299 = mono_aot_get_offset (D.30297, got_offset.192);
            shared_p.193 = D.30296 + D.30299;
            shared_p = shared_p.193;
            shared_p.194 = shared_p;
            D.30302 = decode_value (shared_p.194, &shared_p);
            D.30303 = (<unnamed type>) D.30302;
            ji->type = D.30303;
            shared_p.194 = shared_p;
            res = decode_patch (aot_module, mp, ji, shared_p.194, &shared_p);
            if (res == 0) goto cleanup; else goto <D.30304>;
            <D.30304>:
            <D.30295>:
            D.30305 = *got_slots;
            pindex.190 = (unsigned int) pindex;
            D.30306 = pindex.190 * 4;
            D.30307 = D.30305 + D.30306;
            *D.30307 = got_offset;
          }
        finally
          {
            shared_p = {CLOBBER};
          }
      }
      pindex = pindex + 1;
      <D.26448>:
      if (pindex < n_patches) goto <D.26447>; else goto <D.26449>;
      <D.26449>:
      p.191 = p;
      *endbuf = p.191;
      D.30308 = patches;
      return D.30308;
      cleanup:
      D.30305 = *got_slots;
      monoeg_g_free (D.30305);
      *got_slots = 0B;
      D.30308 = 0B;
      return D.30308;
    }
  finally
    {
      p = {CLOBBER};
    }
}


decode_patch (struct MonoAotModule * aot_module, struct MonoMemPool * mp, struct MonoJumpInfo * ji, guint8 * buf, guint8 * * endbuf)
{
  <unnamed type> D.30313;
  guint8 * p.195;
  struct MonoMethod * D.30318;
  int mono_aot_only.196;
  int D.30322;
  unsigned int D.30325;
  unsigned int D.30326;
  struct MonoDomain * D.30328;
  struct MonoImage * D.30329;
  void * D.30330;
  void * D.30331;
  struct MonoMethod * D.30335;
  struct MonoMethod * D.30336;
  _Bool D.30337;
  long int D.30338;
  long int D.30339;
  struct MonoClass * D.30342;
  int D.30343;
  sizetype D.30344;
  guint8 * p.197;
  struct MonoMethod * D.30346;
  struct MonoClass * D.30348;
  struct MonoClass * D.30349;
  struct MonoClass * D.30351;
  int D.30353;
  struct MonoImage * D.30354;
  struct MonoImage * D.30355;
  struct MonoClassField * D.30357;
  struct MonoClassField * D.30358;
  void * D.30360;
  struct MonoJumpInfoBBTable * D.30361;
  int D.30362;
  struct MonoDomain * D.30363;
  int D.30364;
  unsigned int D.30365;
  unsigned int D.30366;
  unsigned int i.198;
  unsigned int D.30368;
  void * * D.30369;
  int D.30370;
  void * D.30371;
  struct MonoDomain * D.30372;
  void * D.30373;
  int D.30374;
  unsigned int val.199;
  const void * D.30376;
  guint32 * val.200;
  float D.30378;
  struct MonoDomain * D.30379;
  void * D.30380;
  int D.30381;
  unsigned int D.30382;
  int D.30383;
  unsigned int D.30384;
  unsigned int D.30385;
  long long unsigned int D.30386;
  long long unsigned int D.30387;
  unsigned int D.30388;
  long long unsigned int D.30389;
  long long unsigned int v.201;
  guint64 * v.202;
  double D.30392;
  int D.30393;
  int D.30395;
  int D.30396;
  unsigned int D.30397;
  struct MonoJumpInfoToken * D.30398;
  int D.30399;
  int D.30401;
  unsigned int D.30402;
  struct MonoJumpInfoToken * D.30403;
  struct MonoJumpInfoToken * D.30404;
  int D.30405;
  int D.30406;
  struct MonoGenericContext * D.30409;
  struct MonoClass * D.30411;
  const char * D.30413;
  int D.30414;
  int D.30415;
  int D.30416;
  guint8 * D.30417;
  guint8 * p2.203;
  guint8 * p2.204;
  struct MonoMethod * D.30420;
  unsigned int D.30421;
  _Bool D.30422;
  int D.30423;
  unsigned int D.30424;
  unsigned int D.30425;
  void * D.30426;
  struct MonoJumpInfo * D.30427;
  unsigned int D.30428;
  unsigned int D.30429;
  struct MonoMethod * D.30431;
  int D.30432;
  struct MonoMethodSignature * D.30433;
  int D.30434;
  const void * D.30435;
  struct MonoMethodSignature * D.30436;
  struct MonoMethodSignature * D.30437;
  _Bool D.30438;
  long int D.30439;
  long int D.30440;
  struct MonoMethod * D.30443;
  struct MonoMethod * D.30444;
  _Bool D.30445;
  long int D.30446;
  long int D.30447;
  struct MonoMethod * D.30450;
  struct MonoMethod * D.30451;
  _Bool D.30452;
  long int D.30453;
  long int D.30454;
  struct GPtrArray * D.30457;
  int D.30458;
  <unnamed type> D.30459;
  <unnamed type> D.30460;
  <unnamed type> D.30461;
  struct MonoType * D.30463;
  struct MonoClassField * D.30464;
  void * D.30465;
  struct GPtrArray * D.30467;
  gboolean D.30468;
  guint8 * p;
  void * * table;
  struct MonoImage * image;
  int i;
  void cleanup = <<< error >>>;

  try
    {
      p = buf;
      D.30313 = ji->type;
      switch (D.30313) <default: <D.26430>, case 3: <D.26358>, case 4: <D.26359>, case 5: <D.26396>, case 6: <D.26370>, case 7: <D.26367>, case 8: <D.26380>, case 10: <D.26395>, case 11: <D.26372>, case 12: <D.26377>, case 13: <D.26378>, case 14: <D.26371>, case 15: <D.26375>, case 16: <D.26379>, case 17: <D.26389>, case 18: <D.26392>, case 19: <D.26393>, case 20: <D.26384>, case 21: <D.26386>, case 23: <D.26373>, case 24: <D.26374>, case 28: <D.26391>, case 29: <D.26390>, case 30: <D.26376>, case 31: <D.26360>, case 32: <D.26368>, case 33: <D.26397>, case 34: <D.26361>, case 35: <D.26404>, case 36: <D.26398>, case 37: <D.26399>, case 38: <D.26400>, case 40: <D.26410>, case 41: <D.26411>, case 42: <D.26401>, case 43: <D.26402>, case 44: <D.26413>, case 45: <D.26415>, case 46: <D.26417>, case 47: <D.26403>, case 48: <D.26414>, case 50: <D.26362>>
      <D.26358>:
      <D.26359>:
      <D.26360>:
      <D.26361>:
      <D.26362>:
      {
        struct MethodRef ref;
        gboolean res;

        try
          {
            p.195 = p;
            res = decode_method_ref (aot_module, &ref, p.195, &p);
            if (res == 0) goto cleanup; else goto <D.30315>;
            <D.30315>:
            D.30318 = ref.method;
            if (D.30318 == 0B) goto <D.30319>; else goto <D.30316>;
            <D.30319>:
            mono_aot_only.196 = mono_aot_only;
            if (mono_aot_only.196 == 0) goto <D.30321>; else goto <D.30316>;
            <D.30321>:
            D.30322 = ref.no_aot_trampoline;
            if (D.30322 == 0) goto <D.30323>; else goto <D.30316>;
            <D.30323>:
            D.30313 = ji->type;
            if (D.30313 == 3) goto <D.30324>; else goto <D.30316>;
            <D.30324>:
            D.30325 = ref.token;
            D.30326 = D.30325 >> 24;
            if (D.30326 == 6) goto <D.30327>; else goto <D.30316>;
            <D.30327>:
            D.30328 = mono_domain_get ();
            D.30329 = ref.image;
            D.30325 = ref.token;
            D.30330 = mono_create_jit_trampoline_from_token (D.30329, D.30325);
            D.30331 = mono_create_ftnptr (D.30328, D.30330);
            ji->data.target = D.30331;
            ji->type = 1;
            goto <D.30317>;
            <D.30316>:
            D.30318 = ref.method;
            if (D.30318 != 0B) goto <D.30332>; else goto <D.30333>;
            <D.30332>:
            D.30318 = ref.method;
            ji->data.method = D.30318;
            goto <D.30334>;
            <D.30333>:
            D.30329 = ref.image;
            D.30325 = ref.token;
            D.30335 = mono_get_method (D.30329, D.30325, 0B);
            ji->data.method = D.30335;
            <D.30334>:
            D.30336 = ji->data.method;
            D.30337 = D.30336 == 0B;
            D.30338 = (long int) D.30337;
            D.30339 = __builtin_expect (D.30338, 0);
            if (D.30339 != 0) goto <D.30340>; else goto <D.30341>;
            <D.30340>:
            monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "aot-runtime.c", 2969, "ji->data.method");
            <D.30341>:
            D.30336 = ji->data.method;
            D.30342 = D.30336->klass;
            mono_class_init (D.30342);
            <D.30317>:
            goto <D.26366>;
          }
        finally
          {
            ref = {CLOBBER};
          }
      }
      <D.26367>:
      <D.26368>:
      {
        guint32 len;

        p.195 = p;
        D.30343 = decode_value (p.195, &p);
        len = (guint32) D.30343;
        p.195 = p;
        ji->data.name = p.195;
        p.195 = p;
        D.30344 = len + 1;
        p.197 = p.195 + D.30344;
        p = p.197;
        goto <D.26366>;
      }
      <D.26370>:
      p.195 = p;
      D.30346 = decode_resolve_method_ref (aot_module, p.195, &p);
      ji->data.method = D.30346;
      D.30336 = ji->data.method;
      if (D.30336 == 0B) goto cleanup; else goto <D.30347>;
      <D.30347>:
      goto <D.26366>;
      <D.26371>:
      <D.26372>:
      <D.26373>:
      <D.26374>:
      p.195 = p;
      D.30348 = decode_klass_ref (aot_module, p.195, &p);
      ji->data.klass = D.30348;
      D.30349 = ji->data.klass;
      if (D.30349 == 0B) goto cleanup; else goto <D.30350>;
      <D.30350>:
      goto <D.26366>;
      <D.26375>:
      <D.26376>:
      p.195 = p;
      D.30351 = decode_klass_ref (aot_module, p.195, &p);
      ji->data.klass = D.30351;
      D.30349 = ji->data.klass;
      if (D.30349 == 0B) goto cleanup; else goto <D.30352>;
      <D.30352>:
      goto <D.26366>;
      <D.26377>:
      p.195 = p;
      D.30353 = decode_value (p.195, &p);
      D.30354 = load_image (aot_module, D.30353, 1);
      ji->data.image = D.30354;
      D.30355 = ji->data.image;
      if (D.30355 == 0B) goto cleanup; else goto <D.30356>;
      <D.30356>:
      goto <D.26366>;
      <D.26378>:
      <D.26379>:
      p.195 = p;
      D.30357 = decode_field_info (aot_module, p.195, &p);
      ji->data.field = D.30357;
      D.30358 = ji->data.field;
      if (D.30358 == 0B) goto cleanup; else goto <D.30359>;
      <D.30359>:
      goto <D.26366>;
      <D.26380>:
      D.30360 = mono_mempool_alloc0 (mp, 8);
      ji->data.table = D.30360;
      D.30361 = ji->data.table;
      p.195 = p;
      D.30362 = decode_value (p.195, &p);
      D.30361->table_size = D.30362;
      D.30363 = mono_domain_get ();
      D.30361 = ji->data.table;
      D.30364 = D.30361->table_size;
      D.30365 = (unsigned int) D.30364;
      D.30366 = D.30365 * 4;
      table = mono_domain_alloc (D.30363, D.30366);
      D.30361 = ji->data.table;
      D.30361->table = table;
      i = 0;
      goto <D.26382>;
      <D.26381>:
      i.198 = (unsigned int) i;
      D.30368 = i.198 * 4;
      D.30369 = table + D.30368;
      p.195 = p;
      D.30370 = decode_value (p.195, &p);
      D.30371 = (void *) D.30370;
      *D.30369 = D.30371;
      i = i + 1;
      <D.26382>:
      D.30361 = ji->data.table;
      D.30364 = D.30361->table_size;
      if (D.30364 > i) goto <D.26381>; else goto <D.26383>;
      <D.26383>:
      goto <D.26366>;
      <D.26384>:
      {
        guint32 val;

        try
          {
            D.30372 = mono_domain_get ();
            D.30373 = mono_domain_alloc0 (D.30372, 4);
            ji->data.target = D.30373;
            p.195 = p;
            D.30374 = decode_value (p.195, &p);
            val.199 = (unsigned int) D.30374;
            val = val.199;
            D.30376 = ji->data.target;
            val.200 = &val;
            D.30378 = MEM[(float *)val.200];
            MEM[(float *)D.30376] = D.30378;
            goto <D.26366>;
          }
        finally
          {
            val = {CLOBBER};
          }
      }
      <D.26386>:
      {
        guint32 val[2];
        guint64 v;

        try
          {
            D.30379 = mono_domain_get ();
            D.30380 = mono_domain_alloc0 (D.30379, 8);
            ji->data.target = D.30380;
            p.195 = p;
            D.30381 = decode_value (p.195, &p);
            D.30382 = (unsigned int) D.30381;
            val[0] = D.30382;
            p.195 = p;
            D.30383 = decode_value (p.195, &p);
            D.30384 = (unsigned int) D.30383;
            val[1] = D.30384;
            D.30385 = val[1];
            D.30386 = (long long unsigned int) D.30385;
            D.30387 = D.30386 << 32;
            D.30388 = val[0];
            D.30389 = (long long unsigned int) D.30388;
            v.201 = D.30387 | D.30389;
            v = v.201;
            D.30376 = ji->data.target;
            v.202 = &v;
            D.30392 = MEM[(double *)v.202];
            MEM[(double *)D.30376] = D.30392;
            goto <D.26366>;
          }
        finally
          {
            val = {CLOBBER};
            v = {CLOBBER};
          }
      }
      <D.26389>:
      p.195 = p;
      D.30393 = decode_value (p.195, &p);
      image = load_image (aot_module, D.30393, 1);
      if (image == 0B) goto cleanup; else goto <D.30394>;
      <D.30394>:
      p.195 = p;
      D.30395 = decode_value (p.195, &p);
      D.30396 = D.30395 + 1879048192;
      D.30397 = (unsigned int) D.30396;
      D.30398 = mono_jump_info_token_new (mp, image, D.30397);
      ji->data.token = D.30398;
      goto <D.26366>;
      <D.26390>:
      <D.26391>:
      <D.26392>:
      <D.26393>:
      p.195 = p;
      D.30399 = decode_value (p.195, &p);
      image = load_image (aot_module, D.30399, 1);
      if (image == 0B) goto cleanup; else goto <D.30400>;
      <D.30400>:
      p.195 = p;
      D.30401 = decode_value (p.195, &p);
      D.30402 = (unsigned int) D.30401;
      D.30403 = mono_jump_info_token_new (mp, image, D.30402);
      ji->data.token = D.30403;
      D.30404 = ji->data.token;
      p.195 = p;
      D.30405 = decode_value (p.195, &p);
      D.30404->has_context = D.30405;
      D.30404 = ji->data.token;
      D.30406 = D.30404->has_context;
      if (D.30406 != 0) goto <D.30407>; else goto <D.30408>;
      <D.30407>:
      {
        gboolean res;

        D.30404 = ji->data.token;
        D.30409 = &D.30404->context;
        p.195 = p;
        res = decode_generic_context (aot_module, D.30409, p.195, &p);
        if (res == 0) goto cleanup; else goto <D.30410>;
        <D.30410>:
      }
      <D.30408>:
      goto <D.26366>;
      <D.26395>:
      p.195 = p;
      D.30411 = decode_klass_ref (aot_module, p.195, &p);
      ji->data.klass = D.30411;
      D.30349 = ji->data.klass;
      if (D.30349 == 0B) goto cleanup; else goto <D.30412>;
      <D.30412>:
      D.30349 = ji->data.klass;
      D.30413 = D.30349->name;
      ji->data.name = D.30413;
      goto <D.26366>;
      <D.26396>:
      p.195 = p;
      D.30414 = decode_value (p.195, &p);
      ji->data.offset = D.30414;
      goto <D.26366>;
      <D.26397>:
      <D.26398>:
      <D.26399>:
      <D.26400>:
      <D.26401>:
      <D.26402>:
      <D.26403>:
      goto <D.26366>;
      <D.26404>:
      {
        gboolean res;
        struct MonoJumpInfoRgctxEntry * entry;
        guint32 offset;
        guint32 val;
        guint8 * p2;

        try
          {
            p.195 = p;
            D.30415 = decode_value (p.195, &p);
            offset = (guint32) D.30415;
            p.195 = p;
            D.30416 = decode_value (p.195, &p);
            val = (guint32) D.30416;
            entry = mono_mempool_alloc0 (mp, 16);
            D.30417 = aot_module->blob;
            p2.203 = D.30417 + offset;
            p2 = p2.203;
            p2.204 = p2;
            D.30420 = decode_resolve_method_ref (aot_module, p2.204, &p2);
            entry->method = D.30420;
            D.30421 = val & 1;
            D.30422 = D.30421 != 0;
            D.30423 = (int) D.30422;
            entry->in_mrgctx = D.30423;
            D.30424 = val >> 1;
            D.30425 = D.30424 & 255;
            entry->info_type = D.30425;
            D.30426 = mono_mempool_alloc0 (mp, 20);
            entry->data = D.30426;
            D.30427 = entry->data;
            D.30428 = val >> 9;
            D.30429 = D.30428 & 255;
            D.30427->type = D.30429;
            D.30427 = entry->data;
            p.195 = p;
            res = decode_patch (aot_module, mp, D.30427, p.195, &p);
            if (res == 0) goto cleanup; else goto <D.30430>;
            <D.30430>:
            ji->data.rgctx_entry = entry;
            goto <D.26366>;
          }
        finally
          {
            p2 = {CLOBBER};
          }
      }
      <D.26410>:
      goto <D.26366>;
      <D.26411>:
      {
        struct MonoJumpInfoImtTramp * imt_tramp;

        imt_tramp = mono_mempool_alloc0 (mp, 8);
        p.195 = p;
        D.30431 = decode_resolve_method_ref (aot_module, p.195, &p);
        imt_tramp->method = D.30431;
        p.195 = p;
        D.30432 = decode_value (p.195, &p);
        imt_tramp->vt_offset = D.30432;
        ji->data.imt_tramp = imt_tramp;
        goto <D.26366>;
      }
      <D.26413>:
      p.195 = p;
      D.30433 = decode_signature (aot_module, p.195, &p);
      ji->data.target = D.30433;
      goto <D.26366>;
      <D.26414>:
      p.195 = p;
      D.30434 = decode_value (p.195, &p);
      D.30435 = (const void *) D.30434;
      ji->data.target = D.30435;
      goto <D.26366>;
      <D.26415>:
      {
        struct MonoJumpInfoGSharedVtCall * info;

        info = monoeg_malloc0 (8);
        p.195 = p;
        D.30436 = decode_signature (aot_module, p.195, &p);
        info->sig = D.30436;
        D.30437 = info->sig;
        D.30438 = D.30437 == 0B;
        D.30439 = (long int) D.30438;
        D.30440 = __builtin_expect (D.30439, 0);
        if (D.30440 != 0) goto <D.30441>; else goto <D.30442>;
        <D.30441>:
        monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "aot-runtime.c", 3126, "info->sig");
        <D.30442>:
        p.195 = p;
        D.30443 = decode_resolve_method_ref (aot_module, p.195, &p);
        info->method = D.30443;
        D.30444 = info->method;
        D.30445 = D.30444 == 0B;
        D.30446 = (long int) D.30445;
        D.30447 = __builtin_expect (D.30446, 0);
        if (D.30447 != 0) goto <D.30448>; else goto <D.30449>;
        <D.30448>:
        monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "aot-runtime.c", 3128, "info->method");
        <D.30449>:
        ji->data.target = info;
        goto <D.26366>;
      }
      <D.26417>:
      {
        struct MonoGSharedVtMethodInfo * info;
        int i;
        int nentries;

        info = monoeg_malloc0 (8);
        p.195 = p;
        D.30450 = decode_resolve_method_ref (aot_module, p.195, &p);
        info->method = D.30450;
        D.30451 = info->method;
        D.30452 = D.30451 == 0B;
        D.30453 = (long int) D.30452;
        D.30454 = __builtin_expect (D.30453, 0);
        if (D.30454 != 0) goto <D.30455>; else goto <D.30456>;
        <D.30455>:
        monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "aot-runtime.c", 3138, "info->method");
        <D.30456>:
        p.195 = p;
        nentries = decode_value (p.195, &p);
        D.30457 = monoeg_g_ptr_array_new ();
        info->entries = D.30457;
        i = 0;
        goto <D.26428>;
        <D.26427>:
        {
          struct MonoRuntimeGenericContextInfoTemplate * template;

          template = monoeg_malloc0 (12);
          p.195 = p;
          D.30458 = decode_value (p.195, &p);
          D.30459 = (<unnamed type>) D.30458;
          template->info_type = D.30459;
          D.30460 = template->info_type;
          D.30461 = mini_rgctx_info_type_to_patch_info_type (D.30460);
          switch (D.30461) <default: <D.26426>, case 11: <D.26422>, case 13: <D.26425>>
          <D.26422>:
          {
            struct MonoClass * klass;

            p.195 = p;
            klass = decode_klass_ref (aot_module, p.195, &p);
            if (klass == 0B) goto cleanup; else goto <D.30462>;
            <D.30462>:
            D.30463 = &klass->byval_arg;
            template->data = D.30463;
            goto <D.26424>;
          }
          <D.26425>:
          p.195 = p;
          D.30464 = decode_field_info (aot_module, p.195, &p);
          template->data = D.30464;
          D.30465 = template->data;
          if (D.30465 == 0B) goto cleanup; else goto <D.30466>;
          <D.30466>:
          goto <D.26424>;
          <D.26426>:
          monoeg_assertion_message ("* Assertion: should not be reached at %s:%d\n", "aot-runtime.c", 3159);
          <D.26424>:
          D.30467 = info->entries;
          monoeg_g_ptr_array_add (D.30467, template);
        }
        i = i + 1;
        <D.26428>:
        if (i < nentries) goto <D.26427>; else goto <D.26429>;
        <D.26429>:
        ji->data.target = info;
        goto <D.26366>;
      }
      <D.26430>:
      D.30313 = ji->type;
      monoeg_g_log (0B, 16, "unhandled type %d", D.30313);
      monoeg_assertion_message ("* Assertion: should not be reached at %s:%d\n", "aot-runtime.c", 3170);
      <D.26366>:
      p.195 = p;
      *endbuf = p.195;
      D.30468 = 1;
      return D.30468;
      cleanup:
      D.30468 = 0;
      return D.30468;
    }
  finally
    {
      p = {CLOBBER};
    }
}


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

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


decode_field_info (struct MonoAotModule * module, guint8 * buf, guint8 * * endbuf)
{
  guint8 * buf.205;
  struct MonoClassField * D.30483;
  guint8 * p.206;
  int D.30485;
  int D.30486;
  struct MonoClass * klass;
  guint32 token;
  guint8 * p;

  try
    {
      buf.205 = buf;
      klass = decode_klass_ref (module, buf.205, &buf);
      buf.205 = buf;
      p = buf.205;
      if (klass == 0B) goto <D.30481>; else goto <D.30482>;
      <D.30481>:
      D.30483 = 0B;
      return D.30483;
      <D.30482>:
      p.206 = p;
      D.30485 = decode_value (p.206, &p);
      D.30486 = D.30485 + 67108864;
      token = (guint32) D.30486;
      p.206 = p;
      *endbuf = p.206;
      D.30483 = mono_class_get_field (klass, token);
      return D.30483;
    }
  finally
    {
      p = {CLOBBER};
    }
}


register_jump_target_got_slot (struct MonoDomain * domain, struct MonoMethod * method, void * * got_slot)
{
  union mono_mutex_t * D.30489;
  _Bool D.30492;
  long int D.30493;
  long int D.30494;
  struct GHashTable * D.30497;
  struct GHashTable * D.30500;
  _Bool D.30503;
  long int D.30504;
  long int D.30505;
  struct MonoJitDomainInfo * info;
  struct GSList * list;

  info = domain->runtime_info;
  {
    int ret;

    D.30489 = &domain->lock.mutex;
    ret = pthread_mutex_lock (D.30489);
    if (ret != 0) goto <D.30490>; else goto <D.30491>;
    <D.30490>:
    monoeg_g_log (0B, 16, "Bad call to mono_mutex_lock result %d", ret);
    <D.30491>:
    D.30492 = ret != 0;
    D.30493 = (long int) D.30492;
    D.30494 = __builtin_expect (D.30493, 0);
    if (D.30494 != 0) goto <D.30495>; else goto <D.30496>;
    <D.30495>:
    monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "aot-runtime.c", 3242, "ret == 0");
    <D.30496>:
  }
  D.30497 = info->jump_target_got_slot_hash;
  if (D.30497 == 0B) goto <D.30498>; else goto <D.30499>;
  <D.30498>:
  D.30500 = monoeg_g_hash_table_new (0B, 0B);
  info->jump_target_got_slot_hash = D.30500;
  <D.30499>:
  D.30497 = info->jump_target_got_slot_hash;
  list = monoeg_g_hash_table_lookup (D.30497, method);
  list = monoeg_g_slist_prepend (list, got_slot);
  D.30497 = info->jump_target_got_slot_hash;
  monoeg_g_hash_table_insert_replace (D.30497, method, list, 0);
  {
    int ret;

    D.30489 = &domain->lock.mutex;
    ret = pthread_mutex_unlock (D.30489);
    if (ret != 0) goto <D.30501>; else goto <D.30502>;
    <D.30501>:
    monoeg_g_log (0B, 16, "Bad call to mono_mutex_unlock result %d", ret);
    <D.30502>:
    D.30503 = ret != 0;
    D.30504 = (long int) D.30503;
    D.30505 = __builtin_expect (D.30504, 0);
    if (D.30505 != 0) goto <D.30506>; else goto <D.30507>;
    <D.30506>:
    monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "aot-runtime.c", 3248, "ret == 0");
    <D.30507>:
  }
}


InterlockedIncrement (volatile gint32 * val)
{
  gint32 D.30508;
  unsigned int D.30509;

  D.30509 = __sync_add_and_fetch_4 (val, 1);
  D.30508 = (gint32) D.30509;
  return D.30508;
}


init_plt (struct MonoAotModule * amodule)
{
  int D.30511;
  struct MonoDomain * D.30514;
  struct MonoDomain * D.30515;
  void * * D.30516;
  unsigned int D.30517;
  unsigned int i.207;
  unsigned int D.30519;
  unsigned int D.30520;
  void * * D.30521;
  unsigned int D.30522;
  int i;
  void * tramp;

  D.30511 = amodule->plt_inited;
  if (D.30511 != 0) goto <D.30512>; else goto <D.30513>;
  <D.30512>:
  return;
  <D.30513>:
  D.30514 = mono_get_root_domain ();
  tramp = mono_create_specific_trampoline (amodule, 6, D.30514, 0B);
  D.30515 = mono_domain_get ();
  tramp = mono_create_ftnptr (D.30515, tramp);
  i = 1;
  goto <D.26742>;
  <D.26741>:
  D.30516 = amodule->got;
  D.30517 = amodule->info.plt_got_offset_base;
  i.207 = (unsigned int) i;
  D.30519 = D.30517 + i.207;
  D.30520 = D.30519 * 4;
  D.30521 = D.30516 + D.30520;
  *D.30521 = tramp;
  i = i + 1;
  <D.26742>:
  i.207 = (unsigned int) i;
  D.30522 = amodule->info.plt_size;
  if (i.207 < D.30522) goto <D.26741>; else goto <D.26743>;
  <D.26743>:
  amodule->plt_inited = 1;
}


mono_aot_get_method_from_token (struct MonoDomain * domain, struct MonoImage * image, guint32 token)
{
  void * D.30526;
  unsigned int D.30527;
  unsigned int D.30528;
  struct MonoAotModule * aot_module;
  int method_index;

  aot_module = image->aot_module;
  if (aot_module == 0B) goto <D.30524>; else goto <D.30525>;
  <D.30524>:
  D.30526 = 0B;
  return D.30526;
  <D.30525>:
  D.30527 = token & 16777215;
  D.30528 = D.30527 + 4294967295;
  method_index = (int) D.30528;
  D.30526 = load_method (domain, aot_module, image, 0B, token, method_index);
  return D.30526;
}


mono_aot_is_got_entry (guint8 * code, guint8 * addr)
{
  struct GHashTable * aot_modules.208;
  gboolean D.30533;
  _Bool D.30536;
  long int D.30537;
  long int D.30538;
  _Bool D.30543;
  long int D.30544;
  long int D.30545;
  struct IsGotEntryUserData user_data;

  try
    {
      aot_modules.208 = aot_modules;
      if (aot_modules.208 == 0B) goto <D.30531>; else goto <D.30532>;
      <D.30531>:
      D.30533 = 0;
      return D.30533;
      <D.30532>:
      user_data.addr = addr;
      user_data.res = 0;
      {
        int ret;

        ret = pthread_mutex_lock (&aot_mutex.mutex);
        if (ret != 0) goto <D.30534>; else goto <D.30535>;
        <D.30534>:
        monoeg_g_log (0B, 16, "Bad call to mono_mutex_lock result %d", ret);
        <D.30535>:
        D.30536 = ret != 0;
        D.30537 = (long int) D.30536;
        D.30538 = __builtin_expect (D.30537, 0);
        if (D.30538 != 0) goto <D.30539>; else goto <D.30540>;
        <D.30539>:
        monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "aot-runtime.c", 3812, "ret == 0");
        <D.30540>:
      }
      aot_modules.208 = aot_modules;
      monoeg_g_hash_table_foreach (aot_modules.208, check_is_got_entry, &user_data);
      {
        int ret;

        ret = pthread_mutex_unlock (&aot_mutex.mutex);
        if (ret != 0) goto <D.30541>; else goto <D.30542>;
        <D.30541>:
        monoeg_g_log (0B, 16, "Bad call to mono_mutex_unlock result %d", ret);
        <D.30542>:
        D.30543 = ret != 0;
        D.30544 = (long int) D.30543;
        D.30545 = __builtin_expect (D.30544, 0);
        if (D.30545 != 0) goto <D.30546>; else goto <D.30547>;
        <D.30546>:
        monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "aot-runtime.c", 3814, "ret == 0");
        <D.30547>:
      }
      D.30533 = user_data.res;
      return D.30533;
    }
  finally
    {
      user_data = {CLOBBER};
    }
}


check_is_got_entry (void * key, void * value, void * user_data)
{
  void * * D.30550;
  guint8 * D.30553;
  unsigned int D.30556;
  unsigned int D.30557;
  guint8 * D.30558;
  struct IsGotEntryUserData * data;
  struct MonoAotModule * aot_module;

  data = user_data;
  aot_module = value;
  D.30550 = aot_module->got;
  if (D.30550 != 0B) goto <D.30551>; else goto <D.30552>;
  <D.30551>:
  D.30553 = data->addr;
  D.30550 = aot_module->got;
  if (D.30553 >= D.30550) goto <D.30554>; else goto <D.30555>;
  <D.30554>:
  D.30553 = data->addr;
  D.30550 = aot_module->got;
  D.30556 = aot_module->info.got_size;
  D.30557 = D.30556 * 4;
  D.30558 = D.30550 + D.30557;
  if (D.30553 < D.30558) goto <D.30559>; else goto <D.30560>;
  <D.30559>:
  data->res = 1;
  <D.30560>:
  <D.30555>:
  <D.30552>:
}


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

  D.30561 = mono_domain_get ();
  D.30562 = mono_get_root_domain ();
  if (D.30561 == D.30562) goto <D.30563>; else goto <D.30564>;
  <D.30563>:
  mono_arch_patch_plt_entry (code, got, regs, addr);
  <D.30564>:
}


mono_aot_plt_resolve (void * aot_module, guint32 plt_info_offset, guint8 * code)
{
  guint8 * D.30565;
  guint8 * p.209;
  guint8 * p.210;
  int D.30568;
  <unnamed type> D.30569;
  void * D.30572;
  int mono_aot_only.211;
  <unnamed type> D.30577;
  struct MonoMethod * D.30579;
  unsigned char D.30580;
  unsigned char D.30581;
  int D.30583;
  short unsigned int D.30585;
  int D.30586;
  int D.30587;
  int D.30589;
  struct MonoDomain * D.30592;
  <unnamed type> D.30593;
  _Bool D.30594;
  _Bool D.30595;
  _Bool D.30596;
  struct MonoDomain * D.30610;
  _Bool D.30611;
  long int D.30612;
  long int D.30613;
  void * * D.30616;
  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.30565 = module->blob;
      p.209 = D.30565 + plt_info_offset;
      p = p.209;
      p.210 = p;
      D.30568 = decode_value (p.210, &p);
      D.30569 = (<unnamed type>) D.30568;
      ji.type = D.30569;
      mp = mono_mempool_new_size (512);
      p.210 = p;
      res = decode_patch (module, mp, &ji, p.210, &p);
      if (res == 0) goto <D.30570>; else goto <D.30571>;
      <D.30570>:
      mono_mempool_destroy (mp);
      D.30572 = 0B;
      return D.30572;
      <D.30571>:
      using_gsharedvt = 1;
      mono_aot_only.211 = mono_aot_only;
      if (mono_aot_only.211 != 0) goto <D.30576>; else goto <D.30573>;
      <D.30576>:
      D.30577 = ji.type;
      if (D.30577 == 3) goto <D.30578>; else goto <D.30573>;
      <D.30578>:
      D.30579 = ji.data.method;
      D.30580 = BIT_FIELD_REF <*D.30579, 8, 168>;
      D.30581 = D.30580 & 8;
      if (D.30581 == 0) goto <D.30582>; else goto <D.30573>;
      <D.30582>:
      D.30579 = ji.data.method;
      D.30583 = mono_method_check_context_used (D.30579);
      if (D.30583 == 0) goto <D.30584>; else goto <D.30573>;
      <D.30584>:
      D.30579 = ji.data.method;
      D.30585 = D.30579->iflags;
      D.30586 = (int) D.30585;
      D.30587 = D.30586 & 32;
      if (D.30587 == 0) goto <D.30588>; else goto <D.30573>;
      <D.30588>:
      D.30579 = ji.data.method;
      D.30589 = mono_method_needs_static_rgctx_invoke (D.30579, 0);
      if (D.30589 == 0) goto <D.30590>; else goto <D.30573>;
      <D.30590>:
      if (using_gsharedvt == 0) goto <D.30591>; else goto <D.30573>;
      <D.30591>:
      D.30579 = ji.data.method;
      target = mono_jit_compile_method (D.30579);
      no_ftnptr = 1;
      goto <D.30574>;
      <D.30573>:
      D.30592 = mono_domain_get ();
      target = mono_resolve_patch_target (0B, D.30592, 0B, &ji, 1);
      <D.30574>:
      D.30593 = ji.type;
      D.30594 = D.30593 == 1;
      D.30595 = D.30593 == 7;
      D.30596 = D.30594 | D.30595;
      if (D.30596 != 0) goto <D.30597>; else goto <D.30598>;
      <D.30598>:
      D.30577 = ji.type;
      if (D.30577 == 15) goto <D.30599>; else goto <D.30600>;
      <D.30600>:
      D.30577 = ji.type;
      if (D.30577 == 31) goto <D.30601>; else goto <D.30602>;
      <D.30602>:
      D.30577 = ji.type;
      if (D.30577 == 32) goto <D.30603>; else goto <D.30604>;
      <D.30604>:
      D.30577 = ji.type;
      if (D.30577 == 35) goto <D.30605>; else goto <D.30606>;
      <D.30605>:
      goto <D.30607>;
      <D.30606>:
      if (no_ftnptr == 0) goto <D.30608>; else goto <D.30609>;
      <D.30608>:
      D.30610 = mono_domain_get ();
      target = mono_create_ftnptr (D.30610, target);
      <D.30609>:
      <D.30607>:
      <D.30603>:
      <D.30601>:
      <D.30599>:
      <D.30597>:
      mono_mempool_destroy (mp);
      plt_entry = mono_aot_get_plt_entry (code);
      D.30611 = plt_entry == 0B;
      D.30612 = (long int) D.30611;
      D.30613 = __builtin_expect (D.30612, 0);
      if (D.30613 != 0) goto <D.30614>; else goto <D.30615>;
      <D.30614>:
      monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "aot-runtime.c", 3944, "plt_entry");
      <D.30615>:
      D.30616 = module->got;
      mono_aot_patch_plt_entry (plt_entry, D.30616, 0B, target);
      D.30572 = target;
      return D.30572;
    }
  finally
    {
      p = {CLOBBER};
      ji = {CLOBBER};
    }
}


mono_aot_get_plt_entry (guint8 * code)
{
  guint8 * D.30621;
  guint8 * D.30622;
  guint8 * D.30628;
  guint8 * D.30630;
  struct MonoAotModule * amodule;
  guint8 * target;

  amodule = find_aot_module (code);
  target = 0B;
  if (amodule == 0B) goto <D.30619>; else goto <D.30620>;
  <D.30619>:
  D.30621 = 0B;
  return D.30621;
  <D.30620>:
  D.30622 = amodule->thumb_end;
  if (D.30622 != 0B) goto <D.30623>; else goto <D.30624>;
  <D.30623>:
  D.30622 = amodule->thumb_end;
  if (D.30622 > code) goto <D.30625>; else goto <D.30626>;
  <D.30625>:
  D.30621 = mono_arm_get_thumb_plt_entry (code);
  return D.30621;
  <D.30626>:
  <D.30624>:
  target = mono_arch_get_call_target (code);
  D.30628 = amodule->plt;
  if (D.30628 <= target) goto <D.30629>; else goto <D.30627>;
  <D.30629>:
  D.30630 = amodule->plt_end;
  if (D.30630 > target) goto <D.30631>; else goto <D.30627>;
  <D.30631>:
  D.30621 = target;
  return D.30621;
  <D.30627>:
  D.30621 = 0B;
  return D.30621;
}


find_aot_module (guint8 * code)
{
  struct GHashTable * aot_modules.212;
  struct MonoAotModule * D.30636;
  unsigned int code.213;
  unsigned int aot_code_low_addr.214;
  unsigned int aot_code_high_addr.215;
  _Bool D.30645;
  long int D.30646;
  long int D.30647;
  _Bool D.30652;
  long int D.30653;
  long int D.30654;
  struct FindAotModuleUserData user_data;

  try
    {
      aot_modules.212 = aot_modules;
      if (aot_modules.212 == 0B) goto <D.30634>; else goto <D.30635>;
      <D.30634>:
      D.30636 = 0B;
      return D.30636;
      <D.30635>:
      code.213 = (unsigned int) code;
      aot_code_low_addr.214 = aot_code_low_addr;
      if (code.213 < aot_code_low_addr.214) goto <D.30637>; else goto <D.30641>;
      <D.30641>:
      code.213 = (unsigned int) code;
      aot_code_high_addr.215 = aot_code_high_addr;
      if (code.213 > aot_code_high_addr.215) goto <D.30637>; else goto <D.30638>;
      <D.30637>:
      D.30636 = 0B;
      return D.30636;
      <D.30638>:
      user_data.addr = code;
      user_data.module = 0B;
      {
        int ret;

        ret = pthread_mutex_lock (&aot_mutex.mutex);
        if (ret != 0) goto <D.30643>; else goto <D.30644>;
        <D.30643>:
        monoeg_g_log (0B, 16, "Bad call to mono_mutex_lock result %d", ret);
        <D.30644>:
        D.30645 = ret != 0;
        D.30646 = (long int) D.30645;
        D.30647 = __builtin_expect (D.30646, 0);
        if (D.30647 != 0) goto <D.30648>; else goto <D.30649>;
        <D.30648>:
        monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "aot-runtime.c", 3849, "ret == 0");
        <D.30649>:
      }
      aot_modules.212 = aot_modules;
      monoeg_g_hash_table_foreach (aot_modules.212, find_aot_module_cb, &user_data);
      {
        int ret;

        ret = pthread_mutex_unlock (&aot_mutex.mutex);
        if (ret != 0) goto <D.30650>; else goto <D.30651>;
        <D.30650>:
        monoeg_g_log (0B, 16, "Bad call to mono_mutex_unlock result %d", ret);
        <D.30651>:
        D.30652 = ret != 0;
        D.30653 = (long int) D.30652;
        D.30654 = __builtin_expect (D.30653, 0);
        if (D.30654 != 0) goto <D.30655>; else goto <D.30656>;
        <D.30655>:
        monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "aot-runtime.c", 3851, "ret == 0");
        <D.30656>:
      }
      D.30636 = user_data.module;
      return D.30636;
    }
  finally
    {
      user_data = {CLOBBER};
    }
}


find_aot_module_cb (void * key, void * value, void * user_data)
{
  guint8 * D.30659;
  guint8 * D.30660;
  guint8 * D.30663;
  struct FindAotModuleUserData * data;
  struct MonoAotModule * aot_module;

  data = user_data;
  aot_module = value;
  D.30659 = data->addr;
  D.30660 = aot_module->code;
  if (D.30659 >= D.30660) goto <D.30661>; else goto <D.30662>;
  <D.30661>:
  D.30659 = data->addr;
  D.30663 = aot_module->code_end;
  if (D.30659 < D.30663) goto <D.30664>; else goto <D.30665>;
  <D.30664>:
  data->module = aot_module;
  <D.30665>:
  <D.30662>:
}


mono_aot_get_plt_info_offset (mgreg_t * regs, guint8 * code)
{
  _Bool D.30666;
  long int D.30667;
  long int D.30668;
  guint32 D.30671;
  guint8 * plt_entry;

  plt_entry = mono_aot_get_plt_entry (code);
  D.30666 = plt_entry == 0B;
  D.30667 = (long int) D.30666;
  D.30668 = __builtin_expect (D.30667, 0);
  if (D.30668 != 0) goto <D.30669>; else goto <D.30670>;
  <D.30669>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "aot-runtime.c", 4039, "plt_entry");
  <D.30670>:
  D.30671 = mono_arch_get_plt_info_offset (plt_entry, regs, code);
  return D.30671;
}


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

  aot_jit_icall_hash.216 = aot_jit_icall_hash;
  if (aot_jit_icall_hash.216 == 0B) goto <D.30674>; else goto <D.30675>;
  <D.30674>:
  aot_jit_icall_hash.217 = monoeg_g_hash_table_new (monoeg_g_str_hash, monoeg_g_str_equal);
  aot_jit_icall_hash = aot_jit_icall_hash.217;
  <D.30675>:
  aot_jit_icall_hash.216 = aot_jit_icall_hash;
  monoeg_g_hash_table_insert_replace (aot_jit_icall_hash.216, name, addr, 0);
}


mono_aot_get_trampoline_full (const char * name, struct MonoTrampInfo * * out_tinfo)
{
  _Bool D.30677;
  long int D.30678;
  long int D.30679;
  _Bool D.30682;
  long int D.30683;
  long int D.30684;
  void * D.30687;
  void * D.30688;
  struct MonoImage * image;
  struct MonoAotModule * amodule;

  image = mono_defaults.corlib;
  D.30677 = image == 0B;
  D.30678 = (long int) D.30677;
  D.30679 = __builtin_expect (D.30678, 0);
  if (D.30679 != 0) goto <D.30680>; else goto <D.30681>;
  <D.30680>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "aot-runtime.c", 4242, "image");
  <D.30681>:
  amodule = image->aot_module;
  D.30682 = amodule == 0B;
  D.30683 = (long int) D.30682;
  D.30684 = __builtin_expect (D.30683, 0);
  if (D.30684 != 0) goto <D.30685>; else goto <D.30686>;
  <D.30685>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "aot-runtime.c", 4245, "amodule");
  <D.30686>:
  D.30688 = load_function_full (amodule, name, out_tinfo);
  D.30687 = mono_create_ftnptr_malloc (D.30688);
  return D.30687;
}


load_function_full (struct MonoAotModule * amodule, const char * name, struct MonoTrampInfo * * out_tinfo)
{
  struct MonoDl * D.30690;
  void * * D.30691;
  void * code.218;
  char * D.30695;
  guint8 * p.219;
  void * D.30699;
  guint8 * p.220;
  guint8 * D.30703;
  guint8 * uw_info.221;
  guint8 * uw_info.222;
  int D.30706;
  guint8 * D.30707;
  guint8 * p.223;
  _Bool D.30711;
  long int D.30712;
  long int D.30713;
  unsigned int pindex.224;
  unsigned int D.30717;
  void * * D.30718;
  guint32 * got_slots.225;
  unsigned int D.30720;
  guint32 * D.30721;
  unsigned int D.30722;
  unsigned int D.30723;
  void * * D.30724;
  void * D.30725;
  <unnamed type> D.30728;
  int D.26792;
  int iftmp.226;
  int D.26791;
  const char[18] * D.30734;
  unsigned char D.30735;
  int D.30736;
  unsigned char D.30737;
  int D.30738;
  _Bool D.30739;
  _Bool D.30740;
  _Bool D.30741;
  const unsigned char * D.30744;
  unsigned char D.30745;
  int D.30746;
  const unsigned char * D.30747;
  unsigned char D.30748;
  int D.30749;
  _Bool D.30750;
  _Bool D.30751;
  const unsigned char * D.30754;
  unsigned char D.30755;
  int D.30756;
  const unsigned char * D.30757;
  unsigned char D.30758;
  int D.30759;
  _Bool D.30760;
  _Bool D.30761;
  const unsigned char * D.30764;
  unsigned char D.30765;
  int D.30766;
  const unsigned char * D.30767;
  unsigned char D.30768;
  int D.30769;
  const char * D.30771;
  int D.26801;
  int iftmp.227;
  int D.26800;
  const char[42] * D.30778;
  unsigned char D.30779;
  int D.30780;
  unsigned char D.30781;
  int D.30782;
  _Bool D.30783;
  _Bool D.30784;
  _Bool D.30785;
  const unsigned char * D.30788;
  unsigned char D.30789;
  int D.30790;
  const unsigned char * D.30791;
  unsigned char D.30792;
  int D.30793;
  _Bool D.30794;
  _Bool D.30795;
  const unsigned char * D.30798;
  unsigned char D.30799;
  int D.30800;
  const unsigned char * D.30801;
  unsigned char D.30802;
  int D.30803;
  _Bool D.30804;
  _Bool D.30805;
  const unsigned char * D.30808;
  unsigned char D.30809;
  int D.30810;
  const unsigned char * D.30811;
  unsigned char D.30812;
  int D.30813;
  int D.26810;
  int iftmp.228;
  int D.26809;
  const char[26] * D.30821;
  unsigned char D.30822;
  int D.30823;
  unsigned char D.30824;
  int D.30825;
  _Bool D.30826;
  _Bool D.30827;
  _Bool D.30828;
  const unsigned char * D.30831;
  unsigned char D.30832;
  int D.30833;
  const unsigned char * D.30834;
  unsigned char D.30835;
  int D.30836;
  _Bool D.30837;
  _Bool D.30838;
  const unsigned char * D.30841;
  unsigned char D.30842;
  int D.30843;
  const unsigned char * D.30844;
  unsigned char D.30845;
  int D.30846;
  _Bool D.30847;
  _Bool D.30848;
  const unsigned char * D.30851;
  unsigned char D.30852;
  int D.30853;
  const unsigned char * D.30854;
  unsigned char D.30855;
  int D.30856;
  int D.26819;
  int iftmp.229;
  int D.26818;
  const char[21] * D.30864;
  unsigned char D.30865;
  int D.30866;
  unsigned char D.30867;
  int D.30868;
  _Bool D.30869;
  _Bool D.30870;
  _Bool D.30871;
  const unsigned char * D.30874;
  unsigned char D.30875;
  int D.30876;
  const unsigned char * D.30877;
  unsigned char D.30878;
  int D.30879;
  _Bool D.30880;
  _Bool D.30881;
  const unsigned char * D.30884;
  unsigned char D.30885;
  int D.30886;
  const unsigned char * D.30887;
  unsigned char D.30888;
  int D.30889;
  _Bool D.30890;
  _Bool D.30891;
  const unsigned char * D.30894;
  unsigned char D.30895;
  int D.30896;
  const unsigned char * D.30897;
  unsigned char D.30898;
  int D.30899;
  char * D.30904;
  const char * D.30907;
  <unnamed type> tramp_type2.230;
  char * D.30910;
  _Bool D.30913;
  long int D.30914;
  long int D.30915;
  unsigned int slot.231;
  void * slot.232;
  struct MonoDomain * D.30920;
  int D.26831;
  int iftmp.233;
  int D.26830;
  const char[34] * D.30925;
  unsigned char D.30926;
  int D.30927;
  unsigned char D.30928;
  int D.30929;
  _Bool D.30930;
  _Bool D.30931;
  _Bool D.30932;
  const unsigned char * D.30935;
  unsigned char D.30936;
  int D.30937;
  const unsigned char * D.30938;
  unsigned char D.30939;
  int D.30940;
  _Bool D.30941;
  _Bool D.30942;
  const unsigned char * D.30945;
  unsigned char D.30946;
  int D.30947;
  const unsigned char * D.30948;
  unsigned char D.30949;
  int D.30950;
  _Bool D.30951;
  _Bool D.30952;
  const unsigned char * D.30955;
  unsigned char D.30956;
  int D.30957;
  const unsigned char * D.30958;
  unsigned char D.30959;
  int D.30960;
  struct MonoDomain * D.30964;
  int D.26840;
  int iftmp.234;
  int D.26839;
  const char[33] * D.30969;
  unsigned char D.30970;
  int D.30971;
  unsigned char D.30972;
  int D.30973;
  _Bool D.30974;
  _Bool D.30975;
  _Bool D.30976;
  const unsigned char * D.30979;
  unsigned char D.30980;
  int D.30981;
  const unsigned char * D.30982;
  unsigned char D.30983;
  int D.30984;
  _Bool D.30985;
  _Bool D.30986;
  const unsigned char * D.30989;
  unsigned char D.30990;
  int D.30991;
  const unsigned char * D.30992;
  unsigned char D.30993;
  int D.30994;
  _Bool D.30995;
  _Bool D.30996;
  const unsigned char * D.30999;
  unsigned char D.31000;
  int D.31001;
  const unsigned char * D.31002;
  unsigned char D.31003;
  int D.31004;
  struct MonoDomain * D.31008;
  int D.26849;
  int iftmp.235;
  int D.26848;
  const char[39] * D.31013;
  unsigned char D.31014;
  int D.31015;
  unsigned char D.31016;
  int D.31017;
  _Bool D.31018;
  _Bool D.31019;
  _Bool D.31020;
  const unsigned char * D.31023;
  unsigned char D.31024;
  int D.31025;
  const unsigned char * D.31026;
  unsigned char D.31027;
  int D.31028;
  _Bool D.31029;
  _Bool D.31030;
  const unsigned char * D.31033;
  unsigned char D.31034;
  int D.31035;
  const unsigned char * D.31036;
  unsigned char D.31037;
  int D.31038;
  _Bool D.31039;
  _Bool D.31040;
  const unsigned char * D.31043;
  unsigned char D.31044;
  int D.31045;
  const unsigned char * D.31046;
  unsigned char D.31047;
  int D.31048;
  struct MonoDomain * D.31052;
  int D.26858;
  int iftmp.236;
  int D.26857;
  const char[44] * D.31057;
  unsigned char D.31058;
  int D.31059;
  unsigned char D.31060;
  int D.31061;
  _Bool D.31062;
  _Bool D.31063;
  _Bool D.31064;
  const unsigned char * D.31067;
  unsigned char D.31068;
  int D.31069;
  const unsigned char * D.31070;
  unsigned char D.31071;
  int D.31072;
  _Bool D.31073;
  _Bool D.31074;
  const unsigned char * D.31077;
  unsigned char D.31078;
  int D.31079;
  const unsigned char * D.31080;
  unsigned char D.31081;
  int D.31082;
  _Bool D.31083;
  _Bool D.31084;
  const unsigned char * D.31087;
  unsigned char D.31088;
  int D.31089;
  const unsigned char * D.31090;
  unsigned char D.31091;
  int D.31092;
  char * D.31097;
  struct GHashTable * aot_jit_icall_hash.237;
  void * D.31105;
  struct _IO_FILE * stderr.238;
  _Bool D.31109;
  long int D.31110;
  long int D.31111;
  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.30690 = amodule->sofile;
      D.30691 = amodule->globals;
      find_symbol (D.30690, D.30691, symbol, &code);
      monoeg_g_free (symbol);
      code.218 = code;
      if (code.218 == 0B) goto <D.30693>; else goto <D.30694>;
      <D.30693>:
      D.30695 = amodule->aot_name;
      monoeg_g_log (0B, 4, "Symbol \'%s\' not found in AOT file \'%s\'.\n", name, D.30695);
      <D.26773>:
      goto <D.26773>;
      <D.30694>:
      D.30695 = amodule->aot_name;
      mono_trace (128, 32, "AOT FOUND function \'%s\' in AOT file \'%s\'.", name, D.30695);
      symbol = monoeg_g_strdup_printf ("%s_p", name);
      D.30690 = amodule->sofile;
      D.30691 = amodule->globals;
      find_symbol (D.30690, D.30691, symbol, &p);
      monoeg_g_free (symbol);
      p.219 = p;
      if (p.219 == 0B) goto <D.30697>; else goto <D.30698>;
      <D.30697>:
      D.30699 = code;
      return D.30699;
      <D.30698>:
      p.219 = p;
      info_offset = MEM[(guint32 *)p.219];
      if (out_tinfo != 0B) goto <D.30700>; else goto <D.30701>;
      <D.30700>:
      {
        struct MonoTrampInfo * tinfo;
        guint32 code_size;
        guint32 uw_info_len;
        guint32 uw_offset;
        guint8 * uw_info;

        try
          {
            p.219 = p;
            p.220 = p.219 + 4;
            p = p.220;
            p.219 = p;
            code_size = MEM[(guint32 *)p.219];
            p.219 = p;
            p.220 = p.219 + 4;
            p = p.220;
            p.219 = p;
            uw_offset = MEM[(guint32 *)p.219];
            D.30703 = amodule->unwind_info;
            uw_info.221 = D.30703 + uw_offset;
            uw_info = uw_info.221;
            uw_info.222 = uw_info;
            D.30706 = decode_value (uw_info.222, &uw_info);
            uw_info_len = (guint32) D.30706;
            tinfo = monoeg_malloc0 (28);
            code.218 = code;
            tinfo->code = code.218;
            tinfo->code_size = code_size;
            uw_info.222 = uw_info;
            tinfo->uw_info = uw_info.222;
            tinfo->uw_info_len = uw_info_len;
            *out_tinfo = tinfo;
          }
        finally
          {
            uw_info = {CLOBBER};
          }
      }
      <D.30701>:
      D.30707 = amodule->blob;
      p.223 = D.30707 + info_offset;
      p = p.223;
      p.219 = p;
      n_patches = decode_value (p.219, &p);
      if (n_patches != 0) goto <D.30709>; else goto <D.30710>;
      <D.30709>:
      {
        struct MonoJumpInfo * patches;
        guint32 * got_slots;

        try
          {
            mp = mono_mempool_new ();
            p.219 = p;
            patches = load_patch_info (amodule, mp, n_patches, &got_slots, p.219, &p);
            D.30711 = patches == 0B;
            D.30712 = (long int) D.30711;
            D.30713 = __builtin_expect (D.30712, 0);
            if (D.30713 != 0) goto <D.30714>; else goto <D.30715>;
            <D.30714>:
            monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "aot-runtime.c", 4151, "patches");
            <D.30715>:
            pindex = 0;
            goto <D.26860>;
            <D.26859>:
            {
              struct MonoJumpInfo * ji;
              void * target;

              pindex.224 = (unsigned int) pindex;
              D.30717 = pindex.224 * 20;
              ji = patches + D.30717;
              D.30718 = amodule->got;
              got_slots.225 = got_slots;
              pindex.224 = (unsigned int) pindex;
              D.30720 = pindex.224 * 4;
              D.30721 = got_slots.225 + D.30720;
              D.30722 = *D.30721;
              D.30723 = D.30722 * 4;
              D.30724 = D.30718 + D.30723;
              D.30725 = *D.30724;
              if (D.30725 != 0B) goto <D.30726>; else goto <D.30727>;
              <D.30726>:
              // predicted unlikely by continue predictor.
              goto <D.26783>;
              <D.30727>:
              D.30728 = ji->type;
              if (D.30728 == 32) goto <D.30729>; else goto <D.30730>;
              <D.30729>:
              {
                size_t __s1_len;
                size_t __s2_len;

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

                  __s2 = ji->data.name;
                  D.30734 = "mono_get_lmf_addr";
                  D.30735 = MEM[(const unsigned char *)D.30734];
                  D.30736 = (int) D.30735;
                  D.30737 = *__s2;
                  D.30738 = (int) D.30737;
                  __result = D.30736 - D.30738;
                  {
                    D.30739 = __s2_len != 0;
                    D.30740 = __result == 0;
                    D.30741 = D.30739 & D.30740;
                    if (D.30741 != 0) goto <D.30742>; else goto <D.30743>;
                    <D.30742>:
                    D.30744 = &MEM[(void *)"mono_get_lmf_addr" + 1B];
                    D.30745 = *D.30744;
                    D.30746 = (int) D.30745;
                    D.30747 = __s2 + 1;
                    D.30748 = *D.30747;
                    D.30749 = (int) D.30748;
                    __result = D.30746 - D.30749;
                    D.30750 = __s2_len > 1;
                    D.30740 = __result == 0;
                    D.30751 = D.30750 & D.30740;
                    if (D.30751 != 0) goto <D.30752>; else goto <D.30753>;
                    <D.30752>:
                    D.30754 = &MEM[(void *)"mono_get_lmf_addr" + 2B];
                    D.30755 = *D.30754;
                    D.30756 = (int) D.30755;
                    D.30757 = __s2 + 2;
                    D.30758 = *D.30757;
                    D.30759 = (int) D.30758;
                    __result = D.30756 - D.30759;
                    D.30760 = __s2_len > 2;
                    D.30740 = __result == 0;
                    D.30761 = D.30760 & D.30740;
                    if (D.30761 != 0) goto <D.30762>; else goto <D.30763>;
                    <D.30762>:
                    D.30764 = &MEM[(void *)"mono_get_lmf_addr" + 3B];
                    D.30765 = *D.30764;
                    D.30766 = (int) D.30765;
                    D.30767 = __s2 + 3;
                    D.30768 = *D.30767;
                    D.30769 = (int) D.30768;
                    __result = D.30766 - D.30769;
                    <D.30763>:
                    <D.30753>:
                    <D.30743>:
                  }
                  D.26791 = __result;
                }
                iftmp.226 = -D.26791;
                goto <D.30770>;
                <D.30733>:
                D.30771 = ji->data.name;
                iftmp.226 = __builtin_strcmp (D.30771, "mono_get_lmf_addr");
                <D.30770>:
                D.26792 = iftmp.226;
              }
              if (D.26792 == 0) goto <D.30772>; else goto <D.30773>;
              <D.30772>:
              target = mono_get_lmf_addr;
              goto <D.30774>;
              <D.30773>:
              {
                size_t __s1_len;
                size_t __s2_len;

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

                  __s2 = ji->data.name;
                  D.30778 = "mono_thread_force_interruption_checkpoint";
                  D.30779 = MEM[(const unsigned char *)D.30778];
                  D.30780 = (int) D.30779;
                  D.30781 = *__s2;
                  D.30782 = (int) D.30781;
                  __result = D.30780 - D.30782;
                  {
                    D.30783 = __s2_len != 0;
                    D.30784 = __result == 0;
                    D.30785 = D.30783 & D.30784;
                    if (D.30785 != 0) goto <D.30786>; else goto <D.30787>;
                    <D.30786>:
                    D.30788 = &MEM[(void *)"mono_thread_force_interruption_checkpoint" + 1B];
                    D.30789 = *D.30788;
                    D.30790 = (int) D.30789;
                    D.30791 = __s2 + 1;
                    D.30792 = *D.30791;
                    D.30793 = (int) D.30792;
                    __result = D.30790 - D.30793;
                    D.30794 = __s2_len > 1;
                    D.30784 = __result == 0;
                    D.30795 = D.30794 & D.30784;
                    if (D.30795 != 0) goto <D.30796>; else goto <D.30797>;
                    <D.30796>:
                    D.30798 = &MEM[(void *)"mono_thread_force_interruption_checkpoint" + 2B];
                    D.30799 = *D.30798;
                    D.30800 = (int) D.30799;
                    D.30801 = __s2 + 2;
                    D.30802 = *D.30801;
                    D.30803 = (int) D.30802;
                    __result = D.30800 - D.30803;
                    D.30804 = __s2_len > 2;
                    D.30784 = __result == 0;
                    D.30805 = D.30804 & D.30784;
                    if (D.30805 != 0) goto <D.30806>; else goto <D.30807>;
                    <D.30806>:
                    D.30808 = &MEM[(void *)"mono_thread_force_interruption_checkpoint" + 3B];
                    D.30809 = *D.30808;
                    D.30810 = (int) D.30809;
                    D.30811 = __s2 + 3;
                    D.30812 = *D.30811;
                    D.30813 = (int) D.30812;
                    __result = D.30810 - D.30813;
                    <D.30807>:
                    <D.30797>:
                    <D.30787>:
                  }
                  D.26800 = __result;
                }
                iftmp.227 = -D.26800;
                goto <D.30814>;
                <D.30777>:
                D.30771 = ji->data.name;
                iftmp.227 = __builtin_strcmp (D.30771, "mono_thread_force_interruption_checkpoint");
                <D.30814>:
                D.26801 = iftmp.227;
              }
              if (D.26801 == 0) goto <D.30815>; else goto <D.30816>;
              <D.30815>:
              target = mono_thread_force_interruption_checkpoint;
              goto <D.30817>;
              <D.30816>:
              {
                size_t __s1_len;
                size_t __s2_len;

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

                  __s2 = ji->data.name;
                  D.30821 = "mono_exception_from_token";
                  D.30822 = MEM[(const unsigned char *)D.30821];
                  D.30823 = (int) D.30822;
                  D.30824 = *__s2;
                  D.30825 = (int) D.30824;
                  __result = D.30823 - D.30825;
                  {
                    D.30826 = __s2_len != 0;
                    D.30827 = __result == 0;
                    D.30828 = D.30826 & D.30827;
                    if (D.30828 != 0) goto <D.30829>; else goto <D.30830>;
                    <D.30829>:
                    D.30831 = &MEM[(void *)"mono_exception_from_token" + 1B];
                    D.30832 = *D.30831;
                    D.30833 = (int) D.30832;
                    D.30834 = __s2 + 1;
                    D.30835 = *D.30834;
                    D.30836 = (int) D.30835;
                    __result = D.30833 - D.30836;
                    D.30837 = __s2_len > 1;
                    D.30827 = __result == 0;
                    D.30838 = D.30837 & D.30827;
                    if (D.30838 != 0) goto <D.30839>; else goto <D.30840>;
                    <D.30839>:
                    D.30841 = &MEM[(void *)"mono_exception_from_token" + 2B];
                    D.30842 = *D.30841;
                    D.30843 = (int) D.30842;
                    D.30844 = __s2 + 2;
                    D.30845 = *D.30844;
                    D.30846 = (int) D.30845;
                    __result = D.30843 - D.30846;
                    D.30847 = __s2_len > 2;
                    D.30827 = __result == 0;
                    D.30848 = D.30847 & D.30827;
                    if (D.30848 != 0) goto <D.30849>; else goto <D.30850>;
                    <D.30849>:
                    D.30851 = &MEM[(void *)"mono_exception_from_token" + 3B];
                    D.30852 = *D.30851;
                    D.30853 = (int) D.30852;
                    D.30854 = __s2 + 3;
                    D.30855 = *D.30854;
                    D.30856 = (int) D.30855;
                    __result = D.30853 - D.30856;
                    <D.30850>:
                    <D.30840>:
                    <D.30830>:
                  }
                  D.26809 = __result;
                }
                iftmp.228 = -D.26809;
                goto <D.30857>;
                <D.30820>:
                D.30771 = ji->data.name;
                iftmp.228 = __builtin_strcmp (D.30771, "mono_exception_from_token");
                <D.30857>:
                D.26810 = iftmp.228;
              }
              if (D.26810 == 0) goto <D.30858>; else goto <D.30859>;
              <D.30858>:
              target = mono_exception_from_token;
              goto <D.30860>;
              <D.30859>:
              {
                size_t __s1_len;
                size_t __s2_len;

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

                  __s2 = ji->data.name;
                  D.30864 = "mono_throw_exception";
                  D.30865 = MEM[(const unsigned char *)D.30864];
                  D.30866 = (int) D.30865;
                  D.30867 = *__s2;
                  D.30868 = (int) D.30867;
                  __result = D.30866 - D.30868;
                  {
                    D.30869 = __s2_len != 0;
                    D.30870 = __result == 0;
                    D.30871 = D.30869 & D.30870;
                    if (D.30871 != 0) goto <D.30872>; else goto <D.30873>;
                    <D.30872>:
                    D.30874 = &MEM[(void *)"mono_throw_exception" + 1B];
                    D.30875 = *D.30874;
                    D.30876 = (int) D.30875;
                    D.30877 = __s2 + 1;
                    D.30878 = *D.30877;
                    D.30879 = (int) D.30878;
                    __result = D.30876 - D.30879;
                    D.30880 = __s2_len > 1;
                    D.30870 = __result == 0;
                    D.30881 = D.30880 & D.30870;
                    if (D.30881 != 0) goto <D.30882>; else goto <D.30883>;
                    <D.30882>:
                    D.30884 = &MEM[(void *)"mono_throw_exception" + 2B];
                    D.30885 = *D.30884;
                    D.30886 = (int) D.30885;
                    D.30887 = __s2 + 2;
                    D.30888 = *D.30887;
                    D.30889 = (int) D.30888;
                    __result = D.30886 - D.30889;
                    D.30890 = __s2_len > 2;
                    D.30870 = __result == 0;
                    D.30891 = D.30890 & D.30870;
                    if (D.30891 != 0) goto <D.30892>; else goto <D.30893>;
                    <D.30892>:
                    D.30894 = &MEM[(void *)"mono_throw_exception" + 3B];
                    D.30895 = *D.30894;
                    D.30896 = (int) D.30895;
                    D.30897 = __s2 + 3;
                    D.30898 = *D.30897;
                    D.30899 = (int) D.30898;
                    __result = D.30896 - D.30899;
                    <D.30893>:
                    <D.30883>:
                    <D.30873>:
                  }
                  D.26818 = __result;
                }
                iftmp.229 = -D.26818;
                goto <D.30900>;
                <D.30863>:
                D.30771 = ji->data.name;
                iftmp.229 = __builtin_strcmp (D.30771, "mono_throw_exception");
                <D.30900>:
                D.26819 = iftmp.229;
              }
              if (D.26819 == 0) goto <D.30901>; else goto <D.30902>;
              <D.30901>:
              target = mono_get_throw_exception ();
              goto <D.30903>;
              <D.30902>:
              D.30771 = ji->data.name;
              D.30904 = strstr (D.30771, "trampoline_func_");
              D.30771 = ji->data.name;
              if (D.30904 == D.30771) goto <D.30905>; else goto <D.30906>;
              <D.30905>:
              {
                int tramp_type2;

                D.30771 = ji->data.name;
                D.30907 = D.30771 + 16;
                tramp_type2 = atoi (D.30907);
                tramp_type2.230 = (<unnamed type>) tramp_type2;
                target = mono_get_trampoline_func (tramp_type2.230);
              }
              goto <D.30909>;
              <D.30906>:
              D.30771 = ji->data.name;
              D.30910 = strstr (D.30771, "specific_trampoline_lazy_fetch_");
              D.30771 = ji->data.name;
              if (D.30910 == D.30771) goto <D.30911>; else goto <D.30912>;
              <D.30911>:
              {
                guint32 slot;
                int res;

                try
                  {
                    D.30771 = ji->data.name;
                    res = sscanf (D.30771, "specific_trampoline_lazy_fetch_%u", &slot);
                    D.30913 = res != 1;
                    D.30914 = (long int) D.30913;
                    D.30915 = __builtin_expect (D.30914, 0);
                    if (D.30915 != 0) goto <D.30916>; else goto <D.30917>;
                    <D.30916>:
                    monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "aot-runtime.c", 4182, "res == 1");
                    <D.30917>:
                    slot.231 = slot;
                    slot.232 = (void *) slot.231;
                    D.30920 = mono_get_root_domain ();
                    target = mono_create_specific_trampoline (slot.232, 4, D.30920, 0B);
                    target = mono_create_ftnptr_malloc (target);
                  }
                finally
                  {
                    slot = {CLOBBER};
                  }
              }
              goto <D.30921>;
              <D.30912>:
              {
                size_t __s1_len;
                size_t __s2_len;

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

                  __s2 = ji->data.name;
                  D.30925 = "specific_trampoline_monitor_enter";
                  D.30926 = MEM[(const unsigned char *)D.30925];
                  D.30927 = (int) D.30926;
                  D.30928 = *__s2;
                  D.30929 = (int) D.30928;
                  __result = D.30927 - D.30929;
                  {
                    D.30930 = __s2_len != 0;
                    D.30931 = __result == 0;
                    D.30932 = D.30930 & D.30931;
                    if (D.30932 != 0) goto <D.30933>; else goto <D.30934>;
                    <D.30933>:
                    D.30935 = &MEM[(void *)"specific_trampoline_monitor_enter" + 1B];
                    D.30936 = *D.30935;
                    D.30937 = (int) D.30936;
                    D.30938 = __s2 + 1;
                    D.30939 = *D.30938;
                    D.30940 = (int) D.30939;
                    __result = D.30937 - D.30940;
                    D.30941 = __s2_len > 1;
                    D.30931 = __result == 0;
                    D.30942 = D.30941 & D.30931;
                    if (D.30942 != 0) goto <D.30943>; else goto <D.30944>;
                    <D.30943>:
                    D.30945 = &MEM[(void *)"specific_trampoline_monitor_enter" + 2B];
                    D.30946 = *D.30945;
                    D.30947 = (int) D.30946;
                    D.30948 = __s2 + 2;
                    D.30949 = *D.30948;
                    D.30950 = (int) D.30949;
                    __result = D.30947 - D.30950;
                    D.30951 = __s2_len > 2;
                    D.30931 = __result == 0;
                    D.30952 = D.30951 & D.30931;
                    if (D.30952 != 0) goto <D.30953>; else goto <D.30954>;
                    <D.30953>:
                    D.30955 = &MEM[(void *)"specific_trampoline_monitor_enter" + 3B];
                    D.30956 = *D.30955;
                    D.30957 = (int) D.30956;
                    D.30958 = __s2 + 3;
                    D.30959 = *D.30958;
                    D.30960 = (int) D.30959;
                    __result = D.30957 - D.30960;
                    <D.30954>:
                    <D.30944>:
                    <D.30934>:
                  }
                  D.26830 = __result;
                }
                iftmp.233 = -D.26830;
                goto <D.30961>;
                <D.30924>:
                D.30771 = ji->data.name;
                iftmp.233 = __builtin_strcmp (D.30771, "specific_trampoline_monitor_enter");
                <D.30961>:
                D.26831 = iftmp.233;
              }
              if (D.26831 == 0) goto <D.30962>; else goto <D.30963>;
              <D.30962>:
              D.30964 = mono_get_root_domain ();
              target = mono_create_specific_trampoline (0B, 10, D.30964, 0B);
              target = mono_create_ftnptr_malloc (target);
              goto <D.30965>;
              <D.30963>:
              {
                size_t __s1_len;
                size_t __s2_len;

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

                  __s2 = ji->data.name;
                  D.30969 = "specific_trampoline_monitor_exit";
                  D.30970 = MEM[(const unsigned char *)D.30969];
                  D.30971 = (int) D.30970;
                  D.30972 = *__s2;
                  D.30973 = (int) D.30972;
                  __result = D.30971 - D.30973;
                  {
                    D.30974 = __s2_len != 0;
                    D.30975 = __result == 0;
                    D.30976 = D.30974 & D.30975;
                    if (D.30976 != 0) goto <D.30977>; else goto <D.30978>;
                    <D.30977>:
                    D.30979 = &MEM[(void *)"specific_trampoline_monitor_exit" + 1B];
                    D.30980 = *D.30979;
                    D.30981 = (int) D.30980;
                    D.30982 = __s2 + 1;
                    D.30983 = *D.30982;
                    D.30984 = (int) D.30983;
                    __result = D.30981 - D.30984;
                    D.30985 = __s2_len > 1;
                    D.30975 = __result == 0;
                    D.30986 = D.30985 & D.30975;
                    if (D.30986 != 0) goto <D.30987>; else goto <D.30988>;
                    <D.30987>:
                    D.30989 = &MEM[(void *)"specific_trampoline_monitor_exit" + 2B];
                    D.30990 = *D.30989;
                    D.30991 = (int) D.30990;
                    D.30992 = __s2 + 2;
                    D.30993 = *D.30992;
                    D.30994 = (int) D.30993;
                    __result = D.30991 - D.30994;
                    D.30995 = __s2_len > 2;
                    D.30975 = __result == 0;
                    D.30996 = D.30995 & D.30975;
                    if (D.30996 != 0) goto <D.30997>; else goto <D.30998>;
                    <D.30997>:
                    D.30999 = &MEM[(void *)"specific_trampoline_monitor_exit" + 3B];
                    D.31000 = *D.30999;
                    D.31001 = (int) D.31000;
                    D.31002 = __s2 + 3;
                    D.31003 = *D.31002;
                    D.31004 = (int) D.31003;
                    __result = D.31001 - D.31004;
                    <D.30998>:
                    <D.30988>:
                    <D.30978>:
                  }
                  D.26839 = __result;
                }
                iftmp.234 = -D.26839;
                goto <D.31005>;
                <D.30968>:
                D.30771 = ji->data.name;
                iftmp.234 = __builtin_strcmp (D.30771, "specific_trampoline_monitor_exit");
                <D.31005>:
                D.26840 = iftmp.234;
              }
              if (D.26840 == 0) goto <D.31006>; else goto <D.31007>;
              <D.31006>:
              D.31008 = mono_get_root_domain ();
              target = mono_create_specific_trampoline (0B, 11, D.31008, 0B);
              target = mono_create_ftnptr_malloc (target);
              goto <D.31009>;
              <D.31007>:
              {
                size_t __s1_len;
                size_t __s2_len;

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

                  __s2 = ji->data.name;
                  D.31013 = "specific_trampoline_generic_class_init";
                  D.31014 = MEM[(const unsigned char *)D.31013];
                  D.31015 = (int) D.31014;
                  D.31016 = *__s2;
                  D.31017 = (int) D.31016;
                  __result = D.31015 - D.31017;
                  {
                    D.31018 = __s2_len != 0;
                    D.31019 = __result == 0;
                    D.31020 = D.31018 & D.31019;
                    if (D.31020 != 0) goto <D.31021>; else goto <D.31022>;
                    <D.31021>:
                    D.31023 = &MEM[(void *)"specific_trampoline_generic_class_init" + 1B];
                    D.31024 = *D.31023;
                    D.31025 = (int) D.31024;
                    D.31026 = __s2 + 1;
                    D.31027 = *D.31026;
                    D.31028 = (int) D.31027;
                    __result = D.31025 - D.31028;
                    D.31029 = __s2_len > 1;
                    D.31019 = __result == 0;
                    D.31030 = D.31029 & D.31019;
                    if (D.31030 != 0) goto <D.31031>; else goto <D.31032>;
                    <D.31031>:
                    D.31033 = &MEM[(void *)"specific_trampoline_generic_class_init" + 2B];
                    D.31034 = *D.31033;
                    D.31035 = (int) D.31034;
                    D.31036 = __s2 + 2;
                    D.31037 = *D.31036;
                    D.31038 = (int) D.31037;
                    __result = D.31035 - D.31038;
                    D.31039 = __s2_len > 2;
                    D.31019 = __result == 0;
                    D.31040 = D.31039 & D.31019;
                    if (D.31040 != 0) goto <D.31041>; else goto <D.31042>;
                    <D.31041>:
                    D.31043 = &MEM[(void *)"specific_trampoline_generic_class_init" + 3B];
                    D.31044 = *D.31043;
                    D.31045 = (int) D.31044;
                    D.31046 = __s2 + 3;
                    D.31047 = *D.31046;
                    D.31048 = (int) D.31047;
                    __result = D.31045 - D.31048;
                    <D.31042>:
                    <D.31032>:
                    <D.31022>:
                  }
                  D.26848 = __result;
                }
                iftmp.235 = -D.26848;
                goto <D.31049>;
                <D.31012>:
                D.30771 = ji->data.name;
                iftmp.235 = __builtin_strcmp (D.30771, "specific_trampoline_generic_class_init");
                <D.31049>:
                D.26849 = iftmp.235;
              }
              if (D.26849 == 0) goto <D.31050>; else goto <D.31051>;
              <D.31050>:
              D.31052 = mono_get_root_domain ();
              target = mono_create_specific_trampoline (0B, 3, D.31052, 0B);
              target = mono_create_ftnptr_malloc (target);
              goto <D.31053>;
              <D.31051>:
              {
                size_t __s1_len;
                size_t __s2_len;

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

                  __s2 = ji->data.name;
                  D.31057 = "mono_thread_get_and_clear_pending_exception";
                  D.31058 = MEM[(const unsigned char *)D.31057];
                  D.31059 = (int) D.31058;
                  D.31060 = *__s2;
                  D.31061 = (int) D.31060;
                  __result = D.31059 - D.31061;
                  {
                    D.31062 = __s2_len != 0;
                    D.31063 = __result == 0;
                    D.31064 = D.31062 & D.31063;
                    if (D.31064 != 0) goto <D.31065>; else goto <D.31066>;
                    <D.31065>:
                    D.31067 = &MEM[(void *)"mono_thread_get_and_clear_pending_exception" + 1B];
                    D.31068 = *D.31067;
                    D.31069 = (int) D.31068;
                    D.31070 = __s2 + 1;
                    D.31071 = *D.31070;
                    D.31072 = (int) D.31071;
                    __result = D.31069 - D.31072;
                    D.31073 = __s2_len > 1;
                    D.31063 = __result == 0;
                    D.31074 = D.31073 & D.31063;
                    if (D.31074 != 0) goto <D.31075>; else goto <D.31076>;
                    <D.31075>:
                    D.31077 = &MEM[(void *)"mono_thread_get_and_clear_pending_exception" + 2B];
                    D.31078 = *D.31077;
                    D.31079 = (int) D.31078;
                    D.31080 = __s2 + 2;
                    D.31081 = *D.31080;
                    D.31082 = (int) D.31081;
                    __result = D.31079 - D.31082;
                    D.31083 = __s2_len > 2;
                    D.31063 = __result == 0;
                    D.31084 = D.31083 & D.31063;
                    if (D.31084 != 0) goto <D.31085>; else goto <D.31086>;
                    <D.31085>:
                    D.31087 = &MEM[(void *)"mono_thread_get_and_clear_pending_exception" + 3B];
                    D.31088 = *D.31087;
                    D.31089 = (int) D.31088;
                    D.31090 = __s2 + 3;
                    D.31091 = *D.31090;
                    D.31092 = (int) D.31091;
                    __result = D.31089 - D.31092;
                    <D.31086>:
                    <D.31076>:
                    <D.31066>:
                  }
                  D.26857 = __result;
                }
                iftmp.236 = -D.26857;
                goto <D.31093>;
                <D.31056>:
                D.30771 = ji->data.name;
                iftmp.236 = __builtin_strcmp (D.30771, "mono_thread_get_and_clear_pending_exception");
                <D.31093>:
                D.26858 = iftmp.236;
              }
              if (D.26858 == 0) goto <D.31094>; else goto <D.31095>;
              <D.31094>:
              target = mono_thread_get_and_clear_pending_exception;
              goto <D.31096>;
              <D.31095>:
              D.30771 = ji->data.name;
              D.31097 = strstr (D.30771, "generic_trampoline_");
              if (D.31097 != 0B) goto <D.31098>; else goto <D.31099>;
              <D.31098>:
              D.30771 = ji->data.name;
              target = mono_aot_get_trampoline (D.30771);
              goto <D.31100>;
              <D.31099>:
              aot_jit_icall_hash.237 = aot_jit_icall_hash;
              if (aot_jit_icall_hash.237 != 0B) goto <D.31104>; else goto <D.31101>;
              <D.31104>:
              aot_jit_icall_hash.237 = aot_jit_icall_hash;
              D.30771 = ji->data.name;
              D.31105 = monoeg_g_hash_table_lookup (aot_jit_icall_hash.237, D.30771);
              if (D.31105 != 0B) goto <D.31106>; else goto <D.31101>;
              <D.31106>:
              aot_jit_icall_hash.237 = aot_jit_icall_hash;
              D.30771 = ji->data.name;
              target = monoeg_g_hash_table_lookup (aot_jit_icall_hash.237, D.30771);
              goto <D.31102>;
              <D.31101>:
              stderr.238 = stderr;
              D.30771 = ji->data.name;
              fprintf (stderr.238, "Unknown relocation \'%s\'\n", D.30771);
              monoeg_assertion_message ("* Assertion: should not be reached at %s:%d\n", "aot-runtime.c", 4203);
              target = 0B;
              <D.31102>:
              <D.31100>:
              <D.31096>:
              <D.31053>:
              <D.31009>:
              <D.30965>:
              <D.30921>:
              <D.30909>:
              <D.30903>:
              <D.30860>:
              <D.30817>:
              <D.30774>:
              goto <D.31108>;
              <D.30730>:
              code.218 = code;
              target = mono_resolve_patch_target (0B, 0B, code.218, ji, 0);
              D.31109 = target == 0B;
              D.31110 = (long int) D.31109;
              D.31111 = __builtin_expect (D.31110, 0);
              if (D.31111 != 0) goto <D.31112>; else goto <D.31113>;
              <D.31112>:
              monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "aot-runtime.c", 4211, "target");
              <D.31113>:
              <D.31108>:
              D.30718 = amodule->got;
              got_slots.225 = got_slots;
              pindex.224 = (unsigned int) pindex;
              D.30720 = pindex.224 * 4;
              D.30721 = got_slots.225 + D.30720;
              D.30722 = *D.30721;
              D.30723 = D.30722 * 4;
              D.30724 = D.30718 + D.30723;
              *D.30724 = target;
            }
            <D.26783>:
            pindex = pindex + 1;
            <D.26860>:
            if (pindex < n_patches) goto <D.26859>; else goto <D.26861>;
            <D.26861>:
            got_slots.225 = got_slots;
            monoeg_g_free (got_slots.225);
            mono_mempool_destroy (mp);
          }
        finally
          {
            got_slots = {CLOBBER};
          }
      }
      <D.30710>:
      D.30699 = code;
      return D.30699;
    }
  finally
    {
      p = {CLOBBER};
      code = {CLOBBER};
    }
}


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

  D.31116 = code;
  return D.31116;
}


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

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


mono_aot_create_specific_trampoline (struct MonoImage * image, void * arg1, MonoTrampolineType tramp_type, struct MonoDomain * domain, guint32 * code_len)
{
  int inited.239;
  _Bool D.31125;
  long int D.31126;
  long int D.31127;
  _Bool D.31134;
  long int D.31135;
  long int D.31136;
  unsigned int num_trampolines.240;
  unsigned int num_trampolines.241;
  void * D.31141;
  void * D.31144;
  _Bool D.31145;
  long int D.31146;
  long int D.31147;
  struct MonoAotModule * amodule.242;
  void * * D.31154;
  unsigned int got_offset.243;
  unsigned int D.31156;
  void * * D.31157;
  sizetype D.31158;
  sizetype D.31159;
  void * * D.31160;
  unsigned int tramp_size.244;
  void * D.31164;
  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.239 = inited;
      if (inited.239 == 0) goto <D.31121>; else goto <D.31122>;
      <D.31121>:
      {
        int ret;

        ret = pthread_mutex_lock (&aot_mutex.mutex);
        if (ret != 0) goto <D.31123>; else goto <D.31124>;
        <D.31123>:
        monoeg_g_log (0B, 16, "Bad call to mono_mutex_lock result %d", ret);
        <D.31124>:
        D.31125 = ret != 0;
        D.31126 = (long int) D.31125;
        D.31127 = __builtin_expect (D.31126, 0);
        if (D.31127 != 0) goto <D.31128>; else goto <D.31129>;
        <D.31128>:
        monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "aot-runtime.c", 4494, "ret == 0");
        <D.31129>:
      }
      inited.239 = inited;
      if (inited.239 == 0) goto <D.31130>; else goto <D.31131>;
      <D.31130>:
      mono_counters_register ("Specific trampolines", 256, &num_trampolines);
      inited = 1;
      <D.31131>:
      {
        int ret;

        ret = pthread_mutex_unlock (&aot_mutex.mutex);
        if (ret != 0) goto <D.31132>; else goto <D.31133>;
        <D.31132>:
        monoeg_g_log (0B, 16, "Bad call to mono_mutex_unlock result %d", ret);
        <D.31133>:
        D.31134 = ret != 0;
        D.31135 = (long int) D.31134;
        D.31136 = __builtin_expect (D.31135, 0);
        if (D.31136 != 0) goto <D.31137>; else goto <D.31138>;
        <D.31137>:
        monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "aot-runtime.c", 4501, "ret == 0");
        <D.31138>:
      }
      <D.31122>:
      num_trampolines.240 = num_trampolines;
      num_trampolines.241 = num_trampolines.240 + 1;
      num_trampolines = num_trampolines.241;
      D.31141 = generic_trampolines[tramp_type];
      if (D.31141 == 0B) goto <D.31142>; else goto <D.31143>;
      <D.31142>:
      {
        char * symbol;

        symbol = mono_get_generic_trampoline_name (tramp_type);
        D.31144 = mono_aot_get_trampoline (symbol);
        generic_trampolines[tramp_type] = D.31144;
        monoeg_g_free (symbol);
      }
      <D.31143>:
      tramp = generic_trampolines[tramp_type];
      D.31145 = tramp == 0B;
      D.31146 = (long int) D.31145;
      D.31147 = __builtin_expect (D.31146, 0);
      if (D.31147 != 0) goto <D.31148>; else goto <D.31149>;
      <D.31148>:
      monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "aot-runtime.c", 4515, "tramp");
      <D.31149>:
      if (0 != 0) goto <D.31150>; else goto <D.31151>;
      <D.31150>:
      code = get_new_specific_trampoline_from_page (tramp, arg1);
      tramp_size = 8;
      goto <D.31152>;
      <D.31151>:
      code = get_numerous_trampoline (0, 2, &amodule, &got_offset, &tramp_size);
      amodule.242 = amodule;
      D.31154 = amodule.242->got;
      got_offset.243 = got_offset;
      D.31156 = got_offset.243 * 4;
      D.31157 = D.31154 + D.31156;
      *D.31157 = tramp;
      amodule.242 = amodule;
      D.31154 = amodule.242->got;
      got_offset.243 = got_offset;
      D.31158 = got_offset.243 + 1;
      D.31159 = D.31158 * 4;
      D.31160 = D.31154 + D.31159;
      *D.31160 = arg1;
      <D.31152>:
      if (code_len != 0B) goto <D.31161>; else goto <D.31162>;
      <D.31161>:
      tramp_size.244 = tramp_size;
      *code_len = tramp_size.244;
      <D.31162>:
      D.31164 = code;
      return D.31164;
    }
  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.31167;
  long int D.31168;
  long int D.31169;
  _Bool D.31174;
  long int D.31175;
  long int D.31176;
  _Bool D.31179;
  long int D.31180;
  long int D.31181;
  unsigned int D.31184;
  unsigned int D.31185;
  char * D.31188;
  unsigned int D.31189;
  unsigned int D.31190;
  _Bool D.31193;
  long int D.31194;
  long int D.31195;
  unsigned int D.31198;
  int D.31199;
  unsigned int D.31200;
  unsigned int D.31201;
  unsigned int D.31202;
  unsigned int tramp_size.245;
  void * D.31206;
  guint8 * D.31207;
  int D.31208;
  sizetype D.31209;
  struct MonoAotModule * amodule;
  int index;
  int tramp_size;
  struct MonoImage * image;

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

    ret = pthread_mutex_lock (&aot_mutex.mutex);
    if (ret != 0) goto <D.31172>; else goto <D.31173>;
    <D.31172>:
    monoeg_g_log (0B, 16, "Bad call to mono_mutex_lock result %d", ret);
    <D.31173>:
    D.31174 = ret != 0;
    D.31175 = (long int) D.31174;
    D.31176 = __builtin_expect (D.31175, 0);
    if (D.31176 != 0) goto <D.31177>; else goto <D.31178>;
    <D.31177>:
    monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "aot-runtime.c", 4450, "ret == 0");
    <D.31178>:
  }
  amodule = image->aot_module;
  D.31179 = amodule == 0B;
  D.31180 = (long int) D.31179;
  D.31181 = __builtin_expect (D.31180, 0);
  if (D.31181 != 0) goto <D.31182>; else goto <D.31183>;
  <D.31182>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "aot-runtime.c", 4453, "amodule");
  <D.31183>:
  *out_amodule = amodule;
  D.31184 = amodule->trampoline_index[tramp_type];
  D.31185 = amodule->info.num_trampolines[tramp_type];
  if (D.31184 == D.31185) goto <D.31186>; else goto <D.31187>;
  <D.31186>:
  D.31188 = image->name;
  D.31185 = 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.31188, D.31185, "");
  <D.26914>:
  goto <D.26914>;
  <D.31187>:
  D.31184 = amodule->trampoline_index[tramp_type];
  D.31189 = D.31184;
  D.31190 = D.31189 + 1;
  amodule->trampoline_index[tramp_type] = D.31190;
  index = (int) D.31189;
  {
    int ret;

    ret = pthread_mutex_unlock (&aot_mutex.mutex);
    if (ret != 0) goto <D.31191>; else goto <D.31192>;
    <D.31191>:
    monoeg_g_log (0B, 16, "Bad call to mono_mutex_unlock result %d", ret);
    <D.31192>:
    D.31193 = ret != 0;
    D.31194 = (long int) D.31193;
    D.31195 = __builtin_expect (D.31194, 0);
    if (D.31195 != 0) goto <D.31196>; else goto <D.31197>;
    <D.31196>:
    monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "aot-runtime.c", 4468, "ret == 0");
    <D.31197>:
  }
  D.31198 = amodule->info.trampoline_got_offset_base[tramp_type];
  D.31199 = index * n_got_slots;
  D.31200 = (unsigned int) D.31199;
  D.31201 = D.31198 + D.31200;
  *got_offset = D.31201;
  D.31202 = amodule->info.trampoline_size[tramp_type];
  tramp_size = (int) D.31202;
  if (out_tramp_size != 0B) goto <D.31203>; else goto <D.31204>;
  <D.31203>:
  tramp_size.245 = (unsigned int) tramp_size;
  *out_tramp_size = tramp_size.245;
  <D.31204>:
  D.31207 = amodule->trampolines[tramp_type];
  D.31208 = index * tramp_size;
  D.31209 = (sizetype) D.31208;
  D.31206 = D.31207 + D.31209;
  return D.31206;
}


mono_aot_get_static_rgctx_trampoline (void * ctx, void * addr)
{
  struct MonoAotModule * amodule.246;
  void * * D.31215;
  unsigned int got_offset.247;
  unsigned int D.31217;
  void * * D.31218;
  sizetype D.31219;
  sizetype D.31220;
  void * * D.31221;
  void * D.31222;
  struct MonoDomain * D.31223;
  struct MonoAotModule * amodule;
  guint8 * code;
  guint32 got_offset;

  try
    {
      if (0 != 0) goto <D.31211>; else goto <D.31212>;
      <D.31211>:
      code = get_new_rgctx_trampoline_from_page (addr, ctx);
      goto <D.31213>;
      <D.31212>:
      code = get_numerous_trampoline (1, 2, &amodule, &got_offset, 0B);
      amodule.246 = amodule;
      D.31215 = amodule.246->got;
      got_offset.247 = got_offset;
      D.31217 = got_offset.247 * 4;
      D.31218 = D.31215 + D.31217;
      *D.31218 = ctx;
      amodule.246 = amodule;
      D.31215 = amodule.246->got;
      got_offset.247 = got_offset;
      D.31219 = got_offset.247 + 1;
      D.31220 = D.31219 * 4;
      D.31221 = D.31215 + D.31220;
      *D.31221 = addr;
      <D.31213>:
      D.31223 = mono_domain_get ();
      D.31222 = mono_create_ftnptr (D.31223, code);
      return D.31222;
    }
  finally
    {
      amodule = {CLOBBER};
      got_offset = {CLOBBER};
    }
}


mono_aot_get_unbox_trampoline (struct MonoMethod * method)
{
  unsigned int D.31226;
  unsigned int D.31227;
  unsigned char D.31230;
  unsigned char D.31231;
  int D.31233;
  int D.31237;
  _Bool D.31240;
  long int D.31241;
  long int D.31242;
  struct MonoClass * D.31245;
  struct MonoImage * D.31246;
  void * amodule.248;
  struct MonoAotModule * amodule.249;
  _Bool D.31249;
  long int D.31250;
  long int D.31251;
  int ut_end.250;
  int ut.251;
  int D.31256;
  int D.31257;
  int D.31258;
  unsigned int entry_index.252;
  unsigned int D.31260;
  unsigned int D.31261;
  unsigned int D.31268;
  unsigned int D.31269;
  guint32 * D.31272;
  guint8 * D.31274;
  unsigned int D.31275;
  _Bool D.31276;
  long int D.31277;
  long int D.31278;
  void * D.31281;
  struct MonoDomain * D.31282;
  guint32 method_index;
  struct MonoAotModule * amodule;
  void * code;
  guint32 * ut;
  guint32 * ut_end;
  guint32 * entry;
  int low;
  int high;
  int entry_index;

  try
    {
      D.31226 = method->token;
      D.31227 = D.31226 & 16777215;
      method_index = D.31227 + 4294967295;
      D.31230 = BIT_FIELD_REF <*method, 8, 168>;
      D.31231 = D.31230 & 16;
      if (D.31231 != 0) goto <D.31232>; else goto <D.31228>;
      <D.31232>:
      D.31233 = mono_method_is_generic_sharable_full (method, 0, 0, 0);
      if (D.31233 == 0) goto <D.31234>; else goto <D.31228>;
      <D.31234>:
      method_index = find_extra_method (method, &amodule);
      if (method_index == 16777215) goto <D.31235>; else goto <D.31236>;
      <D.31235>:
      D.31237 = mono_method_is_generic_sharable_full (method, 0, 0, 1);
      if (D.31237 != 0) goto <D.31238>; else goto <D.31239>;
      <D.31238>:
      {
        struct MonoMethod * shared;

        shared = mini_get_shared_method_full (method, 1, 1);
        method_index = find_extra_method (shared, &amodule);
      }
      <D.31239>:
      <D.31236>:
      D.31240 = method_index == 16777215;
      D.31241 = (long int) D.31240;
      D.31242 = __builtin_expect (D.31241, 0);
      if (D.31242 != 0) goto <D.31243>; else goto <D.31244>;
      <D.31243>:
      monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "aot-runtime.c", 4568, "method_index != 0xffffff");
      <D.31244>:
      goto <D.31229>;
      <D.31228>:
      D.31245 = method->klass;
      D.31246 = D.31245->image;
      amodule.248 = D.31246->aot_module;
      amodule = amodule.248;
      amodule.249 = amodule;
      D.31249 = amodule.249 == 0B;
      D.31250 = (long int) D.31249;
      D.31251 = __builtin_expect (D.31250, 0);
      if (D.31251 != 0) goto <D.31252>; else goto <D.31253>;
      <D.31252>:
      monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "aot-runtime.c", 4571, "amodule");
      <D.31253>:
      <D.31229>:
      amodule.249 = amodule;
      ut = amodule.249->unbox_trampolines;
      amodule.249 = amodule;
      ut_end = amodule.249->unbox_trampolines_end;
      code = 0B;
      low = 0;
      ut_end.250 = (int) ut_end;
      ut.251 = (int) ut;
      D.31256 = ut_end.250 - ut.251;
      D.31257 = D.31256 /[ex] 4;
      high = D.31257 / 2;
      goto <D.26956>;
      <D.26955>:
      D.31258 = low + high;
      entry_index = D.31258 / 2;
      entry_index.252 = (unsigned int) entry_index;
      D.31260 = entry_index.252 * 8;
      entry = ut + D.31260;
      D.31261 = *entry;
      if (D.31261 < method_index) goto <D.31262>; else goto <D.31263>;
      <D.31262>:
      low = entry_index + 1;
      goto <D.31264>;
      <D.31263>:
      D.31261 = *entry;
      if (D.31261 > method_index) goto <D.31265>; else goto <D.31266>;
      <D.31265>:
      high = entry_index;
      goto <D.31267>;
      <D.31266>:
      amodule.249 = amodule;
      D.31268 = amodule.249->info.flags;
      D.31269 = D.31268 & 8;
      if (D.31269 != 0) goto <D.31270>; else goto <D.31271>;
      <D.31270>:
      D.31272 = entry + 4;
      code = get_arm_bl_target (D.31272);
      goto <D.31273>;
      <D.31271>:
      amodule.249 = amodule;
      D.31274 = amodule.249->code;
      D.31272 = entry + 4;
      D.31275 = *D.31272;
      code = D.31274 + D.31275;
      <D.31273>:
      goto <D.26954>;
      <D.31267>:
      <D.31264>:
      <D.26956>:
      if (low < high) goto <D.26955>; else goto <D.26954>;
      <D.26954>:
      D.31276 = code == 0B;
      D.31277 = (long int) D.31276;
      D.31278 = __builtin_expect (D.31277, 0);
      if (D.31278 != 0) goto <D.31279>; else goto <D.31280>;
      <D.31279>:
      monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "aot-runtime.c", 4596, "code");
      <D.31280>:
      D.31282 = mono_domain_get ();
      D.31281 = mono_create_ftnptr (D.31282, code);
      return D.31281;
    }
  finally
    {
      amodule = {CLOBBER};
    }
}


get_arm_bl_target (guint32 * ins_addr)
{
  unsigned int D.31285;
  unsigned int D.31288;
  unsigned int D.31289;
  unsigned int D.31290;
  unsigned int D.31291;
  unsigned int D.31292;
  int D.31293;
  int D.31294;
  void * D.31295;
  int D.31296;
  sizetype D.31297;
  sizetype D.31298;
  int ins.253;
  int D.31300;
  int D.31301;
  sizetype D.31302;
  sizetype D.31303;
  guint32 ins;
  gint32 offset;

  ins = *ins_addr;
  D.31285 = ins >> 28;
  if (D.31285 == 15) goto <D.31286>; else goto <D.31287>;
  <D.31286>:
  D.31288 = ins & 16777215;
  D.31289 = D.31288 << 1;
  D.31290 = ins >> 24;
  D.31291 = D.31290 & 1;
  D.31292 = D.31289 | D.31291;
  D.31293 = (int) D.31292;
  D.31294 = D.31293 << 7;
  offset = D.31294 >> 7;
  D.31296 = offset * 2;
  D.31297 = (sizetype) D.31296;
  D.31298 = D.31297 + 9;
  D.31295 = ins_addr + D.31298;
  return D.31295;
  <D.31287>:
  ins.253 = (int) ins;
  D.31300 = ins.253 << 8;
  offset = D.31300 >> 8;
  D.31301 = offset * 4;
  D.31302 = (sizetype) D.31301;
  D.31303 = D.31302 + 8;
  D.31295 = ins_addr + D.31303;
  return D.31295;
}


mono_aot_get_lazy_fetch_trampoline (guint32 slot)
{
  struct MonoImage * D.31305;
  int count.254;
  int count.255;
  unsigned int D.31308;
  void * addr.256;
  void * addr.257;
  struct MonoDomain * D.31315;
  void * slot.258;
  void * * D.31317;
  struct MonoDomain * D.31318;
  void * D.31319;
  void * D.31320;
  struct MonoDomain * D.31321;
  int slot.259;
  void * D.31323;
  struct MonoDomain * D.31324;
  char * symbol;
  void * code;
  struct MonoAotModule * amodule;
  guint32 index;
  static int count = 0;

  D.31305 = mono_defaults.corlib;
  amodule = D.31305->aot_module;
  index = slot & 2147483647;
  count.254 = count;
  count.255 = count.254 + 1;
  count = count.255;
  D.31308 = amodule->info.num_rgctx_fetch_trampolines;
  if (D.31308 <= index) goto <D.31309>; else goto <D.31310>;
  <D.31309>:
  {
    static void * addr;
    void * * info;

    addr.256 = addr;
    if (addr.256 == 0B) goto <D.31312>; else goto <D.31313>;
    <D.31312>:
    addr.257 = load_function (amodule, "rgctx_fetch_trampoline_general");
    addr = addr.257;
    <D.31313>:
    D.31315 = mono_get_root_domain ();
    info = mono_domain_alloc0 (D.31315, 8);
    slot.258 = (void *) slot;
    *info = slot.258;
    D.31317 = info + 4;
    slot.258 = (void *) slot;
    D.31318 = mono_get_root_domain ();
    D.31319 = mono_create_specific_trampoline (slot.258, 4, D.31318, 0B);
    *D.31317 = D.31319;
    addr.256 = addr;
    code = mono_aot_get_static_rgctx_trampoline (info, addr.256);
    D.31321 = mono_domain_get ();
    D.31320 = mono_create_ftnptr (D.31321, code);
    return D.31320;
  }
  <D.31310>:
  slot.259 = (int) slot;
  symbol = mono_get_rgctx_fetch_trampoline_name (slot.259);
  D.31305 = mono_defaults.corlib;
  D.31323 = D.31305->aot_module;
  code = load_function (D.31323, symbol);
  monoeg_g_free (symbol);
  D.31324 = mono_domain_get ();
  D.31320 = mono_create_ftnptr (D.31324, code);
  return D.31320;
}


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

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


mono_aot_get_imt_thunk (struct MonoVTable * vtable, struct MonoDomain * domain, struct MonoIMTCheckItem * * imt_entries, int count, void * fail_tramp)
{
  unsigned int i.260;
  unsigned int D.31329;
  struct MonoIMTCheckItem * * D.31330;
  unsigned char D.31331;
  int D.31334;
  unsigned int D.31335;
  unsigned int D.31336;
  unsigned char D.31337;
  void * D.31340;
  _Bool D.31341;
  long int D.31342;
  long int D.31343;
  unsigned int index.261;
  unsigned int D.31347;
  void * * D.31348;
  unsigned char D.31349;
  void * D.31352;
  sizetype index.262;
  sizetype D.31354;
  sizetype D.31355;
  void * * D.31356;
  int D.31358;
  void * * D.31359;
  struct MonoAotModule * amodule.263;
  void * * D.31364;
  unsigned int got_offset.264;
  unsigned int D.31366;
  void * * D.31367;
  void * D.31368;
  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.26983>;
      <D.26982>:
      {
        struct MonoIMTCheckItem * item;

        i.260 = (unsigned int) i;
        D.31329 = i.260 * 4;
        D.31330 = imt_entries + D.31329;
        item = *D.31330;
        D.31331 = item->is_equals;
        if (D.31331 != 0) goto <D.31332>; else goto <D.31333>;
        <D.31332>:
        real_count = real_count + 1;
        <D.31333>:
      }
      i = i + 1;
      <D.26983>:
      if (i < count) goto <D.26982>; else goto <D.26984>;
      <D.26984>:
      D.31334 = real_count + 1;
      D.31335 = (unsigned int) D.31334;
      D.31336 = D.31335 * 8;
      buf = mono_domain_alloc (domain, D.31336);
      index = 0;
      i = 0;
      goto <D.26989>;
      <D.26988>:
      {
        struct MonoIMTCheckItem * item;

        i.260 = (unsigned int) i;
        D.31329 = i.260 * 4;
        D.31330 = imt_entries + D.31329;
        item = *D.31330;
        D.31337 = item->is_equals;
        if (D.31337 == 0) goto <D.31338>; else goto <D.31339>;
        <D.31338>:
        // predicted unlikely by continue predictor.
        goto <D.26986>;
        <D.31339>:
        D.31340 = item->key;
        D.31341 = D.31340 == 0B;
        D.31342 = (long int) D.31341;
        D.31343 = __builtin_expect (D.31342, 0);
        if (D.31343 != 0) goto <D.31344>; else goto <D.31345>;
        <D.31344>:
        monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "aot-runtime.c", 4661, "item->key");
        <D.31345>:
        index.261 = (unsigned int) index;
        D.31347 = index.261 * 8;
        D.31348 = buf + D.31347;
        D.31340 = item->key;
        *D.31348 = D.31340;
        D.31349 = item->has_target_code;
        if (D.31349 != 0) goto <D.31350>; else goto <D.31351>;
        <D.31350>:
        {
          void * * p;

          p = mono_domain_alloc (domain, 4);
          D.31352 = item->value.target_code;
          *p = D.31352;
          index.262 = (sizetype) index;
          D.31354 = index.262 * 8;
          D.31355 = D.31354 + 4;
          D.31356 = buf + D.31355;
          *D.31356 = p;
        }
        goto <D.31357>;
        <D.31351>:
        index.262 = (sizetype) index;
        D.31354 = index.262 * 8;
        D.31355 = D.31354 + 4;
        D.31356 = buf + D.31355;
        D.31358 = item->value.vtable_slot;
        D.31359 = &vtable->vtable[D.31358];
        *D.31356 = D.31359;
        <D.31357>:
        index = index + 1;
      }
      <D.26986>:
      i = i + 1;
      <D.26989>:
      if (i < count) goto <D.26988>; else goto <D.26990>;
      <D.26990>:
      index.261 = (unsigned int) index;
      D.31347 = index.261 * 8;
      D.31348 = buf + D.31347;
      *D.31348 = 0B;
      index.262 = (sizetype) index;
      D.31354 = index.262 * 8;
      D.31355 = D.31354 + 4;
      D.31356 = buf + D.31355;
      *D.31356 = fail_tramp;
      if (0 != 0) goto <D.31360>; else goto <D.31361>;
      <D.31360>:
      code = get_new_imt_trampoline_from_page (buf);
      goto <D.31362>;
      <D.31361>:
      code = get_numerous_trampoline (2, 1, &amodule, &got_offset, 0B);
      amodule.263 = amodule;
      D.31364 = amodule.263->got;
      got_offset.264 = got_offset;
      D.31366 = got_offset.264 * 4;
      D.31367 = D.31364 + D.31366;
      *D.31367 = buf;
      <D.31362>:
      D.31368 = code;
      return D.31368;
    }
  finally
    {
      got_offset = {CLOBBER};
      amodule = {CLOBBER};
    }
}


mono_aot_get_gsharedvt_arg_trampoline (void * arg, void * addr)
{
  struct MonoAotModule * amodule.265;
  void * * D.31375;
  unsigned int got_offset.266;
  unsigned int D.31377;
  void * * D.31378;
  sizetype D.31379;
  sizetype D.31380;
  void * * D.31381;
  void * D.31382;
  struct MonoDomain * D.31383;
  struct MonoAotModule * amodule;
  guint8 * code;
  guint32 got_offset;

  try
    {
      if (0 != 0) goto <D.31371>; else goto <D.31372>;
      <D.31371>:
      code = get_new_gsharedvt_arg_trampoline_from_page (addr, arg);
      goto <D.31373>;
      <D.31372>:
      code = get_numerous_trampoline (3, 2, &amodule, &got_offset, 0B);
      amodule.265 = amodule;
      D.31375 = amodule.265->got;
      got_offset.266 = got_offset;
      D.31377 = got_offset.266 * 4;
      D.31378 = D.31375 + D.31377;
      *D.31378 = arg;
      amodule.265 = amodule;
      D.31375 = amodule.265->got;
      got_offset.266 = got_offset;
      D.31379 = got_offset.266 + 1;
      D.31380 = D.31379 * 4;
      D.31381 = D.31375 + D.31380;
      *D.31381 = addr;
      <D.31373>:
      D.31383 = mono_domain_get ();
      D.31382 = mono_create_ftnptr (D.31383, code);
      return D.31382;
    }
  finally
    {
      amodule = {CLOBBER};
      got_offset = {CLOBBER};
    }
}


mono_aot_set_make_unreadable (gboolean unreadable)
{
  int make_unreadable.267;
  int inited.268;
  static int inited;

  make_unreadable = unreadable;
  make_unreadable.267 = make_unreadable;
  if (make_unreadable.267 != 0) goto <D.31387>; else goto <D.31388>;
  <D.31387>:
  inited.268 = inited;
  if (inited.268 == 0) goto <D.31390>; else goto <D.31391>;
  <D.31390>:
  mono_counters_register ("AOT pagefaults", 256, &n_pagefaults);
  <D.31391>:
  <D.31388>:
}


mono_aot_is_pagefault (void * ptr)
{
  int make_unreadable.269;
  gboolean D.31395;
  struct MonoAotModule * D.31396;
  _Bool D.31397;

  make_unreadable.269 = make_unreadable;
  if (make_unreadable.269 == 0) goto <D.31393>; else goto <D.31394>;
  <D.31393>:
  D.31395 = 0;
  return D.31395;
  <D.31394>:
  D.31396 = find_module_for_addr (ptr);
  D.31397 = D.31396 != 0B;
  D.31395 = (gboolean) D.31397;
  return D.31395;
}


find_module_for_addr (void * ptr)
{
  int make_unreadable.270;
  struct MonoAotModule * D.31402;
  _Bool D.31405;
  long int D.31406;
  long int D.31407;
  struct GHashTable * aot_modules.271;
  _Bool D.31413;
  long int D.31414;
  long int D.31415;
  struct FindMapUserData data;

  try
    {
      make_unreadable.270 = make_unreadable;
      if (make_unreadable.270 == 0) goto <D.31400>; else goto <D.31401>;
      <D.31400>:
      D.31402 = 0B;
      return D.31402;
      <D.31401>:
      data.module = 0B;
      data.ptr = ptr;
      {
        int ret;

        ret = pthread_mutex_lock (&aot_mutex.mutex);
        if (ret != 0) goto <D.31403>; else goto <D.31404>;
        <D.31403>:
        monoeg_g_log (0B, 16, "Bad call to mono_mutex_lock result %d", ret);
        <D.31404>:
        D.31405 = ret != 0;
        D.31406 = (long int) D.31405;
        D.31407 = __builtin_expect (D.31406, 0);
        if (D.31407 != 0) goto <D.31408>; else goto <D.31409>;
        <D.31408>:
        monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "aot-runtime.c", 4752, "ret == 0");
        <D.31409>:
      }
      aot_modules.271 = aot_modules;
      monoeg_g_hash_table_foreach (aot_modules.271, find_map, &data);
      {
        int ret;

        ret = pthread_mutex_unlock (&aot_mutex.mutex);
        if (ret != 0) goto <D.31411>; else goto <D.31412>;
        <D.31411>:
        monoeg_g_log (0B, 16, "Bad call to mono_mutex_unlock result %d", ret);
        <D.31412>:
        D.31413 = ret != 0;
        D.31414 = (long int) D.31413;
        D.31415 = __builtin_expect (D.31414, 0);
        if (D.31415 != 0) goto <D.31416>; else goto <D.31417>;
        <D.31416>:
        monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "aot-runtime.c", 4754, "ret == 0");
        <D.31417>:
      }
      D.31402 = data.module;
      return D.31402;
    }
  finally
    {
      data = {CLOBBER};
    }
}


find_map (void * key, void * value, void * user_data)
{
  struct MonoAotModule * D.31420;
  guint8 * D.31423;
  guint8 * D.31424;
  guint8 * D.31427;
  struct MonoAotModule * module;
  struct FindMapUserData * data;

  module = value;
  data = user_data;
  D.31420 = data->module;
  if (D.31420 == 0B) goto <D.31421>; else goto <D.31422>;
  <D.31421>:
  D.31423 = data->ptr;
  D.31424 = module->mem_begin;
  if (D.31423 >= D.31424) goto <D.31425>; else goto <D.31426>;
  <D.31425>:
  D.31423 = data->ptr;
  D.31427 = module->mem_end;
  if (D.31423 < D.31427) goto <D.31428>; else goto <D.31429>;
  <D.31428>:
  data->module = module;
  <D.31429>:
  <D.31426>:
  <D.31422>:
}


mono_aot_handle_pagefault (void * ptr)
{
  int D.31430;
  int D.31431;
  int ptr.272;
  int D.31433;
  _Bool D.31436;
  long int D.31437;
  long int D.31438;
  int D.31441;
  unsigned int D.31442;
  _Bool D.31443;
  long int D.31444;
  long int D.31445;
  unsigned int n_pagefaults.273;
  unsigned int n_pagefaults.274;
  _Bool D.31452;
  long int D.31453;
  long int D.31454;
  guint8 * start;
  int res;

  D.31430 = mono_pagesize ();
  D.31431 = -D.31430;
  ptr.272 = (int) ptr;
  D.31433 = D.31431 & ptr.272;
  start = (guint8 *) D.31433;
  {
    int ret;

    ret = pthread_mutex_lock (&aot_mutex.mutex);
    if (ret != 0) goto <D.31434>; else goto <D.31435>;
    <D.31434>:
    monoeg_g_log (0B, 16, "Bad call to mono_mutex_lock result %d", ret);
    <D.31435>:
    D.31436 = ret != 0;
    D.31437 = (long int) D.31436;
    D.31438 = __builtin_expect (D.31437, 0);
    if (D.31438 != 0) goto <D.31439>; else goto <D.31440>;
    <D.31439>:
    monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "aot-runtime.c", 4790, "ret == 0");
    <D.31440>:
  }
  D.31441 = mono_pagesize ();
  D.31442 = (unsigned int) D.31441;
  res = mono_mprotect (start, D.31442, 7);
  D.31443 = res != 0;
  D.31444 = (long int) D.31443;
  D.31445 = __builtin_expect (D.31444, 0);
  if (D.31445 != 0) goto <D.31446>; else goto <D.31447>;
  <D.31446>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "aot-runtime.c", 4792, "res == 0");
  <D.31447>:
  n_pagefaults.273 = n_pagefaults;
  n_pagefaults.274 = n_pagefaults.273 + 1;
  n_pagefaults = n_pagefaults.274;
  {
    int ret;

    ret = pthread_mutex_unlock (&aot_mutex.mutex);
    if (ret != 0) goto <D.31450>; else goto <D.31451>;
    <D.31450>:
    monoeg_g_log (0B, 16, "Bad call to mono_mutex_unlock result %d", ret);
    <D.31451>:
    D.31452 = ret != 0;
    D.31453 = (long int) D.31452;
    D.31454 = __builtin_expect (D.31453, 0);
    if (D.31454 != 0) goto <D.31455>; else goto <D.31456>;
    <D.31455>:
    monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "aot-runtime.c", 4795, "ret == 0");
    <D.31456>:
  }
}