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.24192;
  _Bool D.24193;
  long int D.24194;
  long int D.24195;
  _Bool D.24198;
  long int D.24199;
  long int D.24200;
  struct GHashTable * aot_modules.0;
  _Bool D.24208;
  long int D.24209;
  long int D.24210;
  struct GHashTable * static_aot_modules.1;
  struct GHashTable * static_aot_modules.2;
  _Bool D.24221;
  long int D.24222;
  long int D.24223;
  void * * globals;
  char * aname;
  struct MonoAotFileInfo * info;

  info = aot_info;
  D.24192 = info->version;
  D.24193 = D.24192 != 97;
  D.24194 = (long int) D.24193;
  D.24195 = __builtin_expect (D.24194, 0);
  if (D.24195 != 0) goto <D.24196>; else goto <D.24197>;
  <D.24196>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "aot-runtime.c", 1889, "info->version == MONO_AOT_FILE_VERSION");
  <D.24197>:
  globals = info->globals;
  D.24198 = globals == 0B;
  D.24199 = (long int) D.24198;
  D.24200 = __builtin_expect (D.24199, 0);
  if (D.24200 != 0) goto <D.24201>; else goto <D.24202>;
  <D.24201>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "aot-runtime.c", 1892, "globals");
  <D.24202>:
  aname = info->assembly_name;
  aot_modules.0 = aot_modules;
  if (aot_modules.0 != 0B) goto <D.24204>; else goto <D.24205>;
  <D.24204>:
  {
    int ret;

    ret = pthread_mutex_lock (&aot_mutex.mutex);
    if (ret != 0) goto <D.24206>; else goto <D.24207>;
    <D.24206>:
    monoeg_g_log (0B, 16, "Bad call to mono_mutex_lock result %d", ret);
    <D.24207>:
    D.24208 = ret != 0;
    D.24209 = (long int) D.24208;
    D.24210 = __builtin_expect (D.24209, 0);
    if (D.24210 != 0) goto <D.24211>; else goto <D.24212>;
    <D.24211>:
    monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "aot-runtime.c", 1898, "ret == 0");
    <D.24212>:
  }
  <D.24205>:
  static_aot_modules.1 = static_aot_modules;
  if (static_aot_modules.1 == 0B) goto <D.24214>; else goto <D.24215>;
  <D.24214>:
  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.24215>:
  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.24217>; else goto <D.24218>;
  <D.24217>:
  {
    int ret;

    ret = pthread_mutex_unlock (&aot_mutex.mutex);
    if (ret != 0) goto <D.24219>; else goto <D.24220>;
    <D.24219>:
    monoeg_g_log (0B, 16, "Bad call to mono_mutex_unlock result %d", ret);
    <D.24220>:
    D.24221 = ret != 0;
    D.24222 = (long int) D.24221;
    D.24223 = __builtin_expect (D.24222, 0);
    if (D.24223 != 0) goto <D.24224>; else goto <D.24225>;
    <D.24224>:
    monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "aot-runtime.c", 1906, "ret == 0");
    <D.24225>:
  }
  <D.24218>:
}


mono_aot_init ()
{
  struct GHashTable * aot_modules.3;
  const gchar * D.24227;
  const gchar * D.24230;
  int mono_last_aot_method.4;
  const gchar * D.24232;

  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.24227 = monoeg_g_getenv ("MONO_LASTAOT");
  if (D.24227 != 0B) goto <D.24228>; else goto <D.24229>;
  <D.24228>:
  D.24230 = monoeg_g_getenv ("MONO_LASTAOT");
  mono_last_aot_method.4 = atoi (D.24230);
  mono_last_aot_method = mono_last_aot_method.4;
  <D.24229>:
  D.24232 = monoeg_g_getenv ("MONO_AOT_CACHE");
  if (D.24232 != 0B) goto <D.24233>; else goto <D.24234>;
  <D.24233>:
  use_aot_cache = 1;
  <D.24234>:
}


load_aot_module (struct MonoAssembly * assembly, void * user_data)
{
  int mono_compile_aot.5;
  struct MonoImage * D.24238;
  void * D.24239;
  unsigned int D.24244;
  unsigned int D.24245;
  int D.24247;
  <unnamed type> D.24248;
  _Bool D.24253;
  long int D.24254;
  long int D.24255;
  struct GHashTable * static_aot_modules.6;
  const char * D.24261;
  void * info.7;
  _Bool D.24266;
  long int D.24267;
  long int D.24268;
  struct MonoAotFileInfo * info.8;
  gchar * aot_name.9;
  char * aot_name.10;
  int use_aot_cache.11;
  char * D.24281;
  gchar * aot_name.12;
  char * err.13;
  int mono_aot_only.14;
  unsigned int D.24293;
  unsigned int D.24294;
  struct _IO_FILE * stderr.15;
  char * version_symbol.16;
  _Bool D.24304;
  long int D.24305;
  long int D.24306;
  unsigned int D.24309;
  gchar * msg.17;
  char * msg.18;
  unsigned int D.24321;
  unsigned int align_double.19;
  _Bool D.24323;
  long int D.24324;
  long int D.24325;
  unsigned int D.24328;
  unsigned int align_int64.20;
  _Bool D.24330;
  long int D.24331;
  long int D.24332;
  unsigned int D.24335;
  _Bool D.24336;
  long int D.24337;
  long int D.24338;
  struct MonoAotFileInfo * D.24341;
  void * D.24342;
  void * * D.24343;
  struct GHashTable * D.24344;
  _Bool D.24345;
  long int D.24346;
  long int D.24347;
  unsigned int D.24350;
  void * D.24351;
  unsigned int D.24352;
  void * D.24353;
  void * D.24354;
  struct MonoAssemblyName * D.24355;
  unsigned int D.24356;
  gchar * D.24357;
  unsigned int D.24358;
  sizetype D.24359;
  char * * D.24360;
  unsigned int D.24361;
  char * * D.24362;
  gchar * D.24363;
  unsigned int D.24364;
  sizetype D.24365;
  char D.24366;
  gchar * D.24369;
  unsigned int D.24370;
  sizetype D.24371;
  mono_byte[17] * D.24372;
  unsigned int D.24373;
  unsigned int D.24374;
  unsigned int D.24375;
  sizetype D.24376;
  int table.21;
  int D.24378;
  int D.24379;
  unsigned int D.24380;
  short unsigned int D.24381;
  void * D.24382;
  void * D.24383;
  void * D.24384;
  void * D.24385;
  void * D.24386;
  void * D.24387;
  void * D.24388;
  void * D.24389;
  void * D.24390;
  void * D.24391;
  void * D.24392;
  void * D.24393;
  void * D.24394;
  void * D.24395;
  void * D.24396;
  guint8 * D.24397;
  void * D.24398;
  void * D.24399;
  void * D.24400;
  void * D.24401;
  void * D.24402;
  void * D.24403;
  void * D.24404;
  void * D.24405;
  int make_unreadable.22;
  guint8 * D.24409;
  int D.24410;
  guint8 * D.24411;
  int D.24412;
  int D.24413;
  sizetype D.24414;
  int D.24415;
  int D.24416;
  int addr.23;
  int D.24418;
  sizetype D.24419;
  sizetype D.24420;
  sizetype len.24;
  guint8 * D.24422;
  int D.24423;
  int D.24424;
  int D.24425;
  int D.24426;
  int page_end.25;
  int page_start.26;
  int D.24431;
  unsigned int D.24432;
  _Bool D.24433;
  long int D.24434;
  long int D.24435;
  _Bool D.24440;
  long int D.24441;
  long int D.24442;
  unsigned int D.24445;
  unsigned int aot_code_low_addr.27;
  unsigned int aot_code_low_addr.28;
  guint8 * D.24448;
  unsigned int D.24449;
  unsigned int aot_code_high_addr.29;
  unsigned int aot_code_high_addr.30;
  struct GHashTable * aot_modules.31;
  _Bool D.24455;
  long int D.24456;
  long int D.24457;
  struct MonoDl * D.24462;
  void * * D.24463;
  char * code.32;
  _Bool D.24465;
  int D.24466;
  struct MonoImage * D.24467;
  void * * D.24470;
  void * * D.24471;
  int D.24473;
  void * * D.24476;
  struct MonoDomain * D.24477;
  void * D.24478;
  unsigned int i.33;
  unsigned int D.24482;
  int D.24483;
  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.24236>; else goto <D.24237>;
      <D.24236>:
      return;
      <D.24237>:
      D.24238 = assembly->image;
      D.24239 = D.24238->aot_module;
      if (D.24239 != 0B) goto <D.24240>; else goto <D.24241>;
      <D.24240>:
      return;
      <D.24241>:
      D.24238 = assembly->image;
      D.24244 = BIT_FIELD_REF <*D.24238, 32, 128>;
      D.24245 = D.24244 & 8;
      if (D.24245 != 0) goto <D.24242>; else goto <D.24246>;
      <D.24246>:
      D.24247 = assembly->ref_only;
      if (D.24247 != 0) goto <D.24242>; else goto <D.24243>;
      <D.24242>:
      return;
      <D.24243>:
      D.24248 = mono_security_get_mode ();
      if (D.24248 == 2) goto <D.24249>; else goto <D.24250>;
      <D.24249>:
      return;
      <D.24250>:
      {
        int ret;

        ret = pthread_mutex_lock (&aot_mutex.mutex);
        if (ret != 0) goto <D.24251>; else goto <D.24252>;
        <D.24251>:
        monoeg_g_log (0B, 16, "Bad call to mono_mutex_lock result %d", ret);
        <D.24252>:
        D.24253 = ret != 0;
        D.24254 = (long int) D.24253;
        D.24255 = __builtin_expect (D.24254, 0);
        if (D.24255 != 0) goto <D.24256>; else goto <D.24257>;
        <D.24256>:
        monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "aot-runtime.c", 1577, "ret == 0");
        <D.24257>:
      }
      static_aot_modules.6 = static_aot_modules;
      if (static_aot_modules.6 != 0B) goto <D.24259>; else goto <D.24260>;
      <D.24259>:
      static_aot_modules.6 = static_aot_modules;
      D.24261 = assembly->aname.name;
      info.7 = monoeg_g_hash_table_lookup (static_aot_modules.6, D.24261);
      info = info.7;
      goto <D.24263>;
      <D.24260>:
      info = 0B;
      <D.24263>:
      {
        int ret;

        ret = pthread_mutex_unlock (&aot_mutex.mutex);
        if (ret != 0) goto <D.24264>; else goto <D.24265>;
        <D.24264>:
        monoeg_g_log (0B, 16, "Bad call to mono_mutex_unlock result %d", ret);
        <D.24265>:
        D.24266 = ret != 0;
        D.24267 = (long int) D.24266;
        D.24268 = __builtin_expect (D.24267, 0);
        if (D.24268 != 0) goto <D.24269>; else goto <D.24270>;
        <D.24269>:
        monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "aot-runtime.c", 1582, "ret == 0");
        <D.24270>:
      }
      info.8 = info;
      if (info.8 != 0B) goto <D.24272>; else goto <D.24273>;
      <D.24272>:
      sofile = 0B;
      D.24261 = assembly->aname.name;
      aot_name.9 = monoeg_g_strdup_printf ("%s", D.24261);
      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.24276>;
      <D.24273>:
      use_aot_cache.11 = use_aot_cache;
      if (use_aot_cache.11 != 0) goto <D.24278>; else goto <D.24279>;
      <D.24278>:
      sofile = load_aot_module_from_cache (assembly, &aot_name);
      goto <D.24280>;
      <D.24279>:
      {
        char * err;

        try
          {
            D.24238 = assembly->image;
            D.24281 = D.24238->name;
            aot_name.12 = monoeg_g_strdup_printf ("%s%s", D.24281, ".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.24283>; else goto <D.24284>;
            <D.24283>:
            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.24284>:
          }
        finally
          {
            err = {CLOBBER};
          }
      }
      <D.24280>:
      <D.24276>:
      if (sofile == 0B) goto <D.24286>; else goto <D.24287>;
      <D.24286>:
      if (globals == 0B) goto <D.24288>; else goto <D.24289>;
      <D.24288>:
      mono_aot_only.14 = mono_aot_only;
      if (mono_aot_only.14 != 0) goto <D.24291>; else goto <D.24292>;
      <D.24291>:
      D.24238 = assembly->image;
      D.24293 = BIT_FIELD_REF <*D.24238, 32, 1408>;
      D.24294 = D.24293 & 16777215;
      if (D.24294 != 0) goto <D.24295>; else goto <D.24296>;
      <D.24295>:
      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.24296>:
      <D.24292>:
      aot_name.10 = aot_name;
      monoeg_g_free (aot_name.10);
      return;
      <D.24289>:
      <D.24287>:
      info.8 = info;
      if (info.8 == 0B) goto <D.24298>; else goto <D.24299>;
      <D.24298>:
      find_symbol (sofile, globals, "mono_aot_version", &version_symbol);
      find_symbol (sofile, globals, "mono_aot_file_info", &info);
      <D.24299>:
      version_symbol.16 = version_symbol;
      if (version_symbol.16 != 0B) goto <D.24301>; else goto <D.24302>;
      <D.24301>:
      version_symbol.16 = version_symbol;
      version = atoi (version_symbol.16);
      goto <D.24303>;
      <D.24302>:
      info.8 = info;
      D.24304 = info.8 == 0B;
      D.24305 = (long int) D.24304;
      D.24306 = __builtin_expect (D.24305, 0);
      if (D.24306 != 0) goto <D.24307>; else goto <D.24308>;
      <D.24307>:
      monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "aot-runtime.c", 1624, "info");
      <D.24308>:
      info.8 = info;
      D.24309 = info.8->version;
      version = (int) D.24309;
      <D.24303>:
      if (version != 97) goto <D.24310>; else goto <D.24311>;
      <D.24310>:
      msg.17 = monoeg_g_strdup_printf ("wrong file format version (expected %d got %d)", 97, version);
      msg = msg.17;
      usable = 0;
      goto <D.24313>;
      <D.24311>:
      info.8 = info;
      usable = check_usable (assembly, info.8, &msg);
      <D.24313>:
      if (usable == 0) goto <D.24314>; else goto <D.24315>;
      <D.24314>:
      mono_aot_only.14 = mono_aot_only;
      if (mono_aot_only.14 != 0) goto <D.24316>; else goto <D.24317>;
      <D.24316>:
      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.24317>:
      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.24319>; else goto <D.24320>;
      <D.24319>:
      mono_dl_close (sofile);
      <D.24320>:
      D.24238 = assembly->image;
      D.24238->aot_module = 0B;
      return;
      <D.24315>:
      align_double = 8;
      align_int64 = 8;
      info.8 = info;
      D.24321 = info.8->double_align;
      align_double.19 = (unsigned int) align_double;
      D.24323 = D.24321 != align_double.19;
      D.24324 = (long int) D.24323;
      D.24325 = __builtin_expect (D.24324, 0);
      if (D.24325 != 0) goto <D.24326>; else goto <D.24327>;
      <D.24326>:
      monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "aot-runtime.c", 1670, "info->double_align == align_double");
      <D.24327>:
      info.8 = info;
      D.24328 = info.8->long_align;
      align_int64.20 = (unsigned int) align_int64;
      D.24330 = D.24328 != align_int64.20;
      D.24331 = (long int) D.24330;
      D.24332 = __builtin_expect (D.24331, 0);
      if (D.24332 != 0) goto <D.24333>; else goto <D.24334>;
      <D.24333>:
      monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "aot-runtime.c", 1671, "info->long_align == align_int64");
      <D.24334>:
      info.8 = info;
      D.24335 = info.8->generic_tramp_num;
      D.24336 = D.24335 != 14;
      D.24337 = (long int) D.24336;
      D.24338 = __builtin_expect (D.24337, 0);
      if (D.24338 != 0) goto <D.24339>; else goto <D.24340>;
      <D.24339>:
      monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "aot-runtime.c", 1672, "info->generic_tramp_num == MONO_TRAMPOLINE_NUM");
      <D.24340>:
      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.24341 = &amodule->info;
      info.8 = info;
      memcpy (D.24341, info.8, 244);
      D.24342 = amodule->info.got;
      amodule->got = D.24342;
      D.24343 = amodule->got;
      D.24238 = assembly->image;
      *D.24343 = D.24238;
      amodule->globals = globals;
      amodule->sofile = sofile;
      D.24344 = monoeg_g_hash_table_new (mono_aligned_addr_hash, 0B);
      amodule->method_to_code = D.24344;
      amodule->blob = blob;
      {
        guint32 table_len;
        guint32 i;
        char * table;

        table = 0B;
        info.8 = info;
        table = info.8->image_table;
        D.24345 = table == 0B;
        D.24346 = (long int) D.24345;
        D.24347 = __builtin_expect (D.24346, 0);
        if (D.24347 != 0) goto <D.24348>; else goto <D.24349>;
        <D.24348>:
        monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "aot-runtime.c", 1695, "table");
        <D.24349>:
        table_len = MEM[(guint32 *)table];
        table = table + 4;
        D.24350 = table_len * 4;
        D.24351 = monoeg_malloc0 (D.24350);
        amodule->image_table = D.24351;
        D.24352 = table_len * 60;
        D.24353 = monoeg_malloc0 (D.24352);
        amodule->image_names = D.24353;
        D.24350 = table_len * 4;
        D.24354 = monoeg_malloc0 (D.24350);
        amodule->image_guids = D.24354;
        amodule->image_table_len = table_len;
        i = 0;
        goto <D.23147>;
        <D.23146>:
        {
          struct MonoAssemblyName * aname;

          D.24355 = amodule->image_names;
          D.24356 = i * 60;
          aname = D.24355 + D.24356;
          D.24357 = monoeg_strdup (table);
          aname->name = D.24357;
          D.24358 = strlen (table);
          D.24359 = D.24358 + 1;
          table = table + D.24359;
          D.24360 = amodule->image_guids;
          D.24361 = i * 4;
          D.24362 = D.24360 + D.24361;
          D.24363 = monoeg_strdup (table);
          *D.24362 = D.24363;
          D.24364 = strlen (table);
          D.24365 = D.24364 + 1;
          table = table + D.24365;
          D.24366 = *table;
          if (D.24366 != 0) goto <D.24367>; else goto <D.24368>;
          <D.24367>:
          D.24369 = monoeg_strdup (table);
          aname->culture = D.24369;
          <D.24368>:
          D.24370 = strlen (table);
          D.24371 = D.24370 + 1;
          table = table + D.24371;
          D.24372 = &aname->public_key_token;
          D.24373 = strlen (table);
          D.24374 = D.24373 + 1;
          memcpy (D.24372, table, D.24374);
          D.24375 = strlen (table);
          D.24376 = D.24375 + 1;
          table = table + D.24376;
          table.21 = (int) table;
          D.24378 = table.21 + 7;
          D.24379 = D.24378 & -8;
          table = (char *) D.24379;
          D.24380 = MEM[(guint32 *)table];
          aname->flags = D.24380;
          table = table + 4;
          D.24380 = MEM[(guint32 *)table];
          D.24381 = (short unsigned int) D.24380;
          aname->major = D.24381;
          table = table + 4;
          D.24380 = MEM[(guint32 *)table];
          D.24381 = (short unsigned int) D.24380;
          aname->minor = D.24381;
          table = table + 4;
          D.24380 = MEM[(guint32 *)table];
          D.24381 = (short unsigned int) D.24380;
          aname->build = D.24381;
          table = table + 4;
          D.24380 = MEM[(guint32 *)table];
          D.24381 = (short unsigned int) D.24380;
          aname->revision = D.24381;
          table = table + 4;
        }
        i = i + 1;
        <D.23147>:
        if (i < table_len) goto <D.23146>; else goto <D.23148>;
        <D.23148>:
      }
      info.8 = info;
      D.24382 = info.8->code_offsets;
      amodule->code_offsets = D.24382;
      info.8 = info;
      D.24383 = info.8->method_addresses;
      amodule->method_addresses = D.24383;
      info.8 = info;
      D.24384 = info.8->methods;
      amodule->code = D.24384;
      info.8 = info;
      D.24385 = info.8->methods_end;
      amodule->code_end = D.24385;
      info.8 = info;
      D.24386 = info.8->method_info_offsets;
      amodule->method_info_offsets = D.24386;
      info.8 = info;
      D.24387 = info.8->ex_info_offsets;
      amodule->ex_info_offsets = D.24387;
      info.8 = info;
      D.24388 = info.8->class_info_offsets;
      amodule->class_info_offsets = D.24388;
      info.8 = info;
      D.24389 = info.8->class_name_table;
      amodule->class_name_table = D.24389;
      info.8 = info;
      D.24390 = info.8->extra_method_table;
      amodule->extra_method_table = D.24390;
      info.8 = info;
      D.24391 = info.8->extra_method_info_offsets;
      amodule->extra_method_info_offsets = D.24391;
      info.8 = info;
      D.24392 = info.8->unbox_trampolines;
      amodule->unbox_trampolines = D.24392;
      info.8 = info;
      D.24393 = info.8->unbox_trampolines_end;
      amodule->unbox_trampolines_end = D.24393;
      info.8 = info;
      D.24394 = info.8->got_info_offsets;
      amodule->got_info_offsets = D.24394;
      info.8 = info;
      D.24395 = info.8->unwind_info;
      amodule->unwind_info = D.24395;
      info.8 = info;
      D.24396 = info.8->mem_end;
      amodule->mem_end = D.24396;
      D.24397 = amodule->code;
      amodule->mem_begin = D.24397;
      info.8 = info;
      D.24398 = info.8->plt;
      amodule->plt = D.24398;
      info.8 = info;
      D.24399 = info.8->plt_end;
      amodule->plt_end = D.24399;
      info.8 = info;
      D.24400 = info.8->mono_eh_frame;
      amodule->mono_eh_frame = D.24400;
      info.8 = info;
      D.24401 = info.8->specific_trampolines;
      amodule->trampolines[0] = D.24401;
      info.8 = info;
      D.24402 = info.8->static_rgctx_trampolines;
      amodule->trampolines[1] = D.24402;
      info.8 = info;
      D.24403 = info.8->imt_thunks;
      amodule->trampolines[2] = D.24403;
      info.8 = info;
      D.24404 = info.8->gsharedvt_arg_trampolines;
      amodule->trampolines[3] = D.24404;
      info.8 = info;
      D.24405 = info.8->thumb_end;
      amodule->thumb_end = D.24405;
      make_unreadable.22 = make_unreadable;
      if (make_unreadable.22 != 0) goto <D.24407>; else goto <D.24408>;
      <D.24407>:
      {
        guint8 * addr;
        guint8 * page_start;
        guint8 * page_end;
        int err;
        int len;

        addr = amodule->mem_begin;
        D.24409 = amodule->mem_end;
        D.24410 = (int) D.24409;
        D.24411 = amodule->mem_begin;
        D.24412 = (int) D.24411;
        len = D.24410 - D.24412;
        D.24413 = mono_pagesize ();
        D.24414 = (sizetype) D.24413;
        D.24415 = mono_pagesize ();
        D.24416 = -D.24415;
        addr.23 = (int) addr;
        D.24418 = D.24416 & addr.23;
        D.24419 = (sizetype) D.24418;
        D.24420 = D.24414 + D.24419;
        page_start = (guint8 *) D.24420;
        len.24 = (sizetype) len;
        D.24422 = addr + len.24;
        D.24423 = (int) D.24422;
        D.24424 = mono_pagesize ();
        D.24425 = -D.24424;
        D.24426 = D.24423 & D.24425;
        page_end = (guint8 *) D.24426;
        if (page_end > page_start) goto <D.24427>; else goto <D.24428>;
        <D.24427>:
        page_end.25 = (int) page_end;
        page_start.26 = (int) page_start;
        D.24431 = page_end.25 - page_start.26;
        D.24432 = (unsigned int) D.24431;
        err = mono_mprotect (page_start, D.24432, 0);
        D.24433 = err != 0;
        D.24434 = (long int) D.24433;
        D.24435 = __builtin_expect (D.24434, 0);
        if (D.24435 != 0) goto <D.24436>; else goto <D.24437>;
        <D.24436>:
        monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "aot-runtime.c", 1789, "err == 0");
        <D.24437>:
        <D.24428>:
      }
      <D.24408>:
      {
        int ret;

        ret = pthread_mutex_lock (&aot_mutex.mutex);
        if (ret != 0) goto <D.24438>; else goto <D.24439>;
        <D.24438>:
        monoeg_g_log (0B, 16, "Bad call to mono_mutex_lock result %d", ret);
        <D.24439>:
        D.24440 = ret != 0;
        D.24441 = (long int) D.24440;
        D.24442 = __builtin_expect (D.24441, 0);
        if (D.24442 != 0) goto <D.24443>; else goto <D.24444>;
        <D.24443>:
        monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "aot-runtime.c", 1794, "ret == 0");
        <D.24444>:
      }
      D.24397 = amodule->code;
      D.24445 = (unsigned int) D.24397;
      aot_code_low_addr.27 = aot_code_low_addr;
      aot_code_low_addr.28 = MIN_EXPR <D.24445, aot_code_low_addr.27>;
      aot_code_low_addr = aot_code_low_addr.28;
      D.24448 = amodule->code_end;
      D.24449 = (unsigned int) D.24448;
      aot_code_high_addr.29 = aot_code_high_addr;
      aot_code_high_addr.30 = MAX_EXPR <D.24449, 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.24453>; else goto <D.24454>;
        <D.24453>:
        monoeg_g_log (0B, 16, "Bad call to mono_mutex_unlock result %d", ret);
        <D.24454>:
        D.24455 = ret != 0;
        D.24456 = (long int) D.24455;
        D.24457 = __builtin_expect (D.24456, 0);
        if (D.24457 != 0) goto <D.24458>; else goto <D.24459>;
        <D.24458>:
        monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "aot-runtime.c", 1800, "ret == 0");
        <D.24459>:
      }
      D.24238 = assembly->image;
      D.24397 = amodule->code;
      D.24448 = amodule->code_end;
      mono_jit_info_add_aot_module (D.24238, D.24397, D.24448);
      D.24238 = assembly->image;
      D.24238->aot_module = amodule;
      mono_aot_only.14 = mono_aot_only;
      if (mono_aot_only.14 != 0) goto <D.24460>; else goto <D.24461>;
      <D.24460>:
      {
        char * code;

        try
          {
            D.24462 = amodule->sofile;
            D.24463 = amodule->globals;
            find_symbol (D.24462, D.24463, "specific_trampolines_page", &code);
            code.32 = code;
            D.24465 = code.32 != 0B;
            D.24466 = (int) D.24465;
            amodule->use_page_trampolines = D.24466;
            D.24467 = mono_defaults.corlib;
            if (D.24467 != 0B) goto <D.24468>; else goto <D.24469>;
            <D.24468>:
            {
              struct MonoAotModule * mscorlib_amodule;

              D.24467 = mono_defaults.corlib;
              mscorlib_amodule = D.24467->aot_module;
              D.24343 = amodule->got;
              D.24470 = D.24343 + 4;
              D.24471 = mscorlib_amodule->got;
              *D.24470 = D.24471;
            }
            goto <D.24472>;
            <D.24469>:
            D.24343 = amodule->got;
            D.24470 = D.24343 + 4;
            D.24343 = amodule->got;
            *D.24470 = D.24343;
            <D.24472>:
          }
        finally
          {
            code = {CLOBBER};
          }
      }
      <D.24461>:
      D.24473 = mono_gc_is_moving ();
      if (D.24473 != 0) goto <D.24474>; else goto <D.24475>;
      <D.24474>:
      {
        struct MonoJumpInfo ji;

        try
          {
            memset (&ji, 0, 20);
            ji.type = 42;
            D.24343 = amodule->got;
            D.24476 = D.24343 + 8;
            D.24477 = mono_get_root_domain ();
            D.24478 = mono_resolve_patch_target (0B, D.24477, 0B, &ji, 0);
            *D.24476 = D.24478;
          }
        finally
          {
            ji = {CLOBBER};
          }
      }
      <D.24475>:
      if (do_load_image != 0) goto <D.24479>; else goto <D.24480>;
      <D.24479>:
      i = 0;
      goto <D.23160>;
      <D.23159>:
      load_image (amodule, i, 0);
      i = i + 1;
      <D.23160>:
      i.33 = (unsigned int) i;
      D.24482 = amodule->image_table_len;
      if (i.33 < D.24482) goto <D.23159>; else goto <D.23161>;
      <D.23161>:
      <D.24480>:
      D.24483 = amodule->out_of_date;
      if (D.24483 != 0) goto <D.24484>; else goto <D.24485>;
      <D.24484>:
      D.24238 = assembly->image;
      D.24281 = D.24238->name;
      mono_trace (64, 32, "AOT Module %s is unusable because a dependency is out-of-date.\n", D.24281);
      mono_aot_only.14 = mono_aot_only;
      if (mono_aot_only.14 != 0) goto <D.24486>; else goto <D.24487>;
      <D.24486>:
      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.24487>:
      goto <D.24488>;
      <D.24485>:
      D.24238 = assembly->image;
      D.24281 = D.24238->name;
      mono_trace (64, 32, "AOT loaded AOT Module for %s.\n", D.24281);
      <D.24488>:
    }
  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.24492;
  unsigned int D.24493;
  unsigned int D.24494;
  struct MonoDl * D.24497;
  const char * D.24498;
  char * D.24499;
  char * D.24502;
  int spawn_compiler.34;
  union 
{
  gint __in;
  int __i;
} D.23046;
  int exit_status.35;
  int D.24511;
  int D.24512;
  union 
{
  gint __in;
  int __i;
} D.23050;
  int D.24514;
  int D.24515;
  int D.24516;
  gchar * err.36;
  gchar * out.37;
  int D.24521;
  unsigned int D.24522;
  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.24492 = assembly->image;
      D.24493 = BIT_FIELD_REF <*D.24492, 32, 128>;
      D.24494 = D.24493 & 8;
      if (D.24494 != 0) goto <D.24495>; else goto <D.24496>;
      <D.24495>:
      D.24497 = 0B;
      return D.24497;
      <D.24496>:
      create_cache_structure ();
      home = monoeg_g_get_home_dir ();
      D.24492 = assembly->image;
      D.24498 = D.24492->assembly_name;
      D.24492 = assembly->image;
      D.24499 = D.24492->guid;
      tmp2 = monoeg_g_strdup_printf ("%s-%s%s", D.24498, D.24499, ".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.24500>; else goto <D.24501>;
      <D.24500>:
      mono_trace (64, 32, "AOT not found.");
      D.24492 = assembly->image;
      D.24502 = D.24492->name;
      mono_trace (32, 32, "AOT precompiling assembly \'%s\'... ", D.24502);
      aot_options = monoeg_g_strdup_printf ("outfile=%s", fname);
      spawn_compiler.34 = spawn_compiler;
      if (spawn_compiler.34 != 0) goto <D.24504>; else goto <D.24505>;
      <D.24504>:
      D.24492 = assembly->image;
      D.24502 = D.24492->name;
      cmd = monoeg_g_strdup_printf ("mono -O=all --aot=%s %s", aot_options, D.24502);
      res = monoeg_g_spawn_command_line_sync (cmd, &out, &err, &exit_status, 0B);
      if (res != 0) goto <D.24506>; else goto <D.24507>;
      <D.24506>:
      {
        typedef union 
      {
        gint __in;
        int __i;
      } unionunion 
      {
        gint __in;
        int __i;
      };
        typedef union 
      {
        gint __in;
        int __i;
      } unionunion 
      {
        gint __in;
        int __i;
      };

        exit_status.35 = exit_status;
        D.23046.__in = exit_status.35;
        D.24511 = D.23046.__i;
        D.24512 = D.24511 & 127;
        if (D.24512 != 0) goto <D.24513>; else goto <D.24508>;
        <D.24513>:
        exit_status.35 = exit_status;
        D.23050.__in = exit_status.35;
        D.24514 = D.23050.__i;
        D.24515 = D.24514 & 65280;
        D.24516 = D.24515 >> 8;
        if (D.24516 == 0) goto <D.24517>; else goto <D.24508>;
        <D.24517>:
        err.36 = err;
        mono_trace (32, 32, "AOT failed: %s.", err.36);
        goto <D.24509>;
        <D.24508>:
        mono_trace (32, 32, "AOT succeeded.");
        <D.24509>:
        out.37 = out;
        monoeg_g_free (out.37);
        err.36 = err;
        monoeg_g_free (err.36);
      }
      <D.24507>:
      monoeg_g_free (cmd);
      goto <D.24520>;
      <D.24505>:
      D.24521 = mono_parse_default_optimizations (0B);
      D.24522 = (unsigned int) D.24521;
      res = mono_compile_assembly (assembly, D.24522, aot_options);
      if (res == 0) goto <D.24523>; else goto <D.24524>;
      <D.24523>:
      mono_trace (32, 32, "AOT failed.");
      goto <D.24525>;
      <D.24524>:
      mono_trace (32, 32, "AOT succeeded.");
      <D.24525>:
      <D.24520>:
      module = mono_dl_open (fname, 1, 0B);
      monoeg_g_free (aot_options);
      <D.24501>:
      D.24497 = module;
      return D.24497;
    }
  finally
    {
      out = {CLOBBER};
      err = {CLOBBER};
      exit_status = {CLOBBER};
    }
}


create_cache_structure ()
{
  int D.24530;
  int * D.24535;
  int D.24536;
  const gchar * D.24537;
  int D.24538;
  const gchar * D.24543;
  const char * home;
  char * tmp;
  int err;

  home = monoeg_g_get_home_dir ();
  if (home == 0B) goto <D.24528>; else goto <D.24529>;
  <D.24528>:
  return;
  <D.24529>:
  tmp = monoeg_g_build_path ("/", home, ".mono", 0B);
  D.24530 = monoeg_g_file_test (tmp, 4);
  if (D.24530 == 0) goto <D.24531>; else goto <D.24532>;
  <D.24531>:
  mono_trace (64, 32, "AOT creating directory %s", tmp);
  err = mkdir (tmp, 511);
  if (err != 0) goto <D.24533>; else goto <D.24534>;
  <D.24533>:
  D.24535 = __errno_location ();
  D.24536 = *D.24535;
  D.24537 = monoeg_g_strerror (D.24536);
  mono_trace (64, 32, "AOT failed: %s", D.24537);
  monoeg_g_free (tmp);
  return;
  <D.24534>:
  <D.24532>:
  monoeg_g_free (tmp);
  tmp = monoeg_g_build_path ("/", home, ".mono", "aot-cache", 0B);
  D.24538 = monoeg_g_file_test (tmp, 4);
  if (D.24538 == 0) goto <D.24539>; else goto <D.24540>;
  <D.24539>:
  mono_trace (64, 32, "AOT creating directory %s", tmp);
  err = mkdir (tmp, 511);
  if (err != 0) goto <D.24541>; else goto <D.24542>;
  <D.24541>:
  D.24535 = __errno_location ();
  D.24536 = *D.24535;
  D.24543 = monoeg_g_strerror (D.24536);
  mono_trace (64, 32, "AOT failed: %s", D.24543);
  monoeg_g_free (tmp);
  return;
  <D.24542>:
  <D.24540>:
  monoeg_g_free (tmp);
}


check_usable (struct MonoAssembly * assembly, struct MonoAotFileInfo * info, char * * out_msg)
{
  int D.23097;
  struct MonoImage * D.24545;
  char * D.24546;
  void * D.24547;
  void * D.24550;
  char D.24551;
  int D.23106;
  unsigned int D.24556;
  int D.24557;
  int mono_aot_only.38;
  struct MonoDebugOptions * D.24567;
  int D.24568;
  unsigned int D.24571;
  unsigned int D.24576;
  unsigned int excluded_cpu_optimizations.39;
  unsigned int D.24578;
  unsigned int D.24583;
  unsigned int D.24584;
  unsigned int D.24585;
  unsigned int D.24586;
  int D.24589;
  sizetype D.24592;
  int D.23117;
  gboolean D.24595;
  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.24545 = assembly->image;
        D.24546 = D.24545->guid;
        D.24547 = info->assembly_guid;
        D.23097 = __builtin_strcmp (D.24546, D.24547);
      }
      if (D.23097 != 0) goto <D.24548>; else goto <D.24549>;
      <D.24548>:
      msg = monoeg_g_strdup_printf ("doesn\'t match assembly");
      usable = 0;
      <D.24549>:
      build_info = mono_get_runtime_build_info ();
      D.24550 = info->runtime_version;
      D.24551 = MEM[(const char *)D.24550];
      if (D.24551 != 0) goto <D.24552>; else goto <D.24553>;
      <D.24552>:
      {
        size_t __s1_len;
        size_t __s2_len;

        D.24550 = info->runtime_version;
        D.23106 = __builtin_strcmp (D.24550, build_info);
      }
      if (D.23106 != 0) goto <D.24554>; else goto <D.24555>;
      <D.24554>:
      D.24550 = info->runtime_version;
      msg = monoeg_g_strdup_printf ("compiled against runtime version \'%s\' while this runtime has version \'%s\'", D.24550, build_info);
      usable = 0;
      <D.24555>:
      <D.24553>:
      monoeg_g_free (build_info);
      D.24556 = info->flags;
      D.24557 = (int) D.24556;
      full_aot = D.24557 & 2;
      mono_aot_only.38 = mono_aot_only;
      if (mono_aot_only.38 != 0) goto <D.24559>; else goto <D.24560>;
      <D.24559>:
      if (full_aot == 0) goto <D.24561>; else goto <D.24562>;
      <D.24561>:
      msg = monoeg_g_strdup_printf ("not compiled with --aot=full");
      usable = 0;
      <D.24562>:
      <D.24560>:
      mono_aot_only.38 = mono_aot_only;
      if (mono_aot_only.38 == 0) goto <D.24563>; else goto <D.24564>;
      <D.24563>:
      if (full_aot != 0) goto <D.24565>; else goto <D.24566>;
      <D.24565>:
      msg = monoeg_g_strdup_printf ("compiled with --aot=full");
      usable = 0;
      <D.24566>:
      <D.24564>:
      D.24567 = mini_get_debug_options ();
      D.24568 = D.24567->mdb_optimizations;
      if (D.24568 != 0) goto <D.24569>; else goto <D.24570>;
      <D.24569>:
      D.24556 = info->flags;
      D.24571 = D.24556 & 4;
      if (D.24571 == 0) goto <D.24572>; else goto <D.24573>;
      <D.24572>:
      if (full_aot == 0) goto <D.24574>; else goto <D.24575>;
      <D.24574>:
      msg = monoeg_g_strdup_printf ("not compiled for debugging");
      usable = 0;
      <D.24575>:
      <D.24573>:
      <D.24570>:
      mono_arch_cpu_optimizations (&excluded_cpu_optimizations);
      D.24576 = info->opts;
      excluded_cpu_optimizations.39 = excluded_cpu_optimizations;
      D.24578 = D.24576 & excluded_cpu_optimizations.39;
      if (D.24578 != 0) goto <D.24579>; else goto <D.24580>;
      <D.24579>:
      msg = monoeg_g_strdup_printf ("compiled with unsupported CPU optimizations");
      usable = 0;
      <D.24580>:
      mono_aot_only.38 = mono_aot_only;
      if (mono_aot_only.38 == 0) goto <D.24581>; else goto <D.24582>;
      <D.24581>:
      D.24583 = info->simd_opts;
      D.24584 = mono_arch_cpu_enumerate_simd_versions ();
      D.24585 = ~D.24584;
      D.24586 = D.24583 & D.24585;
      if (D.24586 != 0) goto <D.24587>; else goto <D.24588>;
      <D.24587>:
      msg = monoeg_g_strdup_printf ("compiled with unsupported SIMD extensions");
      usable = 0;
      <D.24588>:
      <D.24582>:
      blob = info->blob;
      D.24589 = info->gc_name_index;
      if (D.24589 != -1) goto <D.24590>; else goto <D.24591>;
      <D.24590>:
      {
        char * gc_name;
        const char * current_gc_name;

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

          D.23117 = __builtin_strcmp (current_gc_name, gc_name);
        }
        if (D.23117 != 0) goto <D.24593>; else goto <D.24594>;
        <D.24593>:
        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.24594>:
      }
      <D.24591>:
      *out_msg = msg;
      D.24595 = usable;
      return D.24595;
    }
  finally
    {
      excluded_cpu_optimizations = {CLOBBER};
    }
}


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

  if (str != 0B) goto <D.24598>; else goto <D.24599>;
  <D.24598>:
  D.24600 = __strdup (str);
  return D.24600;
  <D.24599>:
  D.24600 = 0B;
  return D.24600;
}


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

  D.24603 = __builtin_object_size (__dest, 0);
  D.24602 = __builtin___memcpy_chk (__dest, __src, __len, D.24603);
  return D.24602;
}


find_symbol (struct MonoDl * module, void * * globals, const char * name, void * * value)
{
  unsigned int D.24607;
  unsigned int D.24608;
  unsigned int D.24609;
  short unsigned int D.24610;
  int D.24611;
  int D.24612;
  guint16 * D.24613;
  short unsigned int D.24614;
  int D.23073;
  unsigned int D.24615;
  void * * D.24616;
  void * D.24617;
  unsigned int D.24621;
  sizetype global_index.40;
  sizetype D.24625;
  sizetype D.24626;
  void * * D.24627;
  void * D.24628;

  if (globals != 0B) goto <D.24605>; else goto <D.24606>;
  <D.24605>:
  {
    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.24607 = mono_metadata_str_hash (symbol);
    D.24608 = (unsigned int) table_size;
    hash = D.24607 % D.24608;
    D.24609 = hash * 4;
    entry = table + D.24609;
    global_index = -1;
    goto <D.23076>;
    <D.23075>:
    {
      guint32 index;
      guint32 next;

      D.24610 = *entry;
      D.24611 = (int) D.24610;
      D.24612 = D.24611 + -1;
      index = (guint32) D.24612;
      D.24613 = entry + 2;
      D.24614 = *D.24613;
      next = (guint32) D.24614;
      {
        size_t __s1_len;
        size_t __s2_len;

        D.24615 = index * 8;
        D.24616 = globals + D.24615;
        D.24617 = *D.24616;
        D.23073 = __builtin_strcmp (D.24617, symbol);
      }
      if (D.23073 == 0) goto <D.24618>; else goto <D.24619>;
      <D.24618>:
      global_index = (int) index;
      goto <D.23074>;
      <D.24619>:
      if (next != 0) goto <D.24620>; else goto <D.23074>;
      <D.24620>:
      D.24621 = next * 4;
      entry = table + D.24621;
    }
    <D.23076>:
    D.24610 = *entry;
    if (D.24610 != 0) goto <D.23075>; else goto <D.23074>;
    <D.23074>:
    if (global_index != -1) goto <D.24622>; else goto <D.24623>;
    <D.24622>:
    global_index.40 = (sizetype) global_index;
    D.24625 = global_index.40 * 8;
    D.24626 = D.24625 + 4;
    D.24627 = globals + D.24626;
    D.24628 = *D.24627;
    *value = D.24628;
    goto <D.24629>;
    <D.24623>:
    *value = 0B;
    <D.24629>:
    if (symbol != name) goto <D.24630>; else goto <D.24631>;
    <D.24630>:
    monoeg_g_free (symbol);
    <D.24631>:
  }
  goto <D.24632>;
  <D.24606>:
  {
    char * err;

    err = mono_dl_symbol (module, name, value);
    if (err != 0B) goto <D.24633>; else goto <D.24634>;
    <D.24633>:
    monoeg_g_free (err);
    <D.24634>:
  }
  <D.24632>:
}


memset (void * __dest, int __ch, size_t __len)
{
  int D.24637;
  int D.24642;
  void * D.24644;
  unsigned int D.24645;

  D.24637 = __builtin_constant_p (__len);
  if (D.24637 != 0) goto <D.24638>; else goto <D.24639>;
  <D.24638>:
  if (__len == 0) goto <D.24640>; else goto <D.24641>;
  <D.24640>:
  D.24642 = __builtin_constant_p (__ch);
  if (D.24642 == 0) goto <D.24635>; else goto <D.24643>;
  <D.24643>:
  if (__ch != 0) goto <D.24635>; else goto <D.24636>;
  <D.24635>:
  __warn_memset_zero_len ();
  D.24644 = __dest;
  return D.24644;
  <D.24636>:
  <D.24641>:
  <D.24639>:
  D.24645 = __builtin_object_size (__dest, 0);
  D.24644 = __builtin___memset_chk (__dest, __ch, __len, D.24645);
  return D.24644;
}


load_image (struct MonoAotModule * amodule, int index, gboolean set_error)
{
  unsigned int index.41;
  unsigned int D.24648;
  _Bool D.24649;
  long int D.24650;
  long int D.24651;
  struct MonoImage * * D.24654;
  unsigned int index.42;
  unsigned int D.24656;
  struct MonoImage * * D.24657;
  struct MonoImage * D.24658;
  struct MonoImage * D.24661;
  int D.24662;
  struct MonoAssemblyName * D.24665;
  unsigned int D.24666;
  struct MonoAssemblyName * D.24667;
  struct MonoAssembly * D.24668;
  char * D.24669;
  char * D.24672;
  const char * D.24673;
  int D.22684;
  struct MonoImage * D.24676;
  char * D.24677;
  char * * D.24678;
  char * * D.24679;
  char * D.24680;
  struct MonoAssembly * assembly;
  MonoImageOpenStatus status;

  try
    {
      index.41 = (unsigned int) index;
      D.24648 = amodule->image_table_len;
      D.24649 = index.41 >= D.24648;
      D.24650 = (long int) D.24649;
      D.24651 = __builtin_expect (D.24650, 0);
      if (D.24651 != 0) goto <D.24652>; else goto <D.24653>;
      <D.24652>:
      monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "aot-runtime.c", 223, "index < amodule->image_table_len");
      <D.24653>:
      D.24654 = amodule->image_table;
      index.42 = (unsigned int) index;
      D.24656 = index.42 * 4;
      D.24657 = D.24654 + D.24656;
      D.24658 = *D.24657;
      if (D.24658 != 0B) goto <D.24659>; else goto <D.24660>;
      <D.24659>:
      D.24654 = amodule->image_table;
      index.42 = (unsigned int) index;
      D.24656 = index.42 * 4;
      D.24657 = D.24654 + D.24656;
      D.24661 = *D.24657;
      return D.24661;
      <D.24660>:
      D.24662 = amodule->out_of_date;
      if (D.24662 != 0) goto <D.24663>; else goto <D.24664>;
      <D.24663>:
      D.24661 = 0B;
      return D.24661;
      <D.24664>:
      D.24665 = amodule->image_names;
      index.42 = (unsigned int) index;
      D.24666 = index.42 * 60;
      D.24667 = D.24665 + D.24666;
      D.24668 = amodule->assembly;
      D.24669 = D.24668->basedir;
      assembly = mono_assembly_load (D.24667, D.24669, &status);
      if (assembly == 0B) goto <D.24670>; else goto <D.24671>;
      <D.24670>:
      D.24672 = amodule->aot_name;
      D.24665 = amodule->image_names;
      index.42 = (unsigned int) index;
      D.24666 = index.42 * 60;
      D.24667 = D.24665 + D.24666;
      D.24673 = D.24667->name;
      mono_trace (64, 32, "AOT module %s is unusable because dependency %s is not found.\n", D.24672, D.24673);
      amodule->out_of_date = 1;
      if (set_error != 0) goto <D.24674>; else goto <D.24675>;
      <D.24674>:
      {
        char * full_name;

        D.24665 = amodule->image_names;
        index.42 = (unsigned int) index;
        D.24666 = index.42 * 60;
        D.24667 = D.24665 + D.24666;
        full_name = mono_stringify_assembly_name (D.24667);
        mono_loader_set_error_assembly_load (full_name, 0);
        monoeg_g_free (full_name);
      }
      <D.24675>:
      D.24661 = 0B;
      return D.24661;
      <D.24671>:
      {
        size_t __s1_len;
        size_t __s2_len;

        D.24676 = assembly->image;
        D.24677 = D.24676->guid;
        D.24678 = amodule->image_guids;
        index.42 = (unsigned int) index;
        D.24656 = index.42 * 4;
        D.24679 = D.24678 + D.24656;
        D.24680 = *D.24679;
        D.22684 = __builtin_strcmp (D.24677, D.24680);
      }
      if (D.22684 != 0) goto <D.24681>; else goto <D.24682>;
      <D.24681>:
      D.24672 = amodule->aot_name;
      D.24665 = amodule->image_names;
      index.42 = (unsigned int) index;
      D.24666 = index.42 * 60;
      D.24667 = D.24665 + D.24666;
      D.24673 = D.24667->name;
      D.24678 = amodule->image_guids;
      index.42 = (unsigned int) index;
      D.24656 = index.42 * 4;
      D.24679 = D.24678 + D.24656;
      D.24680 = *D.24679;
      D.24676 = assembly->image;
      D.24677 = D.24676->guid;
      mono_trace (64, 32, "AOT module %s is unusable (GUID of dependent assembly %s doesn\'t match (expected \'%s\', got \'%s\').\n", D.24672, D.24673, D.24680, D.24677);
      amodule->out_of_date = 1;
      D.24661 = 0B;
      return D.24661;
      <D.24682>:
      D.24654 = amodule->image_table;
      index.42 = (unsigned int) index;
      D.24656 = index.42 * 4;
      D.24657 = D.24654 + D.24656;
      D.24676 = assembly->image;
      *D.24657 = D.24676;
      D.24661 = assembly->image;
      return D.24661;
    }
  finally
    {
      status = {CLOBBER};
    }
}


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

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


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

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


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

  aot_jit_icall_hash.43 = aot_jit_icall_hash;
  if (aot_jit_icall_hash.43 != 0B) goto <D.24690>; else goto <D.24691>;
  <D.24690>:
  aot_jit_icall_hash.43 = aot_jit_icall_hash;
  monoeg_g_hash_table_destroy (aot_jit_icall_hash.43);
  <D.24691>:
  aot_modules.44 = aot_modules;
  if (aot_modules.44 != 0B) goto <D.24693>; else goto <D.24694>;
  <D.24693>:
  aot_modules.44 = aot_modules;
  monoeg_g_hash_table_destroy (aot_modules.44);
  <D.24694>:
}


mono_aot_get_method_from_vt_slot (struct MonoDomain * domain, struct MonoVTable * vtable, int slot)
{
  struct MonoImage * D.24695;
  unsigned int D.24698;
  unsigned int D.24699;
  unsigned char D.24701;
  unsigned char D.24704;
  void * D.24706;
  guint8 * D.24707;
  guint32 * D.24708;
  unsigned int D.24709;
  unsigned int D.24710;
  unsigned int D.24711;
  int D.24712;
  unsigned int D.24713;
  guint8 * p.45;
  int D.24719;
  unsigned int D.24724;
  unsigned int D.24725;
  unsigned int D.24727;
  struct MonoImage * D.24728;
  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.24695 = klass->image;
      amodule = D.24695->aot_module;
      D.24698 = klass->flags;
      D.24699 = D.24698 & 32;
      if (D.24699 != 0) goto <D.24696>; else goto <D.24700>;
      <D.24700>:
      D.24701 = klass->byval_arg.type;
      if (D.24701 == 19) goto <D.24696>; else goto <D.24702>;
      <D.24702>:
      D.24701 = klass->byval_arg.type;
      if (D.24701 == 30) goto <D.24696>; else goto <D.24703>;
      <D.24703>:
      D.24704 = klass->rank;
      if (D.24704 != 0) goto <D.24696>; else goto <D.24705>;
      <D.24705>:
      if (amodule == 0B) goto <D.24696>; else goto <D.24697>;
      <D.24696>:
      D.24706 = 0B;
      return D.24706;
      <D.24697>:
      D.24707 = amodule->blob;
      D.24708 = amodule->class_info_offsets;
      D.24709 = klass->type_token;
      D.24710 = D.24709 & 16777215;
      D.24711 = D.24710 + 4294967295;
      D.24712 = (int) D.24711;
      D.24713 = mono_aot_get_offset (D.24708, D.24712);
      info = D.24707 + D.24713;
      p = info;
      p.45 = p;
      err = decode_cached_class_info (amodule, &class_info, p.45, &p);
      if (err == 0) goto <D.24715>; else goto <D.24716>;
      <D.24715>:
      D.24706 = 0B;
      return D.24706;
      <D.24716>:
      i = 0;
      goto <D.23203>;
      <D.23202>:
      p.45 = p;
      decode_method_ref (amodule, &ref, p.45, &p);
      i = i + 1;
      <D.23203>:
      if (i < slot) goto <D.23202>; else goto <D.23204>;
      <D.23204>:
      p.45 = p;
      res = decode_method_ref (amodule, &ref, p.45, &p);
      if (res == 0) goto <D.24717>; else goto <D.24718>;
      <D.24717>:
      D.24706 = 0B;
      return D.24706;
      <D.24718>:
      D.24719 = ref.no_aot_trampoline;
      if (D.24719 != 0) goto <D.24720>; else goto <D.24721>;
      <D.24720>:
      D.24706 = 0B;
      return D.24706;
      <D.24721>:
      D.24724 = ref.token;
      D.24725 = D.24724 & 16777215;
      if (D.24725 == 0) goto <D.24722>; else goto <D.24726>;
      <D.24726>:
      D.24724 = ref.token;
      D.24727 = D.24724 >> 24;
      if (D.24727 != 6) goto <D.24722>; else goto <D.24723>;
      <D.24722>:
      D.24706 = 0B;
      return D.24706;
      <D.24723>:
      D.24728 = ref.image;
      D.24724 = ref.token;
      D.24706 = mono_aot_get_method_from_token (domain, D.24728, D.24724);
      return D.24706;
    }
  finally
    {
      p = {CLOBBER};
      class_info = {CLOBBER};
      ref = {CLOBBER};
    }
}


mono_aot_get_offset (guint32 * table, int index)
{
  unsigned int D.24731;
  guint32 * D.24732;
  unsigned int D.24733;
  guint32 * D.24734;
  unsigned int D.24735;
  guint32 * D.24736;
  unsigned int D.24737;
  unsigned int ngroups.46;
  unsigned int D.24741;
  unsigned int group.47;
  unsigned int D.24743;
  guint16 * D.24744;
  short unsigned int D.24745;
  sizetype D.24746;
  guint8 * p.48;
  unsigned int D.24749;
  unsigned int D.24750;
  guint32 * D.24751;
  unsigned int D.24752;
  guint8 * p.49;
  guint8 * p.50;
  int D.24755;
  int D.24756;
  guint32 D.24757;
  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.24731 = *table;
      noffsets = (int) D.24731;
      D.24732 = table + 4;
      D.24733 = *D.24732;
      group_size = (int) D.24733;
      D.24734 = table + 8;
      D.24735 = *D.24734;
      ngroups = (int) D.24735;
      D.24736 = table + 12;
      D.24737 = *D.24736;
      index_entry_size = (int) D.24737;
      group = index / group_size;
      if (index_entry_size == 2) goto <D.24738>; else goto <D.24739>;
      <D.24738>:
      index16 = table + 16;
      ngroups.46 = (unsigned int) ngroups;
      D.24741 = ngroups.46 * 2;
      data_start = index16 + D.24741;
      group.47 = (unsigned int) group;
      D.24743 = group.47 * 2;
      D.24744 = index16 + D.24743;
      D.24745 = *D.24744;
      D.24746 = (sizetype) D.24745;
      p.48 = data_start + D.24746;
      p = p.48;
      goto <D.24748>;
      <D.24739>:
      index32 = table + 16;
      ngroups.46 = (unsigned int) ngroups;
      D.24749 = ngroups.46 * 4;
      data_start = index32 + D.24749;
      group.47 = (unsigned int) group;
      D.24750 = group.47 * 4;
      D.24751 = index32 + D.24750;
      D.24752 = *D.24751;
      p.49 = data_start + D.24752;
      p = p.49;
      <D.24748>:
      p.50 = p;
      start_offset = decode_value (p.50, &p);
      offset = start_offset;
      D.24755 = group * group_size;
      i = D.24755 + 1;
      goto <D.22708>;
      <D.22707>:
      p.50 = p;
      D.24756 = decode_value (p.50, &p);
      offset = D.24756 + offset;
      i = i + 1;
      <D.22708>:
      if (i <= index) goto <D.22707>; else goto <D.22709>;
      <D.22709>:
      D.24757 = (guint32) offset;
      return D.24757;
    }
  finally
    {
      p = {CLOBBER};
    }
}


decode_value (guint8 * ptr, guint8 * * rptr)
{
  signed char b.51;
  int D.24764;
  int D.24765;
  int D.24768;
  int D.24769;
  guint8 * D.24770;
  unsigned char D.24771;
  int D.24772;
  int D.24776;
  int D.24777;
  int D.24778;
  int D.24779;
  guint8 * D.24780;
  unsigned char D.24781;
  int D.24782;
  int D.24783;
  int D.24784;
  guint8 * D.24785;
  unsigned char D.24786;
  int D.24787;
  int D.24789;
  int D.24790;
  int D.24791;
  int D.24792;
  int D.24793;
  guint8 * D.24794;
  unsigned char D.24795;
  int D.24796;
  gint32 D.24799;
  guint8 b;
  gint32 len;

  b = *ptr;
  b.51 = (signed char) b;
  if (b.51 >= 0) goto <D.24761>; else goto <D.24762>;
  <D.24761>:
  len = (gint32) b;
  ptr = ptr + 1;
  goto <D.24763>;
  <D.24762>:
  D.24764 = (int) b;
  D.24765 = D.24764 & 64;
  if (D.24765 == 0) goto <D.24766>; else goto <D.24767>;
  <D.24766>:
  D.24764 = (int) b;
  D.24768 = D.24764 & 63;
  D.24769 = D.24768 << 8;
  D.24770 = ptr + 1;
  D.24771 = *D.24770;
  D.24772 = (int) D.24771;
  len = D.24769 | D.24772;
  ptr = ptr + 2;
  goto <D.24773>;
  <D.24767>:
  if (b != 255) goto <D.24774>; else goto <D.24775>;
  <D.24774>:
  D.24764 = (int) b;
  D.24776 = D.24764 & 31;
  D.24777 = D.24776 << 24;
  D.24770 = ptr + 1;
  D.24771 = *D.24770;
  D.24772 = (int) D.24771;
  D.24778 = D.24772 << 16;
  D.24779 = D.24777 | D.24778;
  D.24780 = ptr + 2;
  D.24781 = *D.24780;
  D.24782 = (int) D.24781;
  D.24783 = D.24782 << 8;
  D.24784 = D.24779 | D.24783;
  D.24785 = ptr + 3;
  D.24786 = *D.24785;
  D.24787 = (int) D.24786;
  len = D.24784 | D.24787;
  ptr = ptr + 4;
  goto <D.24788>;
  <D.24775>:
  D.24770 = ptr + 1;
  D.24771 = *D.24770;
  D.24772 = (int) D.24771;
  D.24789 = D.24772 << 24;
  D.24780 = ptr + 2;
  D.24781 = *D.24780;
  D.24782 = (int) D.24781;
  D.24790 = D.24782 << 16;
  D.24791 = D.24789 | D.24790;
  D.24785 = ptr + 3;
  D.24786 = *D.24785;
  D.24787 = (int) D.24786;
  D.24792 = D.24787 << 8;
  D.24793 = D.24791 | D.24792;
  D.24794 = ptr + 4;
  D.24795 = *D.24794;
  D.24796 = (int) D.24795;
  len = D.24793 | D.24796;
  ptr = ptr + 5;
  <D.24788>:
  <D.24773>:
  <D.24763>:
  if (rptr != 0B) goto <D.24797>; else goto <D.24798>;
  <D.24797>:
  *rptr = ptr;
  <D.24798>:
  D.24799 = len;
  return D.24799;
}


decode_cached_class_info (struct MonoAotModule * module, struct MonoCachedClassInfo * info, guint8 * buf, guint8 * * endbuf)
{
  guint8 * buf.52;
  int D.24802;
  unsigned int D.24803;
  unsigned int D.24804;
  gboolean D.24807;
  int D.24808;
  unsigned char D.24809;
  <unnamed-unsigned:1> D.24810;
  unsigned int D.24811;
  unsigned char D.24812;
  <unnamed-unsigned:1> D.24813;
  unsigned int D.24814;
  unsigned char D.24815;
  <unnamed-unsigned:1> D.24816;
  unsigned int D.24817;
  unsigned char D.24818;
  <unnamed-unsigned:1> D.24819;
  unsigned int D.24820;
  unsigned char D.24821;
  <unnamed-unsigned:1> D.24822;
  unsigned int D.24823;
  unsigned char D.24824;
  <unnamed-unsigned:1> D.24825;
  unsigned int D.24826;
  unsigned char D.24827;
  <unnamed-unsigned:1> D.24828;
  unsigned int D.24829;
  unsigned char D.24830;
  <unnamed-unsigned:1> D.24831;
  unsigned int D.24832;
  unsigned char D.24833;
  <unnamed-unsigned:1> D.24834;
  unsigned int D.24835;
  unsigned int D.24836;
  unsigned int D.24841;
  unsigned int D.24842;
  struct MonoImage * D.24847;
  int D.24848;
  unsigned int D.24849;
  int D.24850;
  unsigned int D.24851;
  int D.24852;
  unsigned int D.24853;
  int D.24854;
  unsigned int D.24855;
  guint32 flags;
  struct MethodRef ref;
  gboolean res;

  try
    {
      buf.52 = buf;
      D.24802 = decode_value (buf.52, &buf);
      D.24803 = (unsigned int) D.24802;
      info->vtable_size = D.24803;
      D.24804 = info->vtable_size;
      if (D.24804 == 4294967295) goto <D.24805>; else goto <D.24806>;
      <D.24805>:
      D.24807 = 0;
      return D.24807;
      <D.24806>:
      buf.52 = buf;
      D.24808 = decode_value (buf.52, &buf);
      flags = (guint32) D.24808;
      D.24809 = (unsigned char) flags;
      D.24810 = (<unnamed-unsigned:1>) D.24809;
      info->ghcimpl = D.24810;
      D.24811 = flags >> 1;
      D.24812 = (unsigned char) D.24811;
      D.24813 = (<unnamed-unsigned:1>) D.24812;
      info->has_finalize = D.24813;
      D.24814 = flags >> 2;
      D.24815 = (unsigned char) D.24814;
      D.24816 = (<unnamed-unsigned:1>) D.24815;
      info->has_cctor = D.24816;
      D.24817 = flags >> 3;
      D.24818 = (unsigned char) D.24817;
      D.24819 = (<unnamed-unsigned:1>) D.24818;
      info->has_nested_classes = D.24819;
      D.24820 = flags >> 4;
      D.24821 = (unsigned char) D.24820;
      D.24822 = (<unnamed-unsigned:1>) D.24821;
      info->blittable = D.24822;
      D.24823 = flags >> 5;
      D.24824 = (unsigned char) D.24823;
      D.24825 = (<unnamed-unsigned:1>) D.24824;
      info->has_references = D.24825;
      D.24826 = flags >> 6;
      D.24827 = (unsigned char) D.24826;
      D.24828 = (<unnamed-unsigned:1>) D.24827;
      info->has_static_refs = D.24828;
      D.24829 = flags >> 7;
      D.24830 = (unsigned char) D.24829;
      D.24831 = (<unnamed-unsigned:1>) D.24830;
      info->no_special_static_fields = D.24831;
      D.24832 = flags >> 8;
      D.24833 = (unsigned char) D.24832;
      D.24834 = (<unnamed-unsigned:1>) D.24833;
      info->is_generic_container = D.24834;
      D.24835 = BIT_FIELD_REF <*info, 32, 32>;
      D.24836 = D.24835 & 4;
      if (D.24836 != 0) goto <D.24837>; else goto <D.24838>;
      <D.24837>:
      buf.52 = buf;
      res = decode_method_ref (module, &ref, buf.52, &buf);
      if (res == 0) goto <D.24839>; else goto <D.24840>;
      <D.24839>:
      D.24807 = 0;
      return D.24807;
      <D.24840>:
      D.24841 = ref.token;
      info->cctor_token = D.24841;
      <D.24838>:
      D.24835 = BIT_FIELD_REF <*info, 32, 32>;
      D.24842 = D.24835 & 1;
      if (D.24842 != 0) goto <D.24843>; else goto <D.24844>;
      <D.24843>:
      buf.52 = buf;
      res = decode_method_ref (module, &ref, buf.52, &buf);
      if (res == 0) goto <D.24845>; else goto <D.24846>;
      <D.24845>:
      D.24807 = 0;
      return D.24807;
      <D.24846>:
      D.24847 = ref.image;
      info->finalize_image = D.24847;
      D.24841 = ref.token;
      info->finalize_token = D.24841;
      <D.24844>:
      buf.52 = buf;
      D.24848 = decode_value (buf.52, &buf);
      D.24849 = (unsigned int) D.24848;
      info->instance_size = D.24849;
      buf.52 = buf;
      D.24850 = decode_value (buf.52, &buf);
      D.24851 = (unsigned int) D.24850;
      info->class_size = D.24851;
      buf.52 = buf;
      D.24852 = decode_value (buf.52, &buf);
      D.24853 = (unsigned int) D.24852;
      info->packing_size = D.24853;
      buf.52 = buf;
      D.24854 = decode_value (buf.52, &buf);
      D.24855 = (unsigned int) D.24854;
      info->min_align = D.24855;
      buf.52 = buf;
      *endbuf = buf.52;
      D.24807 = 1;
      return D.24807;
    }
  finally
    {
      ref = {CLOBBER};
    }
}


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

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


decode_method_ref_with_target (struct MonoAotModule * module, struct MethodRef * ref, struct MonoMethod * target, guint8 * buf, guint8 * * endbuf)
{
  guint8 * p.53;
  int D.24861;
  int D.24864;
  unsigned int D.24871;
  unsigned int D.24872;
  gboolean D.24875;
  int D.24878;
  <unnamed-unsigned:5> D.24881;
  unsigned int D.24882;
  struct MonoClass * D.24887;
  struct MonoMethod * D.24888;
  struct MonoMethod * D.24891;
  struct MonoType * D.24896;
  struct MonoMethod * D.24897;
  struct MonoMethod * D.24901;
  struct MonoMethod * D.24905;
  struct MonoMethod * D.24909;
  struct MonoMethod * D.24911;
  struct MonoMethod * D.24912;
  struct MonoMethod * D.24913;
  struct MonoMethod * D.24914;
  _Bool D.24915;
  long int D.24916;
  long int D.24917;
  struct MonoMethod * D.24920;
  struct MonoMethod * D.24923;
  _Bool D.24931;
  long int D.24932;
  long int D.24933;
  <unnamed type> D.24938;
  unsigned int subtype.54;
  int D.24941;
  struct MonoMethod * D.24947;
  unsigned int subtype.55;
  unsigned int D.24949;
  struct MonoClass * D.24956;
  int D.22927;
  int iftmp.56;
  int D.22926;
  const char[15] * D.24964;
  unsigned char D.24965;
  int D.24966;
  unsigned char D.24967;
  int D.24968;
  const unsigned char * D.24973;
  unsigned char D.24974;
  int D.24975;
  const unsigned char * D.24976;
  unsigned char D.24977;
  int D.24978;
  const unsigned char * D.24983;
  unsigned char D.24984;
  int D.24985;
  const unsigned char * D.24986;
  unsigned char D.24987;
  int D.24988;
  const unsigned char * D.24993;
  unsigned char D.24994;
  int D.24995;
  const unsigned char * D.24996;
  unsigned char D.24997;
  int D.24998;
  const char * D.25000;
  struct MonoMethod * D.25003;
  int D.22936;
  int iftmp.57;
  int D.22935;
  const char[15] * D.25008;
  unsigned char D.25009;
  int D.25010;
  unsigned char D.25011;
  int D.25012;
  const unsigned char * D.25017;
  unsigned char D.25018;
  int D.25019;
  const unsigned char * D.25020;
  unsigned char D.25021;
  int D.25022;
  const unsigned char * D.25027;
  unsigned char D.25028;
  int D.25029;
  const unsigned char * D.25030;
  unsigned char D.25031;
  int D.25032;
  const unsigned char * D.25037;
  unsigned char D.25038;
  int D.25039;
  const unsigned char * D.25040;
  unsigned char D.25041;
  int D.25042;
  struct MonoMethod * D.25046;
  struct MonoMethod * D.25052;
  struct MonoMethod * D.25058;
  struct MonoMethod * D.25062;
  struct MonoMethod * D.25066;
  struct MonoClass * D.25077;
  _Bool D.25078;
  long int D.25079;
  long int D.25080;
  struct MonoMethod * D.25083;
  struct MonoMethod * D.25086;
  _Bool D.25094;
  long int D.25095;
  long int D.25096;
  <unnamed type> D.25102;
  unsigned int subtype.58;
  struct MonoMethod * D.25105;
  int D.22957;
  struct MonoMethod * D.25118;
  struct MonoMethod * D.25124;
  struct MonoMethod * D.25128;
  int D.22970;
  int iftmp.59;
  int D.22969;
  const char[23] * D.25137;
  unsigned char D.25138;
  int D.25139;
  unsigned char D.25140;
  int D.25141;
  const unsigned char * D.25146;
  unsigned char D.25147;
  int D.25148;
  const unsigned char * D.25149;
  unsigned char D.25150;
  int D.25151;
  const unsigned char * D.25156;
  unsigned char D.25157;
  int D.25158;
  const unsigned char * D.25159;
  unsigned char D.25160;
  int D.25161;
  const unsigned char * D.25166;
  unsigned char D.25167;
  int D.25168;
  const unsigned char * D.25169;
  unsigned char D.25170;
  int D.25171;
  struct MonoMethod * D.25180;
  struct MonoMethod * D.25186;
  _Bool D.25188;
  long int D.25189;
  long int D.25190;
  <unnamed type> D.25193;
  unsigned int subtype.60;
  struct MonoMethodSignature * D.25197;
  _Bool D.25198;
  long int D.25199;
  long int D.25200;
  int D.25203;
  int D.25220;
  <unnamed type> D.25223;
  int D.25229;
  struct MonoMethod * D.25237;
  int D.25241;
  int D.25242;
  unsigned int D.25243;
  int image_index.61;
  int D.25256;
  int D.25257;
  unsigned int D.25258;
  unsigned int D.25261;
  struct MonoMethod * D.25262;
  struct MonoGenericClass * D.25267;
  struct MonoGenericInst * D.25268;
  struct MonoMethod * D.25269;
  int D.25270;
  struct MonoMethod * D.25273;
  unsigned char D.25279;
  int D.25280;
  struct MonoMethod * D.25281;
  int D.25282;
  struct MonoMethod * D.25283;
  struct MonoMethod * D.25284;
  struct MonoMethod * D.25285;
  struct MonoMethod * D.25286;
  int D.25290;
  int D.25291;
  unsigned int D.25292;
  unsigned int D.25293;
  guint32 image_index;
  guint32 value;
  struct MonoImage * image;
  guint8 * p;

  try
    {
      image = 0B;
      p = buf;
      memset (ref, 0, 16);
      p.53 = p;
      D.24861 = decode_value (p.53, &p);
      value = (guint32) D.24861;
      image_index = value >> 24;
      if (image_index == 251) goto <D.24862>; else goto <D.24863>;
      <D.24862>:
      ref->no_aot_trampoline = 1;
      p.53 = p;
      D.24864 = decode_value (p.53, &p);
      value = (guint32) D.24864;
      image_index = value >> 24;
      <D.24863>:
      if (image_index <= 239) goto <D.24865>; else goto <D.24867>;
      <D.24867>:
      if (image_index == 254) goto <D.24865>; else goto <D.24868>;
      <D.24868>:
      if (image_index == 253) goto <D.24865>; else goto <D.24866>;
      <D.24865>:
      if (target != 0B) goto <D.24869>; else goto <D.24870>;
      <D.24869>:
      D.24871 = BIT_FIELD_REF <*target, 32, 160>;
      D.24872 = D.24871 & 124;
      if (D.24872 != 0) goto <D.24873>; else goto <D.24874>;
      <D.24873>:
      D.24875 = 0;
      return D.24875;
      <D.24874>:
      <D.24870>:
      <D.24866>:
      if (image_index == 252) goto <D.24876>; else goto <D.24877>;
      <D.24876>:
      {
        guint32 wrapper_type;

        p.53 = p;
        D.24878 = decode_value (p.53, &p);
        wrapper_type = (guint32) D.24878;
        if (target != 0B) goto <D.24879>; else goto <D.24880>;
        <D.24879>:
        D.24881 = target->wrapper_type;
        D.24882 = (unsigned int) D.24881;
        if (D.24882 != wrapper_type) goto <D.24883>; else goto <D.24884>;
        <D.24883>:
        D.24875 = 0;
        return D.24875;
        <D.24884>:
        <D.24880>:
        image = mono_defaults.corlib;
        switch (wrapper_type) <default: <D.22992>, case 1: <D.22975>, case 2: <D.22976>, case 3: <D.22977>, case 4: <D.22960>, case 5: <D.22989>, case 6: <D.22945>, case 7: <D.22939>, case 9: <D.22893>, case 12: <D.22898>, case 13: <D.22900>, case 14: <D.22903>, case 15: <D.22904>, case 16: <D.22912>, case 18: <D.22901>, case 19: <D.22958>, case 20: <D.22896>, case 21: <D.22908>, case 23: <D.22899>, case 24: <D.22907>, case 25: <D.22914>, case 28: <D.22905>>
        <D.22893>:
        {
          struct MonoMethod * m;

          p.53 = p;
          m = decode_resolve_method_ref (module, p.53, &p);
          if (m == 0B) goto <D.24885>; else goto <D.24886>;
          <D.24885>:
          D.24875 = 0;
          return D.24875;
          <D.24886>:
          D.24887 = m->klass;
          mono_class_init (D.24887);
          D.24888 = mono_marshal_get_remoting_invoke_with_check (m);
          ref->method = D.24888;
          goto <D.22895>;
        }
        <D.22896>:
        {
          struct MonoClass * klass;

          p.53 = p;
          klass = decode_klass_ref (module, p.53, &p);
          if (klass == 0B) goto <D.24889>; else goto <D.24890>;
          <D.24889>:
          D.24875 = 0;
          return D.24875;
          <D.24890>:
          D.24891 = mono_marshal_get_proxy_cancast (klass);
          ref->method = D.24891;
          goto <D.22895>;
        }
        <D.22898>:
        <D.22899>:
        <D.22900>:
        <D.22901>:
        {
          struct MonoClass * klass;

          p.53 = p;
          klass = decode_klass_ref (module, p.53, &p);
          if (klass == 0B) goto <D.24892>; else goto <D.24893>;
          <D.24892>:
          D.24875 = 0;
          return D.24875;
          <D.24893>:
          if (wrapper_type == 12) goto <D.24894>; else goto <D.24895>;
          <D.24894>:
          D.24896 = &klass->byval_arg;
          D.24897 = mono_marshal_get_ldfld_wrapper (D.24896);
          ref->method = D.24897;
          goto <D.24898>;
          <D.24895>:
          if (wrapper_type == 23) goto <D.24899>; else goto <D.24900>;
          <D.24899>:
          D.24896 = &klass->byval_arg;
          D.24901 = mono_marshal_get_ldflda_wrapper (D.24896);
          ref->method = D.24901;
          goto <D.24902>;
          <D.24900>:
          if (wrapper_type == 13) goto <D.24903>; else goto <D.24904>;
          <D.24903>:
          D.24896 = &klass->byval_arg;
          D.24905 = mono_marshal_get_stfld_wrapper (D.24896);
          ref->method = D.24905;
          goto <D.24906>;
          <D.24904>:
          if (wrapper_type == 18) goto <D.24907>; else goto <D.24908>;
          <D.24907>:
          D.24909 = mono_marshal_get_isinst (klass);
          ref->method = D.24909;
          goto <D.24910>;
          <D.24908>:
          monoeg_assertion_message ("* Assertion: should not be reached at %s:%d\n", "aot-runtime.c", 831);
          <D.24910>:
          <D.24906>:
          <D.24902>:
          <D.24898>:
          goto <D.22895>;
        }
        <D.22903>:
        D.24911 = mono_marshal_get_ldfld_remote_wrapper (0B);
        ref->method = D.24911;
        goto <D.22895>;
        <D.22904>:
        D.24912 = mono_marshal_get_stfld_remote_wrapper (0B);
        ref->method = D.24912;
        goto <D.22895>;
        <D.22905>:
        {
          int atype;

          p.53 = p;
          atype = decode_value (p.53, &p);
          D.24913 = mono_gc_get_managed_allocator_by_type (atype);
          ref->method = D.24913;
          D.24914 = ref->method;
          D.24915 = D.24914 == 0B;
          D.24916 = (long int) D.24915;
          D.24917 = __builtin_expect (D.24916, 0);
          if (D.24917 != 0) goto <D.24918>; else goto <D.24919>;
          <D.24918>:
          monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "aot-runtime.c", 845, "ref->method");
          <D.24919>:
          goto <D.22895>;
        }
        <D.22907>:
        D.24920 = mono_gc_get_write_barrier ();
        ref->method = D.24920;
        goto <D.22895>;
        <D.22908>:
        {
          int subtype;

          p.53 = p;
          subtype = decode_value (p.53, &p);
          if (subtype == 0) goto <D.24921>; else goto <D.24922>;
          <D.24921>:
          D.24923 = mono_marshal_get_stelemref ();
          ref->method = D.24923;
          goto <D.24924>;
          <D.24922>:
          if (subtype == 3) goto <D.24925>; else goto <D.24926>;
          <D.24925>:
          {
            int kind;
            struct WrapperInfo * info;

            p.53 = p;
            kind = decode_value (p.53, &p);
            if (target == 0B) goto <D.24927>; else goto <D.24928>;
            <D.24927>:
            D.24875 = 0;
            return D.24875;
            <D.24928>:
            D.24871 = BIT_FIELD_REF <*target, 32, 160>;
            D.24872 = D.24871 & 124;
            if (D.24872 == 84) goto <D.24929>; else goto <D.24930>;
            <D.24929>:
            info = mono_marshal_get_wrapper_info (target);
            D.24931 = info == 0B;
            D.24932 = (long int) D.24931;
            D.24933 = __builtin_expect (D.24932, 0);
            if (D.24933 != 0) goto <D.24934>; else goto <D.24935>;
            <D.24934>:
            monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "aot-runtime.c", 868, "info");
            <D.24935>:
            D.24938 = info->subtype;
            subtype.54 = (unsigned int) subtype;
            if (D.24938 == subtype.54) goto <D.24940>; else goto <D.24936>;
            <D.24940>:
            D.24941 = info->d.virtual_stelemref.kind;
            if (D.24941 == kind) goto <D.24942>; else goto <D.24936>;
            <D.24942>:
            ref->method = target;
            goto <D.24937>;
            <D.24936>:
            D.24875 = 0;
            return D.24875;
            <D.24937>:
            goto <D.24943>;
            <D.24930>:
            D.24875 = 0;
            return D.24875;
            <D.24943>:
          }
          goto <D.24944>;
          <D.24926>:
          monoeg_assertion_message ("* Assertion: should not be reached at %s:%d\n", "aot-runtime.c", 877);
          <D.24944>:
          <D.24924>:
          goto <D.22895>;
        }
        <D.22912>:
        {
          struct MonoMethod * m;

          p.53 = p;
          m = decode_resolve_method_ref (module, p.53, &p);
          if (m == 0B) goto <D.24945>; else goto <D.24946>;
          <D.24945>:
          D.24875 = 0;
          return D.24875;
          <D.24946>:
          D.24947 = mono_marshal_get_synchronized_wrapper (m);
          ref->method = D.24947;
          goto <D.22895>;
        }
        <D.22914>:
        {
          struct MonoMethodDesc * desc;
          struct MonoMethod * orig_method;
          int subtype;

          p.53 = p;
          subtype = decode_value (p.53, &p);
          subtype.55 = (unsigned int) subtype;
          D.24949 = subtype.55 + 4294967289;
          if (D.24949 <= 1) goto <D.24950>; else goto <D.24951>;
          <D.24950>:
          {
            struct MonoClass * klass;

            p.53 = p;
            klass = decode_klass_ref (module, p.53, &p);
            if (klass == 0B) goto <D.24952>; else goto <D.24953>;
            <D.24952>:
            D.24875 = 0;
            return D.24875;
            <D.24953>:
            if (target == 0B) goto <D.24954>; else goto <D.24955>;
            <D.24954>:
            D.24875 = 0;
            return D.24875;
            <D.24955>:
            D.24956 = target->klass;
            if (D.24956 != klass) goto <D.24957>; else goto <D.24958>;
            <D.24957>:
            D.24875 = 0;
            return D.24875;
            <D.24958>:
            if (subtype == 7) goto <D.24959>; else goto <D.24960>;
            <D.24959>:
            {
              size_t __s1_len;
              size_t __s2_len;

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

                __s2 = target->name;
                D.24964 = "PtrToStructure";
                D.24965 = MEM[(const unsigned char *)D.24964];
                D.24966 = (int) D.24965;
                D.24967 = *__s2;
                D.24968 = (int) D.24967;
                __result = D.24966 - D.24968;
                {
                  if (__s2_len != 0) goto <D.24969>; else goto <D.24970>;
                  <D.24969>:
                  if (__result == 0) goto <D.24971>; else goto <D.24972>;
                  <D.24971>:
                  D.24973 = &MEM[(void *)"PtrToStructure" + 1B];
                  D.24974 = *D.24973;
                  D.24975 = (int) D.24974;
                  D.24976 = __s2 + 1;
                  D.24977 = *D.24976;
                  D.24978 = (int) D.24977;
                  __result = D.24975 - D.24978;
                  if (__s2_len > 1) goto <D.24979>; else goto <D.24980>;
                  <D.24979>:
                  if (__result == 0) goto <D.24981>; else goto <D.24982>;
                  <D.24981>:
                  D.24983 = &MEM[(void *)"PtrToStructure" + 2B];
                  D.24984 = *D.24983;
                  D.24985 = (int) D.24984;
                  D.24986 = __s2 + 2;
                  D.24987 = *D.24986;
                  D.24988 = (int) D.24987;
                  __result = D.24985 - D.24988;
                  if (__s2_len > 2) goto <D.24989>; else goto <D.24990>;
                  <D.24989>:
                  if (__result == 0) goto <D.24991>; else goto <D.24992>;
                  <D.24991>:
                  D.24993 = &MEM[(void *)"PtrToStructure" + 3B];
                  D.24994 = *D.24993;
                  D.24995 = (int) D.24994;
                  D.24996 = __s2 + 3;
                  D.24997 = *D.24996;
                  D.24998 = (int) D.24997;
                  __result = D.24995 - D.24998;
                  <D.24992>:
                  <D.24990>:
                  <D.24982>:
                  <D.24980>:
                  <D.24972>:
                  <D.24970>:
                }
                D.22926 = __result;
              }
              iftmp.56 = -D.22926;
              goto <D.24999>;
              <D.24963>:
              D.25000 = target->name;
              iftmp.56 = __builtin_strcmp (D.25000, "PtrToStructure");
              <D.24999>:
              D.22927 = iftmp.56;
            }
            if (D.22927 != 0) goto <D.25001>; else goto <D.25002>;
            <D.25001>:
            D.24875 = 0;
            return D.24875;
            <D.25002>:
            D.25003 = mono_marshal_get_ptr_to_struct (klass);
            ref->method = D.25003;
            goto <D.25004>;
            <D.24960>:
            {
              size_t __s1_len;
              size_t __s2_len;

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

                __s2 = target->name;
                D.25008 = "StructureToPtr";
                D.25009 = MEM[(const unsigned char *)D.25008];
                D.25010 = (int) D.25009;
                D.25011 = *__s2;
                D.25012 = (int) D.25011;
                __result = D.25010 - D.25012;
                {
                  if (__s2_len != 0) goto <D.25013>; else goto <D.25014>;
                  <D.25013>:
                  if (__result == 0) goto <D.25015>; else goto <D.25016>;
                  <D.25015>:
                  D.25017 = &MEM[(void *)"StructureToPtr" + 1B];
                  D.25018 = *D.25017;
                  D.25019 = (int) D.25018;
                  D.25020 = __s2 + 1;
                  D.25021 = *D.25020;
                  D.25022 = (int) D.25021;
                  __result = D.25019 - D.25022;
                  if (__s2_len > 1) goto <D.25023>; else goto <D.25024>;
                  <D.25023>:
                  if (__result == 0) goto <D.25025>; else goto <D.25026>;
                  <D.25025>:
                  D.25027 = &MEM[(void *)"StructureToPtr" + 2B];
                  D.25028 = *D.25027;
                  D.25029 = (int) D.25028;
                  D.25030 = __s2 + 2;
                  D.25031 = *D.25030;
                  D.25032 = (int) D.25031;
                  __result = D.25029 - D.25032;
                  if (__s2_len > 2) goto <D.25033>; else goto <D.25034>;
                  <D.25033>:
                  if (__result == 0) goto <D.25035>; else goto <D.25036>;
                  <D.25035>:
                  D.25037 = &MEM[(void *)"StructureToPtr" + 3B];
                  D.25038 = *D.25037;
                  D.25039 = (int) D.25038;
                  D.25040 = __s2 + 3;
                  D.25041 = *D.25040;
                  D.25042 = (int) D.25041;
                  __result = D.25039 - D.25042;
                  <D.25036>:
                  <D.25034>:
                  <D.25026>:
                  <D.25024>:
                  <D.25016>:
                  <D.25014>:
                }
                D.22935 = __result;
              }
              iftmp.57 = -D.22935;
              goto <D.25043>;
              <D.25007>:
              D.25000 = target->name;
              iftmp.57 = __builtin_strcmp (D.25000, "StructureToPtr");
              <D.25043>:
              D.22936 = iftmp.57;
            }
            if (D.22936 != 0) goto <D.25044>; else goto <D.25045>;
            <D.25044>:
            D.24875 = 0;
            return D.24875;
            <D.25045>:
            D.25046 = mono_marshal_get_struct_to_ptr (klass);
            ref->method = D.25046;
            <D.25004>:
          }
          goto <D.25047>;
          <D.24951>:
          if (subtype == 17) goto <D.25048>; else goto <D.25049>;
          <D.25048>:
          {
            struct MonoMethod * m;

            p.53 = p;
            m = decode_resolve_method_ref (module, p.53, &p);
            if (m == 0B) goto <D.25050>; else goto <D.25051>;
            <D.25050>:
            D.24875 = 0;
            return D.24875;
            <D.25051>:
            D.25052 = mono_marshal_get_synchronized_inner_wrapper (m);
            ref->method = D.25052;
          }
          goto <D.25053>;
          <D.25049>:
          if (subtype == 20) goto <D.25054>; else goto <D.25055>;
          <D.25054>:
          {
            struct MonoMethod * m;

            p.53 = p;
            m = decode_resolve_method_ref (module, p.53, &p);
            if (m == 0B) goto <D.25056>; else goto <D.25057>;
            <D.25056>:
            D.24875 = 0;
            return D.24875;
            <D.25057>:
            D.25058 = mono_marshal_get_array_accessor_wrapper (m);
            ref->method = D.25058;
          }
          goto <D.25059>;
          <D.25055>:
          if (subtype == 18) goto <D.25060>; else goto <D.25061>;
          <D.25060>:
          D.25062 = mono_marshal_get_gsharedvt_in_wrapper ();
          ref->method = D.25062;
          goto <D.25063>;
          <D.25061>:
          if (subtype == 19) goto <D.25064>; else goto <D.25065>;
          <D.25064>:
          D.25066 = mono_marshal_get_gsharedvt_out_wrapper ();
          ref->method = D.25066;
          goto <D.25067>;
          <D.25065>:
          if (subtype == 4) goto <D.25068>; else goto <D.25069>;
          <D.25068>:
          desc = mono_method_desc_new ("Monitor:Enter", 0);
          goto <D.25070>;
          <D.25069>:
          if (subtype == 6) goto <D.25071>; else goto <D.25072>;
          <D.25071>:
          desc = mono_method_desc_new ("Monitor:Exit", 0);
          goto <D.25073>;
          <D.25072>:
          if (subtype == 5) goto <D.25074>; else goto <D.25075>;
          <D.25074>:
          desc = mono_method_desc_new ("Monitor:Enter(object,bool&)", 0);
          goto <D.25076>;
          <D.25075>:
          monoeg_assertion_message ("* Assertion: should not be reached at %s:%d\n", "aot-runtime.c", 938);
          <D.25076>:
          <D.25073>:
          <D.25070>:
          D.25077 = mono_defaults.monitor_class;
          orig_method = mono_method_desc_search_in_class (desc, D.25077);
          D.25078 = orig_method == 0B;
          D.25079 = (long int) D.25078;
          D.25080 = __builtin_expect (D.25079, 0);
          if (D.25080 != 0) goto <D.25081>; else goto <D.25082>;
          <D.25081>:
          monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "aot-runtime.c", 940, "orig_method");
          <D.25082>:
          mono_method_desc_free (desc);
          D.25083 = mono_monitor_get_fast_path (orig_method);
          ref->method = D.25083;
          <D.25067>:
          <D.25063>:
          <D.25059>:
          <D.25053>:
          <D.25047>:
          goto <D.22895>;
        }
        <D.22939>:
        {
          int subtype;

          p.53 = p;
          subtype = decode_value (p.53, &p);
          if (subtype == 1) goto <D.25084>; else goto <D.25085>;
          <D.25084>:
          {
            int rank;
            int elem_size;

            p.53 = p;
            rank = decode_value (p.53, &p);
            p.53 = p;
            elem_size = decode_value (p.53, &p);
            D.25086 = mono_marshal_get_array_address (rank, elem_size);
            ref->method = D.25086;
          }
          goto <D.25087>;
          <D.25085>:
          if (subtype == 2) goto <D.25088>; else goto <D.25089>;
          <D.25088>:
          {
            struct WrapperInfo * info;
            struct MonoMethod * m;

            p.53 = p;
            m = decode_resolve_method_ref (module, p.53, &p);
            if (m == 0B) goto <D.25090>; else goto <D.25091>;
            <D.25090>:
            D.24875 = 0;
            return D.24875;
            <D.25091>:
            if (target == 0B) goto <D.25092>; else goto <D.25093>;
            <D.25092>:
            D.24875 = 0;
            return D.24875;
            <D.25093>:
            D.24871 = BIT_FIELD_REF <*target, 32, 160>;
            D.24872 = D.24871 & 124;
            D.25094 = D.24872 != 28;
            D.25095 = (long int) D.25094;
            D.25096 = __builtin_expect (D.25095, 0);
            if (D.25096 != 0) goto <D.25097>; else goto <D.25098>;
            <D.25097>:
            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.25098>:
            info = mono_marshal_get_wrapper_info (target);
            if (info != 0B) goto <D.25101>; else goto <D.25099>;
            <D.25101>:
            D.25102 = info->subtype;
            subtype.58 = (unsigned int) subtype;
            if (D.25102 == subtype.58) goto <D.25104>; else goto <D.25099>;
            <D.25104>:
            D.25105 = info->d.string_ctor.method;
            if (D.25105 == m) goto <D.25106>; else goto <D.25099>;
            <D.25106>:
            ref->method = target;
            goto <D.25100>;
            <D.25099>:
            D.24875 = 0;
            return D.24875;
            <D.25100>:
          }
          <D.25089>:
          <D.25087>:
          goto <D.22895>;
        }
        <D.22945>:
        {
          struct MonoMethod * m;
          int subtype;
          char * name;

          p.53 = p;
          subtype = decode_value (p.53, &p);
          if (subtype == 15) goto <D.25107>; else goto <D.25108>;
          <D.25107>:
          if (target == 0B) goto <D.25109>; else goto <D.25110>;
          <D.25109>:
          D.24875 = 0;
          return D.24875;
          <D.25110>:
          name = p;
          {
            size_t __s1_len;
            size_t __s2_len;

            D.25000 = target->name;
            D.22957 = __builtin_strcmp (D.25000, name);
          }
          if (D.22957 != 0) goto <D.25111>; else goto <D.25112>;
          <D.25111>:
          D.24875 = 0;
          return D.24875;
          <D.25112>:
          ref->method = target;
          goto <D.25113>;
          <D.25108>:
          p.53 = p;
          m = decode_resolve_method_ref (module, p.53, &p);
          if (m == 0B) goto <D.25114>; else goto <D.25115>;
          <D.25114>:
          D.24875 = 0;
          return D.24875;
          <D.25115>:
          if (target == 0B) goto <D.25116>; else goto <D.25117>;
          <D.25116>:
          D.24875 = 0;
          return D.24875;
          <D.25117>:
          D.25118 = mono_marshal_method_from_wrapper (target);
          if (D.25118 == m) goto <D.25119>; else goto <D.25120>;
          <D.25119>:
          ref->method = target;
          goto <D.25121>;
          <D.25120>:
          D.24875 = 0;
          return D.24875;
          <D.25121>:
          <D.25113>:
          goto <D.22895>;
        }
        <D.22958>:
        {
          int subtype;

          p.53 = p;
          subtype = decode_value (p.53, &p);
          if (subtype == 9) goto <D.25122>; else goto <D.25123>;
          <D.25122>:
          D.25124 = mono_marshal_get_castclass_with_cache ();
          ref->method = D.25124;
          goto <D.25125>;
          <D.25123>:
          if (subtype == 10) goto <D.25126>; else goto <D.25127>;
          <D.25126>:
          D.25128 = mono_marshal_get_isinst_with_cache ();
          ref->method = D.25128;
          goto <D.25129>;
          <D.25127>:
          monoeg_assertion_message ("* Assertion: should not be reached at %s:%d\n", "aot-runtime.c", 1011);
          <D.25129>:
          <D.25125>:
          goto <D.22895>;
        }
        <D.22960>:
        {
          int subtype;

          p.53 = p;
          subtype = decode_value (p.53, &p);
          if (target == 0B) goto <D.25130>; else goto <D.25131>;
          <D.25130>:
          D.24875 = 0;
          return D.24875;
          <D.25131>:
          if (subtype == 12) goto <D.25132>; else goto <D.25133>;
          <D.25132>:
          {
            size_t __s1_len;
            size_t __s2_len;

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

              __s2 = target->name;
              D.25137 = "runtime_invoke_dynamic";
              D.25138 = MEM[(const unsigned char *)D.25137];
              D.25139 = (int) D.25138;
              D.25140 = *__s2;
              D.25141 = (int) D.25140;
              __result = D.25139 - D.25141;
              {
                if (__s2_len != 0) goto <D.25142>; else goto <D.25143>;
                <D.25142>:
                if (__result == 0) goto <D.25144>; else goto <D.25145>;
                <D.25144>:
                D.25146 = &MEM[(void *)"runtime_invoke_dynamic" + 1B];
                D.25147 = *D.25146;
                D.25148 = (int) D.25147;
                D.25149 = __s2 + 1;
                D.25150 = *D.25149;
                D.25151 = (int) D.25150;
                __result = D.25148 - D.25151;
                if (__s2_len > 1) goto <D.25152>; else goto <D.25153>;
                <D.25152>:
                if (__result == 0) goto <D.25154>; else goto <D.25155>;
                <D.25154>:
                D.25156 = &MEM[(void *)"runtime_invoke_dynamic" + 2B];
                D.25157 = *D.25156;
                D.25158 = (int) D.25157;
                D.25159 = __s2 + 2;
                D.25160 = *D.25159;
                D.25161 = (int) D.25160;
                __result = D.25158 - D.25161;
                if (__s2_len > 2) goto <D.25162>; else goto <D.25163>;
                <D.25162>:
                if (__result == 0) goto <D.25164>; else goto <D.25165>;
                <D.25164>:
                D.25166 = &MEM[(void *)"runtime_invoke_dynamic" + 3B];
                D.25167 = *D.25166;
                D.25168 = (int) D.25167;
                D.25169 = __s2 + 3;
                D.25170 = *D.25169;
                D.25171 = (int) D.25170;
                __result = D.25168 - D.25171;
                <D.25165>:
                <D.25163>:
                <D.25155>:
                <D.25153>:
                <D.25145>:
                <D.25143>:
              }
              D.22969 = __result;
            }
            iftmp.59 = -D.22969;
            goto <D.25172>;
            <D.25136>:
            D.25000 = target->name;
            iftmp.59 = __builtin_strcmp (D.25000, "runtime_invoke_dynamic");
            <D.25172>:
            D.22970 = iftmp.59;
          }
          if (D.22970 != 0) goto <D.25173>; else goto <D.25174>;
          <D.25173>:
          D.24875 = 0;
          return D.24875;
          <D.25174>:
          ref->method = target;
          goto <D.25175>;
          <D.25133>:
          if (subtype == 13) goto <D.25176>; else goto <D.25177>;
          <D.25176>:
          {
            struct MonoMethod * m;

            p.53 = p;
            m = decode_resolve_method_ref (module, p.53, &p);
            if (m == 0B) goto <D.25178>; else goto <D.25179>;
            <D.25178>:
            D.24875 = 0;
            return D.24875;
            <D.25179>:
            D.25180 = mono_marshal_get_runtime_invoke (m, 0);
            ref->method = D.25180;
          }
          goto <D.25181>;
          <D.25177>:
          if (subtype == 14) goto <D.25182>; else goto <D.25183>;
          <D.25182>:
          {
            struct MonoMethod * m;

            p.53 = p;
            m = decode_resolve_method_ref (module, p.53, &p);
            if (m == 0B) goto <D.25184>; else goto <D.25185>;
            <D.25184>:
            D.24875 = 0;
            return D.24875;
            <D.25185>:
            D.25186 = mono_marshal_get_runtime_invoke (m, 1);
            ref->method = D.25186;
          }
          goto <D.25187>;
          <D.25183>:
          {
            struct MonoMethodSignature * sig;
            struct WrapperInfo * info;

            p.53 = p;
            sig = decode_signature_with_target (module, 0B, p.53, &p);
            info = mono_marshal_get_wrapper_info (target);
            D.25188 = info == 0B;
            D.25189 = (long int) D.25188;
            D.25190 = __builtin_expect (D.25189, 0);
            if (D.25190 != 0) goto <D.25191>; else goto <D.25192>;
            <D.25191>:
            monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "aot-runtime.c", 1044, "info");
            <D.25192>:
            D.25193 = info->subtype;
            subtype.60 = (unsigned int) subtype;
            if (D.25193 != subtype.60) goto <D.25195>; else goto <D.25196>;
            <D.25195>:
            D.24875 = 0;
            return D.24875;
            <D.25196>:
            D.25197 = info->d.runtime_invoke.sig;
            D.25198 = D.25197 == 0B;
            D.25199 = (long int) D.25198;
            D.25200 = __builtin_expect (D.25199, 0);
            if (D.25200 != 0) goto <D.25201>; else goto <D.25202>;
            <D.25201>:
            monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "aot-runtime.c", 1048, "info->d.runtime_invoke.sig");
            <D.25202>:
            D.25197 = info->d.runtime_invoke.sig;
            D.25203 = mono_metadata_signature_equal (sig, D.25197);
            if (D.25203 != 0) goto <D.25204>; else goto <D.25205>;
            <D.25204>:
            ref->method = target;
            goto <D.25206>;
            <D.25205>:
            D.24875 = 0;
            return D.24875;
            <D.25206>:
          }
          <D.25187>:
          <D.25181>:
          <D.25175>:
          goto <D.22895>;
        }
        <D.22975>:
        <D.22976>:
        <D.22977>:
        {
          gboolean is_inflated;
          WrapperSubtype subtype;

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

            p.53 = p;
            klass = decode_klass_ref (module, p.53, &p);
            if (klass == 0B) goto <D.25209>; else goto <D.25210>;
            <D.25209>:
            D.24875 = 0;
            return D.24875;
            <D.25210>:
            switch (wrapper_type) <default: <D.22987>, case 1: <D.22983>, case 2: <D.22985>, case 3: <D.22986>>
            <D.22983>:
            invoke = mono_get_delegate_invoke (klass);
            wrapper = mono_marshal_get_delegate_invoke (invoke, 0B);
            goto <D.22984>;
            <D.22985>:
            invoke = mono_get_delegate_begin_invoke (klass);
            wrapper = mono_marshal_get_delegate_begin_invoke (invoke);
            goto <D.22984>;
            <D.22986>:
            invoke = mono_get_delegate_end_invoke (klass);
            wrapper = mono_marshal_get_delegate_end_invoke (invoke);
            goto <D.22984>;
            <D.22987>:
            monoeg_assertion_message ("* Assertion: should not be reached at %s:%d\n", "aot-runtime.c", 1084);
            <D.22984>:
            if (target != 0B) goto <D.25211>; else goto <D.25212>;
            <D.25211>:
            if (wrapper != target) goto <D.25213>; else goto <D.25214>;
            <D.25213>:
            D.24875 = 0;
            return D.24875;
            <D.25214>:
            <D.25212>:
            ref->method = wrapper;
          }
          goto <D.25215>;
          <D.25208>:
          if (target == 0B) goto <D.25216>; else goto <D.25217>;
          <D.25216>:
          D.24875 = 0;
          return D.24875;
          <D.25217>:
          if (wrapper_type == 1) goto <D.25218>; else goto <D.25219>;
          <D.25218>:
          {
            struct WrapperInfo * info;

            p.53 = p;
            D.25220 = decode_value (p.53, &p);
            subtype = (WrapperSubtype) D.25220;
            info = mono_marshal_get_wrapper_info (target);
            if (info != 0B) goto <D.25221>; else goto <D.25222>;
            <D.25221>:
            D.25223 = info->subtype;
            if (D.25223 != subtype) goto <D.25224>; else goto <D.25225>;
            <D.25224>:
            D.24875 = 0;
            return D.24875;
            <D.25225>:
            goto <D.25226>;
            <D.25222>:
            if (subtype != 0) goto <D.25227>; else goto <D.25228>;
            <D.25227>:
            D.24875 = 0;
            return D.24875;
            <D.25228>:
            <D.25226>:
          }
          <D.25219>:
          p.53 = p;
          D.25229 = sig_matches_target (module, target, p.53, &p);
          if (D.25229 != 0) goto <D.25230>; else goto <D.25231>;
          <D.25230>:
          ref->method = target;
          goto <D.25232>;
          <D.25231>:
          D.24875 = 0;
          return D.24875;
          <D.25232>:
          <D.25215>:
          goto <D.22895>;
        }
        <D.22989>:
        {
          struct MonoMethod * m;
          struct MonoClass * klass;

          p.53 = p;
          m = decode_resolve_method_ref (module, p.53, &p);
          if (m == 0B) goto <D.25233>; else goto <D.25234>;
          <D.25233>:
          D.24875 = 0;
          return D.24875;
          <D.25234>:
          p.53 = p;
          klass = decode_klass_ref (module, p.53, &p);
          if (klass == 0B) goto <D.25235>; else goto <D.25236>;
          <D.25235>:
          D.24875 = 0;
          return D.24875;
          <D.25236>:
          D.25237 = mono_marshal_get_managed_wrapper (m, klass, 0);
          ref->method = D.25237;
          goto <D.22895>;
        }
        <D.22992>:
        monoeg_assertion_message ("* Assertion: should not be reached at %s:%d\n", "aot-runtime.c", 1132);
        <D.22895>:
      }
      goto <D.25238>;
      <D.24877>:
      if (image_index == 254) goto <D.25239>; else goto <D.25240>;
      <D.25239>:
      p.53 = p;
      D.25241 = decode_value (p.53, &p);
      image_index = (guint32) D.25241;
      p.53 = p;
      D.25242 = decode_value (p.53, &p);
      D.25243 = (unsigned int) D.25242;
      ref->token = D.25243;
      image_index.61 = (int) image_index;
      image = load_image (module, image_index.61, 1);
      if (image == 0B) goto <D.25245>; else goto <D.25246>;
      <D.25245>:
      D.24875 = 0;
      return D.24875;
      <D.25246>:
      goto <D.25247>;
      <D.25240>:
      if (image_index == 253) goto <D.25248>; else goto <D.25249>;
      <D.25248>:
      {
        struct MonoClass * klass;
        struct MonoGenericContext ctx;

        try
          {
            p.53 = p;
            klass = decode_klass_ref (module, p.53, &p);
            if (klass == 0B) goto <D.25250>; else goto <D.25251>;
            <D.25250>:
            D.24875 = 0;
            return D.24875;
            <D.25251>:
            if (target != 0B) goto <D.25252>; else goto <D.25253>;
            <D.25252>:
            D.24956 = target->klass;
            if (D.24956 != klass) goto <D.25254>; else goto <D.25255>;
            <D.25254>:
            D.24875 = 0;
            return D.24875;
            <D.25255>:
            <D.25253>:
            p.53 = p;
            D.25256 = decode_value (p.53, &p);
            image_index = (guint32) D.25256;
            p.53 = p;
            D.25257 = decode_value (p.53, &p);
            D.25258 = (unsigned int) D.25257;
            ref->token = D.25258;
            image_index.61 = (int) image_index;
            image = load_image (module, image_index.61, 1);
            if (image == 0B) goto <D.25259>; else goto <D.25260>;
            <D.25259>:
            D.24875 = 0;
            return D.24875;
            <D.25260>:
            D.25261 = ref->token;
            D.25262 = mono_get_method_full (image, D.25261, 0B, 0B);
            ref->method = D.25262;
            D.24914 = ref->method;
            if (D.24914 == 0B) goto <D.25263>; else goto <D.25264>;
            <D.25263>:
            D.24875 = 0;
            return D.24875;
            <D.25264>:
            memset (&ctx, 0, 8);
            if (0 != 0) goto <D.25265>; else goto <D.25266>;
            <D.25265>:
            D.25267 = klass->generic_class;
            D.25268 = D.25267->context.class_inst;
            ctx.class_inst = D.25268;
            ctx.method_inst = 0B;
            D.24914 = ref->method;
            D.25269 = mono_class_inflate_generic_method_full (D.24914, klass, &ctx);
            ref->method = D.25269;
            <D.25266>:
            memset (&ctx, 0, 8);
            p.53 = p;
            D.25270 = decode_generic_context (module, &ctx, p.53, &p);
            if (D.25270 == 0) goto <D.25271>; else goto <D.25272>;
            <D.25271>:
            D.24875 = 0;
            return D.24875;
            <D.25272>:
            D.24914 = ref->method;
            D.25273 = mono_class_inflate_generic_method_full (D.24914, klass, &ctx);
            ref->method = D.25273;
          }
        finally
          {
            ctx = {CLOBBER};
          }
      }
      goto <D.25274>;
      <D.25249>:
      if (image_index == 250) goto <D.25275>; else goto <D.25276>;
      <D.25275>:
      {
        struct MonoClass * klass;
        int method_type;

        p.53 = p;
        klass = decode_klass_ref (module, p.53, &p);
        if (klass == 0B) goto <D.25277>; else goto <D.25278>;
        <D.25277>:
        D.24875 = 0;
        return D.24875;
        <D.25278>:
        p.53 = p;
        method_type = decode_value (p.53, &p);
        switch (method_type) <default: <D.23003>, case 0: <D.22997>, case 1: <D.22999>, case 2: <D.23000>, case 3: <D.23001>, case 4: <D.23002>>
        <D.22997>:
        D.25279 = klass->rank;
        D.25280 = (int) D.25279;
        D.25281 = mono_class_get_method_from_name (klass, ".ctor", D.25280);
        ref->method = D.25281;
        goto <D.22998>;
        <D.22999>:
        D.25279 = klass->rank;
        D.25280 = (int) D.25279;
        D.25282 = D.25280 * 2;
        D.25283 = mono_class_get_method_from_name (klass, ".ctor", D.25282);
        ref->method = D.25283;
        goto <D.22998>;
        <D.23000>:
        D.25284 = mono_class_get_method_from_name (klass, "Get", -1);
        ref->method = D.25284;
        goto <D.22998>;
        <D.23001>:
        D.25285 = mono_class_get_method_from_name (klass, "Address", -1);
        ref->method = D.25285;
        goto <D.22998>;
        <D.23002>:
        D.25286 = mono_class_get_method_from_name (klass, "Set", -1);
        ref->method = D.25286;
        goto <D.22998>;
        <D.23003>:
        monoeg_assertion_message ("* Assertion: should not be reached at %s:%d\n", "aot-runtime.c", 1207);
        <D.22998>:
      }
      goto <D.25287>;
      <D.25276>:
      if (image_index == 249) goto <D.25288>; else goto <D.25289>;
      <D.25288>:
      p.53 = p;
      D.25290 = decode_value (p.53, &p);
      image_index = (guint32) D.25290;
      p.53 = p;
      D.25291 = decode_value (p.53, &p);
      value = (guint32) D.25291;
      <D.25289>:
      D.25292 = value & 16777215;
      D.25293 = D.25292 | 100663296;
      ref->token = D.25293;
      image_index.61 = (int) image_index;
      image = load_image (module, image_index.61, 1);
      if (image == 0B) goto <D.25294>; else goto <D.25295>;
      <D.25294>:
      D.24875 = 0;
      return D.24875;
      <D.25295>:
      <D.25287>:
      <D.25274>:
      <D.25247>:
      <D.25238>:
      p.53 = p;
      *endbuf = p.53;
      ref->image = image;
      D.24875 = 1;
      return D.24875;
    }
  finally
    {
      p = {CLOBBER};
    }
}


decode_signature_with_target (struct MonoAotModule * module, struct MonoMethodSignature * target, guint8 * buf, guint8 * * endbuf)
{
  guint8 * p.62;
  unsigned char D.25301;
  guint8 * p.63;
  unsigned int D.25303;
  _Bool D.25304;
  unsigned int D.25305;
  _Bool D.25306;
  unsigned int D.25307;
  _Bool D.25308;
  int flags.64;
  short unsigned int D.25314;
  int D.25315;
  struct MonoMethodSignature * D.25318;
  unsigned int param_count.65;
  unsigned int D.25320;
  unsigned int D.25321;
  short unsigned int D.25322;
  unsigned char D.25323;
  <unnamed-unsigned:1> D.25324;
  unsigned char D.25325;
  <unnamed-unsigned:1> D.25326;
  unsigned char D.25327;
  <unnamed-unsigned:6> D.25328;
  struct MonoType * D.25329;
  unsigned int D.25332;
  unsigned int D.25333;
  _Bool D.25334;
  long int D.25335;
  long int D.25336;
  short int D.25339;
  struct MonoType * D.25340;
  short int D.25343;
  short unsigned int D.25346;
  short int D.25347;
  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.62 = p;
      D.25301 = *p.62;
      flags = (guint32) D.25301;
      p.62 = p;
      p.63 = p.62 + 1;
      p = p.63;
      D.25303 = flags & 16;
      D.25304 = D.25303 != 0;
      has_gen_params = (gboolean) D.25304;
      D.25305 = flags & 32;
      D.25306 = D.25305 != 0;
      hasthis = (gboolean) D.25306;
      D.25307 = flags & 64;
      D.25308 = D.25307 != 0;
      explicit_this = (gboolean) D.25308;
      flags.64 = (int) flags;
      call_conv = flags.64 & 15;
      if (has_gen_params != 0) goto <D.25310>; else goto <D.25311>;
      <D.25310>:
      p.62 = p;
      gen_param_count = decode_value (p.62, &p);
      <D.25311>:
      p.62 = p;
      param_count = decode_value (p.62, &p);
      if (target != 0B) goto <D.25312>; else goto <D.25313>;
      <D.25312>:
      D.25314 = target->param_count;
      D.25315 = (int) D.25314;
      if (D.25315 != param_count) goto <D.25316>; else goto <D.25317>;
      <D.25316>:
      D.25318 = 0B;
      return D.25318;
      <D.25317>:
      <D.25313>:
      param_count.65 = (unsigned int) param_count;
      D.25320 = param_count.65 + 3;
      D.25321 = D.25320 * 4;
      sig = monoeg_malloc0 (D.25321);
      D.25322 = (short unsigned int) param_count;
      sig->param_count = D.25322;
      sig->sentinelpos = -1;
      D.25323 = (unsigned char) hasthis;
      D.25324 = (<unnamed-unsigned:1>) D.25323;
      sig->hasthis = D.25324;
      D.25325 = (unsigned char) explicit_this;
      D.25326 = (<unnamed-unsigned:1>) D.25325;
      sig->explicit_this = D.25326;
      D.25327 = (unsigned char) call_conv;
      D.25328 = (<unnamed-unsigned:6>) D.25327;
      sig->call_convention = D.25328;
      D.25322 = (short unsigned int) param_count;
      sig->param_count = D.25322;
      p.62 = p;
      D.25329 = decode_type (module, p.62, &p);
      sig->ret = D.25329;
      i = 0;
      goto <D.22859>;
      <D.22858>:
      p.62 = p;
      D.25301 = *p.62;
      if (D.25301 == 65) goto <D.25330>; else goto <D.25331>;
      <D.25330>:
      D.25332 = BIT_FIELD_REF <*sig, 32, 64>;
      D.25333 = D.25332 & 4128768;
      D.25334 = D.25333 != 327680;
      D.25335 = (long int) D.25334;
      D.25336 = __builtin_expect (D.25335, 0);
      if (D.25336 != 0) goto <D.25337>; else goto <D.25338>;
      <D.25337>:
      monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "aot-runtime.c", 706, "sig->call_convention == MONO_CALL_VARARG");
      <D.25338>:
      D.25339 = (short int) i;
      sig->sentinelpos = D.25339;
      p.62 = p;
      p.63 = p.62 + 1;
      p = p.63;
      <D.25331>:
      p.62 = p;
      D.25340 = decode_type (module, p.62, &p);
      sig->params[i] = D.25340;
      i = i + 1;
      <D.22859>:
      if (i < param_count) goto <D.22858>; else goto <D.22860>;
      <D.22860>:
      D.25332 = BIT_FIELD_REF <*sig, 32, 64>;
      D.25333 = D.25332 & 4128768;
      if (D.25333 == 327680) goto <D.25341>; else goto <D.25342>;
      <D.25341>:
      D.25343 = sig->sentinelpos;
      if (D.25343 == -1) goto <D.25344>; else goto <D.25345>;
      <D.25344>:
      D.25346 = sig->param_count;
      D.25347 = (short int) D.25346;
      sig->sentinelpos = D.25347;
      <D.25345>:
      <D.25342>:
      p.62 = p;
      *endbuf = p.62;
      D.25318 = sig;
      return D.25318;
    }
  finally
    {
      p = {CLOBBER};
    }
}


decode_type (struct MonoAotModule * module, guint8 * buf, guint8 * * endbuf)
{
  guint8 * p.66;
  unsigned char D.25351;
  guint8 * p.67;
  unsigned char D.25357;
  int D.25358;
  struct MonoClass * D.25359;
  struct MonoClass * D.25360;
  struct MonoClass * D.25361;
  struct MonoType * D.25364;
  struct MonoType * D.25365;
  struct MonoGenericContainer * D.25368;
  _Bool D.25369;
  long int D.25370;
  long int D.25371;
  struct MonoGenericInst * D.25374;
  struct MonoGenericInst * D.25375;
  struct MonoType * D.25378;
  struct MonoGenericClass * D.25379;
  struct MonoClass * D.25380;
  struct MonoClass * D.25381;
  int D.25384;
  unsigned char D.25385;
  int D.25386;
  unsigned char D.25387;
  unsigned char D.25388;
  unsigned int D.25391;
  unsigned int D.25392;
  void * D.25393;
  int * D.25394;
  unsigned int i.68;
  unsigned int D.25396;
  int * D.25397;
  int D.25398;
  int D.25399;
  int D.25400;
  unsigned char D.25401;
  unsigned char D.25402;
  unsigned int D.25405;
  unsigned int D.25406;
  void * D.25407;
  int * D.25408;
  int * D.25409;
  int D.25410;
  int D.25411;
  struct MonoGenericParam * D.25414;
  guint8 * p;
  struct MonoType * t;

  try
    {
      p = buf;
      t = monoeg_malloc0 (8);
      <D.22800>:
      p.66 = p;
      D.25351 = *p.66;
      if (D.25351 == 69) goto <D.25352>; else goto <D.25353>;
      <D.25352>:
      t->pinned = 1;
      p.66 = p;
      p.67 = p.66 + 1;
      p = p.67;
      goto <D.25355>;
      <D.25353>:
      p.66 = p;
      D.25351 = *p.66;
      if (D.25351 == 16) goto <D.25356>; else goto <D.22799>;
      <D.25356>:
      t->byref = 1;
      p.66 = p;
      p.67 = p.66 + 1;
      p = p.67;
      <D.25355>:
      goto <D.22800>;
      <D.22799>:
      p.66 = p;
      D.25351 = *p.66;
      t->type = D.25351;
      p.66 = p;
      p.67 = p.66 + 1;
      p = p.67;
      D.25357 = t->type;
      D.25358 = (int) D.25357;
      switch (D.25358) <default: <D.22841>, case 1: <D.22801>, case 2: <D.22802>, case 3: <D.22803>, case 4: <D.22804>, case 5: <D.22805>, case 6: <D.22806>, case 7: <D.22807>, case 8: <D.22808>, case 9: <D.22809>, case 10: <D.22810>, case 11: <D.22811>, case 12: <D.22812>, case 13: <D.22813>, case 14: <D.22816>, case 15: <D.22823>, case 17: <D.22820>, case 18: <D.22821>, case 19: <D.22838>, case 20: <D.22829>, case 21: <D.22824>, case 22: <D.22818>, case 24: <D.22814>, case 25: <D.22815>, case 28: <D.22817>, case 29: <D.22822>, case 30: <D.22839>>
      <D.22801>:
      <D.22802>:
      <D.22803>:
      <D.22804>:
      <D.22805>:
      <D.22806>:
      <D.22807>:
      <D.22808>:
      <D.22809>:
      <D.22810>:
      <D.22811>:
      <D.22812>:
      <D.22813>:
      <D.22814>:
      <D.22815>:
      <D.22816>:
      <D.22817>:
      <D.22818>:
      goto <D.22819>;
      <D.22820>:
      <D.22821>:
      p.66 = p;
      D.25359 = decode_klass_ref (module, p.66, &p);
      t->data.klass = D.25359;
      goto <D.22819>;
      <D.22822>:
      p.66 = p;
      D.25360 = decode_klass_ref (module, p.66, &p);
      t->data.klass = D.25360;
      D.25361 = t->data.klass;
      if (D.25361 == 0B) goto <D.25362>; else goto <D.25363>;
      <D.25362>:
      D.25364 = 0B;
      return D.25364;
      <D.25363>:
      goto <D.22819>;
      <D.22823>:
      p.66 = p;
      D.25365 = decode_type (module, p.66, &p);
      t->data.type = D.25365;
      goto <D.22819>;
      <D.22824>:
      {
        struct MonoClass * gclass;
        struct MonoGenericContext ctx;
        struct MonoType * type;
        struct MonoClass * klass;

        try
          {
            p.66 = p;
            gclass = decode_klass_ref (module, p.66, &p);
            if (gclass == 0B) goto <D.25366>; else goto <D.25367>;
            <D.25366>:
            D.25364 = 0B;
            return D.25364;
            <D.25367>:
            D.25368 = gclass->generic_container;
            D.25369 = D.25368 == 0B;
            D.25370 = (long int) D.25369;
            D.25371 = __builtin_expect (D.25370, 0);
            if (D.25371 != 0) goto <D.25372>; else goto <D.25373>;
            <D.25372>:
            monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "aot-runtime.c", 620, "gclass->generic_container");
            <D.25373>:
            memset (&ctx, 0, 8);
            p.66 = p;
            D.25374 = decode_generic_inst (module, p.66, &p);
            ctx.class_inst = D.25374;
            D.25375 = ctx.class_inst;
            if (D.25375 == 0B) goto <D.25376>; else goto <D.25377>;
            <D.25376>:
            D.25364 = 0B;
            return D.25364;
            <D.25377>:
            D.25378 = &gclass->byval_arg;
            type = mono_class_inflate_generic_type (D.25378, &ctx);
            klass = mono_class_from_mono_type (type);
            D.25379 = klass->generic_class;
            t->data.generic_class = D.25379;
            goto <D.22819>;
          }
        finally
          {
            ctx = {CLOBBER};
          }
      }
      <D.22829>:
      {
        struct MonoArrayType * array;
        int i;

        array = monoeg_malloc0 (16);
        p.66 = p;
        D.25380 = decode_klass_ref (module, p.66, &p);
        array->eklass = D.25380;
        D.25381 = array->eklass;
        if (D.25381 == 0B) goto <D.25382>; else goto <D.25383>;
        <D.25382>:
        D.25364 = 0B;
        return D.25364;
        <D.25383>:
        p.66 = p;
        D.25384 = decode_value (p.66, &p);
        D.25385 = (unsigned char) D.25384;
        array->rank = D.25385;
        p.66 = p;
        D.25386 = decode_value (p.66, &p);
        D.25387 = (unsigned char) D.25386;
        array->numsizes = D.25387;
        D.25388 = array->numsizes;
        if (D.25388 != 0) goto <D.25389>; else goto <D.25390>;
        <D.25389>:
        D.25388 = array->numsizes;
        D.25391 = (unsigned int) D.25388;
        D.25392 = D.25391 * 4;
        D.25393 = monoeg_malloc0 (D.25392);
        array->sizes = D.25393;
        <D.25390>:
        i = 0;
        goto <D.22833>;
        <D.22832>:
        D.25394 = array->sizes;
        i.68 = (unsigned int) i;
        D.25396 = i.68 * 4;
        D.25397 = D.25394 + D.25396;
        p.66 = p;
        D.25398 = decode_value (p.66, &p);
        *D.25397 = D.25398;
        i = i + 1;
        <D.22833>:
        D.25388 = array->numsizes;
        D.25399 = (int) D.25388;
        if (D.25399 > i) goto <D.22832>; else goto <D.22834>;
        <D.22834>:
        p.66 = p;
        D.25400 = decode_value (p.66, &p);
        D.25401 = (unsigned char) D.25400;
        array->numlobounds = D.25401;
        D.25402 = array->numlobounds;
        if (D.25402 != 0) goto <D.25403>; else goto <D.25404>;
        <D.25403>:
        D.25402 = array->numlobounds;
        D.25405 = (unsigned int) D.25402;
        D.25406 = D.25405 * 4;
        D.25407 = monoeg_malloc0 (D.25406);
        array->lobounds = D.25407;
        <D.25404>:
        i = 0;
        goto <D.22836>;
        <D.22835>:
        D.25408 = array->lobounds;
        i.68 = (unsigned int) i;
        D.25396 = i.68 * 4;
        D.25409 = D.25408 + D.25396;
        p.66 = p;
        D.25410 = decode_value (p.66, &p);
        *D.25409 = D.25410;
        i = i + 1;
        <D.22836>:
        D.25402 = array->numlobounds;
        D.25411 = (int) D.25402;
        if (D.25411 > i) goto <D.22835>; else goto <D.22837>;
        <D.22837>:
        t->data.array = array;
        goto <D.22819>;
      }
      <D.22838>:
      <D.22839>:
      {
        struct MonoClass * klass;

        p.66 = p;
        klass = decode_klass_ref (module, p.66, &p);
        if (klass == 0B) goto <D.25412>; else goto <D.25413>;
        <D.25412>:
        D.25364 = 0B;
        return D.25364;
        <D.25413>:
        D.25414 = klass->byval_arg.data.generic_param;
        t->data.generic_param = D.25414;
        goto <D.22819>;
      }
      <D.22841>:
      monoeg_assertion_message ("* Assertion: should not be reached at %s:%d\n", "aot-runtime.c", 665);
      <D.22819>:
      p.66 = p;
      *endbuf = p.66;
      D.25364 = t;
      return D.25364;
    }
  finally
    {
      p = {CLOBBER};
    }
}


decode_generic_inst (struct MonoAotModule * module, guint8 * buf, guint8 * * endbuf)
{
  guint8 * p.69;
  unsigned int type_argc.70;
  unsigned int D.25422;
  struct MonoGenericInst * D.25425;
  unsigned int i.71;
  unsigned int D.25427;
  struct MonoType * * D.25428;
  struct MonoType * D.25429;
  int type_argc;
  int i;
  struct MonoType * * type_argv;
  struct MonoGenericInst * inst;
  guint8 * p;

  try
    {
      p = buf;
      p.69 = p;
      type_argc = decode_value (p.69, &p);
      type_argc.70 = (unsigned int) type_argc;
      D.25422 = type_argc.70 * 4;
      type_argv = monoeg_malloc0 (D.25422);
      i = 0;
      goto <D.22734>;
      <D.22733>:
      {
        struct MonoClass * pclass;

        p.69 = p;
        pclass = decode_klass_ref (module, p.69, &p);
        if (pclass == 0B) goto <D.25423>; else goto <D.25424>;
        <D.25423>:
        monoeg_g_free (type_argv);
        D.25425 = 0B;
        return D.25425;
        <D.25424>:
        i.71 = (unsigned int) i;
        D.25427 = i.71 * 4;
        D.25428 = type_argv + D.25427;
        D.25429 = &pclass->byval_arg;
        *D.25428 = D.25429;
      }
      i = i + 1;
      <D.22734>:
      if (i < type_argc) goto <D.22733>; else goto <D.22735>;
      <D.22735>:
      inst = mono_metadata_get_generic_inst (type_argc, type_argv);
      monoeg_g_free (type_argv);
      p.69 = p;
      *endbuf = p.69;
      D.25425 = inst;
      return D.25425;
    }
  finally
    {
      p = {CLOBBER};
    }
}


sig_matches_target (struct MonoAotModule * module, struct MonoMethod * target, guint8 * buf, guint8 * * endbuf)
{
  struct MonoMethodSignature * D.25432;
  guint8 * p.72;
  int iftmp.73;
  struct MonoMethodSignature * D.25438;
  int D.25439;
  gboolean D.25441;
  struct MonoMethodSignature * sig;
  gboolean res;
  guint8 * p;

  try
    {
      p = buf;
      D.25432 = mono_method_signature (target);
      p.72 = p;
      sig = decode_signature_with_target (module, D.25432, p.72, &p);
      if (sig != 0B) goto <D.25437>; else goto <D.25435>;
      <D.25437>:
      D.25438 = mono_method_signature (target);
      D.25439 = mono_metadata_signature_equal (D.25438, sig);
      if (D.25439 != 0) goto <D.25440>; else goto <D.25435>;
      <D.25440>:
      iftmp.73 = 1;
      goto <D.25436>;
      <D.25435>:
      iftmp.73 = 0;
      <D.25436>:
      res = iftmp.73;
      monoeg_g_free (sig);
      p.72 = p;
      *endbuf = p.72;
      D.25441 = res;
      return D.25441;
    }
  finally
    {
      p = {CLOBBER};
    }
}


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

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


decode_resolve_method_ref_with_target (struct MonoAotModule * module, struct MonoMethod * target, guint8 * buf, guint8 * * endbuf)
{
  struct MonoMethod * D.25448;
  struct MonoMethod * D.25449;
  struct MonoImage * D.25452;
  unsigned int D.25455;
  struct MethodRef ref;
  gboolean res;

  try
    {
      res = decode_method_ref_with_target (module, &ref, target, buf, endbuf);
      if (res == 0) goto <D.25446>; else goto <D.25447>;
      <D.25446>:
      D.25448 = 0B;
      return D.25448;
      <D.25447>:
      D.25449 = ref.method;
      if (D.25449 != 0B) goto <D.25450>; else goto <D.25451>;
      <D.25450>:
      D.25448 = ref.method;
      return D.25448;
      <D.25451>:
      D.25452 = ref.image;
      if (D.25452 == 0B) goto <D.25453>; else goto <D.25454>;
      <D.25453>:
      D.25448 = 0B;
      return D.25448;
      <D.25454>:
      D.25452 = ref.image;
      D.25455 = ref.token;
      D.25448 = mono_get_method (D.25452, D.25455, 0B);
      return D.25448;
    }
  finally
    {
      ref = {CLOBBER};
    }
}


decode_generic_context (struct MonoAotModule * module, struct MonoGenericContext * ctx, guint8 * buf, guint8 * * endbuf)
{
  guint8 * p.74;
  struct MonoGenericInst * D.25461;
  struct MonoGenericInst * D.25462;
  gboolean D.25465;
  struct MonoGenericInst * D.25468;
  struct MonoGenericInst * D.25469;
  guint8 * p;
  guint8 * p2;
  int argc;

  try
    {
      p = buf;
      p2 = p;
      p.74 = p;
      argc = decode_value (p.74, &p);
      if (argc != 0) goto <D.25459>; else goto <D.25460>;
      <D.25459>:
      p = p2;
      p.74 = p;
      D.25461 = decode_generic_inst (module, p.74, &p);
      ctx->class_inst = D.25461;
      D.25462 = ctx->class_inst;
      if (D.25462 == 0B) goto <D.25463>; else goto <D.25464>;
      <D.25463>:
      D.25465 = 0;
      return D.25465;
      <D.25464>:
      <D.25460>:
      p2 = p;
      p.74 = p;
      argc = decode_value (p.74, &p);
      if (argc != 0) goto <D.25466>; else goto <D.25467>;
      <D.25466>:
      p = p2;
      p.74 = p;
      D.25468 = decode_generic_inst (module, p.74, &p);
      ctx->method_inst = D.25468;
      D.25469 = ctx->method_inst;
      if (D.25469 == 0B) goto <D.25470>; else goto <D.25471>;
      <D.25470>:
      D.25465 = 0;
      return D.25465;
      <D.25471>:
      <D.25467>:
      p.74 = p;
      *endbuf = p.74;
      D.25465 = 1;
      return D.25465;
    }
  finally
    {
      p = {CLOBBER};
    }
}


decode_klass_ref (struct MonoAotModule * module, guint8 * buf, guint8 * * endbuf)
{
  guint8 * p.75;
  struct MonoClass * D.25477;
  int D.25478;
  unsigned int D.25481;
  int D.25482;
  int D.25483;
  int D.25486;
  struct MonoAssembly * D.25487;
  struct MonoGenericContainer * D.25492;
  _Bool D.25493;
  long int D.25494;
  long int D.25495;
  struct MonoGenericInst * D.25498;
  struct MonoGenericInst * D.25499;
  struct MonoType * D.25502;
  _Bool D.25507;
  long int D.25508;
  long int D.25509;
  _Bool D.25515;
  long int D.25516;
  long int D.25517;
  unsigned char D.25523;
  struct MonoGenericParamFull * D.25526;
  unsigned int num.76;
  unsigned int D.25528;
  struct MonoGenericParam * D.25529;
  _Bool D.25530;
  long int D.25531;
  long int D.25532;
  short unsigned int D.25536;
  short unsigned int D.25537;
  struct MonoImage * D.25538;
  int D.25539;
  int D.25542;
  guint8 * D.25543;
  guint8 * p2.77;
  guint8 * p2.78;
  _Bool D.25546;
  long int D.25547;
  long int D.25548;
  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.75 = p;
      reftype = decode_value (p.75, &p);
      if (reftype == 0) goto <D.25475>; else goto <D.25476>;
      <D.25475>:
      p.75 = p;
      *endbuf = p.75;
      D.25477 = 0B;
      return D.25477;
      <D.25476>:
      switch (reftype) <default: <D.22783>, case 1: <D.22758>, case 2: <D.22760>, case 3: <D.22761>, case 4: <D.22762>, case 5: <D.22766>, case 6: <D.22777>, case 7: <D.22780>, case 8: <D.22778>>
      <D.22758>:
      p.75 = p;
      D.25478 = decode_value (p.75, &p);
      idx = (guint32) D.25478;
      image = load_image (module, 0, 1);
      if (image == 0B) goto <D.25479>; else goto <D.25480>;
      <D.25479>:
      D.25477 = 0B;
      return D.25477;
      <D.25480>:
      D.25481 = idx + 33554432;
      klass = mono_class_get (image, D.25481);
      goto <D.22759>;
      <D.22760>:
      p.75 = p;
      D.25482 = decode_value (p.75, &p);
      idx = (guint32) D.25482;
      p.75 = p;
      D.25483 = decode_value (p.75, &p);
      image = load_image (module, D.25483, 1);
      if (image == 0B) goto <D.25484>; else goto <D.25485>;
      <D.25484>:
      D.25477 = 0B;
      return D.25477;
      <D.25485>:
      D.25481 = idx + 33554432;
      klass = mono_class_get (image, D.25481);
      goto <D.22759>;
      <D.22761>:
      p.75 = p;
      D.25486 = decode_value (p.75, &p);
      token = (guint32) D.25486;
      D.25487 = module->assembly;
      image = D.25487->image;
      if (image == 0B) goto <D.25488>; else goto <D.25489>;
      <D.25488>:
      D.25477 = 0B;
      return D.25477;
      <D.25489>:
      klass = mono_class_get (image, token);
      goto <D.22759>;
      <D.22762>:
      {
        struct MonoClass * gclass;
        struct MonoGenericContext ctx;
        struct MonoType * type;

        try
          {
            p.75 = p;
            gclass = decode_klass_ref (module, p.75, &p);
            if (gclass == 0B) goto <D.25490>; else goto <D.25491>;
            <D.25490>:
            D.25477 = 0B;
            return D.25477;
            <D.25491>:
            D.25492 = gclass->generic_container;
            D.25493 = D.25492 == 0B;
            D.25494 = (long int) D.25493;
            D.25495 = __builtin_expect (D.25494, 0);
            if (D.25495 != 0) goto <D.25496>; else goto <D.25497>;
            <D.25496>:
            monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "aot-runtime.c", 435, "gclass->generic_container");
            <D.25497>:
            memset (&ctx, 0, 8);
            p.75 = p;
            D.25498 = decode_generic_inst (module, p.75, &p);
            ctx.class_inst = D.25498;
            D.25499 = ctx.class_inst;
            if (D.25499 == 0B) goto <D.25500>; else goto <D.25501>;
            <D.25500>:
            D.25477 = 0B;
            return D.25477;
            <D.25501>:
            D.25502 = &gclass->byval_arg;
            type = mono_class_inflate_generic_type (D.25502, &ctx);
            klass = mono_class_from_mono_type (type);
            mono_metadata_free_type (type);
            goto <D.22759>;
          }
        finally
          {
            ctx = {CLOBBER};
          }
      }
      <D.22766>:
      {
        struct MonoType * t;
        struct MonoGenericContainer * container;
        int type;
        int num;
        gboolean has_container;
        int serial;

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

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

            D.25507 = type != 30;
            D.25508 = (long int) D.25507;
            D.25509 = __builtin_expect (D.25508, 0);
            if (D.25509 != 0) goto <D.25510>; else goto <D.25511>;
            <D.25510>:
            monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "aot-runtime.c", 459, "type == MONO_TYPE_MVAR");
            <D.25511>:
            p.75 = p;
            method_def = decode_resolve_method_ref (module, p.75, &p);
            if (method_def == 0B) goto <D.25512>; else goto <D.25513>;
            <D.25512>:
            D.25477 = 0B;
            return D.25477;
            <D.25513>:
            container = mono_method_get_generic_container (method_def);
          }
          goto <D.25514>;
          <D.25506>:
          {
            struct MonoClass * class_def;

            D.25515 = type != 19;
            D.25516 = (long int) D.25515;
            D.25517 = __builtin_expect (D.25516, 0);
            if (D.25517 != 0) goto <D.25518>; else goto <D.25519>;
            <D.25518>:
            monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "aot-runtime.c", 467, "type == MONO_TYPE_VAR");
            <D.25519>:
            p.75 = p;
            class_def = decode_klass_ref (module, p.75, &p);
            if (class_def == 0B) goto <D.25520>; else goto <D.25521>;
            <D.25520>:
            D.25477 = 0B;
            return D.25477;
            <D.25521>:
            container = class_def->generic_container;
          }
          <D.25514>:
        }
        goto <D.25522>;
        <D.25504>:
        p.75 = p;
        serial = decode_value (p.75, &p);
        <D.25522>:
        t = monoeg_malloc0 (8);
        D.25523 = (unsigned char) type;
        t->type = D.25523;
        if (container != 0B) goto <D.25524>; else goto <D.25525>;
        <D.25524>:
        D.25526 = container->type_params;
        num.76 = (unsigned int) num;
        D.25528 = num.76 * 32;
        D.25529 = D.25526 + D.25528;
        t->data.generic_param = D.25529;
        D.25530 = serial != 0;
        D.25531 = (long int) D.25530;
        D.25532 = __builtin_expect (D.25531, 0);
        if (D.25532 != 0) goto <D.25533>; else goto <D.25534>;
        <D.25533>:
        monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "aot-runtime.c", 483, "serial == 0");
        <D.25534>:
        goto <D.25535>;
        <D.25525>:
        {
          struct MonoGenericParam * par;

          par = monoeg_malloc0 (32);
          D.25536 = (short unsigned int) num;
          par->num = D.25536;
          D.25537 = (short unsigned int) serial;
          par->serial = D.25537;
          D.25538 = mono_defaults.corlib;
          par->image = D.25538;
          t->data.generic_param = par;
        }
        <D.25535>:
        klass = mono_class_from_mono_type (t);
        monoeg_g_free (t);
        goto <D.22759>;
      }
      <D.22777>:
      p.75 = p;
      D.25539 = decode_value (p.75, &p);
      rank = (guint32) D.25539;
      p.75 = p;
      eklass = decode_klass_ref (module, p.75, &p);
      klass = mono_array_class_get (eklass, rank);
      goto <D.22759>;
      <D.22778>:
      {
        struct MonoType * t;

        p.75 = p;
        t = decode_type (module, p.75, &p);
        if (t == 0B) goto <D.25540>; else goto <D.25541>;
        <D.25540>:
        D.25477 = 0B;
        return D.25477;
        <D.25541>:
        klass = mono_class_from_mono_type (t);
        monoeg_g_free (t);
        goto <D.22759>;
      }
      <D.22780>:
      {
        guint32 offset;
        guint8 * p2;

        try
          {
            p.75 = p;
            D.25542 = decode_value (p.75, &p);
            offset = (guint32) D.25542;
            D.25543 = module->blob;
            p2.77 = D.25543 + offset;
            p2 = p2.77;
            p2.78 = p2;
            klass = decode_klass_ref (module, p2.78, &p2);
            goto <D.22759>;
          }
        finally
          {
            p2 = {CLOBBER};
          }
      }
      <D.22783>:
      monoeg_assertion_message ("* Assertion: should not be reached at %s:%d\n", "aot-runtime.c", 526);
      <D.22759>:
      D.25546 = klass == 0B;
      D.25547 = (long int) D.25546;
      D.25548 = __builtin_expect (D.25547, 0);
      if (D.25548 != 0) goto <D.25549>; else goto <D.25550>;
      <D.25549>:
      monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "aot-runtime.c", 528, "klass");
      <D.25550>:
      p.75 = p;
      *endbuf = p.75;
      D.25477 = klass;
      return D.25477;
    }
  finally
    {
      p = {CLOBBER};
    }
}


mono_aot_get_cached_class_info (struct MonoClass * klass, struct MonoCachedClassInfo * res)
{
  struct MonoImage * D.25556;
  unsigned char D.25559;
  gboolean D.25561;
  guint8 * D.25562;
  guint32 * D.25563;
  unsigned int D.25564;
  unsigned int D.25565;
  unsigned int D.25566;
  int D.25567;
  unsigned int D.25568;
  guint8 * p.79;
  guint8 * p.80;
  struct MonoAotModule * amodule;
  guint8 * p;
  gboolean err;

  try
    {
      D.25556 = klass->image;
      amodule = D.25556->aot_module;
      D.25559 = klass->rank;
      if (D.25559 != 0) goto <D.25557>; else goto <D.25560>;
      <D.25560>:
      if (amodule == 0B) goto <D.25557>; else goto <D.25558>;
      <D.25557>:
      D.25561 = 0;
      return D.25561;
      <D.25558>:
      D.25562 = amodule->blob;
      D.25563 = amodule->class_info_offsets;
      D.25564 = klass->type_token;
      D.25565 = D.25564 & 16777215;
      D.25566 = D.25565 + 4294967295;
      D.25567 = (int) D.25566;
      D.25568 = mono_aot_get_offset (D.25563, D.25567);
      p.79 = D.25562 + D.25568;
      p = p.79;
      p.80 = p;
      err = decode_cached_class_info (amodule, res, p.80, &p);
      if (err == 0) goto <D.25571>; else goto <D.25572>;
      <D.25571>:
      D.25561 = 0;
      return D.25561;
      <D.25572>:
      D.25561 = 1;
      return D.25561;
    }
  finally
    {
      p = {CLOBBER};
    }
}


mono_aot_get_class_from_name (struct MonoImage * image, const char * name_space, const char * name, struct MonoClass * * klass)
{
  guint16 * D.25578;
  gboolean D.25579;
  _Bool D.25582;
  long int D.25583;
  long int D.25584;
  struct GHashTable * D.25587;
  struct GHashTable * D.25590;
  void * D.25593;
  struct MonoClass * D.25594;
  _Bool D.25599;
  long int D.25600;
  long int D.25601;
  char D.25604;
  unsigned int D.25608;
  unsigned int D.25609;
  unsigned int D.25610;
  unsigned int D.25614;
  unsigned int D.25615;
  unsigned int D.25618;
  short unsigned int D.25619;
  guint16 * D.25622;
  short unsigned int D.25623;
  unsigned int name_table_accesses.81;
  unsigned int name_table_accesses.82;
  unsigned int D.25626;
  int D.25627;
  unsigned int D.25628;
  unsigned int D.25629;
  int D.23243;
  int D.23252;
  _Bool D.25636;
  long int D.25637;
  long int D.25638;
  struct MonoClass * D.25641;
  _Bool D.25646;
  long int D.25647;
  long int D.25648;
  _Bool D.25655;
  long int D.25656;
  long int D.25657;
  unsigned int D.25661;
  _Bool D.25664;
  long int D.25665;
  long int D.25666;
  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.25575>; else goto <D.25577>;
      <D.25577>:
      D.25578 = amodule->class_name_table;
      if (D.25578 == 0B) goto <D.25575>; else goto <D.25576>;
      <D.25575>:
      D.25579 = 0;
      return D.25579;
      <D.25576>:
      {
        int ret;

        ret = pthread_mutex_lock (&aot_mutex.mutex);
        if (ret != 0) goto <D.25580>; else goto <D.25581>;
        <D.25580>:
        monoeg_g_log (0B, 16, "Bad call to mono_mutex_lock result %d", ret);
        <D.25581>:
        D.25582 = ret != 0;
        D.25583 = (long int) D.25582;
        D.25584 = __builtin_expect (D.25583, 0);
        if (D.25584 != 0) goto <D.25585>; else goto <D.25586>;
        <D.25585>:
        monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "aot-runtime.c", 2065, "ret == 0");
        <D.25586>:
      }
      *klass = 0B;
      D.25587 = amodule->name_cache;
      if (D.25587 == 0B) goto <D.25588>; else goto <D.25589>;
      <D.25588>:
      D.25590 = monoeg_g_hash_table_new (monoeg_g_str_hash, monoeg_g_str_equal);
      amodule->name_cache = D.25590;
      <D.25589>:
      D.25587 = amodule->name_cache;
      nspace_table = monoeg_g_hash_table_lookup (D.25587, name_space);
      if (nspace_table != 0B) goto <D.25591>; else goto <D.25592>;
      <D.25591>:
      D.25593 = monoeg_g_hash_table_lookup (nspace_table, name);
      *klass = D.25593;
      D.25594 = *klass;
      if (D.25594 != 0B) goto <D.25595>; else goto <D.25596>;
      <D.25595>:
      {
        int ret;

        ret = pthread_mutex_unlock (&aot_mutex.mutex);
        if (ret != 0) goto <D.25597>; else goto <D.25598>;
        <D.25597>:
        monoeg_g_log (0B, 16, "Bad call to mono_mutex_unlock result %d", ret);
        <D.25598>:
        D.25599 = ret != 0;
        D.25600 = (long int) D.25599;
        D.25601 = __builtin_expect (D.25600, 0);
        if (D.25601 != 0) goto <D.25602>; else goto <D.25603>;
        <D.25602>:
        monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "aot-runtime.c", 2076, "ret == 0");
        <D.25603>:
      }
      D.25579 = 1;
      return D.25579;
      <D.25596>:
      <D.25592>:
      D.25578 = amodule->class_name_table;
      table_size = *D.25578;
      D.25578 = amodule->class_name_table;
      table = D.25578 + 2;
      D.25604 = *name_space;
      if (D.25604 == 0) goto <D.25605>; else goto <D.25606>;
      <D.25605>:
      full_name = monoeg_g_strdup_printf ("%s", name);
      goto <D.25607>;
      <D.25606>:
      D.25608 = strlen (name_space);
      D.25609 = strlen (name);
      D.25610 = D.25608 + D.25609;
      if (D.25610 <= 999) goto <D.25611>; else goto <D.25612>;
      <D.25611>:
      sprintf (&full_name_buf, "%s.%s", name_space, name);
      full_name = &full_name_buf;
      goto <D.25613>;
      <D.25612>:
      full_name = monoeg_g_strdup_printf ("%s.%s", name_space, name);
      <D.25613>:
      <D.25607>:
      D.25614 = mono_metadata_str_hash (full_name);
      D.25615 = (unsigned int) table_size;
      hash = D.25614 % D.25615;
      if (&full_name_buf != full_name) goto <D.25616>; else goto <D.25617>;
      <D.25616>:
      monoeg_g_free (full_name);
      <D.25617>:
      D.25618 = hash * 4;
      entry = table + D.25618;
      D.25619 = *entry;
      if (D.25619 != 0) goto <D.25620>; else goto <D.25621>;
      <D.25620>:
      t = &image->tables[2];
      <D.23257>:
      {
        guint32 index;
        guint32 next;
        guint32 token;

        D.25619 = *entry;
        index = (guint32) D.25619;
        D.25622 = entry + 2;
        D.25623 = *D.25622;
        next = (guint32) D.25623;
        token = index | 33554432;
        name_table_accesses.81 = name_table_accesses;
        name_table_accesses.82 = name_table_accesses.81 + 1;
        name_table_accesses = name_table_accesses.82;
        D.25626 = index + 4294967295;
        D.25627 = (int) D.25626;
        mono_metadata_decode_row (t, D.25627, &cols, 6);
        D.25628 = cols[1];
        name2 = mono_metadata_string_heap (image, D.25628);
        D.25629 = cols[2];
        name_space2 = mono_metadata_string_heap (image, D.25629);
        {
          size_t __s1_len;
          size_t __s2_len;

          D.23243 = __builtin_strcmp (name, name2);
        }
        if (D.23243 == 0) goto <D.25630>; else goto <D.25631>;
        <D.25630>:
        {
          size_t __s1_len;
          size_t __s2_len;

          D.23252 = __builtin_strcmp (name_space, name_space2);
        }
        if (D.23252 == 0) goto <D.25632>; else goto <D.25633>;
        <D.25632>:
        {
          int ret;

          ret = pthread_mutex_unlock (&aot_mutex.mutex);
          if (ret != 0) goto <D.25634>; else goto <D.25635>;
          <D.25634>:
          monoeg_g_log (0B, 16, "Bad call to mono_mutex_unlock result %d", ret);
          <D.25635>:
          D.25636 = ret != 0;
          D.25637 = (long int) D.25636;
          D.25638 = __builtin_expect (D.25637, 0);
          if (D.25638 != 0) goto <D.25639>; else goto <D.25640>;
          <D.25639>:
          monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "aot-runtime.c", 2116, "ret == 0");
          <D.25640>:
        }
        D.25641 = mono_class_get (image, token);
        *klass = D.25641;
        D.25594 = *klass;
        if (D.25594 != 0B) goto <D.25642>; else goto <D.25643>;
        <D.25642>:
        {
          int ret;

          ret = pthread_mutex_lock (&aot_mutex.mutex);
          if (ret != 0) goto <D.25644>; else goto <D.25645>;
          <D.25644>:
          monoeg_g_log (0B, 16, "Bad call to mono_mutex_lock result %d", ret);
          <D.25645>:
          D.25646 = ret != 0;
          D.25647 = (long int) D.25646;
          D.25648 = __builtin_expect (D.25647, 0);
          if (D.25648 != 0) goto <D.25649>; else goto <D.25650>;
          <D.25649>:
          monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "aot-runtime.c", 2121, "ret == 0");
          <D.25650>:
        }
        D.25587 = amodule->name_cache;
        nspace_table = monoeg_g_hash_table_lookup (D.25587, name_space);
        if (nspace_table == 0B) goto <D.25651>; else goto <D.25652>;
        <D.25651>:
        nspace_table = monoeg_g_hash_table_new (monoeg_g_str_hash, monoeg_g_str_equal);
        D.25587 = amodule->name_cache;
        monoeg_g_hash_table_insert_replace (D.25587, name_space2, nspace_table, 0);
        <D.25652>:
        D.25594 = *klass;
        monoeg_g_hash_table_insert_replace (nspace_table, name2, D.25594, 0);
        {
          int ret;

          ret = pthread_mutex_unlock (&aot_mutex.mutex);
          if (ret != 0) goto <D.25653>; else goto <D.25654>;
          <D.25653>:
          monoeg_g_log (0B, 16, "Bad call to mono_mutex_unlock result %d", ret);
          <D.25654>:
          D.25655 = ret != 0;
          D.25656 = (long int) D.25655;
          D.25657 = __builtin_expect (D.25656, 0);
          if (D.25657 != 0) goto <D.25658>; else goto <D.25659>;
          <D.25658>:
          monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "aot-runtime.c", 2128, "ret == 0");
          <D.25659>:
        }
        <D.25643>:
        D.25579 = 1;
        return D.25579;
        <D.25633>:
        <D.25631>:
        if (next != 0) goto <D.25660>; else goto <D.23256>;
        <D.25660>:
        D.25661 = next * 4;
        entry = table + D.25661;
      }
      goto <D.23257>;
      <D.23256>:
      <D.25621>:
      {
        int ret;

        ret = pthread_mutex_unlock (&aot_mutex.mutex);
        if (ret != 0) goto <D.25662>; else goto <D.25663>;
        <D.25662>:
        monoeg_g_log (0B, 16, "Bad call to mono_mutex_unlock result %d", ret);
        <D.25663>:
        D.25664 = ret != 0;
        D.25665 = (long int) D.25664;
        D.25666 = __builtin_expect (D.25665, 0);
        if (D.25666 != 0) goto <D.25667>; else goto <D.25668>;
        <D.25667>:
        monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "aot-runtime.c", 2141, "ret == 0");
        <D.25668>:
      }
      D.25579 = 1;
      return D.25579;
    }
  finally
    {
      full_name_buf = {CLOBBER};
      cols = {CLOBBER};
    }
}


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

  D.25672 = __builtin_object_size (__s, 1);
  D.25671 = __builtin___sprintf_chk (__s, 1, D.25672, __fmt, __builtin_va_arg_pack ());
  return D.25671;
}


mono_aot_get_unwind_info (struct MonoJitInfo * ji, guint32 * unwind_info_len)
{
  unsigned int D.25674;
  unsigned int D.25675;
  struct MonoMethod * D.25679;
  struct MonoClass * D.25680;
  struct MonoImage * D.25681;
  _Bool D.25682;
  long int D.25683;
  long int D.25684;
  unsigned int D.25687;
  _Bool D.25688;
  long int D.25689;
  long int D.25690;
  guint8 * D.25695;
  guint8 * D.25697;
  _Bool D.25700;
  long int D.25701;
  long int D.25702;
  struct GHashTable * ji_to_amodule.83;
  _Bool D.25706;
  long int D.25707;
  long int D.25708;
  int iftmp.84;
  _Bool D.25718;
  long int D.25719;
  long int D.25720;
  _Bool D.25725;
  long int D.25726;
  long int D.25727;
  guint8 * D.25730;
  unsigned int D.25731;
  guint8 * p.85;
  guint8 * p.86;
  int D.25734;
  unsigned int D.25735;
  guint8 * D.25736;
  struct MonoAotModule * amodule;
  guint8 * p;
  guint8 * code;

  try
    {
      code = ji->code_start;
      D.25674 = BIT_FIELD_REF <*ji, 32, 160>;
      D.25675 = D.25674 & 16777216;
      if (D.25675 != 0) goto <D.25676>; else goto <D.25677>;
      <D.25676>:
      amodule = ji->d.aot_info;
      goto <D.25678>;
      <D.25677>:
      D.25679 = jinfo_get_method (ji);
      D.25680 = D.25679->klass;
      D.25681 = D.25680->image;
      amodule = D.25681->aot_module;
      <D.25678>:
      D.25682 = amodule == 0B;
      D.25683 = (long int) D.25682;
      D.25684 = __builtin_expect (D.25683, 0);
      if (D.25684 != 0) goto <D.25685>; else goto <D.25686>;
      <D.25685>:
      monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "aot-runtime.c", 2655, "amodule");
      <D.25686>:
      D.25674 = BIT_FIELD_REF <*ji, 32, 160>;
      D.25687 = D.25674 & 1048576;
      D.25688 = D.25687 == 0;
      D.25689 = (long int) D.25688;
      D.25690 = __builtin_expect (D.25689, 0);
      if (D.25690 != 0) goto <D.25691>; else goto <D.25692>;
      <D.25691>:
      monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "aot-runtime.c", 2656, "ji->from_aot");
      <D.25692>:
      D.25695 = amodule->code;
      if (D.25695 > code) goto <D.25693>; else goto <D.25696>;
      <D.25696>:
      D.25697 = amodule->code_end;
      if (D.25697 < code) goto <D.25693>; else goto <D.25694>;
      <D.25693>:
      {
        int ret;

        ret = pthread_mutex_lock (&aot_mutex.mutex);
        if (ret != 0) goto <D.25698>; else goto <D.25699>;
        <D.25698>:
        monoeg_g_log (0B, 16, "Bad call to mono_mutex_lock result %d", ret);
        <D.25699>:
        D.25700 = ret != 0;
        D.25701 = (long int) D.25700;
        D.25702 = __builtin_expect (D.25701, 0);
        if (D.25702 != 0) goto <D.25703>; else goto <D.25704>;
        <D.25703>:
        monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "aot-runtime.c", 2660, "ret == 0");
        <D.25704>:
      }
      ji_to_amodule.83 = ji_to_amodule;
      D.25706 = ji_to_amodule.83 == 0B;
      D.25707 = (long int) D.25706;
      D.25708 = __builtin_expect (D.25707, 0);
      if (D.25708 != 0) goto <D.25709>; else goto <D.25710>;
      <D.25709>:
      monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "aot-runtime.c", 2661, "ji_to_amodule");
      <D.25710>:
      ji_to_amodule.83 = ji_to_amodule;
      amodule = monoeg_g_hash_table_lookup (ji_to_amodule.83, ji);
      D.25682 = amodule == 0B;
      D.25683 = (long int) D.25682;
      D.25684 = __builtin_expect (D.25683, 0);
      if (D.25684 != 0) goto <D.25711>; else goto <D.25712>;
      <D.25711>:
      monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "aot-runtime.c", 2663, "amodule");
      <D.25712>:
      D.25695 = amodule->code;
      if (D.25695 > code) goto <D.25714>; else goto <D.25717>;
      <D.25717>:
      D.25697 = amodule->code_end;
      if (D.25697 < code) goto <D.25714>; else goto <D.25715>;
      <D.25714>:
      iftmp.84 = 1;
      goto <D.25716>;
      <D.25715>:
      iftmp.84 = 0;
      <D.25716>:
      D.25718 = iftmp.84 != 0;
      D.25719 = (long int) D.25718;
      D.25720 = __builtin_expect (D.25719, 0);
      if (D.25720 != 0) goto <D.25721>; else goto <D.25722>;
      <D.25721>:
      monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "aot-runtime.c", 2664, "code >= amodule->code && code <= amodule->code_end");
      <D.25722>:
      {
        int ret;

        ret = pthread_mutex_unlock (&aot_mutex.mutex);
        if (ret != 0) goto <D.25723>; else goto <D.25724>;
        <D.25723>:
        monoeg_g_log (0B, 16, "Bad call to mono_mutex_unlock result %d", ret);
        <D.25724>:
        D.25725 = ret != 0;
        D.25726 = (long int) D.25725;
        D.25727 = __builtin_expect (D.25726, 0);
        if (D.25727 != 0) goto <D.25728>; else goto <D.25729>;
        <D.25728>:
        monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "aot-runtime.c", 2665, "ret == 0");
        <D.25729>:
      }
      <D.25694>:
      D.25730 = amodule->unwind_info;
      D.25731 = ji->used_regs;
      p.85 = D.25730 + D.25731;
      p = p.85;
      p.86 = p;
      D.25734 = decode_value (p.86, &p);
      D.25735 = (unsigned int) D.25734;
      *unwind_info_len = D.25735;
      D.25736 = p;
      return D.25736;
    }
  finally
    {
      p = {CLOBBER};
    }
}


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

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


mono_aot_find_jit_info (struct MonoDomain * domain, struct MonoImage * image, void * addr)
{
  unsigned int D.25741;
  struct MonoJitInfo * D.25744;
  struct MonoDomain * D.25745;
  int addr.87;
  guint8 * D.25749;
  int D.25750;
  gint32 * D.25751;
  unsigned int nmethods.88;
  unsigned int D.25755;
  gint32 * D.25756;
  unsigned int i.89;
  unsigned int D.25758;
  gint32 * D.25759;
  int D.25760;
  unsigned int offsets_len.90;
  unsigned int D.25764;
  gint32 * D.25765;
  sizetype offsets_len.91;
  sizetype D.25767;
  sizetype D.25768;
  gint32 * D.25769;
  unsigned int D.25770;
  gint32 * D.25771;
  int D.25772;
  int D.25773;
  unsigned int D.25774;
  unsigned int D.25775;
  gint32 * D.25776;
  int D.25777;
  _Bool D.25778;
  long int D.25779;
  long int D.25780;
  int D.25783;
  gint32 * * D.25784;
  void * D.25785;
  int D.25792;
  guint8 * D.25794;
  int D.25795;
  int D.25796;
  int D.25797;
  unsigned int pos.92;
  unsigned int D.25799;
  gint32 * D.25800;
  int D.25801;
  unsigned int D.25805;
  unsigned int D.25806;
  gint32 * D.25807;
  int D.25812;
  _Bool D.25813;
  long int D.25814;
  long int D.25815;
  int D.25820;
  _Bool D.25821;
  long int D.25822;
  long int D.25823;
  sizetype pos.93;
  sizetype D.25827;
  sizetype D.25828;
  gint32 * D.25829;
  struct JitInfoMap * D.25834;
  int D.25835;
  unsigned int method_index.94;
  unsigned int D.25839;
  gint32 * D.25840;
  int D.25841;
  sizetype D.25842;
  guint8 * D.25843;
  guint32 * D.25844;
  unsigned int D.25845;
  int code.95;
  int iftmp.96;
  sizetype code_len.97;
  guint8 * D.25856;
  _Bool D.25857;
  long int D.25858;
  long int D.25859;
  struct GHashTable * D.25864;
  _Bool D.25869;
  long int D.25870;
  long int D.25871;
  const void * method_index.98;
  _Bool D.25877;
  long int D.25878;
  long int D.25879;
  <unnamed-unsigned:24> D.25885;
  int D.25886;
  guint32 * D.25889;
  unsigned int D.25890;
  _Bool D.25891;
  long int D.25892;
  long int D.25893;
  guint32 * D.25896;
  unsigned int D.25897;
  unsigned int method_index.99;
  guint32 * D.25903;
  unsigned int D.25904;
  guint8 * p.100;
  guint8 * p.101;
  int D.25910;
  int D.25911;
  _Bool D.25912;
  long int D.25913;
  long int D.25914;
  unsigned int code_len.102;
  void * D.25918;
  _Bool D.25919;
  long int D.25920;
  long int D.25921;
  int D.25924;
  sizetype D.25925;
  guint8 * D.25926;
  _Bool D.25927;
  long int D.25928;
  long int D.25929;
  int D.25937;
  unsigned int D.25938;
  unsigned int D.25939;
  int D.25940;
  unsigned int len.103;
  unsigned int D.25944;
  struct JitInfoMap * D.25945;
  struct JitInfoMap * * D.25946;
  void * D.25947;
  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.25741 = amodule->info.nmethods;
      nmethods = (int) D.25741;
      if (amodule == 0B) goto <D.25742>; else goto <D.25743>;
      <D.25742>:
      D.25744 = 0B;
      return D.25744;
      <D.25743>:
      D.25745 = mono_get_root_domain ();
      if (D.25745 != domain) goto <D.25746>; else goto <D.25747>;
      <D.25746>:
      D.25744 = 0B;
      return D.25744;
      <D.25747>:
      async = mono_thread_info_is_async_context ();
      addr.87 = (int) addr;
      D.25749 = amodule->code;
      D.25750 = (int) D.25749;
      offset = addr.87 - D.25750;
      D.25751 = amodule->sorted_code_offsets;
      if (D.25751 == 0B) goto <D.25752>; else goto <D.25753>;
      <D.25752>:
      nmethods.88 = (unsigned int) nmethods;
      D.25755 = nmethods.88 * 8;
      code_offsets = monoeg_malloc0 (D.25755);
      offsets_len = 0;
      i = 0;
      goto <D.23497>;
      <D.23496>:
      D.25756 = amodule->code_offsets;
      i.89 = (unsigned int) i;
      D.25758 = i.89 * 4;
      D.25759 = D.25756 + D.25758;
      D.25760 = *D.25759;
      if (D.25760 == -1) goto <D.25761>; else goto <D.25762>;
      <D.25761>:
      // predicted unlikely by continue predictor.
      goto <D.23495>;
      <D.25762>:
      offsets_len.90 = (unsigned int) offsets_len;
      D.25764 = offsets_len.90 * 8;
      D.25765 = code_offsets + D.25764;
      D.25756 = amodule->code_offsets;
      i.89 = (unsigned int) i;
      D.25758 = i.89 * 4;
      D.25759 = D.25756 + D.25758;
      D.25760 = *D.25759;
      *D.25765 = D.25760;
      offsets_len.91 = (sizetype) offsets_len;
      D.25767 = offsets_len.91 * 8;
      D.25768 = D.25767 + 4;
      D.25769 = code_offsets + D.25768;
      *D.25769 = i;
      offsets_len = offsets_len + 1;
      <D.23495>:
      i = i + 1;
      <D.23497>:
      if (i < nmethods) goto <D.23496>; else goto <D.23498>;
      <D.23498>:
      msort_code_offsets (code_offsets, offsets_len);
      i = 0;
      goto <D.23500>;
      <D.23499>:
      i.89 = (unsigned int) i;
      D.25770 = i.89 * 8;
      D.25771 = code_offsets + D.25770;
      D.25772 = *D.25771;
      D.25773 = i + 1;
      D.25774 = (unsigned int) D.25773;
      D.25775 = D.25774 * 8;
      D.25776 = code_offsets + D.25775;
      D.25777 = *D.25776;
      D.25778 = D.25772 > D.25777;
      D.25779 = (long int) D.25778;
      D.25780 = __builtin_expect (D.25779, 0);
      if (D.25780 != 0) goto <D.25781>; else goto <D.25782>;
      <D.25781>:
      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.25782>:
      i = i + 1;
      <D.23500>:
      D.25783 = offsets_len + -1;
      if (D.25783 > i) goto <D.23499>; else goto <D.23501>;
      <D.23501>:
      amodule->sorted_code_offsets_len = offsets_len;
      mono_memory_barrier ();
      D.25784 = &amodule->sorted_code_offsets;
      D.25785 = InterlockedCompareExchangePointer (D.25784, code_offsets, 0B);
      if (D.25785 != 0B) goto <D.25786>; else goto <D.25787>;
      <D.25786>:
      monoeg_g_free (code_offsets);
      <D.25787>:
      <D.25753>:
      code_offsets = amodule->sorted_code_offsets;
      offsets_len = amodule->sorted_code_offsets_len;
      if (offsets_len > 0) goto <D.25790>; else goto <D.25791>;
      <D.25790>:
      D.25792 = *code_offsets;
      if (D.25792 > offset) goto <D.25788>; else goto <D.25793>;
      <D.25793>:
      D.25794 = amodule->code_end;
      D.25795 = (int) D.25794;
      D.25749 = amodule->code;
      D.25750 = (int) D.25749;
      D.25796 = D.25795 - D.25750;
      if (D.25796 <= offset) goto <D.25788>; else goto <D.25789>;
      <D.25788>:
      D.25744 = 0B;
      return D.25744;
      <D.25789>:
      <D.25791>:
      left = 0;
      right = offsets_len;
      <D.23503>:
      D.25797 = left + right;
      pos = D.25797 / 2;
      pos.92 = (unsigned int) pos;
      D.25799 = pos.92 * 8;
      D.25800 = code_offsets + D.25799;
      offset1 = *D.25800;
      D.25801 = pos + 1;
      if (D.25801 == offsets_len) goto <D.25802>; else goto <D.25803>;
      <D.25802>:
      D.25794 = amodule->code_end;
      D.25795 = (int) D.25794;
      D.25749 = amodule->code;
      D.25750 = (int) D.25749;
      offset2 = D.25795 - D.25750;
      goto <D.25804>;
      <D.25803>:
      D.25801 = pos + 1;
      D.25805 = (unsigned int) D.25801;
      D.25806 = D.25805 * 8;
      D.25807 = code_offsets + D.25806;
      offset2 = *D.25807;
      <D.25804>:
      if (offset < offset1) goto <D.25808>; else goto <D.25809>;
      <D.25808>:
      right = pos;
      goto <D.25810>;
      <D.25809>:
      if (offset >= offset2) goto <D.25811>; else goto <D.23502>;
      <D.25811>:
      left = pos + 1;
      <D.25810>:
      goto <D.23503>;
      <D.23502>:
      pos.92 = (unsigned int) pos;
      D.25799 = pos.92 * 8;
      D.25800 = code_offsets + D.25799;
      D.25812 = *D.25800;
      D.25813 = D.25812 > offset;
      D.25814 = (long int) D.25813;
      D.25815 = __builtin_expect (D.25814, 0);
      if (D.25815 != 0) goto <D.25816>; else goto <D.25817>;
      <D.25816>:
      monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "aot-runtime.c", 2819, "offset >= code_offsets [(pos * 2)]");
      <D.25817>:
      D.25801 = pos + 1;
      if (D.25801 < offsets_len) goto <D.25818>; else goto <D.25819>;
      <D.25818>:
      D.25801 = pos + 1;
      D.25805 = (unsigned int) D.25801;
      D.25806 = D.25805 * 8;
      D.25807 = code_offsets + D.25806;
      D.25820 = *D.25807;
      D.25821 = D.25820 <= offset;
      D.25822 = (long int) D.25821;
      D.25823 = __builtin_expect (D.25822, 0);
      if (D.25823 != 0) goto <D.25824>; else goto <D.25825>;
      <D.25824>:
      monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "aot-runtime.c", 2821, "offset < code_offsets [((pos + 1) * 2)]");
      <D.25825>:
      <D.25819>:
      pos.93 = (sizetype) pos;
      D.25827 = pos.93 * 8;
      D.25828 = D.25827 + 4;
      D.25829 = code_offsets + D.25828;
      method_index = *D.25829;
      if (async != 0) goto <D.25830>; else goto <D.25831>;
      <D.25830>:
      {
        struct JitInfoMap * table;
        int len;

        table = amodule->async_jit_info_table;
        if (table != 0B) goto <D.25832>; else goto <D.25833>;
        <D.25832>:
        len = table->method_index;
        i = 1;
        goto <D.23507>;
        <D.23506>:
        i.89 = (unsigned int) i;
        D.25770 = i.89 * 8;
        D.25834 = table + D.25770;
        D.25835 = D.25834->method_index;
        if (D.25835 == method_index) goto <D.25836>; else goto <D.25837>;
        <D.25836>:
        i.89 = (unsigned int) i;
        D.25770 = i.89 * 8;
        D.25834 = table + D.25770;
        D.25744 = D.25834->jinfo;
        return D.25744;
        <D.25837>:
        i = i + 1;
        <D.23507>:
        if (i < len) goto <D.23506>; else goto <D.23508>;
        <D.23508>:
        <D.25833>:
      }
      <D.25831>:
      D.25749 = amodule->code;
      D.25756 = amodule->code_offsets;
      method_index.94 = (unsigned int) method_index;
      D.25839 = method_index.94 * 4;
      D.25840 = D.25756 + D.25839;
      D.25841 = *D.25840;
      D.25842 = (sizetype) D.25841;
      code = D.25749 + D.25842;
      D.25843 = amodule->blob;
      D.25844 = amodule->ex_info_offsets;
      D.25845 = mono_aot_get_offset (D.25844, method_index);
      ex_info = D.25843 + D.25845;
      D.25783 = offsets_len + -1;
      if (D.25783 == pos) goto <D.25846>; else goto <D.25847>;
      <D.25846>:
      D.25794 = amodule->code_end;
      D.25795 = (int) D.25794;
      code.95 = (int) code;
      code_len = D.25795 - code.95;
      goto <D.25849>;
      <D.25847>:
      D.25801 = pos + 1;
      D.25805 = (unsigned int) D.25801;
      D.25806 = D.25805 * 8;
      D.25807 = code_offsets + D.25806;
      D.25820 = *D.25807;
      pos.92 = (unsigned int) pos;
      D.25799 = pos.92 * 8;
      D.25800 = code_offsets + D.25799;
      D.25812 = *D.25800;
      code_len = D.25820 - D.25812;
      <D.25849>:
      if (code > addr) goto <D.25851>; else goto <D.25854>;
      <D.25854>:
      code_len.97 = (sizetype) code_len;
      D.25856 = code + code_len.97;
      if (D.25856 <= addr) goto <D.25851>; else goto <D.25852>;
      <D.25851>:
      iftmp.96 = 1;
      goto <D.25853>;
      <D.25852>:
      iftmp.96 = 0;
      <D.25853>:
      D.25857 = iftmp.96 != 0;
      D.25858 = (long int) D.25857;
      D.25859 = __builtin_expect (D.25858, 0);
      if (D.25859 != 0) goto <D.25860>; else goto <D.25861>;
      <D.25860>:
      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.25861>:
      if (async == 0) goto <D.25862>; else goto <D.25863>;
      <D.25862>:
      D.25864 = amodule->extra_methods;
      if (D.25864 != 0B) goto <D.25865>; else goto <D.25866>;
      <D.25865>:
      {
        int ret;

        ret = pthread_mutex_lock (&aot_mutex.mutex);
        if (ret != 0) goto <D.25867>; else goto <D.25868>;
        <D.25867>:
        monoeg_g_log (0B, 16, "Bad call to mono_mutex_lock result %d", ret);
        <D.25868>:
        D.25869 = ret != 0;
        D.25870 = (long int) D.25869;
        D.25871 = __builtin_expect (D.25870, 0);
        if (D.25871 != 0) goto <D.25872>; else goto <D.25873>;
        <D.25872>:
        monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "aot-runtime.c", 2851, "ret == 0");
        <D.25873>:
      }
      D.25864 = amodule->extra_methods;
      method_index.98 = (const void *) method_index;
      method = monoeg_g_hash_table_lookup (D.25864, method_index.98);
      {
        int ret;

        ret = pthread_mutex_unlock (&aot_mutex.mutex);
        if (ret != 0) goto <D.25875>; else goto <D.25876>;
        <D.25875>:
        monoeg_g_log (0B, 16, "Bad call to mono_mutex_unlock result %d", ret);
        <D.25876>:
        D.25877 = ret != 0;
        D.25878 = (long int) D.25877;
        D.25879 = __builtin_expect (D.25878, 0);
        if (D.25879 != 0) goto <D.25880>; else goto <D.25881>;
        <D.25880>:
        monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "aot-runtime.c", 2853, "ret == 0");
        <D.25881>:
      }
      goto <D.25882>;
      <D.25866>:
      method = 0B;
      <D.25882>:
      if (method == 0B) goto <D.25883>; else goto <D.25884>;
      <D.25883>:
      D.25885 = image->tables[6].rows;
      D.25886 = (int) D.25885;
      if (D.25886 <= method_index) goto <D.25887>; else goto <D.25888>;
      <D.25887>:
      D.25889 = amodule->extra_method_info_offsets;
      D.25890 = *D.25889;
      table_len = (int) D.25890;
      D.25889 = amodule->extra_method_info_offsets;
      table = D.25889 + 4;
      left = 0;
      right = table_len;
      pos = 0;
      <D.23512>:
      D.25797 = left + right;
      pos = D.25797 / 2;
      D.25891 = pos >= table_len;
      D.25892 = (long int) D.25891;
      D.25893 = __builtin_expect (D.25892, 0);
      if (D.25893 != 0) goto <D.25894>; else goto <D.25895>;
      <D.25894>:
      monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "aot-runtime.c", 2874, "pos < table_len");
      <D.25895>:
      pos.92 = (unsigned int) pos;
      D.25799 = pos.92 * 8;
      D.25896 = table + D.25799;
      D.25897 = *D.25896;
      method_index.99 = (unsigned int) method_index;
      if (D.25897 < method_index.99) goto <D.25899>; else goto <D.25900>;
      <D.25899>:
      left = pos + 1;
      goto <D.25901>;
      <D.25900>:
      pos.92 = (unsigned int) pos;
      D.25799 = pos.92 * 8;
      D.25896 = table + D.25799;
      D.25897 = *D.25896;
      method_index.99 = (unsigned int) method_index;
      if (D.25897 > method_index.99) goto <D.25902>; else goto <D.23511>;
      <D.25902>:
      right = pos;
      <D.25901>:
      goto <D.23512>;
      <D.23511>:
      D.25843 = amodule->blob;
      pos.93 = (sizetype) pos;
      D.25827 = pos.93 * 8;
      D.25828 = D.25827 + 4;
      D.25903 = table + D.25828;
      D.25904 = *D.25903;
      p.100 = D.25843 + D.25904;
      p = p.100;
      p.101 = p;
      method = decode_resolve_method_ref (amodule, p.101, &p);
      if (method == 0B) goto <D.25907>; else goto <D.25908>;
      <D.25907>:
      D.25744 = 0B;
      return D.25744;
      <D.25908>:
      goto <D.25909>;
      <D.25888>:
      D.25910 = method_index + 1;
      D.25911 = D.25910 | 100663296;
      token = (guint32) D.25911;
      method = mono_get_method (image, token, 0B);
      <D.25909>:
      <D.25884>:
      D.25912 = method == 0B;
      D.25913 = (long int) D.25912;
      D.25914 = __builtin_expect (D.25913, 0);
      if (D.25914 != 0) goto <D.25915>; else goto <D.25916>;
      <D.25915>:
      monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "aot-runtime.c", 2895, "method");
      <D.25916>:
      <D.25863>:
      code_len.102 = (unsigned int) code_len;
      jinfo = decode_exception_debug_info (amodule, domain, method, ex_info, addr, code, code_len.102);
      D.25918 = jinfo->code_start;
      D.25919 = D.25918 > addr;
      D.25920 = (long int) D.25919;
      D.25921 = __builtin_expect (D.25920, 0);
      if (D.25921 != 0) goto <D.25922>; else goto <D.25923>;
      <D.25922>:
      monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "aot-runtime.c", 2902, "(guint8*)addr >= (guint8*)jinfo->code_start");
      <D.25923>:
      D.25918 = jinfo->code_start;
      D.25924 = jinfo->code_size;
      D.25925 = (sizetype) D.25924;
      D.25926 = D.25918 + D.25925;
      D.25927 = D.25926 <= addr;
      D.25928 = (long int) D.25927;
      D.25929 = __builtin_expect (D.25928, 0);
      if (D.25929 != 0) goto <D.25930>; else goto <D.25931>;
      <D.25930>:
      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.25931>:
      if (async != 0) goto <D.25932>; else goto <D.25933>;
      <D.25932>:
      {
        struct JitInfoMap * old_table;
        struct JitInfoMap * new_table;
        int len;

        <D.23517>:
        old_table = amodule->async_jit_info_table;
        if (old_table != 0B) goto <D.25934>; else goto <D.25935>;
        <D.25934>:
        len = old_table->method_index;
        goto <D.25936>;
        <D.25935>:
        len = 1;
        <D.25936>:
        D.25937 = len + 1;
        D.25938 = (unsigned int) D.25937;
        D.25939 = D.25938 * 8;
        D.25940 = (int) D.25939;
        new_table = alloc0_jit_info_data (domain, D.25940, async);
        if (old_table != 0B) goto <D.25941>; else goto <D.25942>;
        <D.25941>:
        len.103 = (unsigned int) len;
        D.25944 = len.103 * 8;
        memcpy (new_table, old_table, D.25944);
        <D.25942>:
        D.25937 = len + 1;
        new_table->method_index = D.25937;
        len.103 = (unsigned int) len;
        D.25944 = len.103 * 8;
        D.25945 = new_table + D.25944;
        D.25945->method_index = method_index;
        len.103 = (unsigned int) len;
        D.25944 = len.103 * 8;
        D.25945 = new_table + D.25944;
        D.25945->jinfo = jinfo;
        mono_memory_barrier ();
        D.25946 = &amodule->async_jit_info_table;
        D.25947 = InterlockedCompareExchangePointer (D.25946, new_table, old_table);
        if (D.25947 == old_table) goto <D.23516>; else goto <D.25948>;
        <D.25948>:
        goto <D.23517>;
        <D.23516>:
      }
      goto <D.25949>;
      <D.25933>:
      mono_jit_info_table_add (domain, jinfo);
      <D.25949>:
      D.25744 = jinfo;
      return D.25744;
    }
  finally
    {
      p = {CLOBBER};
    }
}


msort_code_offsets (gint32 * array, int len)
{
  unsigned int len.104;
  unsigned int D.25953;
  int D.25954;
  gint32 * scratch;

  len.104 = (unsigned int) len;
  D.25953 = len.104 * 8;
  scratch = monoeg_malloc (D.25953);
  D.25954 = len + -1;
  msort_code_offsets_internal (array, 0, D.25954, scratch);
  monoeg_g_free (scratch);
}


msort_code_offsets_internal (gint32 * array, int lo, int hi, gint32 * scratch)
{
  int D.25955;
  int D.25958;
  unsigned int i.105;
  unsigned int D.25962;
  gint32 * D.25963;
  int D.25964;
  sizetype i.106;
  sizetype D.25966;
  sizetype D.25967;
  gint32 * D.25968;
  int D.25969;
  int D.25973;
  unsigned int mid.107;
  unsigned int D.25975;
  gint32 * D.25976;
  int D.25977;
  unsigned int D.25978;
  unsigned int D.25979;
  gint32 * D.25980;
  int D.25981;
  unsigned int t_lo.108;
  unsigned int D.25990;
  gint32 * D.25991;
  int D.25992;
  unsigned int t_hi.109;
  unsigned int D.25994;
  gint32 * D.25995;
  int D.25996;
  gint32 * D.25997;
  sizetype D.25998;
  sizetype D.25999;
  gint32 * D.26000;
  sizetype t_lo.110;
  sizetype D.26002;
  sizetype D.26003;
  gint32 * D.26004;
  int D.26005;
  sizetype t_hi.111;
  sizetype D.26007;
  sizetype D.26008;
  gint32 * D.26009;
  int D.26010;
  int D.26011;
  gint32 * D.26012;
  int D.26013;
  int mid;
  int i;
  int t_lo;
  int t_hi;

  D.25955 = lo + hi;
  mid = D.25955 / 2;
  if (lo >= hi) goto <D.25956>; else goto <D.25957>;
  <D.25956>:
  return;
  <D.25957>:
  D.25958 = hi - lo;
  if (D.25958 <= 31) goto <D.25959>; else goto <D.25960>;
  <D.25959>:
  i = lo;
  goto <D.23456>;
  <D.23455>:
  i.105 = (unsigned int) i;
  D.25962 = i.105 * 8;
  D.25963 = array + D.25962;
  D.25964 = *D.25963;
  i.106 = (sizetype) i;
  D.25966 = i.106 + 1;
  D.25967 = D.25966 * 8;
  D.25968 = array + D.25967;
  D.25969 = *D.25968;
  if (D.25964 > D.25969) goto <D.23454>; else goto <D.25970>;
  <D.25970>:
  i = i + 1;
  <D.23456>:
  if (i < hi) goto <D.23455>; else goto <D.23454>;
  <D.23454>:
  if (i == hi) goto <D.25971>; else goto <D.25972>;
  <D.25971>:
  return;
  <D.25972>:
  <D.25960>:
  msort_code_offsets_internal (array, lo, mid, scratch);
  D.25973 = mid + 1;
  msort_code_offsets_internal (array, D.25973, hi, scratch);
  mid.107 = (unsigned int) mid;
  D.25975 = mid.107 * 8;
  D.25976 = array + D.25975;
  D.25977 = *D.25976;
  D.25973 = mid + 1;
  D.25978 = (unsigned int) D.25973;
  D.25979 = D.25978 * 8;
  D.25980 = array + D.25979;
  D.25981 = *D.25980;
  if (D.25977 < D.25981) goto <D.25982>; else goto <D.25983>;
  <D.25982>:
  return;
  <D.25983>:
  t_lo = lo;
  t_hi = mid + 1;
  i = lo;
  goto <D.23458>;
  <D.23457>:
  if (t_lo <= mid) goto <D.25987>; else goto <D.25984>;
  <D.25987>:
  if (t_hi > hi) goto <D.25985>; else goto <D.25988>;
  <D.25988>:
  t_lo.108 = (unsigned int) t_lo;
  D.25990 = t_lo.108 * 8;
  D.25991 = array + D.25990;
  D.25992 = *D.25991;
  t_hi.109 = (unsigned int) t_hi;
  D.25994 = t_hi.109 * 8;
  D.25995 = array + D.25994;
  D.25996 = *D.25995;
  if (D.25992 < D.25996) goto <D.25985>; else goto <D.25984>;
  <D.25985>:
  i.105 = (unsigned int) i;
  D.25962 = i.105 * 8;
  D.25997 = scratch + D.25962;
  t_lo.108 = (unsigned int) t_lo;
  D.25990 = t_lo.108 * 8;
  D.25991 = array + D.25990;
  D.25992 = *D.25991;
  *D.25997 = D.25992;
  i.106 = (sizetype) i;
  D.25998 = i.106 * 8;
  D.25999 = D.25998 + 4;
  D.26000 = scratch + D.25999;
  t_lo.110 = (sizetype) t_lo;
  D.26002 = t_lo.110 * 8;
  D.26003 = D.26002 + 4;
  D.26004 = array + D.26003;
  D.26005 = *D.26004;
  *D.26000 = D.26005;
  t_lo = t_lo + 1;
  goto <D.25986>;
  <D.25984>:
  i.105 = (unsigned int) i;
  D.25962 = i.105 * 8;
  D.25997 = scratch + D.25962;
  t_hi.109 = (unsigned int) t_hi;
  D.25994 = t_hi.109 * 8;
  D.25995 = array + D.25994;
  D.25996 = *D.25995;
  *D.25997 = D.25996;
  i.106 = (sizetype) i;
  D.25998 = i.106 * 8;
  D.25999 = D.25998 + 4;
  D.26000 = scratch + D.25999;
  t_hi.111 = (sizetype) t_hi;
  D.26007 = t_hi.111 * 8;
  D.26008 = D.26007 + 4;
  D.26009 = array + D.26008;
  D.26010 = *D.26009;
  *D.26000 = D.26010;
  t_hi = t_hi + 1;
  <D.25986>:
  i = i + 1;
  <D.23458>:
  if (i <= hi) goto <D.23457>; else goto <D.23459>;
  <D.23459>:
  i = lo;
  goto <D.23461>;
  <D.23460>:
  i.105 = (unsigned int) i;
  D.25962 = i.105 * 8;
  D.25963 = array + D.25962;
  i.105 = (unsigned int) i;
  D.25962 = i.105 * 8;
  D.25997 = scratch + D.25962;
  D.26011 = *D.25997;
  *D.25963 = D.26011;
  i.106 = (sizetype) i;
  D.25998 = i.106 * 8;
  D.25999 = D.25998 + 4;
  D.26012 = array + D.25999;
  i.106 = (sizetype) i;
  D.25998 = i.106 * 8;
  D.25999 = D.25998 + 4;
  D.26000 = scratch + D.25999;
  D.26013 = *D.26000;
  *D.26012 = D.26013;
  i = i + 1;
  <D.23461>:
  if (i <= hi) goto <D.23460>; else goto <D.23462>;
  <D.23462>:
}


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.112;
  int D.26016;
  unsigned int D.26017;
  _Bool D.26018;
  unsigned int D.26019;
  _Bool D.26020;
  unsigned int D.26021;
  _Bool D.26022;
  unsigned int D.26023;
  _Bool D.26024;
  unsigned int D.26025;
  _Bool D.26026;
  unsigned int D.26027;
  _Bool D.26028;
  unsigned int D.26029;
  _Bool D.26030;
  unsigned int D.26031;
  _Bool D.26032;
  int D.26035;
  _Bool D.26036;
  long int D.26037;
  long int D.26038;
  int D.26042;
  unsigned int num_holes.113;
  unsigned int D.26049;
  unsigned int D.26050;
  _Bool D.26060;
  long int D.26061;
  long int D.26062;
  unsigned int num_clauses.114;
  unsigned int D.26066;
  unsigned int D.26067;
  unsigned int i.115;
  unsigned int D.26069;
  int D.26070;
  unsigned int D.26071;
  int D.26072;
  struct MonoClass * D.26075;
  unsigned int D.26077;
  struct GSList * * D.26078;
  struct GSList * D.26079;
  void * nesting_index.116;
  struct GSList * D.26081;
  int D.26082;
  int D.26083;
  unsigned int generic_info_size.117;
  unsigned int D.26086;
  unsigned int try_holes_info_size.118;
  unsigned int D.26088;
  unsigned int arch_eh_jit_info_size.119;
  unsigned int D.26090;
  unsigned int D.26091;
  short unsigned int D.26092;
  <unnamed-unsigned:15> D.26093;
  int D.26094;
  unsigned int D.26095;
  int D.26096;
  unsigned int D.26097;
  unsigned int D.26098;
  int D.26101;
  sizetype D.26102;
  void * D.26103;
  sizetype len.120;
  guint8 * p.121;
  struct MonoClass * D.26112;
  int D.26113;
  sizetype D.26114;
  void * D.26115;
  int D.26116;
  sizetype D.26117;
  void * D.26118;
  int D.26119;
  sizetype D.26120;
  void * D.26121;
  <unnamed-unsigned:15> D.26122;
  int D.26123;
  int code_len.122;
  _Bool D.26127;
  long int D.26128;
  long int D.26129;
  short unsigned int D.26132;
  int D.26133;
  short unsigned int D.26134;
  int D.26135;
  short unsigned int D.26136;
  int D.26137;
  unsigned int D.26138;
  int D.26141;
  unsigned int D.26142;
  struct MonoJitInfo * D.26145;
  _Bool D.26148;
  long int D.26149;
  long int D.26150;
  int D.26153;
  int D.26154;
  unsigned int D.26157;
  unsigned int D.26158;
  int D.26159;
  void * D.26160;
  struct MonoDwarfLocListEntry * D.26161;
  unsigned int D.26162;
  int D.26163;
  int D.26164;
  int D.26165;
  int D.26168;
  int D.26171;
  int D.26172;
  int this_reg.123;
  _Bool D.26177;
  <unnamed-signed:1> D.26178;
  unsigned char D.26179;
  int this_offset.124;
  int D.26182;
  signed char D.26183;
  <unnamed-signed:1> D.26184;
  int D.26185;
  unsigned char D.26186;
  int D.26187;
  sizetype len.125;
  guint8 * p.126;
  struct MonoMethod * D.26193;
  void * D.26194;
  int D.26195;
  unsigned int n.127;
  unsigned int D.26201;
  int D.26202;
  void * D.26203;
  gboolean * D.26204;
  unsigned int i.128;
  unsigned int D.26206;
  gboolean * D.26207;
  int D.26208;
  void * D.26211;
  gboolean * D.26212;
  gboolean * D.26213;
  int D.26214;
  unsigned int len.129;
  unsigned int D.26220;
  unsigned int D.26221;
  int D.26222;
  int D.26223;
  int D.26224;
  int D.26225;
  int D.26226;
  unsigned int D.26227;
  unsigned int D.26228;
  void * D.26229;
  int * D.26230;
  unsigned int j.130;
  unsigned int D.26232;
  int * D.26233;
  int D.26234;
  union mono_mutex_t * D.26235;
  _Bool D.26238;
  long int D.26239;
  long int D.26240;
  void * D.26243;
  struct GHashTable * D.26244;
  _Bool D.26247;
  long int D.26248;
  long int D.26249;
  unsigned int buf_len.131;
  sizetype buf_len.132;
  guint8 * p.133;
  guint8 * p.134;
  unsigned int p.135;
  unsigned int D.26261;
  sizetype map_size.136;
  guint8 * p.137;
  struct MonoMethod * D.26264;
  struct MonoClass * D.26265;
  struct MonoImage * D.26266;
  void * D.26267;
  _Bool D.26272;
  long int D.26273;
  long int D.26274;
  struct GHashTable * ji_to_amodule.138;
  struct GHashTable * ji_to_amodule.139;
  _Bool D.26283;
  long int D.26284;
  long int D.26285;
  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.112 = p;
      D.26016 = decode_value (p.112, &p);
      flags = (guint) D.26016;
      D.26017 = flags & 1;
      D.26018 = D.26017 != 0;
      has_generic_jit_info = (gboolean) D.26018;
      D.26019 = flags & 2;
      D.26020 = D.26019 != 0;
      has_dwarf_unwind_info = (gboolean) D.26020;
      D.26021 = flags & 4;
      D.26022 = D.26021 != 0;
      has_clauses = (gboolean) D.26022;
      D.26023 = flags & 8;
      D.26024 = D.26023 != 0;
      has_seq_points = (gboolean) D.26024;
      D.26025 = flags & 16;
      D.26026 = D.26025 != 0;
      from_llvm = (gboolean) D.26026;
      D.26027 = flags & 32;
      D.26028 = D.26027 != 0;
      has_try_block_holes = (gboolean) D.26028;
      D.26029 = flags & 64;
      D.26030 = D.26029 != 0;
      has_gc_map = (gboolean) D.26030;
      D.26031 = flags & 128;
      D.26032 = D.26031 != 0;
      has_arch_eh_jit_info = (gboolean) D.26032;
      if (has_dwarf_unwind_info != 0) goto <D.26033>; else goto <D.26034>;
      <D.26033>:
      {
        guint32 offset;

        p.112 = p;
        D.26035 = decode_value (p.112, &p);
        offset = (guint32) D.26035;
        D.26036 = offset > 1073741823;
        D.26037 = (long int) D.26036;
        D.26038 = __builtin_expect (D.26037, 0);
        if (D.26038 != 0) goto <D.26039>; else goto <D.26040>;
        <D.26039>:
        monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "aot-runtime.c", 2383, "offset < (1 << 30)");
        <D.26040>:
        used_int_regs = offset;
      }
      goto <D.26041>;
      <D.26034>:
      p.112 = p;
      D.26042 = decode_value (p.112, &p);
      used_int_regs = (guint) D.26042;
      <D.26041>:
      if (has_generic_jit_info != 0) goto <D.26043>; else goto <D.26044>;
      <D.26043>:
      generic_info_size = 20;
      goto <D.26045>;
      <D.26044>:
      generic_info_size = 0;
      <D.26045>:
      if (has_try_block_holes != 0) goto <D.26046>; else goto <D.26047>;
      <D.26046>:
      p.112 = p;
      num_holes = decode_value (p.112, &p);
      num_holes.113 = (unsigned int) num_holes;
      D.26049 = num_holes.113 * 8;
      D.26050 = D.26049 + 4;
      try_holes_info_size = (int) D.26050;
      goto <D.26051>;
      <D.26047>:
      try_holes_info_size = 0;
      num_holes = try_holes_info_size;
      <D.26051>:
      if (has_clauses != 0) goto <D.26052>; else goto <D.26053>;
      <D.26052>:
      p.112 = p;
      num_clauses = decode_value (p.112, &p);
      goto <D.26054>;
      <D.26053>:
      num_clauses = 0;
      <D.26054>:
      if (has_arch_eh_jit_info != 0) goto <D.26055>; else goto <D.26056>;
      <D.26055>:
      arch_eh_jit_info_size = 4;
      goto <D.26057>;
      <D.26056>:
      arch_eh_jit_info_size = 0;
      <D.26057>:
      if (from_llvm != 0) goto <D.26058>; else goto <D.26059>;
      <D.26058>:
      {
        struct MonoJitExceptionInfo * clauses;
        struct GSList * * nesting;

        D.26060 = async != 0;
        D.26061 = (long int) D.26060;
        D.26062 = __builtin_expect (D.26061, 0);
        if (D.26062 != 0) goto <D.26063>; else goto <D.26064>;
        <D.26063>:
        monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "aot-runtime.c", 2414, "!async");
        <D.26064>:
        num_clauses.114 = (unsigned int) num_clauses;
        D.26066 = num_clauses.114 * 24;
        clauses = monoeg_malloc0 (D.26066);
        num_clauses.114 = (unsigned int) num_clauses;
        D.26067 = num_clauses.114 * 4;
        nesting = monoeg_malloc0 (D.26067);
        i = 0;
        goto <D.23378>;
        <D.23377>:
        {
          struct MonoJitExceptionInfo * ei;

          i.115 = (unsigned int) i;
          D.26069 = i.115 * 24;
          ei = clauses + D.26069;
          p.112 = p;
          D.26070 = decode_value (p.112, &p);
          D.26071 = (unsigned int) D.26070;
          ei->flags = D.26071;
          p.112 = p;
          D.26072 = decode_value (p.112, &p);
          if (D.26072 != 0) goto <D.26073>; else goto <D.26074>;
          <D.26073>:
          p.112 = p;
          D.26075 = decode_klass_ref (amodule, p.112, &p);
          ei->data.catch_class = D.26075;
          <D.26074>:
          <D.23376>:
          {
            int nesting_index;

            p.112 = p;
            nesting_index = decode_value (p.112, &p);
            if (nesting_index == -1) goto <D.23375>; else goto <D.26076>;
            <D.26076>:
            i.115 = (unsigned int) i;
            D.26077 = i.115 * 4;
            D.26078 = nesting + D.26077;
            i.115 = (unsigned int) i;
            D.26077 = i.115 * 4;
            D.26078 = nesting + D.26077;
            D.26079 = *D.26078;
            nesting_index.116 = (void *) nesting_index;
            D.26081 = monoeg_g_slist_prepend (D.26079, nesting_index.116);
            *D.26078 = D.26081;
          }
          goto <D.23376>;
          <D.23375>:
        }
        i = i + 1;
        <D.23378>:
        if (i < num_clauses) goto <D.23377>; else goto <D.23379>;
        <D.23379>:
        D.26082 = generic_info_size + try_holes_info_size;
        D.26083 = D.26082 + arch_eh_jit_info_size;
        jinfo = decode_llvm_mono_eh_frame (amodule, domain, method, code, clauses, num_clauses, D.26083, nesting, &this_reg, &this_offset);
        jinfo->from_llvm = -1;
        monoeg_g_free (clauses);
        i = 0;
        goto <D.23381>;
        <D.23380>:
        i.115 = (unsigned int) i;
        D.26077 = i.115 * 4;
        D.26078 = nesting + D.26077;
        D.26079 = *D.26078;
        monoeg_g_slist_free (D.26079);
        i = i + 1;
        <D.23381>:
        if (i < num_clauses) goto <D.23380>; else goto <D.23382>;
        <D.23382>:
        monoeg_g_free (nesting);
      }
      goto <D.26084>;
      <D.26059>:
      num_clauses.114 = (unsigned int) num_clauses;
      D.26066 = num_clauses.114 * 24;
      generic_info_size.117 = (unsigned int) generic_info_size;
      D.26086 = D.26066 + generic_info_size.117;
      try_holes_info_size.118 = (unsigned int) try_holes_info_size;
      D.26088 = D.26086 + try_holes_info_size.118;
      arch_eh_jit_info_size.119 = (unsigned int) arch_eh_jit_info_size;
      D.26090 = D.26088 + arch_eh_jit_info_size.119;
      D.26091 = D.26090 + 28;
      len = (int) D.26091;
      jinfo = alloc0_jit_info_data (domain, len, async);
      D.26092 = (short unsigned int) num_clauses;
      D.26093 = (<unnamed-unsigned:15>) D.26092;
      jinfo->num_clauses = D.26093;
      i = 0;
      goto <D.23386>;
      <D.23385>:
      {
        struct MonoJitExceptionInfo * ei;

        ei = &jinfo->clauses[i];
        p.112 = p;
        D.26094 = decode_value (p.112, &p);
        D.26095 = (unsigned int) D.26094;
        ei->flags = D.26095;
        p.112 = p;
        D.26096 = decode_value (p.112, &p);
        ei->exvar_offset = D.26096;
        D.26097 = ei->flags;
        D.26098 = D.26097 + 4294967295;
        if (D.26098 <= 1) goto <D.26099>; else goto <D.26100>;
        <D.26099>:
        p.112 = p;
        D.26101 = decode_value (p.112, &p);
        D.26102 = (sizetype) D.26101;
        D.26103 = code + D.26102;
        ei->data.filter = D.26103;
        goto <D.26104>;
        <D.26100>:
        {
          int len;

          p.112 = p;
          len = decode_value (p.112, &p);
          if (len > 0) goto <D.26105>; else goto <D.26106>;
          <D.26105>:
          if (async != 0) goto <D.26107>; else goto <D.26108>;
          <D.26107>:
          p.112 = p;
          len.120 = (sizetype) len;
          p.121 = p.112 + len.120;
          p = p.121;
          goto <D.26111>;
          <D.26108>:
          p.112 = p;
          D.26112 = decode_klass_ref (amodule, p.112, &p);
          ei->data.catch_class = D.26112;
          <D.26111>:
          <D.26106>:
        }
        <D.26104>:
        p.112 = p;
        D.26113 = decode_value (p.112, &p);
        D.26114 = (sizetype) D.26113;
        D.26115 = code + D.26114;
        ei->try_start = D.26115;
        p.112 = p;
        D.26116 = decode_value (p.112, &p);
        D.26117 = (sizetype) D.26116;
        D.26118 = code + D.26117;
        ei->try_end = D.26118;
        p.112 = p;
        D.26119 = decode_value (p.112, &p);
        D.26120 = (sizetype) D.26119;
        D.26121 = code + D.26120;
        ei->handler_start = D.26121;
      }
      i = i + 1;
      <D.23386>:
      D.26122 = jinfo->num_clauses;
      D.26123 = (int) D.26122;
      if (D.26123 > i) goto <D.23385>; else goto <D.23387>;
      <D.23387>:
      code_len.122 = (int) code_len;
      jinfo->code_size = code_len.122;
      jinfo->used_regs = used_int_regs;
      jinfo->d.method = method;
      jinfo->code_start = code;
      jinfo->domain_neutral = 0;
      jinfo->from_aot = -1;
      <D.26084>:
      if (has_try_block_holes != 0) goto <D.26125>; else goto <D.26126>;
      <D.26125>:
      {
        struct MonoTryBlockHoleTableJitInfo * table;

        jinfo->has_try_block_holes = -1;
        table = mono_jit_info_get_try_block_hole_table_info (jinfo);
        D.26127 = table == 0B;
        D.26128 = (long int) D.26127;
        D.26129 = __builtin_expect (D.26128, 0);
        if (D.26129 != 0) goto <D.26130>; else goto <D.26131>;
        <D.26130>:
        monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "aot-runtime.c", 2491, "table");
        <D.26131>:
        D.26132 = (short unsigned int) num_holes;
        table->num_holes = D.26132;
        i = 0;
        goto <D.23391>;
        <D.23390>:
        {
          struct MonoTryBlockHoleJitInfo * hole;

          hole = &table->holes[i];
          p.112 = p;
          D.26133 = decode_value (p.112, &p);
          D.26134 = (short unsigned int) D.26133;
          hole->clause = D.26134;
          p.112 = p;
          D.26135 = decode_value (p.112, &p);
          D.26136 = (short unsigned int) D.26135;
          hole->length = D.26136;
          p.112 = p;
          D.26137 = decode_value (p.112, &p);
          D.26138 = (unsigned int) D.26137;
          hole->offset = D.26138;
        }
        i = i + 1;
        <D.23391>:
        if (i < num_holes) goto <D.23390>; else goto <D.23392>;
        <D.23392>:
      }
      <D.26126>:
      if (has_arch_eh_jit_info != 0) goto <D.26139>; else goto <D.26140>;
      <D.26139>:
      {
        struct MonoArchEHJitInfo * eh_info;

        jinfo->has_arch_eh_info = -1;
        eh_info = mono_jit_info_get_arch_eh_info (jinfo);
        p.112 = p;
        D.26141 = decode_value (p.112, &p);
        D.26142 = (unsigned int) D.26141;
        eh_info->stack_size = D.26142;
      }
      <D.26140>:
      if (async != 0) goto <D.26143>; else goto <D.26144>;
      <D.26143>:
      jinfo->async = -1;
      jinfo->d.aot_info = amodule;
      D.26145 = jinfo;
      return D.26145;
      <D.26144>:
      if (has_generic_jit_info != 0) goto <D.26146>; else goto <D.26147>;
      <D.26146>:
      {
        struct MonoGenericJitInfo * gi;
        int len;

        jinfo->has_generic_jit_info = -1;
        gi = mono_jit_info_get_generic_jit_info (jinfo);
        D.26148 = gi == 0B;
        D.26149 = (long int) D.26148;
        D.26150 = __builtin_expect (D.26149, 0);
        if (D.26150 != 0) goto <D.26151>; else goto <D.26152>;
        <D.26151>:
        monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "aot-runtime.c", 2526, "gi");
        <D.26152>:
        p.112 = p;
        D.26153 = decode_value (p.112, &p);
        gi->nlocs = D.26153;
        D.26154 = gi->nlocs;
        if (D.26154 != 0) goto <D.26155>; else goto <D.26156>;
        <D.26155>:
        D.26154 = gi->nlocs;
        D.26157 = (unsigned int) D.26154;
        D.26158 = D.26157 * 20;
        D.26159 = (int) D.26158;
        D.26160 = alloc0_jit_info_data (domain, D.26159, async);
        gi->locations = D.26160;
        i = 0;
        goto <D.23398>;
        <D.23397>:
        {
          struct MonoDwarfLocListEntry * entry;

          D.26161 = gi->locations;
          i.115 = (unsigned int) i;
          D.26162 = i.115 * 20;
          entry = D.26161 + D.26162;
          p.112 = p;
          D.26163 = decode_value (p.112, &p);
          entry->is_reg = D.26163;
          p.112 = p;
          D.26164 = decode_value (p.112, &p);
          entry->reg = D.26164;
          D.26165 = entry->is_reg;
          if (D.26165 == 0) goto <D.26166>; else goto <D.26167>;
          <D.26166>:
          p.112 = p;
          D.26168 = decode_value (p.112, &p);
          entry->offset = D.26168;
          <D.26167>:
          if (i > 0) goto <D.26169>; else goto <D.26170>;
          <D.26169>:
          p.112 = p;
          D.26171 = decode_value (p.112, &p);
          entry->from = D.26171;
          <D.26170>:
          p.112 = p;
          D.26172 = decode_value (p.112, &p);
          entry->to = D.26172;
        }
        i = i + 1;
        <D.23398>:
        D.26154 = gi->nlocs;
        if (D.26154 > i) goto <D.23397>; else goto <D.23399>;
        <D.23399>:
        goto <D.26173>;
        <D.26156>:
        if (from_llvm != 0) goto <D.26174>; else goto <D.26175>;
        <D.26174>:
        this_reg.123 = this_reg;
        D.26177 = this_reg.123 != -1;
        D.26178 = (<unnamed-signed:1>) D.26177;
        gi->has_this = D.26178;
        this_reg.123 = this_reg;
        D.26179 = (unsigned char) this_reg.123;
        gi->this_reg = D.26179;
        this_offset.124 = this_offset;
        gi->this_offset = this_offset.124;
        goto <D.26181>;
        <D.26175>:
        p.112 = p;
        D.26182 = decode_value (p.112, &p);
        D.26183 = (signed char) D.26182;
        D.26184 = (<unnamed-signed:1>) D.26183;
        gi->has_this = D.26184;
        p.112 = p;
        D.26185 = decode_value (p.112, &p);
        D.26186 = (unsigned char) D.26185;
        gi->this_reg = D.26186;
        p.112 = p;
        D.26187 = decode_value (p.112, &p);
        gi->this_offset = D.26187;
        <D.26181>:
        <D.26173>:
        p.112 = p;
        len = decode_value (p.112, &p);
        if (async != 0) goto <D.26188>; else goto <D.26189>;
        <D.26188>:
        p.112 = p;
        len.125 = (sizetype) len;
        p.126 = p.112 + len.125;
        p = p.126;
        goto <D.26192>;
        <D.26189>:
        p.112 = p;
        D.26193 = decode_resolve_method_ref (amodule, p.112, &p);
        jinfo->d.method = D.26193;
        <D.26192>:
        D.26194 = monoeg_malloc0 (8);
        gi->generic_sharing_context = D.26194;
        p.112 = p;
        D.26195 = decode_value (p.112, &p);
        if (D.26195 != 0) goto <D.26196>; else goto <D.26197>;
        <D.26196>:
        {
          int i;
          int n;
          struct MonoGenericSharingContext * gsctx;

          gsctx = gi->generic_sharing_context;
          p.112 = p;
          n = decode_value (p.112, &p);
          if (n != 0) goto <D.26198>; else goto <D.26199>;
          <D.26198>:
          n.127 = (unsigned int) n;
          D.26201 = n.127 * 4;
          D.26202 = (int) D.26201;
          D.26203 = alloc0_jit_info_data (domain, D.26202, async);
          gsctx->var_is_vt = D.26203;
          i = 0;
          goto <D.23404>;
          <D.23403>:
          D.26204 = gsctx->var_is_vt;
          i.128 = (unsigned int) i;
          D.26206 = i.128 * 4;
          D.26207 = D.26204 + D.26206;
          p.112 = p;
          D.26208 = decode_value (p.112, &p);
          *D.26207 = D.26208;
          i = i + 1;
          <D.23404>:
          if (i < n) goto <D.23403>; else goto <D.23405>;
          <D.23405>:
          <D.26199>:
          p.112 = p;
          n = decode_value (p.112, &p);
          if (n != 0) goto <D.26209>; else goto <D.26210>;
          <D.26209>:
          n.127 = (unsigned int) n;
          D.26201 = n.127 * 4;
          D.26202 = (int) D.26201;
          D.26211 = alloc0_jit_info_data (domain, D.26202, async);
          gsctx->mvar_is_vt = D.26211;
          i = 0;
          goto <D.23407>;
          <D.23406>:
          D.26212 = gsctx->mvar_is_vt;
          i.128 = (unsigned int) i;
          D.26206 = i.128 * 4;
          D.26213 = D.26212 + D.26206;
          p.112 = p;
          D.26214 = decode_value (p.112, &p);
          *D.26213 = D.26214;
          i = i + 1;
          <D.23407>:
          if (i < n) goto <D.23406>; else goto <D.23408>;
          <D.23408>:
          <D.26210>:
        }
        <D.26197>:
      }
      <D.26147>:
      if (method != 0B) goto <D.26215>; else goto <D.26216>;
      <D.26215>:
      if (has_seq_points != 0) goto <D.26217>; else goto <D.26218>;
      <D.26217>:
      {
        struct MonoSeqPointInfo * seq_points;
        int il_offset;
        int native_offset;
        int last_il_offset;
        int last_native_offset;
        int j;
        int len;

        p.112 = p;
        len = decode_value (p.112, &p);
        len.129 = (unsigned int) len;
        D.26220 = len.129 * 20;
        D.26221 = D.26220 + 4;
        seq_points = monoeg_malloc0 (D.26221);
        seq_points->len = len;
        last_native_offset = 0;
        last_il_offset = last_native_offset;
        i = 0;
        goto <D.23421>;
        <D.23420>:
        {
          struct SeqPoint * sp;

          sp = &seq_points->seq_points[i];
          p.112 = p;
          D.26222 = decode_value (p.112, &p);
          il_offset = D.26222 + last_il_offset;
          p.112 = p;
          D.26223 = decode_value (p.112, &p);
          native_offset = D.26223 + last_native_offset;
          sp->il_offset = il_offset;
          sp->native_offset = native_offset;
          p.112 = p;
          D.26224 = decode_value (p.112, &p);
          sp->flags = D.26224;
          p.112 = p;
          D.26225 = decode_value (p.112, &p);
          sp->next_len = D.26225;
          D.26226 = sp->next_len;
          D.26227 = (unsigned int) D.26226;
          D.26228 = D.26227 * 4;
          D.26229 = monoeg_malloc (D.26228);
          sp->next = D.26229;
          j = 0;
          goto <D.23418>;
          <D.23417>:
          D.26230 = sp->next;
          j.130 = (unsigned int) j;
          D.26232 = j.130 * 4;
          D.26233 = D.26230 + D.26232;
          p.112 = p;
          D.26234 = decode_value (p.112, &p);
          *D.26233 = D.26234;
          j = j + 1;
          <D.23418>:
          D.26226 = sp->next_len;
          if (D.26226 > j) goto <D.23417>; else goto <D.23419>;
          <D.23419>:
          last_il_offset = il_offset;
          last_native_offset = native_offset;
        }
        i = i + 1;
        <D.23421>:
        if (i < len) goto <D.23420>; else goto <D.23422>;
        <D.23422>:
        {
          int ret;

          D.26235 = &domain->lock.mutex;
          ret = pthread_mutex_lock (D.26235);
          if (ret != 0) goto <D.26236>; else goto <D.26237>;
          <D.26236>:
          monoeg_g_log (0B, 16, "Bad call to mono_mutex_lock result %d", ret);
          <D.26237>:
          D.26238 = ret != 0;
          D.26239 = (long int) D.26238;
          D.26240 = __builtin_expect (D.26239, 0);
          if (D.26240 != 0) goto <D.26241>; else goto <D.26242>;
          <D.26241>:
          monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "aot-runtime.c", 2608, "ret == 0");
          <D.26242>:
        }
        D.26243 = domain->runtime_info;
        D.26244 = MEM[(struct MonoJitDomainInfo *)D.26243].seq_points;
        monoeg_g_hash_table_insert_replace (D.26244, method, seq_points, 0);
        {
          int ret;

          D.26235 = &domain->lock.mutex;
          ret = pthread_mutex_unlock (D.26235);
          if (ret != 0) goto <D.26245>; else goto <D.26246>;
          <D.26245>:
          monoeg_g_log (0B, 16, "Bad call to mono_mutex_unlock result %d", ret);
          <D.26246>:
          D.26247 = ret != 0;
          D.26248 = (long int) D.26247;
          D.26249 = __builtin_expect (D.26248, 0);
          if (D.26249 != 0) goto <D.26250>; else goto <D.26251>;
          <D.26250>:
          monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "aot-runtime.c", 2610, "ret == 0");
          <D.26251>:
        }
      }
      <D.26218>:
      <D.26216>:
      p.112 = p;
      buf_len = decode_value (p.112, &p);
      if (async == 0) goto <D.26252>; else goto <D.26253>;
      <D.26252>:
      p.112 = p;
      buf_len.131 = (unsigned int) buf_len;
      mono_debug_add_aot_method (domain, method, code, p.112, buf_len.131);
      <D.26253>:
      p.112 = p;
      buf_len.132 = (sizetype) buf_len;
      p.133 = p.112 + buf_len.132;
      p = p.133;
      if (has_gc_map != 0) goto <D.26257>; else goto <D.26258>;
      <D.26257>:
      {
        int map_size;

        p.112 = p;
        map_size = decode_value (p.112, &p);
        goto <D.23427>;
        <D.23426>:
        p.112 = p;
        p.134 = p.112 + 1;
        p = p.134;
        <D.23427>:
        p.112 = p;
        p.135 = (unsigned int) p.112;
        D.26261 = p.135 & 3;
        if (D.26261 != 0) goto <D.23426>; else goto <D.23428>;
        <D.23428>:
        p.112 = p;
        jinfo->gc_info = p.112;
        p.112 = p;
        map_size.136 = (sizetype) map_size;
        p.137 = p.112 + map_size.136;
        p = p.137;
      }
      <D.26258>:
      D.26264 = jinfo->d.method;
      D.26265 = D.26264->klass;
      D.26266 = D.26265->image;
      D.26267 = D.26266->aot_module;
      if (D.26267 != amodule) goto <D.26268>; else goto <D.26269>;
      <D.26268>:
      {
        int ret;

        ret = pthread_mutex_lock (&aot_mutex.mutex);
        if (ret != 0) goto <D.26270>; else goto <D.26271>;
        <D.26270>:
        monoeg_g_log (0B, 16, "Bad call to mono_mutex_lock result %d", ret);
        <D.26271>:
        D.26272 = ret != 0;
        D.26273 = (long int) D.26272;
        D.26274 = __builtin_expect (D.26273, 0);
        if (D.26274 != 0) goto <D.26275>; else goto <D.26276>;
        <D.26275>:
        monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "aot-runtime.c", 2629, "ret == 0");
        <D.26276>:
      }
      ji_to_amodule.138 = ji_to_amodule;
      if (ji_to_amodule.138 == 0B) goto <D.26278>; else goto <D.26279>;
      <D.26278>:
      ji_to_amodule.139 = monoeg_g_hash_table_new (0B, 0B);
      ji_to_amodule = ji_to_amodule.139;
      <D.26279>:
      ji_to_amodule.138 = ji_to_amodule;
      monoeg_g_hash_table_insert_replace (ji_to_amodule.138, jinfo, amodule, 0);
      {
        int ret;

        ret = pthread_mutex_unlock (&aot_mutex.mutex);
        if (ret != 0) goto <D.26281>; else goto <D.26282>;
        <D.26281>:
        monoeg_g_log (0B, 16, "Bad call to mono_mutex_unlock result %d", ret);
        <D.26282>:
        D.26283 = ret != 0;
        D.26284 = (long int) D.26283;
        D.26285 = __builtin_expect (D.26284, 0);
        if (D.26285 != 0) goto <D.26286>; else goto <D.26287>;
        <D.26286>:
        monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "aot-runtime.c", 2633, "ret == 0");
        <D.26287>:
      }
      <D.26269>:
      D.26145 = jinfo;
      return D.26145;
    }
  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.26290;
  _Bool D.26291;
  long int D.26292;
  long int D.26293;
  unsigned char D.26296;
  _Bool D.26297;
  long int D.26298;
  long int D.26299;
  int p.140;
  int D.26303;
  int D.26304;
  unsigned int D.26305;
  int D.26306;
  int D.26307;
  sizetype D.26308;
  int code.141;
  guint8 * D.26310;
  int D.26311;
  int D.26312;
  unsigned int pos.142;
  unsigned int D.26314;
  gint32 * D.26315;
  int D.26316;
  _Bool D.26317;
  long int D.26318;
  long int D.26319;
  gint32 * D.26322;
  unsigned int D.26323;
  unsigned int D.26324;
  gint32 * D.26325;
  int D.26326;
  guint8 * D.26329;
  int D.26330;
  unsigned int D.26332;
  unsigned int D.26333;
  gint32 * D.26334;
  int D.26335;
  _Bool D.26336;
  long int D.26337;
  long int D.26338;
  unsigned int D.26341;
  unsigned int D.26342;
  gint32 * D.26343;
  int D.26348;
  sizetype D.26349;
  sizetype len.143;
  int D.26354;
  sizetype D.26355;
  int code_end.144;
  int code_start.145;
  int iftmp.146;
  _Bool D.26363;
  long int D.26364;
  long int D.26365;
  guint8 * D.26368;
  int D.26373;
  sizetype pos.147;
  sizetype D.26375;
  sizetype D.26376;
  gint32 * D.26377;
  int D.26378;
  sizetype D.26379;
  sizetype D.26380;
  gint32 * D.26381;
  int D.26382;
  int D.26383;
  int fde_len.148;
  int D.26385;
  int D.26386;
  unsigned int i.149;
  unsigned int D.26388;
  void * * D.26389;
  void * D.26390;
  unsigned int D.26391;
  unsigned int cindex1.150;
  unsigned int D.26393;
  struct GSList * * D.26394;
  void * D.26395;
  unsigned int j.151;
  unsigned int D.26397;
  void * * D.26398;
  void * D.26399;
  unsigned int D.26400;
  unsigned int j.152;
  unsigned int i.153;
  unsigned int D.26405;
  unsigned int D.26406;
  unsigned int extra_size.154;
  unsigned int D.26408;
  unsigned int D.26409;
  guint8 * D.26410;
  unsigned int D.26411;
  unsigned int D.26412;
  short unsigned int D.26413;
  short unsigned int D.26414;
  short unsigned int D.26415;
  <unnamed-unsigned:15> D.26416;
  unsigned int D.26417;
  unsigned int clause_index.155;
  unsigned int D.26419;
  _Bool D.26420;
  long int D.26421;
  long int D.26422;
  unsigned int D.26425;
  struct MonoClass * D.26426;
  unsigned int D.26427;
  struct MonoJitExceptionInfo * D.26428;
  void * D.26429;
  void * D.26430;
  void * D.26431;
  void * D.26434;
  int D.26437;
  int D.26438;
  void * D.26439;
  unsigned int D.26440;
  unsigned int cindex1.156;
  unsigned int D.26442;
  struct GSList * * D.26443;
  void * D.26444;
  unsigned int D.26445;
  struct MonoJitExceptionInfo * D.26448;
  struct MonoJitExceptionInfo * D.26449;
  void * D.26450;
  void * D.26451;
  _Bool D.26452;
  long int D.26453;
  long int D.26454;
  struct MonoJitInfo * D.26457;
  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.26290 = amodule->mono_eh_frame;
      D.26291 = D.26290 == 0B;
      D.26292 = (long int) D.26291;
      D.26293 = __builtin_expect (D.26292, 0);
      if (D.26293 != 0) goto <D.26294>; else goto <D.26295>;
      <D.26294>:
      monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "aot-runtime.c", 2171, "amodule->mono_eh_frame");
      <D.26295>:
      p = amodule->mono_eh_frame;
      D.26296 = *p;
      version = (int) D.26296;
      D.26297 = version != 3;
      D.26298 = (long int) D.26297;
      D.26299 = __builtin_expect (D.26298, 0);
      if (D.26299 != 0) goto <D.26300>; else goto <D.26301>;
      <D.26300>:
      monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "aot-runtime.c", 2179, "version == 3");
      <D.26301>:
      p = p + 1;
      D.26296 = *p;
      func_encoding = (int) D.26296;
      p = p + 1;
      p.140 = (int) p;
      D.26303 = p.140 + 3;
      D.26304 = D.26303 & -4;
      p = (guint8 *) D.26304;
      D.26305 = MEM[(guint32 *)p];
      fde_count = (int) D.26305;
      p = p + 4;
      table = p;
      D.26306 = fde_count + 1;
      D.26307 = D.26306 * 8;
      D.26308 = (sizetype) D.26307;
      cie = p + D.26308;
      code.141 = (int) code;
      D.26310 = amodule->code;
      D.26311 = (int) D.26310;
      offset = code.141 - D.26311;
      left = 0;
      right = fde_count;
      <D.23298>:
      D.26312 = left + right;
      pos = D.26312 / 2;
      pos.142 = (unsigned int) pos;
      D.26314 = pos.142 * 8;
      D.26315 = table + D.26314;
      D.26316 = *D.26315;
      D.26317 = D.26316 == -1;
      D.26318 = (long int) D.26317;
      D.26319 = __builtin_expect (D.26318, 0);
      if (D.26319 != 0) goto <D.26320>; else goto <D.26321>;
      <D.26320>:
      monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "aot-runtime.c", 2200, "table [(pos * 2)] != -1");
      <D.26321>:
      D.26322 = amodule->code_offsets;
      pos.142 = (unsigned int) pos;
      D.26314 = pos.142 * 8;
      D.26315 = table + D.26314;
      D.26316 = *D.26315;
      D.26323 = (unsigned int) D.26316;
      D.26324 = D.26323 * 4;
      D.26325 = D.26322 + D.26324;
      offset1 = *D.26325;
      D.26326 = pos + 1;
      if (D.26326 == fde_count) goto <D.26327>; else goto <D.26328>;
      <D.26327>:
      D.26329 = amodule->code_end;
      D.26330 = (int) D.26329;
      D.26310 = amodule->code;
      D.26311 = (int) D.26310;
      offset2 = D.26330 - D.26311;
      goto <D.26331>;
      <D.26328>:
      D.26326 = pos + 1;
      D.26332 = (unsigned int) D.26326;
      D.26333 = D.26332 * 8;
      D.26334 = table + D.26333;
      D.26335 = *D.26334;
      D.26336 = D.26335 == -1;
      D.26337 = (long int) D.26336;
      D.26338 = __builtin_expect (D.26337, 0);
      if (D.26338 != 0) goto <D.26339>; else goto <D.26340>;
      <D.26339>:
      monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "aot-runtime.c", 2205, "table [(pos + 1) * 2] != -1");
      <D.26340>:
      D.26322 = amodule->code_offsets;
      D.26326 = pos + 1;
      D.26332 = (unsigned int) D.26326;
      D.26333 = D.26332 * 8;
      D.26334 = table + D.26333;
      D.26335 = *D.26334;
      D.26341 = (unsigned int) D.26335;
      D.26342 = D.26341 * 4;
      D.26343 = D.26322 + D.26342;
      offset2 = *D.26343;
      <D.26331>:
      if (offset < offset1) goto <D.26344>; else goto <D.26345>;
      <D.26344>:
      right = pos;
      goto <D.26346>;
      <D.26345>:
      if (offset >= offset2) goto <D.26347>; else goto <D.23297>;
      <D.26347>:
      left = pos + 1;
      <D.26346>:
      goto <D.23298>;
      <D.23297>:
      D.26310 = amodule->code;
      D.26322 = amodule->code_offsets;
      pos.142 = (unsigned int) pos;
      D.26314 = pos.142 * 8;
      D.26315 = table + D.26314;
      D.26316 = *D.26315;
      D.26323 = (unsigned int) D.26316;
      D.26324 = D.26323 * 4;
      D.26325 = D.26322 + D.26324;
      D.26348 = *D.26325;
      D.26349 = (sizetype) D.26348;
      code_start = D.26310 + D.26349;
      D.26326 = pos + 1;
      if (D.26326 == fde_count) goto <D.26350>; else goto <D.26351>;
      <D.26350>:
      {
        int len;

        D.26326 = pos + 1;
        D.26332 = (unsigned int) D.26326;
        D.26333 = D.26332 * 8;
        D.26334 = table + D.26333;
        len = *D.26334;
        len.143 = (sizetype) len;
        code_end = code_start + len.143;
      }
      goto <D.26353>;
      <D.26351>:
      D.26310 = amodule->code;
      D.26322 = amodule->code_offsets;
      D.26326 = pos + 1;
      D.26332 = (unsigned int) D.26326;
      D.26333 = D.26332 * 8;
      D.26334 = table + D.26333;
      D.26335 = *D.26334;
      D.26341 = (unsigned int) D.26335;
      D.26342 = D.26341 * 4;
      D.26343 = D.26322 + D.26342;
      D.26354 = *D.26343;
      D.26355 = (sizetype) D.26354;
      code_end = D.26310 + D.26355;
      <D.26353>:
      code_end.144 = (int) code_end;
      code_start.145 = (int) code_start;
      code_len = code_end.144 - code_start.145;
      if (code < code_start) goto <D.26359>; else goto <D.26362>;
      <D.26362>:
      if (code >= code_end) goto <D.26359>; else goto <D.26360>;
      <D.26359>:
      iftmp.146 = 1;
      goto <D.26361>;
      <D.26360>:
      iftmp.146 = 0;
      <D.26361>:
      D.26363 = iftmp.146 != 0;
      D.26364 = (long int) D.26363;
      D.26365 = __builtin_expect (D.26364, 0);
      if (D.26365 != 0) goto <D.26366>; else goto <D.26367>;
      <D.26366>:
      monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "aot-runtime.c", 2227, "code >= code_start && code < code_end");
      <D.26367>:
      D.26368 = amodule->thumb_end;
      if (D.26368 != 0B) goto <D.26369>; else goto <D.26370>;
      <D.26369>:
      D.26368 = amodule->thumb_end;
      if (D.26368 > code_start) goto <D.26371>; else goto <D.26372>;
      <D.26371>:
      code_start.145 = (int) code_start;
      D.26373 = code_start.145 & -2;
      code_start = (guint8 *) D.26373;
      <D.26372>:
      <D.26370>:
      D.26290 = amodule->mono_eh_frame;
      pos.147 = (sizetype) pos;
      D.26375 = pos.147 * 8;
      D.26376 = D.26375 + 4;
      D.26377 = table + D.26376;
      D.26378 = *D.26377;
      D.26379 = (sizetype) D.26378;
      fde = D.26290 + D.26379;
      pos.147 = (sizetype) pos;
      D.26375 = pos.147 * 8;
      D.26380 = D.26375 + 12;
      D.26381 = table + D.26380;
      D.26382 = *D.26381;
      pos.147 = (sizetype) pos;
      D.26375 = pos.147 * 8;
      D.26376 = D.26375 + 4;
      D.26377 = table + D.26376;
      D.26378 = *D.26377;
      D.26383 = D.26382 - D.26378;
      fde_len = (guint32) D.26383;
      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.26385 = info.this_reg;
      *this_reg = D.26385;
      D.26386 = info.this_offset;
      *this_offset = D.26386;
      nested_len = 0;
      i = 0;
      goto <D.23311>;
      <D.23310>:
      {
        gint32 cindex1;
        struct GSList * l;

        i.149 = (unsigned int) i;
        D.26388 = i.149 * 4;
        D.26389 = type_info + D.26388;
        D.26390 = *D.26389;
        D.26391 = mono_read32 (D.26390);
        cindex1 = (gint32) D.26391;
        cindex1.150 = (unsigned int) cindex1;
        D.26393 = cindex1.150 * 4;
        D.26394 = nesting + D.26393;
        l = *D.26394;
        goto <D.23308>;
        <D.23307>:
        {
          gint32 nesting_cindex;

          D.26395 = l->data;
          nesting_cindex = (gint32) D.26395;
          j = 0;
          goto <D.23305>;
          <D.23304>:
          {
            gint32 cindex2;

            j.151 = (unsigned int) j;
            D.26397 = j.151 * 4;
            D.26398 = type_info + D.26397;
            D.26399 = *D.26398;
            D.26400 = mono_read32 (D.26399);
            cindex2 = (gint32) D.26400;
            if (cindex2 == nesting_cindex) goto <D.26401>; else goto <D.26402>;
            <D.26401>:
            nested_len = nested_len + 1;
            <D.26402>:
          }
          j = j + 1;
          <D.23305>:
          j.152 = (unsigned int) j;
          if (j.152 < ei_len) goto <D.23304>; else goto <D.23306>;
          <D.23306>:
        }
        l = l->next;
        <D.23308>:
        if (l != 0B) goto <D.23307>; else goto <D.23309>;
        <D.23309>:
      }
      i = i + 1;
      <D.23311>:
      i.153 = (unsigned int) i;
      if (i.153 < ei_len) goto <D.23310>; else goto <D.23312>;
      <D.23312>:
      D.26405 = ei_len + nested_len;
      D.26406 = D.26405 * 24;
      extra_size.154 = (unsigned int) extra_size;
      D.26408 = D.26406 + extra_size.154;
      D.26409 = D.26408 + 28;
      jinfo = mono_domain_alloc0_lock_free (domain, D.26409);
      jinfo->code_size = code_len;
      D.26410 = info.unw_info;
      D.26411 = info.unw_info_len;
      D.26412 = mono_cache_unwind_info (D.26410, D.26411);
      jinfo->used_regs = D.26412;
      jinfo->d.method = method;
      jinfo->code_start = code;
      jinfo->domain_neutral = 0;
      jinfo->from_aot = 0;
      D.26413 = (short unsigned int) ei_len;
      D.26414 = (short unsigned int) nested_len;
      D.26415 = D.26413 + D.26414;
      D.26416 = (<unnamed-unsigned:15>) D.26415;
      jinfo->num_clauses = D.26416;
      i = 0;
      goto <D.23317>;
      <D.23316>:
      {
        int clause_index;
        struct MonoJitExceptionInfo * jei;
        struct MonoJitExceptionInfo * orig_jei;

        i.149 = (unsigned int) i;
        D.26388 = i.149 * 4;
        D.26389 = type_info + D.26388;
        D.26390 = *D.26389;
        D.26417 = mono_read32 (D.26390);
        clause_index = (int) D.26417;
        jei = &jinfo->clauses[i];
        clause_index.155 = (unsigned int) clause_index;
        D.26419 = clause_index.155 * 24;
        orig_jei = clauses + D.26419;
        D.26420 = clause_index >= num_clauses;
        D.26421 = (long int) D.26420;
        D.26422 = __builtin_expect (D.26421, 0);
        if (D.26422 != 0) goto <D.26423>; else goto <D.26424>;
        <D.26423>:
        monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "aot-runtime.c", 2289, "clause_index < num_clauses");
        <D.26424>:
        D.26425 = orig_jei->flags;
        jei->flags = D.26425;
        D.26426 = orig_jei->data.catch_class;
        jei->data.catch_class = D.26426;
        i.149 = (unsigned int) i;
        D.26427 = i.149 * 24;
        D.26428 = ei + D.26427;
        D.26429 = D.26428->try_start;
        jei->try_start = D.26429;
        i.149 = (unsigned int) i;
        D.26427 = i.149 * 24;
        D.26428 = ei + D.26427;
        D.26430 = D.26428->try_end;
        jei->try_end = D.26430;
        i.149 = (unsigned int) i;
        D.26427 = i.149 * 24;
        D.26428 = ei + D.26427;
        D.26431 = D.26428->handler_start;
        jei->handler_start = D.26431;
        D.26368 = amodule->thumb_end;
        if (D.26368 != 0B) goto <D.26432>; else goto <D.26433>;
        <D.26432>:
        D.26434 = jei->handler_start;
        D.26368 = amodule->thumb_end;
        if (D.26434 < D.26368) goto <D.26435>; else goto <D.26436>;
        <D.26435>:
        D.26434 = jei->handler_start;
        D.26437 = (int) D.26434;
        D.26438 = D.26437 + 1;
        D.26439 = (void *) D.26438;
        jei->handler_start = D.26439;
        <D.26436>:
        <D.26433>:
      }
      i = i + 1;
      <D.23317>:
      i.153 = (unsigned int) i;
      if (i.153 < ei_len) goto <D.23316>; else goto <D.23318>;
      <D.23318>:
      nindex = ei_len;
      i = 0;
      goto <D.23330>;
      <D.23329>:
      {
        gint32 cindex1;
        struct GSList * l;

        i.149 = (unsigned int) i;
        D.26388 = i.149 * 4;
        D.26389 = type_info + D.26388;
        D.26390 = *D.26389;
        D.26440 = mono_read32 (D.26390);
        cindex1 = (gint32) D.26440;
        cindex1.156 = (unsigned int) cindex1;
        D.26442 = cindex1.156 * 4;
        D.26443 = nesting + D.26442;
        l = *D.26443;
        goto <D.23327>;
        <D.23326>:
        {
          gint32 nesting_cindex;

          D.26444 = l->data;
          nesting_cindex = (gint32) D.26444;
          j = 0;
          goto <D.23324>;
          <D.23323>:
          {
            gint32 cindex2;

            j.151 = (unsigned int) j;
            D.26397 = j.151 * 4;
            D.26398 = type_info + D.26397;
            D.26399 = *D.26398;
            D.26445 = mono_read32 (D.26399);
            cindex2 = (gint32) D.26445;
            if (cindex2 == nesting_cindex) goto <D.26446>; else goto <D.26447>;
            <D.26446>:
            D.26448 = &jinfo->clauses[nindex];
            D.26449 = &jinfo->clauses[j];
            memcpy (D.26448, D.26449, 24);
            D.26450 = jinfo->clauses[i].try_start;
            jinfo->clauses[nindex].try_start = D.26450;
            D.26451 = jinfo->clauses[i].try_end;
            jinfo->clauses[nindex].try_end = D.26451;
            nindex = nindex + 1;
            <D.26447>:
          }
          j = j + 1;
          <D.23324>:
          j.152 = (unsigned int) j;
          if (j.152 < ei_len) goto <D.23323>; else goto <D.23325>;
          <D.23325>:
        }
        l = l->next;
        <D.23327>:
        if (l != 0B) goto <D.23326>; else goto <D.23328>;
        <D.23328>:
      }
      i = i + 1;
      <D.23330>:
      i.153 = (unsigned int) i;
      if (i.153 < ei_len) goto <D.23329>; else goto <D.23331>;
      <D.23331>:
      D.26405 = ei_len + nested_len;
      D.26452 = D.26405 != nindex;
      D.26453 = (long int) D.26452;
      D.26454 = __builtin_expect (D.26453, 0);
      if (D.26454 != 0) goto <D.26455>; else goto <D.26456>;
      <D.26455>:
      monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "aot-runtime.c", 2327, "nindex == ei_len + nested_len");
      <D.26456>:
      D.26457 = jinfo;
      return D.26457;
    }
  finally
    {
      info = {CLOBBER};
    }
}


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

  if (async_context != 0) goto <D.26460>; else goto <D.26461>;
  <D.26460>:
  size.157 = (unsigned int) size;
  res = mono_domain_alloc0_lock_free (domain, size.157);
  InterlockedExchangeAdd (&async_jit_info_size, size);
  goto <D.26463>;
  <D.26461>:
  size.157 = (unsigned int) size;
  res = mono_domain_alloc0 (domain, size.157);
  <D.26463>:
  D.26464 = res;
  return D.26464;
}


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

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


mono_memory_barrier ()
{
  __sync_synchronize ();
}


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

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


mono_aot_get_method (struct MonoDomain * domain, struct MonoMethod * method)
{
  struct MonoImage * D.26475;
  void * amodule.161;
  struct MonoAotModule * amodule.162;
  void * D.26480;
  int D.26481;
  short unsigned int D.26486;
  int D.26487;
  int D.26488;
  short unsigned int D.26490;
  int D.26491;
  int D.26492;
  int D.26494;
  int D.26496;
  int mono_aot_only.163;
  unsigned int D.26500;
  unsigned int D.26501;
  struct MonoMethod * D.26504;
  unsigned int D.26505;
  unsigned int D.26506;
  _Bool D.26507;
  long int D.26508;
  long int D.26509;
  unsigned int D.26514;
  int D.26516;
  unsigned int D.26518;
  unsigned int D.26519;
  unsigned int D.26523;
  _Bool D.26527;
  long int D.26528;
  long int D.26529;
  struct GHashTable * D.26532;
  _Bool D.26535;
  long int D.26536;
  long int D.26537;
  struct MonoClass * D.26546;
  unsigned char D.26547;
  const char * D.26550;
  char * D.26551;
  int D.26556;
  void * D.26559;
  struct MonoClass * D.26564;
  int D.23731;
  int iftmp.164;
  int D.23730;
  const char[20] * D.26570;
  unsigned char D.26571;
  int D.26572;
  unsigned char D.26573;
  int D.26574;
  const unsigned char * D.26579;
  unsigned char D.26580;
  int D.26581;
  const unsigned char * D.26582;
  unsigned char D.26583;
  int D.26584;
  const unsigned char * D.26589;
  unsigned char D.26590;
  int D.26591;
  const unsigned char * D.26592;
  unsigned char D.26593;
  int D.26594;
  const unsigned char * D.26599;
  unsigned char D.26600;
  int D.26601;
  const unsigned char * D.26602;
  unsigned char D.26603;
  int D.26604;
  struct MonoMethodSignature * D.26608;
  struct MonoType * D.26609;
  unsigned char D.26610;
  _Bool D.26613;
  long int D.26614;
  long int D.26615;
  struct MonoClass * D.26618;
  struct MonoType * D.26619;
  struct MonoGenericInst * D.26620;
  struct MonoMethod * D.26621;
  struct MonoImage * D.26633;
  struct MonoImage * D.26634;
  int D.23743;
  int iftmp.165;
  int D.23742;
  const char[17] * D.26640;
  unsigned char D.26641;
  int D.26642;
  unsigned char D.26643;
  int D.26644;
  const unsigned char * D.26649;
  unsigned char D.26650;
  int D.26651;
  const unsigned char * D.26652;
  unsigned char D.26653;
  int D.26654;
  const unsigned char * D.26659;
  unsigned char D.26660;
  int D.26661;
  const unsigned char * D.26662;
  unsigned char D.26663;
  int D.26664;
  const unsigned char * D.26669;
  unsigned char D.26670;
  int D.26671;
  const unsigned char * D.26672;
  unsigned char D.26673;
  int D.26674;
  const char * D.26676;
  int D.23752;
  int iftmp.166;
  int D.23751;
  const char[12] * D.26681;
  unsigned char D.26682;
  int D.26683;
  unsigned char D.26684;
  int D.26685;
  const unsigned char * D.26690;
  unsigned char D.26691;
  int D.26692;
  const unsigned char * D.26693;
  unsigned char D.26694;
  int D.26695;
  const unsigned char * D.26700;
  unsigned char D.26701;
  int D.26702;
  const unsigned char * D.26703;
  unsigned char D.26704;
  int D.26705;
  const unsigned char * D.26710;
  unsigned char D.26711;
  int D.26712;
  const unsigned char * D.26713;
  unsigned char D.26714;
  int D.26715;
  const char * D.26717;
  int D.23761;
  int iftmp.167;
  int D.23760;
  const char[16] * D.26722;
  unsigned char D.26723;
  int D.26724;
  unsigned char D.26725;
  int D.26726;
  const unsigned char * D.26731;
  unsigned char D.26732;
  int D.26733;
  const unsigned char * D.26734;
  unsigned char D.26735;
  int D.26736;
  const unsigned char * D.26741;
  unsigned char D.26742;
  int D.26743;
  const unsigned char * D.26744;
  unsigned char D.26745;
  int D.26746;
  const unsigned char * D.26751;
  unsigned char D.26752;
  int D.26753;
  const unsigned char * D.26754;
  unsigned char D.26755;
  int D.26756;
  int D.23770;
  int iftmp.168;
  int D.23769;
  const char[9] * D.26762;
  unsigned char D.26763;
  int D.26764;
  unsigned char D.26765;
  int D.26766;
  const unsigned char * D.26771;
  unsigned char D.26772;
  int D.26773;
  const unsigned char * D.26774;
  unsigned char D.26775;
  int D.26776;
  const unsigned char * D.26781;
  unsigned char D.26782;
  int D.26783;
  const unsigned char * D.26784;
  unsigned char D.26785;
  int D.26786;
  const unsigned char * D.26791;
  unsigned char D.26792;
  int D.26793;
  const unsigned char * D.26794;
  unsigned char D.26795;
  int D.26796;
  struct MonoMethodSignature * D.26798;
  struct MonoType * D.26799;
  int D.26800;
  int D.23779;
  int iftmp.169;
  int D.23778;
  unsigned char D.26804;
  int D.26805;
  const unsigned char * D.26810;
  unsigned char D.26811;
  int D.26812;
  const unsigned char * D.26817;
  unsigned char D.26818;
  int D.26819;
  const unsigned char * D.26824;
  unsigned char D.26825;
  int D.26826;
  int D.23788;
  int iftmp.170;
  int D.23787;
  const char[9] * D.26832;
  unsigned char D.26833;
  int D.26834;
  unsigned char D.26835;
  int D.26836;
  const unsigned char * D.26841;
  unsigned char D.26842;
  int D.26843;
  const unsigned char * D.26844;
  unsigned char D.26845;
  int D.26846;
  const unsigned char * D.26851;
  unsigned char D.26852;
  int D.26853;
  const unsigned char * D.26854;
  unsigned char D.26855;
  int D.26856;
  const unsigned char * D.26861;
  unsigned char D.26862;
  int D.26863;
  const unsigned char * D.26864;
  unsigned char D.26865;
  int D.26866;
  int D.23797;
  int iftmp.171;
  int D.23796;
  const char[5] * D.26872;
  unsigned char D.26873;
  int D.26874;
  unsigned char D.26875;
  int D.26876;
  const unsigned char * D.26881;
  unsigned char D.26882;
  int D.26883;
  const unsigned char * D.26884;
  unsigned char D.26885;
  int D.26886;
  const unsigned char * D.26891;
  unsigned char D.26892;
  int D.26893;
  const unsigned char * D.26894;
  unsigned char D.26895;
  int D.26896;
  const unsigned char * D.26901;
  unsigned char D.26902;
  int D.26903;
  const unsigned char * D.26904;
  unsigned char D.26905;
  int D.26906;
  struct MonoMethodSignature * D.26909;
  struct MonoType * D.26910;
  int D.26911;
  int D.23806;
  int iftmp.172;
  int D.23805;
  unsigned char D.26915;
  int D.26916;
  const unsigned char * D.26921;
  unsigned char D.26922;
  int D.26923;
  const unsigned char * D.26928;
  unsigned char D.26929;
  int D.26930;
  const unsigned char * D.26935;
  unsigned char D.26936;
  int D.26937;
  int D.23815;
  int iftmp.173;
  int D.23814;
  unsigned char D.26943;
  int D.26944;
  const unsigned char * D.26949;
  unsigned char D.26950;
  int D.26951;
  const unsigned char * D.26956;
  unsigned char D.26957;
  int D.26958;
  const unsigned char * D.26963;
  unsigned char D.26964;
  int D.26965;
  int D.23824;
  int iftmp.174;
  int D.23823;
  const char[6] * D.26971;
  unsigned char D.26972;
  int D.26973;
  unsigned char D.26974;
  int D.26975;
  const unsigned char * D.26980;
  unsigned char D.26981;
  int D.26982;
  const unsigned char * D.26983;
  unsigned char D.26984;
  int D.26985;
  const unsigned char * D.26990;
  unsigned char D.26991;
  int D.26992;
  const unsigned char * D.26993;
  unsigned char D.26994;
  int D.26995;
  const unsigned char * D.27000;
  unsigned char D.27001;
  int D.27002;
  const unsigned char * D.27003;
  unsigned char D.27004;
  int D.27005;
  struct MonoMethodSignature * D.27008;
  struct MonoType * D.27009;
  int D.27010;
  struct MonoMethodSignature * D.27011;
  short unsigned int D.27012;
  int D.23837;
  const char * D.27015;
  _Bool D.27017;
  long int D.27018;
  long int D.27019;
  struct MonoGenericInst * D.27022;
  struct MonoMethod * D.27023;
  int D.27032;
  int D.27041;
  struct MonoMethod * D.27044;
  int D.27051;
  _Bool D.27058;
  long int D.27059;
  long int D.27060;
  struct GHashTable * D.27063;
  struct GHashTable * D.27066;
  void * method_index.175;
  _Bool D.27070;
  long int D.27071;
  long int D.27072;
  int method_index.176;
  struct MonoClass * klass;
  guint32 method_index;
  struct MonoAotModule * amodule;
  guint8 * code;

  try
    {
      klass = method->klass;
      D.26475 = klass->image;
      amodule.161 = D.26475->aot_module;
      amodule = amodule.161;
      amodule.162 = amodule;
      if (amodule.162 == 0B) goto <D.26478>; else goto <D.26479>;
      <D.26478>:
      D.26480 = 0B;
      return D.26480;
      <D.26479>:
      amodule.162 = amodule;
      D.26481 = amodule.162->out_of_date;
      if (D.26481 != 0) goto <D.26482>; else goto <D.26483>;
      <D.26482>:
      D.26480 = 0B;
      return D.26480;
      <D.26483>:
      D.26486 = method->iflags;
      D.26487 = (int) D.26486;
      D.26488 = D.26487 & 4096;
      if (D.26488 != 0) goto <D.26484>; else goto <D.26489>;
      <D.26489>:
      D.26490 = method->flags;
      D.26491 = (int) D.26490;
      D.26492 = D.26491 & 8192;
      if (D.26492 != 0) goto <D.26484>; else goto <D.26493>;
      <D.26493>:
      D.26486 = method->iflags;
      D.26487 = (int) D.26486;
      D.26494 = D.26487 & 3;
      if (D.26494 != 0) goto <D.26484>; else goto <D.26495>;
      <D.26495>:
      D.26490 = method->flags;
      D.26491 = (int) D.26490;
      D.26496 = D.26491 & 1024;
      if (D.26496 != 0) goto <D.26484>; else goto <D.26485>;
      <D.26484>:
      D.26480 = 0B;
      return D.26480;
      <D.26485>:
      mono_aot_only.163 = mono_aot_only;
      if (mono_aot_only.163 != 0) goto <D.26498>; else goto <D.26499>;
      <D.26498>:
      D.26500 = BIT_FIELD_REF <*method, 32, 160>;
      D.26501 = D.26500 & 124;
      if (D.26501 == 36) goto <D.26502>; else goto <D.26503>;
      <D.26502>:
      D.26504 = mono_marshal_method_from_wrapper (method);
      D.26480 = mono_aot_get_method (domain, D.26504);
      return D.26480;
      <D.26503>:
      <D.26499>:
      D.26505 = BIT_FIELD_REF <*klass, 32, 160>;
      D.26506 = D.26505 & 1;
      D.26507 = D.26506 == 0;
      D.26508 = (long int) D.26507;
      D.26509 = __builtin_expect (D.26508, 0);
      if (D.26509 != 0) goto <D.26510>; else goto <D.26511>;
      <D.26510>:
      monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "aot-runtime.c", 3615, "klass->inited");
      <D.26511>:
      method_index = 16777215;
      D.26500 = BIT_FIELD_REF <*method, 32, 160>;
      D.26514 = D.26500 & 4220;
      if (D.26514 == 4096) goto <D.26515>; else goto <D.26512>;
      <D.26515>:
      D.26516 = mono_method_is_generic_sharable_full (method, 0, 0, 0);
      if (D.26516 != 0) goto <D.26517>; else goto <D.26512>;
      <D.26517>:
      method = mono_method_get_declaring_generic_method (method);
      D.26518 = method->token;
      D.26519 = D.26518 & 16777215;
      method_index = D.26519 + 4294967295;
      goto <D.26513>;
      <D.26512>:
      D.26500 = BIT_FIELD_REF <*method, 32, 160>;
      D.26523 = D.26500 & 4096;
      if (D.26523 != 0) goto <D.26520>; else goto <D.26524>;
      <D.26524>:
      D.26518 = method->token;
      if (D.26518 == 0) goto <D.26520>; else goto <D.26521>;
      <D.26520>:
      {
        int ret;

        ret = pthread_mutex_lock (&aot_mutex.mutex);
        if (ret != 0) goto <D.26525>; else goto <D.26526>;
        <D.26525>:
        monoeg_g_log (0B, 16, "Bad call to mono_mutex_lock result %d", ret);
        <D.26526>:
        D.26527 = ret != 0;
        D.26528 = (long int) D.26527;
        D.26529 = __builtin_expect (D.26528, 0);
        if (D.26529 != 0) goto <D.26530>; else goto <D.26531>;
        <D.26530>:
        monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "aot-runtime.c", 3628, "ret == 0");
        <D.26531>:
      }
      amodule.162 = amodule;
      D.26532 = amodule.162->method_to_code;
      code = monoeg_g_hash_table_lookup (D.26532, method);
      {
        int ret;

        ret = pthread_mutex_unlock (&aot_mutex.mutex);
        if (ret != 0) goto <D.26533>; else goto <D.26534>;
        <D.26533>:
        monoeg_g_log (0B, 16, "Bad call to mono_mutex_unlock result %d", ret);
        <D.26534>:
        D.26535 = ret != 0;
        D.26536 = (long int) D.26535;
        D.26537 = __builtin_expect (D.26536, 0);
        if (D.26537 != 0) goto <D.26538>; else goto <D.26539>;
        <D.26538>:
        monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "aot-runtime.c", 3630, "ret == 0");
        <D.26539>:
      }
      if (code != 0B) goto <D.26540>; else goto <D.26541>;
      <D.26540>:
      D.26480 = code;
      return D.26480;
      <D.26541>:
      method_index = find_extra_method (method, &amodule);
      if (method_index == 16777215) goto <D.26542>; else goto <D.26543>;
      <D.26542>:
      D.26500 = BIT_FIELD_REF <*method, 32, 160>;
      D.26501 = D.26500 & 124;
      if (D.26501 == 28) goto <D.26544>; else goto <D.26545>;
      <D.26544>:
      D.26546 = method->klass;
      D.26547 = D.26546->rank;
      if (D.26547 != 0) goto <D.26548>; else goto <D.26549>;
      <D.26548>:
      D.26550 = method->name;
      D.26551 = strstr (D.26550, "System.Collections.Generic");
      if (D.26551 != 0B) goto <D.26552>; else goto <D.26553>;
      <D.26552>:
      {
        struct MonoMethod * m;

        m = mono_aot_get_array_helper_from_wrapper (method);
        code = mono_aot_get_method (domain, m);
        if (code != 0B) goto <D.26554>; else goto <D.26555>;
        <D.26554>:
        D.26556 = mono_method_needs_static_rgctx_invoke (m, 0);
        if (D.26556 != 0) goto <D.26557>; else goto <D.26558>;
        <D.26557>:
        D.26559 = mono_create_ftnptr (domain, code);
        code = mono_create_static_rgctx_trampoline (m, D.26559);
        code = mono_get_addr_from_ftnptr (code);
        <D.26558>:
        D.26480 = code;
        return D.26480;
        <D.26555>:
      }
      <D.26553>:
      <D.26549>:
      <D.26545>:
      <D.26543>:
      if (method_index == 16777215) goto <D.26560>; else goto <D.26561>;
      <D.26560>:
      D.26500 = BIT_FIELD_REF <*method, 32, 160>;
      D.26501 = D.26500 & 124;
      if (D.26501 == 24) goto <D.26562>; else goto <D.26563>;
      <D.26562>:
      D.26546 = method->klass;
      D.26564 = mono_defaults.array_class;
      if (D.26546 == D.26564) goto <D.26565>; else goto <D.26566>;
      <D.26565>:
      {
        size_t __s1_len;
        size_t __s2_len;

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

          __s2 = method->name;
          D.26570 = "GetGenericValueImpl";
          D.26571 = MEM[(const unsigned char *)D.26570];
          D.26572 = (int) D.26571;
          D.26573 = *__s2;
          D.26574 = (int) D.26573;
          __result = D.26572 - D.26574;
          {
            if (__s2_len != 0) goto <D.26575>; else goto <D.26576>;
            <D.26575>:
            if (__result == 0) goto <D.26577>; else goto <D.26578>;
            <D.26577>:
            D.26579 = &MEM[(void *)"GetGenericValueImpl" + 1B];
            D.26580 = *D.26579;
            D.26581 = (int) D.26580;
            D.26582 = __s2 + 1;
            D.26583 = *D.26582;
            D.26584 = (int) D.26583;
            __result = D.26581 - D.26584;
            if (__s2_len > 1) goto <D.26585>; else goto <D.26586>;
            <D.26585>:
            if (__result == 0) goto <D.26587>; else goto <D.26588>;
            <D.26587>:
            D.26589 = &MEM[(void *)"GetGenericValueImpl" + 2B];
            D.26590 = *D.26589;
            D.26591 = (int) D.26590;
            D.26592 = __s2 + 2;
            D.26593 = *D.26592;
            D.26594 = (int) D.26593;
            __result = D.26591 - D.26594;
            if (__s2_len > 2) goto <D.26595>; else goto <D.26596>;
            <D.26595>:
            if (__result == 0) goto <D.26597>; else goto <D.26598>;
            <D.26597>:
            D.26599 = &MEM[(void *)"GetGenericValueImpl" + 3B];
            D.26600 = *D.26599;
            D.26601 = (int) D.26600;
            D.26602 = __s2 + 3;
            D.26603 = *D.26602;
            D.26604 = (int) D.26603;
            __result = D.26601 - D.26604;
            <D.26598>:
            <D.26596>:
            <D.26588>:
            <D.26586>:
            <D.26578>:
            <D.26576>:
          }
          D.23730 = __result;
        }
        iftmp.164 = -D.23730;
        goto <D.26605>;
        <D.26569>:
        D.26550 = method->name;
        iftmp.164 = __builtin_strcmp (D.26550, "GetGenericValueImpl");
        <D.26605>:
        D.23731 = iftmp.164;
      }
      if (D.23731 == 0) goto <D.26606>; else goto <D.26607>;
      <D.26606>:
      {
        struct MonoMethod * m;
        struct MonoGenericContext ctx;
        struct MonoType * args[16];

        try
          {
            D.26608 = mono_method_signature (method);
            D.26609 = D.26608->params[1];
            D.26610 = D.26609->type;
            if (D.26610 == 28) goto <D.26611>; else goto <D.26612>;
            <D.26611>:
            D.26480 = 0B;
            return D.26480;
            <D.26612>:
            D.26564 = mono_defaults.array_class;
            m = mono_class_get_method_from_name (D.26564, "GetGenericValueImpl", 2);
            D.26613 = m == 0B;
            D.26614 = (long int) D.26613;
            D.26615 = __builtin_expect (D.26614, 0);
            if (D.26615 != 0) goto <D.26616>; else goto <D.26617>;
            <D.26616>:
            monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "aot-runtime.c", 3670, "m");
            <D.26617>:
            memset (&ctx, 0, 8);
            D.26618 = mono_defaults.object_class;
            D.26619 = &D.26618->byval_arg;
            args[0] = D.26619;
            D.26620 = mono_metadata_get_generic_inst (1, &args);
            ctx.method_inst = D.26620;
            D.26621 = mono_class_inflate_generic_method (m, &ctx);
            m = mono_marshal_get_native_wrapper (D.26621, 1, 1);
            code = mono_aot_get_method (domain, m);
            if (code != 0B) goto <D.26622>; else goto <D.26623>;
            <D.26622>:
            D.26480 = code;
            return D.26480;
            <D.26623>:
          }
        finally
          {
            ctx = {CLOBBER};
            args = {CLOBBER};
          }
      }
      <D.26607>:
      <D.26566>:
      <D.26563>:
      <D.26561>:
      if (method_index == 16777215) goto <D.26629>; else goto <D.26630>;
      <D.26629>:
      D.26500 = BIT_FIELD_REF <*method, 32, 160>;
      D.26501 = D.26500 & 124;
      if (D.26501 == 24) goto <D.26631>; else goto <D.26632>;
      <D.26631>:
      D.26546 = method->klass;
      D.26633 = D.26546->image;
      D.26634 = mono_defaults.corlib;
      if (D.26633 == D.26634) goto <D.26635>; else goto <D.26636>;
      <D.26635>:
      {
        size_t __s1_len;
        size_t __s2_len;

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

          D.26546 = method->klass;
          __s2 = D.26546->name_space;
          D.26640 = "System.Threading";
          D.26641 = MEM[(const unsigned char *)D.26640];
          D.26642 = (int) D.26641;
          D.26643 = *__s2;
          D.26644 = (int) D.26643;
          __result = D.26642 - D.26644;
          {
            if (__s2_len != 0) goto <D.26645>; else goto <D.26646>;
            <D.26645>:
            if (__result == 0) goto <D.26647>; else goto <D.26648>;
            <D.26647>:
            D.26649 = &MEM[(void *)"System.Threading" + 1B];
            D.26650 = *D.26649;
            D.26651 = (int) D.26650;
            D.26652 = __s2 + 1;
            D.26653 = *D.26652;
            D.26654 = (int) D.26653;
            __result = D.26651 - D.26654;
            if (__s2_len > 1) goto <D.26655>; else goto <D.26656>;
            <D.26655>:
            if (__result == 0) goto <D.26657>; else goto <D.26658>;
            <D.26657>:
            D.26659 = &MEM[(void *)"System.Threading" + 2B];
            D.26660 = *D.26659;
            D.26661 = (int) D.26660;
            D.26662 = __s2 + 2;
            D.26663 = *D.26662;
            D.26664 = (int) D.26663;
            __result = D.26661 - D.26664;
            if (__s2_len > 2) goto <D.26665>; else goto <D.26666>;
            <D.26665>:
            if (__result == 0) goto <D.26667>; else goto <D.26668>;
            <D.26667>:
            D.26669 = &MEM[(void *)"System.Threading" + 3B];
            D.26670 = *D.26669;
            D.26671 = (int) D.26670;
            D.26672 = __s2 + 3;
            D.26673 = *D.26672;
            D.26674 = (int) D.26673;
            __result = D.26671 - D.26674;
            <D.26668>:
            <D.26666>:
            <D.26658>:
            <D.26656>:
            <D.26648>:
            <D.26646>:
          }
          D.23742 = __result;
        }
        iftmp.165 = -D.23742;
        goto <D.26675>;
        <D.26639>:
        D.26546 = method->klass;
        D.26676 = D.26546->name_space;
        iftmp.165 = __builtin_strcmp (D.26676, "System.Threading");
        <D.26675>:
        D.23743 = iftmp.165;
      }
      if (D.23743 == 0) goto <D.26677>; else goto <D.26624>;
      <D.26677>:
      {
        size_t __s1_len;
        size_t __s2_len;

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

          D.26546 = method->klass;
          __s2 = D.26546->name;
          D.26681 = "Interlocked";
          D.26682 = MEM[(const unsigned char *)D.26681];
          D.26683 = (int) D.26682;
          D.26684 = *__s2;
          D.26685 = (int) D.26684;
          __result = D.26683 - D.26685;
          {
            if (__s2_len != 0) goto <D.26686>; else goto <D.26687>;
            <D.26686>:
            if (__result == 0) goto <D.26688>; else goto <D.26689>;
            <D.26688>:
            D.26690 = &MEM[(void *)"Interlocked" + 1B];
            D.26691 = *D.26690;
            D.26692 = (int) D.26691;
            D.26693 = __s2 + 1;
            D.26694 = *D.26693;
            D.26695 = (int) D.26694;
            __result = D.26692 - D.26695;
            if (__s2_len > 1) goto <D.26696>; else goto <D.26697>;
            <D.26696>:
            if (__result == 0) goto <D.26698>; else goto <D.26699>;
            <D.26698>:
            D.26700 = &MEM[(void *)"Interlocked" + 2B];
            D.26701 = *D.26700;
            D.26702 = (int) D.26701;
            D.26703 = __s2 + 2;
            D.26704 = *D.26703;
            D.26705 = (int) D.26704;
            __result = D.26702 - D.26705;
            if (__s2_len > 2) goto <D.26706>; else goto <D.26707>;
            <D.26706>:
            if (__result == 0) goto <D.26708>; else goto <D.26709>;
            <D.26708>:
            D.26710 = &MEM[(void *)"Interlocked" + 3B];
            D.26711 = *D.26710;
            D.26712 = (int) D.26711;
            D.26713 = __s2 + 3;
            D.26714 = *D.26713;
            D.26715 = (int) D.26714;
            __result = D.26712 - D.26715;
            <D.26709>:
            <D.26707>:
            <D.26699>:
            <D.26697>:
            <D.26689>:
            <D.26687>:
          }
          D.23751 = __result;
        }
        iftmp.166 = -D.23751;
        goto <D.26716>;
        <D.26680>:
        D.26546 = method->klass;
        D.26717 = D.26546->name;
        iftmp.166 = __builtin_strcmp (D.26717, "Interlocked");
        <D.26716>:
        D.23752 = iftmp.166;
      }
      if (D.23752 == 0) goto <D.26718>; else goto <D.26624>;
      <D.26718>:
      {
        size_t __s1_len;
        size_t __s2_len;

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

          __s2 = method->name;
          D.26722 = "CompareExchange";
          D.26723 = MEM[(const unsigned char *)D.26722];
          D.26724 = (int) D.26723;
          D.26725 = *__s2;
          D.26726 = (int) D.26725;
          __result = D.26724 - D.26726;
          {
            if (__s2_len != 0) goto <D.26727>; else goto <D.26728>;
            <D.26727>:
            if (__result == 0) goto <D.26729>; else goto <D.26730>;
            <D.26729>:
            D.26731 = &MEM[(void *)"CompareExchange" + 1B];
            D.26732 = *D.26731;
            D.26733 = (int) D.26732;
            D.26734 = __s2 + 1;
            D.26735 = *D.26734;
            D.26736 = (int) D.26735;
            __result = D.26733 - D.26736;
            if (__s2_len > 1) goto <D.26737>; else goto <D.26738>;
            <D.26737>:
            if (__result == 0) goto <D.26739>; else goto <D.26740>;
            <D.26739>:
            D.26741 = &MEM[(void *)"CompareExchange" + 2B];
            D.26742 = *D.26741;
            D.26743 = (int) D.26742;
            D.26744 = __s2 + 2;
            D.26745 = *D.26744;
            D.26746 = (int) D.26745;
            __result = D.26743 - D.26746;
            if (__s2_len > 2) goto <D.26747>; else goto <D.26748>;
            <D.26747>:
            if (__result == 0) goto <D.26749>; else goto <D.26750>;
            <D.26749>:
            D.26751 = &MEM[(void *)"CompareExchange" + 3B];
            D.26752 = *D.26751;
            D.26753 = (int) D.26752;
            D.26754 = __s2 + 3;
            D.26755 = *D.26754;
            D.26756 = (int) D.26755;
            __result = D.26753 - D.26756;
            <D.26750>:
            <D.26748>:
            <D.26740>:
            <D.26738>:
            <D.26730>:
            <D.26728>:
          }
          D.23760 = __result;
        }
        iftmp.167 = -D.23760;
        goto <D.26757>;
        <D.26721>:
        D.26550 = method->name;
        iftmp.167 = __builtin_strcmp (D.26550, "CompareExchange");
        <D.26757>:
        D.23761 = iftmp.167;
      }
      if (D.23761 == 0) goto <D.26625>; else goto <D.26758>;
      <D.26758>:
      {
        size_t __s1_len;
        size_t __s2_len;

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

          __s2 = method->name;
          D.26762 = "Exchange";
          D.26763 = MEM[(const unsigned char *)D.26762];
          D.26764 = (int) D.26763;
          D.26765 = *__s2;
          D.26766 = (int) D.26765;
          __result = D.26764 - D.26766;
          {
            if (__s2_len != 0) goto <D.26767>; else goto <D.26768>;
            <D.26767>:
            if (__result == 0) goto <D.26769>; else goto <D.26770>;
            <D.26769>:
            D.26771 = &MEM[(void *)"Exchange" + 1B];
            D.26772 = *D.26771;
            D.26773 = (int) D.26772;
            D.26774 = __s2 + 1;
            D.26775 = *D.26774;
            D.26776 = (int) D.26775;
            __result = D.26773 - D.26776;
            if (__s2_len > 1) goto <D.26777>; else goto <D.26778>;
            <D.26777>:
            if (__result == 0) goto <D.26779>; else goto <D.26780>;
            <D.26779>:
            D.26781 = &MEM[(void *)"Exchange" + 2B];
            D.26782 = *D.26781;
            D.26783 = (int) D.26782;
            D.26784 = __s2 + 2;
            D.26785 = *D.26784;
            D.26786 = (int) D.26785;
            __result = D.26783 - D.26786;
            if (__s2_len > 2) goto <D.26787>; else goto <D.26788>;
            <D.26787>:
            if (__result == 0) goto <D.26789>; else goto <D.26790>;
            <D.26789>:
            D.26791 = &MEM[(void *)"Exchange" + 3B];
            D.26792 = *D.26791;
            D.26793 = (int) D.26792;
            D.26794 = __s2 + 3;
            D.26795 = *D.26794;
            D.26796 = (int) D.26795;
            __result = D.26793 - D.26796;
            <D.26790>:
            <D.26788>:
            <D.26780>:
            <D.26778>:
            <D.26770>:
            <D.26768>:
          }
          D.23769 = __result;
        }
        iftmp.168 = -D.23769;
        goto <D.26797>;
        <D.26761>:
        D.26550 = method->name;
        iftmp.168 = __builtin_strcmp (D.26550, "Exchange");
        <D.26797>:
        D.23770 = iftmp.168;
      }
      if (D.23770 == 0) goto <D.26625>; else goto <D.26624>;
      <D.26625>:
      D.26798 = mono_method_signature (method);
      D.26799 = D.26798->params[1];
      D.26800 = mono_type_is_reference (D.26799);
      if (D.26800 != 0) goto <D.26626>; else goto <D.26624>;
      <D.26624>:
      {
        size_t __s1_len;
        size_t __s2_len;

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

          D.26546 = method->klass;
          __s2 = D.26546->name_space;
          D.26640 = "System.Threading";
          D.26641 = MEM[(const unsigned char *)D.26640];
          D.26642 = (int) D.26641;
          D.26804 = *__s2;
          D.26805 = (int) D.26804;
          __result = D.26642 - D.26805;
          {
            if (__s2_len != 0) goto <D.26806>; else goto <D.26807>;
            <D.26806>:
            if (__result == 0) goto <D.26808>; else goto <D.26809>;
            <D.26808>:
            D.26649 = &MEM[(void *)"System.Threading" + 1B];
            D.26650 = *D.26649;
            D.26651 = (int) D.26650;
            D.26810 = __s2 + 1;
            D.26811 = *D.26810;
            D.26812 = (int) D.26811;
            __result = D.26651 - D.26812;
            if (__s2_len > 1) goto <D.26813>; else goto <D.26814>;
            <D.26813>:
            if (__result == 0) goto <D.26815>; else goto <D.26816>;
            <D.26815>:
            D.26659 = &MEM[(void *)"System.Threading" + 2B];
            D.26660 = *D.26659;
            D.26661 = (int) D.26660;
            D.26817 = __s2 + 2;
            D.26818 = *D.26817;
            D.26819 = (int) D.26818;
            __result = D.26661 - D.26819;
            if (__s2_len > 2) goto <D.26820>; else goto <D.26821>;
            <D.26820>:
            if (__result == 0) goto <D.26822>; else goto <D.26823>;
            <D.26822>:
            D.26669 = &MEM[(void *)"System.Threading" + 3B];
            D.26670 = *D.26669;
            D.26671 = (int) D.26670;
            D.26824 = __s2 + 3;
            D.26825 = *D.26824;
            D.26826 = (int) D.26825;
            __result = D.26671 - D.26826;
            <D.26823>:
            <D.26821>:
            <D.26816>:
            <D.26814>:
            <D.26809>:
            <D.26807>:
          }
          D.23778 = __result;
        }
        iftmp.169 = -D.23778;
        goto <D.26827>;
        <D.26803>:
        D.26546 = method->klass;
        D.26676 = D.26546->name_space;
        iftmp.169 = __builtin_strcmp (D.26676, "System.Threading");
        <D.26827>:
        D.23779 = iftmp.169;
      }
      if (D.23779 == 0) goto <D.26828>; else goto <D.26627>;
      <D.26828>:
      {
        size_t __s1_len;
        size_t __s2_len;

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

          D.26546 = method->klass;
          __s2 = D.26546->name;
          D.26832 = "Volatile";
          D.26833 = MEM[(const unsigned char *)D.26832];
          D.26834 = (int) D.26833;
          D.26835 = *__s2;
          D.26836 = (int) D.26835;
          __result = D.26834 - D.26836;
          {
            if (__s2_len != 0) goto <D.26837>; else goto <D.26838>;
            <D.26837>:
            if (__result == 0) goto <D.26839>; else goto <D.26840>;
            <D.26839>:
            D.26841 = &MEM[(void *)"Volatile" + 1B];
            D.26842 = *D.26841;
            D.26843 = (int) D.26842;
            D.26844 = __s2 + 1;
            D.26845 = *D.26844;
            D.26846 = (int) D.26845;
            __result = D.26843 - D.26846;
            if (__s2_len > 1) goto <D.26847>; else goto <D.26848>;
            <D.26847>:
            if (__result == 0) goto <D.26849>; else goto <D.26850>;
            <D.26849>:
            D.26851 = &MEM[(void *)"Volatile" + 2B];
            D.26852 = *D.26851;
            D.26853 = (int) D.26852;
            D.26854 = __s2 + 2;
            D.26855 = *D.26854;
            D.26856 = (int) D.26855;
            __result = D.26853 - D.26856;
            if (__s2_len > 2) goto <D.26857>; else goto <D.26858>;
            <D.26857>:
            if (__result == 0) goto <D.26859>; else goto <D.26860>;
            <D.26859>:
            D.26861 = &MEM[(void *)"Volatile" + 3B];
            D.26862 = *D.26861;
            D.26863 = (int) D.26862;
            D.26864 = __s2 + 3;
            D.26865 = *D.26864;
            D.26866 = (int) D.26865;
            __result = D.26863 - D.26866;
            <D.26860>:
            <D.26858>:
            <D.26850>:
            <D.26848>:
            <D.26840>:
            <D.26838>:
          }
          D.23787 = __result;
        }
        iftmp.170 = -D.23787;
        goto <D.26867>;
        <D.26831>:
        D.26546 = method->klass;
        D.26717 = D.26546->name;
        iftmp.170 = __builtin_strcmp (D.26717, "Volatile");
        <D.26867>:
        D.23788 = iftmp.170;
      }
      if (D.23788 == 0) goto <D.26868>; else goto <D.26627>;
      <D.26868>:
      {
        size_t __s1_len;
        size_t __s2_len;

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

          __s2 = method->name;
          D.26872 = "Read";
          D.26873 = MEM[(const unsigned char *)D.26872];
          D.26874 = (int) D.26873;
          D.26875 = *__s2;
          D.26876 = (int) D.26875;
          __result = D.26874 - D.26876;
          {
            if (__s2_len != 0) goto <D.26877>; else goto <D.26878>;
            <D.26877>:
            if (__result == 0) goto <D.26879>; else goto <D.26880>;
            <D.26879>:
            D.26881 = &MEM[(void *)"Read" + 1B];
            D.26882 = *D.26881;
            D.26883 = (int) D.26882;
            D.26884 = __s2 + 1;
            D.26885 = *D.26884;
            D.26886 = (int) D.26885;
            __result = D.26883 - D.26886;
            if (__s2_len > 1) goto <D.26887>; else goto <D.26888>;
            <D.26887>:
            if (__result == 0) goto <D.26889>; else goto <D.26890>;
            <D.26889>:
            D.26891 = &MEM[(void *)"Read" + 2B];
            D.26892 = *D.26891;
            D.26893 = (int) D.26892;
            D.26894 = __s2 + 2;
            D.26895 = *D.26894;
            D.26896 = (int) D.26895;
            __result = D.26893 - D.26896;
            if (__s2_len > 2) goto <D.26897>; else goto <D.26898>;
            <D.26897>:
            if (__result == 0) goto <D.26899>; else goto <D.26900>;
            <D.26899>:
            D.26901 = &MEM[(void *)"Read" + 3B];
            D.26902 = *D.26901;
            D.26903 = (int) D.26902;
            D.26904 = __s2 + 3;
            D.26905 = *D.26904;
            D.26906 = (int) D.26905;
            __result = D.26903 - D.26906;
            <D.26900>:
            <D.26898>:
            <D.26890>:
            <D.26888>:
            <D.26880>:
            <D.26878>:
          }
          D.23796 = __result;
        }
        iftmp.171 = -D.23796;
        goto <D.26907>;
        <D.26871>:
        D.26550 = method->name;
        iftmp.171 = __builtin_strcmp (D.26550, "Read");
        <D.26907>:
        D.23797 = iftmp.171;
      }
      if (D.23797 == 0) goto <D.26908>; else goto <D.26627>;
      <D.26908>:
      D.26909 = mono_method_signature (method);
      D.26910 = D.26909->ret;
      D.26911 = mono_type_is_reference (D.26910);
      if (D.26911 != 0) goto <D.26626>; else goto <D.26627>;
      <D.26627>:
      {
        size_t __s1_len;
        size_t __s2_len;

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

          D.26546 = method->klass;
          __s2 = D.26546->name_space;
          D.26640 = "System.Threading";
          D.26641 = MEM[(const unsigned char *)D.26640];
          D.26642 = (int) D.26641;
          D.26915 = *__s2;
          D.26916 = (int) D.26915;
          __result = D.26642 - D.26916;
          {
            if (__s2_len != 0) goto <D.26917>; else goto <D.26918>;
            <D.26917>:
            if (__result == 0) goto <D.26919>; else goto <D.26920>;
            <D.26919>:
            D.26649 = &MEM[(void *)"System.Threading" + 1B];
            D.26650 = *D.26649;
            D.26651 = (int) D.26650;
            D.26921 = __s2 + 1;
            D.26922 = *D.26921;
            D.26923 = (int) D.26922;
            __result = D.26651 - D.26923;
            if (__s2_len > 1) goto <D.26924>; else goto <D.26925>;
            <D.26924>:
            if (__result == 0) goto <D.26926>; else goto <D.26927>;
            <D.26926>:
            D.26659 = &MEM[(void *)"System.Threading" + 2B];
            D.26660 = *D.26659;
            D.26661 = (int) D.26660;
            D.26928 = __s2 + 2;
            D.26929 = *D.26928;
            D.26930 = (int) D.26929;
            __result = D.26661 - D.26930;
            if (__s2_len > 2) goto <D.26931>; else goto <D.26932>;
            <D.26931>:
            if (__result == 0) goto <D.26933>; else goto <D.26934>;
            <D.26933>:
            D.26669 = &MEM[(void *)"System.Threading" + 3B];
            D.26670 = *D.26669;
            D.26671 = (int) D.26670;
            D.26935 = __s2 + 3;
            D.26936 = *D.26935;
            D.26937 = (int) D.26936;
            __result = D.26671 - D.26937;
            <D.26934>:
            <D.26932>:
            <D.26927>:
            <D.26925>:
            <D.26920>:
            <D.26918>:
          }
          D.23805 = __result;
        }
        iftmp.172 = -D.23805;
        goto <D.26938>;
        <D.26914>:
        D.26546 = method->klass;
        D.26676 = D.26546->name_space;
        iftmp.172 = __builtin_strcmp (D.26676, "System.Threading");
        <D.26938>:
        D.23806 = iftmp.172;
      }
      if (D.23806 == 0) goto <D.26939>; else goto <D.26628>;
      <D.26939>:
      {
        size_t __s1_len;
        size_t __s2_len;

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

          D.26546 = method->klass;
          __s2 = D.26546->name;
          D.26832 = "Volatile";
          D.26833 = MEM[(const unsigned char *)D.26832];
          D.26834 = (int) D.26833;
          D.26943 = *__s2;
          D.26944 = (int) D.26943;
          __result = D.26834 - D.26944;
          {
            if (__s2_len != 0) goto <D.26945>; else goto <D.26946>;
            <D.26945>:
            if (__result == 0) goto <D.26947>; else goto <D.26948>;
            <D.26947>:
            D.26841 = &MEM[(void *)"Volatile" + 1B];
            D.26842 = *D.26841;
            D.26843 = (int) D.26842;
            D.26949 = __s2 + 1;
            D.26950 = *D.26949;
            D.26951 = (int) D.26950;
            __result = D.26843 - D.26951;
            if (__s2_len > 1) goto <D.26952>; else goto <D.26953>;
            <D.26952>:
            if (__result == 0) goto <D.26954>; else goto <D.26955>;
            <D.26954>:
            D.26851 = &MEM[(void *)"Volatile" + 2B];
            D.26852 = *D.26851;
            D.26853 = (int) D.26852;
            D.26956 = __s2 + 2;
            D.26957 = *D.26956;
            D.26958 = (int) D.26957;
            __result = D.26853 - D.26958;
            if (__s2_len > 2) goto <D.26959>; else goto <D.26960>;
            <D.26959>:
            if (__result == 0) goto <D.26961>; else goto <D.26962>;
            <D.26961>:
            D.26861 = &MEM[(void *)"Volatile" + 3B];
            D.26862 = *D.26861;
            D.26863 = (int) D.26862;
            D.26963 = __s2 + 3;
            D.26964 = *D.26963;
            D.26965 = (int) D.26964;
            __result = D.26863 - D.26965;
            <D.26962>:
            <D.26960>:
            <D.26955>:
            <D.26953>:
            <D.26948>:
            <D.26946>:
          }
          D.23814 = __result;
        }
        iftmp.173 = -D.23814;
        goto <D.26966>;
        <D.26942>:
        D.26546 = method->klass;
        D.26717 = D.26546->name;
        iftmp.173 = __builtin_strcmp (D.26717, "Volatile");
        <D.26966>:
        D.23815 = iftmp.173;
      }
      if (D.23815 == 0) goto <D.26967>; else goto <D.26628>;
      <D.26967>:
      {
        size_t __s1_len;
        size_t __s2_len;

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

          __s2 = method->name;
          D.26971 = "Write";
          D.26972 = MEM[(const unsigned char *)D.26971];
          D.26973 = (int) D.26972;
          D.26974 = *__s2;
          D.26975 = (int) D.26974;
          __result = D.26973 - D.26975;
          {
            if (__s2_len != 0) goto <D.26976>; else goto <D.26977>;
            <D.26976>:
            if (__result == 0) goto <D.26978>; else goto <D.26979>;
            <D.26978>:
            D.26980 = &MEM[(void *)"Write" + 1B];
            D.26981 = *D.26980;
            D.26982 = (int) D.26981;
            D.26983 = __s2 + 1;
            D.26984 = *D.26983;
            D.26985 = (int) D.26984;
            __result = D.26982 - D.26985;
            if (__s2_len > 1) goto <D.26986>; else goto <D.26987>;
            <D.26986>:
            if (__result == 0) goto <D.26988>; else goto <D.26989>;
            <D.26988>:
            D.26990 = &MEM[(void *)"Write" + 2B];
            D.26991 = *D.26990;
            D.26992 = (int) D.26991;
            D.26993 = __s2 + 2;
            D.26994 = *D.26993;
            D.26995 = (int) D.26994;
            __result = D.26992 - D.26995;
            if (__s2_len > 2) goto <D.26996>; else goto <D.26997>;
            <D.26996>:
            if (__result == 0) goto <D.26998>; else goto <D.26999>;
            <D.26998>:
            D.27000 = &MEM[(void *)"Write" + 3B];
            D.27001 = *D.27000;
            D.27002 = (int) D.27001;
            D.27003 = __s2 + 3;
            D.27004 = *D.27003;
            D.27005 = (int) D.27004;
            __result = D.27002 - D.27005;
            <D.26999>:
            <D.26997>:
            <D.26989>:
            <D.26987>:
            <D.26979>:
            <D.26977>:
          }
          D.23823 = __result;
        }
        iftmp.174 = -D.23823;
        goto <D.27006>;
        <D.26970>:
        D.26550 = method->name;
        iftmp.174 = __builtin_strcmp (D.26550, "Write");
        <D.27006>:
        D.23824 = iftmp.174;
      }
      if (D.23824 == 0) goto <D.27007>; else goto <D.26628>;
      <D.27007>:
      D.27008 = mono_method_signature (method);
      D.27009 = D.27008->params[1];
      D.27010 = mono_type_is_reference (D.27009);
      if (D.27010 != 0) goto <D.26626>; else goto <D.26628>;
      <D.26626>:
      {
        struct MonoMethod * m;
        struct MonoGenericContext ctx;
        struct MonoType * args[16];
        void * iter;

        try
          {
            iter = 0B;
            goto <D.23840>;
            <D.23839>:
            D.27011 = mono_method_signature (m);
            D.27012 = D.27011->generic_param_count;
            if (D.27012 != 0) goto <D.27013>; else goto <D.27014>;
            <D.27013>:
            {
              size_t __s1_len;
              size_t __s2_len;

              D.27015 = m->name;
              D.26550 = method->name;
              D.23837 = __builtin_strcmp (D.27015, D.26550);
            }
            if (D.23837 == 0) goto <D.23838>; else goto <D.27016>;
            <D.27016>:
            <D.27014>:
            <D.23840>:
            D.26546 = method->klass;
            m = mono_class_get_methods (D.26546, &iter);
            if (m != 0B) goto <D.23839>; else goto <D.23838>;
            <D.23838>:
            D.27017 = m == 0B;
            D.27018 = (long int) D.27017;
            D.27019 = __builtin_expect (D.27018, 0);
            if (D.27019 != 0) goto <D.27020>; else goto <D.27021>;
            <D.27020>:
            monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "aot-runtime.c", 3702, "m");
            <D.27021>:
            memset (&ctx, 0, 8);
            D.26618 = mono_defaults.object_class;
            D.26619 = &D.26618->byval_arg;
            args[0] = D.26619;
            D.27022 = mono_metadata_get_generic_inst (1, &args);
            ctx.method_inst = D.27022;
            D.27023 = mono_class_inflate_generic_method (m, &ctx);
            m = mono_marshal_get_native_wrapper (D.27023, 1, 1);
            if (method == m) goto <D.27024>; else goto <D.27025>;
            <D.27024>:
            D.26480 = 0B;
            return D.26480;
            <D.27025>:
            code = mono_aot_get_method (domain, m);
            if (code != 0B) goto <D.27026>; else goto <D.27027>;
            <D.27026>:
            D.26480 = code;
            return D.26480;
            <D.27027>:
          }
        finally
          {
            ctx = {CLOBBER};
            args = {CLOBBER};
            iter = {CLOBBER};
          }
      }
      <D.26628>:
      <D.26636>:
      <D.26632>:
      <D.26630>:
      if (method_index == 16777215) goto <D.27028>; else goto <D.27029>;
      <D.27028>:
      D.26500 = BIT_FIELD_REF <*method, 32, 160>;
      D.26523 = D.26500 & 4096;
      if (D.26523 != 0) goto <D.27030>; else goto <D.27031>;
      <D.27030>:
      D.27032 = mono_method_is_generic_sharable_full (method, 0, 1, 0);
      if (D.27032 != 0) goto <D.27033>; else goto <D.27034>;
      <D.27033>:
      {
        struct MonoMethod * shared;

        shared = mini_get_shared_method (method);
        method_index = find_extra_method (shared, &amodule);
        if (method_index != 16777215) goto <D.27035>; else goto <D.27036>;
        <D.27035>:
        method = shared;
        <D.27036>:
      }
      <D.27034>:
      <D.27031>:
      <D.27029>:
      if (method_index == 16777215) goto <D.27037>; else goto <D.27038>;
      <D.27037>:
      D.26500 = BIT_FIELD_REF <*method, 32, 160>;
      D.26523 = D.26500 & 4096;
      if (D.26523 != 0) goto <D.27039>; else goto <D.27040>;
      <D.27039>:
      D.27041 = mono_method_is_generic_sharable_full (method, 0, 0, 1);
      if (D.27041 != 0) goto <D.27042>; else goto <D.27043>;
      <D.27042>:
      D.27044 = mini_get_shared_method_full (method, 1, 1);
      method_index = find_extra_method (D.27044, &amodule);
      if (method_index != 16777215) goto <D.27045>; else goto <D.27046>;
      <D.27045>:
      method = mini_get_shared_method_full (method, 1, 0);
      <D.27046>:
      <D.27043>:
      <D.27040>:
      <D.27038>:
      if (method_index == 16777215) goto <D.27047>; else goto <D.27048>;
      <D.27047>:
      mono_aot_only.163 = mono_aot_only;
      if (mono_aot_only.163 != 0) goto <D.27049>; else goto <D.27050>;
      <D.27049>:
      D.27051 = mono_trace_is_traced (128, 32);
      if (D.27051 != 0) goto <D.27052>; else goto <D.27053>;
      <D.27052>:
      {
        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.27053>:
      <D.27050>:
      D.26480 = 0B;
      return D.26480;
      <D.27048>:
      if (method_index == 16777215) goto <D.27054>; else goto <D.27055>;
      <D.27054>:
      D.26480 = 0B;
      return D.26480;
      <D.27055>:
      {
        int ret;

        ret = pthread_mutex_lock (&aot_mutex.mutex);
        if (ret != 0) goto <D.27056>; else goto <D.27057>;
        <D.27056>:
        monoeg_g_log (0B, 16, "Bad call to mono_mutex_lock result %d", ret);
        <D.27057>:
        D.27058 = ret != 0;
        D.27059 = (long int) D.27058;
        D.27060 = __builtin_expect (D.27059, 0);
        if (D.27060 != 0) goto <D.27061>; else goto <D.27062>;
        <D.27061>:
        monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "aot-runtime.c", 3756, "ret == 0");
        <D.27062>:
      }
      amodule.162 = amodule;
      D.27063 = amodule.162->extra_methods;
      if (D.27063 == 0B) goto <D.27064>; else goto <D.27065>;
      <D.27064>:
      amodule.162 = amodule;
      D.27066 = monoeg_g_hash_table_new (0B, 0B);
      amodule.162->extra_methods = D.27066;
      <D.27065>:
      amodule.162 = amodule;
      D.27063 = amodule.162->extra_methods;
      method_index.175 = (void *) method_index;
      monoeg_g_hash_table_insert_replace (D.27063, method_index.175, method, 0);
      {
        int ret;

        ret = pthread_mutex_unlock (&aot_mutex.mutex);
        if (ret != 0) goto <D.27068>; else goto <D.27069>;
        <D.27068>:
        monoeg_g_log (0B, 16, "Bad call to mono_mutex_unlock result %d", ret);
        <D.27069>:
        D.27070 = ret != 0;
        D.27071 = (long int) D.27070;
        D.27072 = __builtin_expect (D.27071, 0);
        if (D.27072 != 0) goto <D.27073>; else goto <D.27074>;
        <D.27073>:
        monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "aot-runtime.c", 3760, "ret == 0");
        <D.27074>:
      }
      goto <D.26522>;
      <D.26521>:
      D.26518 = method->token;
      D.26519 = D.26518 & 16777215;
      method_index = D.26519 + 4294967295;
      <D.26522>:
      <D.26513>:
      amodule.162 = amodule;
      D.26475 = klass->image;
      D.26518 = method->token;
      method_index.176 = (int) method_index;
      D.26480 = load_method (domain, amodule.162, D.26475, method, D.26518, method_index.176);
      return D.26480;
    }
  finally
    {
      amodule = {CLOBBER};
    }
}


find_extra_method (struct MonoMethod * method, struct MonoAotModule * * out_amodule)
{
  struct MonoClass * D.27082;
  struct MonoImage * D.27083;
  void * D.27084;
  guint32 D.27087;
  _Bool D.27090;
  long int D.27091;
  long int D.27092;
  struct GHashTable * aot_modules.177;
  _Bool D.27098;
  long int D.27099;
  long int D.27100;
  void * * D.27103;
  unsigned int i.178;
  unsigned int D.27105;
  void * * D.27106;
  unsigned int i.179;
  unsigned int D.27112;
  guint32 index;
  struct GPtrArray * modules;
  int i;

  D.27082 = method->klass;
  D.27083 = D.27082->image;
  D.27084 = D.27083->aot_module;
  *out_amodule = D.27084;
  D.27082 = method->klass;
  D.27083 = D.27082->image;
  D.27084 = D.27083->aot_module;
  index = find_extra_method_in_amodule (D.27084, method);
  if (index != 16777215) goto <D.27085>; else goto <D.27086>;
  <D.27085>:
  D.27087 = index;
  return D.27087;
  <D.27086>:
  modules = monoeg_g_ptr_array_new ();
  {
    int ret;

    ret = pthread_mutex_lock (&aot_mutex.mutex);
    if (ret != 0) goto <D.27088>; else goto <D.27089>;
    <D.27088>:
    monoeg_g_log (0B, 16, "Bad call to mono_mutex_lock result %d", ret);
    <D.27089>:
    D.27090 = ret != 0;
    D.27091 = (long int) D.27090;
    D.27092 = __builtin_expect (D.27091, 0);
    if (D.27092 != 0) goto <D.27093>; else goto <D.27094>;
    <D.27093>:
    monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "aot-runtime.c", 3559, "ret == 0");
    <D.27094>:
  }
  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.27096>; else goto <D.27097>;
    <D.27096>:
    monoeg_g_log (0B, 16, "Bad call to mono_mutex_unlock result %d", ret);
    <D.27097>:
    D.27098 = ret != 0;
    D.27099 = (long int) D.27098;
    D.27100 = __builtin_expect (D.27099, 0);
    if (D.27100 != 0) goto <D.27101>; else goto <D.27102>;
    <D.27101>:
    monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "aot-runtime.c", 3561, "ret == 0");
    <D.27102>:
  }
  index = 16777215;
  i = 0;
  goto <D.23711>;
  <D.23710>:
  {
    struct MonoAotModule * amodule;

    D.27103 = modules->pdata;
    i.178 = (unsigned int) i;
    D.27105 = i.178 * 4;
    D.27106 = D.27103 + D.27105;
    amodule = *D.27106;
    D.27082 = method->klass;
    D.27083 = D.27082->image;
    D.27084 = D.27083->aot_module;
    if (D.27084 != amodule) goto <D.27107>; else goto <D.27108>;
    <D.27107>:
    index = find_extra_method_in_amodule (amodule, method);
    <D.27108>:
    if (index != 16777215) goto <D.27109>; else goto <D.27110>;
    <D.27109>:
    *out_amodule = amodule;
    goto <D.23709>;
    <D.27110>:
  }
  i = i + 1;
  <D.23711>:
  i.179 = (unsigned int) i;
  D.27112 = modules->len;
  if (i.179 < D.27112) goto <D.23710>; else goto <D.23709>;
  <D.23709>:
  monoeg_g_ptr_array_free (modules, 1);
  D.27087 = index;
  return D.27087;
}


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.27117;
  guint32 D.27118;
  guint32 * D.27119;
  unsigned int D.27120;
  unsigned int D.27121;
  unsigned int D.27122;
  unsigned int D.27123;
  sizetype D.27126;
  sizetype D.27127;
  guint32 * D.27128;
  guint8 * D.27129;
  guint8 * p.180;
  _Bool D.27133;
  long int D.27134;
  long int D.27135;
  struct GHashTable * D.27138;
  struct GHashTable * D.27141;
  guint8 * p.181;
  _Bool D.27145;
  long int D.27146;
  long int D.27147;
  _Bool D.27156;
  long int D.27157;
  long int D.27158;
  _Bool D.27163;
  long int D.27164;
  long int D.27165;
  unsigned int D.27172;
  unsigned int D.27173;
  unsigned int D.27178;
  unsigned int D.27179;
  struct MonoMethod * D.27182;
  unsigned int n_extra_decodes.182;
  unsigned int n_extra_decodes.183;
  unsigned int D.27190;
  unsigned int D.27191;
  guint32 table_size;
  guint32 entry_size;
  guint32 hash;
  guint32 * table;
  guint32 * entry;
  guint32 index;
  static guint32 n_extra_decodes;

  if (amodule == 0B) goto <D.27114>; else goto <D.27116>;
  <D.27116>:
  D.27117 = amodule->out_of_date;
  if (D.27117 != 0) goto <D.27114>; else goto <D.27115>;
  <D.27114>:
  D.27118 = 16777215;
  return D.27118;
  <D.27115>:
  D.27119 = amodule->extra_method_table;
  table_size = *D.27119;
  D.27119 = amodule->extra_method_table;
  table = D.27119 + 4;
  entry_size = 3;
  D.27120 = mono_aot_method_hash (method);
  hash = D.27120 % table_size;
  D.27121 = hash * entry_size;
  D.27122 = D.27121 * 4;
  entry = table + D.27122;
  D.27123 = *entry;
  if (D.27123 == 0) goto <D.27124>; else goto <D.27125>;
  <D.27124>:
  D.27118 = 16777215;
  return D.27118;
  <D.27125>:
  index = 16777215;
  <D.23693>:
  {
    guint32 key;
    guint32 value;
    guint32 next;
    struct MonoMethod * m;
    guint8 * p;
    guint8 * orig_p;

    try
      {
        key = *entry;
        value = MEM[(guint32 *)entry + 4B];
        D.27126 = entry_size + 1073741823;
        D.27127 = D.27126 * 4;
        D.27128 = entry + D.27127;
        next = *D.27128;
        D.27129 = amodule->blob;
        p.180 = D.27129 + key;
        p = p.180;
        orig_p = p;
        {
          int ret;

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

          ret = pthread_mutex_unlock (&aot_mutex.mutex);
          if (ret != 0) goto <D.27143>; else goto <D.27144>;
          <D.27143>:
          monoeg_g_log (0B, 16, "Bad call to mono_mutex_unlock result %d", ret);
          <D.27144>:
          D.27145 = ret != 0;
          D.27146 = (long int) D.27145;
          D.27147 = __builtin_expect (D.27146, 0);
          if (D.27147 != 0) goto <D.27148>; else goto <D.27149>;
          <D.27148>:
          monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "aot-runtime.c", 3483, "ret == 0");
          <D.27149>:
        }
        if (m == 0B) goto <D.27150>; else goto <D.27151>;
        <D.27150>:
        p.181 = p;
        m = decode_resolve_method_ref_with_target (amodule, method, p.181, &p);
        if (m != 0B) goto <D.27152>; else goto <D.27153>;
        <D.27152>:
        {
          int ret;

          ret = pthread_mutex_lock (&aot_mutex.mutex);
          if (ret != 0) goto <D.27154>; else goto <D.27155>;
          <D.27154>:
          monoeg_g_log (0B, 16, "Bad call to mono_mutex_lock result %d", ret);
          <D.27155>:
          D.27156 = ret != 0;
          D.27157 = (long int) D.27156;
          D.27158 = __builtin_expect (D.27157, 0);
          if (D.27158 != 0) goto <D.27159>; else goto <D.27160>;
          <D.27159>:
          monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "aot-runtime.c", 3487, "ret == 0");
          <D.27160>:
        }
        D.27138 = amodule->method_ref_to_method;
        monoeg_g_hash_table_insert_replace (D.27138, orig_p, m, 0);
        {
          int ret;

          ret = pthread_mutex_unlock (&aot_mutex.mutex);
          if (ret != 0) goto <D.27161>; else goto <D.27162>;
          <D.27161>:
          monoeg_g_log (0B, 16, "Bad call to mono_mutex_unlock result %d", ret);
          <D.27162>:
          D.27163 = ret != 0;
          D.27164 = (long int) D.27163;
          D.27165 = __builtin_expect (D.27164, 0);
          if (D.27165 != 0) goto <D.27166>; else goto <D.27167>;
          <D.27166>:
          monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "aot-runtime.c", 3489, "ret == 0");
          <D.27167>:
        }
        <D.27153>:
        <D.27151>:
        if (m == method) goto <D.27168>; else goto <D.27169>;
        <D.27168>:
        index = value;
        goto <D.23690>;
        <D.27169>:
        if (m != 0B) goto <D.27170>; else goto <D.27171>;
        <D.27170>:
        D.27172 = BIT_FIELD_REF <*method, 32, 160>;
        D.27173 = D.27172 & 124;
        if (D.27173 != 0) goto <D.27174>; else goto <D.27175>;
        <D.27174>:
        D.27172 = BIT_FIELD_REF <*method, 32, 160>;
        D.27173 = D.27172 & 124;
        if (D.27173 == 64) goto <D.27176>; else goto <D.27177>;
        <D.27176>:
        {
          struct MonoMethod * w1;
          struct MonoMethod * w2;

          w1 = mono_marshal_method_from_wrapper (method);
          w2 = mono_marshal_method_from_wrapper (m);
          D.27178 = BIT_FIELD_REF <*w1, 32, 160>;
          D.27179 = D.27178 & 4096;
          if (D.27179 != 0) goto <D.27180>; else goto <D.27181>;
          <D.27180>:
          D.27182 = MEM[(struct MonoMethodInflated *)w1].declaring;
          if (D.27182 == w2) goto <D.27183>; else goto <D.27184>;
          <D.27183>:
          index = value;
          goto <D.23690>;
          <D.27184>:
          <D.27181>:
        }
        <D.27177>:
        <D.27175>:
        <D.27171>:
        if (m != 0B) goto <D.27185>; else goto <D.27186>;
        <D.27185>:
        n_extra_decodes.182 = n_extra_decodes;
        n_extra_decodes.183 = n_extra_decodes.182 + 1;
        n_extra_decodes = n_extra_decodes.183;
        <D.27186>:
        if (next != 0) goto <D.27189>; else goto <D.23690>;
        <D.27189>:
        D.27190 = next * entry_size;
        D.27191 = D.27190 * 4;
        entry = table + D.27191;
      }
    finally
      {
        p = {CLOBBER};
      }
  }
  goto <D.23693>;
  <D.23690>:
  D.27118 = index;
  return D.27118;
}


load_method (struct MonoDomain * domain, struct MonoAotModule * amodule, struct MonoImage * image, struct MonoMethod * method, guint32 token, int method_index)
{
  _Bool D.27195;
  <unnamed type> D.27196;
  unsigned int D.27197;
  void * D.27200;
  struct MonoDomain * D.27201;
  unsigned int D.27204;
  unsigned int D.27205;
  int D.27208;
  gint32 * D.27211;
  unsigned int method_index.184;
  unsigned int D.27213;
  gint32 * D.27214;
  int D.27215;
  int D.27218;
  guint8 * D.27223;
  sizetype D.27224;
  guint8 * D.27225;
  guint32 * D.27226;
  unsigned int D.27227;
  guint8 * D.27228;
  unsigned int D.27233;
  unsigned int D.27234;
  int D.27237;
  _Bool D.27238;
  long int D.27239;
  long int D.27240;
  sizetype D.27243;
  _Bool D.27246;
  long int D.27247;
  long int D.27248;
  guint32 * D.27251;
  unsigned int D.27254;
  unsigned int D.27255;
  unsigned int D.27256;
  unsigned int D.27257;
  void * D.27258;
  _Bool D.27261;
  long int D.27262;
  long int D.27263;
  int D.27266;
  unsigned int D.27267;
  unsigned int D.27268;
  guint32 * D.27269;
  unsigned int D.27270;
  int D.27271;
  unsigned int D.27272;
  unsigned int D.27273;
  int mono_last_aot_method.185;
  int D.27279;
  int D.27282;
  guint8 * p.186;
  int D.27297;
  struct MonoDomain * D.27298;
  unsigned int D.27299;
  unsigned int pindex.187;
  unsigned int D.27309;
  void * * D.27310;
  guint32 * got_slots.188;
  unsigned int D.27312;
  guint32 * D.27313;
  unsigned int D.27314;
  unsigned int D.27315;
  void * * D.27316;
  void * D.27317;
  void * D.27320;
  <unnamed type> D.27321;
  void * D.27324;
  struct MonoMethod * D.27327;
  struct MonoDebugOptions * D.27330;
  int D.27331;
  struct MonoAssembly * D.27334;
  struct MonoImage * D.27335;
  int D.27336;
  int D.27343;
  sizetype D.27344;
  guint8 * D.27345;
  _Bool D.27348;
  long int D.27349;
  long int D.27350;
  int D.27353;
  unsigned int D.27354;
  unsigned int D.27355;
  guint32 * D.27356;
  unsigned int D.27357;
  int D.27358;
  unsigned int D.27359;
  unsigned int D.27360;
  unsigned int D.27363;
  unsigned int D.27364;
  struct GHashTable * D.27367;
  _Bool D.27370;
  long int D.27371;
  long int D.27372;
  <unnamed type> D.27375;
  unsigned int D.27376;
  long int D.27381;
  long int D.27382;
  _Bool D.27385;
  long int D.27386;
  long int D.27387;
  struct MonoGenericContainer * D.27394;
  struct MonoVTable * D.27397;
  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.27195 = method == 0B;
      from_plt = (gboolean) D.27195;
      keep_patches = 1;
      jinfo = 0B;
      D.27196 = mono_profiler_get_events ();
      D.27197 = D.27196 & 4096;
      if (D.27197 != 0) goto <D.27198>; else goto <D.27199>;
      <D.27198>:
      D.27200 = 0B;
      return D.27200;
      <D.27199>:
      D.27201 = mono_get_root_domain ();
      if (D.27201 != domain) goto <D.27202>; else goto <D.27203>;
      <D.27202>:
      D.27204 = amodule->info.opts;
      D.27205 = D.27204 & 512;
      if (D.27205 == 0) goto <D.27206>; else goto <D.27207>;
      <D.27206>:
      D.27200 = 0B;
      return D.27200;
      <D.27207>:
      <D.27203>:
      D.27208 = amodule->out_of_date;
      if (D.27208 != 0) goto <D.27209>; else goto <D.27210>;
      <D.27209>:
      D.27200 = 0B;
      return D.27200;
      <D.27210>:
      D.27211 = amodule->code_offsets;
      method_index.184 = (unsigned int) method_index;
      D.27213 = method_index.184 * 4;
      D.27214 = D.27211 + D.27213;
      D.27215 = *D.27214;
      if (D.27215 == -1) goto <D.27216>; else goto <D.27217>;
      <D.27216>:
      D.27218 = mono_trace_is_traced (128, 32);
      if (D.27218 != 0) goto <D.27219>; else goto <D.27220>;
      <D.27219>:
      {
        char * full_name;

        if (method == 0B) goto <D.27221>; else goto <D.27222>;
        <D.27221>:
        method = mono_get_method (image, token, 0B);
        <D.27222>:
        full_name = mono_method_full_name (method, 1);
        mono_trace (128, 32, "AOT NOT FOUND: %s.", full_name);
        monoeg_g_free (full_name);
      }
      <D.27220>:
      D.27200 = 0B;
      return D.27200;
      <D.27217>:
      D.27223 = amodule->code;
      D.27211 = amodule->code_offsets;
      method_index.184 = (unsigned int) method_index;
      D.27213 = method_index.184 * 4;
      D.27214 = D.27211 + D.27213;
      D.27215 = *D.27214;
      D.27224 = (sizetype) D.27215;
      code = D.27223 + D.27224;
      D.27225 = amodule->blob;
      D.27226 = amodule->method_info_offsets;
      D.27227 = mono_aot_get_offset (D.27226, method_index);
      info = D.27225 + D.27227;
      D.27228 = amodule->thumb_end;
      if (D.27228 != 0B) goto <D.27229>; else goto <D.27230>;
      <D.27229>:
      D.27228 = amodule->thumb_end;
      if (D.27228 > code) goto <D.27231>; else goto <D.27232>;
      <D.27231>:
      D.27233 = amodule->info.flags;
      D.27234 = D.27233 & 8;
      if (D.27234 == 0) goto <D.27235>; else goto <D.27236>;
      <D.27235>:
      D.27211 = amodule->code_offsets;
      method_index.184 = (unsigned int) method_index;
      D.27213 = method_index.184 * 4;
      D.27214 = D.27211 + D.27213;
      D.27215 = *D.27214;
      D.27237 = D.27215 & 1;
      D.27238 = D.27237 != 0;
      D.27239 = (long int) D.27238;
      D.27240 = __builtin_expect (D.27239, 0);
      if (D.27240 != 0) goto <D.27241>; else goto <D.27242>;
      <D.27241>:
      monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "aot-runtime.c", 3299, "(amodule->code_offsets [method_index] & 0x1) == 0");
      <D.27242>:
      D.27223 = amodule->code;
      D.27211 = amodule->code_offsets;
      method_index.184 = (unsigned int) method_index;
      D.27213 = method_index.184 * 4;
      D.27214 = D.27211 + D.27213;
      D.27215 = *D.27214;
      D.27224 = (sizetype) D.27215;
      D.27243 = D.27224 + 1;
      code = D.27223 + D.27243;
      <D.27236>:
      <D.27232>:
      <D.27230>:
      {
        int ret;

        ret = pthread_mutex_lock (&aot_mutex.mutex);
        if (ret != 0) goto <D.27244>; else goto <D.27245>;
        <D.27244>:
        monoeg_g_log (0B, 16, "Bad call to mono_mutex_lock result %d", ret);
        <D.27245>:
        D.27246 = ret != 0;
        D.27247 = (long int) D.27246;
        D.27248 = __builtin_expect (D.27247, 0);
        if (D.27248 != 0) goto <D.27249>; else goto <D.27250>;
        <D.27249>:
        monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "aot-runtime.c", 3303, "ret == 0");
        <D.27250>:
      }
      D.27251 = amodule->methods_loaded;
      if (D.27251 == 0B) goto <D.27252>; else goto <D.27253>;
      <D.27252>:
      D.27254 = amodule->info.nmethods;
      D.27255 = D.27254 / 32;
      D.27256 = D.27255 + 1;
      D.27257 = D.27256 * 4;
      D.27258 = monoeg_malloc0 (D.27257);
      amodule->methods_loaded = D.27258;
      <D.27253>:
      {
        int ret;

        ret = pthread_mutex_unlock (&aot_mutex.mutex);
        if (ret != 0) goto <D.27259>; else goto <D.27260>;
        <D.27259>:
        monoeg_g_log (0B, 16, "Bad call to mono_mutex_unlock result %d", ret);
        <D.27260>:
        D.27261 = ret != 0;
        D.27262 = (long int) D.27261;
        D.27263 = __builtin_expect (D.27262, 0);
        if (D.27263 != 0) goto <D.27264>; else goto <D.27265>;
        <D.27264>:
        monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "aot-runtime.c", 3306, "ret == 0");
        <D.27265>:
      }
      D.27251 = amodule->methods_loaded;
      D.27266 = method_index / 32;
      D.27267 = (unsigned int) D.27266;
      D.27268 = D.27267 * 4;
      D.27269 = D.27251 + D.27268;
      D.27270 = *D.27269;
      D.27271 = method_index % 32;
      D.27272 = D.27270 >> D.27271;
      D.27273 = D.27272 & 1;
      if (D.27273 != 0) goto <D.27274>; else goto <D.27275>;
      <D.27274>:
      D.27200 = code;
      return D.27200;
      <D.27275>:
      mono_last_aot_method.185 = mono_last_aot_method;
      if (mono_last_aot_method.185 != -1) goto <D.27277>; else goto <D.27278>;
      <D.27277>:
      D.27279 = mono_jit_stats.methods_aot;
      mono_last_aot_method.185 = mono_last_aot_method;
      if (D.27279 >= mono_last_aot_method.185) goto <D.27280>; else goto <D.27281>;
      <D.27280>:
      D.27200 = 0B;
      return D.27200;
      <D.27281>:
      D.27279 = mono_jit_stats.methods_aot;
      mono_last_aot_method.185 = mono_last_aot_method;
      D.27282 = mono_last_aot_method.185 + -1;
      if (D.27279 == D.27282) goto <D.27283>; else goto <D.27284>;
      <D.27283>:
      if (method == 0B) goto <D.27285>; else goto <D.27286>;
      <D.27285>:
      method = mono_get_method (image, token, 0B);
      <D.27286>:
      if (method != 0B) goto <D.27287>; else goto <D.27288>;
      <D.27287>:
      {
        char * name;

        name = mono_method_full_name (method, 1);
        printf ("LAST AOT METHOD: %s.\n", name);
        monoeg_g_free (name);
      }
      goto <D.27289>;
      <D.27288>:
      printf ("LAST AOT METHOD: %p %d\n", code, method_index);
      <D.27289>:
      <D.27284>:
      <D.27278>:
      p = info;
      if (method != 0B) goto <D.27290>; else goto <D.27291>;
      <D.27290>:
      klass = method->klass;
      p.186 = p;
      decode_klass_ref (amodule, p.186, &p);
      goto <D.27293>;
      <D.27291>:
      p.186 = p;
      klass = decode_klass_ref (amodule, p.186, &p);
      <D.27293>:
      D.27204 = amodule->info.opts;
      D.27205 = D.27204 & 512;
      if (D.27205 != 0) goto <D.27294>; else goto <D.27295>;
      <D.27294>:
      p.186 = p;
      used_strings = decode_value (p.186, &p);
      goto <D.27296>;
      <D.27295>:
      used_strings = 0;
      <D.27296>:
      i = 0;
      goto <D.23656>;
      <D.23655>:
      {
        guint token;

        p.186 = p;
        D.27297 = decode_value (p.186, &p);
        token = (guint) D.27297;
        D.27298 = mono_get_root_domain ();
        D.27299 = token & 16777215;
        mono_ldstr (D.27298, image, D.27299);
      }
      i = i + 1;
      <D.23656>:
      if (i < used_strings) goto <D.23655>; else goto <D.23657>;
      <D.23657>:
      D.27204 = amodule->info.opts;
      D.27205 = D.27204 & 512;
      if (D.27205 != 0) goto <D.27300>; else goto <D.27301>;
      <D.27300>:
      keep_patches = 0;
      <D.27301>:
      p.186 = p;
      n_patches = decode_value (p.186, &p);
      keep_patches = 0;
      if (n_patches != 0) goto <D.27302>; else goto <D.27303>;
      <D.27302>:
      {
        struct MonoJumpInfo * patches;
        guint32 * got_slots;

        try
          {
            if (keep_patches != 0) goto <D.27304>; else goto <D.27305>;
            <D.27304>:
            mp = domain->mp;
            goto <D.27306>;
            <D.27305>:
            mp = mono_mempool_new ();
            <D.27306>:
            p.186 = p;
            patches = load_patch_info (amodule, mp, n_patches, &got_slots, p.186, &p);
            if (patches == 0B) goto cleanup; else goto <D.27307>;
            <D.27307>:
            pindex = 0;
            goto <D.23663>;
            <D.23662>:
            {
              struct MonoJumpInfo * ji;

              pindex.187 = (unsigned int) pindex;
              D.27309 = pindex.187 * 20;
              ji = patches + D.27309;
              D.27310 = amodule->got;
              got_slots.188 = got_slots;
              pindex.187 = (unsigned int) pindex;
              D.27312 = pindex.187 * 4;
              D.27313 = got_slots.188 + D.27312;
              D.27314 = *D.27313;
              D.27315 = D.27314 * 4;
              D.27316 = D.27310 + D.27315;
              D.27317 = *D.27316;
              if (D.27317 == 0B) goto <D.27318>; else goto <D.27319>;
              <D.27318>:
              D.27310 = amodule->got;
              got_slots.188 = got_slots;
              pindex.187 = (unsigned int) pindex;
              D.27312 = pindex.187 * 4;
              D.27313 = got_slots.188 + D.27312;
              D.27314 = *D.27313;
              D.27315 = D.27314 * 4;
              D.27316 = D.27310 + D.27315;
              D.27320 = mono_resolve_patch_target (method, domain, code, ji, 1);
              *D.27316 = D.27320;
              D.27321 = ji->type;
              if (D.27321 == 4) goto <D.27322>; else goto <D.27323>;
              <D.27322>:
              D.27310 = amodule->got;
              got_slots.188 = got_slots;
              pindex.187 = (unsigned int) pindex;
              D.27312 = pindex.187 * 4;
              D.27313 = got_slots.188 + D.27312;
              D.27314 = *D.27313;
              D.27315 = D.27314 * 4;
              D.27316 = D.27310 + D.27315;
              D.27310 = amodule->got;
              got_slots.188 = got_slots;
              pindex.187 = (unsigned int) pindex;
              D.27312 = pindex.187 * 4;
              D.27313 = got_slots.188 + D.27312;
              D.27314 = *D.27313;
              D.27315 = D.27314 * 4;
              D.27316 = D.27310 + D.27315;
              D.27317 = *D.27316;
              D.27324 = mono_create_ftnptr (domain, D.27317);
              *D.27316 = D.27324;
              <D.27323>:
              D.27321 = ji->type;
              if (D.27321 == 4) goto <D.27325>; else goto <D.27326>;
              <D.27325>:
              D.27327 = ji->data.method;
              D.27310 = amodule->got;
              got_slots.188 = got_slots;
              pindex.187 = (unsigned int) pindex;
              D.27312 = pindex.187 * 4;
              D.27313 = got_slots.188 + D.27312;
              D.27314 = *D.27313;
              D.27315 = D.27314 * 4;
              D.27316 = D.27310 + D.27315;
              register_jump_target_got_slot (domain, D.27327, D.27316);
              <D.27326>:
              <D.27319>:
              ji->type = 51;
            }
            pindex = pindex + 1;
            <D.23663>:
            if (pindex < n_patches) goto <D.23662>; else goto <D.23664>;
            <D.23664>:
            got_slots.188 = got_slots;
            monoeg_g_free (got_slots.188);
            if (keep_patches == 0) goto <D.27328>; else goto <D.27329>;
            <D.27328>:
            mono_mempool_destroy (mp);
            <D.27329>:
          }
        finally
          {
            got_slots = {CLOBBER};
          }
      }
      <D.27303>:
      D.27330 = mini_get_debug_options ();
      D.27331 = D.27330->load_aot_jit_info_eagerly;
      if (D.27331 != 0) goto <D.27332>; else goto <D.27333>;
      <D.27332>:
      D.27334 = amodule->assembly;
      D.27335 = D.27334->image;
      jinfo = mono_aot_find_jit_info (domain, D.27335, code);
      <D.27333>:
      D.27336 = mono_trace_is_traced (128, 32);
      if (D.27336 != 0) goto <D.27337>; else goto <D.27338>;
      <D.27337>:
      {
        char * full_name;

        if (method == 0B) goto <D.27339>; else goto <D.27340>;
        <D.27339>:
        method = mono_get_method (image, token, 0B);
        <D.27340>:
        full_name = mono_method_full_name (method, 1);
        if (jinfo == 0B) goto <D.27341>; else goto <D.27342>;
        <D.27341>:
        D.27334 = amodule->assembly;
        D.27335 = D.27334->image;
        jinfo = mono_aot_find_jit_info (domain, D.27335, code);
        <D.27342>:
        D.27343 = jinfo->code_size;
        D.27344 = (sizetype) D.27343;
        D.27345 = code + D.27344;
        mono_trace (128, 32, "AOT FOUND method %s [%p - %p %p]", full_name, code, D.27345, info);
        monoeg_g_free (full_name);
      }
      <D.27338>:
      {
        int ret;

        ret = pthread_mutex_lock (&aot_mutex.mutex);
        if (ret != 0) goto <D.27346>; else goto <D.27347>;
        <D.27346>:
        monoeg_g_log (0B, 16, "Bad call to mono_mutex_lock result %d", ret);
        <D.27347>:
        D.27348 = ret != 0;
        D.27349 = (long int) D.27348;
        D.27350 = __builtin_expect (D.27349, 0);
        if (D.27350 != 0) goto <D.27351>; else goto <D.27352>;
        <D.27351>:
        monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "aot-runtime.c", 3403, "ret == 0");
        <D.27352>:
      }
      InterlockedIncrement (&mono_jit_stats.methods_aot);
      D.27251 = amodule->methods_loaded;
      D.27353 = method_index / 32;
      D.27354 = (unsigned int) D.27353;
      D.27355 = D.27354 * 4;
      D.27356 = D.27251 + D.27355;
      D.27251 = amodule->methods_loaded;
      D.27354 = (unsigned int) D.27353;
      D.27355 = D.27354 * 4;
      D.27356 = D.27251 + D.27355;
      D.27357 = *D.27356;
      D.27271 = method_index % 32;
      D.27358 = 1 << D.27271;
      D.27359 = (unsigned int) D.27358;
      D.27360 = D.27357 | D.27359;
      *D.27356 = D.27360;
      init_plt (amodule);
      if (method != 0B) goto <D.27361>; else goto <D.27362>;
      <D.27361>:
      D.27363 = BIT_FIELD_REF <*method, 32, 160>;
      D.27364 = D.27363 & 124;
      if (D.27364 != 0) goto <D.27365>; else goto <D.27366>;
      <D.27365>:
      D.27367 = amodule->method_to_code;
      monoeg_g_hash_table_insert_replace (D.27367, method, code, 0);
      <D.27366>:
      <D.27362>:
      {
        int ret;

        ret = pthread_mutex_unlock (&aot_mutex.mutex);
        if (ret != 0) goto <D.27368>; else goto <D.27369>;
        <D.27368>:
        monoeg_g_log (0B, 16, "Bad call to mono_mutex_unlock result %d", ret);
        <D.27369>:
        D.27370 = ret != 0;
        D.27371 = (long int) D.27370;
        D.27372 = __builtin_expect (D.27371, 0);
        if (D.27372 != 0) goto <D.27373>; else goto <D.27374>;
        <D.27373>:
        monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "aot-runtime.c", 3414, "ret == 0");
        <D.27374>:
      }
      D.27375 = mono_profiler_get_events ();
      D.27376 = D.27375 & 16;
      if (D.27376 != 0) goto <D.27377>; else goto <D.27378>;
      <D.27377>:
      {
        struct MonoJitInfo * jinfo;

        if (method == 0B) goto <D.27379>; else goto <D.27380>;
        <D.27379>:
        method = mono_get_method (image, token, 0B);
        D.27195 = method == 0B;
        D.27381 = (long int) D.27195;
        D.27382 = __builtin_expect (D.27381, 0);
        if (D.27382 != 0) goto <D.27383>; else goto <D.27384>;
        <D.27383>:
        monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "aot-runtime.c", 3421, "method");
        <D.27384>:
        <D.27380>:
        mono_profiler_method_jit (method);
        jinfo = mono_jit_info_table_find (domain, code);
        D.27385 = jinfo == 0B;
        D.27386 = (long int) D.27385;
        D.27387 = __builtin_expect (D.27386, 0);
        if (D.27387 != 0) goto <D.27388>; else goto <D.27389>;
        <D.27388>:
        monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "aot-runtime.c", 3425, "jinfo");
        <D.27389>:
        mono_profiler_method_end_jit (method, jinfo, 0);
      }
      <D.27378>:
      if (from_plt != 0) goto <D.27390>; else goto <D.27391>;
      <D.27390>:
      if (klass != 0B) goto <D.27392>; else goto <D.27393>;
      <D.27392>:
      D.27394 = klass->generic_container;
      if (D.27394 == 0B) goto <D.27395>; else goto <D.27396>;
      <D.27395>:
      D.27397 = mono_class_vtable (domain, klass);
      mono_runtime_class_init (D.27397);
      <D.27396>:
      <D.27393>:
      <D.27391>:
      D.27200 = code;
      return D.27200;
      cleanup:
      D.27204 = amodule->info.opts;
      D.27205 = D.27204 & 512;
      if (D.27205 != 0) goto <D.27398>; else goto <D.27399>;
      <D.27398>:
      mono_mempool_destroy (mp);
      <D.27399>:
      if (jinfo != 0B) goto <D.27400>; else goto <D.27401>;
      <D.27400>:
      monoeg_g_free (jinfo);
      <D.27401>:
      D.27200 = 0B;
      return D.27200;
    }
  finally
    {
      p = {CLOBBER};
    }
}


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

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


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.27409;
  unsigned int D.27410;
  void * D.27411;
  unsigned int pindex.190;
  unsigned int D.27413;
  guint8 * p.191;
  int D.27415;
  void * * D.27416;
  unsigned int D.27417;
  void * * D.27418;
  void * D.27419;
  guint8 * D.27423;
  guint32 * D.27424;
  int got_offset.192;
  unsigned int D.27426;
  guint8 * shared_p.193;
  guint8 * shared_p.194;
  int D.27429;
  <unnamed type> D.27430;
  guint32 * D.27432;
  unsigned int D.27433;
  guint32 * D.27434;
  struct MonoJumpInfo * D.27435;
  struct MonoJumpInfo * patches;
  int pindex;
  guint8 * p;
  void cleanup = <<< error >>>;

  try
    {
      p = buf;
      n_patches.189 = (unsigned int) n_patches;
      D.27409 = n_patches.189 * 20;
      patches = mono_mempool_alloc0 (mp, D.27409);
      n_patches.189 = (unsigned int) n_patches;
      D.27410 = n_patches.189 * 4;
      D.27411 = monoeg_malloc (D.27410);
      *got_slots = D.27411;
      pindex = 0;
      goto <D.23619>;
      <D.23618>:
      {
        struct MonoJumpInfo * ji;
        guint8 * shared_p;
        gboolean res;
        guint32 got_offset;

        try
          {
            pindex.190 = (unsigned int) pindex;
            D.27413 = pindex.190 * 20;
            ji = patches + D.27413;
            p.191 = p;
            D.27415 = decode_value (p.191, &p);
            got_offset = (guint32) D.27415;
            D.27416 = aot_module->got;
            D.27417 = got_offset * 4;
            D.27418 = D.27416 + D.27417;
            D.27419 = *D.27418;
            if (D.27419 != 0B) goto <D.27420>; else goto <D.27421>;
            <D.27420>:
            goto <D.27422>;
            <D.27421>:
            D.27423 = aot_module->blob;
            D.27424 = aot_module->got_info_offsets;
            got_offset.192 = (int) got_offset;
            D.27426 = mono_aot_get_offset (D.27424, got_offset.192);
            shared_p.193 = D.27423 + D.27426;
            shared_p = shared_p.193;
            shared_p.194 = shared_p;
            D.27429 = decode_value (shared_p.194, &shared_p);
            D.27430 = (<unnamed type>) D.27429;
            ji->type = D.27430;
            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.27431>;
            <D.27431>:
            <D.27422>:
            D.27432 = *got_slots;
            pindex.190 = (unsigned int) pindex;
            D.27433 = pindex.190 * 4;
            D.27434 = D.27432 + D.27433;
            *D.27434 = got_offset;
          }
        finally
          {
            shared_p = {CLOBBER};
          }
      }
      pindex = pindex + 1;
      <D.23619>:
      if (pindex < n_patches) goto <D.23618>; else goto <D.23620>;
      <D.23620>:
      p.191 = p;
      *endbuf = p.191;
      D.27435 = patches;
      return D.27435;
      cleanup:
      D.27432 = *got_slots;
      monoeg_g_free (D.27432);
      *got_slots = 0B;
      D.27435 = 0B;
      return D.27435;
    }
  finally
    {
      p = {CLOBBER};
    }
}


decode_patch (struct MonoAotModule * aot_module, struct MonoMemPool * mp, struct MonoJumpInfo * ji, guint8 * buf, guint8 * * endbuf)
{
  <unnamed type> D.27440;
  guint8 * p.195;
  struct MonoMethod * D.27445;
  int mono_aot_only.196;
  int D.27449;
  unsigned int D.27452;
  unsigned int D.27453;
  struct MonoDomain * D.27455;
  struct MonoImage * D.27456;
  void * D.27457;
  void * D.27458;
  struct MonoMethod * D.27462;
  struct MonoMethod * D.27463;
  _Bool D.27464;
  long int D.27465;
  long int D.27466;
  struct MonoClass * D.27469;
  int D.27470;
  sizetype D.27471;
  guint8 * p.197;
  struct MonoMethod * D.27473;
  struct MonoClass * D.27475;
  struct MonoClass * D.27476;
  struct MonoClass * D.27478;
  int D.27480;
  struct MonoImage * D.27481;
  struct MonoImage * D.27482;
  struct MonoClassField * D.27484;
  struct MonoClassField * D.27485;
  void * D.27487;
  struct MonoJumpInfoBBTable * D.27488;
  int D.27489;
  struct MonoDomain * D.27490;
  int D.27491;
  unsigned int D.27492;
  unsigned int D.27493;
  unsigned int i.198;
  unsigned int D.27495;
  void * * D.27496;
  int D.27497;
  void * D.27498;
  struct MonoDomain * D.27499;
  void * D.27500;
  int D.27501;
  unsigned int val.199;
  const void * D.27503;
  guint32 * val.200;
  float D.27505;
  struct MonoDomain * D.27506;
  void * D.27507;
  int D.27508;
  unsigned int D.27509;
  int D.27510;
  unsigned int D.27511;
  unsigned int D.27512;
  long long unsigned int D.27513;
  long long unsigned int D.27514;
  unsigned int D.27515;
  long long unsigned int D.27516;
  long long unsigned int v.201;
  guint64 * v.202;
  double D.27519;
  int D.27520;
  int D.27522;
  int D.27523;
  unsigned int D.27524;
  struct MonoJumpInfoToken * D.27525;
  int D.27526;
  int D.27528;
  unsigned int D.27529;
  struct MonoJumpInfoToken * D.27530;
  struct MonoJumpInfoToken * D.27531;
  int D.27532;
  int D.27533;
  struct MonoGenericContext * D.27536;
  struct MonoClass * D.27538;
  const char * D.27540;
  int D.27541;
  int D.27542;
  int D.27543;
  guint8 * D.27544;
  guint8 * p2.203;
  guint8 * p2.204;
  struct MonoMethod * D.27547;
  unsigned int D.27548;
  _Bool D.27549;
  int D.27550;
  unsigned int D.27551;
  unsigned int D.27552;
  void * D.27553;
  struct MonoJumpInfo * D.27554;
  unsigned int D.27555;
  unsigned int D.27556;
  struct MonoMethod * D.27558;
  int D.27559;
  struct MonoMethodSignature * D.27560;
  int D.27561;
  const void * D.27562;
  struct MonoMethodSignature * D.27563;
  struct MonoMethodSignature * D.27564;
  _Bool D.27565;
  long int D.27566;
  long int D.27567;
  struct MonoMethod * D.27570;
  struct MonoMethod * D.27571;
  _Bool D.27572;
  long int D.27573;
  long int D.27574;
  struct MonoMethod * D.27577;
  struct MonoMethod * D.27578;
  _Bool D.27579;
  long int D.27580;
  long int D.27581;
  struct GPtrArray * D.27584;
  int D.27585;
  <unnamed type> D.27586;
  <unnamed type> D.27587;
  <unnamed type> D.27588;
  struct MonoType * D.27590;
  struct MonoClassField * D.27591;
  void * D.27592;
  struct GPtrArray * D.27594;
  gboolean D.27595;
  guint8 * p;
  void * * table;
  struct MonoImage * image;
  int i;
  void cleanup = <<< error >>>;

  try
    {
      p = buf;
      D.27440 = ji->type;
      switch (D.27440) <default: <D.23601>, case 3: <D.23529>, case 4: <D.23530>, case 5: <D.23567>, case 6: <D.23541>, case 7: <D.23538>, case 8: <D.23551>, case 10: <D.23566>, case 11: <D.23543>, case 12: <D.23548>, case 13: <D.23549>, case 14: <D.23542>, case 15: <D.23546>, case 16: <D.23550>, case 17: <D.23560>, case 18: <D.23563>, case 19: <D.23564>, case 20: <D.23555>, case 21: <D.23557>, case 23: <D.23544>, case 24: <D.23545>, case 28: <D.23562>, case 29: <D.23561>, case 30: <D.23547>, case 31: <D.23531>, case 32: <D.23539>, case 33: <D.23568>, case 34: <D.23532>, case 35: <D.23575>, case 36: <D.23569>, case 37: <D.23570>, case 38: <D.23571>, case 40: <D.23581>, case 41: <D.23582>, case 42: <D.23572>, case 43: <D.23573>, case 44: <D.23584>, case 45: <D.23586>, case 46: <D.23588>, case 47: <D.23574>, case 48: <D.23585>, case 50: <D.23533>>
      <D.23529>:
      <D.23530>:
      <D.23531>:
      <D.23532>:
      <D.23533>:
      {
        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.27442>;
            <D.27442>:
            D.27445 = ref.method;
            if (D.27445 == 0B) goto <D.27446>; else goto <D.27443>;
            <D.27446>:
            mono_aot_only.196 = mono_aot_only;
            if (mono_aot_only.196 == 0) goto <D.27448>; else goto <D.27443>;
            <D.27448>:
            D.27449 = ref.no_aot_trampoline;
            if (D.27449 == 0) goto <D.27450>; else goto <D.27443>;
            <D.27450>:
            D.27440 = ji->type;
            if (D.27440 == 3) goto <D.27451>; else goto <D.27443>;
            <D.27451>:
            D.27452 = ref.token;
            D.27453 = D.27452 >> 24;
            if (D.27453 == 6) goto <D.27454>; else goto <D.27443>;
            <D.27454>:
            D.27455 = mono_domain_get ();
            D.27456 = ref.image;
            D.27452 = ref.token;
            D.27457 = mono_create_jit_trampoline_from_token (D.27456, D.27452);
            D.27458 = mono_create_ftnptr (D.27455, D.27457);
            ji->data.target = D.27458;
            ji->type = 1;
            goto <D.27444>;
            <D.27443>:
            D.27445 = ref.method;
            if (D.27445 != 0B) goto <D.27459>; else goto <D.27460>;
            <D.27459>:
            D.27445 = ref.method;
            ji->data.method = D.27445;
            goto <D.27461>;
            <D.27460>:
            D.27456 = ref.image;
            D.27452 = ref.token;
            D.27462 = mono_get_method (D.27456, D.27452, 0B);
            ji->data.method = D.27462;
            <D.27461>:
            D.27463 = ji->data.method;
            D.27464 = D.27463 == 0B;
            D.27465 = (long int) D.27464;
            D.27466 = __builtin_expect (D.27465, 0);
            if (D.27466 != 0) goto <D.27467>; else goto <D.27468>;
            <D.27467>:
            monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "aot-runtime.c", 2969, "ji->data.method");
            <D.27468>:
            D.27463 = ji->data.method;
            D.27469 = D.27463->klass;
            mono_class_init (D.27469);
            <D.27444>:
            goto <D.23537>;
          }
        finally
          {
            ref = {CLOBBER};
          }
      }
      <D.23538>:
      <D.23539>:
      {
        guint32 len;

        p.195 = p;
        D.27470 = decode_value (p.195, &p);
        len = (guint32) D.27470;
        p.195 = p;
        ji->data.name = p.195;
        p.195 = p;
        D.27471 = len + 1;
        p.197 = p.195 + D.27471;
        p = p.197;
        goto <D.23537>;
      }
      <D.23541>:
      p.195 = p;
      D.27473 = decode_resolve_method_ref (aot_module, p.195, &p);
      ji->data.method = D.27473;
      D.27463 = ji->data.method;
      if (D.27463 == 0B) goto cleanup; else goto <D.27474>;
      <D.27474>:
      goto <D.23537>;
      <D.23542>:
      <D.23543>:
      <D.23544>:
      <D.23545>:
      p.195 = p;
      D.27475 = decode_klass_ref (aot_module, p.195, &p);
      ji->data.klass = D.27475;
      D.27476 = ji->data.klass;
      if (D.27476 == 0B) goto cleanup; else goto <D.27477>;
      <D.27477>:
      goto <D.23537>;
      <D.23546>:
      <D.23547>:
      p.195 = p;
      D.27478 = decode_klass_ref (aot_module, p.195, &p);
      ji->data.klass = D.27478;
      D.27476 = ji->data.klass;
      if (D.27476 == 0B) goto cleanup; else goto <D.27479>;
      <D.27479>:
      goto <D.23537>;
      <D.23548>:
      p.195 = p;
      D.27480 = decode_value (p.195, &p);
      D.27481 = load_image (aot_module, D.27480, 1);
      ji->data.image = D.27481;
      D.27482 = ji->data.image;
      if (D.27482 == 0B) goto cleanup; else goto <D.27483>;
      <D.27483>:
      goto <D.23537>;
      <D.23549>:
      <D.23550>:
      p.195 = p;
      D.27484 = decode_field_info (aot_module, p.195, &p);
      ji->data.field = D.27484;
      D.27485 = ji->data.field;
      if (D.27485 == 0B) goto cleanup; else goto <D.27486>;
      <D.27486>:
      goto <D.23537>;
      <D.23551>:
      D.27487 = mono_mempool_alloc0 (mp, 8);
      ji->data.table = D.27487;
      D.27488 = ji->data.table;
      p.195 = p;
      D.27489 = decode_value (p.195, &p);
      D.27488->table_size = D.27489;
      D.27490 = mono_domain_get ();
      D.27488 = ji->data.table;
      D.27491 = D.27488->table_size;
      D.27492 = (unsigned int) D.27491;
      D.27493 = D.27492 * 4;
      table = mono_domain_alloc (D.27490, D.27493);
      D.27488 = ji->data.table;
      D.27488->table = table;
      i = 0;
      goto <D.23553>;
      <D.23552>:
      i.198 = (unsigned int) i;
      D.27495 = i.198 * 4;
      D.27496 = table + D.27495;
      p.195 = p;
      D.27497 = decode_value (p.195, &p);
      D.27498 = (void *) D.27497;
      *D.27496 = D.27498;
      i = i + 1;
      <D.23553>:
      D.27488 = ji->data.table;
      D.27491 = D.27488->table_size;
      if (D.27491 > i) goto <D.23552>; else goto <D.23554>;
      <D.23554>:
      goto <D.23537>;
      <D.23555>:
      {
        guint32 val;

        try
          {
            D.27499 = mono_domain_get ();
            D.27500 = mono_domain_alloc0 (D.27499, 4);
            ji->data.target = D.27500;
            p.195 = p;
            D.27501 = decode_value (p.195, &p);
            val.199 = (unsigned int) D.27501;
            val = val.199;
            D.27503 = ji->data.target;
            val.200 = &val;
            D.27505 = MEM[(float *)val.200];
            MEM[(float *)D.27503] = D.27505;
            goto <D.23537>;
          }
        finally
          {
            val = {CLOBBER};
          }
      }
      <D.23557>:
      {
        guint32 val[2];
        guint64 v;

        try
          {
            D.27506 = mono_domain_get ();
            D.27507 = mono_domain_alloc0 (D.27506, 8);
            ji->data.target = D.27507;
            p.195 = p;
            D.27508 = decode_value (p.195, &p);
            D.27509 = (unsigned int) D.27508;
            val[0] = D.27509;
            p.195 = p;
            D.27510 = decode_value (p.195, &p);
            D.27511 = (unsigned int) D.27510;
            val[1] = D.27511;
            D.27512 = val[1];
            D.27513 = (long long unsigned int) D.27512;
            D.27514 = D.27513 << 32;
            D.27515 = val[0];
            D.27516 = (long long unsigned int) D.27515;
            v.201 = D.27514 | D.27516;
            v = v.201;
            D.27503 = ji->data.target;
            v.202 = &v;
            D.27519 = MEM[(double *)v.202];
            MEM[(double *)D.27503] = D.27519;
            goto <D.23537>;
          }
        finally
          {
            val = {CLOBBER};
            v = {CLOBBER};
          }
      }
      <D.23560>:
      p.195 = p;
      D.27520 = decode_value (p.195, &p);
      image = load_image (aot_module, D.27520, 1);
      if (image == 0B) goto cleanup; else goto <D.27521>;
      <D.27521>:
      p.195 = p;
      D.27522 = decode_value (p.195, &p);
      D.27523 = D.27522 + 1879048192;
      D.27524 = (unsigned int) D.27523;
      D.27525 = mono_jump_info_token_new (mp, image, D.27524);
      ji->data.token = D.27525;
      goto <D.23537>;
      <D.23561>:
      <D.23562>:
      <D.23563>:
      <D.23564>:
      p.195 = p;
      D.27526 = decode_value (p.195, &p);
      image = load_image (aot_module, D.27526, 1);
      if (image == 0B) goto cleanup; else goto <D.27527>;
      <D.27527>:
      p.195 = p;
      D.27528 = decode_value (p.195, &p);
      D.27529 = (unsigned int) D.27528;
      D.27530 = mono_jump_info_token_new (mp, image, D.27529);
      ji->data.token = D.27530;
      D.27531 = ji->data.token;
      p.195 = p;
      D.27532 = decode_value (p.195, &p);
      D.27531->has_context = D.27532;
      D.27531 = ji->data.token;
      D.27533 = D.27531->has_context;
      if (D.27533 != 0) goto <D.27534>; else goto <D.27535>;
      <D.27534>:
      {
        gboolean res;

        D.27531 = ji->data.token;
        D.27536 = &D.27531->context;
        p.195 = p;
        res = decode_generic_context (aot_module, D.27536, p.195, &p);
        if (res == 0) goto cleanup; else goto <D.27537>;
        <D.27537>:
      }
      <D.27535>:
      goto <D.23537>;
      <D.23566>:
      p.195 = p;
      D.27538 = decode_klass_ref (aot_module, p.195, &p);
      ji->data.klass = D.27538;
      D.27476 = ji->data.klass;
      if (D.27476 == 0B) goto cleanup; else goto <D.27539>;
      <D.27539>:
      D.27476 = ji->data.klass;
      D.27540 = D.27476->name;
      ji->data.name = D.27540;
      goto <D.23537>;
      <D.23567>:
      p.195 = p;
      D.27541 = decode_value (p.195, &p);
      ji->data.offset = D.27541;
      goto <D.23537>;
      <D.23568>:
      <D.23569>:
      <D.23570>:
      <D.23571>:
      <D.23572>:
      <D.23573>:
      <D.23574>:
      goto <D.23537>;
      <D.23575>:
      {
        gboolean res;
        struct MonoJumpInfoRgctxEntry * entry;
        guint32 offset;
        guint32 val;
        guint8 * p2;

        try
          {
            p.195 = p;
            D.27542 = decode_value (p.195, &p);
            offset = (guint32) D.27542;
            p.195 = p;
            D.27543 = decode_value (p.195, &p);
            val = (guint32) D.27543;
            entry = mono_mempool_alloc0 (mp, 16);
            D.27544 = aot_module->blob;
            p2.203 = D.27544 + offset;
            p2 = p2.203;
            p2.204 = p2;
            D.27547 = decode_resolve_method_ref (aot_module, p2.204, &p2);
            entry->method = D.27547;
            D.27548 = val & 1;
            D.27549 = D.27548 != 0;
            D.27550 = (int) D.27549;
            entry->in_mrgctx = D.27550;
            D.27551 = val >> 1;
            D.27552 = D.27551 & 255;
            entry->info_type = D.27552;
            D.27553 = mono_mempool_alloc0 (mp, 20);
            entry->data = D.27553;
            D.27554 = entry->data;
            D.27555 = val >> 9;
            D.27556 = D.27555 & 255;
            D.27554->type = D.27556;
            D.27554 = entry->data;
            p.195 = p;
            res = decode_patch (aot_module, mp, D.27554, p.195, &p);
            if (res == 0) goto cleanup; else goto <D.27557>;
            <D.27557>:
            ji->data.rgctx_entry = entry;
            goto <D.23537>;
          }
        finally
          {
            p2 = {CLOBBER};
          }
      }
      <D.23581>:
      goto <D.23537>;
      <D.23582>:
      {
        struct MonoJumpInfoImtTramp * imt_tramp;

        imt_tramp = mono_mempool_alloc0 (mp, 8);
        p.195 = p;
        D.27558 = decode_resolve_method_ref (aot_module, p.195, &p);
        imt_tramp->method = D.27558;
        p.195 = p;
        D.27559 = decode_value (p.195, &p);
        imt_tramp->vt_offset = D.27559;
        ji->data.imt_tramp = imt_tramp;
        goto <D.23537>;
      }
      <D.23584>:
      p.195 = p;
      D.27560 = decode_signature (aot_module, p.195, &p);
      ji->data.target = D.27560;
      goto <D.23537>;
      <D.23585>:
      p.195 = p;
      D.27561 = decode_value (p.195, &p);
      D.27562 = (const void *) D.27561;
      ji->data.target = D.27562;
      goto <D.23537>;
      <D.23586>:
      {
        struct MonoJumpInfoGSharedVtCall * info;

        info = monoeg_malloc0 (8);
        p.195 = p;
        D.27563 = decode_signature (aot_module, p.195, &p);
        info->sig = D.27563;
        D.27564 = info->sig;
        D.27565 = D.27564 == 0B;
        D.27566 = (long int) D.27565;
        D.27567 = __builtin_expect (D.27566, 0);
        if (D.27567 != 0) goto <D.27568>; else goto <D.27569>;
        <D.27568>:
        monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "aot-runtime.c", 3126, "info->sig");
        <D.27569>:
        p.195 = p;
        D.27570 = decode_resolve_method_ref (aot_module, p.195, &p);
        info->method = D.27570;
        D.27571 = info->method;
        D.27572 = D.27571 == 0B;
        D.27573 = (long int) D.27572;
        D.27574 = __builtin_expect (D.27573, 0);
        if (D.27574 != 0) goto <D.27575>; else goto <D.27576>;
        <D.27575>:
        monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "aot-runtime.c", 3128, "info->method");
        <D.27576>:
        ji->data.target = info;
        goto <D.23537>;
      }
      <D.23588>:
      {
        struct MonoGSharedVtMethodInfo * info;
        int i;
        int nentries;

        info = monoeg_malloc0 (8);
        p.195 = p;
        D.27577 = decode_resolve_method_ref (aot_module, p.195, &p);
        info->method = D.27577;
        D.27578 = info->method;
        D.27579 = D.27578 == 0B;
        D.27580 = (long int) D.27579;
        D.27581 = __builtin_expect (D.27580, 0);
        if (D.27581 != 0) goto <D.27582>; else goto <D.27583>;
        <D.27582>:
        monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "aot-runtime.c", 3138, "info->method");
        <D.27583>:
        p.195 = p;
        nentries = decode_value (p.195, &p);
        D.27584 = monoeg_g_ptr_array_new ();
        info->entries = D.27584;
        i = 0;
        goto <D.23599>;
        <D.23598>:
        {
          struct MonoRuntimeGenericContextInfoTemplate * template;

          template = monoeg_malloc0 (12);
          p.195 = p;
          D.27585 = decode_value (p.195, &p);
          D.27586 = (<unnamed type>) D.27585;
          template->info_type = D.27586;
          D.27587 = template->info_type;
          D.27588 = mini_rgctx_info_type_to_patch_info_type (D.27587);
          switch (D.27588) <default: <D.23597>, case 11: <D.23593>, case 13: <D.23596>>
          <D.23593>:
          {
            struct MonoClass * klass;

            p.195 = p;
            klass = decode_klass_ref (aot_module, p.195, &p);
            if (klass == 0B) goto cleanup; else goto <D.27589>;
            <D.27589>:
            D.27590 = &klass->byval_arg;
            template->data = D.27590;
            goto <D.23595>;
          }
          <D.23596>:
          p.195 = p;
          D.27591 = decode_field_info (aot_module, p.195, &p);
          template->data = D.27591;
          D.27592 = template->data;
          if (D.27592 == 0B) goto cleanup; else goto <D.27593>;
          <D.27593>:
          goto <D.23595>;
          <D.23597>:
          monoeg_assertion_message ("* Assertion: should not be reached at %s:%d\n", "aot-runtime.c", 3159);
          <D.23595>:
          D.27594 = info->entries;
          monoeg_g_ptr_array_add (D.27594, template);
        }
        i = i + 1;
        <D.23599>:
        if (i < nentries) goto <D.23598>; else goto <D.23600>;
        <D.23600>:
        ji->data.target = info;
        goto <D.23537>;
      }
      <D.23601>:
      D.27440 = ji->type;
      monoeg_g_log (0B, 16, "unhandled type %d", D.27440);
      monoeg_assertion_message ("* Assertion: should not be reached at %s:%d\n", "aot-runtime.c", 3170);
      <D.23537>:
      p.195 = p;
      *endbuf = p.195;
      D.27595 = 1;
      return D.27595;
      cleanup:
      D.27595 = 0;
      return D.27595;
    }
  finally
    {
      p = {CLOBBER};
    }
}


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

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


decode_field_info (struct MonoAotModule * module, guint8 * buf, guint8 * * endbuf)
{
  guint8 * buf.205;
  struct MonoClassField * D.27610;
  guint8 * p.206;
  int D.27612;
  int D.27613;
  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.27608>; else goto <D.27609>;
      <D.27608>:
      D.27610 = 0B;
      return D.27610;
      <D.27609>:
      p.206 = p;
      D.27612 = decode_value (p.206, &p);
      D.27613 = D.27612 + 67108864;
      token = (guint32) D.27613;
      p.206 = p;
      *endbuf = p.206;
      D.27610 = mono_class_get_field (klass, token);
      return D.27610;
    }
  finally
    {
      p = {CLOBBER};
    }
}


register_jump_target_got_slot (struct MonoDomain * domain, struct MonoMethod * method, void * * got_slot)
{
  union mono_mutex_t * D.27616;
  _Bool D.27619;
  long int D.27620;
  long int D.27621;
  struct GHashTable * D.27624;
  struct GHashTable * D.27627;
  _Bool D.27630;
  long int D.27631;
  long int D.27632;
  struct MonoJitDomainInfo * info;
  struct GSList * list;

  info = domain->runtime_info;
  {
    int ret;

    D.27616 = &domain->lock.mutex;
    ret = pthread_mutex_lock (D.27616);
    if (ret != 0) goto <D.27617>; else goto <D.27618>;
    <D.27617>:
    monoeg_g_log (0B, 16, "Bad call to mono_mutex_lock result %d", ret);
    <D.27618>:
    D.27619 = ret != 0;
    D.27620 = (long int) D.27619;
    D.27621 = __builtin_expect (D.27620, 0);
    if (D.27621 != 0) goto <D.27622>; else goto <D.27623>;
    <D.27622>:
    monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "aot-runtime.c", 3242, "ret == 0");
    <D.27623>:
  }
  D.27624 = info->jump_target_got_slot_hash;
  if (D.27624 == 0B) goto <D.27625>; else goto <D.27626>;
  <D.27625>:
  D.27627 = monoeg_g_hash_table_new (0B, 0B);
  info->jump_target_got_slot_hash = D.27627;
  <D.27626>:
  D.27624 = info->jump_target_got_slot_hash;
  list = monoeg_g_hash_table_lookup (D.27624, method);
  list = monoeg_g_slist_prepend (list, got_slot);
  D.27624 = info->jump_target_got_slot_hash;
  monoeg_g_hash_table_insert_replace (D.27624, method, list, 0);
  {
    int ret;

    D.27616 = &domain->lock.mutex;
    ret = pthread_mutex_unlock (D.27616);
    if (ret != 0) goto <D.27628>; else goto <D.27629>;
    <D.27628>:
    monoeg_g_log (0B, 16, "Bad call to mono_mutex_unlock result %d", ret);
    <D.27629>:
    D.27630 = ret != 0;
    D.27631 = (long int) D.27630;
    D.27632 = __builtin_expect (D.27631, 0);
    if (D.27632 != 0) goto <D.27633>; else goto <D.27634>;
    <D.27633>:
    monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "aot-runtime.c", 3248, "ret == 0");
    <D.27634>:
  }
}


InterlockedIncrement (volatile gint32 * val)
{
  gint32 D.27635;
  unsigned int D.27636;

  D.27636 = __sync_add_and_fetch_4 (val, 1);
  D.27635 = (gint32) D.27636;
  return D.27635;
}


init_plt (struct MonoAotModule * amodule)
{
  int D.27638;
  struct MonoDomain * D.27641;
  struct MonoDomain * D.27642;
  void * * D.27643;
  unsigned int D.27644;
  unsigned int i.207;
  unsigned int D.27646;
  unsigned int D.27647;
  void * * D.27648;
  unsigned int D.27649;
  int i;
  void * tramp;

  D.27638 = amodule->plt_inited;
  if (D.27638 != 0) goto <D.27639>; else goto <D.27640>;
  <D.27639>:
  return;
  <D.27640>:
  D.27641 = mono_get_root_domain ();
  tramp = mono_create_specific_trampoline (amodule, 6, D.27641, 0B);
  D.27642 = mono_domain_get ();
  tramp = mono_create_ftnptr (D.27642, tramp);
  i = 1;
  goto <D.23904>;
  <D.23903>:
  D.27643 = amodule->got;
  D.27644 = amodule->info.plt_got_offset_base;
  i.207 = (unsigned int) i;
  D.27646 = D.27644 + i.207;
  D.27647 = D.27646 * 4;
  D.27648 = D.27643 + D.27647;
  *D.27648 = tramp;
  i = i + 1;
  <D.23904>:
  i.207 = (unsigned int) i;
  D.27649 = amodule->info.plt_size;
  if (i.207 < D.27649) goto <D.23903>; else goto <D.23905>;
  <D.23905>:
  amodule->plt_inited = 1;
}


mono_aot_get_method_from_token (struct MonoDomain * domain, struct MonoImage * image, guint32 token)
{
  void * D.27653;
  unsigned int D.27654;
  unsigned int D.27655;
  struct MonoAotModule * aot_module;
  int method_index;

  aot_module = image->aot_module;
  if (aot_module == 0B) goto <D.27651>; else goto <D.27652>;
  <D.27651>:
  D.27653 = 0B;
  return D.27653;
  <D.27652>:
  D.27654 = token & 16777215;
  D.27655 = D.27654 + 4294967295;
  method_index = (int) D.27655;
  D.27653 = load_method (domain, aot_module, image, 0B, token, method_index);
  return D.27653;
}


mono_aot_is_got_entry (guint8 * code, guint8 * addr)
{
  struct GHashTable * aot_modules.208;
  gboolean D.27660;
  _Bool D.27663;
  long int D.27664;
  long int D.27665;
  _Bool D.27670;
  long int D.27671;
  long int D.27672;
  struct IsGotEntryUserData user_data;

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

        ret = pthread_mutex_lock (&aot_mutex.mutex);
        if (ret != 0) goto <D.27661>; else goto <D.27662>;
        <D.27661>:
        monoeg_g_log (0B, 16, "Bad call to mono_mutex_lock result %d", ret);
        <D.27662>:
        D.27663 = ret != 0;
        D.27664 = (long int) D.27663;
        D.27665 = __builtin_expect (D.27664, 0);
        if (D.27665 != 0) goto <D.27666>; else goto <D.27667>;
        <D.27666>:
        monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "aot-runtime.c", 3812, "ret == 0");
        <D.27667>:
      }
      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.27668>; else goto <D.27669>;
        <D.27668>:
        monoeg_g_log (0B, 16, "Bad call to mono_mutex_unlock result %d", ret);
        <D.27669>:
        D.27670 = ret != 0;
        D.27671 = (long int) D.27670;
        D.27672 = __builtin_expect (D.27671, 0);
        if (D.27672 != 0) goto <D.27673>; else goto <D.27674>;
        <D.27673>:
        monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "aot-runtime.c", 3814, "ret == 0");
        <D.27674>:
      }
      D.27660 = user_data.res;
      return D.27660;
    }
  finally
    {
      user_data = {CLOBBER};
    }
}


check_is_got_entry (void * key, void * value, void * user_data)
{
  void * * D.27677;
  guint8 * D.27680;
  unsigned int D.27683;
  unsigned int D.27684;
  guint8 * D.27685;
  struct IsGotEntryUserData * data;
  struct MonoAotModule * aot_module;

  data = user_data;
  aot_module = value;
  D.27677 = aot_module->got;
  if (D.27677 != 0B) goto <D.27678>; else goto <D.27679>;
  <D.27678>:
  D.27680 = data->addr;
  D.27677 = aot_module->got;
  if (D.27680 >= D.27677) goto <D.27681>; else goto <D.27682>;
  <D.27681>:
  D.27680 = data->addr;
  D.27677 = aot_module->got;
  D.27683 = aot_module->info.got_size;
  D.27684 = D.27683 * 4;
  D.27685 = D.27677 + D.27684;
  if (D.27680 < D.27685) goto <D.27686>; else goto <D.27687>;
  <D.27686>:
  data->res = 1;
  <D.27687>:
  <D.27682>:
  <D.27679>:
}


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

  D.27688 = mono_domain_get ();
  D.27689 = mono_get_root_domain ();
  if (D.27688 == D.27689) goto <D.27690>; else goto <D.27691>;
  <D.27690>:
  mono_arch_patch_plt_entry (code, got, regs, addr);
  <D.27691>:
}


mono_aot_plt_resolve (void * aot_module, guint32 plt_info_offset, guint8 * code)
{
  void * D.27692;

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


mono_aot_get_plt_entry (guint8 * code)
{
  guint8 * D.27696;
  guint8 * D.27698;
  guint8 * D.27700;
  struct MonoAotModule * amodule;
  guint8 * target;

  amodule = find_aot_module (code);
  target = 0B;
  if (amodule == 0B) goto <D.27694>; else goto <D.27695>;
  <D.27694>:
  D.27696 = 0B;
  return D.27696;
  <D.27695>:
  monoeg_assertion_message ("* Assertion: should not be reached at %s:%d\n", "aot-runtime.c", 4007);
  D.27698 = amodule->plt;
  if (D.27698 <= target) goto <D.27699>; else goto <D.27697>;
  <D.27699>:
  D.27700 = amodule->plt_end;
  if (D.27700 > target) goto <D.27701>; else goto <D.27697>;
  <D.27701>:
  D.27696 = target;
  return D.27696;
  <D.27697>:
  D.27696 = 0B;
  return D.27696;
}


find_aot_module (guint8 * code)
{
  struct GHashTable * aot_modules.209;
  struct MonoAotModule * D.27706;
  unsigned int code.210;
  unsigned int aot_code_low_addr.211;
  unsigned int aot_code_high_addr.212;
  _Bool D.27715;
  long int D.27716;
  long int D.27717;
  _Bool D.27722;
  long int D.27723;
  long int D.27724;
  struct FindAotModuleUserData user_data;

  try
    {
      aot_modules.209 = aot_modules;
      if (aot_modules.209 == 0B) goto <D.27704>; else goto <D.27705>;
      <D.27704>:
      D.27706 = 0B;
      return D.27706;
      <D.27705>:
      code.210 = (unsigned int) code;
      aot_code_low_addr.211 = aot_code_low_addr;
      if (code.210 < aot_code_low_addr.211) goto <D.27707>; else goto <D.27711>;
      <D.27711>:
      code.210 = (unsigned int) code;
      aot_code_high_addr.212 = aot_code_high_addr;
      if (code.210 > aot_code_high_addr.212) goto <D.27707>; else goto <D.27708>;
      <D.27707>:
      D.27706 = 0B;
      return D.27706;
      <D.27708>:
      user_data.addr = code;
      user_data.module = 0B;
      {
        int ret;

        ret = pthread_mutex_lock (&aot_mutex.mutex);
        if (ret != 0) goto <D.27713>; else goto <D.27714>;
        <D.27713>:
        monoeg_g_log (0B, 16, "Bad call to mono_mutex_lock result %d", ret);
        <D.27714>:
        D.27715 = ret != 0;
        D.27716 = (long int) D.27715;
        D.27717 = __builtin_expect (D.27716, 0);
        if (D.27717 != 0) goto <D.27718>; else goto <D.27719>;
        <D.27718>:
        monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "aot-runtime.c", 3849, "ret == 0");
        <D.27719>:
      }
      aot_modules.209 = aot_modules;
      monoeg_g_hash_table_foreach (aot_modules.209, find_aot_module_cb, &user_data);
      {
        int ret;

        ret = pthread_mutex_unlock (&aot_mutex.mutex);
        if (ret != 0) goto <D.27720>; else goto <D.27721>;
        <D.27720>:
        monoeg_g_log (0B, 16, "Bad call to mono_mutex_unlock result %d", ret);
        <D.27721>:
        D.27722 = ret != 0;
        D.27723 = (long int) D.27722;
        D.27724 = __builtin_expect (D.27723, 0);
        if (D.27724 != 0) goto <D.27725>; else goto <D.27726>;
        <D.27725>:
        monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "aot-runtime.c", 3851, "ret == 0");
        <D.27726>:
      }
      D.27706 = user_data.module;
      return D.27706;
    }
  finally
    {
      user_data = {CLOBBER};
    }
}


find_aot_module_cb (void * key, void * value, void * user_data)
{
  guint8 * D.27729;
  guint8 * D.27730;
  guint8 * D.27733;
  struct FindAotModuleUserData * data;
  struct MonoAotModule * aot_module;

  data = user_data;
  aot_module = value;
  D.27729 = data->addr;
  D.27730 = aot_module->code;
  if (D.27729 >= D.27730) goto <D.27731>; else goto <D.27732>;
  <D.27731>:
  D.27729 = data->addr;
  D.27733 = aot_module->code_end;
  if (D.27729 < D.27733) goto <D.27734>; else goto <D.27735>;
  <D.27734>:
  data->module = aot_module;
  <D.27735>:
  <D.27732>:
}


mono_aot_get_plt_info_offset (mgreg_t * regs, guint8 * code)
{
  _Bool D.27736;
  long int D.27737;
  long int D.27738;
  guint32 D.27741;
  guint8 * plt_entry;

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


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

  aot_jit_icall_hash.213 = aot_jit_icall_hash;
  if (aot_jit_icall_hash.213 == 0B) goto <D.27744>; else goto <D.27745>;
  <D.27744>:
  aot_jit_icall_hash.214 = monoeg_g_hash_table_new (monoeg_g_str_hash, monoeg_g_str_equal);
  aot_jit_icall_hash = aot_jit_icall_hash.214;
  <D.27745>:
  aot_jit_icall_hash.213 = aot_jit_icall_hash;
  monoeg_g_hash_table_insert_replace (aot_jit_icall_hash.213, name, addr, 0);
}


mono_aot_get_trampoline_full (const char * name, struct MonoTrampInfo * * out_tinfo)
{
  _Bool D.27747;
  long int D.27748;
  long int D.27749;
  _Bool D.27752;
  long int D.27753;
  long int D.27754;
  void * D.27757;
  void * D.27758;
  struct MonoImage * image;
  struct MonoAotModule * amodule;

  image = mono_defaults.corlib;
  D.27747 = image == 0B;
  D.27748 = (long int) D.27747;
  D.27749 = __builtin_expect (D.27748, 0);
  if (D.27749 != 0) goto <D.27750>; else goto <D.27751>;
  <D.27750>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "aot-runtime.c", 4242, "image");
  <D.27751>:
  amodule = image->aot_module;
  D.27752 = amodule == 0B;
  D.27753 = (long int) D.27752;
  D.27754 = __builtin_expect (D.27753, 0);
  if (D.27754 != 0) goto <D.27755>; else goto <D.27756>;
  <D.27755>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "aot-runtime.c", 4245, "amodule");
  <D.27756>:
  D.27758 = load_function_full (amodule, name, out_tinfo);
  D.27757 = mono_create_ftnptr_malloc (D.27758);
  return D.27757;
}


load_function_full (struct MonoAotModule * amodule, const char * name, struct MonoTrampInfo * * out_tinfo)
{
  struct MonoDl * D.27760;
  void * * D.27761;
  void * code.215;
  char * D.27765;
  guint8 * p.216;
  void * D.27769;
  guint8 * p.217;
  guint8 * D.27773;
  guint8 * uw_info.218;
  guint8 * uw_info.219;
  int D.27776;
  guint8 * D.27777;
  guint8 * p.220;
  _Bool D.27781;
  long int D.27782;
  long int D.27783;
  unsigned int pindex.221;
  unsigned int D.27787;
  void * * D.27788;
  guint32 * got_slots.222;
  unsigned int D.27790;
  guint32 * D.27791;
  unsigned int D.27792;
  unsigned int D.27793;
  void * * D.27794;
  void * D.27795;
  <unnamed type> D.27798;
  int D.23954;
  int iftmp.223;
  int D.23953;
  const char[18] * D.27804;
  unsigned char D.27805;
  int D.27806;
  unsigned char D.27807;
  int D.27808;
  const unsigned char * D.27813;
  unsigned char D.27814;
  int D.27815;
  const unsigned char * D.27816;
  unsigned char D.27817;
  int D.27818;
  const unsigned char * D.27823;
  unsigned char D.27824;
  int D.27825;
  const unsigned char * D.27826;
  unsigned char D.27827;
  int D.27828;
  const unsigned char * D.27833;
  unsigned char D.27834;
  int D.27835;
  const unsigned char * D.27836;
  unsigned char D.27837;
  int D.27838;
  const char * D.27840;
  int D.23963;
  int iftmp.224;
  int D.23962;
  const char[42] * D.27847;
  unsigned char D.27848;
  int D.27849;
  unsigned char D.27850;
  int D.27851;
  const unsigned char * D.27856;
  unsigned char D.27857;
  int D.27858;
  const unsigned char * D.27859;
  unsigned char D.27860;
  int D.27861;
  const unsigned char * D.27866;
  unsigned char D.27867;
  int D.27868;
  const unsigned char * D.27869;
  unsigned char D.27870;
  int D.27871;
  const unsigned char * D.27876;
  unsigned char D.27877;
  int D.27878;
  const unsigned char * D.27879;
  unsigned char D.27880;
  int D.27881;
  int D.23972;
  int iftmp.225;
  int D.23971;
  const char[26] * D.27889;
  unsigned char D.27890;
  int D.27891;
  unsigned char D.27892;
  int D.27893;
  const unsigned char * D.27898;
  unsigned char D.27899;
  int D.27900;
  const unsigned char * D.27901;
  unsigned char D.27902;
  int D.27903;
  const unsigned char * D.27908;
  unsigned char D.27909;
  int D.27910;
  const unsigned char * D.27911;
  unsigned char D.27912;
  int D.27913;
  const unsigned char * D.27918;
  unsigned char D.27919;
  int D.27920;
  const unsigned char * D.27921;
  unsigned char D.27922;
  int D.27923;
  int D.23981;
  int iftmp.226;
  int D.23980;
  const char[21] * D.27931;
  unsigned char D.27932;
  int D.27933;
  unsigned char D.27934;
  int D.27935;
  const unsigned char * D.27940;
  unsigned char D.27941;
  int D.27942;
  const unsigned char * D.27943;
  unsigned char D.27944;
  int D.27945;
  const unsigned char * D.27950;
  unsigned char D.27951;
  int D.27952;
  const unsigned char * D.27953;
  unsigned char D.27954;
  int D.27955;
  const unsigned char * D.27960;
  unsigned char D.27961;
  int D.27962;
  const unsigned char * D.27963;
  unsigned char D.27964;
  int D.27965;
  char * D.27970;
  const char * D.27973;
  <unnamed type> tramp_type2.227;
  char * D.27976;
  _Bool D.27979;
  long int D.27980;
  long int D.27981;
  unsigned int slot.228;
  void * slot.229;
  struct MonoDomain * D.27986;
  int D.23993;
  int iftmp.230;
  int D.23992;
  const char[34] * D.27991;
  unsigned char D.27992;
  int D.27993;
  unsigned char D.27994;
  int D.27995;
  const unsigned char * D.28000;
  unsigned char D.28001;
  int D.28002;
  const unsigned char * D.28003;
  unsigned char D.28004;
  int D.28005;
  const unsigned char * D.28010;
  unsigned char D.28011;
  int D.28012;
  const unsigned char * D.28013;
  unsigned char D.28014;
  int D.28015;
  const unsigned char * D.28020;
  unsigned char D.28021;
  int D.28022;
  const unsigned char * D.28023;
  unsigned char D.28024;
  int D.28025;
  struct MonoDomain * D.28029;
  int D.24002;
  int iftmp.231;
  int D.24001;
  const char[33] * D.28034;
  unsigned char D.28035;
  int D.28036;
  unsigned char D.28037;
  int D.28038;
  const unsigned char * D.28043;
  unsigned char D.28044;
  int D.28045;
  const unsigned char * D.28046;
  unsigned char D.28047;
  int D.28048;
  const unsigned char * D.28053;
  unsigned char D.28054;
  int D.28055;
  const unsigned char * D.28056;
  unsigned char D.28057;
  int D.28058;
  const unsigned char * D.28063;
  unsigned char D.28064;
  int D.28065;
  const unsigned char * D.28066;
  unsigned char D.28067;
  int D.28068;
  struct MonoDomain * D.28072;
  int D.24011;
  int iftmp.232;
  int D.24010;
  const char[39] * D.28077;
  unsigned char D.28078;
  int D.28079;
  unsigned char D.28080;
  int D.28081;
  const unsigned char * D.28086;
  unsigned char D.28087;
  int D.28088;
  const unsigned char * D.28089;
  unsigned char D.28090;
  int D.28091;
  const unsigned char * D.28096;
  unsigned char D.28097;
  int D.28098;
  const unsigned char * D.28099;
  unsigned char D.28100;
  int D.28101;
  const unsigned char * D.28106;
  unsigned char D.28107;
  int D.28108;
  const unsigned char * D.28109;
  unsigned char D.28110;
  int D.28111;
  struct MonoDomain * D.28115;
  int D.24020;
  int iftmp.233;
  int D.24019;
  const char[44] * D.28120;
  unsigned char D.28121;
  int D.28122;
  unsigned char D.28123;
  int D.28124;
  const unsigned char * D.28129;
  unsigned char D.28130;
  int D.28131;
  const unsigned char * D.28132;
  unsigned char D.28133;
  int D.28134;
  const unsigned char * D.28139;
  unsigned char D.28140;
  int D.28141;
  const unsigned char * D.28142;
  unsigned char D.28143;
  int D.28144;
  const unsigned char * D.28149;
  unsigned char D.28150;
  int D.28151;
  const unsigned char * D.28152;
  unsigned char D.28153;
  int D.28154;
  char * D.28159;
  struct GHashTable * aot_jit_icall_hash.234;
  void * D.28167;
  struct _IO_FILE * stderr.235;
  _Bool D.28171;
  long int D.28172;
  long int D.28173;
  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.27760 = amodule->sofile;
      D.27761 = amodule->globals;
      find_symbol (D.27760, D.27761, symbol, &code);
      monoeg_g_free (symbol);
      code.215 = code;
      if (code.215 == 0B) goto <D.27763>; else goto <D.27764>;
      <D.27763>:
      D.27765 = amodule->aot_name;
      monoeg_g_log (0B, 4, "Symbol \'%s\' not found in AOT file \'%s\'.\n", name, D.27765);
      <D.23935>:
      goto <D.23935>;
      <D.27764>:
      D.27765 = amodule->aot_name;
      mono_trace (128, 32, "AOT FOUND function \'%s\' in AOT file \'%s\'.", name, D.27765);
      symbol = monoeg_g_strdup_printf ("%s_p", name);
      D.27760 = amodule->sofile;
      D.27761 = amodule->globals;
      find_symbol (D.27760, D.27761, symbol, &p);
      monoeg_g_free (symbol);
      p.216 = p;
      if (p.216 == 0B) goto <D.27767>; else goto <D.27768>;
      <D.27767>:
      D.27769 = code;
      return D.27769;
      <D.27768>:
      p.216 = p;
      info_offset = MEM[(guint32 *)p.216];
      if (out_tinfo != 0B) goto <D.27770>; else goto <D.27771>;
      <D.27770>:
      {
        struct MonoTrampInfo * tinfo;
        guint32 code_size;
        guint32 uw_info_len;
        guint32 uw_offset;
        guint8 * uw_info;

        try
          {
            p.216 = p;
            p.217 = p.216 + 4;
            p = p.217;
            p.216 = p;
            code_size = MEM[(guint32 *)p.216];
            p.216 = p;
            p.217 = p.216 + 4;
            p = p.217;
            p.216 = p;
            uw_offset = MEM[(guint32 *)p.216];
            D.27773 = amodule->unwind_info;
            uw_info.218 = D.27773 + uw_offset;
            uw_info = uw_info.218;
            uw_info.219 = uw_info;
            D.27776 = decode_value (uw_info.219, &uw_info);
            uw_info_len = (guint32) D.27776;
            tinfo = monoeg_malloc0 (28);
            code.215 = code;
            tinfo->code = code.215;
            tinfo->code_size = code_size;
            uw_info.219 = uw_info;
            tinfo->uw_info = uw_info.219;
            tinfo->uw_info_len = uw_info_len;
            *out_tinfo = tinfo;
          }
        finally
          {
            uw_info = {CLOBBER};
          }
      }
      <D.27771>:
      D.27777 = amodule->blob;
      p.220 = D.27777 + info_offset;
      p = p.220;
      p.216 = p;
      n_patches = decode_value (p.216, &p);
      if (n_patches != 0) goto <D.27779>; else goto <D.27780>;
      <D.27779>:
      {
        struct MonoJumpInfo * patches;
        guint32 * got_slots;

        try
          {
            mp = mono_mempool_new ();
            p.216 = p;
            patches = load_patch_info (amodule, mp, n_patches, &got_slots, p.216, &p);
            D.27781 = patches == 0B;
            D.27782 = (long int) D.27781;
            D.27783 = __builtin_expect (D.27782, 0);
            if (D.27783 != 0) goto <D.27784>; else goto <D.27785>;
            <D.27784>:
            monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "aot-runtime.c", 4151, "patches");
            <D.27785>:
            pindex = 0;
            goto <D.24022>;
            <D.24021>:
            {
              struct MonoJumpInfo * ji;
              void * target;

              pindex.221 = (unsigned int) pindex;
              D.27787 = pindex.221 * 20;
              ji = patches + D.27787;
              D.27788 = amodule->got;
              got_slots.222 = got_slots;
              pindex.221 = (unsigned int) pindex;
              D.27790 = pindex.221 * 4;
              D.27791 = got_slots.222 + D.27790;
              D.27792 = *D.27791;
              D.27793 = D.27792 * 4;
              D.27794 = D.27788 + D.27793;
              D.27795 = *D.27794;
              if (D.27795 != 0B) goto <D.27796>; else goto <D.27797>;
              <D.27796>:
              // predicted unlikely by continue predictor.
              goto <D.23945>;
              <D.27797>:
              D.27798 = ji->type;
              if (D.27798 == 32) goto <D.27799>; else goto <D.27800>;
              <D.27799>:
              {
                size_t __s1_len;
                size_t __s2_len;

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

                  __s2 = ji->data.name;
                  D.27804 = "mono_get_lmf_addr";
                  D.27805 = MEM[(const unsigned char *)D.27804];
                  D.27806 = (int) D.27805;
                  D.27807 = *__s2;
                  D.27808 = (int) D.27807;
                  __result = D.27806 - D.27808;
                  {
                    if (__s2_len != 0) goto <D.27809>; else goto <D.27810>;
                    <D.27809>:
                    if (__result == 0) goto <D.27811>; else goto <D.27812>;
                    <D.27811>:
                    D.27813 = &MEM[(void *)"mono_get_lmf_addr" + 1B];
                    D.27814 = *D.27813;
                    D.27815 = (int) D.27814;
                    D.27816 = __s2 + 1;
                    D.27817 = *D.27816;
                    D.27818 = (int) D.27817;
                    __result = D.27815 - D.27818;
                    if (__s2_len > 1) goto <D.27819>; else goto <D.27820>;
                    <D.27819>:
                    if (__result == 0) goto <D.27821>; else goto <D.27822>;
                    <D.27821>:
                    D.27823 = &MEM[(void *)"mono_get_lmf_addr" + 2B];
                    D.27824 = *D.27823;
                    D.27825 = (int) D.27824;
                    D.27826 = __s2 + 2;
                    D.27827 = *D.27826;
                    D.27828 = (int) D.27827;
                    __result = D.27825 - D.27828;
                    if (__s2_len > 2) goto <D.27829>; else goto <D.27830>;
                    <D.27829>:
                    if (__result == 0) goto <D.27831>; else goto <D.27832>;
                    <D.27831>:
                    D.27833 = &MEM[(void *)"mono_get_lmf_addr" + 3B];
                    D.27834 = *D.27833;
                    D.27835 = (int) D.27834;
                    D.27836 = __s2 + 3;
                    D.27837 = *D.27836;
                    D.27838 = (int) D.27837;
                    __result = D.27835 - D.27838;
                    <D.27832>:
                    <D.27830>:
                    <D.27822>:
                    <D.27820>:
                    <D.27812>:
                    <D.27810>:
                  }
                  D.23953 = __result;
                }
                iftmp.223 = -D.23953;
                goto <D.27839>;
                <D.27803>:
                D.27840 = ji->data.name;
                iftmp.223 = __builtin_strcmp (D.27840, "mono_get_lmf_addr");
                <D.27839>:
                D.23954 = iftmp.223;
              }
              if (D.23954 == 0) goto <D.27841>; else goto <D.27842>;
              <D.27841>:
              target = mono_get_lmf_addr;
              goto <D.27843>;
              <D.27842>:
              {
                size_t __s1_len;
                size_t __s2_len;

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

                  __s2 = ji->data.name;
                  D.27847 = "mono_thread_force_interruption_checkpoint";
                  D.27848 = MEM[(const unsigned char *)D.27847];
                  D.27849 = (int) D.27848;
                  D.27850 = *__s2;
                  D.27851 = (int) D.27850;
                  __result = D.27849 - D.27851;
                  {
                    if (__s2_len != 0) goto <D.27852>; else goto <D.27853>;
                    <D.27852>:
                    if (__result == 0) goto <D.27854>; else goto <D.27855>;
                    <D.27854>:
                    D.27856 = &MEM[(void *)"mono_thread_force_interruption_checkpoint" + 1B];
                    D.27857 = *D.27856;
                    D.27858 = (int) D.27857;
                    D.27859 = __s2 + 1;
                    D.27860 = *D.27859;
                    D.27861 = (int) D.27860;
                    __result = D.27858 - D.27861;
                    if (__s2_len > 1) goto <D.27862>; else goto <D.27863>;
                    <D.27862>:
                    if (__result == 0) goto <D.27864>; else goto <D.27865>;
                    <D.27864>:
                    D.27866 = &MEM[(void *)"mono_thread_force_interruption_checkpoint" + 2B];
                    D.27867 = *D.27866;
                    D.27868 = (int) D.27867;
                    D.27869 = __s2 + 2;
                    D.27870 = *D.27869;
                    D.27871 = (int) D.27870;
                    __result = D.27868 - D.27871;
                    if (__s2_len > 2) goto <D.27872>; else goto <D.27873>;
                    <D.27872>:
                    if (__result == 0) goto <D.27874>; else goto <D.27875>;
                    <D.27874>:
                    D.27876 = &MEM[(void *)"mono_thread_force_interruption_checkpoint" + 3B];
                    D.27877 = *D.27876;
                    D.27878 = (int) D.27877;
                    D.27879 = __s2 + 3;
                    D.27880 = *D.27879;
                    D.27881 = (int) D.27880;
                    __result = D.27878 - D.27881;
                    <D.27875>:
                    <D.27873>:
                    <D.27865>:
                    <D.27863>:
                    <D.27855>:
                    <D.27853>:
                  }
                  D.23962 = __result;
                }
                iftmp.224 = -D.23962;
                goto <D.27882>;
                <D.27846>:
                D.27840 = ji->data.name;
                iftmp.224 = __builtin_strcmp (D.27840, "mono_thread_force_interruption_checkpoint");
                <D.27882>:
                D.23963 = iftmp.224;
              }
              if (D.23963 == 0) goto <D.27883>; else goto <D.27884>;
              <D.27883>:
              target = mono_thread_force_interruption_checkpoint;
              goto <D.27885>;
              <D.27884>:
              {
                size_t __s1_len;
                size_t __s2_len;

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

                  __s2 = ji->data.name;
                  D.27889 = "mono_exception_from_token";
                  D.27890 = MEM[(const unsigned char *)D.27889];
                  D.27891 = (int) D.27890;
                  D.27892 = *__s2;
                  D.27893 = (int) D.27892;
                  __result = D.27891 - D.27893;
                  {
                    if (__s2_len != 0) goto <D.27894>; else goto <D.27895>;
                    <D.27894>:
                    if (__result == 0) goto <D.27896>; else goto <D.27897>;
                    <D.27896>:
                    D.27898 = &MEM[(void *)"mono_exception_from_token" + 1B];
                    D.27899 = *D.27898;
                    D.27900 = (int) D.27899;
                    D.27901 = __s2 + 1;
                    D.27902 = *D.27901;
                    D.27903 = (int) D.27902;
                    __result = D.27900 - D.27903;
                    if (__s2_len > 1) goto <D.27904>; else goto <D.27905>;
                    <D.27904>:
                    if (__result == 0) goto <D.27906>; else goto <D.27907>;
                    <D.27906>:
                    D.27908 = &MEM[(void *)"mono_exception_from_token" + 2B];
                    D.27909 = *D.27908;
                    D.27910 = (int) D.27909;
                    D.27911 = __s2 + 2;
                    D.27912 = *D.27911;
                    D.27913 = (int) D.27912;
                    __result = D.27910 - D.27913;
                    if (__s2_len > 2) goto <D.27914>; else goto <D.27915>;
                    <D.27914>:
                    if (__result == 0) goto <D.27916>; else goto <D.27917>;
                    <D.27916>:
                    D.27918 = &MEM[(void *)"mono_exception_from_token" + 3B];
                    D.27919 = *D.27918;
                    D.27920 = (int) D.27919;
                    D.27921 = __s2 + 3;
                    D.27922 = *D.27921;
                    D.27923 = (int) D.27922;
                    __result = D.27920 - D.27923;
                    <D.27917>:
                    <D.27915>:
                    <D.27907>:
                    <D.27905>:
                    <D.27897>:
                    <D.27895>:
                  }
                  D.23971 = __result;
                }
                iftmp.225 = -D.23971;
                goto <D.27924>;
                <D.27888>:
                D.27840 = ji->data.name;
                iftmp.225 = __builtin_strcmp (D.27840, "mono_exception_from_token");
                <D.27924>:
                D.23972 = iftmp.225;
              }
              if (D.23972 == 0) goto <D.27925>; else goto <D.27926>;
              <D.27925>:
              target = mono_exception_from_token;
              goto <D.27927>;
              <D.27926>:
              {
                size_t __s1_len;
                size_t __s2_len;

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

                  __s2 = ji->data.name;
                  D.27931 = "mono_throw_exception";
                  D.27932 = MEM[(const unsigned char *)D.27931];
                  D.27933 = (int) D.27932;
                  D.27934 = *__s2;
                  D.27935 = (int) D.27934;
                  __result = D.27933 - D.27935;
                  {
                    if (__s2_len != 0) goto <D.27936>; else goto <D.27937>;
                    <D.27936>:
                    if (__result == 0) goto <D.27938>; else goto <D.27939>;
                    <D.27938>:
                    D.27940 = &MEM[(void *)"mono_throw_exception" + 1B];
                    D.27941 = *D.27940;
                    D.27942 = (int) D.27941;
                    D.27943 = __s2 + 1;
                    D.27944 = *D.27943;
                    D.27945 = (int) D.27944;
                    __result = D.27942 - D.27945;
                    if (__s2_len > 1) goto <D.27946>; else goto <D.27947>;
                    <D.27946>:
                    if (__result == 0) goto <D.27948>; else goto <D.27949>;
                    <D.27948>:
                    D.27950 = &MEM[(void *)"mono_throw_exception" + 2B];
                    D.27951 = *D.27950;
                    D.27952 = (int) D.27951;
                    D.27953 = __s2 + 2;
                    D.27954 = *D.27953;
                    D.27955 = (int) D.27954;
                    __result = D.27952 - D.27955;
                    if (__s2_len > 2) goto <D.27956>; else goto <D.27957>;
                    <D.27956>:
                    if (__result == 0) goto <D.27958>; else goto <D.27959>;
                    <D.27958>:
                    D.27960 = &MEM[(void *)"mono_throw_exception" + 3B];
                    D.27961 = *D.27960;
                    D.27962 = (int) D.27961;
                    D.27963 = __s2 + 3;
                    D.27964 = *D.27963;
                    D.27965 = (int) D.27964;
                    __result = D.27962 - D.27965;
                    <D.27959>:
                    <D.27957>:
                    <D.27949>:
                    <D.27947>:
                    <D.27939>:
                    <D.27937>:
                  }
                  D.23980 = __result;
                }
                iftmp.226 = -D.23980;
                goto <D.27966>;
                <D.27930>:
                D.27840 = ji->data.name;
                iftmp.226 = __builtin_strcmp (D.27840, "mono_throw_exception");
                <D.27966>:
                D.23981 = iftmp.226;
              }
              if (D.23981 == 0) goto <D.27967>; else goto <D.27968>;
              <D.27967>:
              target = mono_get_throw_exception ();
              goto <D.27969>;
              <D.27968>:
              D.27840 = ji->data.name;
              D.27970 = strstr (D.27840, "trampoline_func_");
              D.27840 = ji->data.name;
              if (D.27970 == D.27840) goto <D.27971>; else goto <D.27972>;
              <D.27971>:
              {
                int tramp_type2;

                D.27840 = ji->data.name;
                D.27973 = D.27840 + 16;
                tramp_type2 = atoi (D.27973);
                tramp_type2.227 = (<unnamed type>) tramp_type2;
                target = mono_get_trampoline_func (tramp_type2.227);
              }
              goto <D.27975>;
              <D.27972>:
              D.27840 = ji->data.name;
              D.27976 = strstr (D.27840, "specific_trampoline_lazy_fetch_");
              D.27840 = ji->data.name;
              if (D.27976 == D.27840) goto <D.27977>; else goto <D.27978>;
              <D.27977>:
              {
                guint32 slot;
                int res;

                try
                  {
                    D.27840 = ji->data.name;
                    res = sscanf (D.27840, "specific_trampoline_lazy_fetch_%u", &slot);
                    D.27979 = res != 1;
                    D.27980 = (long int) D.27979;
                    D.27981 = __builtin_expect (D.27980, 0);
                    if (D.27981 != 0) goto <D.27982>; else goto <D.27983>;
                    <D.27982>:
                    monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "aot-runtime.c", 4182, "res == 1");
                    <D.27983>:
                    slot.228 = slot;
                    slot.229 = (void *) slot.228;
                    D.27986 = mono_get_root_domain ();
                    target = mono_create_specific_trampoline (slot.229, 4, D.27986, 0B);
                    target = mono_create_ftnptr_malloc (target);
                  }
                finally
                  {
                    slot = {CLOBBER};
                  }
              }
              goto <D.27987>;
              <D.27978>:
              {
                size_t __s1_len;
                size_t __s2_len;

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

                  __s2 = ji->data.name;
                  D.27991 = "specific_trampoline_monitor_enter";
                  D.27992 = MEM[(const unsigned char *)D.27991];
                  D.27993 = (int) D.27992;
                  D.27994 = *__s2;
                  D.27995 = (int) D.27994;
                  __result = D.27993 - D.27995;
                  {
                    if (__s2_len != 0) goto <D.27996>; else goto <D.27997>;
                    <D.27996>:
                    if (__result == 0) goto <D.27998>; else goto <D.27999>;
                    <D.27998>:
                    D.28000 = &MEM[(void *)"specific_trampoline_monitor_enter" + 1B];
                    D.28001 = *D.28000;
                    D.28002 = (int) D.28001;
                    D.28003 = __s2 + 1;
                    D.28004 = *D.28003;
                    D.28005 = (int) D.28004;
                    __result = D.28002 - D.28005;
                    if (__s2_len > 1) goto <D.28006>; else goto <D.28007>;
                    <D.28006>:
                    if (__result == 0) goto <D.28008>; else goto <D.28009>;
                    <D.28008>:
                    D.28010 = &MEM[(void *)"specific_trampoline_monitor_enter" + 2B];
                    D.28011 = *D.28010;
                    D.28012 = (int) D.28011;
                    D.28013 = __s2 + 2;
                    D.28014 = *D.28013;
                    D.28015 = (int) D.28014;
                    __result = D.28012 - D.28015;
                    if (__s2_len > 2) goto <D.28016>; else goto <D.28017>;
                    <D.28016>:
                    if (__result == 0) goto <D.28018>; else goto <D.28019>;
                    <D.28018>:
                    D.28020 = &MEM[(void *)"specific_trampoline_monitor_enter" + 3B];
                    D.28021 = *D.28020;
                    D.28022 = (int) D.28021;
                    D.28023 = __s2 + 3;
                    D.28024 = *D.28023;
                    D.28025 = (int) D.28024;
                    __result = D.28022 - D.28025;
                    <D.28019>:
                    <D.28017>:
                    <D.28009>:
                    <D.28007>:
                    <D.27999>:
                    <D.27997>:
                  }
                  D.23992 = __result;
                }
                iftmp.230 = -D.23992;
                goto <D.28026>;
                <D.27990>:
                D.27840 = ji->data.name;
                iftmp.230 = __builtin_strcmp (D.27840, "specific_trampoline_monitor_enter");
                <D.28026>:
                D.23993 = iftmp.230;
              }
              if (D.23993 == 0) goto <D.28027>; else goto <D.28028>;
              <D.28027>:
              D.28029 = mono_get_root_domain ();
              target = mono_create_specific_trampoline (0B, 10, D.28029, 0B);
              target = mono_create_ftnptr_malloc (target);
              goto <D.28030>;
              <D.28028>:
              {
                size_t __s1_len;
                size_t __s2_len;

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

                  __s2 = ji->data.name;
                  D.28034 = "specific_trampoline_monitor_exit";
                  D.28035 = MEM[(const unsigned char *)D.28034];
                  D.28036 = (int) D.28035;
                  D.28037 = *__s2;
                  D.28038 = (int) D.28037;
                  __result = D.28036 - D.28038;
                  {
                    if (__s2_len != 0) goto <D.28039>; else goto <D.28040>;
                    <D.28039>:
                    if (__result == 0) goto <D.28041>; else goto <D.28042>;
                    <D.28041>:
                    D.28043 = &MEM[(void *)"specific_trampoline_monitor_exit" + 1B];
                    D.28044 = *D.28043;
                    D.28045 = (int) D.28044;
                    D.28046 = __s2 + 1;
                    D.28047 = *D.28046;
                    D.28048 = (int) D.28047;
                    __result = D.28045 - D.28048;
                    if (__s2_len > 1) goto <D.28049>; else goto <D.28050>;
                    <D.28049>:
                    if (__result == 0) goto <D.28051>; else goto <D.28052>;
                    <D.28051>:
                    D.28053 = &MEM[(void *)"specific_trampoline_monitor_exit" + 2B];
                    D.28054 = *D.28053;
                    D.28055 = (int) D.28054;
                    D.28056 = __s2 + 2;
                    D.28057 = *D.28056;
                    D.28058 = (int) D.28057;
                    __result = D.28055 - D.28058;
                    if (__s2_len > 2) goto <D.28059>; else goto <D.28060>;
                    <D.28059>:
                    if (__result == 0) goto <D.28061>; else goto <D.28062>;
                    <D.28061>:
                    D.28063 = &MEM[(void *)"specific_trampoline_monitor_exit" + 3B];
                    D.28064 = *D.28063;
                    D.28065 = (int) D.28064;
                    D.28066 = __s2 + 3;
                    D.28067 = *D.28066;
                    D.28068 = (int) D.28067;
                    __result = D.28065 - D.28068;
                    <D.28062>:
                    <D.28060>:
                    <D.28052>:
                    <D.28050>:
                    <D.28042>:
                    <D.28040>:
                  }
                  D.24001 = __result;
                }
                iftmp.231 = -D.24001;
                goto <D.28069>;
                <D.28033>:
                D.27840 = ji->data.name;
                iftmp.231 = __builtin_strcmp (D.27840, "specific_trampoline_monitor_exit");
                <D.28069>:
                D.24002 = iftmp.231;
              }
              if (D.24002 == 0) goto <D.28070>; else goto <D.28071>;
              <D.28070>:
              D.28072 = mono_get_root_domain ();
              target = mono_create_specific_trampoline (0B, 11, D.28072, 0B);
              target = mono_create_ftnptr_malloc (target);
              goto <D.28073>;
              <D.28071>:
              {
                size_t __s1_len;
                size_t __s2_len;

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

                  __s2 = ji->data.name;
                  D.28077 = "specific_trampoline_generic_class_init";
                  D.28078 = MEM[(const unsigned char *)D.28077];
                  D.28079 = (int) D.28078;
                  D.28080 = *__s2;
                  D.28081 = (int) D.28080;
                  __result = D.28079 - D.28081;
                  {
                    if (__s2_len != 0) goto <D.28082>; else goto <D.28083>;
                    <D.28082>:
                    if (__result == 0) goto <D.28084>; else goto <D.28085>;
                    <D.28084>:
                    D.28086 = &MEM[(void *)"specific_trampoline_generic_class_init" + 1B];
                    D.28087 = *D.28086;
                    D.28088 = (int) D.28087;
                    D.28089 = __s2 + 1;
                    D.28090 = *D.28089;
                    D.28091 = (int) D.28090;
                    __result = D.28088 - D.28091;
                    if (__s2_len > 1) goto <D.28092>; else goto <D.28093>;
                    <D.28092>:
                    if (__result == 0) goto <D.28094>; else goto <D.28095>;
                    <D.28094>:
                    D.28096 = &MEM[(void *)"specific_trampoline_generic_class_init" + 2B];
                    D.28097 = *D.28096;
                    D.28098 = (int) D.28097;
                    D.28099 = __s2 + 2;
                    D.28100 = *D.28099;
                    D.28101 = (int) D.28100;
                    __result = D.28098 - D.28101;
                    if (__s2_len > 2) goto <D.28102>; else goto <D.28103>;
                    <D.28102>:
                    if (__result == 0) goto <D.28104>; else goto <D.28105>;
                    <D.28104>:
                    D.28106 = &MEM[(void *)"specific_trampoline_generic_class_init" + 3B];
                    D.28107 = *D.28106;
                    D.28108 = (int) D.28107;
                    D.28109 = __s2 + 3;
                    D.28110 = *D.28109;
                    D.28111 = (int) D.28110;
                    __result = D.28108 - D.28111;
                    <D.28105>:
                    <D.28103>:
                    <D.28095>:
                    <D.28093>:
                    <D.28085>:
                    <D.28083>:
                  }
                  D.24010 = __result;
                }
                iftmp.232 = -D.24010;
                goto <D.28112>;
                <D.28076>:
                D.27840 = ji->data.name;
                iftmp.232 = __builtin_strcmp (D.27840, "specific_trampoline_generic_class_init");
                <D.28112>:
                D.24011 = iftmp.232;
              }
              if (D.24011 == 0) goto <D.28113>; else goto <D.28114>;
              <D.28113>:
              D.28115 = mono_get_root_domain ();
              target = mono_create_specific_trampoline (0B, 3, D.28115, 0B);
              target = mono_create_ftnptr_malloc (target);
              goto <D.28116>;
              <D.28114>:
              {
                size_t __s1_len;
                size_t __s2_len;

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

                  __s2 = ji->data.name;
                  D.28120 = "mono_thread_get_and_clear_pending_exception";
                  D.28121 = MEM[(const unsigned char *)D.28120];
                  D.28122 = (int) D.28121;
                  D.28123 = *__s2;
                  D.28124 = (int) D.28123;
                  __result = D.28122 - D.28124;
                  {
                    if (__s2_len != 0) goto <D.28125>; else goto <D.28126>;
                    <D.28125>:
                    if (__result == 0) goto <D.28127>; else goto <D.28128>;
                    <D.28127>:
                    D.28129 = &MEM[(void *)"mono_thread_get_and_clear_pending_exception" + 1B];
                    D.28130 = *D.28129;
                    D.28131 = (int) D.28130;
                    D.28132 = __s2 + 1;
                    D.28133 = *D.28132;
                    D.28134 = (int) D.28133;
                    __result = D.28131 - D.28134;
                    if (__s2_len > 1) goto <D.28135>; else goto <D.28136>;
                    <D.28135>:
                    if (__result == 0) goto <D.28137>; else goto <D.28138>;
                    <D.28137>:
                    D.28139 = &MEM[(void *)"mono_thread_get_and_clear_pending_exception" + 2B];
                    D.28140 = *D.28139;
                    D.28141 = (int) D.28140;
                    D.28142 = __s2 + 2;
                    D.28143 = *D.28142;
                    D.28144 = (int) D.28143;
                    __result = D.28141 - D.28144;
                    if (__s2_len > 2) goto <D.28145>; else goto <D.28146>;
                    <D.28145>:
                    if (__result == 0) goto <D.28147>; else goto <D.28148>;
                    <D.28147>:
                    D.28149 = &MEM[(void *)"mono_thread_get_and_clear_pending_exception" + 3B];
                    D.28150 = *D.28149;
                    D.28151 = (int) D.28150;
                    D.28152 = __s2 + 3;
                    D.28153 = *D.28152;
                    D.28154 = (int) D.28153;
                    __result = D.28151 - D.28154;
                    <D.28148>:
                    <D.28146>:
                    <D.28138>:
                    <D.28136>:
                    <D.28128>:
                    <D.28126>:
                  }
                  D.24019 = __result;
                }
                iftmp.233 = -D.24019;
                goto <D.28155>;
                <D.28119>:
                D.27840 = ji->data.name;
                iftmp.233 = __builtin_strcmp (D.27840, "mono_thread_get_and_clear_pending_exception");
                <D.28155>:
                D.24020 = iftmp.233;
              }
              if (D.24020 == 0) goto <D.28156>; else goto <D.28157>;
              <D.28156>:
              target = mono_thread_get_and_clear_pending_exception;
              goto <D.28158>;
              <D.28157>:
              D.27840 = ji->data.name;
              D.28159 = strstr (D.27840, "generic_trampoline_");
              if (D.28159 != 0B) goto <D.28160>; else goto <D.28161>;
              <D.28160>:
              D.27840 = ji->data.name;
              target = mono_aot_get_trampoline (D.27840);
              goto <D.28162>;
              <D.28161>:
              aot_jit_icall_hash.234 = aot_jit_icall_hash;
              if (aot_jit_icall_hash.234 != 0B) goto <D.28166>; else goto <D.28163>;
              <D.28166>:
              aot_jit_icall_hash.234 = aot_jit_icall_hash;
              D.27840 = ji->data.name;
              D.28167 = monoeg_g_hash_table_lookup (aot_jit_icall_hash.234, D.27840);
              if (D.28167 != 0B) goto <D.28168>; else goto <D.28163>;
              <D.28168>:
              aot_jit_icall_hash.234 = aot_jit_icall_hash;
              D.27840 = ji->data.name;
              target = monoeg_g_hash_table_lookup (aot_jit_icall_hash.234, D.27840);
              goto <D.28164>;
              <D.28163>:
              stderr.235 = stderr;
              D.27840 = ji->data.name;
              fprintf (stderr.235, "Unknown relocation \'%s\'\n", D.27840);
              monoeg_assertion_message ("* Assertion: should not be reached at %s:%d\n", "aot-runtime.c", 4203);
              target = 0B;
              <D.28164>:
              <D.28162>:
              <D.28158>:
              <D.28116>:
              <D.28073>:
              <D.28030>:
              <D.27987>:
              <D.27975>:
              <D.27969>:
              <D.27927>:
              <D.27885>:
              <D.27843>:
              goto <D.28170>;
              <D.27800>:
              code.215 = code;
              target = mono_resolve_patch_target (0B, 0B, code.215, ji, 0);
              D.28171 = target == 0B;
              D.28172 = (long int) D.28171;
              D.28173 = __builtin_expect (D.28172, 0);
              if (D.28173 != 0) goto <D.28174>; else goto <D.28175>;
              <D.28174>:
              monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "aot-runtime.c", 4211, "target");
              <D.28175>:
              <D.28170>:
              D.27788 = amodule->got;
              got_slots.222 = got_slots;
              pindex.221 = (unsigned int) pindex;
              D.27790 = pindex.221 * 4;
              D.27791 = got_slots.222 + D.27790;
              D.27792 = *D.27791;
              D.27793 = D.27792 * 4;
              D.27794 = D.27788 + D.27793;
              *D.27794 = target;
            }
            <D.23945>:
            pindex = pindex + 1;
            <D.24022>:
            if (pindex < n_patches) goto <D.24021>; else goto <D.24023>;
            <D.24023>:
            got_slots.222 = got_slots;
            monoeg_g_free (got_slots.222);
            mono_mempool_destroy (mp);
          }
        finally
          {
            got_slots = {CLOBBER};
          }
      }
      <D.27780>:
      D.27769 = code;
      return D.27769;
    }
  finally
    {
      p = {CLOBBER};
      code = {CLOBBER};
    }
}


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

  D.28178 = code;
  return D.28178;
}


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

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


mono_aot_create_specific_trampoline (struct MonoImage * image, void * arg1, MonoTrampolineType tramp_type, struct MonoDomain * domain, guint32 * code_len)
{
  int inited.236;
  _Bool D.28187;
  long int D.28188;
  long int D.28189;
  _Bool D.28196;
  long int D.28197;
  long int D.28198;
  unsigned int num_trampolines.237;
  unsigned int num_trampolines.238;
  void * D.28203;
  void * D.28206;
  _Bool D.28207;
  long int D.28208;
  long int D.28209;
  struct MonoAotModule * amodule.239;
  void * * D.28216;
  unsigned int got_offset.240;
  unsigned int D.28218;
  void * * D.28219;
  sizetype D.28220;
  sizetype D.28221;
  void * * D.28222;
  unsigned int tramp_size.241;
  void * D.28226;
  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.236 = inited;
      if (inited.236 == 0) goto <D.28183>; else goto <D.28184>;
      <D.28183>:
      {
        int ret;

        ret = pthread_mutex_lock (&aot_mutex.mutex);
        if (ret != 0) goto <D.28185>; else goto <D.28186>;
        <D.28185>:
        monoeg_g_log (0B, 16, "Bad call to mono_mutex_lock result %d", ret);
        <D.28186>:
        D.28187 = ret != 0;
        D.28188 = (long int) D.28187;
        D.28189 = __builtin_expect (D.28188, 0);
        if (D.28189 != 0) goto <D.28190>; else goto <D.28191>;
        <D.28190>:
        monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "aot-runtime.c", 4494, "ret == 0");
        <D.28191>:
      }
      inited.236 = inited;
      if (inited.236 == 0) goto <D.28192>; else goto <D.28193>;
      <D.28192>:
      mono_counters_register ("Specific trampolines", 256, &num_trampolines);
      inited = 1;
      <D.28193>:
      {
        int ret;

        ret = pthread_mutex_unlock (&aot_mutex.mutex);
        if (ret != 0) goto <D.28194>; else goto <D.28195>;
        <D.28194>:
        monoeg_g_log (0B, 16, "Bad call to mono_mutex_unlock result %d", ret);
        <D.28195>:
        D.28196 = ret != 0;
        D.28197 = (long int) D.28196;
        D.28198 = __builtin_expect (D.28197, 0);
        if (D.28198 != 0) goto <D.28199>; else goto <D.28200>;
        <D.28199>:
        monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "aot-runtime.c", 4501, "ret == 0");
        <D.28200>:
      }
      <D.28184>:
      num_trampolines.237 = num_trampolines;
      num_trampolines.238 = num_trampolines.237 + 1;
      num_trampolines = num_trampolines.238;
      D.28203 = generic_trampolines[tramp_type];
      if (D.28203 == 0B) goto <D.28204>; else goto <D.28205>;
      <D.28204>:
      {
        char * symbol;

        symbol = mono_get_generic_trampoline_name (tramp_type);
        D.28206 = mono_aot_get_trampoline (symbol);
        generic_trampolines[tramp_type] = D.28206;
        monoeg_g_free (symbol);
      }
      <D.28205>:
      tramp = generic_trampolines[tramp_type];
      D.28207 = tramp == 0B;
      D.28208 = (long int) D.28207;
      D.28209 = __builtin_expect (D.28208, 0);
      if (D.28209 != 0) goto <D.28210>; else goto <D.28211>;
      <D.28210>:
      monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "aot-runtime.c", 4515, "tramp");
      <D.28211>:
      if (0 != 0) goto <D.28212>; else goto <D.28213>;
      <D.28212>:
      code = get_new_specific_trampoline_from_page (tramp, arg1);
      tramp_size = 8;
      goto <D.28214>;
      <D.28213>:
      code = get_numerous_trampoline (0, 2, &amodule, &got_offset, &tramp_size);
      amodule.239 = amodule;
      D.28216 = amodule.239->got;
      got_offset.240 = got_offset;
      D.28218 = got_offset.240 * 4;
      D.28219 = D.28216 + D.28218;
      *D.28219 = tramp;
      amodule.239 = amodule;
      D.28216 = amodule.239->got;
      got_offset.240 = got_offset;
      D.28220 = got_offset.240 + 1;
      D.28221 = D.28220 * 4;
      D.28222 = D.28216 + D.28221;
      *D.28222 = arg1;
      <D.28214>:
      if (code_len != 0B) goto <D.28223>; else goto <D.28224>;
      <D.28223>:
      tramp_size.241 = tramp_size;
      *code_len = tramp_size.241;
      <D.28224>:
      D.28226 = code;
      return D.28226;
    }
  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.28229;
  long int D.28230;
  long int D.28231;
  _Bool D.28236;
  long int D.28237;
  long int D.28238;
  _Bool D.28241;
  long int D.28242;
  long int D.28243;
  unsigned int D.28246;
  unsigned int D.28247;
  char * D.28250;
  unsigned int D.28251;
  unsigned int D.28252;
  _Bool D.28255;
  long int D.28256;
  long int D.28257;
  unsigned int D.28260;
  int D.28261;
  unsigned int D.28262;
  unsigned int D.28263;
  unsigned int D.28264;
  unsigned int tramp_size.242;
  void * D.28268;
  guint8 * D.28269;
  int D.28270;
  sizetype D.28271;
  struct MonoAotModule * amodule;
  int index;
  int tramp_size;
  struct MonoImage * image;

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

    ret = pthread_mutex_lock (&aot_mutex.mutex);
    if (ret != 0) goto <D.28234>; else goto <D.28235>;
    <D.28234>:
    monoeg_g_log (0B, 16, "Bad call to mono_mutex_lock result %d", ret);
    <D.28235>:
    D.28236 = ret != 0;
    D.28237 = (long int) D.28236;
    D.28238 = __builtin_expect (D.28237, 0);
    if (D.28238 != 0) goto <D.28239>; else goto <D.28240>;
    <D.28239>:
    monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "aot-runtime.c", 4450, "ret == 0");
    <D.28240>:
  }
  amodule = image->aot_module;
  D.28241 = amodule == 0B;
  D.28242 = (long int) D.28241;
  D.28243 = __builtin_expect (D.28242, 0);
  if (D.28243 != 0) goto <D.28244>; else goto <D.28245>;
  <D.28244>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "aot-runtime.c", 4453, "amodule");
  <D.28245>:
  *out_amodule = amodule;
  D.28246 = amodule->trampoline_index[tramp_type];
  D.28247 = amodule->info.num_trampolines[tramp_type];
  if (D.28246 == D.28247) goto <D.28248>; else goto <D.28249>;
  <D.28248>:
  D.28250 = image->name;
  D.28247 = 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.28250, D.28247, "");
  <D.24076>:
  goto <D.24076>;
  <D.28249>:
  D.28246 = amodule->trampoline_index[tramp_type];
  D.28251 = D.28246;
  D.28252 = D.28251 + 1;
  amodule->trampoline_index[tramp_type] = D.28252;
  index = (int) D.28251;
  {
    int ret;

    ret = pthread_mutex_unlock (&aot_mutex.mutex);
    if (ret != 0) goto <D.28253>; else goto <D.28254>;
    <D.28253>:
    monoeg_g_log (0B, 16, "Bad call to mono_mutex_unlock result %d", ret);
    <D.28254>:
    D.28255 = ret != 0;
    D.28256 = (long int) D.28255;
    D.28257 = __builtin_expect (D.28256, 0);
    if (D.28257 != 0) goto <D.28258>; else goto <D.28259>;
    <D.28258>:
    monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "aot-runtime.c", 4468, "ret == 0");
    <D.28259>:
  }
  D.28260 = amodule->info.trampoline_got_offset_base[tramp_type];
  D.28261 = index * n_got_slots;
  D.28262 = (unsigned int) D.28261;
  D.28263 = D.28260 + D.28262;
  *got_offset = D.28263;
  D.28264 = amodule->info.trampoline_size[tramp_type];
  tramp_size = (int) D.28264;
  if (out_tramp_size != 0B) goto <D.28265>; else goto <D.28266>;
  <D.28265>:
  tramp_size.242 = (unsigned int) tramp_size;
  *out_tramp_size = tramp_size.242;
  <D.28266>:
  D.28269 = amodule->trampolines[tramp_type];
  D.28270 = index * tramp_size;
  D.28271 = (sizetype) D.28270;
  D.28268 = D.28269 + D.28271;
  return D.28268;
}


mono_aot_get_static_rgctx_trampoline (void * ctx, void * addr)
{
  struct MonoAotModule * amodule.243;
  void * * D.28277;
  unsigned int got_offset.244;
  unsigned int D.28279;
  void * * D.28280;
  sizetype D.28281;
  sizetype D.28282;
  void * * D.28283;
  void * D.28284;
  struct MonoDomain * D.28285;
  struct MonoAotModule * amodule;
  guint8 * code;
  guint32 got_offset;

  try
    {
      if (0 != 0) goto <D.28273>; else goto <D.28274>;
      <D.28273>:
      code = get_new_rgctx_trampoline_from_page (addr, ctx);
      goto <D.28275>;
      <D.28274>:
      code = get_numerous_trampoline (1, 2, &amodule, &got_offset, 0B);
      amodule.243 = amodule;
      D.28277 = amodule.243->got;
      got_offset.244 = got_offset;
      D.28279 = got_offset.244 * 4;
      D.28280 = D.28277 + D.28279;
      *D.28280 = ctx;
      amodule.243 = amodule;
      D.28277 = amodule.243->got;
      got_offset.244 = got_offset;
      D.28281 = got_offset.244 + 1;
      D.28282 = D.28281 * 4;
      D.28283 = D.28277 + D.28282;
      *D.28283 = addr;
      <D.28275>:
      D.28285 = mono_domain_get ();
      D.28284 = mono_create_ftnptr (D.28285, code);
      return D.28284;
    }
  finally
    {
      amodule = {CLOBBER};
      got_offset = {CLOBBER};
    }
}


mono_aot_get_unbox_trampoline (struct MonoMethod * method)
{
  unsigned int D.28288;
  unsigned int D.28289;
  unsigned int D.28292;
  unsigned int D.28293;
  int D.28295;
  int D.28299;
  _Bool D.28302;
  long int D.28303;
  long int D.28304;
  struct MonoClass * D.28307;
  struct MonoImage * D.28308;
  void * amodule.245;
  struct MonoAotModule * amodule.246;
  _Bool D.28311;
  long int D.28312;
  long int D.28313;
  int ut_end.247;
  int ut.248;
  int D.28318;
  int D.28319;
  int D.28320;
  unsigned int entry_index.249;
  unsigned int D.28322;
  unsigned int D.28323;
  unsigned int D.28330;
  unsigned int D.28331;
  guint32 * D.28334;
  guint8 * D.28336;
  unsigned int D.28337;
  _Bool D.28338;
  long int D.28339;
  long int D.28340;
  void * D.28343;
  struct MonoDomain * D.28344;
  guint32 method_index;
  struct MonoAotModule * amodule;
  void * code;
  guint32 * ut;
  guint32 * ut_end;
  guint32 * entry;
  int low;
  int high;
  int entry_index;

  try
    {
      D.28288 = method->token;
      D.28289 = D.28288 & 16777215;
      method_index = D.28289 + 4294967295;
      D.28292 = BIT_FIELD_REF <*method, 32, 160>;
      D.28293 = D.28292 & 4096;
      if (D.28293 != 0) goto <D.28294>; else goto <D.28290>;
      <D.28294>:
      D.28295 = mono_method_is_generic_sharable_full (method, 0, 0, 0);
      if (D.28295 == 0) goto <D.28296>; else goto <D.28290>;
      <D.28296>:
      method_index = find_extra_method (method, &amodule);
      if (method_index == 16777215) goto <D.28297>; else goto <D.28298>;
      <D.28297>:
      D.28299 = mono_method_is_generic_sharable_full (method, 0, 0, 1);
      if (D.28299 != 0) goto <D.28300>; else goto <D.28301>;
      <D.28300>:
      {
        struct MonoMethod * shared;

        shared = mini_get_shared_method_full (method, 1, 1);
        method_index = find_extra_method (shared, &amodule);
      }
      <D.28301>:
      <D.28298>:
      D.28302 = method_index == 16777215;
      D.28303 = (long int) D.28302;
      D.28304 = __builtin_expect (D.28303, 0);
      if (D.28304 != 0) goto <D.28305>; else goto <D.28306>;
      <D.28305>:
      monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "aot-runtime.c", 4568, "method_index != 0xffffff");
      <D.28306>:
      goto <D.28291>;
      <D.28290>:
      D.28307 = method->klass;
      D.28308 = D.28307->image;
      amodule.245 = D.28308->aot_module;
      amodule = amodule.245;
      amodule.246 = amodule;
      D.28311 = amodule.246 == 0B;
      D.28312 = (long int) D.28311;
      D.28313 = __builtin_expect (D.28312, 0);
      if (D.28313 != 0) goto <D.28314>; else goto <D.28315>;
      <D.28314>:
      monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "aot-runtime.c", 4571, "amodule");
      <D.28315>:
      <D.28291>:
      amodule.246 = amodule;
      ut = amodule.246->unbox_trampolines;
      amodule.246 = amodule;
      ut_end = amodule.246->unbox_trampolines_end;
      code = 0B;
      low = 0;
      ut_end.247 = (int) ut_end;
      ut.248 = (int) ut;
      D.28318 = ut_end.247 - ut.248;
      D.28319 = D.28318 /[ex] 4;
      high = D.28319 / 2;
      goto <D.24118>;
      <D.24117>:
      D.28320 = low + high;
      entry_index = D.28320 / 2;
      entry_index.249 = (unsigned int) entry_index;
      D.28322 = entry_index.249 * 8;
      entry = ut + D.28322;
      D.28323 = *entry;
      if (D.28323 < method_index) goto <D.28324>; else goto <D.28325>;
      <D.28324>:
      low = entry_index + 1;
      goto <D.28326>;
      <D.28325>:
      D.28323 = *entry;
      if (D.28323 > method_index) goto <D.28327>; else goto <D.28328>;
      <D.28327>:
      high = entry_index;
      goto <D.28329>;
      <D.28328>:
      amodule.246 = amodule;
      D.28330 = amodule.246->info.flags;
      D.28331 = D.28330 & 8;
      if (D.28331 != 0) goto <D.28332>; else goto <D.28333>;
      <D.28332>:
      D.28334 = entry + 4;
      code = get_arm_bl_target (D.28334);
      goto <D.28335>;
      <D.28333>:
      amodule.246 = amodule;
      D.28336 = amodule.246->code;
      D.28334 = entry + 4;
      D.28337 = *D.28334;
      code = D.28336 + D.28337;
      <D.28335>:
      goto <D.24116>;
      <D.28329>:
      <D.28326>:
      <D.24118>:
      if (low < high) goto <D.24117>; else goto <D.24116>;
      <D.24116>:
      D.28338 = code == 0B;
      D.28339 = (long int) D.28338;
      D.28340 = __builtin_expect (D.28339, 0);
      if (D.28340 != 0) goto <D.28341>; else goto <D.28342>;
      <D.28341>:
      monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "aot-runtime.c", 4596, "code");
      <D.28342>:
      D.28344 = mono_domain_get ();
      D.28343 = mono_create_ftnptr (D.28344, code);
      return D.28343;
    }
  finally
    {
      amodule = {CLOBBER};
    }
}


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

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


mono_aot_get_lazy_fetch_trampoline (guint32 slot)
{
  struct MonoImage * D.28349;
  int count.250;
  int count.251;
  unsigned int D.28352;
  void * addr.252;
  void * addr.253;
  struct MonoDomain * D.28359;
  void * slot.254;
  void * * D.28361;
  struct MonoDomain * D.28362;
  void * D.28363;
  void * D.28364;
  struct MonoDomain * D.28365;
  int slot.255;
  void * D.28367;
  struct MonoDomain * D.28368;
  char * symbol;
  void * code;
  struct MonoAotModule * amodule;
  guint32 index;
  static int count = 0;

  D.28349 = mono_defaults.corlib;
  amodule = D.28349->aot_module;
  index = slot & 2147483647;
  count.250 = count;
  count.251 = count.250 + 1;
  count = count.251;
  D.28352 = amodule->info.num_rgctx_fetch_trampolines;
  if (D.28352 <= index) goto <D.28353>; else goto <D.28354>;
  <D.28353>:
  {
    static void * addr;
    void * * info;

    addr.252 = addr;
    if (addr.252 == 0B) goto <D.28356>; else goto <D.28357>;
    <D.28356>:
    addr.253 = load_function (amodule, "rgctx_fetch_trampoline_general");
    addr = addr.253;
    <D.28357>:
    D.28359 = mono_get_root_domain ();
    info = mono_domain_alloc0 (D.28359, 8);
    slot.254 = (void *) slot;
    *info = slot.254;
    D.28361 = info + 4;
    slot.254 = (void *) slot;
    D.28362 = mono_get_root_domain ();
    D.28363 = mono_create_specific_trampoline (slot.254, 4, D.28362, 0B);
    *D.28361 = D.28363;
    addr.252 = addr;
    code = mono_aot_get_static_rgctx_trampoline (info, addr.252);
    D.28365 = mono_domain_get ();
    D.28364 = mono_create_ftnptr (D.28365, code);
    return D.28364;
  }
  <D.28354>:
  slot.255 = (int) slot;
  symbol = mono_get_rgctx_fetch_trampoline_name (slot.255);
  D.28349 = mono_defaults.corlib;
  D.28367 = D.28349->aot_module;
  code = load_function (D.28367, symbol);
  monoeg_g_free (symbol);
  D.28368 = mono_domain_get ();
  D.28364 = mono_create_ftnptr (D.28368, code);
  return D.28364;
}


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

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


mono_aot_get_imt_thunk (struct MonoVTable * vtable, struct MonoDomain * domain, struct MonoIMTCheckItem * * imt_entries, int count, void * fail_tramp)
{
  unsigned int i.256;
  unsigned int D.28373;
  struct MonoIMTCheckItem * * D.28374;
  unsigned char D.28375;
  int D.28378;
  unsigned int D.28379;
  unsigned int D.28380;
  unsigned char D.28381;
  void * D.28384;
  _Bool D.28385;
  long int D.28386;
  long int D.28387;
  unsigned int index.257;
  unsigned int D.28391;
  void * * D.28392;
  unsigned char D.28393;
  void * D.28396;
  sizetype index.258;
  sizetype D.28398;
  sizetype D.28399;
  void * * D.28400;
  int D.28402;
  void * * D.28403;
  struct MonoAotModule * amodule.259;
  void * * D.28408;
  unsigned int got_offset.260;
  unsigned int D.28410;
  void * * D.28411;
  void * D.28412;
  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.24145>;
      <D.24144>:
      {
        struct MonoIMTCheckItem * item;

        i.256 = (unsigned int) i;
        D.28373 = i.256 * 4;
        D.28374 = imt_entries + D.28373;
        item = *D.28374;
        D.28375 = item->is_equals;
        if (D.28375 != 0) goto <D.28376>; else goto <D.28377>;
        <D.28376>:
        real_count = real_count + 1;
        <D.28377>:
      }
      i = i + 1;
      <D.24145>:
      if (i < count) goto <D.24144>; else goto <D.24146>;
      <D.24146>:
      D.28378 = real_count + 1;
      D.28379 = (unsigned int) D.28378;
      D.28380 = D.28379 * 8;
      buf = mono_domain_alloc (domain, D.28380);
      index = 0;
      i = 0;
      goto <D.24151>;
      <D.24150>:
      {
        struct MonoIMTCheckItem * item;

        i.256 = (unsigned int) i;
        D.28373 = i.256 * 4;
        D.28374 = imt_entries + D.28373;
        item = *D.28374;
        D.28381 = item->is_equals;
        if (D.28381 == 0) goto <D.28382>; else goto <D.28383>;
        <D.28382>:
        // predicted unlikely by continue predictor.
        goto <D.24148>;
        <D.28383>:
        D.28384 = item->key;
        D.28385 = D.28384 == 0B;
        D.28386 = (long int) D.28385;
        D.28387 = __builtin_expect (D.28386, 0);
        if (D.28387 != 0) goto <D.28388>; else goto <D.28389>;
        <D.28388>:
        monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "aot-runtime.c", 4661, "item->key");
        <D.28389>:
        index.257 = (unsigned int) index;
        D.28391 = index.257 * 8;
        D.28392 = buf + D.28391;
        D.28384 = item->key;
        *D.28392 = D.28384;
        D.28393 = item->has_target_code;
        if (D.28393 != 0) goto <D.28394>; else goto <D.28395>;
        <D.28394>:
        {
          void * * p;

          p = mono_domain_alloc (domain, 4);
          D.28396 = item->value.target_code;
          *p = D.28396;
          index.258 = (sizetype) index;
          D.28398 = index.258 * 8;
          D.28399 = D.28398 + 4;
          D.28400 = buf + D.28399;
          *D.28400 = p;
        }
        goto <D.28401>;
        <D.28395>:
        index.258 = (sizetype) index;
        D.28398 = index.258 * 8;
        D.28399 = D.28398 + 4;
        D.28400 = buf + D.28399;
        D.28402 = item->value.vtable_slot;
        D.28403 = &vtable->vtable[D.28402];
        *D.28400 = D.28403;
        <D.28401>:
        index = index + 1;
      }
      <D.24148>:
      i = i + 1;
      <D.24151>:
      if (i < count) goto <D.24150>; else goto <D.24152>;
      <D.24152>:
      index.257 = (unsigned int) index;
      D.28391 = index.257 * 8;
      D.28392 = buf + D.28391;
      *D.28392 = 0B;
      index.258 = (sizetype) index;
      D.28398 = index.258 * 8;
      D.28399 = D.28398 + 4;
      D.28400 = buf + D.28399;
      *D.28400 = fail_tramp;
      if (0 != 0) goto <D.28404>; else goto <D.28405>;
      <D.28404>:
      code = get_new_imt_trampoline_from_page (buf);
      goto <D.28406>;
      <D.28405>:
      code = get_numerous_trampoline (2, 1, &amodule, &got_offset, 0B);
      amodule.259 = amodule;
      D.28408 = amodule.259->got;
      got_offset.260 = got_offset;
      D.28410 = got_offset.260 * 4;
      D.28411 = D.28408 + D.28410;
      *D.28411 = buf;
      <D.28406>:
      D.28412 = code;
      return D.28412;
    }
  finally
    {
      got_offset = {CLOBBER};
      amodule = {CLOBBER};
    }
}


mono_aot_get_gsharedvt_arg_trampoline (void * arg, void * addr)
{
  struct MonoAotModule * amodule.261;
  void * * D.28419;
  unsigned int got_offset.262;
  unsigned int D.28421;
  void * * D.28422;
  sizetype D.28423;
  sizetype D.28424;
  void * * D.28425;
  void * D.28426;
  struct MonoDomain * D.28427;
  struct MonoAotModule * amodule;
  guint8 * code;
  guint32 got_offset;

  try
    {
      if (0 != 0) goto <D.28415>; else goto <D.28416>;
      <D.28415>:
      code = get_new_gsharedvt_arg_trampoline_from_page (addr, arg);
      goto <D.28417>;
      <D.28416>:
      code = get_numerous_trampoline (3, 2, &amodule, &got_offset, 0B);
      amodule.261 = amodule;
      D.28419 = amodule.261->got;
      got_offset.262 = got_offset;
      D.28421 = got_offset.262 * 4;
      D.28422 = D.28419 + D.28421;
      *D.28422 = arg;
      amodule.261 = amodule;
      D.28419 = amodule.261->got;
      got_offset.262 = got_offset;
      D.28423 = got_offset.262 + 1;
      D.28424 = D.28423 * 4;
      D.28425 = D.28419 + D.28424;
      *D.28425 = addr;
      <D.28417>:
      D.28427 = mono_domain_get ();
      D.28426 = mono_create_ftnptr (D.28427, code);
      return D.28426;
    }
  finally
    {
      amodule = {CLOBBER};
      got_offset = {CLOBBER};
    }
}


mono_aot_set_make_unreadable (gboolean unreadable)
{
  int make_unreadable.263;
  int inited.264;
  static int inited;

  make_unreadable = unreadable;
  make_unreadable.263 = make_unreadable;
  if (make_unreadable.263 != 0) goto <D.28431>; else goto <D.28432>;
  <D.28431>:
  inited.264 = inited;
  if (inited.264 == 0) goto <D.28434>; else goto <D.28435>;
  <D.28434>:
  mono_counters_register ("AOT pagefaults", 256, &n_pagefaults);
  <D.28435>:
  <D.28432>:
}


mono_aot_is_pagefault (void * ptr)
{
  int make_unreadable.265;
  gboolean D.28439;
  struct MonoAotModule * D.28440;
  _Bool D.28441;

  make_unreadable.265 = make_unreadable;
  if (make_unreadable.265 == 0) goto <D.28437>; else goto <D.28438>;
  <D.28437>:
  D.28439 = 0;
  return D.28439;
  <D.28438>:
  D.28440 = find_module_for_addr (ptr);
  D.28441 = D.28440 != 0B;
  D.28439 = (gboolean) D.28441;
  return D.28439;
}


find_module_for_addr (void * ptr)
{
  int make_unreadable.266;
  struct MonoAotModule * D.28446;
  _Bool D.28449;
  long int D.28450;
  long int D.28451;
  struct GHashTable * aot_modules.267;
  _Bool D.28457;
  long int D.28458;
  long int D.28459;
  struct FindMapUserData data;

  try
    {
      make_unreadable.266 = make_unreadable;
      if (make_unreadable.266 == 0) goto <D.28444>; else goto <D.28445>;
      <D.28444>:
      D.28446 = 0B;
      return D.28446;
      <D.28445>:
      data.module = 0B;
      data.ptr = ptr;
      {
        int ret;

        ret = pthread_mutex_lock (&aot_mutex.mutex);
        if (ret != 0) goto <D.28447>; else goto <D.28448>;
        <D.28447>:
        monoeg_g_log (0B, 16, "Bad call to mono_mutex_lock result %d", ret);
        <D.28448>:
        D.28449 = ret != 0;
        D.28450 = (long int) D.28449;
        D.28451 = __builtin_expect (D.28450, 0);
        if (D.28451 != 0) goto <D.28452>; else goto <D.28453>;
        <D.28452>:
        monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "aot-runtime.c", 4752, "ret == 0");
        <D.28453>:
      }
      aot_modules.267 = aot_modules;
      monoeg_g_hash_table_foreach (aot_modules.267, find_map, &data);
      {
        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", 4754, "ret == 0");
        <D.28461>:
      }
      D.28446 = data.module;
      return D.28446;
    }
  finally
    {
      data = {CLOBBER};
    }
}


find_map (void * key, void * value, void * user_data)
{
  struct MonoAotModule * D.28464;
  guint8 * D.28467;
  guint8 * D.28468;
  guint8 * D.28471;
  struct MonoAotModule * module;
  struct FindMapUserData * data;

  module = value;
  data = user_data;
  D.28464 = data->module;
  if (D.28464 == 0B) goto <D.28465>; else goto <D.28466>;
  <D.28465>:
  D.28467 = data->ptr;
  D.28468 = module->mem_begin;
  if (D.28467 >= D.28468) goto <D.28469>; else goto <D.28470>;
  <D.28469>:
  D.28467 = data->ptr;
  D.28471 = module->mem_end;
  if (D.28467 < D.28471) goto <D.28472>; else goto <D.28473>;
  <D.28472>:
  data->module = module;
  <D.28473>:
  <D.28470>:
  <D.28466>:
}


mono_aot_handle_pagefault (void * ptr)
{
  int D.28474;
  int D.28475;
  int ptr.268;
  int D.28477;
  _Bool D.28480;
  long int D.28481;
  long int D.28482;
  int D.28485;
  unsigned int D.28486;
  _Bool D.28487;
  long int D.28488;
  long int D.28489;
  unsigned int n_pagefaults.269;
  unsigned int n_pagefaults.270;
  _Bool D.28496;
  long int D.28497;
  long int D.28498;
  guint8 * start;
  int res;

  D.28474 = mono_pagesize ();
  D.28475 = -D.28474;
  ptr.268 = (int) ptr;
  D.28477 = D.28475 & ptr.268;
  start = (guint8 *) D.28477;
  {
    int ret;

    ret = pthread_mutex_lock (&aot_mutex.mutex);
    if (ret != 0) goto <D.28478>; else goto <D.28479>;
    <D.28478>:
    monoeg_g_log (0B, 16, "Bad call to mono_mutex_lock result %d", ret);
    <D.28479>:
    D.28480 = ret != 0;
    D.28481 = (long int) D.28480;
    D.28482 = __builtin_expect (D.28481, 0);
    if (D.28482 != 0) goto <D.28483>; else goto <D.28484>;
    <D.28483>:
    monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "aot-runtime.c", 4790, "ret == 0");
    <D.28484>:
  }
  D.28485 = mono_pagesize ();
  D.28486 = (unsigned int) D.28485;
  res = mono_mprotect (start, D.28486, 7);
  D.28487 = res != 0;
  D.28488 = (long int) D.28487;
  D.28489 = __builtin_expect (D.28488, 0);
  if (D.28489 != 0) goto <D.28490>; else goto <D.28491>;
  <D.28490>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "aot-runtime.c", 4792, "res == 0");
  <D.28491>:
  n_pagefaults.269 = n_pagefaults;
  n_pagefaults.270 = n_pagefaults.269 + 1;
  n_pagefaults = n_pagefaults.270;
  {
    int ret;

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