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.24513;
  _Bool D.24514;
  long int D.24515;
  long int D.24516;
  _Bool D.24519;
  long int D.24520;
  long int D.24521;
  struct GHashTable * aot_modules.0;
  _Bool D.24529;
  long int D.24530;
  long int D.24531;
  struct GHashTable * static_aot_modules.1;
  struct GHashTable * static_aot_modules.2;
  _Bool D.24542;
  long int D.24543;
  long int D.24544;
  void * * globals;
  char * aname;
  struct MonoAotFileInfo * info;

  info = aot_info;
  D.24513 = info->version;
  D.24514 = D.24513 != 97;
  D.24515 = (long int) D.24514;
  D.24516 = __builtin_expect (D.24515, 0);
  if (D.24516 != 0) goto <D.24517>; else goto <D.24518>;
  <D.24517>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "aot-runtime.c", 1889, "info->version == MONO_AOT_FILE_VERSION");
  <D.24518>:
  globals = info->globals;
  D.24519 = globals == 0B;
  D.24520 = (long int) D.24519;
  D.24521 = __builtin_expect (D.24520, 0);
  if (D.24521 != 0) goto <D.24522>; else goto <D.24523>;
  <D.24522>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "aot-runtime.c", 1892, "globals");
  <D.24523>:
  aname = info->assembly_name;
  aot_modules.0 = aot_modules;
  if (aot_modules.0 != 0B) goto <D.24525>; else goto <D.24526>;
  <D.24525>:
  {
    int ret;

    ret = pthread_mutex_lock (&aot_mutex.mutex);
    if (ret != 0) goto <D.24527>; else goto <D.24528>;
    <D.24527>:
    monoeg_g_log (0B, 16, "Bad call to mono_mutex_lock result %d", ret);
    <D.24528>:
    D.24529 = ret != 0;
    D.24530 = (long int) D.24529;
    D.24531 = __builtin_expect (D.24530, 0);
    if (D.24531 != 0) goto <D.24532>; else goto <D.24533>;
    <D.24532>:
    monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "aot-runtime.c", 1898, "ret == 0");
    <D.24533>:
  }
  <D.24526>:
  static_aot_modules.1 = static_aot_modules;
  if (static_aot_modules.1 == 0B) goto <D.24535>; else goto <D.24536>;
  <D.24535>:
  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.24536>:
  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.24538>; else goto <D.24539>;
  <D.24538>:
  {
    int ret;

    ret = pthread_mutex_unlock (&aot_mutex.mutex);
    if (ret != 0) goto <D.24540>; else goto <D.24541>;
    <D.24540>:
    monoeg_g_log (0B, 16, "Bad call to mono_mutex_unlock result %d", ret);
    <D.24541>:
    D.24542 = ret != 0;
    D.24543 = (long int) D.24542;
    D.24544 = __builtin_expect (D.24543, 0);
    if (D.24544 != 0) goto <D.24545>; else goto <D.24546>;
    <D.24545>:
    monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "aot-runtime.c", 1906, "ret == 0");
    <D.24546>:
  }
  <D.24539>:
}


mono_aot_init ()
{
  struct GHashTable * aot_modules.3;
  const gchar * D.24548;
  const gchar * D.24551;
  int mono_last_aot_method.4;
  const gchar * D.24553;

  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.24548 = monoeg_g_getenv ("MONO_LASTAOT");
  if (D.24548 != 0B) goto <D.24549>; else goto <D.24550>;
  <D.24549>:
  D.24551 = monoeg_g_getenv ("MONO_LASTAOT");
  mono_last_aot_method.4 = atoi (D.24551);
  mono_last_aot_method = mono_last_aot_method.4;
  <D.24550>:
  D.24553 = monoeg_g_getenv ("MONO_AOT_CACHE");
  if (D.24553 != 0B) goto <D.24554>; else goto <D.24555>;
  <D.24554>:
  use_aot_cache = 1;
  <D.24555>:
}


load_aot_module (struct MonoAssembly * assembly, void * user_data)
{
  int mono_compile_aot.5;
  struct MonoImage * D.24559;
  void * D.24560;
  unsigned char D.24565;
  unsigned char D.24566;
  int D.24568;
  <unnamed type> D.24569;
  _Bool D.24574;
  long int D.24575;
  long int D.24576;
  struct GHashTable * static_aot_modules.6;
  const char * D.24582;
  void * info.7;
  _Bool D.24587;
  long int D.24588;
  long int D.24589;
  struct MonoAotFileInfo * info.8;
  gchar * aot_name.9;
  char * aot_name.10;
  int use_aot_cache.11;
  char * D.24602;
  gchar * aot_name.12;
  char * err.13;
  _Bool D.24607;
  _Bool D.24608;
  _Bool D.24609;
  int mono_aot_only.14;
  unsigned int D.24615;
  unsigned int D.24616;
  struct _IO_FILE * stderr.15;
  char * version_symbol.16;
  _Bool D.24626;
  long int D.24627;
  long int D.24628;
  unsigned int D.24631;
  gchar * msg.17;
  char * msg.18;
  unsigned int D.24643;
  unsigned int align_double.19;
  _Bool D.24645;
  long int D.24646;
  long int D.24647;
  unsigned int D.24650;
  unsigned int align_int64.20;
  _Bool D.24652;
  long int D.24653;
  long int D.24654;
  unsigned int D.24657;
  _Bool D.24658;
  long int D.24659;
  long int D.24660;
  struct MonoAotFileInfo * D.24663;
  void * D.24664;
  void * * D.24665;
  struct GHashTable * D.24666;
  _Bool D.24667;
  long int D.24668;
  long int D.24669;
  unsigned int D.24672;
  void * D.24673;
  unsigned int D.24674;
  void * D.24675;
  void * D.24676;
  struct MonoAssemblyName * D.24677;
  unsigned int D.24678;
  gchar * D.24679;
  unsigned int D.24680;
  sizetype D.24681;
  char * * D.24682;
  unsigned int D.24683;
  char * * D.24684;
  gchar * D.24685;
  unsigned int D.24686;
  sizetype D.24687;
  char D.24688;
  gchar * D.24691;
  unsigned int D.24692;
  sizetype D.24693;
  unsigned int D.24694;
  unsigned int D.24695;
  mono_byte[17] * D.24696;
  unsigned int D.24697;
  sizetype D.24698;
  int table.21;
  int D.24700;
  int D.24701;
  unsigned int D.24702;
  short unsigned int D.24703;
  void * D.24704;
  void * D.24705;
  void * D.24706;
  void * D.24707;
  void * D.24708;
  void * D.24709;
  void * D.24710;
  void * D.24711;
  void * D.24712;
  void * D.24713;
  void * D.24714;
  void * D.24715;
  void * D.24716;
  void * D.24717;
  void * D.24718;
  guint8 * D.24719;
  void * D.24720;
  void * D.24721;
  void * D.24722;
  void * D.24723;
  void * D.24724;
  void * D.24725;
  void * D.24726;
  void * D.24727;
  int make_unreadable.22;
  guint8 * D.24731;
  int D.24732;
  guint8 * D.24733;
  int D.24734;
  int D.24735;
  sizetype D.24736;
  int D.24737;
  int D.24738;
  int addr.23;
  int D.24740;
  sizetype D.24741;
  sizetype D.24742;
  sizetype len.24;
  guint8 * D.24744;
  int D.24745;
  int D.24746;
  int D.24747;
  int D.24748;
  int page_end.25;
  int page_start.26;
  int D.24753;
  unsigned int D.24754;
  _Bool D.24755;
  long int D.24756;
  long int D.24757;
  _Bool D.24762;
  long int D.24763;
  long int D.24764;
  unsigned int D.24767;
  unsigned int aot_code_low_addr.27;
  unsigned int aot_code_low_addr.28;
  guint8 * D.24770;
  unsigned int D.24771;
  unsigned int aot_code_high_addr.29;
  unsigned int aot_code_high_addr.30;
  struct GHashTable * aot_modules.31;
  _Bool D.24777;
  long int D.24778;
  long int D.24779;
  void * * D.24784;
  struct MonoDl * D.24785;
  char * code.32;
  _Bool D.24787;
  int D.24788;
  struct MonoImage * D.24789;
  void * * D.24792;
  void * * D.24793;
  int D.24795;
  void * * D.24798;
  struct MonoDomain * D.24799;
  void * D.24800;
  unsigned int i.33;
  unsigned int D.24804;
  int D.24805;
  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.24557>; else goto <D.24558>;
      <D.24557>:
      return;
      <D.24558>:
      D.24559 = assembly->image;
      D.24560 = D.24559->aot_module;
      if (D.24560 != 0B) goto <D.24561>; else goto <D.24562>;
      <D.24561>:
      return;
      <D.24562>:
      D.24559 = assembly->image;
      D.24565 = BIT_FIELD_REF <*D.24559, 8, 128>;
      D.24566 = D.24565 & 8;
      if (D.24566 != 0) goto <D.24563>; else goto <D.24567>;
      <D.24567>:
      D.24568 = assembly->ref_only;
      if (D.24568 != 0) goto <D.24563>; else goto <D.24564>;
      <D.24563>:
      return;
      <D.24564>:
      D.24569 = mono_security_get_mode ();
      if (D.24569 == 2) goto <D.24570>; else goto <D.24571>;
      <D.24570>:
      return;
      <D.24571>:
      {
        int ret;

        ret = pthread_mutex_lock (&aot_mutex.mutex);
        if (ret != 0) goto <D.24572>; else goto <D.24573>;
        <D.24572>:
        monoeg_g_log (0B, 16, "Bad call to mono_mutex_lock result %d", ret);
        <D.24573>:
        D.24574 = ret != 0;
        D.24575 = (long int) D.24574;
        D.24576 = __builtin_expect (D.24575, 0);
        if (D.24576 != 0) goto <D.24577>; else goto <D.24578>;
        <D.24577>:
        monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "aot-runtime.c", 1577, "ret == 0");
        <D.24578>:
      }
      static_aot_modules.6 = static_aot_modules;
      if (static_aot_modules.6 != 0B) goto <D.24580>; else goto <D.24581>;
      <D.24580>:
      D.24582 = assembly->aname.name;
      static_aot_modules.6 = static_aot_modules;
      info.7 = monoeg_g_hash_table_lookup (static_aot_modules.6, D.24582);
      info = info.7;
      goto <D.24584>;
      <D.24581>:
      info = 0B;
      <D.24584>:
      {
        int ret;

        ret = pthread_mutex_unlock (&aot_mutex.mutex);
        if (ret != 0) goto <D.24585>; else goto <D.24586>;
        <D.24585>:
        monoeg_g_log (0B, 16, "Bad call to mono_mutex_unlock result %d", ret);
        <D.24586>:
        D.24587 = ret != 0;
        D.24588 = (long int) D.24587;
        D.24589 = __builtin_expect (D.24588, 0);
        if (D.24589 != 0) goto <D.24590>; else goto <D.24591>;
        <D.24590>:
        monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "aot-runtime.c", 1582, "ret == 0");
        <D.24591>:
      }
      info.8 = info;
      if (info.8 != 0B) goto <D.24593>; else goto <D.24594>;
      <D.24593>:
      sofile = 0B;
      D.24582 = assembly->aname.name;
      aot_name.9 = monoeg_g_strdup_printf ("%s", D.24582);
      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.24597>;
      <D.24594>:
      use_aot_cache.11 = use_aot_cache;
      if (use_aot_cache.11 != 0) goto <D.24599>; else goto <D.24600>;
      <D.24599>:
      sofile = load_aot_module_from_cache (assembly, &aot_name);
      goto <D.24601>;
      <D.24600>:
      {
        char * err;

        try
          {
            D.24559 = assembly->image;
            D.24602 = D.24559->name;
            aot_name.12 = monoeg_g_strdup_printf ("%s%s", D.24602, ".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.24604>; else goto <D.24605>;
            <D.24604>:
            err.13 = err;
            aot_name.10 = aot_name;
            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.24605>:
          }
        finally
          {
            err = {CLOBBER};
          }
      }
      <D.24601>:
      <D.24597>:
      D.24607 = sofile == 0B;
      D.24608 = globals == 0B;
      D.24609 = D.24607 & D.24608;
      if (D.24609 != 0) goto <D.24610>; else goto <D.24611>;
      <D.24610>:
      mono_aot_only.14 = mono_aot_only;
      if (mono_aot_only.14 != 0) goto <D.24613>; else goto <D.24614>;
      <D.24613>:
      D.24559 = assembly->image;
      D.24615 = BIT_FIELD_REF <*D.24559, 32, 1408>;
      D.24616 = D.24615 & 16777215;
      if (D.24616 != 0) goto <D.24617>; else goto <D.24618>;
      <D.24617>:
      aot_name.10 = aot_name;
      stderr.15 = stderr;
      fprintf (stderr.15, "Failed to load AOT module \'%s\' in aot-only mode.\n", aot_name.10);
      exit (1);
      <D.24618>:
      <D.24614>:
      aot_name.10 = aot_name;
      monoeg_g_free (aot_name.10);
      return;
      <D.24611>:
      info.8 = info;
      if (info.8 == 0B) goto <D.24620>; else goto <D.24621>;
      <D.24620>:
      find_symbol (sofile, globals, "mono_aot_version", &version_symbol);
      find_symbol (sofile, globals, "mono_aot_file_info", &info);
      <D.24621>:
      version_symbol.16 = version_symbol;
      if (version_symbol.16 != 0B) goto <D.24623>; else goto <D.24624>;
      <D.24623>:
      version_symbol.16 = version_symbol;
      version = atoi (version_symbol.16);
      goto <D.24625>;
      <D.24624>:
      info.8 = info;
      D.24626 = info.8 == 0B;
      D.24627 = (long int) D.24626;
      D.24628 = __builtin_expect (D.24627, 0);
      if (D.24628 != 0) goto <D.24629>; else goto <D.24630>;
      <D.24629>:
      monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "aot-runtime.c", 1624, "info");
      <D.24630>:
      info.8 = info;
      D.24631 = info.8->version;
      version = (int) D.24631;
      <D.24625>:
      if (version != 97) goto <D.24632>; else goto <D.24633>;
      <D.24632>:
      msg.17 = monoeg_g_strdup_printf ("wrong file format version (expected %d got %d)", 97, version);
      msg = msg.17;
      usable = 0;
      goto <D.24635>;
      <D.24633>:
      info.8 = info;
      usable = check_usable (assembly, info.8, &msg);
      <D.24635>:
      if (usable == 0) goto <D.24636>; else goto <D.24637>;
      <D.24636>:
      mono_aot_only.14 = mono_aot_only;
      if (mono_aot_only.14 != 0) goto <D.24638>; else goto <D.24639>;
      <D.24638>:
      msg.18 = msg;
      aot_name.10 = aot_name;
      stderr.15 = stderr;
      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.24639>:
      msg.18 = msg;
      aot_name.10 = aot_name;
      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.24641>; else goto <D.24642>;
      <D.24641>:
      mono_dl_close (sofile);
      <D.24642>:
      D.24559 = assembly->image;
      D.24559->aot_module = 0B;
      return;
      <D.24637>:
      align_double = 8;
      align_int64 = 8;
      info.8 = info;
      D.24643 = info.8->double_align;
      align_double.19 = (unsigned int) align_double;
      D.24645 = D.24643 != align_double.19;
      D.24646 = (long int) D.24645;
      D.24647 = __builtin_expect (D.24646, 0);
      if (D.24647 != 0) goto <D.24648>; else goto <D.24649>;
      <D.24648>:
      monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "aot-runtime.c", 1670, "info->double_align == align_double");
      <D.24649>:
      info.8 = info;
      D.24650 = info.8->long_align;
      align_int64.20 = (unsigned int) align_int64;
      D.24652 = D.24650 != align_int64.20;
      D.24653 = (long int) D.24652;
      D.24654 = __builtin_expect (D.24653, 0);
      if (D.24654 != 0) goto <D.24655>; else goto <D.24656>;
      <D.24655>:
      monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "aot-runtime.c", 1671, "info->long_align == align_int64");
      <D.24656>:
      info.8 = info;
      D.24657 = info.8->generic_tramp_num;
      D.24658 = D.24657 != 14;
      D.24659 = (long int) D.24658;
      D.24660 = __builtin_expect (D.24659, 0);
      if (D.24660 != 0) goto <D.24661>; else goto <D.24662>;
      <D.24661>:
      monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "aot-runtime.c", 1672, "info->generic_tramp_num == MONO_TRAMPOLINE_NUM");
      <D.24662>:
      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;
      info.8 = info;
      D.24663 = &amodule->info;
      memcpy (D.24663, info.8, 244);
      D.24664 = amodule->info.got;
      amodule->got = D.24664;
      D.24665 = amodule->got;
      D.24559 = assembly->image;
      *D.24665 = D.24559;
      amodule->globals = globals;
      amodule->sofile = sofile;
      D.24666 = monoeg_g_hash_table_new (mono_aligned_addr_hash, 0B);
      amodule->method_to_code = D.24666;
      amodule->blob = blob;
      {
        guint32 table_len;
        guint32 i;
        char * table;

        table = 0B;
        info.8 = info;
        table = info.8->image_table;
        D.24667 = table == 0B;
        D.24668 = (long int) D.24667;
        D.24669 = __builtin_expect (D.24668, 0);
        if (D.24669 != 0) goto <D.24670>; else goto <D.24671>;
        <D.24670>:
        monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "aot-runtime.c", 1695, "table");
        <D.24671>:
        table_len = MEM[(guint32 *)table];
        table = table + 4;
        D.24672 = table_len * 4;
        D.24673 = monoeg_malloc0 (D.24672);
        amodule->image_table = D.24673;
        D.24674 = table_len * 60;
        D.24675 = monoeg_malloc0 (D.24674);
        amodule->image_names = D.24675;
        D.24672 = table_len * 4;
        D.24676 = monoeg_malloc0 (D.24672);
        amodule->image_guids = D.24676;
        amodule->image_table_len = table_len;
        i = 0;
        goto <D.23459>;
        <D.23458>:
        {
          struct MonoAssemblyName * aname;

          D.24677 = amodule->image_names;
          D.24678 = i * 60;
          aname = D.24677 + D.24678;
          D.24679 = monoeg_strdup (table);
          aname->name = D.24679;
          D.24680 = strlen (table);
          D.24681 = D.24680 + 1;
          table = table + D.24681;
          D.24682 = amodule->image_guids;
          D.24683 = i * 4;
          D.24684 = D.24682 + D.24683;
          D.24685 = monoeg_strdup (table);
          *D.24684 = D.24685;
          D.24686 = strlen (table);
          D.24687 = D.24686 + 1;
          table = table + D.24687;
          D.24688 = *table;
          if (D.24688 != 0) goto <D.24689>; else goto <D.24690>;
          <D.24689>:
          D.24691 = monoeg_strdup (table);
          aname->culture = D.24691;
          <D.24690>:
          D.24692 = strlen (table);
          D.24693 = D.24692 + 1;
          table = table + D.24693;
          D.24694 = strlen (table);
          D.24695 = D.24694 + 1;
          D.24696 = &aname->public_key_token;
          memcpy (D.24696, table, D.24695);
          D.24697 = strlen (table);
          D.24698 = D.24697 + 1;
          table = table + D.24698;
          table.21 = (int) table;
          D.24700 = table.21 + 7;
          D.24701 = D.24700 & -8;
          table = (char *) D.24701;
          D.24702 = MEM[(guint32 *)table];
          aname->flags = D.24702;
          table = table + 4;
          D.24702 = MEM[(guint32 *)table];
          D.24703 = (short unsigned int) D.24702;
          aname->major = D.24703;
          table = table + 4;
          D.24702 = MEM[(guint32 *)table];
          D.24703 = (short unsigned int) D.24702;
          aname->minor = D.24703;
          table = table + 4;
          D.24702 = MEM[(guint32 *)table];
          D.24703 = (short unsigned int) D.24702;
          aname->build = D.24703;
          table = table + 4;
          D.24702 = MEM[(guint32 *)table];
          D.24703 = (short unsigned int) D.24702;
          aname->revision = D.24703;
          table = table + 4;
        }
        i = i + 1;
        <D.23459>:
        if (i < table_len) goto <D.23458>; else goto <D.23460>;
        <D.23460>:
      }
      info.8 = info;
      D.24704 = info.8->code_offsets;
      amodule->code_offsets = D.24704;
      info.8 = info;
      D.24705 = info.8->method_addresses;
      amodule->method_addresses = D.24705;
      info.8 = info;
      D.24706 = info.8->methods;
      amodule->code = D.24706;
      info.8 = info;
      D.24707 = info.8->methods_end;
      amodule->code_end = D.24707;
      info.8 = info;
      D.24708 = info.8->method_info_offsets;
      amodule->method_info_offsets = D.24708;
      info.8 = info;
      D.24709 = info.8->ex_info_offsets;
      amodule->ex_info_offsets = D.24709;
      info.8 = info;
      D.24710 = info.8->class_info_offsets;
      amodule->class_info_offsets = D.24710;
      info.8 = info;
      D.24711 = info.8->class_name_table;
      amodule->class_name_table = D.24711;
      info.8 = info;
      D.24712 = info.8->extra_method_table;
      amodule->extra_method_table = D.24712;
      info.8 = info;
      D.24713 = info.8->extra_method_info_offsets;
      amodule->extra_method_info_offsets = D.24713;
      info.8 = info;
      D.24714 = info.8->unbox_trampolines;
      amodule->unbox_trampolines = D.24714;
      info.8 = info;
      D.24715 = info.8->unbox_trampolines_end;
      amodule->unbox_trampolines_end = D.24715;
      info.8 = info;
      D.24716 = info.8->got_info_offsets;
      amodule->got_info_offsets = D.24716;
      info.8 = info;
      D.24717 = info.8->unwind_info;
      amodule->unwind_info = D.24717;
      info.8 = info;
      D.24718 = info.8->mem_end;
      amodule->mem_end = D.24718;
      D.24719 = amodule->code;
      amodule->mem_begin = D.24719;
      info.8 = info;
      D.24720 = info.8->plt;
      amodule->plt = D.24720;
      info.8 = info;
      D.24721 = info.8->plt_end;
      amodule->plt_end = D.24721;
      info.8 = info;
      D.24722 = info.8->mono_eh_frame;
      amodule->mono_eh_frame = D.24722;
      info.8 = info;
      D.24723 = info.8->specific_trampolines;
      amodule->trampolines[0] = D.24723;
      info.8 = info;
      D.24724 = info.8->static_rgctx_trampolines;
      amodule->trampolines[1] = D.24724;
      info.8 = info;
      D.24725 = info.8->imt_thunks;
      amodule->trampolines[2] = D.24725;
      info.8 = info;
      D.24726 = info.8->gsharedvt_arg_trampolines;
      amodule->trampolines[3] = D.24726;
      info.8 = info;
      D.24727 = info.8->thumb_end;
      amodule->thumb_end = D.24727;
      make_unreadable.22 = make_unreadable;
      if (make_unreadable.22 != 0) goto <D.24729>; else goto <D.24730>;
      <D.24729>:
      {
        guint8 * addr;
        guint8 * page_start;
        guint8 * page_end;
        int err;
        int len;

        addr = amodule->mem_begin;
        D.24731 = amodule->mem_end;
        D.24732 = (int) D.24731;
        D.24733 = amodule->mem_begin;
        D.24734 = (int) D.24733;
        len = D.24732 - D.24734;
        D.24735 = mono_pagesize ();
        D.24736 = (sizetype) D.24735;
        D.24737 = mono_pagesize ();
        D.24738 = -D.24737;
        addr.23 = (int) addr;
        D.24740 = D.24738 & addr.23;
        D.24741 = (sizetype) D.24740;
        D.24742 = D.24736 + D.24741;
        page_start = (guint8 *) D.24742;
        len.24 = (sizetype) len;
        D.24744 = addr + len.24;
        D.24745 = (int) D.24744;
        D.24746 = mono_pagesize ();
        D.24747 = -D.24746;
        D.24748 = D.24745 & D.24747;
        page_end = (guint8 *) D.24748;
        if (page_end > page_start) goto <D.24749>; else goto <D.24750>;
        <D.24749>:
        page_end.25 = (int) page_end;
        page_start.26 = (int) page_start;
        D.24753 = page_end.25 - page_start.26;
        D.24754 = (unsigned int) D.24753;
        err = mono_mprotect (page_start, D.24754, 0);
        D.24755 = err != 0;
        D.24756 = (long int) D.24755;
        D.24757 = __builtin_expect (D.24756, 0);
        if (D.24757 != 0) goto <D.24758>; else goto <D.24759>;
        <D.24758>:
        monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "aot-runtime.c", 1789, "err == 0");
        <D.24759>:
        <D.24750>:
      }
      <D.24730>:
      {
        int ret;

        ret = pthread_mutex_lock (&aot_mutex.mutex);
        if (ret != 0) goto <D.24760>; else goto <D.24761>;
        <D.24760>:
        monoeg_g_log (0B, 16, "Bad call to mono_mutex_lock result %d", ret);
        <D.24761>:
        D.24762 = ret != 0;
        D.24763 = (long int) D.24762;
        D.24764 = __builtin_expect (D.24763, 0);
        if (D.24764 != 0) goto <D.24765>; else goto <D.24766>;
        <D.24765>:
        monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "aot-runtime.c", 1794, "ret == 0");
        <D.24766>:
      }
      D.24719 = amodule->code;
      D.24767 = (unsigned int) D.24719;
      aot_code_low_addr.27 = aot_code_low_addr;
      aot_code_low_addr.28 = MIN_EXPR <D.24767, aot_code_low_addr.27>;
      aot_code_low_addr = aot_code_low_addr.28;
      D.24770 = amodule->code_end;
      D.24771 = (unsigned int) D.24770;
      aot_code_high_addr.29 = aot_code_high_addr;
      aot_code_high_addr.30 = MAX_EXPR <D.24771, 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.24775>; else goto <D.24776>;
        <D.24775>:
        monoeg_g_log (0B, 16, "Bad call to mono_mutex_unlock result %d", ret);
        <D.24776>:
        D.24777 = ret != 0;
        D.24778 = (long int) D.24777;
        D.24779 = __builtin_expect (D.24778, 0);
        if (D.24779 != 0) goto <D.24780>; else goto <D.24781>;
        <D.24780>:
        monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "aot-runtime.c", 1800, "ret == 0");
        <D.24781>:
      }
      D.24770 = amodule->code_end;
      D.24719 = amodule->code;
      D.24559 = assembly->image;
      mono_jit_info_add_aot_module (D.24559, D.24719, D.24770);
      D.24559 = assembly->image;
      D.24559->aot_module = amodule;
      mono_aot_only.14 = mono_aot_only;
      if (mono_aot_only.14 != 0) goto <D.24782>; else goto <D.24783>;
      <D.24782>:
      {
        char * code;

        try
          {
            D.24784 = amodule->globals;
            D.24785 = amodule->sofile;
            find_symbol (D.24785, D.24784, "specific_trampolines_page", &code);
            code.32 = code;
            D.24787 = code.32 != 0B;
            D.24788 = (int) D.24787;
            amodule->use_page_trampolines = D.24788;
            D.24789 = mono_defaults.corlib;
            if (D.24789 != 0B) goto <D.24790>; else goto <D.24791>;
            <D.24790>:
            {
              struct MonoAotModule * mscorlib_amodule;

              D.24789 = mono_defaults.corlib;
              mscorlib_amodule = D.24789->aot_module;
              D.24665 = amodule->got;
              D.24792 = D.24665 + 4;
              D.24793 = mscorlib_amodule->got;
              *D.24792 = D.24793;
            }
            goto <D.24794>;
            <D.24791>:
            D.24665 = amodule->got;
            D.24792 = D.24665 + 4;
            D.24665 = amodule->got;
            *D.24792 = D.24665;
            <D.24794>:
          }
        finally
          {
            code = {CLOBBER};
          }
      }
      <D.24783>:
      D.24795 = mono_gc_is_moving ();
      if (D.24795 != 0) goto <D.24796>; else goto <D.24797>;
      <D.24796>:
      {
        struct MonoJumpInfo ji;

        try
          {
            memset (&ji, 0, 20);
            ji.type = 42;
            D.24665 = amodule->got;
            D.24798 = D.24665 + 8;
            D.24799 = mono_get_root_domain ();
            D.24800 = mono_resolve_patch_target (0B, D.24799, 0B, &ji, 0);
            *D.24798 = D.24800;
          }
        finally
          {
            ji = {CLOBBER};
          }
      }
      <D.24797>:
      if (do_load_image != 0) goto <D.24801>; else goto <D.24802>;
      <D.24801>:
      i = 0;
      goto <D.23472>;
      <D.23471>:
      load_image (amodule, i, 0);
      i = i + 1;
      <D.23472>:
      i.33 = (unsigned int) i;
      D.24804 = amodule->image_table_len;
      if (i.33 < D.24804) goto <D.23471>; else goto <D.23473>;
      <D.23473>:
      <D.24802>:
      D.24805 = amodule->out_of_date;
      if (D.24805 != 0) goto <D.24806>; else goto <D.24807>;
      <D.24806>:
      D.24559 = assembly->image;
      D.24602 = D.24559->name;
      mono_trace (64, 32, "AOT Module %s is unusable because a dependency is out-of-date.\n", D.24602);
      mono_aot_only.14 = mono_aot_only;
      if (mono_aot_only.14 != 0) goto <D.24808>; else goto <D.24809>;
      <D.24808>:
      aot_name.10 = aot_name;
      stderr.15 = stderr;
      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.24809>:
      goto <D.24810>;
      <D.24807>:
      D.24559 = assembly->image;
      D.24602 = D.24559->name;
      mono_trace (64, 32, "AOT loaded AOT Module for %s.\n", D.24602);
      <D.24810>:
    }
  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.24814;
  unsigned char D.24815;
  unsigned char D.24816;
  struct MonoDl * D.24819;
  char * D.24820;
  const char * D.24821;
  char * D.24824;
  int spawn_compiler.34;
  union 
{
  gint __in;
  int __i;
} D.23358;
  int exit_status.35;
  int D.24833;
  int D.24834;
  union 
{
  gint __in;
  int __i;
} D.23362;
  int D.24836;
  int D.24837;
  int D.24838;
  gchar * err.36;
  gchar * out.37;
  int D.24843;
  unsigned int D.24844;
  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.24814 = assembly->image;
      D.24815 = BIT_FIELD_REF <*D.24814, 8, 128>;
      D.24816 = D.24815 & 8;
      if (D.24816 != 0) goto <D.24817>; else goto <D.24818>;
      <D.24817>:
      D.24819 = 0B;
      return D.24819;
      <D.24818>:
      create_cache_structure ();
      home = monoeg_g_get_home_dir ();
      D.24814 = assembly->image;
      D.24820 = D.24814->guid;
      D.24814 = assembly->image;
      D.24821 = D.24814->assembly_name;
      tmp2 = monoeg_g_strdup_printf ("%s-%s%s", D.24821, D.24820, ".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.24822>; else goto <D.24823>;
      <D.24822>:
      mono_trace (64, 32, "AOT not found.");
      D.24814 = assembly->image;
      D.24824 = D.24814->name;
      mono_trace (32, 32, "AOT precompiling assembly \'%s\'... ", D.24824);
      aot_options = monoeg_g_strdup_printf ("outfile=%s", fname);
      spawn_compiler.34 = spawn_compiler;
      if (spawn_compiler.34 != 0) goto <D.24826>; else goto <D.24827>;
      <D.24826>:
      D.24814 = assembly->image;
      D.24824 = D.24814->name;
      cmd = monoeg_g_strdup_printf ("mono -O=all --aot=%s %s", aot_options, D.24824);
      res = monoeg_g_spawn_command_line_sync (cmd, &out, &err, &exit_status, 0B);
      if (res != 0) goto <D.24828>; else goto <D.24829>;
      <D.24828>:
      {
        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.23358.__in = exit_status.35;
        D.24833 = D.23358.__i;
        D.24834 = D.24833 & 127;
        if (D.24834 != 0) goto <D.24835>; else goto <D.24830>;
        <D.24835>:
        exit_status.35 = exit_status;
        D.23362.__in = exit_status.35;
        D.24836 = D.23362.__i;
        D.24837 = D.24836 & 65280;
        D.24838 = D.24837 >> 8;
        if (D.24838 == 0) goto <D.24839>; else goto <D.24830>;
        <D.24839>:
        err.36 = err;
        mono_trace (32, 32, "AOT failed: %s.", err.36);
        goto <D.24831>;
        <D.24830>:
        mono_trace (32, 32, "AOT succeeded.");
        <D.24831>:
        out.37 = out;
        monoeg_g_free (out.37);
        err.36 = err;
        monoeg_g_free (err.36);
      }
      <D.24829>:
      monoeg_g_free (cmd);
      goto <D.24842>;
      <D.24827>:
      D.24843 = mono_parse_default_optimizations (0B);
      D.24844 = (unsigned int) D.24843;
      res = mono_compile_assembly (assembly, D.24844, aot_options);
      if (res == 0) goto <D.24845>; else goto <D.24846>;
      <D.24845>:
      mono_trace (32, 32, "AOT failed.");
      goto <D.24847>;
      <D.24846>:
      mono_trace (32, 32, "AOT succeeded.");
      <D.24847>:
      <D.24842>:
      module = mono_dl_open (fname, 1, 0B);
      monoeg_g_free (aot_options);
      <D.24823>:
      D.24819 = module;
      return D.24819;
    }
  finally
    {
      out = {CLOBBER};
      err = {CLOBBER};
      exit_status = {CLOBBER};
    }
}


create_cache_structure ()
{
  int D.24852;
  int * D.24857;
  int D.24858;
  const gchar * D.24859;
  int D.24860;
  const gchar * D.24865;
  const char * home;
  char * tmp;
  int err;

  home = monoeg_g_get_home_dir ();
  if (home == 0B) goto <D.24850>; else goto <D.24851>;
  <D.24850>:
  return;
  <D.24851>:
  tmp = monoeg_g_build_path ("/", home, ".mono", 0B);
  D.24852 = monoeg_g_file_test (tmp, 4);
  if (D.24852 == 0) goto <D.24853>; else goto <D.24854>;
  <D.24853>:
  mono_trace (64, 32, "AOT creating directory %s", tmp);
  err = mkdir (tmp, 511);
  if (err != 0) goto <D.24855>; else goto <D.24856>;
  <D.24855>:
  D.24857 = __errno_location ();
  D.24858 = *D.24857;
  D.24859 = monoeg_g_strerror (D.24858);
  mono_trace (64, 32, "AOT failed: %s", D.24859);
  monoeg_g_free (tmp);
  return;
  <D.24856>:
  <D.24854>:
  monoeg_g_free (tmp);
  tmp = monoeg_g_build_path ("/", home, ".mono", "aot-cache", 0B);
  D.24860 = monoeg_g_file_test (tmp, 4);
  if (D.24860 == 0) goto <D.24861>; else goto <D.24862>;
  <D.24861>:
  mono_trace (64, 32, "AOT creating directory %s", tmp);
  err = mkdir (tmp, 511);
  if (err != 0) goto <D.24863>; else goto <D.24864>;
  <D.24863>:
  D.24857 = __errno_location ();
  D.24858 = *D.24857;
  D.24865 = monoeg_g_strerror (D.24858);
  mono_trace (64, 32, "AOT failed: %s", D.24865);
  monoeg_g_free (tmp);
  return;
  <D.24864>:
  <D.24862>:
  monoeg_g_free (tmp);
}


check_usable (struct MonoAssembly * assembly, struct MonoAotFileInfo * info, char * * out_msg)
{
  int D.23409;
  void * D.24867;
  struct MonoImage * D.24868;
  char * D.24869;
  void * D.24872;
  char D.24873;
  int D.23418;
  unsigned int D.24878;
  int D.24879;
  int mono_aot_only.38;
  struct MonoDebugOptions * D.24889;
  int D.24890;
  unsigned int D.24893;
  unsigned int D.24898;
  unsigned int excluded_cpu_optimizations.39;
  unsigned int D.24900;
  unsigned int D.24905;
  unsigned int D.24906;
  unsigned int D.24907;
  unsigned int D.24908;
  int D.24911;
  sizetype D.24914;
  int D.23429;
  gboolean D.24917;
  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.24867 = info->assembly_guid;
        D.24868 = assembly->image;
        D.24869 = D.24868->guid;
        D.23409 = __builtin_strcmp (D.24869, D.24867);
      }
      if (D.23409 != 0) goto <D.24870>; else goto <D.24871>;
      <D.24870>:
      msg = monoeg_g_strdup_printf ("doesn\'t match assembly");
      usable = 0;
      <D.24871>:
      build_info = mono_get_runtime_build_info ();
      D.24872 = info->runtime_version;
      D.24873 = MEM[(const char *)D.24872];
      if (D.24873 != 0) goto <D.24874>; else goto <D.24875>;
      <D.24874>:
      {
        size_t __s1_len;
        size_t __s2_len;

        D.24872 = info->runtime_version;
        D.23418 = __builtin_strcmp (D.24872, build_info);
      }
      if (D.23418 != 0) goto <D.24876>; else goto <D.24877>;
      <D.24876>:
      D.24872 = info->runtime_version;
      msg = monoeg_g_strdup_printf ("compiled against runtime version \'%s\' while this runtime has version \'%s\'", D.24872, build_info);
      usable = 0;
      <D.24877>:
      <D.24875>:
      monoeg_g_free (build_info);
      D.24878 = info->flags;
      D.24879 = (int) D.24878;
      full_aot = D.24879 & 2;
      mono_aot_only.38 = mono_aot_only;
      if (mono_aot_only.38 != 0) goto <D.24881>; else goto <D.24882>;
      <D.24881>:
      if (full_aot == 0) goto <D.24883>; else goto <D.24884>;
      <D.24883>:
      msg = monoeg_g_strdup_printf ("not compiled with --aot=full");
      usable = 0;
      <D.24884>:
      <D.24882>:
      mono_aot_only.38 = mono_aot_only;
      if (mono_aot_only.38 == 0) goto <D.24885>; else goto <D.24886>;
      <D.24885>:
      if (full_aot != 0) goto <D.24887>; else goto <D.24888>;
      <D.24887>:
      msg = monoeg_g_strdup_printf ("compiled with --aot=full");
      usable = 0;
      <D.24888>:
      <D.24886>:
      D.24889 = mini_get_debug_options ();
      D.24890 = D.24889->mdb_optimizations;
      if (D.24890 != 0) goto <D.24891>; else goto <D.24892>;
      <D.24891>:
      D.24878 = info->flags;
      D.24893 = D.24878 & 4;
      if (D.24893 == 0) goto <D.24894>; else goto <D.24895>;
      <D.24894>:
      if (full_aot == 0) goto <D.24896>; else goto <D.24897>;
      <D.24896>:
      msg = monoeg_g_strdup_printf ("not compiled for debugging");
      usable = 0;
      <D.24897>:
      <D.24895>:
      <D.24892>:
      mono_arch_cpu_optimizations (&excluded_cpu_optimizations);
      D.24898 = info->opts;
      excluded_cpu_optimizations.39 = excluded_cpu_optimizations;
      D.24900 = D.24898 & excluded_cpu_optimizations.39;
      if (D.24900 != 0) goto <D.24901>; else goto <D.24902>;
      <D.24901>:
      msg = monoeg_g_strdup_printf ("compiled with unsupported CPU optimizations");
      usable = 0;
      <D.24902>:
      mono_aot_only.38 = mono_aot_only;
      if (mono_aot_only.38 == 0) goto <D.24903>; else goto <D.24904>;
      <D.24903>:
      D.24905 = info->simd_opts;
      D.24906 = mono_arch_cpu_enumerate_simd_versions ();
      D.24907 = ~D.24906;
      D.24908 = D.24905 & D.24907;
      if (D.24908 != 0) goto <D.24909>; else goto <D.24910>;
      <D.24909>:
      msg = monoeg_g_strdup_printf ("compiled with unsupported SIMD extensions");
      usable = 0;
      <D.24910>:
      <D.24904>:
      blob = info->blob;
      D.24911 = info->gc_name_index;
      if (D.24911 != -1) goto <D.24912>; else goto <D.24913>;
      <D.24912>:
      {
        char * gc_name;
        const char * current_gc_name;

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

          D.23429 = __builtin_strcmp (current_gc_name, gc_name);
        }
        if (D.23429 != 0) goto <D.24915>; else goto <D.24916>;
        <D.24915>:
        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.24916>:
      }
      <D.24913>:
      *out_msg = msg;
      D.24917 = usable;
      return D.24917;
    }
  finally
    {
      excluded_cpu_optimizations = {CLOBBER};
    }
}


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

  if (str != 0B) goto <D.24920>; else goto <D.24921>;
  <D.24920>:
  D.24922 = __strdup (str);
  return D.24922;
  <D.24921>:
  D.24922 = 0B;
  return D.24922;
}


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

  D.24925 = __builtin_object_size (__dest, 0);
  D.24924 = __builtin___memcpy_chk (__dest, __src, __len, D.24925);
  return D.24924;
}


find_symbol (struct MonoDl * module, void * * globals, const char * name, void * * value)
{
  unsigned int D.24929;
  unsigned int D.24930;
  unsigned int D.24931;
  short unsigned int D.24932;
  int D.24933;
  int D.24934;
  guint16 * D.24935;
  short unsigned int D.24936;
  int D.23385;
  unsigned int D.24937;
  void * * D.24938;
  void * D.24939;
  unsigned int D.24943;
  sizetype global_index.40;
  sizetype D.24947;
  sizetype D.24948;
  void * * D.24949;
  void * D.24950;

  if (globals != 0B) goto <D.24927>; else goto <D.24928>;
  <D.24927>:
  {
    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.24929 = mono_metadata_str_hash (symbol);
    D.24930 = (unsigned int) table_size;
    hash = D.24929 % D.24930;
    D.24931 = hash * 4;
    entry = table + D.24931;
    global_index = -1;
    goto <D.23388>;
    <D.23387>:
    {
      guint32 index;
      guint32 next;

      D.24932 = *entry;
      D.24933 = (int) D.24932;
      D.24934 = D.24933 + -1;
      index = (guint32) D.24934;
      D.24935 = entry + 2;
      D.24936 = *D.24935;
      next = (guint32) D.24936;
      {
        size_t __s1_len;
        size_t __s2_len;

        D.24937 = index * 8;
        D.24938 = globals + D.24937;
        D.24939 = *D.24938;
        D.23385 = __builtin_strcmp (D.24939, symbol);
      }
      if (D.23385 == 0) goto <D.24940>; else goto <D.24941>;
      <D.24940>:
      global_index = (int) index;
      goto <D.23386>;
      <D.24941>:
      if (next != 0) goto <D.24942>; else goto <D.23386>;
      <D.24942>:
      D.24943 = next * 4;
      entry = table + D.24943;
    }
    <D.23388>:
    D.24932 = *entry;
    if (D.24932 != 0) goto <D.23387>; else goto <D.23386>;
    <D.23386>:
    if (global_index != -1) goto <D.24944>; else goto <D.24945>;
    <D.24944>:
    global_index.40 = (sizetype) global_index;
    D.24947 = global_index.40 * 8;
    D.24948 = D.24947 + 4;
    D.24949 = globals + D.24948;
    D.24950 = *D.24949;
    *value = D.24950;
    goto <D.24951>;
    <D.24945>:
    *value = 0B;
    <D.24951>:
    if (symbol != name) goto <D.24952>; else goto <D.24953>;
    <D.24952>:
    monoeg_g_free (symbol);
    <D.24953>:
  }
  goto <D.24954>;
  <D.24928>:
  {
    char * err;

    err = mono_dl_symbol (module, name, value);
    if (err != 0B) goto <D.24955>; else goto <D.24956>;
    <D.24955>:
    monoeg_g_free (err);
    <D.24956>:
  }
  <D.24954>:
}


memset (void * __dest, int __ch, size_t __len)
{
  int D.24959;
  int D.24964;
  void * D.24966;
  unsigned int D.24967;

  D.24959 = __builtin_constant_p (__len);
  if (D.24959 != 0) goto <D.24960>; else goto <D.24961>;
  <D.24960>:
  if (__len == 0) goto <D.24962>; else goto <D.24963>;
  <D.24962>:
  D.24964 = __builtin_constant_p (__ch);
  if (D.24964 == 0) goto <D.24957>; else goto <D.24965>;
  <D.24965>:
  if (__ch != 0) goto <D.24957>; else goto <D.24958>;
  <D.24957>:
  __warn_memset_zero_len ();
  D.24966 = __dest;
  return D.24966;
  <D.24958>:
  <D.24963>:
  <D.24961>:
  D.24967 = __builtin_object_size (__dest, 0);
  D.24966 = __builtin___memset_chk (__dest, __ch, __len, D.24967);
  return D.24966;
}


load_image (struct MonoAotModule * amodule, int index, gboolean set_error)
{
  unsigned int index.41;
  unsigned int D.24970;
  _Bool D.24971;
  long int D.24972;
  long int D.24973;
  struct MonoImage * * D.24976;
  unsigned int index.42;
  unsigned int D.24978;
  struct MonoImage * * D.24979;
  struct MonoImage * D.24980;
  struct MonoImage * D.24983;
  int D.24984;
  struct MonoAssembly * D.24987;
  char * D.24988;
  struct MonoAssemblyName * D.24989;
  unsigned int D.24990;
  struct MonoAssemblyName * D.24991;
  const char * D.24994;
  char * D.24995;
  int D.22996;
  char * * D.24998;
  char * * D.24999;
  char * D.25000;
  struct MonoImage * D.25001;
  char * D.25002;
  struct MonoAssembly * assembly;
  MonoImageOpenStatus status;

  try
    {
      index.41 = (unsigned int) index;
      D.24970 = amodule->image_table_len;
      D.24971 = index.41 >= D.24970;
      D.24972 = (long int) D.24971;
      D.24973 = __builtin_expect (D.24972, 0);
      if (D.24973 != 0) goto <D.24974>; else goto <D.24975>;
      <D.24974>:
      monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "aot-runtime.c", 223, "index < amodule->image_table_len");
      <D.24975>:
      D.24976 = amodule->image_table;
      index.42 = (unsigned int) index;
      D.24978 = index.42 * 4;
      D.24979 = D.24976 + D.24978;
      D.24980 = *D.24979;
      if (D.24980 != 0B) goto <D.24981>; else goto <D.24982>;
      <D.24981>:
      D.24976 = amodule->image_table;
      index.42 = (unsigned int) index;
      D.24978 = index.42 * 4;
      D.24979 = D.24976 + D.24978;
      D.24983 = *D.24979;
      return D.24983;
      <D.24982>:
      D.24984 = amodule->out_of_date;
      if (D.24984 != 0) goto <D.24985>; else goto <D.24986>;
      <D.24985>:
      D.24983 = 0B;
      return D.24983;
      <D.24986>:
      D.24987 = amodule->assembly;
      D.24988 = D.24987->basedir;
      D.24989 = amodule->image_names;
      index.42 = (unsigned int) index;
      D.24990 = index.42 * 60;
      D.24991 = D.24989 + D.24990;
      assembly = mono_assembly_load (D.24991, D.24988, &status);
      if (assembly == 0B) goto <D.24992>; else goto <D.24993>;
      <D.24992>:
      D.24989 = amodule->image_names;
      index.42 = (unsigned int) index;
      D.24990 = index.42 * 60;
      D.24991 = D.24989 + D.24990;
      D.24994 = D.24991->name;
      D.24995 = amodule->aot_name;
      mono_trace (64, 32, "AOT module %s is unusable because dependency %s is not found.\n", D.24995, D.24994);
      amodule->out_of_date = 1;
      if (set_error != 0) goto <D.24996>; else goto <D.24997>;
      <D.24996>:
      {
        char * full_name;

        D.24989 = amodule->image_names;
        index.42 = (unsigned int) index;
        D.24990 = index.42 * 60;
        D.24991 = D.24989 + D.24990;
        full_name = mono_stringify_assembly_name (D.24991);
        mono_loader_set_error_assembly_load (full_name, 0);
        monoeg_g_free (full_name);
      }
      <D.24997>:
      D.24983 = 0B;
      return D.24983;
      <D.24993>:
      {
        size_t __s1_len;
        size_t __s2_len;

        D.24998 = amodule->image_guids;
        index.42 = (unsigned int) index;
        D.24978 = index.42 * 4;
        D.24999 = D.24998 + D.24978;
        D.25000 = *D.24999;
        D.25001 = assembly->image;
        D.25002 = D.25001->guid;
        D.22996 = __builtin_strcmp (D.25002, D.25000);
      }
      if (D.22996 != 0) goto <D.25003>; else goto <D.25004>;
      <D.25003>:
      D.25001 = assembly->image;
      D.25002 = D.25001->guid;
      D.24998 = amodule->image_guids;
      index.42 = (unsigned int) index;
      D.24978 = index.42 * 4;
      D.24999 = D.24998 + D.24978;
      D.25000 = *D.24999;
      D.24989 = amodule->image_names;
      index.42 = (unsigned int) index;
      D.24990 = index.42 * 60;
      D.24991 = D.24989 + D.24990;
      D.24994 = D.24991->name;
      D.24995 = amodule->aot_name;
      mono_trace (64, 32, "AOT module %s is unusable (GUID of dependent assembly %s doesn\'t match (expected \'%s\', got \'%s\').\n", D.24995, D.24994, D.25000, D.25002);
      amodule->out_of_date = 1;
      D.24983 = 0B;
      return D.24983;
      <D.25004>:
      D.24976 = amodule->image_table;
      index.42 = (unsigned int) index;
      D.24978 = index.42 * 4;
      D.24979 = D.24976 + D.24978;
      D.25001 = assembly->image;
      *D.24979 = D.25001;
      D.24983 = assembly->image;
      return D.24983;
    }
  finally
    {
      status = {CLOBBER};
    }
}


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

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


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

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


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.25012>; else goto <D.25013>;
  <D.25012>:
  aot_jit_icall_hash.43 = aot_jit_icall_hash;
  monoeg_g_hash_table_destroy (aot_jit_icall_hash.43);
  <D.25013>:
  aot_modules.44 = aot_modules;
  if (aot_modules.44 != 0B) goto <D.25015>; else goto <D.25016>;
  <D.25015>:
  aot_modules.44 = aot_modules;
  monoeg_g_hash_table_destroy (aot_modules.44);
  <D.25016>:
}


mono_aot_get_method_from_vt_slot (struct MonoDomain * domain, struct MonoVTable * vtable, int slot)
{
  struct MonoImage * D.25017;
  unsigned int D.25020;
  unsigned int D.25021;
  unsigned char D.25023;
  unsigned char D.25026;
  void * D.25028;
  guint8 * D.25029;
  unsigned int D.25030;
  unsigned int D.25031;
  unsigned int D.25032;
  int D.25033;
  guint32 * D.25034;
  unsigned int D.25035;
  guint8 * p.45;
  int D.25041;
  unsigned int D.25046;
  unsigned int D.25047;
  unsigned int D.25049;
  struct MonoImage * D.25050;
  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.25017 = klass->image;
      amodule = D.25017->aot_module;
      D.25020 = klass->flags;
      D.25021 = D.25020 & 32;
      if (D.25021 != 0) goto <D.25018>; else goto <D.25022>;
      <D.25022>:
      D.25023 = klass->byval_arg.type;
      if (D.25023 == 19) goto <D.25018>; else goto <D.25024>;
      <D.25024>:
      D.25023 = klass->byval_arg.type;
      if (D.25023 == 30) goto <D.25018>; else goto <D.25025>;
      <D.25025>:
      D.25026 = klass->rank;
      if (D.25026 != 0) goto <D.25018>; else goto <D.25027>;
      <D.25027>:
      if (amodule == 0B) goto <D.25018>; else goto <D.25019>;
      <D.25018>:
      D.25028 = 0B;
      return D.25028;
      <D.25019>:
      D.25029 = amodule->blob;
      D.25030 = klass->type_token;
      D.25031 = D.25030 & 16777215;
      D.25032 = D.25031 + 4294967295;
      D.25033 = (int) D.25032;
      D.25034 = amodule->class_info_offsets;
      D.25035 = mono_aot_get_offset (D.25034, D.25033);
      info = D.25029 + D.25035;
      p = info;
      p.45 = p;
      err = decode_cached_class_info (amodule, &class_info, p.45, &p);
      if (err == 0) goto <D.25037>; else goto <D.25038>;
      <D.25037>:
      D.25028 = 0B;
      return D.25028;
      <D.25038>:
      i = 0;
      goto <D.23515>;
      <D.23514>:
      p.45 = p;
      decode_method_ref (amodule, &ref, p.45, &p);
      i = i + 1;
      <D.23515>:
      if (i < slot) goto <D.23514>; else goto <D.23516>;
      <D.23516>:
      p.45 = p;
      res = decode_method_ref (amodule, &ref, p.45, &p);
      if (res == 0) goto <D.25039>; else goto <D.25040>;
      <D.25039>:
      D.25028 = 0B;
      return D.25028;
      <D.25040>:
      D.25041 = ref.no_aot_trampoline;
      if (D.25041 != 0) goto <D.25042>; else goto <D.25043>;
      <D.25042>:
      D.25028 = 0B;
      return D.25028;
      <D.25043>:
      D.25046 = ref.token;
      D.25047 = D.25046 & 16777215;
      if (D.25047 == 0) goto <D.25044>; else goto <D.25048>;
      <D.25048>:
      D.25046 = ref.token;
      D.25049 = D.25046 >> 24;
      if (D.25049 != 6) goto <D.25044>; else goto <D.25045>;
      <D.25044>:
      D.25028 = 0B;
      return D.25028;
      <D.25045>:
      D.25046 = ref.token;
      D.25050 = ref.image;
      D.25028 = mono_aot_get_method_from_token (domain, D.25050, D.25046);
      return D.25028;
    }
  finally
    {
      p = {CLOBBER};
      class_info = {CLOBBER};
      ref = {CLOBBER};
    }
}


mono_aot_get_offset (guint32 * table, int index)
{
  unsigned int D.25053;
  guint32 * D.25054;
  unsigned int D.25055;
  guint32 * D.25056;
  unsigned int D.25057;
  guint32 * D.25058;
  unsigned int D.25059;
  unsigned int ngroups.46;
  unsigned int D.25063;
  unsigned int group.47;
  unsigned int D.25065;
  guint16 * D.25066;
  short unsigned int D.25067;
  sizetype D.25068;
  guint8 * p.48;
  unsigned int D.25071;
  unsigned int D.25072;
  guint32 * D.25073;
  unsigned int D.25074;
  guint8 * p.49;
  guint8 * p.50;
  int D.25077;
  int D.25078;
  guint32 D.25079;
  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.25053 = *table;
      noffsets = (int) D.25053;
      D.25054 = table + 4;
      D.25055 = *D.25054;
      group_size = (int) D.25055;
      D.25056 = table + 8;
      D.25057 = *D.25056;
      ngroups = (int) D.25057;
      D.25058 = table + 12;
      D.25059 = *D.25058;
      index_entry_size = (int) D.25059;
      group = index / group_size;
      if (index_entry_size == 2) goto <D.25060>; else goto <D.25061>;
      <D.25060>:
      index16 = table + 16;
      ngroups.46 = (unsigned int) ngroups;
      D.25063 = ngroups.46 * 2;
      data_start = index16 + D.25063;
      group.47 = (unsigned int) group;
      D.25065 = group.47 * 2;
      D.25066 = index16 + D.25065;
      D.25067 = *D.25066;
      D.25068 = (sizetype) D.25067;
      p.48 = data_start + D.25068;
      p = p.48;
      goto <D.25070>;
      <D.25061>:
      index32 = table + 16;
      ngroups.46 = (unsigned int) ngroups;
      D.25071 = ngroups.46 * 4;
      data_start = index32 + D.25071;
      group.47 = (unsigned int) group;
      D.25072 = group.47 * 4;
      D.25073 = index32 + D.25072;
      D.25074 = *D.25073;
      p.49 = data_start + D.25074;
      p = p.49;
      <D.25070>:
      p.50 = p;
      start_offset = decode_value (p.50, &p);
      offset = start_offset;
      D.25077 = group * group_size;
      i = D.25077 + 1;
      goto <D.23020>;
      <D.23019>:
      p.50 = p;
      D.25078 = decode_value (p.50, &p);
      offset = D.25078 + offset;
      i = i + 1;
      <D.23020>:
      if (i <= index) goto <D.23019>; else goto <D.23021>;
      <D.23021>:
      D.25079 = (guint32) offset;
      return D.25079;
    }
  finally
    {
      p = {CLOBBER};
    }
}


decode_value (guint8 * ptr, guint8 * * rptr)
{
  signed char b.51;
  int D.25086;
  int D.25087;
  int D.25090;
  int D.25091;
  guint8 * D.25092;
  unsigned char D.25093;
  int D.25094;
  int D.25098;
  int D.25099;
  int D.25100;
  int D.25101;
  guint8 * D.25102;
  unsigned char D.25103;
  int D.25104;
  int D.25105;
  int D.25106;
  guint8 * D.25107;
  unsigned char D.25108;
  int D.25109;
  int D.25111;
  int D.25112;
  int D.25113;
  int D.25114;
  int D.25115;
  guint8 * D.25116;
  unsigned char D.25117;
  int D.25118;
  gint32 D.25121;
  guint8 b;
  gint32 len;

  b = *ptr;
  b.51 = (signed char) b;
  if (b.51 >= 0) goto <D.25083>; else goto <D.25084>;
  <D.25083>:
  len = (gint32) b;
  ptr = ptr + 1;
  goto <D.25085>;
  <D.25084>:
  D.25086 = (int) b;
  D.25087 = D.25086 & 64;
  if (D.25087 == 0) goto <D.25088>; else goto <D.25089>;
  <D.25088>:
  D.25086 = (int) b;
  D.25090 = D.25086 & 63;
  D.25091 = D.25090 << 8;
  D.25092 = ptr + 1;
  D.25093 = *D.25092;
  D.25094 = (int) D.25093;
  len = D.25091 | D.25094;
  ptr = ptr + 2;
  goto <D.25095>;
  <D.25089>:
  if (b != 255) goto <D.25096>; else goto <D.25097>;
  <D.25096>:
  D.25086 = (int) b;
  D.25098 = D.25086 & 31;
  D.25099 = D.25098 << 24;
  D.25092 = ptr + 1;
  D.25093 = *D.25092;
  D.25094 = (int) D.25093;
  D.25100 = D.25094 << 16;
  D.25101 = D.25099 | D.25100;
  D.25102 = ptr + 2;
  D.25103 = *D.25102;
  D.25104 = (int) D.25103;
  D.25105 = D.25104 << 8;
  D.25106 = D.25101 | D.25105;
  D.25107 = ptr + 3;
  D.25108 = *D.25107;
  D.25109 = (int) D.25108;
  len = D.25106 | D.25109;
  ptr = ptr + 4;
  goto <D.25110>;
  <D.25097>:
  D.25092 = ptr + 1;
  D.25093 = *D.25092;
  D.25094 = (int) D.25093;
  D.25111 = D.25094 << 24;
  D.25102 = ptr + 2;
  D.25103 = *D.25102;
  D.25104 = (int) D.25103;
  D.25112 = D.25104 << 16;
  D.25113 = D.25111 | D.25112;
  D.25107 = ptr + 3;
  D.25108 = *D.25107;
  D.25109 = (int) D.25108;
  D.25114 = D.25109 << 8;
  D.25115 = D.25113 | D.25114;
  D.25116 = ptr + 4;
  D.25117 = *D.25116;
  D.25118 = (int) D.25117;
  len = D.25115 | D.25118;
  ptr = ptr + 5;
  <D.25110>:
  <D.25095>:
  <D.25085>:
  if (rptr != 0B) goto <D.25119>; else goto <D.25120>;
  <D.25119>:
  *rptr = ptr;
  <D.25120>:
  D.25121 = len;
  return D.25121;
}


decode_cached_class_info (struct MonoAotModule * module, struct MonoCachedClassInfo * info, guint8 * buf, guint8 * * endbuf)
{
  guint8 * buf.52;
  int D.25124;
  unsigned int D.25125;
  unsigned int D.25126;
  gboolean D.25129;
  int D.25130;
  unsigned char D.25131;
  <unnamed-unsigned:1> D.25132;
  unsigned int D.25133;
  unsigned char D.25134;
  <unnamed-unsigned:1> D.25135;
  unsigned int D.25136;
  unsigned char D.25137;
  <unnamed-unsigned:1> D.25138;
  unsigned int D.25139;
  unsigned char D.25140;
  <unnamed-unsigned:1> D.25141;
  unsigned int D.25142;
  unsigned char D.25143;
  <unnamed-unsigned:1> D.25144;
  unsigned int D.25145;
  unsigned char D.25146;
  <unnamed-unsigned:1> D.25147;
  unsigned int D.25148;
  unsigned char D.25149;
  <unnamed-unsigned:1> D.25150;
  unsigned int D.25151;
  unsigned char D.25152;
  <unnamed-unsigned:1> D.25153;
  unsigned int D.25154;
  unsigned char D.25155;
  <unnamed-unsigned:1> D.25156;
  unsigned char D.25157;
  unsigned char D.25158;
  unsigned int D.25163;
  unsigned char D.25164;
  struct MonoImage * D.25169;
  int D.25170;
  unsigned int D.25171;
  int D.25172;
  unsigned int D.25173;
  int D.25174;
  unsigned int D.25175;
  int D.25176;
  unsigned int D.25177;
  guint32 flags;
  struct MethodRef ref;
  gboolean res;

  try
    {
      buf.52 = buf;
      D.25124 = decode_value (buf.52, &buf);
      D.25125 = (unsigned int) D.25124;
      info->vtable_size = D.25125;
      D.25126 = info->vtable_size;
      if (D.25126 == 4294967295) goto <D.25127>; else goto <D.25128>;
      <D.25127>:
      D.25129 = 0;
      return D.25129;
      <D.25128>:
      buf.52 = buf;
      D.25130 = decode_value (buf.52, &buf);
      flags = (guint32) D.25130;
      D.25131 = (unsigned char) flags;
      D.25132 = (<unnamed-unsigned:1>) D.25131;
      info->ghcimpl = D.25132;
      D.25133 = flags >> 1;
      D.25134 = (unsigned char) D.25133;
      D.25135 = (<unnamed-unsigned:1>) D.25134;
      info->has_finalize = D.25135;
      D.25136 = flags >> 2;
      D.25137 = (unsigned char) D.25136;
      D.25138 = (<unnamed-unsigned:1>) D.25137;
      info->has_cctor = D.25138;
      D.25139 = flags >> 3;
      D.25140 = (unsigned char) D.25139;
      D.25141 = (<unnamed-unsigned:1>) D.25140;
      info->has_nested_classes = D.25141;
      D.25142 = flags >> 4;
      D.25143 = (unsigned char) D.25142;
      D.25144 = (<unnamed-unsigned:1>) D.25143;
      info->blittable = D.25144;
      D.25145 = flags >> 5;
      D.25146 = (unsigned char) D.25145;
      D.25147 = (<unnamed-unsigned:1>) D.25146;
      info->has_references = D.25147;
      D.25148 = flags >> 6;
      D.25149 = (unsigned char) D.25148;
      D.25150 = (<unnamed-unsigned:1>) D.25149;
      info->has_static_refs = D.25150;
      D.25151 = flags >> 7;
      D.25152 = (unsigned char) D.25151;
      D.25153 = (<unnamed-unsigned:1>) D.25152;
      info->no_special_static_fields = D.25153;
      D.25154 = flags >> 8;
      D.25155 = (unsigned char) D.25154;
      D.25156 = (<unnamed-unsigned:1>) D.25155;
      info->is_generic_container = D.25156;
      D.25157 = BIT_FIELD_REF <*info, 8, 32>;
      D.25158 = D.25157 & 4;
      if (D.25158 != 0) goto <D.25159>; else goto <D.25160>;
      <D.25159>:
      buf.52 = buf;
      res = decode_method_ref (module, &ref, buf.52, &buf);
      if (res == 0) goto <D.25161>; else goto <D.25162>;
      <D.25161>:
      D.25129 = 0;
      return D.25129;
      <D.25162>:
      D.25163 = ref.token;
      info->cctor_token = D.25163;
      <D.25160>:
      D.25157 = BIT_FIELD_REF <*info, 8, 32>;
      D.25164 = D.25157 & 1;
      if (D.25164 != 0) goto <D.25165>; else goto <D.25166>;
      <D.25165>:
      buf.52 = buf;
      res = decode_method_ref (module, &ref, buf.52, &buf);
      if (res == 0) goto <D.25167>; else goto <D.25168>;
      <D.25167>:
      D.25129 = 0;
      return D.25129;
      <D.25168>:
      D.25169 = ref.image;
      info->finalize_image = D.25169;
      D.25163 = ref.token;
      info->finalize_token = D.25163;
      <D.25166>:
      buf.52 = buf;
      D.25170 = decode_value (buf.52, &buf);
      D.25171 = (unsigned int) D.25170;
      info->instance_size = D.25171;
      buf.52 = buf;
      D.25172 = decode_value (buf.52, &buf);
      D.25173 = (unsigned int) D.25172;
      info->class_size = D.25173;
      buf.52 = buf;
      D.25174 = decode_value (buf.52, &buf);
      D.25175 = (unsigned int) D.25174;
      info->packing_size = D.25175;
      buf.52 = buf;
      D.25176 = decode_value (buf.52, &buf);
      D.25177 = (unsigned int) D.25176;
      info->min_align = D.25177;
      buf.52 = buf;
      *endbuf = buf.52;
      D.25129 = 1;
      return D.25129;
    }
  finally
    {
      ref = {CLOBBER};
    }
}


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

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


decode_method_ref_with_target (struct MonoAotModule * module, struct MethodRef * ref, struct MonoMethod * target, guint8 * buf, guint8 * * endbuf)
{
  guint8 * p.53;
  int D.25183;
  int D.25186;
  _Bool D.25189;
  _Bool D.25190;
  _Bool D.25191;
  unsigned char D.25195;
  unsigned char D.25196;
  gboolean D.25199;
  int D.25202;
  <unnamed-unsigned:5> D.25205;
  unsigned int D.25206;
  struct MonoClass * D.25211;
  struct MonoMethod * D.25212;
  struct MonoMethod * D.25215;
  struct MonoType * D.25220;
  struct MonoMethod * D.25221;
  struct MonoMethod * D.25225;
  struct MonoMethod * D.25229;
  struct MonoMethod * D.25233;
  struct MonoMethod * D.25235;
  struct MonoMethod * D.25236;
  struct MonoMethod * D.25237;
  struct MonoMethod * D.25238;
  _Bool D.25239;
  long int D.25240;
  long int D.25241;
  struct MonoMethod * D.25244;
  struct MonoMethod * D.25247;
  _Bool D.25255;
  long int D.25256;
  long int D.25257;
  <unnamed type> D.25262;
  unsigned int subtype.54;
  int D.25265;
  struct MonoMethod * D.25271;
  unsigned int subtype.55;
  unsigned int D.25273;
  struct MonoClass * D.25280;
  int D.23239;
  int iftmp.56;
  int D.23238;
  const char[15] * D.25288;
  unsigned char D.25289;
  int D.25290;
  unsigned char D.25291;
  int D.25292;
  _Bool D.25293;
  _Bool D.25294;
  _Bool D.25295;
  const unsigned char * D.25298;
  unsigned char D.25299;
  int D.25300;
  const unsigned char * D.25301;
  unsigned char D.25302;
  int D.25303;
  _Bool D.25304;
  _Bool D.25305;
  const unsigned char * D.25308;
  unsigned char D.25309;
  int D.25310;
  const unsigned char * D.25311;
  unsigned char D.25312;
  int D.25313;
  _Bool D.25314;
  _Bool D.25315;
  const unsigned char * D.25318;
  unsigned char D.25319;
  int D.25320;
  const unsigned char * D.25321;
  unsigned char D.25322;
  int D.25323;
  const char * D.25325;
  struct MonoMethod * D.25328;
  int D.23248;
  int iftmp.57;
  int D.23247;
  const char[15] * D.25333;
  unsigned char D.25334;
  int D.25335;
  unsigned char D.25336;
  int D.25337;
  _Bool D.25338;
  _Bool D.25339;
  _Bool D.25340;
  const unsigned char * D.25343;
  unsigned char D.25344;
  int D.25345;
  const unsigned char * D.25346;
  unsigned char D.25347;
  int D.25348;
  _Bool D.25349;
  _Bool D.25350;
  const unsigned char * D.25353;
  unsigned char D.25354;
  int D.25355;
  const unsigned char * D.25356;
  unsigned char D.25357;
  int D.25358;
  _Bool D.25359;
  _Bool D.25360;
  const unsigned char * D.25363;
  unsigned char D.25364;
  int D.25365;
  const unsigned char * D.25366;
  unsigned char D.25367;
  int D.25368;
  struct MonoMethod * D.25372;
  struct MonoMethod * D.25378;
  struct MonoMethod * D.25384;
  struct MonoMethod * D.25388;
  struct MonoMethod * D.25392;
  struct MonoClass * D.25403;
  _Bool D.25404;
  long int D.25405;
  long int D.25406;
  struct MonoMethod * D.25409;
  struct MonoMethod * D.25412;
  _Bool D.25420;
  long int D.25421;
  long int D.25422;
  <unnamed type> D.25428;
  unsigned int subtype.58;
  struct MonoMethod * D.25431;
  int D.23269;
  struct MonoMethod * D.25444;
  struct MonoMethod * D.25450;
  struct MonoMethod * D.25454;
  int D.23282;
  int iftmp.59;
  int D.23281;
  const char[23] * D.25463;
  unsigned char D.25464;
  int D.25465;
  unsigned char D.25466;
  int D.25467;
  _Bool D.25468;
  _Bool D.25469;
  _Bool D.25470;
  const unsigned char * D.25473;
  unsigned char D.25474;
  int D.25475;
  const unsigned char * D.25476;
  unsigned char D.25477;
  int D.25478;
  _Bool D.25479;
  _Bool D.25480;
  const unsigned char * D.25483;
  unsigned char D.25484;
  int D.25485;
  const unsigned char * D.25486;
  unsigned char D.25487;
  int D.25488;
  _Bool D.25489;
  _Bool D.25490;
  const unsigned char * D.25493;
  unsigned char D.25494;
  int D.25495;
  const unsigned char * D.25496;
  unsigned char D.25497;
  int D.25498;
  struct MonoMethod * D.25507;
  struct MonoMethod * D.25513;
  _Bool D.25515;
  long int D.25516;
  long int D.25517;
  <unnamed type> D.25520;
  unsigned int subtype.60;
  struct MonoMethodSignature * D.25524;
  _Bool D.25525;
  long int D.25526;
  long int D.25527;
  int D.25530;
  _Bool D.25538;
  _Bool D.25539;
  _Bool D.25540;
  int D.25548;
  <unnamed type> D.25551;
  int D.25557;
  struct MonoMethod * D.25565;
  int D.25569;
  int D.25570;
  unsigned int D.25571;
  int image_index.61;
  int D.25584;
  int D.25585;
  unsigned int D.25586;
  unsigned int D.25589;
  struct MonoMethod * D.25590;
  struct MonoGenericClass * D.25595;
  struct MonoGenericInst * D.25596;
  struct MonoMethod * D.25597;
  int D.25598;
  struct MonoMethod * D.25601;
  unsigned char D.25607;
  int D.25608;
  struct MonoMethod * D.25609;
  int D.25610;
  struct MonoMethod * D.25611;
  struct MonoMethod * D.25612;
  struct MonoMethod * D.25613;
  struct MonoMethod * D.25614;
  int D.25618;
  int D.25619;
  unsigned int D.25620;
  unsigned int D.25621;
  guint32 image_index;
  guint32 value;
  struct MonoImage * image;
  guint8 * p;

  try
    {
      image = 0B;
      p = buf;
      memset (ref, 0, 16);
      p.53 = p;
      D.25183 = decode_value (p.53, &p);
      value = (guint32) D.25183;
      image_index = value >> 24;
      if (image_index == 251) goto <D.25184>; else goto <D.25185>;
      <D.25184>:
      ref->no_aot_trampoline = 1;
      p.53 = p;
      D.25186 = decode_value (p.53, &p);
      value = (guint32) D.25186;
      image_index = value >> 24;
      <D.25185>:
      D.25189 = image_index <= 239;
      D.25190 = image_index == 254;
      D.25191 = D.25189 | D.25190;
      if (D.25191 != 0) goto <D.25187>; else goto <D.25192>;
      <D.25192>:
      if (image_index == 253) goto <D.25187>; else goto <D.25188>;
      <D.25187>:
      if (target != 0B) goto <D.25193>; else goto <D.25194>;
      <D.25193>:
      D.25195 = BIT_FIELD_REF <*target, 8, 160>;
      D.25196 = D.25195 & 124;
      if (D.25196 != 0) goto <D.25197>; else goto <D.25198>;
      <D.25197>:
      D.25199 = 0;
      return D.25199;
      <D.25198>:
      <D.25194>:
      <D.25188>:
      if (image_index == 252) goto <D.25200>; else goto <D.25201>;
      <D.25200>:
      {
        guint32 wrapper_type;

        p.53 = p;
        D.25202 = decode_value (p.53, &p);
        wrapper_type = (guint32) D.25202;
        if (target != 0B) goto <D.25203>; else goto <D.25204>;
        <D.25203>:
        D.25205 = target->wrapper_type;
        D.25206 = (unsigned int) D.25205;
        if (D.25206 != wrapper_type) goto <D.25207>; else goto <D.25208>;
        <D.25207>:
        D.25199 = 0;
        return D.25199;
        <D.25208>:
        <D.25204>:
        image = mono_defaults.corlib;
        switch (wrapper_type) <default: <D.23304>, case 1: <D.23287>, case 2: <D.23288>, case 3: <D.23289>, case 4: <D.23272>, case 5: <D.23301>, case 6: <D.23257>, case 7: <D.23251>, case 9: <D.23205>, case 12: <D.23210>, case 13: <D.23212>, case 14: <D.23215>, case 15: <D.23216>, case 16: <D.23224>, case 18: <D.23213>, case 19: <D.23270>, case 20: <D.23208>, case 21: <D.23220>, case 23: <D.23211>, case 24: <D.23219>, case 25: <D.23226>, case 28: <D.23217>>
        <D.23205>:
        {
          struct MonoMethod * m;

          p.53 = p;
          m = decode_resolve_method_ref (module, p.53, &p);
          if (m == 0B) goto <D.25209>; else goto <D.25210>;
          <D.25209>:
          D.25199 = 0;
          return D.25199;
          <D.25210>:
          D.25211 = m->klass;
          mono_class_init (D.25211);
          D.25212 = mono_marshal_get_remoting_invoke_with_check (m);
          ref->method = D.25212;
          goto <D.23207>;
        }
        <D.23208>:
        {
          struct MonoClass * klass;

          p.53 = p;
          klass = decode_klass_ref (module, p.53, &p);
          if (klass == 0B) goto <D.25213>; else goto <D.25214>;
          <D.25213>:
          D.25199 = 0;
          return D.25199;
          <D.25214>:
          D.25215 = mono_marshal_get_proxy_cancast (klass);
          ref->method = D.25215;
          goto <D.23207>;
        }
        <D.23210>:
        <D.23211>:
        <D.23212>:
        <D.23213>:
        {
          struct MonoClass * klass;

          p.53 = p;
          klass = decode_klass_ref (module, p.53, &p);
          if (klass == 0B) goto <D.25216>; else goto <D.25217>;
          <D.25216>:
          D.25199 = 0;
          return D.25199;
          <D.25217>:
          if (wrapper_type == 12) goto <D.25218>; else goto <D.25219>;
          <D.25218>:
          D.25220 = &klass->byval_arg;
          D.25221 = mono_marshal_get_ldfld_wrapper (D.25220);
          ref->method = D.25221;
          goto <D.25222>;
          <D.25219>:
          if (wrapper_type == 23) goto <D.25223>; else goto <D.25224>;
          <D.25223>:
          D.25220 = &klass->byval_arg;
          D.25225 = mono_marshal_get_ldflda_wrapper (D.25220);
          ref->method = D.25225;
          goto <D.25226>;
          <D.25224>:
          if (wrapper_type == 13) goto <D.25227>; else goto <D.25228>;
          <D.25227>:
          D.25220 = &klass->byval_arg;
          D.25229 = mono_marshal_get_stfld_wrapper (D.25220);
          ref->method = D.25229;
          goto <D.25230>;
          <D.25228>:
          if (wrapper_type == 18) goto <D.25231>; else goto <D.25232>;
          <D.25231>:
          D.25233 = mono_marshal_get_isinst (klass);
          ref->method = D.25233;
          goto <D.25234>;
          <D.25232>:
          monoeg_assertion_message ("* Assertion: should not be reached at %s:%d\n", "aot-runtime.c", 831);
          <D.25234>:
          <D.25230>:
          <D.25226>:
          <D.25222>:
          goto <D.23207>;
        }
        <D.23215>:
        D.25235 = mono_marshal_get_ldfld_remote_wrapper (0B);
        ref->method = D.25235;
        goto <D.23207>;
        <D.23216>:
        D.25236 = mono_marshal_get_stfld_remote_wrapper (0B);
        ref->method = D.25236;
        goto <D.23207>;
        <D.23217>:
        {
          int atype;

          p.53 = p;
          atype = decode_value (p.53, &p);
          D.25237 = mono_gc_get_managed_allocator_by_type (atype);
          ref->method = D.25237;
          D.25238 = ref->method;
          D.25239 = D.25238 == 0B;
          D.25240 = (long int) D.25239;
          D.25241 = __builtin_expect (D.25240, 0);
          if (D.25241 != 0) goto <D.25242>; else goto <D.25243>;
          <D.25242>:
          monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "aot-runtime.c", 845, "ref->method");
          <D.25243>:
          goto <D.23207>;
        }
        <D.23219>:
        D.25244 = mono_gc_get_write_barrier ();
        ref->method = D.25244;
        goto <D.23207>;
        <D.23220>:
        {
          int subtype;

          p.53 = p;
          subtype = decode_value (p.53, &p);
          if (subtype == 0) goto <D.25245>; else goto <D.25246>;
          <D.25245>:
          D.25247 = mono_marshal_get_stelemref ();
          ref->method = D.25247;
          goto <D.25248>;
          <D.25246>:
          if (subtype == 3) goto <D.25249>; else goto <D.25250>;
          <D.25249>:
          {
            int kind;
            struct WrapperInfo * info;

            p.53 = p;
            kind = decode_value (p.53, &p);
            if (target == 0B) goto <D.25251>; else goto <D.25252>;
            <D.25251>:
            D.25199 = 0;
            return D.25199;
            <D.25252>:
            D.25195 = BIT_FIELD_REF <*target, 8, 160>;
            D.25196 = D.25195 & 124;
            if (D.25196 == 84) goto <D.25253>; else goto <D.25254>;
            <D.25253>:
            info = mono_marshal_get_wrapper_info (target);
            D.25255 = info == 0B;
            D.25256 = (long int) D.25255;
            D.25257 = __builtin_expect (D.25256, 0);
            if (D.25257 != 0) goto <D.25258>; else goto <D.25259>;
            <D.25258>:
            monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "aot-runtime.c", 868, "info");
            <D.25259>:
            D.25262 = info->subtype;
            subtype.54 = (unsigned int) subtype;
            if (D.25262 == subtype.54) goto <D.25264>; else goto <D.25260>;
            <D.25264>:
            D.25265 = info->d.virtual_stelemref.kind;
            if (D.25265 == kind) goto <D.25266>; else goto <D.25260>;
            <D.25266>:
            ref->method = target;
            goto <D.25261>;
            <D.25260>:
            D.25199 = 0;
            return D.25199;
            <D.25261>:
            goto <D.25267>;
            <D.25254>:
            D.25199 = 0;
            return D.25199;
            <D.25267>:
          }
          goto <D.25268>;
          <D.25250>:
          monoeg_assertion_message ("* Assertion: should not be reached at %s:%d\n", "aot-runtime.c", 877);
          <D.25268>:
          <D.25248>:
          goto <D.23207>;
        }
        <D.23224>:
        {
          struct MonoMethod * m;

          p.53 = p;
          m = decode_resolve_method_ref (module, p.53, &p);
          if (m == 0B) goto <D.25269>; else goto <D.25270>;
          <D.25269>:
          D.25199 = 0;
          return D.25199;
          <D.25270>:
          D.25271 = mono_marshal_get_synchronized_wrapper (m);
          ref->method = D.25271;
          goto <D.23207>;
        }
        <D.23226>:
        {
          struct MonoMethodDesc * desc;
          struct MonoMethod * orig_method;
          int subtype;

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

            p.53 = p;
            klass = decode_klass_ref (module, p.53, &p);
            if (klass == 0B) goto <D.25276>; else goto <D.25277>;
            <D.25276>:
            D.25199 = 0;
            return D.25199;
            <D.25277>:
            if (target == 0B) goto <D.25278>; else goto <D.25279>;
            <D.25278>:
            D.25199 = 0;
            return D.25199;
            <D.25279>:
            D.25280 = target->klass;
            if (D.25280 != klass) goto <D.25281>; else goto <D.25282>;
            <D.25281>:
            D.25199 = 0;
            return D.25199;
            <D.25282>:
            if (subtype == 7) goto <D.25283>; else goto <D.25284>;
            <D.25283>:
            {
              size_t __s1_len;
              size_t __s2_len;

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

                __s2 = target->name;
                D.25288 = "PtrToStructure";
                D.25289 = MEM[(const unsigned char *)D.25288];
                D.25290 = (int) D.25289;
                D.25291 = *__s2;
                D.25292 = (int) D.25291;
                __result = D.25290 - D.25292;
                {
                  D.25293 = __s2_len != 0;
                  D.25294 = __result == 0;
                  D.25295 = D.25293 & D.25294;
                  if (D.25295 != 0) goto <D.25296>; else goto <D.25297>;
                  <D.25296>:
                  D.25298 = &MEM[(void *)"PtrToStructure" + 1B];
                  D.25299 = *D.25298;
                  D.25300 = (int) D.25299;
                  D.25301 = __s2 + 1;
                  D.25302 = *D.25301;
                  D.25303 = (int) D.25302;
                  __result = D.25300 - D.25303;
                  D.25304 = __s2_len > 1;
                  D.25294 = __result == 0;
                  D.25305 = D.25304 & D.25294;
                  if (D.25305 != 0) goto <D.25306>; else goto <D.25307>;
                  <D.25306>:
                  D.25308 = &MEM[(void *)"PtrToStructure" + 2B];
                  D.25309 = *D.25308;
                  D.25310 = (int) D.25309;
                  D.25311 = __s2 + 2;
                  D.25312 = *D.25311;
                  D.25313 = (int) D.25312;
                  __result = D.25310 - D.25313;
                  D.25314 = __s2_len > 2;
                  D.25294 = __result == 0;
                  D.25315 = D.25314 & D.25294;
                  if (D.25315 != 0) goto <D.25316>; else goto <D.25317>;
                  <D.25316>:
                  D.25318 = &MEM[(void *)"PtrToStructure" + 3B];
                  D.25319 = *D.25318;
                  D.25320 = (int) D.25319;
                  D.25321 = __s2 + 3;
                  D.25322 = *D.25321;
                  D.25323 = (int) D.25322;
                  __result = D.25320 - D.25323;
                  <D.25317>:
                  <D.25307>:
                  <D.25297>:
                }
                D.23238 = __result;
              }
              iftmp.56 = -D.23238;
              goto <D.25324>;
              <D.25287>:
              D.25325 = target->name;
              iftmp.56 = __builtin_strcmp (D.25325, "PtrToStructure");
              <D.25324>:
              D.23239 = iftmp.56;
            }
            if (D.23239 != 0) goto <D.25326>; else goto <D.25327>;
            <D.25326>:
            D.25199 = 0;
            return D.25199;
            <D.25327>:
            D.25328 = mono_marshal_get_ptr_to_struct (klass);
            ref->method = D.25328;
            goto <D.25329>;
            <D.25284>:
            {
              size_t __s1_len;
              size_t __s2_len;

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

                __s2 = target->name;
                D.25333 = "StructureToPtr";
                D.25334 = MEM[(const unsigned char *)D.25333];
                D.25335 = (int) D.25334;
                D.25336 = *__s2;
                D.25337 = (int) D.25336;
                __result = D.25335 - D.25337;
                {
                  D.25338 = __s2_len != 0;
                  D.25339 = __result == 0;
                  D.25340 = D.25338 & D.25339;
                  if (D.25340 != 0) goto <D.25341>; else goto <D.25342>;
                  <D.25341>:
                  D.25343 = &MEM[(void *)"StructureToPtr" + 1B];
                  D.25344 = *D.25343;
                  D.25345 = (int) D.25344;
                  D.25346 = __s2 + 1;
                  D.25347 = *D.25346;
                  D.25348 = (int) D.25347;
                  __result = D.25345 - D.25348;
                  D.25349 = __s2_len > 1;
                  D.25339 = __result == 0;
                  D.25350 = D.25349 & D.25339;
                  if (D.25350 != 0) goto <D.25351>; else goto <D.25352>;
                  <D.25351>:
                  D.25353 = &MEM[(void *)"StructureToPtr" + 2B];
                  D.25354 = *D.25353;
                  D.25355 = (int) D.25354;
                  D.25356 = __s2 + 2;
                  D.25357 = *D.25356;
                  D.25358 = (int) D.25357;
                  __result = D.25355 - D.25358;
                  D.25359 = __s2_len > 2;
                  D.25339 = __result == 0;
                  D.25360 = D.25359 & D.25339;
                  if (D.25360 != 0) goto <D.25361>; else goto <D.25362>;
                  <D.25361>:
                  D.25363 = &MEM[(void *)"StructureToPtr" + 3B];
                  D.25364 = *D.25363;
                  D.25365 = (int) D.25364;
                  D.25366 = __s2 + 3;
                  D.25367 = *D.25366;
                  D.25368 = (int) D.25367;
                  __result = D.25365 - D.25368;
                  <D.25362>:
                  <D.25352>:
                  <D.25342>:
                }
                D.23247 = __result;
              }
              iftmp.57 = -D.23247;
              goto <D.25369>;
              <D.25332>:
              D.25325 = target->name;
              iftmp.57 = __builtin_strcmp (D.25325, "StructureToPtr");
              <D.25369>:
              D.23248 = iftmp.57;
            }
            if (D.23248 != 0) goto <D.25370>; else goto <D.25371>;
            <D.25370>:
            D.25199 = 0;
            return D.25199;
            <D.25371>:
            D.25372 = mono_marshal_get_struct_to_ptr (klass);
            ref->method = D.25372;
            <D.25329>:
          }
          goto <D.25373>;
          <D.25275>:
          if (subtype == 17) goto <D.25374>; else goto <D.25375>;
          <D.25374>:
          {
            struct MonoMethod * m;

            p.53 = p;
            m = decode_resolve_method_ref (module, p.53, &p);
            if (m == 0B) goto <D.25376>; else goto <D.25377>;
            <D.25376>:
            D.25199 = 0;
            return D.25199;
            <D.25377>:
            D.25378 = mono_marshal_get_synchronized_inner_wrapper (m);
            ref->method = D.25378;
          }
          goto <D.25379>;
          <D.25375>:
          if (subtype == 20) goto <D.25380>; else goto <D.25381>;
          <D.25380>:
          {
            struct MonoMethod * m;

            p.53 = p;
            m = decode_resolve_method_ref (module, p.53, &p);
            if (m == 0B) goto <D.25382>; else goto <D.25383>;
            <D.25382>:
            D.25199 = 0;
            return D.25199;
            <D.25383>:
            D.25384 = mono_marshal_get_array_accessor_wrapper (m);
            ref->method = D.25384;
          }
          goto <D.25385>;
          <D.25381>:
          if (subtype == 18) goto <D.25386>; else goto <D.25387>;
          <D.25386>:
          D.25388 = mono_marshal_get_gsharedvt_in_wrapper ();
          ref->method = D.25388;
          goto <D.25389>;
          <D.25387>:
          if (subtype == 19) goto <D.25390>; else goto <D.25391>;
          <D.25390>:
          D.25392 = mono_marshal_get_gsharedvt_out_wrapper ();
          ref->method = D.25392;
          goto <D.25393>;
          <D.25391>:
          if (subtype == 4) goto <D.25394>; else goto <D.25395>;
          <D.25394>:
          desc = mono_method_desc_new ("Monitor:Enter", 0);
          goto <D.25396>;
          <D.25395>:
          if (subtype == 6) goto <D.25397>; else goto <D.25398>;
          <D.25397>:
          desc = mono_method_desc_new ("Monitor:Exit", 0);
          goto <D.25399>;
          <D.25398>:
          if (subtype == 5) goto <D.25400>; else goto <D.25401>;
          <D.25400>:
          desc = mono_method_desc_new ("Monitor:Enter(object,bool&)", 0);
          goto <D.25402>;
          <D.25401>:
          monoeg_assertion_message ("* Assertion: should not be reached at %s:%d\n", "aot-runtime.c", 938);
          <D.25402>:
          <D.25399>:
          <D.25396>:
          D.25403 = mono_defaults.monitor_class;
          orig_method = mono_method_desc_search_in_class (desc, D.25403);
          D.25404 = orig_method == 0B;
          D.25405 = (long int) D.25404;
          D.25406 = __builtin_expect (D.25405, 0);
          if (D.25406 != 0) goto <D.25407>; else goto <D.25408>;
          <D.25407>:
          monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "aot-runtime.c", 940, "orig_method");
          <D.25408>:
          mono_method_desc_free (desc);
          D.25409 = mono_monitor_get_fast_path (orig_method);
          ref->method = D.25409;
          <D.25393>:
          <D.25389>:
          <D.25385>:
          <D.25379>:
          <D.25373>:
          goto <D.23207>;
        }
        <D.23251>:
        {
          int subtype;

          p.53 = p;
          subtype = decode_value (p.53, &p);
          if (subtype == 1) goto <D.25410>; else goto <D.25411>;
          <D.25410>:
          {
            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.25412 = mono_marshal_get_array_address (rank, elem_size);
            ref->method = D.25412;
          }
          goto <D.25413>;
          <D.25411>:
          if (subtype == 2) goto <D.25414>; else goto <D.25415>;
          <D.25414>:
          {
            struct WrapperInfo * info;
            struct MonoMethod * m;

            p.53 = p;
            m = decode_resolve_method_ref (module, p.53, &p);
            if (m == 0B) goto <D.25416>; else goto <D.25417>;
            <D.25416>:
            D.25199 = 0;
            return D.25199;
            <D.25417>:
            if (target == 0B) goto <D.25418>; else goto <D.25419>;
            <D.25418>:
            D.25199 = 0;
            return D.25199;
            <D.25419>:
            D.25195 = BIT_FIELD_REF <*target, 8, 160>;
            D.25196 = D.25195 & 124;
            D.25420 = D.25196 != 28;
            D.25421 = (long int) D.25420;
            D.25422 = __builtin_expect (D.25421, 0);
            if (D.25422 != 0) goto <D.25423>; else goto <D.25424>;
            <D.25423>:
            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.25424>:
            info = mono_marshal_get_wrapper_info (target);
            if (info != 0B) goto <D.25427>; else goto <D.25425>;
            <D.25427>:
            D.25428 = info->subtype;
            subtype.58 = (unsigned int) subtype;
            if (D.25428 == subtype.58) goto <D.25430>; else goto <D.25425>;
            <D.25430>:
            D.25431 = info->d.string_ctor.method;
            if (D.25431 == m) goto <D.25432>; else goto <D.25425>;
            <D.25432>:
            ref->method = target;
            goto <D.25426>;
            <D.25425>:
            D.25199 = 0;
            return D.25199;
            <D.25426>:
          }
          <D.25415>:
          <D.25413>:
          goto <D.23207>;
        }
        <D.23257>:
        {
          struct MonoMethod * m;
          int subtype;
          char * name;

          p.53 = p;
          subtype = decode_value (p.53, &p);
          if (subtype == 15) goto <D.25433>; else goto <D.25434>;
          <D.25433>:
          if (target == 0B) goto <D.25435>; else goto <D.25436>;
          <D.25435>:
          D.25199 = 0;
          return D.25199;
          <D.25436>:
          name = p;
          {
            size_t __s1_len;
            size_t __s2_len;

            D.25325 = target->name;
            D.23269 = __builtin_strcmp (D.25325, name);
          }
          if (D.23269 != 0) goto <D.25437>; else goto <D.25438>;
          <D.25437>:
          D.25199 = 0;
          return D.25199;
          <D.25438>:
          ref->method = target;
          goto <D.25439>;
          <D.25434>:
          p.53 = p;
          m = decode_resolve_method_ref (module, p.53, &p);
          if (m == 0B) goto <D.25440>; else goto <D.25441>;
          <D.25440>:
          D.25199 = 0;
          return D.25199;
          <D.25441>:
          if (target == 0B) goto <D.25442>; else goto <D.25443>;
          <D.25442>:
          D.25199 = 0;
          return D.25199;
          <D.25443>:
          D.25444 = mono_marshal_method_from_wrapper (target);
          if (D.25444 == m) goto <D.25445>; else goto <D.25446>;
          <D.25445>:
          ref->method = target;
          goto <D.25447>;
          <D.25446>:
          D.25199 = 0;
          return D.25199;
          <D.25447>:
          <D.25439>:
          goto <D.23207>;
        }
        <D.23270>:
        {
          int subtype;

          p.53 = p;
          subtype = decode_value (p.53, &p);
          if (subtype == 9) goto <D.25448>; else goto <D.25449>;
          <D.25448>:
          D.25450 = mono_marshal_get_castclass_with_cache ();
          ref->method = D.25450;
          goto <D.25451>;
          <D.25449>:
          if (subtype == 10) goto <D.25452>; else goto <D.25453>;
          <D.25452>:
          D.25454 = mono_marshal_get_isinst_with_cache ();
          ref->method = D.25454;
          goto <D.25455>;
          <D.25453>:
          monoeg_assertion_message ("* Assertion: should not be reached at %s:%d\n", "aot-runtime.c", 1011);
          <D.25455>:
          <D.25451>:
          goto <D.23207>;
        }
        <D.23272>:
        {
          int subtype;

          p.53 = p;
          subtype = decode_value (p.53, &p);
          if (target == 0B) goto <D.25456>; else goto <D.25457>;
          <D.25456>:
          D.25199 = 0;
          return D.25199;
          <D.25457>:
          if (subtype == 12) goto <D.25458>; else goto <D.25459>;
          <D.25458>:
          {
            size_t __s1_len;
            size_t __s2_len;

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

              __s2 = target->name;
              D.25463 = "runtime_invoke_dynamic";
              D.25464 = MEM[(const unsigned char *)D.25463];
              D.25465 = (int) D.25464;
              D.25466 = *__s2;
              D.25467 = (int) D.25466;
              __result = D.25465 - D.25467;
              {
                D.25468 = __s2_len != 0;
                D.25469 = __result == 0;
                D.25470 = D.25468 & D.25469;
                if (D.25470 != 0) goto <D.25471>; else goto <D.25472>;
                <D.25471>:
                D.25473 = &MEM[(void *)"runtime_invoke_dynamic" + 1B];
                D.25474 = *D.25473;
                D.25475 = (int) D.25474;
                D.25476 = __s2 + 1;
                D.25477 = *D.25476;
                D.25478 = (int) D.25477;
                __result = D.25475 - D.25478;
                D.25479 = __s2_len > 1;
                D.25469 = __result == 0;
                D.25480 = D.25479 & D.25469;
                if (D.25480 != 0) goto <D.25481>; else goto <D.25482>;
                <D.25481>:
                D.25483 = &MEM[(void *)"runtime_invoke_dynamic" + 2B];
                D.25484 = *D.25483;
                D.25485 = (int) D.25484;
                D.25486 = __s2 + 2;
                D.25487 = *D.25486;
                D.25488 = (int) D.25487;
                __result = D.25485 - D.25488;
                D.25489 = __s2_len > 2;
                D.25469 = __result == 0;
                D.25490 = D.25489 & D.25469;
                if (D.25490 != 0) goto <D.25491>; else goto <D.25492>;
                <D.25491>:
                D.25493 = &MEM[(void *)"runtime_invoke_dynamic" + 3B];
                D.25494 = *D.25493;
                D.25495 = (int) D.25494;
                D.25496 = __s2 + 3;
                D.25497 = *D.25496;
                D.25498 = (int) D.25497;
                __result = D.25495 - D.25498;
                <D.25492>:
                <D.25482>:
                <D.25472>:
              }
              D.23281 = __result;
            }
            iftmp.59 = -D.23281;
            goto <D.25499>;
            <D.25462>:
            D.25325 = target->name;
            iftmp.59 = __builtin_strcmp (D.25325, "runtime_invoke_dynamic");
            <D.25499>:
            D.23282 = iftmp.59;
          }
          if (D.23282 != 0) goto <D.25500>; else goto <D.25501>;
          <D.25500>:
          D.25199 = 0;
          return D.25199;
          <D.25501>:
          ref->method = target;
          goto <D.25502>;
          <D.25459>:
          if (subtype == 13) goto <D.25503>; else goto <D.25504>;
          <D.25503>:
          {
            struct MonoMethod * m;

            p.53 = p;
            m = decode_resolve_method_ref (module, p.53, &p);
            if (m == 0B) goto <D.25505>; else goto <D.25506>;
            <D.25505>:
            D.25199 = 0;
            return D.25199;
            <D.25506>:
            D.25507 = mono_marshal_get_runtime_invoke (m, 0);
            ref->method = D.25507;
          }
          goto <D.25508>;
          <D.25504>:
          if (subtype == 14) goto <D.25509>; else goto <D.25510>;
          <D.25509>:
          {
            struct MonoMethod * m;

            p.53 = p;
            m = decode_resolve_method_ref (module, p.53, &p);
            if (m == 0B) goto <D.25511>; else goto <D.25512>;
            <D.25511>:
            D.25199 = 0;
            return D.25199;
            <D.25512>:
            D.25513 = mono_marshal_get_runtime_invoke (m, 1);
            ref->method = D.25513;
          }
          goto <D.25514>;
          <D.25510>:
          {
            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.25515 = info == 0B;
            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", 1044, "info");
            <D.25519>:
            D.25520 = info->subtype;
            subtype.60 = (unsigned int) subtype;
            if (D.25520 != subtype.60) goto <D.25522>; else goto <D.25523>;
            <D.25522>:
            D.25199 = 0;
            return D.25199;
            <D.25523>:
            D.25524 = info->d.runtime_invoke.sig;
            D.25525 = D.25524 == 0B;
            D.25526 = (long int) D.25525;
            D.25527 = __builtin_expect (D.25526, 0);
            if (D.25527 != 0) goto <D.25528>; else goto <D.25529>;
            <D.25528>:
            monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "aot-runtime.c", 1048, "info->d.runtime_invoke.sig");
            <D.25529>:
            D.25524 = info->d.runtime_invoke.sig;
            D.25530 = mono_metadata_signature_equal (sig, D.25524);
            if (D.25530 != 0) goto <D.25531>; else goto <D.25532>;
            <D.25531>:
            ref->method = target;
            goto <D.25533>;
            <D.25532>:
            D.25199 = 0;
            return D.25199;
            <D.25533>:
          }
          <D.25514>:
          <D.25508>:
          <D.25502>:
          goto <D.23207>;
        }
        <D.23287>:
        <D.23288>:
        <D.23289>:
        {
          gboolean is_inflated;
          WrapperSubtype subtype;

          p.53 = p;
          is_inflated = decode_value (p.53, &p);
          if (is_inflated != 0) goto <D.25534>; else goto <D.25535>;
          <D.25534>:
          {
            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.25536>; else goto <D.25537>;
            <D.25536>:
            D.25199 = 0;
            return D.25199;
            <D.25537>:
            switch (wrapper_type) <default: <D.23299>, case 1: <D.23295>, case 2: <D.23297>, case 3: <D.23298>>
            <D.23295>:
            invoke = mono_get_delegate_invoke (klass);
            wrapper = mono_marshal_get_delegate_invoke (invoke, 0B);
            goto <D.23296>;
            <D.23297>:
            invoke = mono_get_delegate_begin_invoke (klass);
            wrapper = mono_marshal_get_delegate_begin_invoke (invoke);
            goto <D.23296>;
            <D.23298>:
            invoke = mono_get_delegate_end_invoke (klass);
            wrapper = mono_marshal_get_delegate_end_invoke (invoke);
            goto <D.23296>;
            <D.23299>:
            monoeg_assertion_message ("* Assertion: should not be reached at %s:%d\n", "aot-runtime.c", 1084);
            <D.23296>:
            D.25538 = target != 0B;
            D.25539 = wrapper != target;
            D.25540 = D.25538 & D.25539;
            if (D.25540 != 0) goto <D.25541>; else goto <D.25542>;
            <D.25541>:
            D.25199 = 0;
            return D.25199;
            <D.25542>:
            ref->method = wrapper;
          }
          goto <D.25543>;
          <D.25535>:
          if (target == 0B) goto <D.25544>; else goto <D.25545>;
          <D.25544>:
          D.25199 = 0;
          return D.25199;
          <D.25545>:
          if (wrapper_type == 1) goto <D.25546>; else goto <D.25547>;
          <D.25546>:
          {
            struct WrapperInfo * info;

            p.53 = p;
            D.25548 = decode_value (p.53, &p);
            subtype = (WrapperSubtype) D.25548;
            info = mono_marshal_get_wrapper_info (target);
            if (info != 0B) goto <D.25549>; else goto <D.25550>;
            <D.25549>:
            D.25551 = info->subtype;
            if (D.25551 != subtype) goto <D.25552>; else goto <D.25553>;
            <D.25552>:
            D.25199 = 0;
            return D.25199;
            <D.25553>:
            goto <D.25554>;
            <D.25550>:
            if (subtype != 0) goto <D.25555>; else goto <D.25556>;
            <D.25555>:
            D.25199 = 0;
            return D.25199;
            <D.25556>:
            <D.25554>:
          }
          <D.25547>:
          p.53 = p;
          D.25557 = sig_matches_target (module, target, p.53, &p);
          if (D.25557 != 0) goto <D.25558>; else goto <D.25559>;
          <D.25558>:
          ref->method = target;
          goto <D.25560>;
          <D.25559>:
          D.25199 = 0;
          return D.25199;
          <D.25560>:
          <D.25543>:
          goto <D.23207>;
        }
        <D.23301>:
        {
          struct MonoMethod * m;
          struct MonoClass * klass;

          p.53 = p;
          m = decode_resolve_method_ref (module, p.53, &p);
          if (m == 0B) goto <D.25561>; else goto <D.25562>;
          <D.25561>:
          D.25199 = 0;
          return D.25199;
          <D.25562>:
          p.53 = p;
          klass = decode_klass_ref (module, p.53, &p);
          if (klass == 0B) goto <D.25563>; else goto <D.25564>;
          <D.25563>:
          D.25199 = 0;
          return D.25199;
          <D.25564>:
          D.25565 = mono_marshal_get_managed_wrapper (m, klass, 0);
          ref->method = D.25565;
          goto <D.23207>;
        }
        <D.23304>:
        monoeg_assertion_message ("* Assertion: should not be reached at %s:%d\n", "aot-runtime.c", 1132);
        <D.23207>:
      }
      goto <D.25566>;
      <D.25201>:
      if (image_index == 254) goto <D.25567>; else goto <D.25568>;
      <D.25567>:
      p.53 = p;
      D.25569 = decode_value (p.53, &p);
      image_index = (guint32) D.25569;
      p.53 = p;
      D.25570 = decode_value (p.53, &p);
      D.25571 = (unsigned int) D.25570;
      ref->token = D.25571;
      image_index.61 = (int) image_index;
      image = load_image (module, image_index.61, 1);
      if (image == 0B) goto <D.25573>; else goto <D.25574>;
      <D.25573>:
      D.25199 = 0;
      return D.25199;
      <D.25574>:
      goto <D.25575>;
      <D.25568>:
      if (image_index == 253) goto <D.25576>; else goto <D.25577>;
      <D.25576>:
      {
        struct MonoClass * klass;
        struct MonoGenericContext ctx;

        try
          {
            p.53 = p;
            klass = decode_klass_ref (module, p.53, &p);
            if (klass == 0B) goto <D.25578>; else goto <D.25579>;
            <D.25578>:
            D.25199 = 0;
            return D.25199;
            <D.25579>:
            if (target != 0B) goto <D.25580>; else goto <D.25581>;
            <D.25580>:
            D.25280 = target->klass;
            if (D.25280 != klass) goto <D.25582>; else goto <D.25583>;
            <D.25582>:
            D.25199 = 0;
            return D.25199;
            <D.25583>:
            <D.25581>:
            p.53 = p;
            D.25584 = decode_value (p.53, &p);
            image_index = (guint32) D.25584;
            p.53 = p;
            D.25585 = decode_value (p.53, &p);
            D.25586 = (unsigned int) D.25585;
            ref->token = D.25586;
            image_index.61 = (int) image_index;
            image = load_image (module, image_index.61, 1);
            if (image == 0B) goto <D.25587>; else goto <D.25588>;
            <D.25587>:
            D.25199 = 0;
            return D.25199;
            <D.25588>:
            D.25589 = ref->token;
            D.25590 = mono_get_method_full (image, D.25589, 0B, 0B);
            ref->method = D.25590;
            D.25238 = ref->method;
            if (D.25238 == 0B) goto <D.25591>; else goto <D.25592>;
            <D.25591>:
            D.25199 = 0;
            return D.25199;
            <D.25592>:
            memset (&ctx, 0, 8);
            if (0 != 0) goto <D.25593>; else goto <D.25594>;
            <D.25593>:
            D.25595 = klass->generic_class;
            D.25596 = D.25595->context.class_inst;
            ctx.class_inst = D.25596;
            ctx.method_inst = 0B;
            D.25238 = ref->method;
            D.25597 = mono_class_inflate_generic_method_full (D.25238, klass, &ctx);
            ref->method = D.25597;
            <D.25594>:
            memset (&ctx, 0, 8);
            p.53 = p;
            D.25598 = decode_generic_context (module, &ctx, p.53, &p);
            if (D.25598 == 0) goto <D.25599>; else goto <D.25600>;
            <D.25599>:
            D.25199 = 0;
            return D.25199;
            <D.25600>:
            D.25238 = ref->method;
            D.25601 = mono_class_inflate_generic_method_full (D.25238, klass, &ctx);
            ref->method = D.25601;
          }
        finally
          {
            ctx = {CLOBBER};
          }
      }
      goto <D.25602>;
      <D.25577>:
      if (image_index == 250) goto <D.25603>; else goto <D.25604>;
      <D.25603>:
      {
        struct MonoClass * klass;
        int method_type;

        p.53 = p;
        klass = decode_klass_ref (module, p.53, &p);
        if (klass == 0B) goto <D.25605>; else goto <D.25606>;
        <D.25605>:
        D.25199 = 0;
        return D.25199;
        <D.25606>:
        p.53 = p;
        method_type = decode_value (p.53, &p);
        switch (method_type) <default: <D.23315>, case 0: <D.23309>, case 1: <D.23311>, case 2: <D.23312>, case 3: <D.23313>, case 4: <D.23314>>
        <D.23309>:
        D.25607 = klass->rank;
        D.25608 = (int) D.25607;
        D.25609 = mono_class_get_method_from_name (klass, ".ctor", D.25608);
        ref->method = D.25609;
        goto <D.23310>;
        <D.23311>:
        D.25607 = klass->rank;
        D.25608 = (int) D.25607;
        D.25610 = D.25608 * 2;
        D.25611 = mono_class_get_method_from_name (klass, ".ctor", D.25610);
        ref->method = D.25611;
        goto <D.23310>;
        <D.23312>:
        D.25612 = mono_class_get_method_from_name (klass, "Get", -1);
        ref->method = D.25612;
        goto <D.23310>;
        <D.23313>:
        D.25613 = mono_class_get_method_from_name (klass, "Address", -1);
        ref->method = D.25613;
        goto <D.23310>;
        <D.23314>:
        D.25614 = mono_class_get_method_from_name (klass, "Set", -1);
        ref->method = D.25614;
        goto <D.23310>;
        <D.23315>:
        monoeg_assertion_message ("* Assertion: should not be reached at %s:%d\n", "aot-runtime.c", 1207);
        <D.23310>:
      }
      goto <D.25615>;
      <D.25604>:
      if (image_index == 249) goto <D.25616>; else goto <D.25617>;
      <D.25616>:
      p.53 = p;
      D.25618 = decode_value (p.53, &p);
      image_index = (guint32) D.25618;
      p.53 = p;
      D.25619 = decode_value (p.53, &p);
      value = (guint32) D.25619;
      <D.25617>:
      D.25620 = value & 16777215;
      D.25621 = D.25620 | 100663296;
      ref->token = D.25621;
      image_index.61 = (int) image_index;
      image = load_image (module, image_index.61, 1);
      if (image == 0B) goto <D.25622>; else goto <D.25623>;
      <D.25622>:
      D.25199 = 0;
      return D.25199;
      <D.25623>:
      <D.25615>:
      <D.25602>:
      <D.25575>:
      <D.25566>:
      p.53 = p;
      *endbuf = p.53;
      ref->image = image;
      D.25199 = 1;
      return D.25199;
    }
  finally
    {
      p = {CLOBBER};
    }
}


decode_signature_with_target (struct MonoAotModule * module, struct MonoMethodSignature * target, guint8 * buf, guint8 * * endbuf)
{
  guint8 * p.62;
  unsigned char D.25629;
  guint8 * p.63;
  unsigned int D.25631;
  _Bool D.25632;
  unsigned int D.25633;
  _Bool D.25634;
  unsigned int D.25635;
  _Bool D.25636;
  int flags.64;
  short unsigned int D.25642;
  int D.25643;
  struct MonoMethodSignature * D.25646;
  unsigned int param_count.65;
  unsigned int D.25648;
  unsigned int D.25649;
  short unsigned int D.25650;
  unsigned char D.25651;
  <unnamed-unsigned:1> D.25652;
  unsigned char D.25653;
  <unnamed-unsigned:1> D.25654;
  unsigned char D.25655;
  <unnamed-unsigned:6> D.25656;
  struct MonoType * D.25657;
  unsigned char D.25660;
  unsigned char D.25661;
  _Bool D.25662;
  long int D.25663;
  long int D.25664;
  short int D.25667;
  struct MonoType * D.25668;
  short int D.25671;
  short unsigned int D.25674;
  short int D.25675;
  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.25629 = *p.62;
      flags = (guint32) D.25629;
      p.62 = p;
      p.63 = p.62 + 1;
      p = p.63;
      D.25631 = flags & 16;
      D.25632 = D.25631 != 0;
      has_gen_params = (gboolean) D.25632;
      D.25633 = flags & 32;
      D.25634 = D.25633 != 0;
      hasthis = (gboolean) D.25634;
      D.25635 = flags & 64;
      D.25636 = D.25635 != 0;
      explicit_this = (gboolean) D.25636;
      flags.64 = (int) flags;
      call_conv = flags.64 & 15;
      if (has_gen_params != 0) goto <D.25638>; else goto <D.25639>;
      <D.25638>:
      p.62 = p;
      gen_param_count = decode_value (p.62, &p);
      <D.25639>:
      p.62 = p;
      param_count = decode_value (p.62, &p);
      if (target != 0B) goto <D.25640>; else goto <D.25641>;
      <D.25640>:
      D.25642 = target->param_count;
      D.25643 = (int) D.25642;
      if (D.25643 != param_count) goto <D.25644>; else goto <D.25645>;
      <D.25644>:
      D.25646 = 0B;
      return D.25646;
      <D.25645>:
      <D.25641>:
      param_count.65 = (unsigned int) param_count;
      D.25648 = param_count.65 + 3;
      D.25649 = D.25648 * 4;
      sig = monoeg_malloc0 (D.25649);
      D.25650 = (short unsigned int) param_count;
      sig->param_count = D.25650;
      sig->sentinelpos = -1;
      D.25651 = (unsigned char) hasthis;
      D.25652 = (<unnamed-unsigned:1>) D.25651;
      sig->hasthis = D.25652;
      D.25653 = (unsigned char) explicit_this;
      D.25654 = (<unnamed-unsigned:1>) D.25653;
      sig->explicit_this = D.25654;
      D.25655 = (unsigned char) call_conv;
      D.25656 = (<unnamed-unsigned:6>) D.25655;
      sig->call_convention = D.25656;
      D.25650 = (short unsigned int) param_count;
      sig->param_count = D.25650;
      p.62 = p;
      D.25657 = decode_type (module, p.62, &p);
      sig->ret = D.25657;
      i = 0;
      goto <D.23171>;
      <D.23170>:
      p.62 = p;
      D.25629 = *p.62;
      if (D.25629 == 65) goto <D.25658>; else goto <D.25659>;
      <D.25658>:
      D.25660 = BIT_FIELD_REF <*sig, 8, 80>;
      D.25661 = D.25660 & 63;
      D.25662 = D.25661 != 5;
      D.25663 = (long int) D.25662;
      D.25664 = __builtin_expect (D.25663, 0);
      if (D.25664 != 0) goto <D.25665>; else goto <D.25666>;
      <D.25665>:
      monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "aot-runtime.c", 706, "sig->call_convention == MONO_CALL_VARARG");
      <D.25666>:
      D.25667 = (short int) i;
      sig->sentinelpos = D.25667;
      p.62 = p;
      p.63 = p.62 + 1;
      p = p.63;
      <D.25659>:
      p.62 = p;
      D.25668 = decode_type (module, p.62, &p);
      sig->params[i] = D.25668;
      i = i + 1;
      <D.23171>:
      if (i < param_count) goto <D.23170>; else goto <D.23172>;
      <D.23172>:
      D.25660 = BIT_FIELD_REF <*sig, 8, 80>;
      D.25661 = D.25660 & 63;
      if (D.25661 == 5) goto <D.25669>; else goto <D.25670>;
      <D.25669>:
      D.25671 = sig->sentinelpos;
      if (D.25671 == -1) goto <D.25672>; else goto <D.25673>;
      <D.25672>:
      D.25674 = sig->param_count;
      D.25675 = (short int) D.25674;
      sig->sentinelpos = D.25675;
      <D.25673>:
      <D.25670>:
      p.62 = p;
      *endbuf = p.62;
      D.25646 = sig;
      return D.25646;
    }
  finally
    {
      p = {CLOBBER};
    }
}


decode_type (struct MonoAotModule * module, guint8 * buf, guint8 * * endbuf)
{
  guint8 * p.66;
  unsigned char D.25679;
  guint8 * p.67;
  unsigned char D.25685;
  int D.25686;
  struct MonoClass * D.25687;
  struct MonoClass * D.25688;
  struct MonoClass * D.25689;
  struct MonoType * D.25692;
  struct MonoType * D.25693;
  struct MonoGenericContainer * D.25696;
  _Bool D.25697;
  long int D.25698;
  long int D.25699;
  struct MonoGenericInst * D.25702;
  struct MonoGenericInst * D.25703;
  struct MonoType * D.25706;
  struct MonoGenericClass * D.25707;
  struct MonoClass * D.25708;
  struct MonoClass * D.25709;
  int D.25712;
  unsigned char D.25713;
  int D.25714;
  unsigned char D.25715;
  unsigned char D.25716;
  unsigned int D.25719;
  unsigned int D.25720;
  void * D.25721;
  int * D.25722;
  unsigned int i.68;
  unsigned int D.25724;
  int * D.25725;
  int D.25726;
  int D.25727;
  int D.25728;
  unsigned char D.25729;
  unsigned char D.25730;
  unsigned int D.25733;
  unsigned int D.25734;
  void * D.25735;
  int * D.25736;
  int * D.25737;
  int D.25738;
  int D.25739;
  struct MonoGenericParam * D.25742;
  guint8 * p;
  struct MonoType * t;

  try
    {
      p = buf;
      t = monoeg_malloc0 (8);
      <D.23112>:
      p.66 = p;
      D.25679 = *p.66;
      if (D.25679 == 69) goto <D.25680>; else goto <D.25681>;
      <D.25680>:
      t->pinned = 1;
      p.66 = p;
      p.67 = p.66 + 1;
      p = p.67;
      goto <D.25683>;
      <D.25681>:
      p.66 = p;
      D.25679 = *p.66;
      if (D.25679 == 16) goto <D.25684>; else goto <D.23111>;
      <D.25684>:
      t->byref = 1;
      p.66 = p;
      p.67 = p.66 + 1;
      p = p.67;
      <D.25683>:
      goto <D.23112>;
      <D.23111>:
      p.66 = p;
      D.25679 = *p.66;
      t->type = D.25679;
      p.66 = p;
      p.67 = p.66 + 1;
      p = p.67;
      D.25685 = t->type;
      D.25686 = (int) D.25685;
      switch (D.25686) <default: <D.23153>, case 1: <D.23113>, case 2: <D.23114>, case 3: <D.23115>, case 4: <D.23116>, case 5: <D.23117>, case 6: <D.23118>, case 7: <D.23119>, case 8: <D.23120>, case 9: <D.23121>, case 10: <D.23122>, case 11: <D.23123>, case 12: <D.23124>, case 13: <D.23125>, case 14: <D.23128>, case 15: <D.23135>, case 17: <D.23132>, case 18: <D.23133>, case 19: <D.23150>, case 20: <D.23141>, case 21: <D.23136>, case 22: <D.23130>, case 24: <D.23126>, case 25: <D.23127>, case 28: <D.23129>, case 29: <D.23134>, case 30: <D.23151>>
      <D.23113>:
      <D.23114>:
      <D.23115>:
      <D.23116>:
      <D.23117>:
      <D.23118>:
      <D.23119>:
      <D.23120>:
      <D.23121>:
      <D.23122>:
      <D.23123>:
      <D.23124>:
      <D.23125>:
      <D.23126>:
      <D.23127>:
      <D.23128>:
      <D.23129>:
      <D.23130>:
      goto <D.23131>;
      <D.23132>:
      <D.23133>:
      p.66 = p;
      D.25687 = decode_klass_ref (module, p.66, &p);
      t->data.klass = D.25687;
      goto <D.23131>;
      <D.23134>:
      p.66 = p;
      D.25688 = decode_klass_ref (module, p.66, &p);
      t->data.klass = D.25688;
      D.25689 = t->data.klass;
      if (D.25689 == 0B) goto <D.25690>; else goto <D.25691>;
      <D.25690>:
      D.25692 = 0B;
      return D.25692;
      <D.25691>:
      goto <D.23131>;
      <D.23135>:
      p.66 = p;
      D.25693 = decode_type (module, p.66, &p);
      t->data.type = D.25693;
      goto <D.23131>;
      <D.23136>:
      {
        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.25694>; else goto <D.25695>;
            <D.25694>:
            D.25692 = 0B;
            return D.25692;
            <D.25695>:
            D.25696 = gclass->generic_container;
            D.25697 = D.25696 == 0B;
            D.25698 = (long int) D.25697;
            D.25699 = __builtin_expect (D.25698, 0);
            if (D.25699 != 0) goto <D.25700>; else goto <D.25701>;
            <D.25700>:
            monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "aot-runtime.c", 620, "gclass->generic_container");
            <D.25701>:
            memset (&ctx, 0, 8);
            p.66 = p;
            D.25702 = decode_generic_inst (module, p.66, &p);
            ctx.class_inst = D.25702;
            D.25703 = ctx.class_inst;
            if (D.25703 == 0B) goto <D.25704>; else goto <D.25705>;
            <D.25704>:
            D.25692 = 0B;
            return D.25692;
            <D.25705>:
            D.25706 = &gclass->byval_arg;
            type = mono_class_inflate_generic_type (D.25706, &ctx);
            klass = mono_class_from_mono_type (type);
            D.25707 = klass->generic_class;
            t->data.generic_class = D.25707;
            goto <D.23131>;
          }
        finally
          {
            ctx = {CLOBBER};
          }
      }
      <D.23141>:
      {
        struct MonoArrayType * array;
        int i;

        array = monoeg_malloc0 (16);
        p.66 = p;
        D.25708 = decode_klass_ref (module, p.66, &p);
        array->eklass = D.25708;
        D.25709 = array->eklass;
        if (D.25709 == 0B) goto <D.25710>; else goto <D.25711>;
        <D.25710>:
        D.25692 = 0B;
        return D.25692;
        <D.25711>:
        p.66 = p;
        D.25712 = decode_value (p.66, &p);
        D.25713 = (unsigned char) D.25712;
        array->rank = D.25713;
        p.66 = p;
        D.25714 = decode_value (p.66, &p);
        D.25715 = (unsigned char) D.25714;
        array->numsizes = D.25715;
        D.25716 = array->numsizes;
        if (D.25716 != 0) goto <D.25717>; else goto <D.25718>;
        <D.25717>:
        D.25716 = array->numsizes;
        D.25719 = (unsigned int) D.25716;
        D.25720 = D.25719 * 4;
        D.25721 = monoeg_malloc0 (D.25720);
        array->sizes = D.25721;
        <D.25718>:
        i = 0;
        goto <D.23145>;
        <D.23144>:
        D.25722 = array->sizes;
        i.68 = (unsigned int) i;
        D.25724 = i.68 * 4;
        D.25725 = D.25722 + D.25724;
        p.66 = p;
        D.25726 = decode_value (p.66, &p);
        *D.25725 = D.25726;
        i = i + 1;
        <D.23145>:
        D.25716 = array->numsizes;
        D.25727 = (int) D.25716;
        if (D.25727 > i) goto <D.23144>; else goto <D.23146>;
        <D.23146>:
        p.66 = p;
        D.25728 = decode_value (p.66, &p);
        D.25729 = (unsigned char) D.25728;
        array->numlobounds = D.25729;
        D.25730 = array->numlobounds;
        if (D.25730 != 0) goto <D.25731>; else goto <D.25732>;
        <D.25731>:
        D.25730 = array->numlobounds;
        D.25733 = (unsigned int) D.25730;
        D.25734 = D.25733 * 4;
        D.25735 = monoeg_malloc0 (D.25734);
        array->lobounds = D.25735;
        <D.25732>:
        i = 0;
        goto <D.23148>;
        <D.23147>:
        D.25736 = array->lobounds;
        i.68 = (unsigned int) i;
        D.25724 = i.68 * 4;
        D.25737 = D.25736 + D.25724;
        p.66 = p;
        D.25738 = decode_value (p.66, &p);
        *D.25737 = D.25738;
        i = i + 1;
        <D.23148>:
        D.25730 = array->numlobounds;
        D.25739 = (int) D.25730;
        if (D.25739 > i) goto <D.23147>; else goto <D.23149>;
        <D.23149>:
        t->data.array = array;
        goto <D.23131>;
      }
      <D.23150>:
      <D.23151>:
      {
        struct MonoClass * klass;

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


decode_generic_inst (struct MonoAotModule * module, guint8 * buf, guint8 * * endbuf)
{
  guint8 * p.69;
  unsigned int type_argc.70;
  unsigned int D.25750;
  struct MonoGenericInst * D.25753;
  unsigned int i.71;
  unsigned int D.25755;
  struct MonoType * * D.25756;
  struct MonoType * D.25757;
  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.25750 = type_argc.70 * 4;
      type_argv = monoeg_malloc0 (D.25750);
      i = 0;
      goto <D.23046>;
      <D.23045>:
      {
        struct MonoClass * pclass;

        p.69 = p;
        pclass = decode_klass_ref (module, p.69, &p);
        if (pclass == 0B) goto <D.25751>; else goto <D.25752>;
        <D.25751>:
        monoeg_g_free (type_argv);
        D.25753 = 0B;
        return D.25753;
        <D.25752>:
        i.71 = (unsigned int) i;
        D.25755 = i.71 * 4;
        D.25756 = type_argv + D.25755;
        D.25757 = &pclass->byval_arg;
        *D.25756 = D.25757;
      }
      i = i + 1;
      <D.23046>:
      if (i < type_argc) goto <D.23045>; else goto <D.23047>;
      <D.23047>:
      inst = mono_metadata_get_generic_inst (type_argc, type_argv);
      monoeg_g_free (type_argv);
      p.69 = p;
      *endbuf = p.69;
      D.25753 = inst;
      return D.25753;
    }
  finally
    {
      p = {CLOBBER};
    }
}


sig_matches_target (struct MonoAotModule * module, struct MonoMethod * target, guint8 * buf, guint8 * * endbuf)
{
  guint8 * p.72;
  struct MonoMethodSignature * D.25761;
  int iftmp.73;
  struct MonoMethodSignature * D.25766;
  int D.25767;
  gboolean D.25769;
  struct MonoMethodSignature * sig;
  gboolean res;
  guint8 * p;

  try
    {
      p = buf;
      p.72 = p;
      D.25761 = mono_method_signature (target);
      sig = decode_signature_with_target (module, D.25761, p.72, &p);
      if (sig != 0B) goto <D.25765>; else goto <D.25763>;
      <D.25765>:
      D.25766 = mono_method_signature (target);
      D.25767 = mono_metadata_signature_equal (D.25766, sig);
      if (D.25767 != 0) goto <D.25768>; else goto <D.25763>;
      <D.25768>:
      iftmp.73 = 1;
      goto <D.25764>;
      <D.25763>:
      iftmp.73 = 0;
      <D.25764>:
      res = iftmp.73;
      monoeg_g_free (sig);
      p.72 = p;
      *endbuf = p.72;
      D.25769 = res;
      return D.25769;
    }
  finally
    {
      p = {CLOBBER};
    }
}


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

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


decode_resolve_method_ref_with_target (struct MonoAotModule * module, struct MonoMethod * target, guint8 * buf, guint8 * * endbuf)
{
  struct MonoMethod * D.25776;
  struct MonoMethod * D.25777;
  struct MonoImage * D.25780;
  unsigned int D.25783;
  struct MethodRef ref;
  gboolean res;

  try
    {
      res = decode_method_ref_with_target (module, &ref, target, buf, endbuf);
      if (res == 0) goto <D.25774>; else goto <D.25775>;
      <D.25774>:
      D.25776 = 0B;
      return D.25776;
      <D.25775>:
      D.25777 = ref.method;
      if (D.25777 != 0B) goto <D.25778>; else goto <D.25779>;
      <D.25778>:
      D.25776 = ref.method;
      return D.25776;
      <D.25779>:
      D.25780 = ref.image;
      if (D.25780 == 0B) goto <D.25781>; else goto <D.25782>;
      <D.25781>:
      D.25776 = 0B;
      return D.25776;
      <D.25782>:
      D.25783 = ref.token;
      D.25780 = ref.image;
      D.25776 = mono_get_method (D.25780, D.25783, 0B);
      return D.25776;
    }
  finally
    {
      ref = {CLOBBER};
    }
}


decode_generic_context (struct MonoAotModule * module, struct MonoGenericContext * ctx, guint8 * buf, guint8 * * endbuf)
{
  guint8 * p.74;
  struct MonoGenericInst * D.25789;
  struct MonoGenericInst * D.25790;
  gboolean D.25793;
  struct MonoGenericInst * D.25796;
  struct MonoGenericInst * D.25797;
  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.25787>; else goto <D.25788>;
      <D.25787>:
      p = p2;
      p.74 = p;
      D.25789 = decode_generic_inst (module, p.74, &p);
      ctx->class_inst = D.25789;
      D.25790 = ctx->class_inst;
      if (D.25790 == 0B) goto <D.25791>; else goto <D.25792>;
      <D.25791>:
      D.25793 = 0;
      return D.25793;
      <D.25792>:
      <D.25788>:
      p2 = p;
      p.74 = p;
      argc = decode_value (p.74, &p);
      if (argc != 0) goto <D.25794>; else goto <D.25795>;
      <D.25794>:
      p = p2;
      p.74 = p;
      D.25796 = decode_generic_inst (module, p.74, &p);
      ctx->method_inst = D.25796;
      D.25797 = ctx->method_inst;
      if (D.25797 == 0B) goto <D.25798>; else goto <D.25799>;
      <D.25798>:
      D.25793 = 0;
      return D.25793;
      <D.25799>:
      <D.25795>:
      p.74 = p;
      *endbuf = p.74;
      D.25793 = 1;
      return D.25793;
    }
  finally
    {
      p = {CLOBBER};
    }
}


decode_klass_ref (struct MonoAotModule * module, guint8 * buf, guint8 * * endbuf)
{
  guint8 * p.75;
  struct MonoClass * D.25805;
  int D.25806;
  unsigned int D.25809;
  int D.25810;
  int D.25811;
  int D.25814;
  struct MonoAssembly * D.25815;
  struct MonoGenericContainer * D.25820;
  _Bool D.25821;
  long int D.25822;
  long int D.25823;
  struct MonoGenericInst * D.25826;
  struct MonoGenericInst * D.25827;
  struct MonoType * D.25830;
  _Bool D.25835;
  long int D.25836;
  long int D.25837;
  _Bool D.25843;
  long int D.25844;
  long int D.25845;
  unsigned char D.25851;
  struct MonoGenericParamFull * D.25854;
  unsigned int num.76;
  unsigned int D.25856;
  struct MonoGenericParam * D.25857;
  _Bool D.25858;
  long int D.25859;
  long int D.25860;
  short unsigned int D.25864;
  short unsigned int D.25865;
  struct MonoImage * D.25866;
  int D.25867;
  int D.25870;
  guint8 * D.25871;
  guint8 * p2.77;
  guint8 * p2.78;
  _Bool D.25874;
  long int D.25875;
  long int D.25876;
  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.25803>; else goto <D.25804>;
      <D.25803>:
      p.75 = p;
      *endbuf = p.75;
      D.25805 = 0B;
      return D.25805;
      <D.25804>:
      switch (reftype) <default: <D.23095>, case 1: <D.23070>, case 2: <D.23072>, case 3: <D.23073>, case 4: <D.23074>, case 5: <D.23078>, case 6: <D.23089>, case 7: <D.23092>, case 8: <D.23090>>
      <D.23070>:
      p.75 = p;
      D.25806 = decode_value (p.75, &p);
      idx = (guint32) D.25806;
      image = load_image (module, 0, 1);
      if (image == 0B) goto <D.25807>; else goto <D.25808>;
      <D.25807>:
      D.25805 = 0B;
      return D.25805;
      <D.25808>:
      D.25809 = idx + 33554432;
      klass = mono_class_get (image, D.25809);
      goto <D.23071>;
      <D.23072>:
      p.75 = p;
      D.25810 = decode_value (p.75, &p);
      idx = (guint32) D.25810;
      p.75 = p;
      D.25811 = decode_value (p.75, &p);
      image = load_image (module, D.25811, 1);
      if (image == 0B) goto <D.25812>; else goto <D.25813>;
      <D.25812>:
      D.25805 = 0B;
      return D.25805;
      <D.25813>:
      D.25809 = idx + 33554432;
      klass = mono_class_get (image, D.25809);
      goto <D.23071>;
      <D.23073>:
      p.75 = p;
      D.25814 = decode_value (p.75, &p);
      token = (guint32) D.25814;
      D.25815 = module->assembly;
      image = D.25815->image;
      if (image == 0B) goto <D.25816>; else goto <D.25817>;
      <D.25816>:
      D.25805 = 0B;
      return D.25805;
      <D.25817>:
      klass = mono_class_get (image, token);
      goto <D.23071>;
      <D.23074>:
      {
        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.25818>; else goto <D.25819>;
            <D.25818>:
            D.25805 = 0B;
            return D.25805;
            <D.25819>:
            D.25820 = gclass->generic_container;
            D.25821 = D.25820 == 0B;
            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", 435, "gclass->generic_container");
            <D.25825>:
            memset (&ctx, 0, 8);
            p.75 = p;
            D.25826 = decode_generic_inst (module, p.75, &p);
            ctx.class_inst = D.25826;
            D.25827 = ctx.class_inst;
            if (D.25827 == 0B) goto <D.25828>; else goto <D.25829>;
            <D.25828>:
            D.25805 = 0B;
            return D.25805;
            <D.25829>:
            D.25830 = &gclass->byval_arg;
            type = mono_class_inflate_generic_type (D.25830, &ctx);
            klass = mono_class_from_mono_type (type);
            mono_metadata_free_type (type);
            goto <D.23071>;
          }
        finally
          {
            ctx = {CLOBBER};
          }
      }
      <D.23078>:
      {
        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.25831>; else goto <D.25832>;
        <D.25831>:
        {
          gboolean is_method;

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

            D.25835 = type != 30;
            D.25836 = (long int) D.25835;
            D.25837 = __builtin_expect (D.25836, 0);
            if (D.25837 != 0) goto <D.25838>; else goto <D.25839>;
            <D.25838>:
            monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "aot-runtime.c", 459, "type == MONO_TYPE_MVAR");
            <D.25839>:
            p.75 = p;
            method_def = decode_resolve_method_ref (module, p.75, &p);
            if (method_def == 0B) goto <D.25840>; else goto <D.25841>;
            <D.25840>:
            D.25805 = 0B;
            return D.25805;
            <D.25841>:
            container = mono_method_get_generic_container (method_def);
          }
          goto <D.25842>;
          <D.25834>:
          {
            struct MonoClass * class_def;

            D.25843 = type != 19;
            D.25844 = (long int) D.25843;
            D.25845 = __builtin_expect (D.25844, 0);
            if (D.25845 != 0) goto <D.25846>; else goto <D.25847>;
            <D.25846>:
            monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "aot-runtime.c", 467, "type == MONO_TYPE_VAR");
            <D.25847>:
            p.75 = p;
            class_def = decode_klass_ref (module, p.75, &p);
            if (class_def == 0B) goto <D.25848>; else goto <D.25849>;
            <D.25848>:
            D.25805 = 0B;
            return D.25805;
            <D.25849>:
            container = class_def->generic_container;
          }
          <D.25842>:
        }
        goto <D.25850>;
        <D.25832>:
        p.75 = p;
        serial = decode_value (p.75, &p);
        <D.25850>:
        t = monoeg_malloc0 (8);
        D.25851 = (unsigned char) type;
        t->type = D.25851;
        if (container != 0B) goto <D.25852>; else goto <D.25853>;
        <D.25852>:
        D.25854 = container->type_params;
        num.76 = (unsigned int) num;
        D.25856 = num.76 * 32;
        D.25857 = D.25854 + D.25856;
        t->data.generic_param = D.25857;
        D.25858 = serial != 0;
        D.25859 = (long int) D.25858;
        D.25860 = __builtin_expect (D.25859, 0);
        if (D.25860 != 0) goto <D.25861>; else goto <D.25862>;
        <D.25861>:
        monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "aot-runtime.c", 483, "serial == 0");
        <D.25862>:
        goto <D.25863>;
        <D.25853>:
        {
          struct MonoGenericParam * par;

          par = monoeg_malloc0 (32);
          D.25864 = (short unsigned int) num;
          par->num = D.25864;
          D.25865 = (short unsigned int) serial;
          par->serial = D.25865;
          D.25866 = mono_defaults.corlib;
          par->image = D.25866;
          t->data.generic_param = par;
        }
        <D.25863>:
        klass = mono_class_from_mono_type (t);
        monoeg_g_free (t);
        goto <D.23071>;
      }
      <D.23089>:
      p.75 = p;
      D.25867 = decode_value (p.75, &p);
      rank = (guint32) D.25867;
      p.75 = p;
      eklass = decode_klass_ref (module, p.75, &p);
      klass = mono_array_class_get (eklass, rank);
      goto <D.23071>;
      <D.23090>:
      {
        struct MonoType * t;

        p.75 = p;
        t = decode_type (module, p.75, &p);
        if (t == 0B) goto <D.25868>; else goto <D.25869>;
        <D.25868>:
        D.25805 = 0B;
        return D.25805;
        <D.25869>:
        klass = mono_class_from_mono_type (t);
        monoeg_g_free (t);
        goto <D.23071>;
      }
      <D.23092>:
      {
        guint32 offset;
        guint8 * p2;

        try
          {
            p.75 = p;
            D.25870 = decode_value (p.75, &p);
            offset = (guint32) D.25870;
            D.25871 = module->blob;
            p2.77 = D.25871 + offset;
            p2 = p2.77;
            p2.78 = p2;
            klass = decode_klass_ref (module, p2.78, &p2);
            goto <D.23071>;
          }
        finally
          {
            p2 = {CLOBBER};
          }
      }
      <D.23095>:
      monoeg_assertion_message ("* Assertion: should not be reached at %s:%d\n", "aot-runtime.c", 526);
      <D.23071>:
      D.25874 = klass == 0B;
      D.25875 = (long int) D.25874;
      D.25876 = __builtin_expect (D.25875, 0);
      if (D.25876 != 0) goto <D.25877>; else goto <D.25878>;
      <D.25877>:
      monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "aot-runtime.c", 528, "klass");
      <D.25878>:
      p.75 = p;
      *endbuf = p.75;
      D.25805 = klass;
      return D.25805;
    }
  finally
    {
      p = {CLOBBER};
    }
}


mono_aot_get_cached_class_info (struct MonoClass * klass, struct MonoCachedClassInfo * res)
{
  struct MonoImage * D.25884;
  unsigned char D.25887;
  gboolean D.25889;
  guint8 * D.25890;
  unsigned int D.25891;
  unsigned int D.25892;
  unsigned int D.25893;
  int D.25894;
  guint32 * D.25895;
  unsigned int D.25896;
  guint8 * p.79;
  guint8 * p.80;
  struct MonoAotModule * amodule;
  guint8 * p;
  gboolean err;

  try
    {
      D.25884 = klass->image;
      amodule = D.25884->aot_module;
      D.25887 = klass->rank;
      if (D.25887 != 0) goto <D.25885>; else goto <D.25888>;
      <D.25888>:
      if (amodule == 0B) goto <D.25885>; else goto <D.25886>;
      <D.25885>:
      D.25889 = 0;
      return D.25889;
      <D.25886>:
      D.25890 = amodule->blob;
      D.25891 = klass->type_token;
      D.25892 = D.25891 & 16777215;
      D.25893 = D.25892 + 4294967295;
      D.25894 = (int) D.25893;
      D.25895 = amodule->class_info_offsets;
      D.25896 = mono_aot_get_offset (D.25895, D.25894);
      p.79 = D.25890 + D.25896;
      p = p.79;
      p.80 = p;
      err = decode_cached_class_info (amodule, res, p.80, &p);
      if (err == 0) goto <D.25899>; else goto <D.25900>;
      <D.25899>:
      D.25889 = 0;
      return D.25889;
      <D.25900>:
      D.25889 = 1;
      return D.25889;
    }
  finally
    {
      p = {CLOBBER};
    }
}


mono_aot_get_class_from_name (struct MonoImage * image, const char * name_space, const char * name, struct MonoClass * * klass)
{
  guint16 * D.25906;
  gboolean D.25907;
  _Bool D.25910;
  long int D.25911;
  long int D.25912;
  struct GHashTable * D.25915;
  struct GHashTable * D.25918;
  void * D.25921;
  struct MonoClass * D.25922;
  _Bool D.25927;
  long int D.25928;
  long int D.25929;
  char D.25932;
  unsigned int D.25936;
  unsigned int D.25937;
  unsigned int D.25938;
  unsigned int D.25942;
  unsigned int D.25943;
  unsigned int D.25946;
  short unsigned int D.25947;
  guint16 * D.25950;
  short unsigned int D.25951;
  unsigned int name_table_accesses.81;
  unsigned int name_table_accesses.82;
  unsigned int D.25954;
  int D.25955;
  unsigned int D.25956;
  unsigned int D.25957;
  int D.23555;
  int D.23564;
  _Bool D.25964;
  long int D.25965;
  long int D.25966;
  struct MonoClass * D.25969;
  _Bool D.25974;
  long int D.25975;
  long int D.25976;
  _Bool D.25983;
  long int D.25984;
  long int D.25985;
  unsigned int D.25989;
  _Bool D.25992;
  long int D.25993;
  long int D.25994;
  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.25903>; else goto <D.25905>;
      <D.25905>:
      D.25906 = amodule->class_name_table;
      if (D.25906 == 0B) goto <D.25903>; else goto <D.25904>;
      <D.25903>:
      D.25907 = 0;
      return D.25907;
      <D.25904>:
      {
        int ret;

        ret = pthread_mutex_lock (&aot_mutex.mutex);
        if (ret != 0) goto <D.25908>; else goto <D.25909>;
        <D.25908>:
        monoeg_g_log (0B, 16, "Bad call to mono_mutex_lock result %d", ret);
        <D.25909>:
        D.25910 = ret != 0;
        D.25911 = (long int) D.25910;
        D.25912 = __builtin_expect (D.25911, 0);
        if (D.25912 != 0) goto <D.25913>; else goto <D.25914>;
        <D.25913>:
        monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "aot-runtime.c", 2065, "ret == 0");
        <D.25914>:
      }
      *klass = 0B;
      D.25915 = amodule->name_cache;
      if (D.25915 == 0B) goto <D.25916>; else goto <D.25917>;
      <D.25916>:
      D.25918 = monoeg_g_hash_table_new (monoeg_g_str_hash, monoeg_g_str_equal);
      amodule->name_cache = D.25918;
      <D.25917>:
      D.25915 = amodule->name_cache;
      nspace_table = monoeg_g_hash_table_lookup (D.25915, name_space);
      if (nspace_table != 0B) goto <D.25919>; else goto <D.25920>;
      <D.25919>:
      D.25921 = monoeg_g_hash_table_lookup (nspace_table, name);
      *klass = D.25921;
      D.25922 = *klass;
      if (D.25922 != 0B) goto <D.25923>; else goto <D.25924>;
      <D.25923>:
      {
        int ret;

        ret = pthread_mutex_unlock (&aot_mutex.mutex);
        if (ret != 0) goto <D.25925>; else goto <D.25926>;
        <D.25925>:
        monoeg_g_log (0B, 16, "Bad call to mono_mutex_unlock result %d", ret);
        <D.25926>:
        D.25927 = ret != 0;
        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", 2076, "ret == 0");
        <D.25931>:
      }
      D.25907 = 1;
      return D.25907;
      <D.25924>:
      <D.25920>:
      D.25906 = amodule->class_name_table;
      table_size = *D.25906;
      D.25906 = amodule->class_name_table;
      table = D.25906 + 2;
      D.25932 = *name_space;
      if (D.25932 == 0) goto <D.25933>; else goto <D.25934>;
      <D.25933>:
      full_name = monoeg_g_strdup_printf ("%s", name);
      goto <D.25935>;
      <D.25934>:
      D.25936 = strlen (name_space);
      D.25937 = strlen (name);
      D.25938 = D.25936 + D.25937;
      if (D.25938 <= 999) goto <D.25939>; else goto <D.25940>;
      <D.25939>:
      sprintf (&full_name_buf, "%s.%s", name_space, name);
      full_name = &full_name_buf;
      goto <D.25941>;
      <D.25940>:
      full_name = monoeg_g_strdup_printf ("%s.%s", name_space, name);
      <D.25941>:
      <D.25935>:
      D.25942 = mono_metadata_str_hash (full_name);
      D.25943 = (unsigned int) table_size;
      hash = D.25942 % D.25943;
      if (&full_name_buf != full_name) goto <D.25944>; else goto <D.25945>;
      <D.25944>:
      monoeg_g_free (full_name);
      <D.25945>:
      D.25946 = hash * 4;
      entry = table + D.25946;
      D.25947 = *entry;
      if (D.25947 != 0) goto <D.25948>; else goto <D.25949>;
      <D.25948>:
      t = &image->tables[2];
      <D.23569>:
      {
        guint32 index;
        guint32 next;
        guint32 token;

        D.25947 = *entry;
        index = (guint32) D.25947;
        D.25950 = entry + 2;
        D.25951 = *D.25950;
        next = (guint32) D.25951;
        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.25954 = index + 4294967295;
        D.25955 = (int) D.25954;
        mono_metadata_decode_row (t, D.25955, &cols, 6);
        D.25956 = cols[1];
        name2 = mono_metadata_string_heap (image, D.25956);
        D.25957 = cols[2];
        name_space2 = mono_metadata_string_heap (image, D.25957);
        {
          size_t __s1_len;
          size_t __s2_len;

          D.23555 = __builtin_strcmp (name, name2);
        }
        if (D.23555 == 0) goto <D.25958>; else goto <D.25959>;
        <D.25958>:
        {
          size_t __s1_len;
          size_t __s2_len;

          D.23564 = __builtin_strcmp (name_space, name_space2);
        }
        if (D.23564 == 0) goto <D.25960>; else goto <D.25961>;
        <D.25960>:
        {
          int ret;

          ret = pthread_mutex_unlock (&aot_mutex.mutex);
          if (ret != 0) goto <D.25962>; else goto <D.25963>;
          <D.25962>:
          monoeg_g_log (0B, 16, "Bad call to mono_mutex_unlock result %d", ret);
          <D.25963>:
          D.25964 = ret != 0;
          D.25965 = (long int) D.25964;
          D.25966 = __builtin_expect (D.25965, 0);
          if (D.25966 != 0) goto <D.25967>; else goto <D.25968>;
          <D.25967>:
          monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "aot-runtime.c", 2116, "ret == 0");
          <D.25968>:
        }
        D.25969 = mono_class_get (image, token);
        *klass = D.25969;
        D.25922 = *klass;
        if (D.25922 != 0B) goto <D.25970>; else goto <D.25971>;
        <D.25970>:
        {
          int ret;

          ret = pthread_mutex_lock (&aot_mutex.mutex);
          if (ret != 0) goto <D.25972>; else goto <D.25973>;
          <D.25972>:
          monoeg_g_log (0B, 16, "Bad call to mono_mutex_lock result %d", ret);
          <D.25973>:
          D.25974 = ret != 0;
          D.25975 = (long int) D.25974;
          D.25976 = __builtin_expect (D.25975, 0);
          if (D.25976 != 0) goto <D.25977>; else goto <D.25978>;
          <D.25977>:
          monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "aot-runtime.c", 2121, "ret == 0");
          <D.25978>:
        }
        D.25915 = amodule->name_cache;
        nspace_table = monoeg_g_hash_table_lookup (D.25915, name_space);
        if (nspace_table == 0B) goto <D.25979>; else goto <D.25980>;
        <D.25979>:
        nspace_table = monoeg_g_hash_table_new (monoeg_g_str_hash, monoeg_g_str_equal);
        D.25915 = amodule->name_cache;
        monoeg_g_hash_table_insert_replace (D.25915, name_space2, nspace_table, 0);
        <D.25980>:
        D.25922 = *klass;
        monoeg_g_hash_table_insert_replace (nspace_table, name2, D.25922, 0);
        {
          int ret;

          ret = pthread_mutex_unlock (&aot_mutex.mutex);
          if (ret != 0) goto <D.25981>; else goto <D.25982>;
          <D.25981>:
          monoeg_g_log (0B, 16, "Bad call to mono_mutex_unlock result %d", ret);
          <D.25982>:
          D.25983 = ret != 0;
          D.25984 = (long int) D.25983;
          D.25985 = __builtin_expect (D.25984, 0);
          if (D.25985 != 0) goto <D.25986>; else goto <D.25987>;
          <D.25986>:
          monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "aot-runtime.c", 2128, "ret == 0");
          <D.25987>:
        }
        <D.25971>:
        D.25907 = 1;
        return D.25907;
        <D.25961>:
        <D.25959>:
        if (next != 0) goto <D.25988>; else goto <D.23568>;
        <D.25988>:
        D.25989 = next * 4;
        entry = table + D.25989;
      }
      goto <D.23569>;
      <D.23568>:
      <D.25949>:
      {
        int ret;

        ret = pthread_mutex_unlock (&aot_mutex.mutex);
        if (ret != 0) goto <D.25990>; else goto <D.25991>;
        <D.25990>:
        monoeg_g_log (0B, 16, "Bad call to mono_mutex_unlock result %d", ret);
        <D.25991>:
        D.25992 = ret != 0;
        D.25993 = (long int) D.25992;
        D.25994 = __builtin_expect (D.25993, 0);
        if (D.25994 != 0) goto <D.25995>; else goto <D.25996>;
        <D.25995>:
        monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "aot-runtime.c", 2141, "ret == 0");
        <D.25996>:
      }
      D.25907 = 1;
      return D.25907;
    }
  finally
    {
      full_name_buf = {CLOBBER};
      cols = {CLOBBER};
    }
}


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

  D.26000 = __builtin_object_size (__s, 1);
  D.25999 = __builtin___sprintf_chk (__s, 1, D.26000, __fmt, __builtin_va_arg_pack ());
  return D.25999;
}


mono_aot_get_unwind_info (struct MonoJitInfo * ji, guint32 * unwind_info_len)
{
  unsigned char D.26002;
  unsigned char D.26003;
  struct MonoMethod * D.26007;
  struct MonoClass * D.26008;
  struct MonoImage * D.26009;
  _Bool D.26010;
  long int D.26011;
  long int D.26012;
  unsigned char D.26015;
  unsigned char D.26016;
  _Bool D.26017;
  long int D.26018;
  long int D.26019;
  guint8 * D.26024;
  guint8 * D.26026;
  _Bool D.26029;
  long int D.26030;
  long int D.26031;
  struct GHashTable * ji_to_amodule.83;
  _Bool D.26035;
  long int D.26036;
  long int D.26037;
  int iftmp.84;
  _Bool D.26047;
  long int D.26048;
  long int D.26049;
  _Bool D.26054;
  long int D.26055;
  long int D.26056;
  guint8 * D.26059;
  unsigned int D.26060;
  guint8 * p.85;
  guint8 * p.86;
  int D.26063;
  unsigned int D.26064;
  guint8 * D.26065;
  struct MonoAotModule * amodule;
  guint8 * p;
  guint8 * code;

  try
    {
      code = ji->code_start;
      D.26002 = BIT_FIELD_REF <*ji, 8, 184>;
      D.26003 = D.26002 & 1;
      if (D.26003 != 0) goto <D.26004>; else goto <D.26005>;
      <D.26004>:
      amodule = ji->d.aot_info;
      goto <D.26006>;
      <D.26005>:
      D.26007 = jinfo_get_method (ji);
      D.26008 = D.26007->klass;
      D.26009 = D.26008->image;
      amodule = D.26009->aot_module;
      <D.26006>:
      D.26010 = amodule == 0B;
      D.26011 = (long int) D.26010;
      D.26012 = __builtin_expect (D.26011, 0);
      if (D.26012 != 0) goto <D.26013>; else goto <D.26014>;
      <D.26013>:
      monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "aot-runtime.c", 2655, "amodule");
      <D.26014>:
      D.26015 = BIT_FIELD_REF <*ji, 8, 176>;
      D.26016 = D.26015 & 16;
      D.26017 = D.26016 == 0;
      D.26018 = (long int) D.26017;
      D.26019 = __builtin_expect (D.26018, 0);
      if (D.26019 != 0) goto <D.26020>; else goto <D.26021>;
      <D.26020>:
      monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "aot-runtime.c", 2656, "ji->from_aot");
      <D.26021>:
      D.26024 = amodule->code;
      if (D.26024 > code) goto <D.26022>; else goto <D.26025>;
      <D.26025>:
      D.26026 = amodule->code_end;
      if (D.26026 < code) goto <D.26022>; else goto <D.26023>;
      <D.26022>:
      {
        int ret;

        ret = pthread_mutex_lock (&aot_mutex.mutex);
        if (ret != 0) goto <D.26027>; else goto <D.26028>;
        <D.26027>:
        monoeg_g_log (0B, 16, "Bad call to mono_mutex_lock result %d", ret);
        <D.26028>:
        D.26029 = ret != 0;
        D.26030 = (long int) D.26029;
        D.26031 = __builtin_expect (D.26030, 0);
        if (D.26031 != 0) goto <D.26032>; else goto <D.26033>;
        <D.26032>:
        monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "aot-runtime.c", 2660, "ret == 0");
        <D.26033>:
      }
      ji_to_amodule.83 = ji_to_amodule;
      D.26035 = ji_to_amodule.83 == 0B;
      D.26036 = (long int) D.26035;
      D.26037 = __builtin_expect (D.26036, 0);
      if (D.26037 != 0) goto <D.26038>; else goto <D.26039>;
      <D.26038>:
      monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "aot-runtime.c", 2661, "ji_to_amodule");
      <D.26039>:
      ji_to_amodule.83 = ji_to_amodule;
      amodule = monoeg_g_hash_table_lookup (ji_to_amodule.83, ji);
      D.26010 = amodule == 0B;
      D.26011 = (long int) D.26010;
      D.26012 = __builtin_expect (D.26011, 0);
      if (D.26012 != 0) goto <D.26040>; else goto <D.26041>;
      <D.26040>:
      monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "aot-runtime.c", 2663, "amodule");
      <D.26041>:
      D.26024 = amodule->code;
      if (D.26024 > code) goto <D.26043>; else goto <D.26046>;
      <D.26046>:
      D.26026 = amodule->code_end;
      if (D.26026 < code) goto <D.26043>; else goto <D.26044>;
      <D.26043>:
      iftmp.84 = 1;
      goto <D.26045>;
      <D.26044>:
      iftmp.84 = 0;
      <D.26045>:
      D.26047 = iftmp.84 != 0;
      D.26048 = (long int) D.26047;
      D.26049 = __builtin_expect (D.26048, 0);
      if (D.26049 != 0) goto <D.26050>; else goto <D.26051>;
      <D.26050>:
      monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "aot-runtime.c", 2664, "code >= amodule->code && code <= amodule->code_end");
      <D.26051>:
      {
        int ret;

        ret = pthread_mutex_unlock (&aot_mutex.mutex);
        if (ret != 0) goto <D.26052>; else goto <D.26053>;
        <D.26052>:
        monoeg_g_log (0B, 16, "Bad call to mono_mutex_unlock result %d", ret);
        <D.26053>:
        D.26054 = ret != 0;
        D.26055 = (long int) D.26054;
        D.26056 = __builtin_expect (D.26055, 0);
        if (D.26056 != 0) goto <D.26057>; else goto <D.26058>;
        <D.26057>:
        monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "aot-runtime.c", 2665, "ret == 0");
        <D.26058>:
      }
      <D.26023>:
      D.26059 = amodule->unwind_info;
      D.26060 = ji->used_regs;
      p.85 = D.26059 + D.26060;
      p = p.85;
      p.86 = p;
      D.26063 = decode_value (p.86, &p);
      D.26064 = (unsigned int) D.26063;
      *unwind_info_len = D.26064;
      D.26065 = p;
      return D.26065;
    }
  finally
    {
      p = {CLOBBER};
    }
}


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

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


mono_aot_find_jit_info (struct MonoDomain * domain, struct MonoImage * image, void * addr)
{
  unsigned int D.26070;
  struct MonoJitInfo * D.26073;
  struct MonoDomain * D.26074;
  int addr.87;
  guint8 * D.26078;
  int D.26079;
  gint32 * D.26080;
  unsigned int nmethods.88;
  unsigned int D.26084;
  gint32 * D.26085;
  unsigned int i.89;
  unsigned int D.26087;
  gint32 * D.26088;
  int D.26089;
  unsigned int offsets_len.90;
  unsigned int D.26093;
  gint32 * D.26094;
  sizetype offsets_len.91;
  sizetype D.26096;
  sizetype D.26097;
  gint32 * D.26098;
  unsigned int D.26099;
  gint32 * D.26100;
  int D.26101;
  int D.26102;
  unsigned int D.26103;
  unsigned int D.26104;
  gint32 * D.26105;
  int D.26106;
  _Bool D.26107;
  long int D.26108;
  long int D.26109;
  int D.26112;
  gint32 * * D.26113;
  void * D.26114;
  int D.26121;
  guint8 * D.26123;
  int D.26124;
  int D.26125;
  int D.26126;
  unsigned int pos.92;
  unsigned int D.26128;
  gint32 * D.26129;
  int D.26130;
  unsigned int D.26134;
  unsigned int D.26135;
  gint32 * D.26136;
  int D.26141;
  _Bool D.26142;
  long int D.26143;
  long int D.26144;
  int D.26149;
  _Bool D.26150;
  long int D.26151;
  long int D.26152;
  sizetype pos.93;
  sizetype D.26156;
  sizetype D.26157;
  gint32 * D.26158;
  struct JitInfoMap * D.26163;
  int D.26164;
  unsigned int method_index.94;
  unsigned int D.26168;
  gint32 * D.26169;
  int D.26170;
  sizetype D.26171;
  guint8 * D.26172;
  guint32 * D.26173;
  unsigned int D.26174;
  int code.95;
  int iftmp.96;
  sizetype code_len.97;
  guint8 * D.26185;
  _Bool D.26186;
  long int D.26187;
  long int D.26188;
  struct GHashTable * D.26193;
  _Bool D.26198;
  long int D.26199;
  long int D.26200;
  const void * method_index.98;
  _Bool D.26206;
  long int D.26207;
  long int D.26208;
  <unnamed-unsigned:24> D.26214;
  int D.26215;
  guint32 * D.26218;
  unsigned int D.26219;
  _Bool D.26220;
  long int D.26221;
  long int D.26222;
  guint32 * D.26225;
  unsigned int D.26226;
  unsigned int method_index.99;
  guint32 * D.26232;
  unsigned int D.26233;
  guint8 * p.100;
  guint8 * p.101;
  int D.26239;
  int D.26240;
  _Bool D.26241;
  long int D.26242;
  long int D.26243;
  unsigned int code_len.102;
  void * D.26247;
  _Bool D.26248;
  long int D.26249;
  long int D.26250;
  int D.26253;
  sizetype D.26254;
  guint8 * D.26255;
  _Bool D.26256;
  long int D.26257;
  long int D.26258;
  int D.26266;
  unsigned int D.26267;
  unsigned int D.26268;
  int D.26269;
  unsigned int len.103;
  unsigned int D.26273;
  struct JitInfoMap * D.26274;
  struct JitInfoMap * * D.26275;
  void * D.26276;
  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.26070 = amodule->info.nmethods;
      nmethods = (int) D.26070;
      if (amodule == 0B) goto <D.26071>; else goto <D.26072>;
      <D.26071>:
      D.26073 = 0B;
      return D.26073;
      <D.26072>:
      D.26074 = mono_get_root_domain ();
      if (D.26074 != domain) goto <D.26075>; else goto <D.26076>;
      <D.26075>:
      D.26073 = 0B;
      return D.26073;
      <D.26076>:
      async = mono_thread_info_is_async_context ();
      addr.87 = (int) addr;
      D.26078 = amodule->code;
      D.26079 = (int) D.26078;
      offset = addr.87 - D.26079;
      D.26080 = amodule->sorted_code_offsets;
      if (D.26080 == 0B) goto <D.26081>; else goto <D.26082>;
      <D.26081>:
      nmethods.88 = (unsigned int) nmethods;
      D.26084 = nmethods.88 * 8;
      code_offsets = monoeg_malloc0 (D.26084);
      offsets_len = 0;
      i = 0;
      goto <D.23809>;
      <D.23808>:
      D.26085 = amodule->code_offsets;
      i.89 = (unsigned int) i;
      D.26087 = i.89 * 4;
      D.26088 = D.26085 + D.26087;
      D.26089 = *D.26088;
      if (D.26089 == -1) goto <D.26090>; else goto <D.26091>;
      <D.26090>:
      // predicted unlikely by continue predictor.
      goto <D.23807>;
      <D.26091>:
      offsets_len.90 = (unsigned int) offsets_len;
      D.26093 = offsets_len.90 * 8;
      D.26094 = code_offsets + D.26093;
      D.26085 = amodule->code_offsets;
      i.89 = (unsigned int) i;
      D.26087 = i.89 * 4;
      D.26088 = D.26085 + D.26087;
      D.26089 = *D.26088;
      *D.26094 = D.26089;
      offsets_len.91 = (sizetype) offsets_len;
      D.26096 = offsets_len.91 * 8;
      D.26097 = D.26096 + 4;
      D.26098 = code_offsets + D.26097;
      *D.26098 = i;
      offsets_len = offsets_len + 1;
      <D.23807>:
      i = i + 1;
      <D.23809>:
      if (i < nmethods) goto <D.23808>; else goto <D.23810>;
      <D.23810>:
      msort_code_offsets (code_offsets, offsets_len);
      i = 0;
      goto <D.23812>;
      <D.23811>:
      i.89 = (unsigned int) i;
      D.26099 = i.89 * 8;
      D.26100 = code_offsets + D.26099;
      D.26101 = *D.26100;
      D.26102 = i + 1;
      D.26103 = (unsigned int) D.26102;
      D.26104 = D.26103 * 8;
      D.26105 = code_offsets + D.26104;
      D.26106 = *D.26105;
      D.26107 = D.26101 > D.26106;
      D.26108 = (long int) D.26107;
      D.26109 = __builtin_expect (D.26108, 0);
      if (D.26109 != 0) goto <D.26110>; else goto <D.26111>;
      <D.26110>:
      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.26111>:
      i = i + 1;
      <D.23812>:
      D.26112 = offsets_len + -1;
      if (D.26112 > i) goto <D.23811>; else goto <D.23813>;
      <D.23813>:
      amodule->sorted_code_offsets_len = offsets_len;
      mono_memory_barrier ();
      D.26113 = &amodule->sorted_code_offsets;
      D.26114 = InterlockedCompareExchangePointer (D.26113, code_offsets, 0B);
      if (D.26114 != 0B) goto <D.26115>; else goto <D.26116>;
      <D.26115>:
      monoeg_g_free (code_offsets);
      <D.26116>:
      <D.26082>:
      code_offsets = amodule->sorted_code_offsets;
      offsets_len = amodule->sorted_code_offsets_len;
      if (offsets_len > 0) goto <D.26119>; else goto <D.26120>;
      <D.26119>:
      D.26121 = *code_offsets;
      if (D.26121 > offset) goto <D.26117>; else goto <D.26122>;
      <D.26122>:
      D.26123 = amodule->code_end;
      D.26124 = (int) D.26123;
      D.26078 = amodule->code;
      D.26079 = (int) D.26078;
      D.26125 = D.26124 - D.26079;
      if (D.26125 <= offset) goto <D.26117>; else goto <D.26118>;
      <D.26117>:
      D.26073 = 0B;
      return D.26073;
      <D.26118>:
      <D.26120>:
      left = 0;
      right = offsets_len;
      <D.23815>:
      D.26126 = left + right;
      pos = D.26126 / 2;
      pos.92 = (unsigned int) pos;
      D.26128 = pos.92 * 8;
      D.26129 = code_offsets + D.26128;
      offset1 = *D.26129;
      D.26130 = pos + 1;
      if (D.26130 == offsets_len) goto <D.26131>; else goto <D.26132>;
      <D.26131>:
      D.26123 = amodule->code_end;
      D.26124 = (int) D.26123;
      D.26078 = amodule->code;
      D.26079 = (int) D.26078;
      offset2 = D.26124 - D.26079;
      goto <D.26133>;
      <D.26132>:
      D.26130 = pos + 1;
      D.26134 = (unsigned int) D.26130;
      D.26135 = D.26134 * 8;
      D.26136 = code_offsets + D.26135;
      offset2 = *D.26136;
      <D.26133>:
      if (offset < offset1) goto <D.26137>; else goto <D.26138>;
      <D.26137>:
      right = pos;
      goto <D.26139>;
      <D.26138>:
      if (offset >= offset2) goto <D.26140>; else goto <D.23814>;
      <D.26140>:
      left = pos + 1;
      <D.26139>:
      goto <D.23815>;
      <D.23814>:
      pos.92 = (unsigned int) pos;
      D.26128 = pos.92 * 8;
      D.26129 = code_offsets + D.26128;
      D.26141 = *D.26129;
      D.26142 = D.26141 > offset;
      D.26143 = (long int) D.26142;
      D.26144 = __builtin_expect (D.26143, 0);
      if (D.26144 != 0) goto <D.26145>; else goto <D.26146>;
      <D.26145>:
      monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "aot-runtime.c", 2819, "offset >= code_offsets [(pos * 2)]");
      <D.26146>:
      D.26130 = pos + 1;
      if (D.26130 < offsets_len) goto <D.26147>; else goto <D.26148>;
      <D.26147>:
      D.26130 = pos + 1;
      D.26134 = (unsigned int) D.26130;
      D.26135 = D.26134 * 8;
      D.26136 = code_offsets + D.26135;
      D.26149 = *D.26136;
      D.26150 = D.26149 <= offset;
      D.26151 = (long int) D.26150;
      D.26152 = __builtin_expect (D.26151, 0);
      if (D.26152 != 0) goto <D.26153>; else goto <D.26154>;
      <D.26153>:
      monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "aot-runtime.c", 2821, "offset < code_offsets [((pos + 1) * 2)]");
      <D.26154>:
      <D.26148>:
      pos.93 = (sizetype) pos;
      D.26156 = pos.93 * 8;
      D.26157 = D.26156 + 4;
      D.26158 = code_offsets + D.26157;
      method_index = *D.26158;
      if (async != 0) goto <D.26159>; else goto <D.26160>;
      <D.26159>:
      {
        struct JitInfoMap * table;
        int len;

        table = amodule->async_jit_info_table;
        if (table != 0B) goto <D.26161>; else goto <D.26162>;
        <D.26161>:
        len = table->method_index;
        i = 1;
        goto <D.23819>;
        <D.23818>:
        i.89 = (unsigned int) i;
        D.26099 = i.89 * 8;
        D.26163 = table + D.26099;
        D.26164 = D.26163->method_index;
        if (D.26164 == method_index) goto <D.26165>; else goto <D.26166>;
        <D.26165>:
        i.89 = (unsigned int) i;
        D.26099 = i.89 * 8;
        D.26163 = table + D.26099;
        D.26073 = D.26163->jinfo;
        return D.26073;
        <D.26166>:
        i = i + 1;
        <D.23819>:
        if (i < len) goto <D.23818>; else goto <D.23820>;
        <D.23820>:
        <D.26162>:
      }
      <D.26160>:
      D.26078 = amodule->code;
      D.26085 = amodule->code_offsets;
      method_index.94 = (unsigned int) method_index;
      D.26168 = method_index.94 * 4;
      D.26169 = D.26085 + D.26168;
      D.26170 = *D.26169;
      D.26171 = (sizetype) D.26170;
      code = D.26078 + D.26171;
      D.26172 = amodule->blob;
      D.26173 = amodule->ex_info_offsets;
      D.26174 = mono_aot_get_offset (D.26173, method_index);
      ex_info = D.26172 + D.26174;
      D.26112 = offsets_len + -1;
      if (D.26112 == pos) goto <D.26175>; else goto <D.26176>;
      <D.26175>:
      D.26123 = amodule->code_end;
      D.26124 = (int) D.26123;
      code.95 = (int) code;
      code_len = D.26124 - code.95;
      goto <D.26178>;
      <D.26176>:
      D.26130 = pos + 1;
      D.26134 = (unsigned int) D.26130;
      D.26135 = D.26134 * 8;
      D.26136 = code_offsets + D.26135;
      D.26149 = *D.26136;
      pos.92 = (unsigned int) pos;
      D.26128 = pos.92 * 8;
      D.26129 = code_offsets + D.26128;
      D.26141 = *D.26129;
      code_len = D.26149 - D.26141;
      <D.26178>:
      if (code > addr) goto <D.26180>; else goto <D.26183>;
      <D.26183>:
      code_len.97 = (sizetype) code_len;
      D.26185 = code + code_len.97;
      if (D.26185 <= addr) goto <D.26180>; else goto <D.26181>;
      <D.26180>:
      iftmp.96 = 1;
      goto <D.26182>;
      <D.26181>:
      iftmp.96 = 0;
      <D.26182>:
      D.26186 = iftmp.96 != 0;
      D.26187 = (long int) D.26186;
      D.26188 = __builtin_expect (D.26187, 0);
      if (D.26188 != 0) goto <D.26189>; else goto <D.26190>;
      <D.26189>:
      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.26190>:
      if (async == 0) goto <D.26191>; else goto <D.26192>;
      <D.26191>:
      D.26193 = amodule->extra_methods;
      if (D.26193 != 0B) goto <D.26194>; else goto <D.26195>;
      <D.26194>:
      {
        int ret;

        ret = pthread_mutex_lock (&aot_mutex.mutex);
        if (ret != 0) goto <D.26196>; else goto <D.26197>;
        <D.26196>:
        monoeg_g_log (0B, 16, "Bad call to mono_mutex_lock result %d", ret);
        <D.26197>:
        D.26198 = ret != 0;
        D.26199 = (long int) D.26198;
        D.26200 = __builtin_expect (D.26199, 0);
        if (D.26200 != 0) goto <D.26201>; else goto <D.26202>;
        <D.26201>:
        monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "aot-runtime.c", 2851, "ret == 0");
        <D.26202>:
      }
      method_index.98 = (const void *) method_index;
      D.26193 = amodule->extra_methods;
      method = monoeg_g_hash_table_lookup (D.26193, method_index.98);
      {
        int ret;

        ret = pthread_mutex_unlock (&aot_mutex.mutex);
        if (ret != 0) goto <D.26204>; else goto <D.26205>;
        <D.26204>:
        monoeg_g_log (0B, 16, "Bad call to mono_mutex_unlock result %d", ret);
        <D.26205>:
        D.26206 = ret != 0;
        D.26207 = (long int) D.26206;
        D.26208 = __builtin_expect (D.26207, 0);
        if (D.26208 != 0) goto <D.26209>; else goto <D.26210>;
        <D.26209>:
        monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "aot-runtime.c", 2853, "ret == 0");
        <D.26210>:
      }
      goto <D.26211>;
      <D.26195>:
      method = 0B;
      <D.26211>:
      if (method == 0B) goto <D.26212>; else goto <D.26213>;
      <D.26212>:
      D.26214 = image->tables[6].rows;
      D.26215 = (int) D.26214;
      if (D.26215 <= method_index) goto <D.26216>; else goto <D.26217>;
      <D.26216>:
      D.26218 = amodule->extra_method_info_offsets;
      D.26219 = *D.26218;
      table_len = (int) D.26219;
      D.26218 = amodule->extra_method_info_offsets;
      table = D.26218 + 4;
      left = 0;
      right = table_len;
      pos = 0;
      <D.23824>:
      D.26126 = left + right;
      pos = D.26126 / 2;
      D.26220 = pos >= table_len;
      D.26221 = (long int) D.26220;
      D.26222 = __builtin_expect (D.26221, 0);
      if (D.26222 != 0) goto <D.26223>; else goto <D.26224>;
      <D.26223>:
      monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "aot-runtime.c", 2874, "pos < table_len");
      <D.26224>:
      pos.92 = (unsigned int) pos;
      D.26128 = pos.92 * 8;
      D.26225 = table + D.26128;
      D.26226 = *D.26225;
      method_index.99 = (unsigned int) method_index;
      if (D.26226 < method_index.99) goto <D.26228>; else goto <D.26229>;
      <D.26228>:
      left = pos + 1;
      goto <D.26230>;
      <D.26229>:
      pos.92 = (unsigned int) pos;
      D.26128 = pos.92 * 8;
      D.26225 = table + D.26128;
      D.26226 = *D.26225;
      method_index.99 = (unsigned int) method_index;
      if (D.26226 > method_index.99) goto <D.26231>; else goto <D.23823>;
      <D.26231>:
      right = pos;
      <D.26230>:
      goto <D.23824>;
      <D.23823>:
      D.26172 = amodule->blob;
      pos.93 = (sizetype) pos;
      D.26156 = pos.93 * 8;
      D.26157 = D.26156 + 4;
      D.26232 = table + D.26157;
      D.26233 = *D.26232;
      p.100 = D.26172 + D.26233;
      p = p.100;
      p.101 = p;
      method = decode_resolve_method_ref (amodule, p.101, &p);
      if (method == 0B) goto <D.26236>; else goto <D.26237>;
      <D.26236>:
      D.26073 = 0B;
      return D.26073;
      <D.26237>:
      goto <D.26238>;
      <D.26217>:
      D.26239 = method_index + 1;
      D.26240 = D.26239 | 100663296;
      token = (guint32) D.26240;
      method = mono_get_method (image, token, 0B);
      <D.26238>:
      <D.26213>:
      D.26241 = method == 0B;
      D.26242 = (long int) D.26241;
      D.26243 = __builtin_expect (D.26242, 0);
      if (D.26243 != 0) goto <D.26244>; else goto <D.26245>;
      <D.26244>:
      monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "aot-runtime.c", 2895, "method");
      <D.26245>:
      <D.26192>:
      code_len.102 = (unsigned int) code_len;
      jinfo = decode_exception_debug_info (amodule, domain, method, ex_info, addr, code, code_len.102);
      D.26247 = jinfo->code_start;
      D.26248 = D.26247 > addr;
      D.26249 = (long int) D.26248;
      D.26250 = __builtin_expect (D.26249, 0);
      if (D.26250 != 0) goto <D.26251>; else goto <D.26252>;
      <D.26251>:
      monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "aot-runtime.c", 2902, "(guint8*)addr >= (guint8*)jinfo->code_start");
      <D.26252>:
      D.26247 = jinfo->code_start;
      D.26253 = jinfo->code_size;
      D.26254 = (sizetype) D.26253;
      D.26255 = D.26247 + D.26254;
      D.26256 = D.26255 <= addr;
      D.26257 = (long int) D.26256;
      D.26258 = __builtin_expect (D.26257, 0);
      if (D.26258 != 0) goto <D.26259>; else goto <D.26260>;
      <D.26259>:
      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.26260>:
      if (async != 0) goto <D.26261>; else goto <D.26262>;
      <D.26261>:
      {
        struct JitInfoMap * old_table;
        struct JitInfoMap * new_table;
        int len;

        <D.23829>:
        old_table = amodule->async_jit_info_table;
        if (old_table != 0B) goto <D.26263>; else goto <D.26264>;
        <D.26263>:
        len = old_table->method_index;
        goto <D.26265>;
        <D.26264>:
        len = 1;
        <D.26265>:
        D.26266 = len + 1;
        D.26267 = (unsigned int) D.26266;
        D.26268 = D.26267 * 8;
        D.26269 = (int) D.26268;
        new_table = alloc0_jit_info_data (domain, D.26269, async);
        if (old_table != 0B) goto <D.26270>; else goto <D.26271>;
        <D.26270>:
        len.103 = (unsigned int) len;
        D.26273 = len.103 * 8;
        memcpy (new_table, old_table, D.26273);
        <D.26271>:
        D.26266 = len + 1;
        new_table->method_index = D.26266;
        len.103 = (unsigned int) len;
        D.26273 = len.103 * 8;
        D.26274 = new_table + D.26273;
        D.26274->method_index = method_index;
        len.103 = (unsigned int) len;
        D.26273 = len.103 * 8;
        D.26274 = new_table + D.26273;
        D.26274->jinfo = jinfo;
        mono_memory_barrier ();
        D.26275 = &amodule->async_jit_info_table;
        D.26276 = InterlockedCompareExchangePointer (D.26275, new_table, old_table);
        if (D.26276 == old_table) goto <D.23828>; else goto <D.26277>;
        <D.26277>:
        goto <D.23829>;
        <D.23828>:
      }
      goto <D.26278>;
      <D.26262>:
      mono_jit_info_table_add (domain, jinfo);
      <D.26278>:
      D.26073 = jinfo;
      return D.26073;
    }
  finally
    {
      p = {CLOBBER};
    }
}


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

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


msort_code_offsets_internal (gint32 * array, int lo, int hi, gint32 * scratch)
{
  int D.26284;
  int D.26287;
  unsigned int i.105;
  unsigned int D.26291;
  gint32 * D.26292;
  int D.26293;
  sizetype i.106;
  sizetype D.26295;
  sizetype D.26296;
  gint32 * D.26297;
  int D.26298;
  int D.26302;
  unsigned int mid.107;
  unsigned int D.26304;
  gint32 * D.26305;
  int D.26306;
  unsigned int D.26307;
  unsigned int D.26308;
  gint32 * D.26309;
  int D.26310;
  unsigned int t_lo.108;
  unsigned int D.26319;
  gint32 * D.26320;
  int D.26321;
  unsigned int t_hi.109;
  unsigned int D.26323;
  gint32 * D.26324;
  int D.26325;
  gint32 * D.26326;
  sizetype D.26327;
  sizetype D.26328;
  gint32 * D.26329;
  sizetype t_lo.110;
  sizetype D.26331;
  sizetype D.26332;
  gint32 * D.26333;
  int D.26334;
  sizetype t_hi.111;
  sizetype D.26336;
  sizetype D.26337;
  gint32 * D.26338;
  int D.26339;
  int D.26340;
  gint32 * D.26341;
  int D.26342;
  int mid;
  int i;
  int t_lo;
  int t_hi;

  D.26284 = lo + hi;
  mid = D.26284 / 2;
  if (lo >= hi) goto <D.26285>; else goto <D.26286>;
  <D.26285>:
  return;
  <D.26286>:
  D.26287 = hi - lo;
  if (D.26287 <= 31) goto <D.26288>; else goto <D.26289>;
  <D.26288>:
  i = lo;
  goto <D.23768>;
  <D.23767>:
  i.105 = (unsigned int) i;
  D.26291 = i.105 * 8;
  D.26292 = array + D.26291;
  D.26293 = *D.26292;
  i.106 = (sizetype) i;
  D.26295 = i.106 + 1;
  D.26296 = D.26295 * 8;
  D.26297 = array + D.26296;
  D.26298 = *D.26297;
  if (D.26293 > D.26298) goto <D.23766>; else goto <D.26299>;
  <D.26299>:
  i = i + 1;
  <D.23768>:
  if (i < hi) goto <D.23767>; else goto <D.23766>;
  <D.23766>:
  if (i == hi) goto <D.26300>; else goto <D.26301>;
  <D.26300>:
  return;
  <D.26301>:
  <D.26289>:
  msort_code_offsets_internal (array, lo, mid, scratch);
  D.26302 = mid + 1;
  msort_code_offsets_internal (array, D.26302, hi, scratch);
  mid.107 = (unsigned int) mid;
  D.26304 = mid.107 * 8;
  D.26305 = array + D.26304;
  D.26306 = *D.26305;
  D.26302 = mid + 1;
  D.26307 = (unsigned int) D.26302;
  D.26308 = D.26307 * 8;
  D.26309 = array + D.26308;
  D.26310 = *D.26309;
  if (D.26306 < D.26310) goto <D.26311>; else goto <D.26312>;
  <D.26311>:
  return;
  <D.26312>:
  t_lo = lo;
  t_hi = mid + 1;
  i = lo;
  goto <D.23770>;
  <D.23769>:
  if (t_lo <= mid) goto <D.26316>; else goto <D.26313>;
  <D.26316>:
  if (t_hi > hi) goto <D.26314>; else goto <D.26317>;
  <D.26317>:
  t_lo.108 = (unsigned int) t_lo;
  D.26319 = t_lo.108 * 8;
  D.26320 = array + D.26319;
  D.26321 = *D.26320;
  t_hi.109 = (unsigned int) t_hi;
  D.26323 = t_hi.109 * 8;
  D.26324 = array + D.26323;
  D.26325 = *D.26324;
  if (D.26321 < D.26325) goto <D.26314>; else goto <D.26313>;
  <D.26314>:
  i.105 = (unsigned int) i;
  D.26291 = i.105 * 8;
  D.26326 = scratch + D.26291;
  t_lo.108 = (unsigned int) t_lo;
  D.26319 = t_lo.108 * 8;
  D.26320 = array + D.26319;
  D.26321 = *D.26320;
  *D.26326 = D.26321;
  i.106 = (sizetype) i;
  D.26327 = i.106 * 8;
  D.26328 = D.26327 + 4;
  D.26329 = scratch + D.26328;
  t_lo.110 = (sizetype) t_lo;
  D.26331 = t_lo.110 * 8;
  D.26332 = D.26331 + 4;
  D.26333 = array + D.26332;
  D.26334 = *D.26333;
  *D.26329 = D.26334;
  t_lo = t_lo + 1;
  goto <D.26315>;
  <D.26313>:
  i.105 = (unsigned int) i;
  D.26291 = i.105 * 8;
  D.26326 = scratch + D.26291;
  t_hi.109 = (unsigned int) t_hi;
  D.26323 = t_hi.109 * 8;
  D.26324 = array + D.26323;
  D.26325 = *D.26324;
  *D.26326 = D.26325;
  i.106 = (sizetype) i;
  D.26327 = i.106 * 8;
  D.26328 = D.26327 + 4;
  D.26329 = scratch + D.26328;
  t_hi.111 = (sizetype) t_hi;
  D.26336 = t_hi.111 * 8;
  D.26337 = D.26336 + 4;
  D.26338 = array + D.26337;
  D.26339 = *D.26338;
  *D.26329 = D.26339;
  t_hi = t_hi + 1;
  <D.26315>:
  i = i + 1;
  <D.23770>:
  if (i <= hi) goto <D.23769>; else goto <D.23771>;
  <D.23771>:
  i = lo;
  goto <D.23773>;
  <D.23772>:
  i.105 = (unsigned int) i;
  D.26291 = i.105 * 8;
  D.26292 = array + D.26291;
  i.105 = (unsigned int) i;
  D.26291 = i.105 * 8;
  D.26326 = scratch + D.26291;
  D.26340 = *D.26326;
  *D.26292 = D.26340;
  i.106 = (sizetype) i;
  D.26327 = i.106 * 8;
  D.26328 = D.26327 + 4;
  D.26341 = array + D.26328;
  i.106 = (sizetype) i;
  D.26327 = i.106 * 8;
  D.26328 = D.26327 + 4;
  D.26329 = scratch + D.26328;
  D.26342 = *D.26329;
  *D.26341 = D.26342;
  i = i + 1;
  <D.23773>:
  if (i <= hi) goto <D.23772>; else goto <D.23774>;
  <D.23774>:
}


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.26345;
  unsigned int D.26346;
  _Bool D.26347;
  unsigned int D.26348;
  _Bool D.26349;
  unsigned int D.26350;
  _Bool D.26351;
  unsigned int D.26352;
  _Bool D.26353;
  unsigned int D.26354;
  _Bool D.26355;
  unsigned int D.26356;
  _Bool D.26357;
  unsigned int D.26358;
  _Bool D.26359;
  unsigned int D.26360;
  _Bool D.26361;
  int D.26364;
  _Bool D.26365;
  long int D.26366;
  long int D.26367;
  int D.26371;
  unsigned int num_holes.113;
  unsigned int D.26378;
  unsigned int D.26379;
  _Bool D.26389;
  long int D.26390;
  long int D.26391;
  unsigned int num_clauses.114;
  unsigned int D.26395;
  unsigned int D.26396;
  unsigned int i.115;
  unsigned int D.26398;
  int D.26399;
  unsigned int D.26400;
  int D.26401;
  struct MonoClass * D.26404;
  unsigned int D.26406;
  struct GSList * * D.26407;
  void * nesting_index.116;
  struct GSList * D.26409;
  struct GSList * D.26410;
  int D.26411;
  int D.26412;
  unsigned int generic_info_size.117;
  unsigned int D.26415;
  unsigned int try_holes_info_size.118;
  unsigned int D.26417;
  unsigned int arch_eh_jit_info_size.119;
  unsigned int D.26419;
  unsigned int D.26420;
  short unsigned int D.26421;
  <unnamed-unsigned:15> D.26422;
  int D.26423;
  unsigned int D.26424;
  int D.26425;
  unsigned int D.26426;
  unsigned int D.26427;
  int D.26430;
  sizetype D.26431;
  void * D.26432;
  sizetype len.120;
  guint8 * p.121;
  struct MonoClass * D.26441;
  int D.26442;
  sizetype D.26443;
  void * D.26444;
  int D.26445;
  sizetype D.26446;
  void * D.26447;
  int D.26448;
  sizetype D.26449;
  void * D.26450;
  <unnamed-unsigned:15> D.26451;
  int D.26452;
  int code_len.122;
  _Bool D.26456;
  long int D.26457;
  long int D.26458;
  short unsigned int D.26461;
  int D.26462;
  short unsigned int D.26463;
  int D.26464;
  short unsigned int D.26465;
  int D.26466;
  unsigned int D.26467;
  int D.26470;
  unsigned int D.26471;
  struct MonoJitInfo * D.26474;
  _Bool D.26477;
  long int D.26478;
  long int D.26479;
  int D.26482;
  int D.26483;
  unsigned int D.26486;
  unsigned int D.26487;
  int D.26488;
  void * D.26489;
  struct MonoDwarfLocListEntry * D.26490;
  unsigned int D.26491;
  int D.26492;
  int D.26493;
  int D.26494;
  int D.26497;
  int D.26500;
  int D.26501;
  int this_reg.123;
  _Bool D.26506;
  <unnamed-signed:1> D.26507;
  unsigned char D.26508;
  int this_offset.124;
  int D.26511;
  signed char D.26512;
  <unnamed-signed:1> D.26513;
  int D.26514;
  unsigned char D.26515;
  int D.26516;
  sizetype len.125;
  guint8 * p.126;
  struct MonoMethod * D.26522;
  void * D.26523;
  int D.26524;
  unsigned int n.127;
  unsigned int D.26530;
  int D.26531;
  void * D.26532;
  gboolean * D.26533;
  unsigned int i.128;
  unsigned int D.26535;
  gboolean * D.26536;
  int D.26537;
  void * D.26540;
  gboolean * D.26541;
  gboolean * D.26542;
  int D.26543;
  _Bool D.26544;
  _Bool D.26545;
  _Bool D.26546;
  unsigned int len.129;
  unsigned int D.26550;
  unsigned int D.26551;
  int D.26552;
  int D.26553;
  int D.26554;
  int D.26555;
  int D.26556;
  unsigned int D.26557;
  unsigned int D.26558;
  void * D.26559;
  int * D.26560;
  unsigned int j.130;
  unsigned int D.26562;
  int * D.26563;
  int D.26564;
  union mono_mutex_t * D.26565;
  _Bool D.26568;
  long int D.26569;
  long int D.26570;
  void * D.26573;
  struct GHashTable * D.26574;
  _Bool D.26577;
  long int D.26578;
  long int D.26579;
  unsigned int buf_len.131;
  sizetype buf_len.132;
  guint8 * p.133;
  guint8 * p.134;
  unsigned int p.135;
  unsigned int D.26591;
  sizetype map_size.136;
  guint8 * p.137;
  struct MonoMethod * D.26594;
  struct MonoClass * D.26595;
  struct MonoImage * D.26596;
  void * D.26597;
  _Bool D.26602;
  long int D.26603;
  long int D.26604;
  struct GHashTable * ji_to_amodule.138;
  struct GHashTable * ji_to_amodule.139;
  _Bool D.26613;
  long int D.26614;
  long int D.26615;
  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.26345 = decode_value (p.112, &p);
      flags = (guint) D.26345;
      D.26346 = flags & 1;
      D.26347 = D.26346 != 0;
      has_generic_jit_info = (gboolean) D.26347;
      D.26348 = flags & 2;
      D.26349 = D.26348 != 0;
      has_dwarf_unwind_info = (gboolean) D.26349;
      D.26350 = flags & 4;
      D.26351 = D.26350 != 0;
      has_clauses = (gboolean) D.26351;
      D.26352 = flags & 8;
      D.26353 = D.26352 != 0;
      has_seq_points = (gboolean) D.26353;
      D.26354 = flags & 16;
      D.26355 = D.26354 != 0;
      from_llvm = (gboolean) D.26355;
      D.26356 = flags & 32;
      D.26357 = D.26356 != 0;
      has_try_block_holes = (gboolean) D.26357;
      D.26358 = flags & 64;
      D.26359 = D.26358 != 0;
      has_gc_map = (gboolean) D.26359;
      D.26360 = flags & 128;
      D.26361 = D.26360 != 0;
      has_arch_eh_jit_info = (gboolean) D.26361;
      if (has_dwarf_unwind_info != 0) goto <D.26362>; else goto <D.26363>;
      <D.26362>:
      {
        guint32 offset;

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

        D.26389 = async != 0;
        D.26390 = (long int) D.26389;
        D.26391 = __builtin_expect (D.26390, 0);
        if (D.26391 != 0) goto <D.26392>; else goto <D.26393>;
        <D.26392>:
        monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "aot-runtime.c", 2414, "!async");
        <D.26393>:
        num_clauses.114 = (unsigned int) num_clauses;
        D.26395 = num_clauses.114 * 24;
        clauses = monoeg_malloc0 (D.26395);
        num_clauses.114 = (unsigned int) num_clauses;
        D.26396 = num_clauses.114 * 4;
        nesting = monoeg_malloc0 (D.26396);
        i = 0;
        goto <D.23690>;
        <D.23689>:
        {
          struct MonoJitExceptionInfo * ei;

          i.115 = (unsigned int) i;
          D.26398 = i.115 * 24;
          ei = clauses + D.26398;
          p.112 = p;
          D.26399 = decode_value (p.112, &p);
          D.26400 = (unsigned int) D.26399;
          ei->flags = D.26400;
          p.112 = p;
          D.26401 = decode_value (p.112, &p);
          if (D.26401 != 0) goto <D.26402>; else goto <D.26403>;
          <D.26402>:
          p.112 = p;
          D.26404 = decode_klass_ref (amodule, p.112, &p);
          ei->data.catch_class = D.26404;
          <D.26403>:
          <D.23688>:
          {
            int nesting_index;

            p.112 = p;
            nesting_index = decode_value (p.112, &p);
            if (nesting_index == -1) goto <D.23687>; else goto <D.26405>;
            <D.26405>:
            i.115 = (unsigned int) i;
            D.26406 = i.115 * 4;
            D.26407 = nesting + D.26406;
            nesting_index.116 = (void *) nesting_index;
            i.115 = (unsigned int) i;
            D.26406 = i.115 * 4;
            D.26407 = nesting + D.26406;
            D.26409 = *D.26407;
            D.26410 = monoeg_g_slist_prepend (D.26409, nesting_index.116);
            *D.26407 = D.26410;
          }
          goto <D.23688>;
          <D.23687>:
        }
        i = i + 1;
        <D.23690>:
        if (i < num_clauses) goto <D.23689>; else goto <D.23691>;
        <D.23691>:
        D.26411 = generic_info_size + try_holes_info_size;
        D.26412 = D.26411 + arch_eh_jit_info_size;
        jinfo = decode_llvm_mono_eh_frame (amodule, domain, method, code, clauses, num_clauses, D.26412, nesting, &this_reg, &this_offset);
        jinfo->from_llvm = -1;
        monoeg_g_free (clauses);
        i = 0;
        goto <D.23693>;
        <D.23692>:
        i.115 = (unsigned int) i;
        D.26406 = i.115 * 4;
        D.26407 = nesting + D.26406;
        D.26409 = *D.26407;
        monoeg_g_slist_free (D.26409);
        i = i + 1;
        <D.23693>:
        if (i < num_clauses) goto <D.23692>; else goto <D.23694>;
        <D.23694>:
        monoeg_g_free (nesting);
      }
      goto <D.26413>;
      <D.26388>:
      num_clauses.114 = (unsigned int) num_clauses;
      D.26395 = num_clauses.114 * 24;
      generic_info_size.117 = (unsigned int) generic_info_size;
      D.26415 = D.26395 + generic_info_size.117;
      try_holes_info_size.118 = (unsigned int) try_holes_info_size;
      D.26417 = D.26415 + try_holes_info_size.118;
      arch_eh_jit_info_size.119 = (unsigned int) arch_eh_jit_info_size;
      D.26419 = D.26417 + arch_eh_jit_info_size.119;
      D.26420 = D.26419 + 28;
      len = (int) D.26420;
      jinfo = alloc0_jit_info_data (domain, len, async);
      D.26421 = (short unsigned int) num_clauses;
      D.26422 = (<unnamed-unsigned:15>) D.26421;
      jinfo->num_clauses = D.26422;
      i = 0;
      goto <D.23698>;
      <D.23697>:
      {
        struct MonoJitExceptionInfo * ei;

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

          p.112 = p;
          len = decode_value (p.112, &p);
          if (len > 0) goto <D.26434>; else goto <D.26435>;
          <D.26434>:
          if (async != 0) goto <D.26436>; else goto <D.26437>;
          <D.26436>:
          p.112 = p;
          len.120 = (sizetype) len;
          p.121 = p.112 + len.120;
          p = p.121;
          goto <D.26440>;
          <D.26437>:
          p.112 = p;
          D.26441 = decode_klass_ref (amodule, p.112, &p);
          ei->data.catch_class = D.26441;
          <D.26440>:
          <D.26435>:
        }
        <D.26433>:
        p.112 = p;
        D.26442 = decode_value (p.112, &p);
        D.26443 = (sizetype) D.26442;
        D.26444 = code + D.26443;
        ei->try_start = D.26444;
        p.112 = p;
        D.26445 = decode_value (p.112, &p);
        D.26446 = (sizetype) D.26445;
        D.26447 = code + D.26446;
        ei->try_end = D.26447;
        p.112 = p;
        D.26448 = decode_value (p.112, &p);
        D.26449 = (sizetype) D.26448;
        D.26450 = code + D.26449;
        ei->handler_start = D.26450;
      }
      i = i + 1;
      <D.23698>:
      D.26451 = jinfo->num_clauses;
      D.26452 = (int) D.26451;
      if (D.26452 > i) goto <D.23697>; else goto <D.23699>;
      <D.23699>:
      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.26413>:
      if (has_try_block_holes != 0) goto <D.26454>; else goto <D.26455>;
      <D.26454>:
      {
        struct MonoTryBlockHoleTableJitInfo * table;

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

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

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

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

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

          gsctx = gi->generic_sharing_context;
          p.112 = p;
          n = decode_value (p.112, &p);
          if (n != 0) goto <D.26527>; else goto <D.26528>;
          <D.26527>:
          n.127 = (unsigned int) n;
          D.26530 = n.127 * 4;
          D.26531 = (int) D.26530;
          D.26532 = alloc0_jit_info_data (domain, D.26531, async);
          gsctx->var_is_vt = D.26532;
          i = 0;
          goto <D.23716>;
          <D.23715>:
          D.26533 = gsctx->var_is_vt;
          i.128 = (unsigned int) i;
          D.26535 = i.128 * 4;
          D.26536 = D.26533 + D.26535;
          p.112 = p;
          D.26537 = decode_value (p.112, &p);
          *D.26536 = D.26537;
          i = i + 1;
          <D.23716>:
          if (i < n) goto <D.23715>; else goto <D.23717>;
          <D.23717>:
          <D.26528>:
          p.112 = p;
          n = decode_value (p.112, &p);
          if (n != 0) goto <D.26538>; else goto <D.26539>;
          <D.26538>:
          n.127 = (unsigned int) n;
          D.26530 = n.127 * 4;
          D.26531 = (int) D.26530;
          D.26540 = alloc0_jit_info_data (domain, D.26531, async);
          gsctx->mvar_is_vt = D.26540;
          i = 0;
          goto <D.23719>;
          <D.23718>:
          D.26541 = gsctx->mvar_is_vt;
          i.128 = (unsigned int) i;
          D.26535 = i.128 * 4;
          D.26542 = D.26541 + D.26535;
          p.112 = p;
          D.26543 = decode_value (p.112, &p);
          *D.26542 = D.26543;
          i = i + 1;
          <D.23719>:
          if (i < n) goto <D.23718>; else goto <D.23720>;
          <D.23720>:
          <D.26539>:
        }
        <D.26526>:
      }
      <D.26476>:
      D.26544 = method != 0B;
      D.26545 = has_seq_points != 0;
      D.26546 = D.26544 & D.26545;
      if (D.26546 != 0) goto <D.26547>; else goto <D.26548>;
      <D.26547>:
      {
        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.26550 = len.129 * 20;
        D.26551 = D.26550 + 4;
        seq_points = monoeg_malloc0 (D.26551);
        seq_points->len = len;
        last_native_offset = 0;
        last_il_offset = last_native_offset;
        i = 0;
        goto <D.23733>;
        <D.23732>:
        {
          struct SeqPoint * sp;

          sp = &seq_points->seq_points[i];
          p.112 = p;
          D.26552 = decode_value (p.112, &p);
          il_offset = D.26552 + last_il_offset;
          p.112 = p;
          D.26553 = decode_value (p.112, &p);
          native_offset = D.26553 + last_native_offset;
          sp->il_offset = il_offset;
          sp->native_offset = native_offset;
          p.112 = p;
          D.26554 = decode_value (p.112, &p);
          sp->flags = D.26554;
          p.112 = p;
          D.26555 = decode_value (p.112, &p);
          sp->next_len = D.26555;
          D.26556 = sp->next_len;
          D.26557 = (unsigned int) D.26556;
          D.26558 = D.26557 * 4;
          D.26559 = monoeg_malloc (D.26558);
          sp->next = D.26559;
          j = 0;
          goto <D.23730>;
          <D.23729>:
          D.26560 = sp->next;
          j.130 = (unsigned int) j;
          D.26562 = j.130 * 4;
          D.26563 = D.26560 + D.26562;
          p.112 = p;
          D.26564 = decode_value (p.112, &p);
          *D.26563 = D.26564;
          j = j + 1;
          <D.23730>:
          D.26556 = sp->next_len;
          if (D.26556 > j) goto <D.23729>; else goto <D.23731>;
          <D.23731>:
          last_il_offset = il_offset;
          last_native_offset = native_offset;
        }
        i = i + 1;
        <D.23733>:
        if (i < len) goto <D.23732>; else goto <D.23734>;
        <D.23734>:
        {
          int ret;

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

          D.26565 = &domain->lock.mutex;
          ret = pthread_mutex_unlock (D.26565);
          if (ret != 0) goto <D.26575>; else goto <D.26576>;
          <D.26575>:
          monoeg_g_log (0B, 16, "Bad call to mono_mutex_unlock result %d", ret);
          <D.26576>:
          D.26577 = ret != 0;
          D.26578 = (long int) D.26577;
          D.26579 = __builtin_expect (D.26578, 0);
          if (D.26579 != 0) goto <D.26580>; else goto <D.26581>;
          <D.26580>:
          monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "aot-runtime.c", 2610, "ret == 0");
          <D.26581>:
        }
      }
      <D.26548>:
      p.112 = p;
      buf_len = decode_value (p.112, &p);
      if (async == 0) goto <D.26582>; else goto <D.26583>;
      <D.26582>:
      buf_len.131 = (unsigned int) buf_len;
      p.112 = p;
      mono_debug_add_aot_method (domain, method, code, p.112, buf_len.131);
      <D.26583>:
      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.26587>; else goto <D.26588>;
      <D.26587>:
      {
        int map_size;

        p.112 = p;
        map_size = decode_value (p.112, &p);
        goto <D.23739>;
        <D.23738>:
        p.112 = p;
        p.134 = p.112 + 1;
        p = p.134;
        <D.23739>:
        p.112 = p;
        p.135 = (unsigned int) p.112;
        D.26591 = p.135 & 3;
        if (D.26591 != 0) goto <D.23738>; else goto <D.23740>;
        <D.23740>:
        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.26588>:
      D.26594 = jinfo->d.method;
      D.26595 = D.26594->klass;
      D.26596 = D.26595->image;
      D.26597 = D.26596->aot_module;
      if (D.26597 != amodule) goto <D.26598>; else goto <D.26599>;
      <D.26598>:
      {
        int ret;

        ret = pthread_mutex_lock (&aot_mutex.mutex);
        if (ret != 0) goto <D.26600>; else goto <D.26601>;
        <D.26600>:
        monoeg_g_log (0B, 16, "Bad call to mono_mutex_lock result %d", ret);
        <D.26601>:
        D.26602 = ret != 0;
        D.26603 = (long int) D.26602;
        D.26604 = __builtin_expect (D.26603, 0);
        if (D.26604 != 0) goto <D.26605>; else goto <D.26606>;
        <D.26605>:
        monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "aot-runtime.c", 2629, "ret == 0");
        <D.26606>:
      }
      ji_to_amodule.138 = ji_to_amodule;
      if (ji_to_amodule.138 == 0B) goto <D.26608>; else goto <D.26609>;
      <D.26608>:
      ji_to_amodule.139 = monoeg_g_hash_table_new (0B, 0B);
      ji_to_amodule = ji_to_amodule.139;
      <D.26609>:
      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.26611>; else goto <D.26612>;
        <D.26611>:
        monoeg_g_log (0B, 16, "Bad call to mono_mutex_unlock result %d", ret);
        <D.26612>:
        D.26613 = ret != 0;
        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", 2633, "ret == 0");
        <D.26617>:
      }
      <D.26599>:
      D.26474 = jinfo;
      return D.26474;
    }
  finally
    {
      p = {CLOBBER};
      this_reg = {CLOBBER};
      this_offset = {CLOBBER};
    }
}


decode_llvm_mono_eh_frame (struct MonoAotModule * amodule, struct MonoDomain * domain, struct MonoMethod * method, guint8 * code, struct MonoJitExceptionInfo * clauses, int num_clauses, int extra_size, struct GSList * * nesting, int * this_reg, int * this_offset)
{
  guint8 * D.26620;
  _Bool D.26621;
  long int D.26622;
  long int D.26623;
  unsigned char D.26626;
  _Bool D.26627;
  long int D.26628;
  long int D.26629;
  int p.140;
  int D.26633;
  int D.26634;
  unsigned int D.26635;
  int D.26636;
  int D.26637;
  sizetype D.26638;
  int code.141;
  guint8 * D.26640;
  int D.26641;
  int D.26642;
  unsigned int pos.142;
  unsigned int D.26644;
  gint32 * D.26645;
  int D.26646;
  _Bool D.26647;
  long int D.26648;
  long int D.26649;
  gint32 * D.26652;
  unsigned int D.26653;
  unsigned int D.26654;
  gint32 * D.26655;
  int D.26656;
  guint8 * D.26659;
  int D.26660;
  unsigned int D.26662;
  unsigned int D.26663;
  gint32 * D.26664;
  int D.26665;
  _Bool D.26666;
  long int D.26667;
  long int D.26668;
  unsigned int D.26671;
  unsigned int D.26672;
  gint32 * D.26673;
  int D.26678;
  sizetype D.26679;
  sizetype len.143;
  int D.26684;
  sizetype D.26685;
  int code_end.144;
  int code_start.145;
  _Bool D.26688;
  _Bool D.26689;
  _Bool D.26690;
  int D.26691;
  _Bool D.26692;
  long int D.26693;
  long int D.26694;
  guint8 * D.26697;
  int D.26702;
  sizetype pos.146;
  sizetype D.26704;
  sizetype D.26705;
  gint32 * D.26706;
  int D.26707;
  sizetype D.26708;
  sizetype D.26709;
  gint32 * D.26710;
  int D.26711;
  int D.26712;
  int fde_len.147;
  int D.26714;
  int D.26715;
  unsigned int i.148;
  unsigned int D.26717;
  void * * D.26718;
  void * D.26719;
  unsigned int D.26720;
  unsigned int cindex1.149;
  unsigned int D.26722;
  struct GSList * * D.26723;
  void * D.26724;
  unsigned int j.150;
  unsigned int D.26726;
  void * * D.26727;
  void * D.26728;
  unsigned int D.26729;
  unsigned int j.151;
  unsigned int i.152;
  unsigned int D.26734;
  unsigned int D.26735;
  unsigned int extra_size.153;
  unsigned int D.26737;
  unsigned int D.26738;
  unsigned int D.26739;
  guint8 * D.26740;
  unsigned int D.26741;
  short unsigned int D.26742;
  short unsigned int D.26743;
  short unsigned int D.26744;
  <unnamed-unsigned:15> D.26745;
  unsigned int clause_index.154;
  unsigned int D.26747;
  _Bool D.26748;
  long int D.26749;
  long int D.26750;
  unsigned int D.26753;
  struct MonoClass * D.26754;
  unsigned int D.26755;
  struct MonoJitExceptionInfo * D.26756;
  void * D.26757;
  void * D.26758;
  void * D.26759;
  void * D.26762;
  int D.26765;
  int D.26766;
  void * D.26767;
  unsigned int cindex1.155;
  unsigned int D.26769;
  struct GSList * * D.26770;
  void * D.26771;
  struct MonoJitExceptionInfo * D.26774;
  struct MonoJitExceptionInfo * D.26775;
  void * D.26776;
  void * D.26777;
  _Bool D.26778;
  long int D.26779;
  long int D.26780;
  struct MonoJitInfo * D.26783;
  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.26620 = amodule->mono_eh_frame;
      D.26621 = D.26620 == 0B;
      D.26622 = (long int) D.26621;
      D.26623 = __builtin_expect (D.26622, 0);
      if (D.26623 != 0) goto <D.26624>; else goto <D.26625>;
      <D.26624>:
      monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "aot-runtime.c", 2171, "amodule->mono_eh_frame");
      <D.26625>:
      p = amodule->mono_eh_frame;
      D.26626 = *p;
      version = (int) D.26626;
      D.26627 = version != 3;
      D.26628 = (long int) D.26627;
      D.26629 = __builtin_expect (D.26628, 0);
      if (D.26629 != 0) goto <D.26630>; else goto <D.26631>;
      <D.26630>:
      monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "aot-runtime.c", 2179, "version == 3");
      <D.26631>:
      p = p + 1;
      D.26626 = *p;
      func_encoding = (int) D.26626;
      p = p + 1;
      p.140 = (int) p;
      D.26633 = p.140 + 3;
      D.26634 = D.26633 & -4;
      p = (guint8 *) D.26634;
      D.26635 = MEM[(guint32 *)p];
      fde_count = (int) D.26635;
      p = p + 4;
      table = p;
      D.26636 = fde_count + 1;
      D.26637 = D.26636 * 8;
      D.26638 = (sizetype) D.26637;
      cie = p + D.26638;
      code.141 = (int) code;
      D.26640 = amodule->code;
      D.26641 = (int) D.26640;
      offset = code.141 - D.26641;
      left = 0;
      right = fde_count;
      <D.23610>:
      D.26642 = left + right;
      pos = D.26642 / 2;
      pos.142 = (unsigned int) pos;
      D.26644 = pos.142 * 8;
      D.26645 = table + D.26644;
      D.26646 = *D.26645;
      D.26647 = D.26646 == -1;
      D.26648 = (long int) D.26647;
      D.26649 = __builtin_expect (D.26648, 0);
      if (D.26649 != 0) goto <D.26650>; else goto <D.26651>;
      <D.26650>:
      monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "aot-runtime.c", 2200, "table [(pos * 2)] != -1");
      <D.26651>:
      D.26652 = amodule->code_offsets;
      pos.142 = (unsigned int) pos;
      D.26644 = pos.142 * 8;
      D.26645 = table + D.26644;
      D.26646 = *D.26645;
      D.26653 = (unsigned int) D.26646;
      D.26654 = D.26653 * 4;
      D.26655 = D.26652 + D.26654;
      offset1 = *D.26655;
      D.26656 = pos + 1;
      if (D.26656 == fde_count) goto <D.26657>; else goto <D.26658>;
      <D.26657>:
      D.26659 = amodule->code_end;
      D.26660 = (int) D.26659;
      D.26640 = amodule->code;
      D.26641 = (int) D.26640;
      offset2 = D.26660 - D.26641;
      goto <D.26661>;
      <D.26658>:
      D.26656 = pos + 1;
      D.26662 = (unsigned int) D.26656;
      D.26663 = D.26662 * 8;
      D.26664 = table + D.26663;
      D.26665 = *D.26664;
      D.26666 = D.26665 == -1;
      D.26667 = (long int) D.26666;
      D.26668 = __builtin_expect (D.26667, 0);
      if (D.26668 != 0) goto <D.26669>; else goto <D.26670>;
      <D.26669>:
      monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "aot-runtime.c", 2205, "table [(pos + 1) * 2] != -1");
      <D.26670>:
      D.26652 = amodule->code_offsets;
      D.26656 = pos + 1;
      D.26662 = (unsigned int) D.26656;
      D.26663 = D.26662 * 8;
      D.26664 = table + D.26663;
      D.26665 = *D.26664;
      D.26671 = (unsigned int) D.26665;
      D.26672 = D.26671 * 4;
      D.26673 = D.26652 + D.26672;
      offset2 = *D.26673;
      <D.26661>:
      if (offset < offset1) goto <D.26674>; else goto <D.26675>;
      <D.26674>:
      right = pos;
      goto <D.26676>;
      <D.26675>:
      if (offset >= offset2) goto <D.26677>; else goto <D.23609>;
      <D.26677>:
      left = pos + 1;
      <D.26676>:
      goto <D.23610>;
      <D.23609>:
      D.26640 = amodule->code;
      D.26652 = amodule->code_offsets;
      pos.142 = (unsigned int) pos;
      D.26644 = pos.142 * 8;
      D.26645 = table + D.26644;
      D.26646 = *D.26645;
      D.26653 = (unsigned int) D.26646;
      D.26654 = D.26653 * 4;
      D.26655 = D.26652 + D.26654;
      D.26678 = *D.26655;
      D.26679 = (sizetype) D.26678;
      code_start = D.26640 + D.26679;
      D.26656 = pos + 1;
      if (D.26656 == fde_count) goto <D.26680>; else goto <D.26681>;
      <D.26680>:
      {
        int len;

        D.26656 = pos + 1;
        D.26662 = (unsigned int) D.26656;
        D.26663 = D.26662 * 8;
        D.26664 = table + D.26663;
        len = *D.26664;
        len.143 = (sizetype) len;
        code_end = code_start + len.143;
      }
      goto <D.26683>;
      <D.26681>:
      D.26640 = amodule->code;
      D.26652 = amodule->code_offsets;
      D.26656 = pos + 1;
      D.26662 = (unsigned int) D.26656;
      D.26663 = D.26662 * 8;
      D.26664 = table + D.26663;
      D.26665 = *D.26664;
      D.26671 = (unsigned int) D.26665;
      D.26672 = D.26671 * 4;
      D.26673 = D.26652 + D.26672;
      D.26684 = *D.26673;
      D.26685 = (sizetype) D.26684;
      code_end = D.26640 + D.26685;
      <D.26683>:
      code_end.144 = (int) code_end;
      code_start.145 = (int) code_start;
      code_len = code_end.144 - code_start.145;
      D.26688 = code < code_start;
      D.26689 = code >= code_end;
      D.26690 = D.26688 | D.26689;
      D.26691 = (int) D.26690;
      D.26692 = D.26691 != 0;
      D.26693 = (long int) D.26692;
      D.26694 = __builtin_expect (D.26693, 0);
      if (D.26694 != 0) goto <D.26695>; else goto <D.26696>;
      <D.26695>:
      monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "aot-runtime.c", 2227, "code >= code_start && code < code_end");
      <D.26696>:
      D.26697 = amodule->thumb_end;
      if (D.26697 != 0B) goto <D.26698>; else goto <D.26699>;
      <D.26698>:
      D.26697 = amodule->thumb_end;
      if (D.26697 > code_start) goto <D.26700>; else goto <D.26701>;
      <D.26700>:
      code_start.145 = (int) code_start;
      D.26702 = code_start.145 & -2;
      code_start = (guint8 *) D.26702;
      <D.26701>:
      <D.26699>:
      D.26620 = amodule->mono_eh_frame;
      pos.146 = (sizetype) pos;
      D.26704 = pos.146 * 8;
      D.26705 = D.26704 + 4;
      D.26706 = table + D.26705;
      D.26707 = *D.26706;
      D.26708 = (sizetype) D.26707;
      fde = D.26620 + D.26708;
      pos.146 = (sizetype) pos;
      D.26704 = pos.146 * 8;
      D.26709 = D.26704 + 12;
      D.26710 = table + D.26709;
      D.26711 = *D.26710;
      pos.146 = (sizetype) pos;
      D.26704 = pos.146 * 8;
      D.26705 = D.26704 + 4;
      D.26706 = table + D.26705;
      D.26707 = *D.26706;
      D.26712 = D.26711 - D.26707;
      fde_len = (guint32) D.26712;
      fde_len.147 = (int) fde_len;
      mono_unwind_decode_llvm_mono_fde (fde, fde_len.147, cie, code_start, &info);
      ei = info.ex_info;
      ei_len = info.ex_info_len;
      type_info = info.type_info;
      D.26714 = info.this_reg;
      *this_reg = D.26714;
      D.26715 = info.this_offset;
      *this_offset = D.26715;
      nested_len = 0;
      i = 0;
      goto <D.23623>;
      <D.23622>:
      {
        gint32 cindex1;
        struct GSList * l;

        i.148 = (unsigned int) i;
        D.26717 = i.148 * 4;
        D.26718 = type_info + D.26717;
        D.26719 = *D.26718;
        D.26720 = MEM[(const guint32 *)D.26719];
        cindex1 = (gint32) D.26720;
        cindex1.149 = (unsigned int) cindex1;
        D.26722 = cindex1.149 * 4;
        D.26723 = nesting + D.26722;
        l = *D.26723;
        goto <D.23620>;
        <D.23619>:
        {
          gint32 nesting_cindex;

          D.26724 = l->data;
          nesting_cindex = (gint32) D.26724;
          j = 0;
          goto <D.23617>;
          <D.23616>:
          {
            gint32 cindex2;

            j.150 = (unsigned int) j;
            D.26726 = j.150 * 4;
            D.26727 = type_info + D.26726;
            D.26728 = *D.26727;
            D.26729 = MEM[(const guint32 *)D.26728];
            cindex2 = (gint32) D.26729;
            if (cindex2 == nesting_cindex) goto <D.26730>; else goto <D.26731>;
            <D.26730>:
            nested_len = nested_len + 1;
            <D.26731>:
          }
          j = j + 1;
          <D.23617>:
          j.151 = (unsigned int) j;
          if (j.151 < ei_len) goto <D.23616>; else goto <D.23618>;
          <D.23618>:
        }
        l = l->next;
        <D.23620>:
        if (l != 0B) goto <D.23619>; else goto <D.23621>;
        <D.23621>:
      }
      i = i + 1;
      <D.23623>:
      i.152 = (unsigned int) i;
      if (i.152 < ei_len) goto <D.23622>; else goto <D.23624>;
      <D.23624>:
      D.26734 = ei_len + nested_len;
      D.26735 = D.26734 * 24;
      extra_size.153 = (unsigned int) extra_size;
      D.26737 = D.26735 + extra_size.153;
      D.26738 = D.26737 + 28;
      jinfo = mono_domain_alloc0_lock_free (domain, D.26738);
      jinfo->code_size = code_len;
      D.26739 = info.unw_info_len;
      D.26740 = info.unw_info;
      D.26741 = mono_cache_unwind_info (D.26740, D.26739);
      jinfo->used_regs = D.26741;
      jinfo->d.method = method;
      jinfo->code_start = code;
      jinfo->domain_neutral = 0;
      jinfo->from_aot = 0;
      D.26742 = (short unsigned int) ei_len;
      D.26743 = (short unsigned int) nested_len;
      D.26744 = D.26742 + D.26743;
      D.26745 = (<unnamed-unsigned:15>) D.26744;
      jinfo->num_clauses = D.26745;
      i = 0;
      goto <D.23629>;
      <D.23628>:
      {
        int clause_index;
        struct MonoJitExceptionInfo * jei;
        struct MonoJitExceptionInfo * orig_jei;

        i.148 = (unsigned int) i;
        D.26717 = i.148 * 4;
        D.26718 = type_info + D.26717;
        D.26719 = *D.26718;
        D.26720 = MEM[(const guint32 *)D.26719];
        clause_index = (int) D.26720;
        jei = &jinfo->clauses[i];
        clause_index.154 = (unsigned int) clause_index;
        D.26747 = clause_index.154 * 24;
        orig_jei = clauses + D.26747;
        D.26748 = clause_index >= num_clauses;
        D.26749 = (long int) D.26748;
        D.26750 = __builtin_expect (D.26749, 0);
        if (D.26750 != 0) goto <D.26751>; else goto <D.26752>;
        <D.26751>:
        monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "aot-runtime.c", 2289, "clause_index < num_clauses");
        <D.26752>:
        D.26753 = orig_jei->flags;
        jei->flags = D.26753;
        D.26754 = orig_jei->data.catch_class;
        jei->data.catch_class = D.26754;
        i.148 = (unsigned int) i;
        D.26755 = i.148 * 24;
        D.26756 = ei + D.26755;
        D.26757 = D.26756->try_start;
        jei->try_start = D.26757;
        i.148 = (unsigned int) i;
        D.26755 = i.148 * 24;
        D.26756 = ei + D.26755;
        D.26758 = D.26756->try_end;
        jei->try_end = D.26758;
        i.148 = (unsigned int) i;
        D.26755 = i.148 * 24;
        D.26756 = ei + D.26755;
        D.26759 = D.26756->handler_start;
        jei->handler_start = D.26759;
        D.26697 = amodule->thumb_end;
        if (D.26697 != 0B) goto <D.26760>; else goto <D.26761>;
        <D.26760>:
        D.26762 = jei->handler_start;
        D.26697 = amodule->thumb_end;
        if (D.26762 < D.26697) goto <D.26763>; else goto <D.26764>;
        <D.26763>:
        D.26762 = jei->handler_start;
        D.26765 = (int) D.26762;
        D.26766 = D.26765 + 1;
        D.26767 = (void *) D.26766;
        jei->handler_start = D.26767;
        <D.26764>:
        <D.26761>:
      }
      i = i + 1;
      <D.23629>:
      i.152 = (unsigned int) i;
      if (i.152 < ei_len) goto <D.23628>; else goto <D.23630>;
      <D.23630>:
      nindex = ei_len;
      i = 0;
      goto <D.23642>;
      <D.23641>:
      {
        gint32 cindex1;
        struct GSList * l;

        i.148 = (unsigned int) i;
        D.26717 = i.148 * 4;
        D.26718 = type_info + D.26717;
        D.26719 = *D.26718;
        D.26720 = MEM[(const guint32 *)D.26719];
        cindex1 = (gint32) D.26720;
        cindex1.155 = (unsigned int) cindex1;
        D.26769 = cindex1.155 * 4;
        D.26770 = nesting + D.26769;
        l = *D.26770;
        goto <D.23639>;
        <D.23638>:
        {
          gint32 nesting_cindex;

          D.26771 = l->data;
          nesting_cindex = (gint32) D.26771;
          j = 0;
          goto <D.23636>;
          <D.23635>:
          {
            gint32 cindex2;

            j.150 = (unsigned int) j;
            D.26726 = j.150 * 4;
            D.26727 = type_info + D.26726;
            D.26728 = *D.26727;
            D.26729 = MEM[(const guint32 *)D.26728];
            cindex2 = (gint32) D.26729;
            if (cindex2 == nesting_cindex) goto <D.26772>; else goto <D.26773>;
            <D.26772>:
            D.26774 = &jinfo->clauses[j];
            D.26775 = &jinfo->clauses[nindex];
            memcpy (D.26775, D.26774, 24);
            D.26776 = jinfo->clauses[i].try_start;
            jinfo->clauses[nindex].try_start = D.26776;
            D.26777 = jinfo->clauses[i].try_end;
            jinfo->clauses[nindex].try_end = D.26777;
            nindex = nindex + 1;
            <D.26773>:
          }
          j = j + 1;
          <D.23636>:
          j.151 = (unsigned int) j;
          if (j.151 < ei_len) goto <D.23635>; else goto <D.23637>;
          <D.23637>:
        }
        l = l->next;
        <D.23639>:
        if (l != 0B) goto <D.23638>; else goto <D.23640>;
        <D.23640>:
      }
      i = i + 1;
      <D.23642>:
      i.152 = (unsigned int) i;
      if (i.152 < ei_len) goto <D.23641>; else goto <D.23643>;
      <D.23643>:
      D.26734 = ei_len + nested_len;
      D.26778 = D.26734 != nindex;
      D.26779 = (long int) D.26778;
      D.26780 = __builtin_expect (D.26779, 0);
      if (D.26780 != 0) goto <D.26781>; else goto <D.26782>;
      <D.26781>:
      monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "aot-runtime.c", 2327, "nindex == ei_len + nested_len");
      <D.26782>:
      D.26783 = jinfo;
      return D.26783;
    }
  finally
    {
      info = {CLOBBER};
    }
}


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

  if (async_context != 0) goto <D.26786>; else goto <D.26787>;
  <D.26786>:
  size.156 = (unsigned int) size;
  res = mono_domain_alloc0_lock_free (domain, size.156);
  InterlockedExchangeAdd (&async_jit_info_size, size);
  goto <D.26789>;
  <D.26787>:
  size.156 = (unsigned int) size;
  res = mono_domain_alloc0 (domain, size.156);
  <D.26789>:
  D.26790 = res;
  return D.26790;
}


InterlockedExchangeAdd (volatile gint32 * val, gint32 add)
{
  gint32 D.26792;
  unsigned int add.157;
  unsigned int D.26794;

  add.157 = (unsigned int) add;
  D.26794 = __sync_fetch_and_add_4 (val, add.157);
  D.26792 = (gint32) D.26794;
  return D.26792;
}


mono_memory_barrier ()
{
  __sync_synchronize ();
}


InterlockedCompareExchangePointer (void * volatile * dest, void * exch, void * comp)
{
  void * D.26796;
  unsigned int exch.158;
  unsigned int comp.159;
  unsigned int D.26799;

  exch.158 = (unsigned int) exch;
  comp.159 = (unsigned int) comp;
  D.26799 = __sync_val_compare_and_swap_4 (dest, comp.159, exch.158);
  D.26796 = (void *) D.26799;
  return D.26796;
}


mono_aot_get_method (struct MonoDomain * domain, struct MonoMethod * method)
{
  struct MonoImage * D.26801;
  void * amodule.160;
  struct MonoAotModule * amodule.161;
  void * D.26806;
  int D.26807;
  short unsigned int D.26812;
  int D.26813;
  int D.26814;
  short unsigned int D.26816;
  int D.26817;
  int D.26818;
  int D.26820;
  int D.26822;
  int mono_aot_only.162;
  unsigned char D.26826;
  unsigned char D.26827;
  struct MonoMethod * D.26830;
  unsigned char D.26831;
  unsigned char D.26832;
  _Bool D.26833;
  long int D.26834;
  long int D.26835;
  short unsigned int D.26840;
  short unsigned int D.26841;
  int D.26843;
  unsigned int D.26845;
  unsigned int D.26846;
  unsigned char D.26850;
  unsigned char D.26851;
  _Bool D.26855;
  long int D.26856;
  long int D.26857;
  struct GHashTable * D.26860;
  _Bool D.26863;
  long int D.26864;
  long int D.26865;
  struct MonoClass * D.26874;
  unsigned char D.26875;
  const char * D.26878;
  char * D.26879;
  int D.26884;
  void * D.26887;
  struct MonoClass * D.26892;
  int D.24043;
  int iftmp.163;
  int D.24042;
  const char[20] * D.26898;
  unsigned char D.26899;
  int D.26900;
  unsigned char D.26901;
  int D.26902;
  _Bool D.26903;
  _Bool D.26904;
  _Bool D.26905;
  const unsigned char * D.26908;
  unsigned char D.26909;
  int D.26910;
  const unsigned char * D.26911;
  unsigned char D.26912;
  int D.26913;
  _Bool D.26914;
  _Bool D.26915;
  const unsigned char * D.26918;
  unsigned char D.26919;
  int D.26920;
  const unsigned char * D.26921;
  unsigned char D.26922;
  int D.26923;
  _Bool D.26924;
  _Bool D.26925;
  const unsigned char * D.26928;
  unsigned char D.26929;
  int D.26930;
  const unsigned char * D.26931;
  unsigned char D.26932;
  int D.26933;
  struct MonoMethodSignature * D.26937;
  struct MonoType * D.26938;
  unsigned char D.26939;
  _Bool D.26942;
  long int D.26943;
  long int D.26944;
  struct MonoClass * D.26947;
  struct MonoType * D.26948;
  struct MonoGenericInst * D.26949;
  struct MonoMethod * D.26950;
  struct MonoImage * D.26962;
  struct MonoImage * D.26963;
  int D.24055;
  int iftmp.164;
  int D.24054;
  const char[17] * D.26969;
  unsigned char D.26970;
  int D.26971;
  unsigned char D.26972;
  int D.26973;
  _Bool D.26974;
  _Bool D.26975;
  _Bool D.26976;
  const unsigned char * D.26979;
  unsigned char D.26980;
  int D.26981;
  const unsigned char * D.26982;
  unsigned char D.26983;
  int D.26984;
  _Bool D.26985;
  _Bool D.26986;
  const unsigned char * D.26989;
  unsigned char D.26990;
  int D.26991;
  const unsigned char * D.26992;
  unsigned char D.26993;
  int D.26994;
  _Bool D.26995;
  _Bool D.26996;
  const unsigned char * D.26999;
  unsigned char D.27000;
  int D.27001;
  const unsigned char * D.27002;
  unsigned char D.27003;
  int D.27004;
  const char * D.27006;
  int D.24064;
  int iftmp.165;
  int D.24063;
  const char[12] * D.27011;
  unsigned char D.27012;
  int D.27013;
  unsigned char D.27014;
  int D.27015;
  _Bool D.27016;
  _Bool D.27017;
  _Bool D.27018;
  const unsigned char * D.27021;
  unsigned char D.27022;
  int D.27023;
  const unsigned char * D.27024;
  unsigned char D.27025;
  int D.27026;
  _Bool D.27027;
  _Bool D.27028;
  const unsigned char * D.27031;
  unsigned char D.27032;
  int D.27033;
  const unsigned char * D.27034;
  unsigned char D.27035;
  int D.27036;
  _Bool D.27037;
  _Bool D.27038;
  const unsigned char * D.27041;
  unsigned char D.27042;
  int D.27043;
  const unsigned char * D.27044;
  unsigned char D.27045;
  int D.27046;
  const char * D.27048;
  int D.24073;
  int iftmp.166;
  int D.24072;
  const char[16] * D.27053;
  unsigned char D.27054;
  int D.27055;
  unsigned char D.27056;
  int D.27057;
  _Bool D.27058;
  _Bool D.27059;
  _Bool D.27060;
  const unsigned char * D.27063;
  unsigned char D.27064;
  int D.27065;
  const unsigned char * D.27066;
  unsigned char D.27067;
  int D.27068;
  _Bool D.27069;
  _Bool D.27070;
  const unsigned char * D.27073;
  unsigned char D.27074;
  int D.27075;
  const unsigned char * D.27076;
  unsigned char D.27077;
  int D.27078;
  _Bool D.27079;
  _Bool D.27080;
  const unsigned char * D.27083;
  unsigned char D.27084;
  int D.27085;
  const unsigned char * D.27086;
  unsigned char D.27087;
  int D.27088;
  int D.24082;
  int iftmp.167;
  int D.24081;
  const char[9] * D.27094;
  unsigned char D.27095;
  int D.27096;
  unsigned char D.27097;
  int D.27098;
  _Bool D.27099;
  _Bool D.27100;
  _Bool D.27101;
  const unsigned char * D.27104;
  unsigned char D.27105;
  int D.27106;
  const unsigned char * D.27107;
  unsigned char D.27108;
  int D.27109;
  _Bool D.27110;
  _Bool D.27111;
  const unsigned char * D.27114;
  unsigned char D.27115;
  int D.27116;
  const unsigned char * D.27117;
  unsigned char D.27118;
  int D.27119;
  _Bool D.27120;
  _Bool D.27121;
  const unsigned char * D.27124;
  unsigned char D.27125;
  int D.27126;
  const unsigned char * D.27127;
  unsigned char D.27128;
  int D.27129;
  struct MonoMethodSignature * D.27131;
  struct MonoType * D.27132;
  int D.27133;
  int D.24091;
  int iftmp.168;
  int D.24090;
  unsigned char D.27137;
  int D.27138;
  _Bool D.27139;
  _Bool D.27140;
  _Bool D.27141;
  const unsigned char * D.27144;
  unsigned char D.27145;
  int D.27146;
  _Bool D.27147;
  _Bool D.27148;
  const unsigned char * D.27151;
  unsigned char D.27152;
  int D.27153;
  _Bool D.27154;
  _Bool D.27155;
  const unsigned char * D.27158;
  unsigned char D.27159;
  int D.27160;
  int D.24100;
  int iftmp.169;
  int D.24099;
  const char[9] * D.27166;
  unsigned char D.27167;
  int D.27168;
  unsigned char D.27169;
  int D.27170;
  _Bool D.27171;
  _Bool D.27172;
  _Bool D.27173;
  const unsigned char * D.27176;
  unsigned char D.27177;
  int D.27178;
  const unsigned char * D.27179;
  unsigned char D.27180;
  int D.27181;
  _Bool D.27182;
  _Bool D.27183;
  const unsigned char * D.27186;
  unsigned char D.27187;
  int D.27188;
  const unsigned char * D.27189;
  unsigned char D.27190;
  int D.27191;
  _Bool D.27192;
  _Bool D.27193;
  const unsigned char * D.27196;
  unsigned char D.27197;
  int D.27198;
  const unsigned char * D.27199;
  unsigned char D.27200;
  int D.27201;
  int D.24109;
  int iftmp.170;
  int D.24108;
  const char[5] * D.27207;
  unsigned char D.27208;
  int D.27209;
  unsigned char D.27210;
  int D.27211;
  _Bool D.27212;
  _Bool D.27213;
  _Bool D.27214;
  const unsigned char * D.27217;
  unsigned char D.27218;
  int D.27219;
  const unsigned char * D.27220;
  unsigned char D.27221;
  int D.27222;
  _Bool D.27223;
  _Bool D.27224;
  const unsigned char * D.27227;
  unsigned char D.27228;
  int D.27229;
  const unsigned char * D.27230;
  unsigned char D.27231;
  int D.27232;
  _Bool D.27233;
  _Bool D.27234;
  const unsigned char * D.27237;
  unsigned char D.27238;
  int D.27239;
  const unsigned char * D.27240;
  unsigned char D.27241;
  int D.27242;
  struct MonoMethodSignature * D.27245;
  struct MonoType * D.27246;
  int D.27247;
  int D.24118;
  int iftmp.171;
  int D.24117;
  unsigned char D.27251;
  int D.27252;
  _Bool D.27253;
  _Bool D.27254;
  _Bool D.27255;
  const unsigned char * D.27258;
  unsigned char D.27259;
  int D.27260;
  _Bool D.27261;
  _Bool D.27262;
  const unsigned char * D.27265;
  unsigned char D.27266;
  int D.27267;
  _Bool D.27268;
  _Bool D.27269;
  const unsigned char * D.27272;
  unsigned char D.27273;
  int D.27274;
  int D.24127;
  int iftmp.172;
  int D.24126;
  unsigned char D.27280;
  int D.27281;
  _Bool D.27282;
  _Bool D.27283;
  _Bool D.27284;
  const unsigned char * D.27287;
  unsigned char D.27288;
  int D.27289;
  _Bool D.27290;
  _Bool D.27291;
  const unsigned char * D.27294;
  unsigned char D.27295;
  int D.27296;
  _Bool D.27297;
  _Bool D.27298;
  const unsigned char * D.27301;
  unsigned char D.27302;
  int D.27303;
  int D.24136;
  int iftmp.173;
  int D.24135;
  const char[6] * D.27309;
  unsigned char D.27310;
  int D.27311;
  unsigned char D.27312;
  int D.27313;
  _Bool D.27314;
  _Bool D.27315;
  _Bool D.27316;
  const unsigned char * D.27319;
  unsigned char D.27320;
  int D.27321;
  const unsigned char * D.27322;
  unsigned char D.27323;
  int D.27324;
  _Bool D.27325;
  _Bool D.27326;
  const unsigned char * D.27329;
  unsigned char D.27330;
  int D.27331;
  const unsigned char * D.27332;
  unsigned char D.27333;
  int D.27334;
  _Bool D.27335;
  _Bool D.27336;
  const unsigned char * D.27339;
  unsigned char D.27340;
  int D.27341;
  const unsigned char * D.27342;
  unsigned char D.27343;
  int D.27344;
  struct MonoMethodSignature * D.27347;
  struct MonoType * D.27348;
  int D.27349;
  struct MonoMethodSignature * D.27350;
  short unsigned int D.27351;
  int D.24149;
  const char * D.27354;
  _Bool D.27356;
  long int D.27357;
  long int D.27358;
  struct MonoGenericInst * D.27361;
  struct MonoMethod * D.27362;
  int D.27371;
  int D.27380;
  struct MonoMethod * D.27383;
  int D.27390;
  _Bool D.27397;
  long int D.27398;
  long int D.27399;
  struct GHashTable * D.27402;
  struct GHashTable * D.27405;
  void * method_index.174;
  _Bool D.27409;
  long int D.27410;
  long int D.27411;
  int method_index.175;
  struct MonoClass * klass;
  guint32 method_index;
  struct MonoAotModule * amodule;
  guint8 * code;

  try
    {
      klass = method->klass;
      D.26801 = klass->image;
      amodule.160 = D.26801->aot_module;
      amodule = amodule.160;
      amodule.161 = amodule;
      if (amodule.161 == 0B) goto <D.26804>; else goto <D.26805>;
      <D.26804>:
      D.26806 = 0B;
      return D.26806;
      <D.26805>:
      amodule.161 = amodule;
      D.26807 = amodule.161->out_of_date;
      if (D.26807 != 0) goto <D.26808>; else goto <D.26809>;
      <D.26808>:
      D.26806 = 0B;
      return D.26806;
      <D.26809>:
      D.26812 = method->iflags;
      D.26813 = (int) D.26812;
      D.26814 = D.26813 & 4096;
      if (D.26814 != 0) goto <D.26810>; else goto <D.26815>;
      <D.26815>:
      D.26816 = method->flags;
      D.26817 = (int) D.26816;
      D.26818 = D.26817 & 8192;
      if (D.26818 != 0) goto <D.26810>; else goto <D.26819>;
      <D.26819>:
      D.26812 = method->iflags;
      D.26813 = (int) D.26812;
      D.26820 = D.26813 & 3;
      if (D.26820 != 0) goto <D.26810>; else goto <D.26821>;
      <D.26821>:
      D.26816 = method->flags;
      D.26817 = (int) D.26816;
      D.26822 = D.26817 & 1024;
      if (D.26822 != 0) goto <D.26810>; else goto <D.26811>;
      <D.26810>:
      D.26806 = 0B;
      return D.26806;
      <D.26811>:
      mono_aot_only.162 = mono_aot_only;
      if (mono_aot_only.162 != 0) goto <D.26824>; else goto <D.26825>;
      <D.26824>:
      D.26826 = BIT_FIELD_REF <*method, 8, 160>;
      D.26827 = D.26826 & 124;
      if (D.26827 == 36) goto <D.26828>; else goto <D.26829>;
      <D.26828>:
      D.26830 = mono_marshal_method_from_wrapper (method);
      D.26806 = mono_aot_get_method (domain, D.26830);
      return D.26806;
      <D.26829>:
      <D.26825>:
      D.26831 = BIT_FIELD_REF <*klass, 8, 160>;
      D.26832 = D.26831 & 1;
      D.26833 = D.26832 == 0;
      D.26834 = (long int) D.26833;
      D.26835 = __builtin_expect (D.26834, 0);
      if (D.26835 != 0) goto <D.26836>; else goto <D.26837>;
      <D.26836>:
      monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "aot-runtime.c", 3615, "klass->inited");
      <D.26837>:
      method_index = 16777215;
      D.26840 = BIT_FIELD_REF <*method, 16, 160>;
      D.26841 = D.26840 & 4220;
      if (D.26841 == 4096) goto <D.26842>; else goto <D.26838>;
      <D.26842>:
      D.26843 = mono_method_is_generic_sharable_full (method, 0, 0, 0);
      if (D.26843 != 0) goto <D.26844>; else goto <D.26838>;
      <D.26844>:
      method = mono_method_get_declaring_generic_method (method);
      D.26845 = method->token;
      D.26846 = D.26845 & 16777215;
      method_index = D.26846 + 4294967295;
      goto <D.26839>;
      <D.26838>:
      D.26850 = BIT_FIELD_REF <*method, 8, 168>;
      D.26851 = D.26850 & 16;
      if (D.26851 != 0) goto <D.26847>; else goto <D.26852>;
      <D.26852>:
      D.26845 = method->token;
      if (D.26845 == 0) goto <D.26847>; else goto <D.26848>;
      <D.26847>:
      {
        int ret;

        ret = pthread_mutex_lock (&aot_mutex.mutex);
        if (ret != 0) goto <D.26853>; else goto <D.26854>;
        <D.26853>:
        monoeg_g_log (0B, 16, "Bad call to mono_mutex_lock result %d", ret);
        <D.26854>:
        D.26855 = ret != 0;
        D.26856 = (long int) D.26855;
        D.26857 = __builtin_expect (D.26856, 0);
        if (D.26857 != 0) goto <D.26858>; else goto <D.26859>;
        <D.26858>:
        monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "aot-runtime.c", 3628, "ret == 0");
        <D.26859>:
      }
      amodule.161 = amodule;
      D.26860 = amodule.161->method_to_code;
      code = monoeg_g_hash_table_lookup (D.26860, method);
      {
        int ret;

        ret = pthread_mutex_unlock (&aot_mutex.mutex);
        if (ret != 0) goto <D.26861>; else goto <D.26862>;
        <D.26861>:
        monoeg_g_log (0B, 16, "Bad call to mono_mutex_unlock result %d", ret);
        <D.26862>:
        D.26863 = ret != 0;
        D.26864 = (long int) D.26863;
        D.26865 = __builtin_expect (D.26864, 0);
        if (D.26865 != 0) goto <D.26866>; else goto <D.26867>;
        <D.26866>:
        monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "aot-runtime.c", 3630, "ret == 0");
        <D.26867>:
      }
      if (code != 0B) goto <D.26868>; else goto <D.26869>;
      <D.26868>:
      D.26806 = code;
      return D.26806;
      <D.26869>:
      method_index = find_extra_method (method, &amodule);
      if (method_index == 16777215) goto <D.26870>; else goto <D.26871>;
      <D.26870>:
      D.26826 = BIT_FIELD_REF <*method, 8, 160>;
      D.26827 = D.26826 & 124;
      if (D.26827 == 28) goto <D.26872>; else goto <D.26873>;
      <D.26872>:
      D.26874 = method->klass;
      D.26875 = D.26874->rank;
      if (D.26875 != 0) goto <D.26876>; else goto <D.26877>;
      <D.26876>:
      D.26878 = method->name;
      D.26879 = strstr (D.26878, "System.Collections.Generic");
      if (D.26879 != 0B) goto <D.26880>; else goto <D.26881>;
      <D.26880>:
      {
        struct MonoMethod * m;

        m = mono_aot_get_array_helper_from_wrapper (method);
        code = mono_aot_get_method (domain, m);
        if (code != 0B) goto <D.26882>; else goto <D.26883>;
        <D.26882>:
        D.26884 = mono_method_needs_static_rgctx_invoke (m, 0);
        if (D.26884 != 0) goto <D.26885>; else goto <D.26886>;
        <D.26885>:
        D.26887 = mono_create_ftnptr (domain, code);
        code = mono_create_static_rgctx_trampoline (m, D.26887);
        code = mono_get_addr_from_ftnptr (code);
        <D.26886>:
        D.26806 = code;
        return D.26806;
        <D.26883>:
      }
      <D.26881>:
      <D.26877>:
      <D.26873>:
      <D.26871>:
      if (method_index == 16777215) goto <D.26888>; else goto <D.26889>;
      <D.26888>:
      D.26826 = BIT_FIELD_REF <*method, 8, 160>;
      D.26827 = D.26826 & 124;
      if (D.26827 == 24) goto <D.26890>; else goto <D.26891>;
      <D.26890>:
      D.26874 = method->klass;
      D.26892 = mono_defaults.array_class;
      if (D.26874 == D.26892) goto <D.26893>; else goto <D.26894>;
      <D.26893>:
      {
        size_t __s1_len;
        size_t __s2_len;

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

          __s2 = method->name;
          D.26898 = "GetGenericValueImpl";
          D.26899 = MEM[(const unsigned char *)D.26898];
          D.26900 = (int) D.26899;
          D.26901 = *__s2;
          D.26902 = (int) D.26901;
          __result = D.26900 - D.26902;
          {
            D.26903 = __s2_len != 0;
            D.26904 = __result == 0;
            D.26905 = D.26903 & D.26904;
            if (D.26905 != 0) goto <D.26906>; else goto <D.26907>;
            <D.26906>:
            D.26908 = &MEM[(void *)"GetGenericValueImpl" + 1B];
            D.26909 = *D.26908;
            D.26910 = (int) D.26909;
            D.26911 = __s2 + 1;
            D.26912 = *D.26911;
            D.26913 = (int) D.26912;
            __result = D.26910 - D.26913;
            D.26914 = __s2_len > 1;
            D.26904 = __result == 0;
            D.26915 = D.26914 & D.26904;
            if (D.26915 != 0) goto <D.26916>; else goto <D.26917>;
            <D.26916>:
            D.26918 = &MEM[(void *)"GetGenericValueImpl" + 2B];
            D.26919 = *D.26918;
            D.26920 = (int) D.26919;
            D.26921 = __s2 + 2;
            D.26922 = *D.26921;
            D.26923 = (int) D.26922;
            __result = D.26920 - D.26923;
            D.26924 = __s2_len > 2;
            D.26904 = __result == 0;
            D.26925 = D.26924 & D.26904;
            if (D.26925 != 0) goto <D.26926>; else goto <D.26927>;
            <D.26926>:
            D.26928 = &MEM[(void *)"GetGenericValueImpl" + 3B];
            D.26929 = *D.26928;
            D.26930 = (int) D.26929;
            D.26931 = __s2 + 3;
            D.26932 = *D.26931;
            D.26933 = (int) D.26932;
            __result = D.26930 - D.26933;
            <D.26927>:
            <D.26917>:
            <D.26907>:
          }
          D.24042 = __result;
        }
        iftmp.163 = -D.24042;
        goto <D.26934>;
        <D.26897>:
        D.26878 = method->name;
        iftmp.163 = __builtin_strcmp (D.26878, "GetGenericValueImpl");
        <D.26934>:
        D.24043 = iftmp.163;
      }
      if (D.24043 == 0) goto <D.26935>; else goto <D.26936>;
      <D.26935>:
      {
        struct MonoMethod * m;
        struct MonoGenericContext ctx;
        struct MonoType * args[16];

        try
          {
            D.26937 = mono_method_signature (method);
            D.26938 = D.26937->params[1];
            D.26939 = D.26938->type;
            if (D.26939 == 28) goto <D.26940>; else goto <D.26941>;
            <D.26940>:
            D.26806 = 0B;
            return D.26806;
            <D.26941>:
            D.26892 = mono_defaults.array_class;
            m = mono_class_get_method_from_name (D.26892, "GetGenericValueImpl", 2);
            D.26942 = m == 0B;
            D.26943 = (long int) D.26942;
            D.26944 = __builtin_expect (D.26943, 0);
            if (D.26944 != 0) goto <D.26945>; else goto <D.26946>;
            <D.26945>:
            monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "aot-runtime.c", 3670, "m");
            <D.26946>:
            memset (&ctx, 0, 8);
            D.26947 = mono_defaults.object_class;
            D.26948 = &D.26947->byval_arg;
            args[0] = D.26948;
            D.26949 = mono_metadata_get_generic_inst (1, &args);
            ctx.method_inst = D.26949;
            D.26950 = mono_class_inflate_generic_method (m, &ctx);
            m = mono_marshal_get_native_wrapper (D.26950, 1, 1);
            code = mono_aot_get_method (domain, m);
            if (code != 0B) goto <D.26951>; else goto <D.26952>;
            <D.26951>:
            D.26806 = code;
            return D.26806;
            <D.26952>:
          }
        finally
          {
            ctx = {CLOBBER};
            args = {CLOBBER};
          }
      }
      <D.26936>:
      <D.26894>:
      <D.26891>:
      <D.26889>:
      if (method_index == 16777215) goto <D.26958>; else goto <D.26959>;
      <D.26958>:
      D.26826 = BIT_FIELD_REF <*method, 8, 160>;
      D.26827 = D.26826 & 124;
      if (D.26827 == 24) goto <D.26960>; else goto <D.26961>;
      <D.26960>:
      D.26874 = method->klass;
      D.26962 = D.26874->image;
      D.26963 = mono_defaults.corlib;
      if (D.26962 == D.26963) goto <D.26964>; else goto <D.26965>;
      <D.26964>:
      {
        size_t __s1_len;
        size_t __s2_len;

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

          D.26874 = method->klass;
          __s2 = D.26874->name_space;
          D.26969 = "System.Threading";
          D.26970 = MEM[(const unsigned char *)D.26969];
          D.26971 = (int) D.26970;
          D.26972 = *__s2;
          D.26973 = (int) D.26972;
          __result = D.26971 - D.26973;
          {
            D.26974 = __s2_len != 0;
            D.26975 = __result == 0;
            D.26976 = D.26974 & D.26975;
            if (D.26976 != 0) goto <D.26977>; else goto <D.26978>;
            <D.26977>:
            D.26979 = &MEM[(void *)"System.Threading" + 1B];
            D.26980 = *D.26979;
            D.26981 = (int) D.26980;
            D.26982 = __s2 + 1;
            D.26983 = *D.26982;
            D.26984 = (int) D.26983;
            __result = D.26981 - D.26984;
            D.26985 = __s2_len > 1;
            D.26975 = __result == 0;
            D.26986 = D.26985 & D.26975;
            if (D.26986 != 0) goto <D.26987>; else goto <D.26988>;
            <D.26987>:
            D.26989 = &MEM[(void *)"System.Threading" + 2B];
            D.26990 = *D.26989;
            D.26991 = (int) D.26990;
            D.26992 = __s2 + 2;
            D.26993 = *D.26992;
            D.26994 = (int) D.26993;
            __result = D.26991 - D.26994;
            D.26995 = __s2_len > 2;
            D.26975 = __result == 0;
            D.26996 = D.26995 & D.26975;
            if (D.26996 != 0) goto <D.26997>; else goto <D.26998>;
            <D.26997>:
            D.26999 = &MEM[(void *)"System.Threading" + 3B];
            D.27000 = *D.26999;
            D.27001 = (int) D.27000;
            D.27002 = __s2 + 3;
            D.27003 = *D.27002;
            D.27004 = (int) D.27003;
            __result = D.27001 - D.27004;
            <D.26998>:
            <D.26988>:
            <D.26978>:
          }
          D.24054 = __result;
        }
        iftmp.164 = -D.24054;
        goto <D.27005>;
        <D.26968>:
        D.26874 = method->klass;
        D.27006 = D.26874->name_space;
        iftmp.164 = __builtin_strcmp (D.27006, "System.Threading");
        <D.27005>:
        D.24055 = iftmp.164;
      }
      if (D.24055 == 0) goto <D.27007>; else goto <D.26953>;
      <D.27007>:
      {
        size_t __s1_len;
        size_t __s2_len;

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

          D.26874 = method->klass;
          __s2 = D.26874->name;
          D.27011 = "Interlocked";
          D.27012 = MEM[(const unsigned char *)D.27011];
          D.27013 = (int) D.27012;
          D.27014 = *__s2;
          D.27015 = (int) D.27014;
          __result = D.27013 - D.27015;
          {
            D.27016 = __s2_len != 0;
            D.27017 = __result == 0;
            D.27018 = D.27016 & D.27017;
            if (D.27018 != 0) goto <D.27019>; else goto <D.27020>;
            <D.27019>:
            D.27021 = &MEM[(void *)"Interlocked" + 1B];
            D.27022 = *D.27021;
            D.27023 = (int) D.27022;
            D.27024 = __s2 + 1;
            D.27025 = *D.27024;
            D.27026 = (int) D.27025;
            __result = D.27023 - D.27026;
            D.27027 = __s2_len > 1;
            D.27017 = __result == 0;
            D.27028 = D.27027 & D.27017;
            if (D.27028 != 0) goto <D.27029>; else goto <D.27030>;
            <D.27029>:
            D.27031 = &MEM[(void *)"Interlocked" + 2B];
            D.27032 = *D.27031;
            D.27033 = (int) D.27032;
            D.27034 = __s2 + 2;
            D.27035 = *D.27034;
            D.27036 = (int) D.27035;
            __result = D.27033 - D.27036;
            D.27037 = __s2_len > 2;
            D.27017 = __result == 0;
            D.27038 = D.27037 & D.27017;
            if (D.27038 != 0) goto <D.27039>; else goto <D.27040>;
            <D.27039>:
            D.27041 = &MEM[(void *)"Interlocked" + 3B];
            D.27042 = *D.27041;
            D.27043 = (int) D.27042;
            D.27044 = __s2 + 3;
            D.27045 = *D.27044;
            D.27046 = (int) D.27045;
            __result = D.27043 - D.27046;
            <D.27040>:
            <D.27030>:
            <D.27020>:
          }
          D.24063 = __result;
        }
        iftmp.165 = -D.24063;
        goto <D.27047>;
        <D.27010>:
        D.26874 = method->klass;
        D.27048 = D.26874->name;
        iftmp.165 = __builtin_strcmp (D.27048, "Interlocked");
        <D.27047>:
        D.24064 = iftmp.165;
      }
      if (D.24064 == 0) goto <D.27049>; else goto <D.26953>;
      <D.27049>:
      {
        size_t __s1_len;
        size_t __s2_len;

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

          __s2 = method->name;
          D.27053 = "CompareExchange";
          D.27054 = MEM[(const unsigned char *)D.27053];
          D.27055 = (int) D.27054;
          D.27056 = *__s2;
          D.27057 = (int) D.27056;
          __result = D.27055 - D.27057;
          {
            D.27058 = __s2_len != 0;
            D.27059 = __result == 0;
            D.27060 = D.27058 & D.27059;
            if (D.27060 != 0) goto <D.27061>; else goto <D.27062>;
            <D.27061>:
            D.27063 = &MEM[(void *)"CompareExchange" + 1B];
            D.27064 = *D.27063;
            D.27065 = (int) D.27064;
            D.27066 = __s2 + 1;
            D.27067 = *D.27066;
            D.27068 = (int) D.27067;
            __result = D.27065 - D.27068;
            D.27069 = __s2_len > 1;
            D.27059 = __result == 0;
            D.27070 = D.27069 & D.27059;
            if (D.27070 != 0) goto <D.27071>; else goto <D.27072>;
            <D.27071>:
            D.27073 = &MEM[(void *)"CompareExchange" + 2B];
            D.27074 = *D.27073;
            D.27075 = (int) D.27074;
            D.27076 = __s2 + 2;
            D.27077 = *D.27076;
            D.27078 = (int) D.27077;
            __result = D.27075 - D.27078;
            D.27079 = __s2_len > 2;
            D.27059 = __result == 0;
            D.27080 = D.27079 & D.27059;
            if (D.27080 != 0) goto <D.27081>; else goto <D.27082>;
            <D.27081>:
            D.27083 = &MEM[(void *)"CompareExchange" + 3B];
            D.27084 = *D.27083;
            D.27085 = (int) D.27084;
            D.27086 = __s2 + 3;
            D.27087 = *D.27086;
            D.27088 = (int) D.27087;
            __result = D.27085 - D.27088;
            <D.27082>:
            <D.27072>:
            <D.27062>:
          }
          D.24072 = __result;
        }
        iftmp.166 = -D.24072;
        goto <D.27089>;
        <D.27052>:
        D.26878 = method->name;
        iftmp.166 = __builtin_strcmp (D.26878, "CompareExchange");
        <D.27089>:
        D.24073 = iftmp.166;
      }
      if (D.24073 == 0) goto <D.26954>; else goto <D.27090>;
      <D.27090>:
      {
        size_t __s1_len;
        size_t __s2_len;

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

          __s2 = method->name;
          D.27094 = "Exchange";
          D.27095 = MEM[(const unsigned char *)D.27094];
          D.27096 = (int) D.27095;
          D.27097 = *__s2;
          D.27098 = (int) D.27097;
          __result = D.27096 - D.27098;
          {
            D.27099 = __s2_len != 0;
            D.27100 = __result == 0;
            D.27101 = D.27099 & D.27100;
            if (D.27101 != 0) goto <D.27102>; else goto <D.27103>;
            <D.27102>:
            D.27104 = &MEM[(void *)"Exchange" + 1B];
            D.27105 = *D.27104;
            D.27106 = (int) D.27105;
            D.27107 = __s2 + 1;
            D.27108 = *D.27107;
            D.27109 = (int) D.27108;
            __result = D.27106 - D.27109;
            D.27110 = __s2_len > 1;
            D.27100 = __result == 0;
            D.27111 = D.27110 & D.27100;
            if (D.27111 != 0) goto <D.27112>; else goto <D.27113>;
            <D.27112>:
            D.27114 = &MEM[(void *)"Exchange" + 2B];
            D.27115 = *D.27114;
            D.27116 = (int) D.27115;
            D.27117 = __s2 + 2;
            D.27118 = *D.27117;
            D.27119 = (int) D.27118;
            __result = D.27116 - D.27119;
            D.27120 = __s2_len > 2;
            D.27100 = __result == 0;
            D.27121 = D.27120 & D.27100;
            if (D.27121 != 0) goto <D.27122>; else goto <D.27123>;
            <D.27122>:
            D.27124 = &MEM[(void *)"Exchange" + 3B];
            D.27125 = *D.27124;
            D.27126 = (int) D.27125;
            D.27127 = __s2 + 3;
            D.27128 = *D.27127;
            D.27129 = (int) D.27128;
            __result = D.27126 - D.27129;
            <D.27123>:
            <D.27113>:
            <D.27103>:
          }
          D.24081 = __result;
        }
        iftmp.167 = -D.24081;
        goto <D.27130>;
        <D.27093>:
        D.26878 = method->name;
        iftmp.167 = __builtin_strcmp (D.26878, "Exchange");
        <D.27130>:
        D.24082 = iftmp.167;
      }
      if (D.24082 == 0) goto <D.26954>; else goto <D.26953>;
      <D.26954>:
      D.27131 = mono_method_signature (method);
      D.27132 = D.27131->params[1];
      D.27133 = mono_type_is_reference (D.27132);
      if (D.27133 != 0) goto <D.26955>; else goto <D.26953>;
      <D.26953>:
      {
        size_t __s1_len;
        size_t __s2_len;

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

          D.26874 = method->klass;
          __s2 = D.26874->name_space;
          D.26969 = "System.Threading";
          D.26970 = MEM[(const unsigned char *)D.26969];
          D.26971 = (int) D.26970;
          D.27137 = *__s2;
          D.27138 = (int) D.27137;
          __result = D.26971 - D.27138;
          {
            D.27139 = __s2_len != 0;
            D.27140 = __result == 0;
            D.27141 = D.27139 & D.27140;
            if (D.27141 != 0) goto <D.27142>; else goto <D.27143>;
            <D.27142>:
            D.26979 = &MEM[(void *)"System.Threading" + 1B];
            D.26980 = *D.26979;
            D.26981 = (int) D.26980;
            D.27144 = __s2 + 1;
            D.27145 = *D.27144;
            D.27146 = (int) D.27145;
            __result = D.26981 - D.27146;
            D.27147 = __s2_len > 1;
            D.27140 = __result == 0;
            D.27148 = D.27147 & D.27140;
            if (D.27148 != 0) goto <D.27149>; else goto <D.27150>;
            <D.27149>:
            D.26989 = &MEM[(void *)"System.Threading" + 2B];
            D.26990 = *D.26989;
            D.26991 = (int) D.26990;
            D.27151 = __s2 + 2;
            D.27152 = *D.27151;
            D.27153 = (int) D.27152;
            __result = D.26991 - D.27153;
            D.27154 = __s2_len > 2;
            D.27140 = __result == 0;
            D.27155 = D.27154 & D.27140;
            if (D.27155 != 0) goto <D.27156>; else goto <D.27157>;
            <D.27156>:
            D.26999 = &MEM[(void *)"System.Threading" + 3B];
            D.27000 = *D.26999;
            D.27001 = (int) D.27000;
            D.27158 = __s2 + 3;
            D.27159 = *D.27158;
            D.27160 = (int) D.27159;
            __result = D.27001 - D.27160;
            <D.27157>:
            <D.27150>:
            <D.27143>:
          }
          D.24090 = __result;
        }
        iftmp.168 = -D.24090;
        goto <D.27161>;
        <D.27136>:
        D.26874 = method->klass;
        D.27006 = D.26874->name_space;
        iftmp.168 = __builtin_strcmp (D.27006, "System.Threading");
        <D.27161>:
        D.24091 = iftmp.168;
      }
      if (D.24091 == 0) goto <D.27162>; else goto <D.26956>;
      <D.27162>:
      {
        size_t __s1_len;
        size_t __s2_len;

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

          D.26874 = method->klass;
          __s2 = D.26874->name;
          D.27166 = "Volatile";
          D.27167 = MEM[(const unsigned char *)D.27166];
          D.27168 = (int) D.27167;
          D.27169 = *__s2;
          D.27170 = (int) D.27169;
          __result = D.27168 - D.27170;
          {
            D.27171 = __s2_len != 0;
            D.27172 = __result == 0;
            D.27173 = D.27171 & D.27172;
            if (D.27173 != 0) goto <D.27174>; else goto <D.27175>;
            <D.27174>:
            D.27176 = &MEM[(void *)"Volatile" + 1B];
            D.27177 = *D.27176;
            D.27178 = (int) D.27177;
            D.27179 = __s2 + 1;
            D.27180 = *D.27179;
            D.27181 = (int) D.27180;
            __result = D.27178 - D.27181;
            D.27182 = __s2_len > 1;
            D.27172 = __result == 0;
            D.27183 = D.27182 & D.27172;
            if (D.27183 != 0) goto <D.27184>; else goto <D.27185>;
            <D.27184>:
            D.27186 = &MEM[(void *)"Volatile" + 2B];
            D.27187 = *D.27186;
            D.27188 = (int) D.27187;
            D.27189 = __s2 + 2;
            D.27190 = *D.27189;
            D.27191 = (int) D.27190;
            __result = D.27188 - D.27191;
            D.27192 = __s2_len > 2;
            D.27172 = __result == 0;
            D.27193 = D.27192 & D.27172;
            if (D.27193 != 0) goto <D.27194>; else goto <D.27195>;
            <D.27194>:
            D.27196 = &MEM[(void *)"Volatile" + 3B];
            D.27197 = *D.27196;
            D.27198 = (int) D.27197;
            D.27199 = __s2 + 3;
            D.27200 = *D.27199;
            D.27201 = (int) D.27200;
            __result = D.27198 - D.27201;
            <D.27195>:
            <D.27185>:
            <D.27175>:
          }
          D.24099 = __result;
        }
        iftmp.169 = -D.24099;
        goto <D.27202>;
        <D.27165>:
        D.26874 = method->klass;
        D.27048 = D.26874->name;
        iftmp.169 = __builtin_strcmp (D.27048, "Volatile");
        <D.27202>:
        D.24100 = iftmp.169;
      }
      if (D.24100 == 0) goto <D.27203>; else goto <D.26956>;
      <D.27203>:
      {
        size_t __s1_len;
        size_t __s2_len;

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

          __s2 = method->name;
          D.27207 = "Read";
          D.27208 = MEM[(const unsigned char *)D.27207];
          D.27209 = (int) D.27208;
          D.27210 = *__s2;
          D.27211 = (int) D.27210;
          __result = D.27209 - D.27211;
          {
            D.27212 = __s2_len != 0;
            D.27213 = __result == 0;
            D.27214 = D.27212 & D.27213;
            if (D.27214 != 0) goto <D.27215>; else goto <D.27216>;
            <D.27215>:
            D.27217 = &MEM[(void *)"Read" + 1B];
            D.27218 = *D.27217;
            D.27219 = (int) D.27218;
            D.27220 = __s2 + 1;
            D.27221 = *D.27220;
            D.27222 = (int) D.27221;
            __result = D.27219 - D.27222;
            D.27223 = __s2_len > 1;
            D.27213 = __result == 0;
            D.27224 = D.27223 & D.27213;
            if (D.27224 != 0) goto <D.27225>; else goto <D.27226>;
            <D.27225>:
            D.27227 = &MEM[(void *)"Read" + 2B];
            D.27228 = *D.27227;
            D.27229 = (int) D.27228;
            D.27230 = __s2 + 2;
            D.27231 = *D.27230;
            D.27232 = (int) D.27231;
            __result = D.27229 - D.27232;
            D.27233 = __s2_len > 2;
            D.27213 = __result == 0;
            D.27234 = D.27233 & D.27213;
            if (D.27234 != 0) goto <D.27235>; else goto <D.27236>;
            <D.27235>:
            D.27237 = &MEM[(void *)"Read" + 3B];
            D.27238 = *D.27237;
            D.27239 = (int) D.27238;
            D.27240 = __s2 + 3;
            D.27241 = *D.27240;
            D.27242 = (int) D.27241;
            __result = D.27239 - D.27242;
            <D.27236>:
            <D.27226>:
            <D.27216>:
          }
          D.24108 = __result;
        }
        iftmp.170 = -D.24108;
        goto <D.27243>;
        <D.27206>:
        D.26878 = method->name;
        iftmp.170 = __builtin_strcmp (D.26878, "Read");
        <D.27243>:
        D.24109 = iftmp.170;
      }
      if (D.24109 == 0) goto <D.27244>; else goto <D.26956>;
      <D.27244>:
      D.27245 = mono_method_signature (method);
      D.27246 = D.27245->ret;
      D.27247 = mono_type_is_reference (D.27246);
      if (D.27247 != 0) goto <D.26955>; else goto <D.26956>;
      <D.26956>:
      {
        size_t __s1_len;
        size_t __s2_len;

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

          D.26874 = method->klass;
          __s2 = D.26874->name_space;
          D.26969 = "System.Threading";
          D.26970 = MEM[(const unsigned char *)D.26969];
          D.26971 = (int) D.26970;
          D.27251 = *__s2;
          D.27252 = (int) D.27251;
          __result = D.26971 - D.27252;
          {
            D.27253 = __s2_len != 0;
            D.27254 = __result == 0;
            D.27255 = D.27253 & D.27254;
            if (D.27255 != 0) goto <D.27256>; else goto <D.27257>;
            <D.27256>:
            D.26979 = &MEM[(void *)"System.Threading" + 1B];
            D.26980 = *D.26979;
            D.26981 = (int) D.26980;
            D.27258 = __s2 + 1;
            D.27259 = *D.27258;
            D.27260 = (int) D.27259;
            __result = D.26981 - D.27260;
            D.27261 = __s2_len > 1;
            D.27254 = __result == 0;
            D.27262 = D.27261 & D.27254;
            if (D.27262 != 0) goto <D.27263>; else goto <D.27264>;
            <D.27263>:
            D.26989 = &MEM[(void *)"System.Threading" + 2B];
            D.26990 = *D.26989;
            D.26991 = (int) D.26990;
            D.27265 = __s2 + 2;
            D.27266 = *D.27265;
            D.27267 = (int) D.27266;
            __result = D.26991 - D.27267;
            D.27268 = __s2_len > 2;
            D.27254 = __result == 0;
            D.27269 = D.27268 & D.27254;
            if (D.27269 != 0) goto <D.27270>; else goto <D.27271>;
            <D.27270>:
            D.26999 = &MEM[(void *)"System.Threading" + 3B];
            D.27000 = *D.26999;
            D.27001 = (int) D.27000;
            D.27272 = __s2 + 3;
            D.27273 = *D.27272;
            D.27274 = (int) D.27273;
            __result = D.27001 - D.27274;
            <D.27271>:
            <D.27264>:
            <D.27257>:
          }
          D.24117 = __result;
        }
        iftmp.171 = -D.24117;
        goto <D.27275>;
        <D.27250>:
        D.26874 = method->klass;
        D.27006 = D.26874->name_space;
        iftmp.171 = __builtin_strcmp (D.27006, "System.Threading");
        <D.27275>:
        D.24118 = iftmp.171;
      }
      if (D.24118 == 0) goto <D.27276>; else goto <D.26957>;
      <D.27276>:
      {
        size_t __s1_len;
        size_t __s2_len;

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

          D.26874 = method->klass;
          __s2 = D.26874->name;
          D.27166 = "Volatile";
          D.27167 = MEM[(const unsigned char *)D.27166];
          D.27168 = (int) D.27167;
          D.27280 = *__s2;
          D.27281 = (int) D.27280;
          __result = D.27168 - D.27281;
          {
            D.27282 = __s2_len != 0;
            D.27283 = __result == 0;
            D.27284 = D.27282 & D.27283;
            if (D.27284 != 0) goto <D.27285>; else goto <D.27286>;
            <D.27285>:
            D.27176 = &MEM[(void *)"Volatile" + 1B];
            D.27177 = *D.27176;
            D.27178 = (int) D.27177;
            D.27287 = __s2 + 1;
            D.27288 = *D.27287;
            D.27289 = (int) D.27288;
            __result = D.27178 - D.27289;
            D.27290 = __s2_len > 1;
            D.27283 = __result == 0;
            D.27291 = D.27290 & D.27283;
            if (D.27291 != 0) goto <D.27292>; else goto <D.27293>;
            <D.27292>:
            D.27186 = &MEM[(void *)"Volatile" + 2B];
            D.27187 = *D.27186;
            D.27188 = (int) D.27187;
            D.27294 = __s2 + 2;
            D.27295 = *D.27294;
            D.27296 = (int) D.27295;
            __result = D.27188 - D.27296;
            D.27297 = __s2_len > 2;
            D.27283 = __result == 0;
            D.27298 = D.27297 & D.27283;
            if (D.27298 != 0) goto <D.27299>; else goto <D.27300>;
            <D.27299>:
            D.27196 = &MEM[(void *)"Volatile" + 3B];
            D.27197 = *D.27196;
            D.27198 = (int) D.27197;
            D.27301 = __s2 + 3;
            D.27302 = *D.27301;
            D.27303 = (int) D.27302;
            __result = D.27198 - D.27303;
            <D.27300>:
            <D.27293>:
            <D.27286>:
          }
          D.24126 = __result;
        }
        iftmp.172 = -D.24126;
        goto <D.27304>;
        <D.27279>:
        D.26874 = method->klass;
        D.27048 = D.26874->name;
        iftmp.172 = __builtin_strcmp (D.27048, "Volatile");
        <D.27304>:
        D.24127 = iftmp.172;
      }
      if (D.24127 == 0) goto <D.27305>; else goto <D.26957>;
      <D.27305>:
      {
        size_t __s1_len;
        size_t __s2_len;

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

          __s2 = method->name;
          D.27309 = "Write";
          D.27310 = MEM[(const unsigned char *)D.27309];
          D.27311 = (int) D.27310;
          D.27312 = *__s2;
          D.27313 = (int) D.27312;
          __result = D.27311 - D.27313;
          {
            D.27314 = __s2_len != 0;
            D.27315 = __result == 0;
            D.27316 = D.27314 & D.27315;
            if (D.27316 != 0) goto <D.27317>; else goto <D.27318>;
            <D.27317>:
            D.27319 = &MEM[(void *)"Write" + 1B];
            D.27320 = *D.27319;
            D.27321 = (int) D.27320;
            D.27322 = __s2 + 1;
            D.27323 = *D.27322;
            D.27324 = (int) D.27323;
            __result = D.27321 - D.27324;
            D.27325 = __s2_len > 1;
            D.27315 = __result == 0;
            D.27326 = D.27325 & D.27315;
            if (D.27326 != 0) goto <D.27327>; else goto <D.27328>;
            <D.27327>:
            D.27329 = &MEM[(void *)"Write" + 2B];
            D.27330 = *D.27329;
            D.27331 = (int) D.27330;
            D.27332 = __s2 + 2;
            D.27333 = *D.27332;
            D.27334 = (int) D.27333;
            __result = D.27331 - D.27334;
            D.27335 = __s2_len > 2;
            D.27315 = __result == 0;
            D.27336 = D.27335 & D.27315;
            if (D.27336 != 0) goto <D.27337>; else goto <D.27338>;
            <D.27337>:
            D.27339 = &MEM[(void *)"Write" + 3B];
            D.27340 = *D.27339;
            D.27341 = (int) D.27340;
            D.27342 = __s2 + 3;
            D.27343 = *D.27342;
            D.27344 = (int) D.27343;
            __result = D.27341 - D.27344;
            <D.27338>:
            <D.27328>:
            <D.27318>:
          }
          D.24135 = __result;
        }
        iftmp.173 = -D.24135;
        goto <D.27345>;
        <D.27308>:
        D.26878 = method->name;
        iftmp.173 = __builtin_strcmp (D.26878, "Write");
        <D.27345>:
        D.24136 = iftmp.173;
      }
      if (D.24136 == 0) goto <D.27346>; else goto <D.26957>;
      <D.27346>:
      D.27347 = mono_method_signature (method);
      D.27348 = D.27347->params[1];
      D.27349 = mono_type_is_reference (D.27348);
      if (D.27349 != 0) goto <D.26955>; else goto <D.26957>;
      <D.26955>:
      {
        struct MonoMethod * m;
        struct MonoGenericContext ctx;
        struct MonoType * args[16];
        void * iter;

        try
          {
            iter = 0B;
            goto <D.24152>;
            <D.24151>:
            D.27350 = mono_method_signature (m);
            D.27351 = D.27350->generic_param_count;
            if (D.27351 != 0) goto <D.27352>; else goto <D.27353>;
            <D.27352>:
            {
              size_t __s1_len;
              size_t __s2_len;

              D.26878 = method->name;
              D.27354 = m->name;
              D.24149 = __builtin_strcmp (D.27354, D.26878);
            }
            if (D.24149 == 0) goto <D.24150>; else goto <D.27355>;
            <D.27355>:
            <D.27353>:
            <D.24152>:
            D.26874 = method->klass;
            m = mono_class_get_methods (D.26874, &iter);
            if (m != 0B) goto <D.24151>; else goto <D.24150>;
            <D.24150>:
            D.27356 = m == 0B;
            D.27357 = (long int) D.27356;
            D.27358 = __builtin_expect (D.27357, 0);
            if (D.27358 != 0) goto <D.27359>; else goto <D.27360>;
            <D.27359>:
            monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "aot-runtime.c", 3702, "m");
            <D.27360>:
            memset (&ctx, 0, 8);
            D.26947 = mono_defaults.object_class;
            D.26948 = &D.26947->byval_arg;
            args[0] = D.26948;
            D.27361 = mono_metadata_get_generic_inst (1, &args);
            ctx.method_inst = D.27361;
            D.27362 = mono_class_inflate_generic_method (m, &ctx);
            m = mono_marshal_get_native_wrapper (D.27362, 1, 1);
            if (method == m) goto <D.27363>; else goto <D.27364>;
            <D.27363>:
            D.26806 = 0B;
            return D.26806;
            <D.27364>:
            code = mono_aot_get_method (domain, m);
            if (code != 0B) goto <D.27365>; else goto <D.27366>;
            <D.27365>:
            D.26806 = code;
            return D.26806;
            <D.27366>:
          }
        finally
          {
            ctx = {CLOBBER};
            args = {CLOBBER};
            iter = {CLOBBER};
          }
      }
      <D.26957>:
      <D.26965>:
      <D.26961>:
      <D.26959>:
      if (method_index == 16777215) goto <D.27367>; else goto <D.27368>;
      <D.27367>:
      D.26850 = BIT_FIELD_REF <*method, 8, 168>;
      D.26851 = D.26850 & 16;
      if (D.26851 != 0) goto <D.27369>; else goto <D.27370>;
      <D.27369>:
      D.27371 = mono_method_is_generic_sharable_full (method, 0, 1, 0);
      if (D.27371 != 0) goto <D.27372>; else goto <D.27373>;
      <D.27372>:
      {
        struct MonoMethod * shared;

        shared = mini_get_shared_method (method);
        method_index = find_extra_method (shared, &amodule);
        if (method_index != 16777215) goto <D.27374>; else goto <D.27375>;
        <D.27374>:
        method = shared;
        <D.27375>:
      }
      <D.27373>:
      <D.27370>:
      <D.27368>:
      if (method_index == 16777215) goto <D.27376>; else goto <D.27377>;
      <D.27376>:
      D.26850 = BIT_FIELD_REF <*method, 8, 168>;
      D.26851 = D.26850 & 16;
      if (D.26851 != 0) goto <D.27378>; else goto <D.27379>;
      <D.27378>:
      D.27380 = mono_method_is_generic_sharable_full (method, 0, 0, 1);
      if (D.27380 != 0) goto <D.27381>; else goto <D.27382>;
      <D.27381>:
      D.27383 = mini_get_shared_method_full (method, 1, 1);
      method_index = find_extra_method (D.27383, &amodule);
      if (method_index != 16777215) goto <D.27384>; else goto <D.27385>;
      <D.27384>:
      method = mini_get_shared_method_full (method, 1, 0);
      <D.27385>:
      <D.27382>:
      <D.27379>:
      <D.27377>:
      if (method_index == 16777215) goto <D.27386>; else goto <D.27387>;
      <D.27386>:
      mono_aot_only.162 = mono_aot_only;
      if (mono_aot_only.162 != 0) goto <D.27388>; else goto <D.27389>;
      <D.27388>:
      D.27390 = mono_trace_is_traced (128, 32);
      if (D.27390 != 0) goto <D.27391>; else goto <D.27392>;
      <D.27391>:
      {
        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.27392>:
      <D.27389>:
      D.26806 = 0B;
      return D.26806;
      <D.27387>:
      if (method_index == 16777215) goto <D.27393>; else goto <D.27394>;
      <D.27393>:
      D.26806 = 0B;
      return D.26806;
      <D.27394>:
      {
        int ret;

        ret = pthread_mutex_lock (&aot_mutex.mutex);
        if (ret != 0) goto <D.27395>; else goto <D.27396>;
        <D.27395>:
        monoeg_g_log (0B, 16, "Bad call to mono_mutex_lock result %d", ret);
        <D.27396>:
        D.27397 = ret != 0;
        D.27398 = (long int) D.27397;
        D.27399 = __builtin_expect (D.27398, 0);
        if (D.27399 != 0) goto <D.27400>; else goto <D.27401>;
        <D.27400>:
        monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "aot-runtime.c", 3756, "ret == 0");
        <D.27401>:
      }
      amodule.161 = amodule;
      D.27402 = amodule.161->extra_methods;
      if (D.27402 == 0B) goto <D.27403>; else goto <D.27404>;
      <D.27403>:
      amodule.161 = amodule;
      D.27405 = monoeg_g_hash_table_new (0B, 0B);
      amodule.161->extra_methods = D.27405;
      <D.27404>:
      method_index.174 = (void *) method_index;
      amodule.161 = amodule;
      D.27402 = amodule.161->extra_methods;
      monoeg_g_hash_table_insert_replace (D.27402, method_index.174, method, 0);
      {
        int ret;

        ret = pthread_mutex_unlock (&aot_mutex.mutex);
        if (ret != 0) goto <D.27407>; else goto <D.27408>;
        <D.27407>:
        monoeg_g_log (0B, 16, "Bad call to mono_mutex_unlock result %d", ret);
        <D.27408>:
        D.27409 = ret != 0;
        D.27410 = (long int) D.27409;
        D.27411 = __builtin_expect (D.27410, 0);
        if (D.27411 != 0) goto <D.27412>; else goto <D.27413>;
        <D.27412>:
        monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "aot-runtime.c", 3760, "ret == 0");
        <D.27413>:
      }
      goto <D.26849>;
      <D.26848>:
      D.26845 = method->token;
      D.26846 = D.26845 & 16777215;
      method_index = D.26846 + 4294967295;
      <D.26849>:
      <D.26839>:
      method_index.175 = (int) method_index;
      D.26845 = method->token;
      D.26801 = klass->image;
      amodule.161 = amodule;
      D.26806 = load_method (domain, amodule.161, D.26801, method, D.26845, method_index.175);
      return D.26806;
    }
  finally
    {
      amodule = {CLOBBER};
    }
}


find_extra_method (struct MonoMethod * method, struct MonoAotModule * * out_amodule)
{
  struct MonoClass * D.27421;
  struct MonoImage * D.27422;
  void * D.27423;
  guint32 D.27426;
  _Bool D.27429;
  long int D.27430;
  long int D.27431;
  struct GHashTable * aot_modules.176;
  _Bool D.27437;
  long int D.27438;
  long int D.27439;
  void * * D.27442;
  unsigned int i.177;
  unsigned int D.27444;
  void * * D.27445;
  unsigned int i.178;
  unsigned int D.27451;
  guint32 index;
  struct GPtrArray * modules;
  int i;

  D.27421 = method->klass;
  D.27422 = D.27421->image;
  D.27423 = D.27422->aot_module;
  *out_amodule = D.27423;
  D.27421 = method->klass;
  D.27422 = D.27421->image;
  D.27423 = D.27422->aot_module;
  index = find_extra_method_in_amodule (D.27423, method);
  if (index != 16777215) goto <D.27424>; else goto <D.27425>;
  <D.27424>:
  D.27426 = index;
  return D.27426;
  <D.27425>:
  modules = monoeg_g_ptr_array_new ();
  {
    int ret;

    ret = pthread_mutex_lock (&aot_mutex.mutex);
    if (ret != 0) goto <D.27427>; else goto <D.27428>;
    <D.27427>:
    monoeg_g_log (0B, 16, "Bad call to mono_mutex_lock result %d", ret);
    <D.27428>:
    D.27429 = ret != 0;
    D.27430 = (long int) D.27429;
    D.27431 = __builtin_expect (D.27430, 0);
    if (D.27431 != 0) goto <D.27432>; else goto <D.27433>;
    <D.27432>:
    monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "aot-runtime.c", 3559, "ret == 0");
    <D.27433>:
  }
  aot_modules.176 = aot_modules;
  monoeg_g_hash_table_foreach (aot_modules.176, add_module_cb, modules);
  {
    int ret;

    ret = pthread_mutex_unlock (&aot_mutex.mutex);
    if (ret != 0) goto <D.27435>; else goto <D.27436>;
    <D.27435>:
    monoeg_g_log (0B, 16, "Bad call to mono_mutex_unlock result %d", ret);
    <D.27436>:
    D.27437 = ret != 0;
    D.27438 = (long int) D.27437;
    D.27439 = __builtin_expect (D.27438, 0);
    if (D.27439 != 0) goto <D.27440>; else goto <D.27441>;
    <D.27440>:
    monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "aot-runtime.c", 3561, "ret == 0");
    <D.27441>:
  }
  index = 16777215;
  i = 0;
  goto <D.24023>;
  <D.24022>:
  {
    struct MonoAotModule * amodule;

    D.27442 = modules->pdata;
    i.177 = (unsigned int) i;
    D.27444 = i.177 * 4;
    D.27445 = D.27442 + D.27444;
    amodule = *D.27445;
    D.27421 = method->klass;
    D.27422 = D.27421->image;
    D.27423 = D.27422->aot_module;
    if (D.27423 != amodule) goto <D.27446>; else goto <D.27447>;
    <D.27446>:
    index = find_extra_method_in_amodule (amodule, method);
    <D.27447>:
    if (index != 16777215) goto <D.27448>; else goto <D.27449>;
    <D.27448>:
    *out_amodule = amodule;
    goto <D.24021>;
    <D.27449>:
  }
  i = i + 1;
  <D.24023>:
  i.178 = (unsigned int) i;
  D.27451 = modules->len;
  if (i.178 < D.27451) goto <D.24022>; else goto <D.24021>;
  <D.24021>:
  monoeg_g_ptr_array_free (modules, 1);
  D.27426 = index;
  return D.27426;
}


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.27456;
  guint32 D.27457;
  guint32 * D.27458;
  unsigned int D.27459;
  unsigned int D.27460;
  unsigned int D.27461;
  unsigned int D.27462;
  sizetype D.27465;
  sizetype D.27466;
  guint32 * D.27467;
  guint8 * D.27468;
  guint8 * p.179;
  _Bool D.27472;
  long int D.27473;
  long int D.27474;
  struct GHashTable * D.27477;
  struct GHashTable * D.27480;
  guint8 * p.180;
  _Bool D.27484;
  long int D.27485;
  long int D.27486;
  _Bool D.27495;
  long int D.27496;
  long int D.27497;
  _Bool D.27502;
  long int D.27503;
  long int D.27504;
  unsigned char D.27511;
  unsigned char D.27512;
  unsigned char D.27517;
  unsigned char D.27518;
  struct MonoMethod * D.27521;
  unsigned int n_extra_decodes.181;
  unsigned int n_extra_decodes.182;
  unsigned int D.27529;
  unsigned int D.27530;
  guint32 table_size;
  guint32 entry_size;
  guint32 hash;
  guint32 * table;
  guint32 * entry;
  guint32 index;
  static guint32 n_extra_decodes;

  if (amodule == 0B) goto <D.27453>; else goto <D.27455>;
  <D.27455>:
  D.27456 = amodule->out_of_date;
  if (D.27456 != 0) goto <D.27453>; else goto <D.27454>;
  <D.27453>:
  D.27457 = 16777215;
  return D.27457;
  <D.27454>:
  D.27458 = amodule->extra_method_table;
  table_size = *D.27458;
  D.27458 = amodule->extra_method_table;
  table = D.27458 + 4;
  entry_size = 3;
  D.27459 = mono_aot_method_hash (method);
  hash = D.27459 % table_size;
  D.27460 = hash * entry_size;
  D.27461 = D.27460 * 4;
  entry = table + D.27461;
  D.27462 = *entry;
  if (D.27462 == 0) goto <D.27463>; else goto <D.27464>;
  <D.27463>:
  D.27457 = 16777215;
  return D.27457;
  <D.27464>:
  index = 16777215;
  <D.24005>:
  {
    guint32 key;
    guint32 value;
    guint32 next;
    struct MonoMethod * m;
    guint8 * p;
    guint8 * orig_p;

    try
      {
        key = *entry;
        value = MEM[(guint32 *)entry + 4B];
        D.27465 = entry_size + 1073741823;
        D.27466 = D.27465 * 4;
        D.27467 = entry + D.27466;
        next = *D.27467;
        D.27468 = amodule->blob;
        p.179 = D.27468 + key;
        p = p.179;
        orig_p = p;
        {
          int ret;

          ret = pthread_mutex_lock (&aot_mutex.mutex);
          if (ret != 0) goto <D.27470>; else goto <D.27471>;
          <D.27470>:
          monoeg_g_log (0B, 16, "Bad call to mono_mutex_lock result %d", ret);
          <D.27471>:
          D.27472 = ret != 0;
          D.27473 = (long int) D.27472;
          D.27474 = __builtin_expect (D.27473, 0);
          if (D.27474 != 0) goto <D.27475>; else goto <D.27476>;
          <D.27475>:
          monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "aot-runtime.c", 3479, "ret == 0");
          <D.27476>:
        }
        D.27477 = amodule->method_ref_to_method;
        if (D.27477 == 0B) goto <D.27478>; else goto <D.27479>;
        <D.27478>:
        D.27480 = monoeg_g_hash_table_new (0B, 0B);
        amodule->method_ref_to_method = D.27480;
        <D.27479>:
        p.180 = p;
        D.27477 = amodule->method_ref_to_method;
        m = monoeg_g_hash_table_lookup (D.27477, p.180);
        {
          int ret;

          ret = pthread_mutex_unlock (&aot_mutex.mutex);
          if (ret != 0) goto <D.27482>; else goto <D.27483>;
          <D.27482>:
          monoeg_g_log (0B, 16, "Bad call to mono_mutex_unlock result %d", ret);
          <D.27483>:
          D.27484 = ret != 0;
          D.27485 = (long int) D.27484;
          D.27486 = __builtin_expect (D.27485, 0);
          if (D.27486 != 0) goto <D.27487>; else goto <D.27488>;
          <D.27487>:
          monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "aot-runtime.c", 3483, "ret == 0");
          <D.27488>:
        }
        if (m == 0B) goto <D.27489>; else goto <D.27490>;
        <D.27489>:
        p.180 = p;
        m = decode_resolve_method_ref_with_target (amodule, method, p.180, &p);
        if (m != 0B) goto <D.27491>; else goto <D.27492>;
        <D.27491>:
        {
          int ret;

          ret = pthread_mutex_lock (&aot_mutex.mutex);
          if (ret != 0) goto <D.27493>; else goto <D.27494>;
          <D.27493>:
          monoeg_g_log (0B, 16, "Bad call to mono_mutex_lock result %d", ret);
          <D.27494>:
          D.27495 = ret != 0;
          D.27496 = (long int) D.27495;
          D.27497 = __builtin_expect (D.27496, 0);
          if (D.27497 != 0) goto <D.27498>; else goto <D.27499>;
          <D.27498>:
          monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "aot-runtime.c", 3487, "ret == 0");
          <D.27499>:
        }
        D.27477 = amodule->method_ref_to_method;
        monoeg_g_hash_table_insert_replace (D.27477, orig_p, m, 0);
        {
          int ret;

          ret = pthread_mutex_unlock (&aot_mutex.mutex);
          if (ret != 0) goto <D.27500>; else goto <D.27501>;
          <D.27500>:
          monoeg_g_log (0B, 16, "Bad call to mono_mutex_unlock result %d", ret);
          <D.27501>:
          D.27502 = ret != 0;
          D.27503 = (long int) D.27502;
          D.27504 = __builtin_expect (D.27503, 0);
          if (D.27504 != 0) goto <D.27505>; else goto <D.27506>;
          <D.27505>:
          monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "aot-runtime.c", 3489, "ret == 0");
          <D.27506>:
        }
        <D.27492>:
        <D.27490>:
        if (m == method) goto <D.27507>; else goto <D.27508>;
        <D.27507>:
        index = value;
        goto <D.24002>;
        <D.27508>:
        if (m != 0B) goto <D.27509>; else goto <D.27510>;
        <D.27509>:
        D.27511 = BIT_FIELD_REF <*method, 8, 160>;
        D.27512 = D.27511 & 124;
        if (D.27512 != 0) goto <D.27513>; else goto <D.27514>;
        <D.27513>:
        D.27511 = BIT_FIELD_REF <*method, 8, 160>;
        D.27512 = D.27511 & 124;
        if (D.27512 == 64) goto <D.27515>; else goto <D.27516>;
        <D.27515>:
        {
          struct MonoMethod * w1;
          struct MonoMethod * w2;

          w1 = mono_marshal_method_from_wrapper (method);
          w2 = mono_marshal_method_from_wrapper (m);
          D.27517 = BIT_FIELD_REF <*w1, 8, 168>;
          D.27518 = D.27517 & 16;
          if (D.27518 != 0) goto <D.27519>; else goto <D.27520>;
          <D.27519>:
          D.27521 = MEM[(struct MonoMethodInflated *)w1].declaring;
          if (D.27521 == w2) goto <D.27522>; else goto <D.27523>;
          <D.27522>:
          index = value;
          goto <D.24002>;
          <D.27523>:
          <D.27520>:
        }
        <D.27516>:
        <D.27514>:
        <D.27510>:
        if (m != 0B) goto <D.27524>; else goto <D.27525>;
        <D.27524>:
        n_extra_decodes.181 = n_extra_decodes;
        n_extra_decodes.182 = n_extra_decodes.181 + 1;
        n_extra_decodes = n_extra_decodes.182;
        <D.27525>:
        if (next != 0) goto <D.27528>; else goto <D.24002>;
        <D.27528>:
        D.27529 = next * entry_size;
        D.27530 = D.27529 * 4;
        entry = table + D.27530;
      }
    finally
      {
        p = {CLOBBER};
      }
  }
  goto <D.24005>;
  <D.24002>:
  D.27457 = index;
  return D.27457;
}


load_method (struct MonoDomain * domain, struct MonoAotModule * amodule, struct MonoImage * image, struct MonoMethod * method, guint32 token, int method_index)
{
  _Bool D.27534;
  <unnamed type> D.27535;
  unsigned int D.27536;
  void * D.27539;
  struct MonoDomain * D.27540;
  unsigned int D.27543;
  unsigned int D.27544;
  int D.27547;
  gint32 * D.27550;
  unsigned int method_index.183;
  unsigned int D.27552;
  gint32 * D.27553;
  int D.27554;
  int D.27557;
  guint8 * D.27562;
  sizetype D.27563;
  guint8 * D.27564;
  guint32 * D.27565;
  unsigned int D.27566;
  guint8 * D.27567;
  unsigned int D.27572;
  unsigned int D.27573;
  int D.27576;
  _Bool D.27577;
  long int D.27578;
  long int D.27579;
  sizetype D.27582;
  _Bool D.27585;
  long int D.27586;
  long int D.27587;
  guint32 * D.27590;
  unsigned int D.27593;
  unsigned int D.27594;
  unsigned int D.27595;
  unsigned int D.27596;
  void * D.27597;
  _Bool D.27600;
  long int D.27601;
  long int D.27602;
  int D.27605;
  unsigned int D.27606;
  unsigned int D.27607;
  guint32 * D.27608;
  unsigned int D.27609;
  int D.27610;
  unsigned int D.27611;
  unsigned int D.27612;
  int mono_last_aot_method.184;
  int D.27618;
  int D.27621;
  guint8 * p.185;
  int D.27636;
  unsigned int D.27637;
  struct MonoDomain * D.27638;
  unsigned int pindex.186;
  unsigned int D.27648;
  void * * D.27649;
  guint32 * got_slots.187;
  unsigned int D.27651;
  guint32 * D.27652;
  unsigned int D.27653;
  unsigned int D.27654;
  void * * D.27655;
  void * D.27656;
  void * D.27659;
  <unnamed type> D.27660;
  void * D.27663;
  struct MonoMethod * D.27666;
  struct MonoDebugOptions * D.27669;
  int D.27670;
  struct MonoAssembly * D.27673;
  struct MonoImage * D.27674;
  int D.27675;
  int D.27682;
  sizetype D.27683;
  guint8 * D.27684;
  _Bool D.27687;
  long int D.27688;
  long int D.27689;
  int D.27692;
  unsigned int D.27693;
  unsigned int D.27694;
  guint32 * D.27695;
  unsigned int D.27696;
  int D.27697;
  unsigned int D.27698;
  unsigned int D.27699;
  unsigned char D.27702;
  unsigned char D.27703;
  struct GHashTable * D.27706;
  _Bool D.27709;
  long int D.27710;
  long int D.27711;
  <unnamed type> D.27714;
  unsigned int D.27715;
  long int D.27720;
  long int D.27721;
  _Bool D.27724;
  long int D.27725;
  long int D.27726;
  _Bool D.27729;
  _Bool D.27730;
  _Bool D.27731;
  struct MonoGenericContainer * D.27734;
  struct MonoVTable * D.27737;
  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.27534 = method == 0B;
      from_plt = (gboolean) D.27534;
      keep_patches = 1;
      jinfo = 0B;
      D.27535 = mono_profiler_get_events ();
      D.27536 = D.27535 & 4096;
      if (D.27536 != 0) goto <D.27537>; else goto <D.27538>;
      <D.27537>:
      D.27539 = 0B;
      return D.27539;
      <D.27538>:
      D.27540 = mono_get_root_domain ();
      if (D.27540 != domain) goto <D.27541>; else goto <D.27542>;
      <D.27541>:
      D.27543 = amodule->info.opts;
      D.27544 = D.27543 & 512;
      if (D.27544 == 0) goto <D.27545>; else goto <D.27546>;
      <D.27545>:
      D.27539 = 0B;
      return D.27539;
      <D.27546>:
      <D.27542>:
      D.27547 = amodule->out_of_date;
      if (D.27547 != 0) goto <D.27548>; else goto <D.27549>;
      <D.27548>:
      D.27539 = 0B;
      return D.27539;
      <D.27549>:
      D.27550 = amodule->code_offsets;
      method_index.183 = (unsigned int) method_index;
      D.27552 = method_index.183 * 4;
      D.27553 = D.27550 + D.27552;
      D.27554 = *D.27553;
      if (D.27554 == -1) goto <D.27555>; else goto <D.27556>;
      <D.27555>:
      D.27557 = mono_trace_is_traced (128, 32);
      if (D.27557 != 0) goto <D.27558>; else goto <D.27559>;
      <D.27558>:
      {
        char * full_name;

        if (method == 0B) goto <D.27560>; else goto <D.27561>;
        <D.27560>:
        method = mono_get_method (image, token, 0B);
        <D.27561>:
        full_name = mono_method_full_name (method, 1);
        mono_trace (128, 32, "AOT NOT FOUND: %s.", full_name);
        monoeg_g_free (full_name);
      }
      <D.27559>:
      D.27539 = 0B;
      return D.27539;
      <D.27556>:
      D.27562 = amodule->code;
      D.27550 = amodule->code_offsets;
      method_index.183 = (unsigned int) method_index;
      D.27552 = method_index.183 * 4;
      D.27553 = D.27550 + D.27552;
      D.27554 = *D.27553;
      D.27563 = (sizetype) D.27554;
      code = D.27562 + D.27563;
      D.27564 = amodule->blob;
      D.27565 = amodule->method_info_offsets;
      D.27566 = mono_aot_get_offset (D.27565, method_index);
      info = D.27564 + D.27566;
      D.27567 = amodule->thumb_end;
      if (D.27567 != 0B) goto <D.27568>; else goto <D.27569>;
      <D.27568>:
      D.27567 = amodule->thumb_end;
      if (D.27567 > code) goto <D.27570>; else goto <D.27571>;
      <D.27570>:
      D.27572 = amodule->info.flags;
      D.27573 = D.27572 & 8;
      if (D.27573 == 0) goto <D.27574>; else goto <D.27575>;
      <D.27574>:
      D.27550 = amodule->code_offsets;
      method_index.183 = (unsigned int) method_index;
      D.27552 = method_index.183 * 4;
      D.27553 = D.27550 + D.27552;
      D.27554 = *D.27553;
      D.27576 = D.27554 & 1;
      D.27577 = D.27576 != 0;
      D.27578 = (long int) D.27577;
      D.27579 = __builtin_expect (D.27578, 0);
      if (D.27579 != 0) goto <D.27580>; else goto <D.27581>;
      <D.27580>:
      monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "aot-runtime.c", 3299, "(amodule->code_offsets [method_index] & 0x1) == 0");
      <D.27581>:
      D.27562 = amodule->code;
      D.27550 = amodule->code_offsets;
      method_index.183 = (unsigned int) method_index;
      D.27552 = method_index.183 * 4;
      D.27553 = D.27550 + D.27552;
      D.27554 = *D.27553;
      D.27563 = (sizetype) D.27554;
      D.27582 = D.27563 + 1;
      code = D.27562 + D.27582;
      <D.27575>:
      <D.27571>:
      <D.27569>:
      {
        int ret;

        ret = pthread_mutex_lock (&aot_mutex.mutex);
        if (ret != 0) goto <D.27583>; else goto <D.27584>;
        <D.27583>:
        monoeg_g_log (0B, 16, "Bad call to mono_mutex_lock result %d", ret);
        <D.27584>:
        D.27585 = ret != 0;
        D.27586 = (long int) D.27585;
        D.27587 = __builtin_expect (D.27586, 0);
        if (D.27587 != 0) goto <D.27588>; else goto <D.27589>;
        <D.27588>:
        monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "aot-runtime.c", 3303, "ret == 0");
        <D.27589>:
      }
      D.27590 = amodule->methods_loaded;
      if (D.27590 == 0B) goto <D.27591>; else goto <D.27592>;
      <D.27591>:
      D.27593 = amodule->info.nmethods;
      D.27594 = D.27593 / 32;
      D.27595 = D.27594 + 1;
      D.27596 = D.27595 * 4;
      D.27597 = monoeg_malloc0 (D.27596);
      amodule->methods_loaded = D.27597;
      <D.27592>:
      {
        int ret;

        ret = pthread_mutex_unlock (&aot_mutex.mutex);
        if (ret != 0) goto <D.27598>; else goto <D.27599>;
        <D.27598>:
        monoeg_g_log (0B, 16, "Bad call to mono_mutex_unlock result %d", ret);
        <D.27599>:
        D.27600 = ret != 0;
        D.27601 = (long int) D.27600;
        D.27602 = __builtin_expect (D.27601, 0);
        if (D.27602 != 0) goto <D.27603>; else goto <D.27604>;
        <D.27603>:
        monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "aot-runtime.c", 3306, "ret == 0");
        <D.27604>:
      }
      D.27590 = amodule->methods_loaded;
      D.27605 = method_index / 32;
      D.27606 = (unsigned int) D.27605;
      D.27607 = D.27606 * 4;
      D.27608 = D.27590 + D.27607;
      D.27609 = *D.27608;
      D.27610 = method_index % 32;
      D.27611 = D.27609 >> D.27610;
      D.27612 = D.27611 & 1;
      if (D.27612 != 0) goto <D.27613>; else goto <D.27614>;
      <D.27613>:
      D.27539 = code;
      return D.27539;
      <D.27614>:
      mono_last_aot_method.184 = mono_last_aot_method;
      if (mono_last_aot_method.184 != -1) goto <D.27616>; else goto <D.27617>;
      <D.27616>:
      D.27618 = mono_jit_stats.methods_aot;
      mono_last_aot_method.184 = mono_last_aot_method;
      if (D.27618 >= mono_last_aot_method.184) goto <D.27619>; else goto <D.27620>;
      <D.27619>:
      D.27539 = 0B;
      return D.27539;
      <D.27620>:
      D.27618 = mono_jit_stats.methods_aot;
      mono_last_aot_method.184 = mono_last_aot_method;
      D.27621 = mono_last_aot_method.184 + -1;
      if (D.27618 == D.27621) goto <D.27622>; else goto <D.27623>;
      <D.27622>:
      if (method == 0B) goto <D.27624>; else goto <D.27625>;
      <D.27624>:
      method = mono_get_method (image, token, 0B);
      <D.27625>:
      if (method != 0B) goto <D.27626>; else goto <D.27627>;
      <D.27626>:
      {
        char * name;

        name = mono_method_full_name (method, 1);
        printf ("LAST AOT METHOD: %s.\n", name);
        monoeg_g_free (name);
      }
      goto <D.27628>;
      <D.27627>:
      printf ("LAST AOT METHOD: %p %d\n", code, method_index);
      <D.27628>:
      <D.27623>:
      <D.27617>:
      p = info;
      if (method != 0B) goto <D.27629>; else goto <D.27630>;
      <D.27629>:
      klass = method->klass;
      p.185 = p;
      decode_klass_ref (amodule, p.185, &p);
      goto <D.27632>;
      <D.27630>:
      p.185 = p;
      klass = decode_klass_ref (amodule, p.185, &p);
      <D.27632>:
      D.27543 = amodule->info.opts;
      D.27544 = D.27543 & 512;
      if (D.27544 != 0) goto <D.27633>; else goto <D.27634>;
      <D.27633>:
      p.185 = p;
      used_strings = decode_value (p.185, &p);
      goto <D.27635>;
      <D.27634>:
      used_strings = 0;
      <D.27635>:
      i = 0;
      goto <D.23968>;
      <D.23967>:
      {
        guint token;

        p.185 = p;
        D.27636 = decode_value (p.185, &p);
        token = (guint) D.27636;
        D.27637 = token & 16777215;
        D.27638 = mono_get_root_domain ();
        mono_ldstr (D.27638, image, D.27637);
      }
      i = i + 1;
      <D.23968>:
      if (i < used_strings) goto <D.23967>; else goto <D.23969>;
      <D.23969>:
      D.27543 = amodule->info.opts;
      D.27544 = D.27543 & 512;
      if (D.27544 != 0) goto <D.27639>; else goto <D.27640>;
      <D.27639>:
      keep_patches = 0;
      <D.27640>:
      p.185 = p;
      n_patches = decode_value (p.185, &p);
      keep_patches = 0;
      if (n_patches != 0) goto <D.27641>; else goto <D.27642>;
      <D.27641>:
      {
        struct MonoJumpInfo * patches;
        guint32 * got_slots;

        try
          {
            if (keep_patches != 0) goto <D.27643>; else goto <D.27644>;
            <D.27643>:
            mp = domain->mp;
            goto <D.27645>;
            <D.27644>:
            mp = mono_mempool_new ();
            <D.27645>:
            p.185 = p;
            patches = load_patch_info (amodule, mp, n_patches, &got_slots, p.185, &p);
            if (patches == 0B) goto cleanup; else goto <D.27646>;
            <D.27646>:
            pindex = 0;
            goto <D.23975>;
            <D.23974>:
            {
              struct MonoJumpInfo * ji;

              pindex.186 = (unsigned int) pindex;
              D.27648 = pindex.186 * 20;
              ji = patches + D.27648;
              D.27649 = amodule->got;
              got_slots.187 = got_slots;
              pindex.186 = (unsigned int) pindex;
              D.27651 = pindex.186 * 4;
              D.27652 = got_slots.187 + D.27651;
              D.27653 = *D.27652;
              D.27654 = D.27653 * 4;
              D.27655 = D.27649 + D.27654;
              D.27656 = *D.27655;
              if (D.27656 == 0B) goto <D.27657>; else goto <D.27658>;
              <D.27657>:
              D.27649 = amodule->got;
              got_slots.187 = got_slots;
              pindex.186 = (unsigned int) pindex;
              D.27651 = pindex.186 * 4;
              D.27652 = got_slots.187 + D.27651;
              D.27653 = *D.27652;
              D.27654 = D.27653 * 4;
              D.27655 = D.27649 + D.27654;
              D.27659 = mono_resolve_patch_target (method, domain, code, ji, 1);
              *D.27655 = D.27659;
              D.27660 = ji->type;
              if (D.27660 == 4) goto <D.27661>; else goto <D.27662>;
              <D.27661>:
              D.27649 = amodule->got;
              got_slots.187 = got_slots;
              pindex.186 = (unsigned int) pindex;
              D.27651 = pindex.186 * 4;
              D.27652 = got_slots.187 + D.27651;
              D.27653 = *D.27652;
              D.27654 = D.27653 * 4;
              D.27655 = D.27649 + D.27654;
              D.27649 = amodule->got;
              got_slots.187 = got_slots;
              pindex.186 = (unsigned int) pindex;
              D.27651 = pindex.186 * 4;
              D.27652 = got_slots.187 + D.27651;
              D.27653 = *D.27652;
              D.27654 = D.27653 * 4;
              D.27655 = D.27649 + D.27654;
              D.27656 = *D.27655;
              D.27663 = mono_create_ftnptr (domain, D.27656);
              *D.27655 = D.27663;
              <D.27662>:
              D.27660 = ji->type;
              if (D.27660 == 4) goto <D.27664>; else goto <D.27665>;
              <D.27664>:
              D.27649 = amodule->got;
              got_slots.187 = got_slots;
              pindex.186 = (unsigned int) pindex;
              D.27651 = pindex.186 * 4;
              D.27652 = got_slots.187 + D.27651;
              D.27653 = *D.27652;
              D.27654 = D.27653 * 4;
              D.27655 = D.27649 + D.27654;
              D.27666 = ji->data.method;
              register_jump_target_got_slot (domain, D.27666, D.27655);
              <D.27665>:
              <D.27658>:
              ji->type = 51;
            }
            pindex = pindex + 1;
            <D.23975>:
            if (pindex < n_patches) goto <D.23974>; else goto <D.23976>;
            <D.23976>:
            got_slots.187 = got_slots;
            monoeg_g_free (got_slots.187);
            if (keep_patches == 0) goto <D.27667>; else goto <D.27668>;
            <D.27667>:
            mono_mempool_destroy (mp);
            <D.27668>:
          }
        finally
          {
            got_slots = {CLOBBER};
          }
      }
      <D.27642>:
      D.27669 = mini_get_debug_options ();
      D.27670 = D.27669->load_aot_jit_info_eagerly;
      if (D.27670 != 0) goto <D.27671>; else goto <D.27672>;
      <D.27671>:
      D.27673 = amodule->assembly;
      D.27674 = D.27673->image;
      jinfo = mono_aot_find_jit_info (domain, D.27674, code);
      <D.27672>:
      D.27675 = mono_trace_is_traced (128, 32);
      if (D.27675 != 0) goto <D.27676>; else goto <D.27677>;
      <D.27676>:
      {
        char * full_name;

        if (method == 0B) goto <D.27678>; else goto <D.27679>;
        <D.27678>:
        method = mono_get_method (image, token, 0B);
        <D.27679>:
        full_name = mono_method_full_name (method, 1);
        if (jinfo == 0B) goto <D.27680>; else goto <D.27681>;
        <D.27680>:
        D.27673 = amodule->assembly;
        D.27674 = D.27673->image;
        jinfo = mono_aot_find_jit_info (domain, D.27674, code);
        <D.27681>:
        D.27682 = jinfo->code_size;
        D.27683 = (sizetype) D.27682;
        D.27684 = code + D.27683;
        mono_trace (128, 32, "AOT FOUND method %s [%p - %p %p]", full_name, code, D.27684, info);
        monoeg_g_free (full_name);
      }
      <D.27677>:
      {
        int ret;

        ret = pthread_mutex_lock (&aot_mutex.mutex);
        if (ret != 0) goto <D.27685>; else goto <D.27686>;
        <D.27685>:
        monoeg_g_log (0B, 16, "Bad call to mono_mutex_lock result %d", ret);
        <D.27686>:
        D.27687 = ret != 0;
        D.27688 = (long int) D.27687;
        D.27689 = __builtin_expect (D.27688, 0);
        if (D.27689 != 0) goto <D.27690>; else goto <D.27691>;
        <D.27690>:
        monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "aot-runtime.c", 3403, "ret == 0");
        <D.27691>:
      }
      InterlockedIncrement (&mono_jit_stats.methods_aot);
      D.27590 = amodule->methods_loaded;
      D.27692 = method_index / 32;
      D.27693 = (unsigned int) D.27692;
      D.27694 = D.27693 * 4;
      D.27695 = D.27590 + D.27694;
      D.27590 = amodule->methods_loaded;
      D.27693 = (unsigned int) D.27692;
      D.27694 = D.27693 * 4;
      D.27695 = D.27590 + D.27694;
      D.27696 = *D.27695;
      D.27610 = method_index % 32;
      D.27697 = 1 << D.27610;
      D.27698 = (unsigned int) D.27697;
      D.27699 = D.27696 | D.27698;
      *D.27695 = D.27699;
      init_plt (amodule);
      if (method != 0B) goto <D.27700>; else goto <D.27701>;
      <D.27700>:
      D.27702 = BIT_FIELD_REF <*method, 8, 160>;
      D.27703 = D.27702 & 124;
      if (D.27703 != 0) goto <D.27704>; else goto <D.27705>;
      <D.27704>:
      D.27706 = amodule->method_to_code;
      monoeg_g_hash_table_insert_replace (D.27706, method, code, 0);
      <D.27705>:
      <D.27701>:
      {
        int ret;

        ret = pthread_mutex_unlock (&aot_mutex.mutex);
        if (ret != 0) goto <D.27707>; else goto <D.27708>;
        <D.27707>:
        monoeg_g_log (0B, 16, "Bad call to mono_mutex_unlock result %d", ret);
        <D.27708>:
        D.27709 = ret != 0;
        D.27710 = (long int) D.27709;
        D.27711 = __builtin_expect (D.27710, 0);
        if (D.27711 != 0) goto <D.27712>; else goto <D.27713>;
        <D.27712>:
        monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "aot-runtime.c", 3414, "ret == 0");
        <D.27713>:
      }
      D.27714 = mono_profiler_get_events ();
      D.27715 = D.27714 & 16;
      if (D.27715 != 0) goto <D.27716>; else goto <D.27717>;
      <D.27716>:
      {
        struct MonoJitInfo * jinfo;

        if (method == 0B) goto <D.27718>; else goto <D.27719>;
        <D.27718>:
        method = mono_get_method (image, token, 0B);
        D.27534 = method == 0B;
        D.27720 = (long int) D.27534;
        D.27721 = __builtin_expect (D.27720, 0);
        if (D.27721 != 0) goto <D.27722>; else goto <D.27723>;
        <D.27722>:
        monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "aot-runtime.c", 3421, "method");
        <D.27723>:
        <D.27719>:
        mono_profiler_method_jit (method);
        jinfo = mono_jit_info_table_find (domain, code);
        D.27724 = jinfo == 0B;
        D.27725 = (long int) D.27724;
        D.27726 = __builtin_expect (D.27725, 0);
        if (D.27726 != 0) goto <D.27727>; else goto <D.27728>;
        <D.27727>:
        monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "aot-runtime.c", 3425, "jinfo");
        <D.27728>:
        mono_profiler_method_end_jit (method, jinfo, 0);
      }
      <D.27717>:
      D.27729 = from_plt != 0;
      D.27730 = klass != 0B;
      D.27731 = D.27729 & D.27730;
      if (D.27731 != 0) goto <D.27732>; else goto <D.27733>;
      <D.27732>:
      D.27734 = klass->generic_container;
      if (D.27734 == 0B) goto <D.27735>; else goto <D.27736>;
      <D.27735>:
      D.27737 = mono_class_vtable (domain, klass);
      mono_runtime_class_init (D.27737);
      <D.27736>:
      <D.27733>:
      D.27539 = code;
      return D.27539;
      cleanup:
      D.27543 = amodule->info.opts;
      D.27544 = D.27543 & 512;
      if (D.27544 != 0) goto <D.27738>; else goto <D.27739>;
      <D.27738>:
      mono_mempool_destroy (mp);
      <D.27739>:
      if (jinfo != 0B) goto <D.27740>; else goto <D.27741>;
      <D.27740>:
      monoeg_g_free (jinfo);
      <D.27741>:
      D.27539 = 0B;
      return D.27539;
    }
  finally
    {
      p = {CLOBBER};
    }
}


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

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


load_patch_info (struct MonoAotModule * aot_module, struct MonoMemPool * mp, int n_patches, guint32 * * got_slots, guint8 * buf, guint8 * * endbuf)
{
  unsigned int n_patches.188;
  unsigned int D.27749;
  unsigned int D.27750;
  void * D.27751;
  unsigned int pindex.189;
  unsigned int D.27753;
  guint8 * p.190;
  int D.27755;
  void * * D.27756;
  unsigned int D.27757;
  void * * D.27758;
  void * D.27759;
  guint8 * D.27763;
  int got_offset.191;
  guint32 * D.27765;
  unsigned int D.27766;
  guint8 * shared_p.192;
  guint8 * shared_p.193;
  int D.27769;
  <unnamed type> D.27770;
  guint32 * D.27772;
  unsigned int D.27773;
  guint32 * D.27774;
  struct MonoJumpInfo * D.27775;
  struct MonoJumpInfo * patches;
  int pindex;
  guint8 * p;
  void cleanup = <<< error >>>;

  try
    {
      p = buf;
      n_patches.188 = (unsigned int) n_patches;
      D.27749 = n_patches.188 * 20;
      patches = mono_mempool_alloc0 (mp, D.27749);
      n_patches.188 = (unsigned int) n_patches;
      D.27750 = n_patches.188 * 4;
      D.27751 = monoeg_malloc (D.27750);
      *got_slots = D.27751;
      pindex = 0;
      goto <D.23931>;
      <D.23930>:
      {
        struct MonoJumpInfo * ji;
        guint8 * shared_p;
        gboolean res;
        guint32 got_offset;

        try
          {
            pindex.189 = (unsigned int) pindex;
            D.27753 = pindex.189 * 20;
            ji = patches + D.27753;
            p.190 = p;
            D.27755 = decode_value (p.190, &p);
            got_offset = (guint32) D.27755;
            D.27756 = aot_module->got;
            D.27757 = got_offset * 4;
            D.27758 = D.27756 + D.27757;
            D.27759 = *D.27758;
            if (D.27759 != 0B) goto <D.27760>; else goto <D.27761>;
            <D.27760>:
            goto <D.27762>;
            <D.27761>:
            D.27763 = aot_module->blob;
            got_offset.191 = (int) got_offset;
            D.27765 = aot_module->got_info_offsets;
            D.27766 = mono_aot_get_offset (D.27765, got_offset.191);
            shared_p.192 = D.27763 + D.27766;
            shared_p = shared_p.192;
            shared_p.193 = shared_p;
            D.27769 = decode_value (shared_p.193, &shared_p);
            D.27770 = (<unnamed type>) D.27769;
            ji->type = D.27770;
            shared_p.193 = shared_p;
            res = decode_patch (aot_module, mp, ji, shared_p.193, &shared_p);
            if (res == 0) goto cleanup; else goto <D.27771>;
            <D.27771>:
            <D.27762>:
            D.27772 = *got_slots;
            pindex.189 = (unsigned int) pindex;
            D.27773 = pindex.189 * 4;
            D.27774 = D.27772 + D.27773;
            *D.27774 = got_offset;
          }
        finally
          {
            shared_p = {CLOBBER};
          }
      }
      pindex = pindex + 1;
      <D.23931>:
      if (pindex < n_patches) goto <D.23930>; else goto <D.23932>;
      <D.23932>:
      p.190 = p;
      *endbuf = p.190;
      D.27775 = patches;
      return D.27775;
      cleanup:
      D.27772 = *got_slots;
      monoeg_g_free (D.27772);
      *got_slots = 0B;
      D.27775 = 0B;
      return D.27775;
    }
  finally
    {
      p = {CLOBBER};
    }
}


decode_patch (struct MonoAotModule * aot_module, struct MonoMemPool * mp, struct MonoJumpInfo * ji, guint8 * buf, guint8 * * endbuf)
{
  <unnamed type> D.27780;
  guint8 * p.194;
  struct MonoMethod * D.27785;
  int mono_aot_only.195;
  int D.27789;
  unsigned int D.27792;
  unsigned int D.27793;
  struct MonoImage * D.27795;
  void * D.27796;
  struct MonoDomain * D.27797;
  void * D.27798;
  struct MonoMethod * D.27802;
  struct MonoMethod * D.27803;
  _Bool D.27804;
  long int D.27805;
  long int D.27806;
  struct MonoClass * D.27809;
  int D.27810;
  sizetype D.27811;
  guint8 * p.196;
  struct MonoMethod * D.27813;
  struct MonoClass * D.27815;
  struct MonoClass * D.27816;
  struct MonoClass * D.27818;
  int D.27820;
  struct MonoImage * D.27821;
  struct MonoImage * D.27822;
  struct MonoClassField * D.27824;
  struct MonoClassField * D.27825;
  void * D.27827;
  struct MonoJumpInfoBBTable * D.27828;
  int D.27829;
  int D.27830;
  unsigned int D.27831;
  unsigned int D.27832;
  struct MonoDomain * D.27833;
  unsigned int i.197;
  unsigned int D.27835;
  void * * D.27836;
  int D.27837;
  void * D.27838;
  struct MonoDomain * D.27839;
  void * D.27840;
  int D.27841;
  unsigned int val.198;
  const void * D.27843;
  guint32 * val.199;
  float D.27845;
  struct MonoDomain * D.27846;
  void * D.27847;
  int D.27848;
  unsigned int D.27849;
  int D.27850;
  unsigned int D.27851;
  unsigned int D.27852;
  long long unsigned int D.27853;
  long long unsigned int D.27854;
  unsigned int D.27855;
  long long unsigned int D.27856;
  long long unsigned int v.200;
  guint64 * v.201;
  double D.27859;
  int D.27860;
  int D.27862;
  int D.27863;
  unsigned int D.27864;
  struct MonoJumpInfoToken * D.27865;
  int D.27866;
  int D.27868;
  unsigned int D.27869;
  struct MonoJumpInfoToken * D.27870;
  struct MonoJumpInfoToken * D.27871;
  int D.27872;
  int D.27873;
  struct MonoGenericContext * D.27876;
  struct MonoClass * D.27878;
  const char * D.27880;
  int D.27881;
  int D.27882;
  int D.27883;
  guint8 * D.27884;
  guint8 * p2.202;
  guint8 * p2.203;
  struct MonoMethod * D.27887;
  unsigned int D.27888;
  _Bool D.27889;
  int D.27890;
  unsigned int D.27891;
  unsigned int D.27892;
  void * D.27893;
  struct MonoJumpInfo * D.27894;
  unsigned int D.27895;
  unsigned int D.27896;
  struct MonoMethod * D.27898;
  int D.27899;
  struct MonoMethodSignature * D.27900;
  int D.27901;
  const void * D.27902;
  struct MonoMethodSignature * D.27903;
  struct MonoMethodSignature * D.27904;
  _Bool D.27905;
  long int D.27906;
  long int D.27907;
  struct MonoMethod * D.27910;
  struct MonoMethod * D.27911;
  _Bool D.27912;
  long int D.27913;
  long int D.27914;
  struct MonoMethod * D.27917;
  struct MonoMethod * D.27918;
  _Bool D.27919;
  long int D.27920;
  long int D.27921;
  struct GPtrArray * D.27924;
  int D.27925;
  <unnamed type> D.27926;
  <unnamed type> D.27927;
  <unnamed type> D.27928;
  struct MonoType * D.27930;
  struct MonoClassField * D.27931;
  void * D.27932;
  struct GPtrArray * D.27934;
  gboolean D.27935;
  guint8 * p;
  void * * table;
  struct MonoImage * image;
  int i;
  void cleanup = <<< error >>>;

  try
    {
      p = buf;
      D.27780 = ji->type;
      switch (D.27780) <default: <D.23913>, case 3: <D.23841>, case 4: <D.23842>, case 5: <D.23879>, case 6: <D.23853>, case 7: <D.23850>, case 8: <D.23863>, case 10: <D.23878>, case 11: <D.23855>, case 12: <D.23860>, case 13: <D.23861>, case 14: <D.23854>, case 15: <D.23858>, case 16: <D.23862>, case 17: <D.23872>, case 18: <D.23875>, case 19: <D.23876>, case 20: <D.23867>, case 21: <D.23869>, case 23: <D.23856>, case 24: <D.23857>, case 28: <D.23874>, case 29: <D.23873>, case 30: <D.23859>, case 31: <D.23843>, case 32: <D.23851>, case 33: <D.23880>, case 34: <D.23844>, case 35: <D.23887>, case 36: <D.23881>, case 37: <D.23882>, case 38: <D.23883>, case 40: <D.23893>, case 41: <D.23894>, case 42: <D.23884>, case 43: <D.23885>, case 44: <D.23896>, case 45: <D.23898>, case 46: <D.23900>, case 47: <D.23886>, case 48: <D.23897>, case 50: <D.23845>>
      <D.23841>:
      <D.23842>:
      <D.23843>:
      <D.23844>:
      <D.23845>:
      {
        struct MethodRef ref;
        gboolean res;

        try
          {
            p.194 = p;
            res = decode_method_ref (aot_module, &ref, p.194, &p);
            if (res == 0) goto cleanup; else goto <D.27782>;
            <D.27782>:
            D.27785 = ref.method;
            if (D.27785 == 0B) goto <D.27786>; else goto <D.27783>;
            <D.27786>:
            mono_aot_only.195 = mono_aot_only;
            if (mono_aot_only.195 == 0) goto <D.27788>; else goto <D.27783>;
            <D.27788>:
            D.27789 = ref.no_aot_trampoline;
            if (D.27789 == 0) goto <D.27790>; else goto <D.27783>;
            <D.27790>:
            D.27780 = ji->type;
            if (D.27780 == 3) goto <D.27791>; else goto <D.27783>;
            <D.27791>:
            D.27792 = ref.token;
            D.27793 = D.27792 >> 24;
            if (D.27793 == 6) goto <D.27794>; else goto <D.27783>;
            <D.27794>:
            D.27792 = ref.token;
            D.27795 = ref.image;
            D.27796 = mono_create_jit_trampoline_from_token (D.27795, D.27792);
            D.27797 = mono_domain_get ();
            D.27798 = mono_create_ftnptr (D.27797, D.27796);
            ji->data.target = D.27798;
            ji->type = 1;
            goto <D.27784>;
            <D.27783>:
            D.27785 = ref.method;
            if (D.27785 != 0B) goto <D.27799>; else goto <D.27800>;
            <D.27799>:
            D.27785 = ref.method;
            ji->data.method = D.27785;
            goto <D.27801>;
            <D.27800>:
            D.27792 = ref.token;
            D.27795 = ref.image;
            D.27802 = mono_get_method (D.27795, D.27792, 0B);
            ji->data.method = D.27802;
            <D.27801>:
            D.27803 = ji->data.method;
            D.27804 = D.27803 == 0B;
            D.27805 = (long int) D.27804;
            D.27806 = __builtin_expect (D.27805, 0);
            if (D.27806 != 0) goto <D.27807>; else goto <D.27808>;
            <D.27807>:
            monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "aot-runtime.c", 2969, "ji->data.method");
            <D.27808>:
            D.27803 = ji->data.method;
            D.27809 = D.27803->klass;
            mono_class_init (D.27809);
            <D.27784>:
            goto <D.23849>;
          }
        finally
          {
            ref = {CLOBBER};
          }
      }
      <D.23850>:
      <D.23851>:
      {
        guint32 len;

        p.194 = p;
        D.27810 = decode_value (p.194, &p);
        len = (guint32) D.27810;
        p.194 = p;
        ji->data.name = p.194;
        p.194 = p;
        D.27811 = len + 1;
        p.196 = p.194 + D.27811;
        p = p.196;
        goto <D.23849>;
      }
      <D.23853>:
      p.194 = p;
      D.27813 = decode_resolve_method_ref (aot_module, p.194, &p);
      ji->data.method = D.27813;
      D.27803 = ji->data.method;
      if (D.27803 == 0B) goto cleanup; else goto <D.27814>;
      <D.27814>:
      goto <D.23849>;
      <D.23854>:
      <D.23855>:
      <D.23856>:
      <D.23857>:
      p.194 = p;
      D.27815 = decode_klass_ref (aot_module, p.194, &p);
      ji->data.klass = D.27815;
      D.27816 = ji->data.klass;
      if (D.27816 == 0B) goto cleanup; else goto <D.27817>;
      <D.27817>:
      goto <D.23849>;
      <D.23858>:
      <D.23859>:
      p.194 = p;
      D.27818 = decode_klass_ref (aot_module, p.194, &p);
      ji->data.klass = D.27818;
      D.27816 = ji->data.klass;
      if (D.27816 == 0B) goto cleanup; else goto <D.27819>;
      <D.27819>:
      goto <D.23849>;
      <D.23860>:
      p.194 = p;
      D.27820 = decode_value (p.194, &p);
      D.27821 = load_image (aot_module, D.27820, 1);
      ji->data.image = D.27821;
      D.27822 = ji->data.image;
      if (D.27822 == 0B) goto cleanup; else goto <D.27823>;
      <D.27823>:
      goto <D.23849>;
      <D.23861>:
      <D.23862>:
      p.194 = p;
      D.27824 = decode_field_info (aot_module, p.194, &p);
      ji->data.field = D.27824;
      D.27825 = ji->data.field;
      if (D.27825 == 0B) goto cleanup; else goto <D.27826>;
      <D.27826>:
      goto <D.23849>;
      <D.23863>:
      D.27827 = mono_mempool_alloc0 (mp, 8);
      ji->data.table = D.27827;
      D.27828 = ji->data.table;
      p.194 = p;
      D.27829 = decode_value (p.194, &p);
      D.27828->table_size = D.27829;
      D.27828 = ji->data.table;
      D.27830 = D.27828->table_size;
      D.27831 = (unsigned int) D.27830;
      D.27832 = D.27831 * 4;
      D.27833 = mono_domain_get ();
      table = mono_domain_alloc (D.27833, D.27832);
      D.27828 = ji->data.table;
      D.27828->table = table;
      i = 0;
      goto <D.23865>;
      <D.23864>:
      i.197 = (unsigned int) i;
      D.27835 = i.197 * 4;
      D.27836 = table + D.27835;
      p.194 = p;
      D.27837 = decode_value (p.194, &p);
      D.27838 = (void *) D.27837;
      *D.27836 = D.27838;
      i = i + 1;
      <D.23865>:
      D.27828 = ji->data.table;
      D.27830 = D.27828->table_size;
      if (D.27830 > i) goto <D.23864>; else goto <D.23866>;
      <D.23866>:
      goto <D.23849>;
      <D.23867>:
      {
        guint32 val;

        try
          {
            D.27839 = mono_domain_get ();
            D.27840 = mono_domain_alloc0 (D.27839, 4);
            ji->data.target = D.27840;
            p.194 = p;
            D.27841 = decode_value (p.194, &p);
            val.198 = (unsigned int) D.27841;
            val = val.198;
            D.27843 = ji->data.target;
            val.199 = &val;
            D.27845 = MEM[(float *)val.199];
            MEM[(float *)D.27843] = D.27845;
            goto <D.23849>;
          }
        finally
          {
            val = {CLOBBER};
          }
      }
      <D.23869>:
      {
        guint32 val[2];
        guint64 v;

        try
          {
            D.27846 = mono_domain_get ();
            D.27847 = mono_domain_alloc0 (D.27846, 8);
            ji->data.target = D.27847;
            p.194 = p;
            D.27848 = decode_value (p.194, &p);
            D.27849 = (unsigned int) D.27848;
            val[0] = D.27849;
            p.194 = p;
            D.27850 = decode_value (p.194, &p);
            D.27851 = (unsigned int) D.27850;
            val[1] = D.27851;
            D.27852 = val[1];
            D.27853 = (long long unsigned int) D.27852;
            D.27854 = D.27853 << 32;
            D.27855 = val[0];
            D.27856 = (long long unsigned int) D.27855;
            v.200 = D.27854 | D.27856;
            v = v.200;
            D.27843 = ji->data.target;
            v.201 = &v;
            D.27859 = MEM[(double *)v.201];
            MEM[(double *)D.27843] = D.27859;
            goto <D.23849>;
          }
        finally
          {
            val = {CLOBBER};
            v = {CLOBBER};
          }
      }
      <D.23872>:
      p.194 = p;
      D.27860 = decode_value (p.194, &p);
      image = load_image (aot_module, D.27860, 1);
      if (image == 0B) goto cleanup; else goto <D.27861>;
      <D.27861>:
      p.194 = p;
      D.27862 = decode_value (p.194, &p);
      D.27863 = D.27862 + 1879048192;
      D.27864 = (unsigned int) D.27863;
      D.27865 = mono_jump_info_token_new (mp, image, D.27864);
      ji->data.token = D.27865;
      goto <D.23849>;
      <D.23873>:
      <D.23874>:
      <D.23875>:
      <D.23876>:
      p.194 = p;
      D.27866 = decode_value (p.194, &p);
      image = load_image (aot_module, D.27866, 1);
      if (image == 0B) goto cleanup; else goto <D.27867>;
      <D.27867>:
      p.194 = p;
      D.27868 = decode_value (p.194, &p);
      D.27869 = (unsigned int) D.27868;
      D.27870 = mono_jump_info_token_new (mp, image, D.27869);
      ji->data.token = D.27870;
      D.27871 = ji->data.token;
      p.194 = p;
      D.27872 = decode_value (p.194, &p);
      D.27871->has_context = D.27872;
      D.27871 = ji->data.token;
      D.27873 = D.27871->has_context;
      if (D.27873 != 0) goto <D.27874>; else goto <D.27875>;
      <D.27874>:
      {
        gboolean res;

        p.194 = p;
        D.27871 = ji->data.token;
        D.27876 = &D.27871->context;
        res = decode_generic_context (aot_module, D.27876, p.194, &p);
        if (res == 0) goto cleanup; else goto <D.27877>;
        <D.27877>:
      }
      <D.27875>:
      goto <D.23849>;
      <D.23878>:
      p.194 = p;
      D.27878 = decode_klass_ref (aot_module, p.194, &p);
      ji->data.klass = D.27878;
      D.27816 = ji->data.klass;
      if (D.27816 == 0B) goto cleanup; else goto <D.27879>;
      <D.27879>:
      D.27816 = ji->data.klass;
      D.27880 = D.27816->name;
      ji->data.name = D.27880;
      goto <D.23849>;
      <D.23879>:
      p.194 = p;
      D.27881 = decode_value (p.194, &p);
      ji->data.offset = D.27881;
      goto <D.23849>;
      <D.23880>:
      <D.23881>:
      <D.23882>:
      <D.23883>:
      <D.23884>:
      <D.23885>:
      <D.23886>:
      goto <D.23849>;
      <D.23887>:
      {
        gboolean res;
        struct MonoJumpInfoRgctxEntry * entry;
        guint32 offset;
        guint32 val;
        guint8 * p2;

        try
          {
            p.194 = p;
            D.27882 = decode_value (p.194, &p);
            offset = (guint32) D.27882;
            p.194 = p;
            D.27883 = decode_value (p.194, &p);
            val = (guint32) D.27883;
            entry = mono_mempool_alloc0 (mp, 16);
            D.27884 = aot_module->blob;
            p2.202 = D.27884 + offset;
            p2 = p2.202;
            p2.203 = p2;
            D.27887 = decode_resolve_method_ref (aot_module, p2.203, &p2);
            entry->method = D.27887;
            D.27888 = val & 1;
            D.27889 = D.27888 != 0;
            D.27890 = (int) D.27889;
            entry->in_mrgctx = D.27890;
            D.27891 = val >> 1;
            D.27892 = D.27891 & 255;
            entry->info_type = D.27892;
            D.27893 = mono_mempool_alloc0 (mp, 20);
            entry->data = D.27893;
            D.27894 = entry->data;
            D.27895 = val >> 9;
            D.27896 = D.27895 & 255;
            D.27894->type = D.27896;
            p.194 = p;
            D.27894 = entry->data;
            res = decode_patch (aot_module, mp, D.27894, p.194, &p);
            if (res == 0) goto cleanup; else goto <D.27897>;
            <D.27897>:
            ji->data.rgctx_entry = entry;
            goto <D.23849>;
          }
        finally
          {
            p2 = {CLOBBER};
          }
      }
      <D.23893>:
      goto <D.23849>;
      <D.23894>:
      {
        struct MonoJumpInfoImtTramp * imt_tramp;

        imt_tramp = mono_mempool_alloc0 (mp, 8);
        p.194 = p;
        D.27898 = decode_resolve_method_ref (aot_module, p.194, &p);
        imt_tramp->method = D.27898;
        p.194 = p;
        D.27899 = decode_value (p.194, &p);
        imt_tramp->vt_offset = D.27899;
        ji->data.imt_tramp = imt_tramp;
        goto <D.23849>;
      }
      <D.23896>:
      p.194 = p;
      D.27900 = decode_signature (aot_module, p.194, &p);
      ji->data.target = D.27900;
      goto <D.23849>;
      <D.23897>:
      p.194 = p;
      D.27901 = decode_value (p.194, &p);
      D.27902 = (const void *) D.27901;
      ji->data.target = D.27902;
      goto <D.23849>;
      <D.23898>:
      {
        struct MonoJumpInfoGSharedVtCall * info;

        info = monoeg_malloc0 (8);
        p.194 = p;
        D.27903 = decode_signature (aot_module, p.194, &p);
        info->sig = D.27903;
        D.27904 = info->sig;
        D.27905 = D.27904 == 0B;
        D.27906 = (long int) D.27905;
        D.27907 = __builtin_expect (D.27906, 0);
        if (D.27907 != 0) goto <D.27908>; else goto <D.27909>;
        <D.27908>:
        monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "aot-runtime.c", 3126, "info->sig");
        <D.27909>:
        p.194 = p;
        D.27910 = decode_resolve_method_ref (aot_module, p.194, &p);
        info->method = D.27910;
        D.27911 = info->method;
        D.27912 = D.27911 == 0B;
        D.27913 = (long int) D.27912;
        D.27914 = __builtin_expect (D.27913, 0);
        if (D.27914 != 0) goto <D.27915>; else goto <D.27916>;
        <D.27915>:
        monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "aot-runtime.c", 3128, "info->method");
        <D.27916>:
        ji->data.target = info;
        goto <D.23849>;
      }
      <D.23900>:
      {
        struct MonoGSharedVtMethodInfo * info;
        int i;
        int nentries;

        info = monoeg_malloc0 (8);
        p.194 = p;
        D.27917 = decode_resolve_method_ref (aot_module, p.194, &p);
        info->method = D.27917;
        D.27918 = info->method;
        D.27919 = D.27918 == 0B;
        D.27920 = (long int) D.27919;
        D.27921 = __builtin_expect (D.27920, 0);
        if (D.27921 != 0) goto <D.27922>; else goto <D.27923>;
        <D.27922>:
        monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "aot-runtime.c", 3138, "info->method");
        <D.27923>:
        p.194 = p;
        nentries = decode_value (p.194, &p);
        D.27924 = monoeg_g_ptr_array_new ();
        info->entries = D.27924;
        i = 0;
        goto <D.23911>;
        <D.23910>:
        {
          struct MonoRuntimeGenericContextInfoTemplate * template;

          template = monoeg_malloc0 (12);
          p.194 = p;
          D.27925 = decode_value (p.194, &p);
          D.27926 = (<unnamed type>) D.27925;
          template->info_type = D.27926;
          D.27927 = template->info_type;
          D.27928 = mini_rgctx_info_type_to_patch_info_type (D.27927);
          switch (D.27928) <default: <D.23909>, case 11: <D.23905>, case 13: <D.23908>>
          <D.23905>:
          {
            struct MonoClass * klass;

            p.194 = p;
            klass = decode_klass_ref (aot_module, p.194, &p);
            if (klass == 0B) goto cleanup; else goto <D.27929>;
            <D.27929>:
            D.27930 = &klass->byval_arg;
            template->data = D.27930;
            goto <D.23907>;
          }
          <D.23908>:
          p.194 = p;
          D.27931 = decode_field_info (aot_module, p.194, &p);
          template->data = D.27931;
          D.27932 = template->data;
          if (D.27932 == 0B) goto cleanup; else goto <D.27933>;
          <D.27933>:
          goto <D.23907>;
          <D.23909>:
          monoeg_assertion_message ("* Assertion: should not be reached at %s:%d\n", "aot-runtime.c", 3159);
          <D.23907>:
          D.27934 = info->entries;
          monoeg_g_ptr_array_add (D.27934, template);
        }
        i = i + 1;
        <D.23911>:
        if (i < nentries) goto <D.23910>; else goto <D.23912>;
        <D.23912>:
        ji->data.target = info;
        goto <D.23849>;
      }
      <D.23913>:
      D.27780 = ji->type;
      monoeg_g_log (0B, 16, "unhandled type %d", D.27780);
      monoeg_assertion_message ("* Assertion: should not be reached at %s:%d\n", "aot-runtime.c", 3170);
      <D.23849>:
      p.194 = p;
      *endbuf = p.194;
      D.27935 = 1;
      return D.27935;
      cleanup:
      D.27935 = 0;
      return D.27935;
    }
  finally
    {
      p = {CLOBBER};
    }
}


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

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


decode_field_info (struct MonoAotModule * module, guint8 * buf, guint8 * * endbuf)
{
  guint8 * buf.204;
  struct MonoClassField * D.27950;
  guint8 * p.205;
  int D.27952;
  int D.27953;
  struct MonoClass * klass;
  guint32 token;
  guint8 * p;

  try
    {
      buf.204 = buf;
      klass = decode_klass_ref (module, buf.204, &buf);
      buf.204 = buf;
      p = buf.204;
      if (klass == 0B) goto <D.27948>; else goto <D.27949>;
      <D.27948>:
      D.27950 = 0B;
      return D.27950;
      <D.27949>:
      p.205 = p;
      D.27952 = decode_value (p.205, &p);
      D.27953 = D.27952 + 67108864;
      token = (guint32) D.27953;
      p.205 = p;
      *endbuf = p.205;
      D.27950 = mono_class_get_field (klass, token);
      return D.27950;
    }
  finally
    {
      p = {CLOBBER};
    }
}


register_jump_target_got_slot (struct MonoDomain * domain, struct MonoMethod * method, void * * got_slot)
{
  union mono_mutex_t * D.27956;
  _Bool D.27959;
  long int D.27960;
  long int D.27961;
  struct GHashTable * D.27964;
  struct GHashTable * D.27967;
  _Bool D.27970;
  long int D.27971;
  long int D.27972;
  struct MonoJitDomainInfo * info;
  struct GSList * list;

  info = domain->runtime_info;
  {
    int ret;

    D.27956 = &domain->lock.mutex;
    ret = pthread_mutex_lock (D.27956);
    if (ret != 0) goto <D.27957>; else goto <D.27958>;
    <D.27957>:
    monoeg_g_log (0B, 16, "Bad call to mono_mutex_lock result %d", ret);
    <D.27958>:
    D.27959 = ret != 0;
    D.27960 = (long int) D.27959;
    D.27961 = __builtin_expect (D.27960, 0);
    if (D.27961 != 0) goto <D.27962>; else goto <D.27963>;
    <D.27962>:
    monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "aot-runtime.c", 3242, "ret == 0");
    <D.27963>:
  }
  D.27964 = info->jump_target_got_slot_hash;
  if (D.27964 == 0B) goto <D.27965>; else goto <D.27966>;
  <D.27965>:
  D.27967 = monoeg_g_hash_table_new (0B, 0B);
  info->jump_target_got_slot_hash = D.27967;
  <D.27966>:
  D.27964 = info->jump_target_got_slot_hash;
  list = monoeg_g_hash_table_lookup (D.27964, method);
  list = monoeg_g_slist_prepend (list, got_slot);
  D.27964 = info->jump_target_got_slot_hash;
  monoeg_g_hash_table_insert_replace (D.27964, method, list, 0);
  {
    int ret;

    D.27956 = &domain->lock.mutex;
    ret = pthread_mutex_unlock (D.27956);
    if (ret != 0) goto <D.27968>; else goto <D.27969>;
    <D.27968>:
    monoeg_g_log (0B, 16, "Bad call to mono_mutex_unlock result %d", ret);
    <D.27969>:
    D.27970 = ret != 0;
    D.27971 = (long int) D.27970;
    D.27972 = __builtin_expect (D.27971, 0);
    if (D.27972 != 0) goto <D.27973>; else goto <D.27974>;
    <D.27973>:
    monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "aot-runtime.c", 3248, "ret == 0");
    <D.27974>:
  }
}


InterlockedIncrement (volatile gint32 * val)
{
  gint32 D.27975;
  unsigned int D.27976;

  D.27976 = __sync_add_and_fetch_4 (val, 1);
  D.27975 = (gint32) D.27976;
  return D.27975;
}


init_plt (struct MonoAotModule * amodule)
{
  int D.27978;
  struct MonoDomain * D.27981;
  struct MonoDomain * D.27982;
  void * * D.27983;
  unsigned int D.27984;
  unsigned int i.206;
  unsigned int D.27986;
  unsigned int D.27987;
  void * * D.27988;
  unsigned int D.27989;
  int i;
  void * tramp;

  D.27978 = amodule->plt_inited;
  if (D.27978 != 0) goto <D.27979>; else goto <D.27980>;
  <D.27979>:
  return;
  <D.27980>:
  D.27981 = mono_get_root_domain ();
  tramp = mono_create_specific_trampoline (amodule, 6, D.27981, 0B);
  D.27982 = mono_domain_get ();
  tramp = mono_create_ftnptr (D.27982, tramp);
  i = 1;
  goto <D.24225>;
  <D.24224>:
  D.27983 = amodule->got;
  D.27984 = amodule->info.plt_got_offset_base;
  i.206 = (unsigned int) i;
  D.27986 = D.27984 + i.206;
  D.27987 = D.27986 * 4;
  D.27988 = D.27983 + D.27987;
  *D.27988 = tramp;
  i = i + 1;
  <D.24225>:
  i.206 = (unsigned int) i;
  D.27989 = amodule->info.plt_size;
  if (i.206 < D.27989) goto <D.24224>; else goto <D.24226>;
  <D.24226>:
  amodule->plt_inited = 1;
}


mono_aot_get_method_from_token (struct MonoDomain * domain, struct MonoImage * image, guint32 token)
{
  void * D.27993;
  unsigned int D.27994;
  unsigned int D.27995;
  struct MonoAotModule * aot_module;
  int method_index;

  aot_module = image->aot_module;
  if (aot_module == 0B) goto <D.27991>; else goto <D.27992>;
  <D.27991>:
  D.27993 = 0B;
  return D.27993;
  <D.27992>:
  D.27994 = token & 16777215;
  D.27995 = D.27994 + 4294967295;
  method_index = (int) D.27995;
  D.27993 = load_method (domain, aot_module, image, 0B, token, method_index);
  return D.27993;
}


mono_aot_is_got_entry (guint8 * code, guint8 * addr)
{
  struct GHashTable * aot_modules.207;
  gboolean D.28000;
  _Bool D.28003;
  long int D.28004;
  long int D.28005;
  _Bool D.28010;
  long int D.28011;
  long int D.28012;
  struct IsGotEntryUserData user_data;

  try
    {
      aot_modules.207 = aot_modules;
      if (aot_modules.207 == 0B) goto <D.27998>; else goto <D.27999>;
      <D.27998>:
      D.28000 = 0;
      return D.28000;
      <D.27999>:
      user_data.addr = addr;
      user_data.res = 0;
      {
        int ret;

        ret = pthread_mutex_lock (&aot_mutex.mutex);
        if (ret != 0) goto <D.28001>; else goto <D.28002>;
        <D.28001>:
        monoeg_g_log (0B, 16, "Bad call to mono_mutex_lock result %d", ret);
        <D.28002>:
        D.28003 = ret != 0;
        D.28004 = (long int) D.28003;
        D.28005 = __builtin_expect (D.28004, 0);
        if (D.28005 != 0) goto <D.28006>; else goto <D.28007>;
        <D.28006>:
        monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "aot-runtime.c", 3812, "ret == 0");
        <D.28007>:
      }
      aot_modules.207 = aot_modules;
      monoeg_g_hash_table_foreach (aot_modules.207, check_is_got_entry, &user_data);
      {
        int ret;

        ret = pthread_mutex_unlock (&aot_mutex.mutex);
        if (ret != 0) goto <D.28008>; else goto <D.28009>;
        <D.28008>:
        monoeg_g_log (0B, 16, "Bad call to mono_mutex_unlock result %d", ret);
        <D.28009>:
        D.28010 = ret != 0;
        D.28011 = (long int) D.28010;
        D.28012 = __builtin_expect (D.28011, 0);
        if (D.28012 != 0) goto <D.28013>; else goto <D.28014>;
        <D.28013>:
        monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "aot-runtime.c", 3814, "ret == 0");
        <D.28014>:
      }
      D.28000 = user_data.res;
      return D.28000;
    }
  finally
    {
      user_data = {CLOBBER};
    }
}


check_is_got_entry (void * key, void * value, void * user_data)
{
  void * * D.28017;
  guint8 * D.28020;
  unsigned int D.28023;
  unsigned int D.28024;
  guint8 * D.28025;
  struct IsGotEntryUserData * data;
  struct MonoAotModule * aot_module;

  data = user_data;
  aot_module = value;
  D.28017 = aot_module->got;
  if (D.28017 != 0B) goto <D.28018>; else goto <D.28019>;
  <D.28018>:
  D.28020 = data->addr;
  D.28017 = aot_module->got;
  if (D.28020 >= D.28017) goto <D.28021>; else goto <D.28022>;
  <D.28021>:
  D.28020 = data->addr;
  D.28017 = aot_module->got;
  D.28023 = aot_module->info.got_size;
  D.28024 = D.28023 * 4;
  D.28025 = D.28017 + D.28024;
  if (D.28020 < D.28025) goto <D.28026>; else goto <D.28027>;
  <D.28026>:
  data->res = 1;
  <D.28027>:
  <D.28022>:
  <D.28019>:
}


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

  D.28028 = mono_domain_get ();
  D.28029 = mono_get_root_domain ();
  if (D.28028 == D.28029) goto <D.28030>; else goto <D.28031>;
  <D.28030>:
  mono_arch_patch_plt_entry (code, got, regs, addr);
  <D.28031>:
}


mono_aot_plt_resolve (void * aot_module, guint32 plt_info_offset, guint8 * code)
{
  guint8 * D.28032;
  guint8 * p.208;
  guint8 * p.209;
  int D.28035;
  <unnamed type> D.28036;
  void * D.28039;
  int mono_aot_only.210;
  <unnamed type> D.28044;
  struct MonoMethod * D.28046;
  unsigned char D.28047;
  unsigned char D.28048;
  int D.28050;
  short unsigned int D.28052;
  int D.28053;
  int D.28054;
  int D.28056;
  struct MonoDomain * D.28059;
  <unnamed type> D.28060;
  _Bool D.28061;
  _Bool D.28062;
  _Bool D.28063;
  struct MonoDomain * D.28077;
  _Bool D.28078;
  long int D.28079;
  long int D.28080;
  void * * D.28083;
  guint8 * p;
  guint8 * target;
  guint8 * plt_entry;
  struct MonoJumpInfo ji;
  struct MonoAotModule * module;
  gboolean res;
  gboolean no_ftnptr;
  struct MonoMemPool * mp;
  gboolean using_gsharedvt;

  try
    {
      module = aot_module;
      no_ftnptr = 0;
      using_gsharedvt = 0;
      D.28032 = module->blob;
      p.208 = D.28032 + plt_info_offset;
      p = p.208;
      p.209 = p;
      D.28035 = decode_value (p.209, &p);
      D.28036 = (<unnamed type>) D.28035;
      ji.type = D.28036;
      mp = mono_mempool_new_size (512);
      p.209 = p;
      res = decode_patch (module, mp, &ji, p.209, &p);
      if (res == 0) goto <D.28037>; else goto <D.28038>;
      <D.28037>:
      mono_mempool_destroy (mp);
      D.28039 = 0B;
      return D.28039;
      <D.28038>:
      using_gsharedvt = 1;
      mono_aot_only.210 = mono_aot_only;
      if (mono_aot_only.210 != 0) goto <D.28043>; else goto <D.28040>;
      <D.28043>:
      D.28044 = ji.type;
      if (D.28044 == 3) goto <D.28045>; else goto <D.28040>;
      <D.28045>:
      D.28046 = ji.data.method;
      D.28047 = BIT_FIELD_REF <*D.28046, 8, 168>;
      D.28048 = D.28047 & 8;
      if (D.28048 == 0) goto <D.28049>; else goto <D.28040>;
      <D.28049>:
      D.28046 = ji.data.method;
      D.28050 = mono_method_check_context_used (D.28046);
      if (D.28050 == 0) goto <D.28051>; else goto <D.28040>;
      <D.28051>:
      D.28046 = ji.data.method;
      D.28052 = D.28046->iflags;
      D.28053 = (int) D.28052;
      D.28054 = D.28053 & 32;
      if (D.28054 == 0) goto <D.28055>; else goto <D.28040>;
      <D.28055>:
      D.28046 = ji.data.method;
      D.28056 = mono_method_needs_static_rgctx_invoke (D.28046, 0);
      if (D.28056 == 0) goto <D.28057>; else goto <D.28040>;
      <D.28057>:
      if (using_gsharedvt == 0) goto <D.28058>; else goto <D.28040>;
      <D.28058>:
      D.28046 = ji.data.method;
      target = mono_jit_compile_method (D.28046);
      no_ftnptr = 1;
      goto <D.28041>;
      <D.28040>:
      D.28059 = mono_domain_get ();
      target = mono_resolve_patch_target (0B, D.28059, 0B, &ji, 1);
      <D.28041>:
      D.28060 = ji.type;
      D.28061 = D.28060 == 1;
      D.28062 = D.28060 == 7;
      D.28063 = D.28061 | D.28062;
      if (D.28063 != 0) goto <D.28064>; else goto <D.28065>;
      <D.28065>:
      D.28044 = ji.type;
      if (D.28044 == 15) goto <D.28066>; else goto <D.28067>;
      <D.28067>:
      D.28044 = ji.type;
      if (D.28044 == 31) goto <D.28068>; else goto <D.28069>;
      <D.28069>:
      D.28044 = ji.type;
      if (D.28044 == 32) goto <D.28070>; else goto <D.28071>;
      <D.28071>:
      D.28044 = ji.type;
      if (D.28044 == 35) goto <D.28072>; else goto <D.28073>;
      <D.28072>:
      goto <D.28074>;
      <D.28073>:
      if (no_ftnptr == 0) goto <D.28075>; else goto <D.28076>;
      <D.28075>:
      D.28077 = mono_domain_get ();
      target = mono_create_ftnptr (D.28077, target);
      <D.28076>:
      <D.28074>:
      <D.28070>:
      <D.28068>:
      <D.28066>:
      <D.28064>:
      mono_mempool_destroy (mp);
      plt_entry = mono_aot_get_plt_entry (code);
      D.28078 = plt_entry == 0B;
      D.28079 = (long int) D.28078;
      D.28080 = __builtin_expect (D.28079, 0);
      if (D.28080 != 0) goto <D.28081>; else goto <D.28082>;
      <D.28081>:
      monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "aot-runtime.c", 3944, "plt_entry");
      <D.28082>:
      D.28083 = module->got;
      mono_aot_patch_plt_entry (plt_entry, D.28083, 0B, target);
      D.28039 = target;
      return D.28039;
    }
  finally
    {
      p = {CLOBBER};
      ji = {CLOBBER};
    }
}


mono_aot_get_plt_entry (guint8 * code)
{
  guint8 * D.28088;
  guint8 * D.28090;
  guint8 * D.28092;
  struct MonoAotModule * amodule;
  guint8 * target;

  amodule = find_aot_module (code);
  target = 0B;
  if (amodule == 0B) goto <D.28086>; else goto <D.28087>;
  <D.28086>:
  D.28088 = 0B;
  return D.28088;
  <D.28087>:
  target = mono_arch_get_call_target (code);
  D.28090 = amodule->plt;
  if (D.28090 <= target) goto <D.28091>; else goto <D.28089>;
  <D.28091>:
  D.28092 = amodule->plt_end;
  if (D.28092 > target) goto <D.28093>; else goto <D.28089>;
  <D.28093>:
  D.28088 = target;
  return D.28088;
  <D.28089>:
  D.28088 = 0B;
  return D.28088;
}


find_aot_module (guint8 * code)
{
  struct GHashTable * aot_modules.211;
  struct MonoAotModule * D.28098;
  unsigned int code.212;
  unsigned int aot_code_low_addr.213;
  unsigned int aot_code_high_addr.214;
  _Bool D.28107;
  long int D.28108;
  long int D.28109;
  _Bool D.28114;
  long int D.28115;
  long int D.28116;
  struct FindAotModuleUserData user_data;

  try
    {
      aot_modules.211 = aot_modules;
      if (aot_modules.211 == 0B) goto <D.28096>; else goto <D.28097>;
      <D.28096>:
      D.28098 = 0B;
      return D.28098;
      <D.28097>:
      code.212 = (unsigned int) code;
      aot_code_low_addr.213 = aot_code_low_addr;
      if (code.212 < aot_code_low_addr.213) goto <D.28099>; else goto <D.28103>;
      <D.28103>:
      code.212 = (unsigned int) code;
      aot_code_high_addr.214 = aot_code_high_addr;
      if (code.212 > aot_code_high_addr.214) goto <D.28099>; else goto <D.28100>;
      <D.28099>:
      D.28098 = 0B;
      return D.28098;
      <D.28100>:
      user_data.addr = code;
      user_data.module = 0B;
      {
        int ret;

        ret = pthread_mutex_lock (&aot_mutex.mutex);
        if (ret != 0) goto <D.28105>; else goto <D.28106>;
        <D.28105>:
        monoeg_g_log (0B, 16, "Bad call to mono_mutex_lock result %d", ret);
        <D.28106>:
        D.28107 = ret != 0;
        D.28108 = (long int) D.28107;
        D.28109 = __builtin_expect (D.28108, 0);
        if (D.28109 != 0) goto <D.28110>; else goto <D.28111>;
        <D.28110>:
        monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "aot-runtime.c", 3849, "ret == 0");
        <D.28111>:
      }
      aot_modules.211 = aot_modules;
      monoeg_g_hash_table_foreach (aot_modules.211, find_aot_module_cb, &user_data);
      {
        int ret;

        ret = pthread_mutex_unlock (&aot_mutex.mutex);
        if (ret != 0) goto <D.28112>; else goto <D.28113>;
        <D.28112>:
        monoeg_g_log (0B, 16, "Bad call to mono_mutex_unlock result %d", ret);
        <D.28113>:
        D.28114 = ret != 0;
        D.28115 = (long int) D.28114;
        D.28116 = __builtin_expect (D.28115, 0);
        if (D.28116 != 0) goto <D.28117>; else goto <D.28118>;
        <D.28117>:
        monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "aot-runtime.c", 3851, "ret == 0");
        <D.28118>:
      }
      D.28098 = user_data.module;
      return D.28098;
    }
  finally
    {
      user_data = {CLOBBER};
    }
}


find_aot_module_cb (void * key, void * value, void * user_data)
{
  guint8 * D.28121;
  guint8 * D.28122;
  guint8 * D.28125;
  struct FindAotModuleUserData * data;
  struct MonoAotModule * aot_module;

  data = user_data;
  aot_module = value;
  D.28121 = data->addr;
  D.28122 = aot_module->code;
  if (D.28121 >= D.28122) goto <D.28123>; else goto <D.28124>;
  <D.28123>:
  D.28121 = data->addr;
  D.28125 = aot_module->code_end;
  if (D.28121 < D.28125) goto <D.28126>; else goto <D.28127>;
  <D.28126>:
  data->module = aot_module;
  <D.28127>:
  <D.28124>:
}


mono_aot_get_plt_info_offset (mgreg_t * regs, guint8 * code)
{
  _Bool D.28128;
  long int D.28129;
  long int D.28130;
  guint32 D.28133;
  guint8 * plt_entry;

  plt_entry = mono_aot_get_plt_entry (code);
  D.28128 = plt_entry == 0B;
  D.28129 = (long int) D.28128;
  D.28130 = __builtin_expect (D.28129, 0);
  if (D.28130 != 0) goto <D.28131>; else goto <D.28132>;
  <D.28131>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "aot-runtime.c", 4039, "plt_entry");
  <D.28132>:
  D.28133 = mono_arch_get_plt_info_offset (plt_entry, regs, code);
  return D.28133;
}


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

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


mono_aot_get_trampoline_full (const char * name, struct MonoTrampInfo * * out_tinfo)
{
  _Bool D.28139;
  long int D.28140;
  long int D.28141;
  _Bool D.28144;
  long int D.28145;
  long int D.28146;
  void * D.28149;
  void * D.28150;
  struct MonoImage * image;
  struct MonoAotModule * amodule;

  image = mono_defaults.corlib;
  D.28139 = image == 0B;
  D.28140 = (long int) D.28139;
  D.28141 = __builtin_expect (D.28140, 0);
  if (D.28141 != 0) goto <D.28142>; else goto <D.28143>;
  <D.28142>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "aot-runtime.c", 4242, "image");
  <D.28143>:
  amodule = image->aot_module;
  D.28144 = amodule == 0B;
  D.28145 = (long int) D.28144;
  D.28146 = __builtin_expect (D.28145, 0);
  if (D.28146 != 0) goto <D.28147>; else goto <D.28148>;
  <D.28147>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "aot-runtime.c", 4245, "amodule");
  <D.28148>:
  D.28150 = load_function_full (amodule, name, out_tinfo);
  D.28149 = mono_create_ftnptr_malloc (D.28150);
  return D.28149;
}


load_function_full (struct MonoAotModule * amodule, const char * name, struct MonoTrampInfo * * out_tinfo)
{
  void * * D.28152;
  struct MonoDl * D.28153;
  void * code.217;
  char * D.28157;
  guint8 * p.218;
  void * D.28161;
  guint8 * p.219;
  guint8 * D.28165;
  guint8 * uw_info.220;
  guint8 * uw_info.221;
  int D.28168;
  guint8 * D.28169;
  guint8 * p.222;
  _Bool D.28173;
  long int D.28174;
  long int D.28175;
  unsigned int pindex.223;
  unsigned int D.28179;
  void * * D.28180;
  guint32 * got_slots.224;
  unsigned int D.28182;
  guint32 * D.28183;
  unsigned int D.28184;
  unsigned int D.28185;
  void * * D.28186;
  void * D.28187;
  <unnamed type> D.28190;
  int D.24275;
  int iftmp.225;
  int D.24274;
  const char[18] * D.28196;
  unsigned char D.28197;
  int D.28198;
  unsigned char D.28199;
  int D.28200;
  _Bool D.28201;
  _Bool D.28202;
  _Bool D.28203;
  const unsigned char * D.28206;
  unsigned char D.28207;
  int D.28208;
  const unsigned char * D.28209;
  unsigned char D.28210;
  int D.28211;
  _Bool D.28212;
  _Bool D.28213;
  const unsigned char * D.28216;
  unsigned char D.28217;
  int D.28218;
  const unsigned char * D.28219;
  unsigned char D.28220;
  int D.28221;
  _Bool D.28222;
  _Bool D.28223;
  const unsigned char * D.28226;
  unsigned char D.28227;
  int D.28228;
  const unsigned char * D.28229;
  unsigned char D.28230;
  int D.28231;
  const char * D.28233;
  int D.24284;
  int iftmp.226;
  int D.24283;
  const char[42] * D.28240;
  unsigned char D.28241;
  int D.28242;
  unsigned char D.28243;
  int D.28244;
  _Bool D.28245;
  _Bool D.28246;
  _Bool D.28247;
  const unsigned char * D.28250;
  unsigned char D.28251;
  int D.28252;
  const unsigned char * D.28253;
  unsigned char D.28254;
  int D.28255;
  _Bool D.28256;
  _Bool D.28257;
  const unsigned char * D.28260;
  unsigned char D.28261;
  int D.28262;
  const unsigned char * D.28263;
  unsigned char D.28264;
  int D.28265;
  _Bool D.28266;
  _Bool D.28267;
  const unsigned char * D.28270;
  unsigned char D.28271;
  int D.28272;
  const unsigned char * D.28273;
  unsigned char D.28274;
  int D.28275;
  int D.24293;
  int iftmp.227;
  int D.24292;
  const char[26] * D.28283;
  unsigned char D.28284;
  int D.28285;
  unsigned char D.28286;
  int D.28287;
  _Bool D.28288;
  _Bool D.28289;
  _Bool D.28290;
  const unsigned char * D.28293;
  unsigned char D.28294;
  int D.28295;
  const unsigned char * D.28296;
  unsigned char D.28297;
  int D.28298;
  _Bool D.28299;
  _Bool D.28300;
  const unsigned char * D.28303;
  unsigned char D.28304;
  int D.28305;
  const unsigned char * D.28306;
  unsigned char D.28307;
  int D.28308;
  _Bool D.28309;
  _Bool D.28310;
  const unsigned char * D.28313;
  unsigned char D.28314;
  int D.28315;
  const unsigned char * D.28316;
  unsigned char D.28317;
  int D.28318;
  int D.24302;
  int iftmp.228;
  int D.24301;
  const char[21] * D.28326;
  unsigned char D.28327;
  int D.28328;
  unsigned char D.28329;
  int D.28330;
  _Bool D.28331;
  _Bool D.28332;
  _Bool D.28333;
  const unsigned char * D.28336;
  unsigned char D.28337;
  int D.28338;
  const unsigned char * D.28339;
  unsigned char D.28340;
  int D.28341;
  _Bool D.28342;
  _Bool D.28343;
  const unsigned char * D.28346;
  unsigned char D.28347;
  int D.28348;
  const unsigned char * D.28349;
  unsigned char D.28350;
  int D.28351;
  _Bool D.28352;
  _Bool D.28353;
  const unsigned char * D.28356;
  unsigned char D.28357;
  int D.28358;
  const unsigned char * D.28359;
  unsigned char D.28360;
  int D.28361;
  char * D.28366;
  const char * D.28369;
  <unnamed type> tramp_type2.229;
  char * D.28372;
  _Bool D.28375;
  long int D.28376;
  long int D.28377;
  struct MonoDomain * D.28380;
  unsigned int slot.230;
  void * slot.231;
  int D.24314;
  int iftmp.232;
  int D.24313;
  const char[34] * D.28387;
  unsigned char D.28388;
  int D.28389;
  unsigned char D.28390;
  int D.28391;
  _Bool D.28392;
  _Bool D.28393;
  _Bool D.28394;
  const unsigned char * D.28397;
  unsigned char D.28398;
  int D.28399;
  const unsigned char * D.28400;
  unsigned char D.28401;
  int D.28402;
  _Bool D.28403;
  _Bool D.28404;
  const unsigned char * D.28407;
  unsigned char D.28408;
  int D.28409;
  const unsigned char * D.28410;
  unsigned char D.28411;
  int D.28412;
  _Bool D.28413;
  _Bool D.28414;
  const unsigned char * D.28417;
  unsigned char D.28418;
  int D.28419;
  const unsigned char * D.28420;
  unsigned char D.28421;
  int D.28422;
  struct MonoDomain * D.28426;
  int D.24323;
  int iftmp.233;
  int D.24322;
  const char[33] * D.28431;
  unsigned char D.28432;
  int D.28433;
  unsigned char D.28434;
  int D.28435;
  _Bool D.28436;
  _Bool D.28437;
  _Bool D.28438;
  const unsigned char * D.28441;
  unsigned char D.28442;
  int D.28443;
  const unsigned char * D.28444;
  unsigned char D.28445;
  int D.28446;
  _Bool D.28447;
  _Bool D.28448;
  const unsigned char * D.28451;
  unsigned char D.28452;
  int D.28453;
  const unsigned char * D.28454;
  unsigned char D.28455;
  int D.28456;
  _Bool D.28457;
  _Bool D.28458;
  const unsigned char * D.28461;
  unsigned char D.28462;
  int D.28463;
  const unsigned char * D.28464;
  unsigned char D.28465;
  int D.28466;
  struct MonoDomain * D.28470;
  int D.24332;
  int iftmp.234;
  int D.24331;
  const char[39] * D.28475;
  unsigned char D.28476;
  int D.28477;
  unsigned char D.28478;
  int D.28479;
  _Bool D.28480;
  _Bool D.28481;
  _Bool D.28482;
  const unsigned char * D.28485;
  unsigned char D.28486;
  int D.28487;
  const unsigned char * D.28488;
  unsigned char D.28489;
  int D.28490;
  _Bool D.28491;
  _Bool D.28492;
  const unsigned char * D.28495;
  unsigned char D.28496;
  int D.28497;
  const unsigned char * D.28498;
  unsigned char D.28499;
  int D.28500;
  _Bool D.28501;
  _Bool D.28502;
  const unsigned char * D.28505;
  unsigned char D.28506;
  int D.28507;
  const unsigned char * D.28508;
  unsigned char D.28509;
  int D.28510;
  struct MonoDomain * D.28514;
  int D.24341;
  int iftmp.235;
  int D.24340;
  const char[44] * D.28519;
  unsigned char D.28520;
  int D.28521;
  unsigned char D.28522;
  int D.28523;
  _Bool D.28524;
  _Bool D.28525;
  _Bool D.28526;
  const unsigned char * D.28529;
  unsigned char D.28530;
  int D.28531;
  const unsigned char * D.28532;
  unsigned char D.28533;
  int D.28534;
  _Bool D.28535;
  _Bool D.28536;
  const unsigned char * D.28539;
  unsigned char D.28540;
  int D.28541;
  const unsigned char * D.28542;
  unsigned char D.28543;
  int D.28544;
  _Bool D.28545;
  _Bool D.28546;
  const unsigned char * D.28549;
  unsigned char D.28550;
  int D.28551;
  const unsigned char * D.28552;
  unsigned char D.28553;
  int D.28554;
  char * D.28559;
  struct GHashTable * aot_jit_icall_hash.236;
  void * D.28567;
  struct _IO_FILE * stderr.237;
  _Bool D.28571;
  long int D.28572;
  long int D.28573;
  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.28152 = amodule->globals;
      D.28153 = amodule->sofile;
      find_symbol (D.28153, D.28152, symbol, &code);
      monoeg_g_free (symbol);
      code.217 = code;
      if (code.217 == 0B) goto <D.28155>; else goto <D.28156>;
      <D.28155>:
      D.28157 = amodule->aot_name;
      monoeg_g_log (0B, 4, "Symbol \'%s\' not found in AOT file \'%s\'.\n", name, D.28157);
      <D.24256>:
      goto <D.24256>;
      <D.28156>:
      D.28157 = amodule->aot_name;
      mono_trace (128, 32, "AOT FOUND function \'%s\' in AOT file \'%s\'.", name, D.28157);
      symbol = monoeg_g_strdup_printf ("%s_p", name);
      D.28152 = amodule->globals;
      D.28153 = amodule->sofile;
      find_symbol (D.28153, D.28152, symbol, &p);
      monoeg_g_free (symbol);
      p.218 = p;
      if (p.218 == 0B) goto <D.28159>; else goto <D.28160>;
      <D.28159>:
      D.28161 = code;
      return D.28161;
      <D.28160>:
      p.218 = p;
      info_offset = MEM[(guint32 *)p.218];
      if (out_tinfo != 0B) goto <D.28162>; else goto <D.28163>;
      <D.28162>:
      {
        struct MonoTrampInfo * tinfo;
        guint32 code_size;
        guint32 uw_info_len;
        guint32 uw_offset;
        guint8 * uw_info;

        try
          {
            p.218 = p;
            p.219 = p.218 + 4;
            p = p.219;
            p.218 = p;
            code_size = MEM[(guint32 *)p.218];
            p.218 = p;
            p.219 = p.218 + 4;
            p = p.219;
            p.218 = p;
            uw_offset = MEM[(guint32 *)p.218];
            D.28165 = amodule->unwind_info;
            uw_info.220 = D.28165 + uw_offset;
            uw_info = uw_info.220;
            uw_info.221 = uw_info;
            D.28168 = decode_value (uw_info.221, &uw_info);
            uw_info_len = (guint32) D.28168;
            tinfo = monoeg_malloc0 (28);
            code.217 = code;
            tinfo->code = code.217;
            tinfo->code_size = code_size;
            uw_info.221 = uw_info;
            tinfo->uw_info = uw_info.221;
            tinfo->uw_info_len = uw_info_len;
            *out_tinfo = tinfo;
          }
        finally
          {
            uw_info = {CLOBBER};
          }
      }
      <D.28163>:
      D.28169 = amodule->blob;
      p.222 = D.28169 + info_offset;
      p = p.222;
      p.218 = p;
      n_patches = decode_value (p.218, &p);
      if (n_patches != 0) goto <D.28171>; else goto <D.28172>;
      <D.28171>:
      {
        struct MonoJumpInfo * patches;
        guint32 * got_slots;

        try
          {
            mp = mono_mempool_new ();
            p.218 = p;
            patches = load_patch_info (amodule, mp, n_patches, &got_slots, p.218, &p);
            D.28173 = patches == 0B;
            D.28174 = (long int) D.28173;
            D.28175 = __builtin_expect (D.28174, 0);
            if (D.28175 != 0) goto <D.28176>; else goto <D.28177>;
            <D.28176>:
            monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "aot-runtime.c", 4151, "patches");
            <D.28177>:
            pindex = 0;
            goto <D.24343>;
            <D.24342>:
            {
              struct MonoJumpInfo * ji;
              void * target;

              pindex.223 = (unsigned int) pindex;
              D.28179 = pindex.223 * 20;
              ji = patches + D.28179;
              D.28180 = amodule->got;
              got_slots.224 = got_slots;
              pindex.223 = (unsigned int) pindex;
              D.28182 = pindex.223 * 4;
              D.28183 = got_slots.224 + D.28182;
              D.28184 = *D.28183;
              D.28185 = D.28184 * 4;
              D.28186 = D.28180 + D.28185;
              D.28187 = *D.28186;
              if (D.28187 != 0B) goto <D.28188>; else goto <D.28189>;
              <D.28188>:
              // predicted unlikely by continue predictor.
              goto <D.24266>;
              <D.28189>:
              D.28190 = ji->type;
              if (D.28190 == 32) goto <D.28191>; else goto <D.28192>;
              <D.28191>:
              {
                size_t __s1_len;
                size_t __s2_len;

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

                  __s2 = ji->data.name;
                  D.28196 = "mono_get_lmf_addr";
                  D.28197 = MEM[(const unsigned char *)D.28196];
                  D.28198 = (int) D.28197;
                  D.28199 = *__s2;
                  D.28200 = (int) D.28199;
                  __result = D.28198 - D.28200;
                  {
                    D.28201 = __s2_len != 0;
                    D.28202 = __result == 0;
                    D.28203 = D.28201 & D.28202;
                    if (D.28203 != 0) goto <D.28204>; else goto <D.28205>;
                    <D.28204>:
                    D.28206 = &MEM[(void *)"mono_get_lmf_addr" + 1B];
                    D.28207 = *D.28206;
                    D.28208 = (int) D.28207;
                    D.28209 = __s2 + 1;
                    D.28210 = *D.28209;
                    D.28211 = (int) D.28210;
                    __result = D.28208 - D.28211;
                    D.28212 = __s2_len > 1;
                    D.28202 = __result == 0;
                    D.28213 = D.28212 & D.28202;
                    if (D.28213 != 0) goto <D.28214>; else goto <D.28215>;
                    <D.28214>:
                    D.28216 = &MEM[(void *)"mono_get_lmf_addr" + 2B];
                    D.28217 = *D.28216;
                    D.28218 = (int) D.28217;
                    D.28219 = __s2 + 2;
                    D.28220 = *D.28219;
                    D.28221 = (int) D.28220;
                    __result = D.28218 - D.28221;
                    D.28222 = __s2_len > 2;
                    D.28202 = __result == 0;
                    D.28223 = D.28222 & D.28202;
                    if (D.28223 != 0) goto <D.28224>; else goto <D.28225>;
                    <D.28224>:
                    D.28226 = &MEM[(void *)"mono_get_lmf_addr" + 3B];
                    D.28227 = *D.28226;
                    D.28228 = (int) D.28227;
                    D.28229 = __s2 + 3;
                    D.28230 = *D.28229;
                    D.28231 = (int) D.28230;
                    __result = D.28228 - D.28231;
                    <D.28225>:
                    <D.28215>:
                    <D.28205>:
                  }
                  D.24274 = __result;
                }
                iftmp.225 = -D.24274;
                goto <D.28232>;
                <D.28195>:
                D.28233 = ji->data.name;
                iftmp.225 = __builtin_strcmp (D.28233, "mono_get_lmf_addr");
                <D.28232>:
                D.24275 = iftmp.225;
              }
              if (D.24275 == 0) goto <D.28234>; else goto <D.28235>;
              <D.28234>:
              target = mono_get_lmf_addr;
              goto <D.28236>;
              <D.28235>:
              {
                size_t __s1_len;
                size_t __s2_len;

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

                  __s2 = ji->data.name;
                  D.28240 = "mono_thread_force_interruption_checkpoint";
                  D.28241 = MEM[(const unsigned char *)D.28240];
                  D.28242 = (int) D.28241;
                  D.28243 = *__s2;
                  D.28244 = (int) D.28243;
                  __result = D.28242 - D.28244;
                  {
                    D.28245 = __s2_len != 0;
                    D.28246 = __result == 0;
                    D.28247 = D.28245 & D.28246;
                    if (D.28247 != 0) goto <D.28248>; else goto <D.28249>;
                    <D.28248>:
                    D.28250 = &MEM[(void *)"mono_thread_force_interruption_checkpoint" + 1B];
                    D.28251 = *D.28250;
                    D.28252 = (int) D.28251;
                    D.28253 = __s2 + 1;
                    D.28254 = *D.28253;
                    D.28255 = (int) D.28254;
                    __result = D.28252 - D.28255;
                    D.28256 = __s2_len > 1;
                    D.28246 = __result == 0;
                    D.28257 = D.28256 & D.28246;
                    if (D.28257 != 0) goto <D.28258>; else goto <D.28259>;
                    <D.28258>:
                    D.28260 = &MEM[(void *)"mono_thread_force_interruption_checkpoint" + 2B];
                    D.28261 = *D.28260;
                    D.28262 = (int) D.28261;
                    D.28263 = __s2 + 2;
                    D.28264 = *D.28263;
                    D.28265 = (int) D.28264;
                    __result = D.28262 - D.28265;
                    D.28266 = __s2_len > 2;
                    D.28246 = __result == 0;
                    D.28267 = D.28266 & D.28246;
                    if (D.28267 != 0) goto <D.28268>; else goto <D.28269>;
                    <D.28268>:
                    D.28270 = &MEM[(void *)"mono_thread_force_interruption_checkpoint" + 3B];
                    D.28271 = *D.28270;
                    D.28272 = (int) D.28271;
                    D.28273 = __s2 + 3;
                    D.28274 = *D.28273;
                    D.28275 = (int) D.28274;
                    __result = D.28272 - D.28275;
                    <D.28269>:
                    <D.28259>:
                    <D.28249>:
                  }
                  D.24283 = __result;
                }
                iftmp.226 = -D.24283;
                goto <D.28276>;
                <D.28239>:
                D.28233 = ji->data.name;
                iftmp.226 = __builtin_strcmp (D.28233, "mono_thread_force_interruption_checkpoint");
                <D.28276>:
                D.24284 = iftmp.226;
              }
              if (D.24284 == 0) goto <D.28277>; else goto <D.28278>;
              <D.28277>:
              target = mono_thread_force_interruption_checkpoint;
              goto <D.28279>;
              <D.28278>:
              {
                size_t __s1_len;
                size_t __s2_len;

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

                  __s2 = ji->data.name;
                  D.28283 = "mono_exception_from_token";
                  D.28284 = MEM[(const unsigned char *)D.28283];
                  D.28285 = (int) D.28284;
                  D.28286 = *__s2;
                  D.28287 = (int) D.28286;
                  __result = D.28285 - D.28287;
                  {
                    D.28288 = __s2_len != 0;
                    D.28289 = __result == 0;
                    D.28290 = D.28288 & D.28289;
                    if (D.28290 != 0) goto <D.28291>; else goto <D.28292>;
                    <D.28291>:
                    D.28293 = &MEM[(void *)"mono_exception_from_token" + 1B];
                    D.28294 = *D.28293;
                    D.28295 = (int) D.28294;
                    D.28296 = __s2 + 1;
                    D.28297 = *D.28296;
                    D.28298 = (int) D.28297;
                    __result = D.28295 - D.28298;
                    D.28299 = __s2_len > 1;
                    D.28289 = __result == 0;
                    D.28300 = D.28299 & D.28289;
                    if (D.28300 != 0) goto <D.28301>; else goto <D.28302>;
                    <D.28301>:
                    D.28303 = &MEM[(void *)"mono_exception_from_token" + 2B];
                    D.28304 = *D.28303;
                    D.28305 = (int) D.28304;
                    D.28306 = __s2 + 2;
                    D.28307 = *D.28306;
                    D.28308 = (int) D.28307;
                    __result = D.28305 - D.28308;
                    D.28309 = __s2_len > 2;
                    D.28289 = __result == 0;
                    D.28310 = D.28309 & D.28289;
                    if (D.28310 != 0) goto <D.28311>; else goto <D.28312>;
                    <D.28311>:
                    D.28313 = &MEM[(void *)"mono_exception_from_token" + 3B];
                    D.28314 = *D.28313;
                    D.28315 = (int) D.28314;
                    D.28316 = __s2 + 3;
                    D.28317 = *D.28316;
                    D.28318 = (int) D.28317;
                    __result = D.28315 - D.28318;
                    <D.28312>:
                    <D.28302>:
                    <D.28292>:
                  }
                  D.24292 = __result;
                }
                iftmp.227 = -D.24292;
                goto <D.28319>;
                <D.28282>:
                D.28233 = ji->data.name;
                iftmp.227 = __builtin_strcmp (D.28233, "mono_exception_from_token");
                <D.28319>:
                D.24293 = iftmp.227;
              }
              if (D.24293 == 0) goto <D.28320>; else goto <D.28321>;
              <D.28320>:
              target = mono_exception_from_token;
              goto <D.28322>;
              <D.28321>:
              {
                size_t __s1_len;
                size_t __s2_len;

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

                  __s2 = ji->data.name;
                  D.28326 = "mono_throw_exception";
                  D.28327 = MEM[(const unsigned char *)D.28326];
                  D.28328 = (int) D.28327;
                  D.28329 = *__s2;
                  D.28330 = (int) D.28329;
                  __result = D.28328 - D.28330;
                  {
                    D.28331 = __s2_len != 0;
                    D.28332 = __result == 0;
                    D.28333 = D.28331 & D.28332;
                    if (D.28333 != 0) goto <D.28334>; else goto <D.28335>;
                    <D.28334>:
                    D.28336 = &MEM[(void *)"mono_throw_exception" + 1B];
                    D.28337 = *D.28336;
                    D.28338 = (int) D.28337;
                    D.28339 = __s2 + 1;
                    D.28340 = *D.28339;
                    D.28341 = (int) D.28340;
                    __result = D.28338 - D.28341;
                    D.28342 = __s2_len > 1;
                    D.28332 = __result == 0;
                    D.28343 = D.28342 & D.28332;
                    if (D.28343 != 0) goto <D.28344>; else goto <D.28345>;
                    <D.28344>:
                    D.28346 = &MEM[(void *)"mono_throw_exception" + 2B];
                    D.28347 = *D.28346;
                    D.28348 = (int) D.28347;
                    D.28349 = __s2 + 2;
                    D.28350 = *D.28349;
                    D.28351 = (int) D.28350;
                    __result = D.28348 - D.28351;
                    D.28352 = __s2_len > 2;
                    D.28332 = __result == 0;
                    D.28353 = D.28352 & D.28332;
                    if (D.28353 != 0) goto <D.28354>; else goto <D.28355>;
                    <D.28354>:
                    D.28356 = &MEM[(void *)"mono_throw_exception" + 3B];
                    D.28357 = *D.28356;
                    D.28358 = (int) D.28357;
                    D.28359 = __s2 + 3;
                    D.28360 = *D.28359;
                    D.28361 = (int) D.28360;
                    __result = D.28358 - D.28361;
                    <D.28355>:
                    <D.28345>:
                    <D.28335>:
                  }
                  D.24301 = __result;
                }
                iftmp.228 = -D.24301;
                goto <D.28362>;
                <D.28325>:
                D.28233 = ji->data.name;
                iftmp.228 = __builtin_strcmp (D.28233, "mono_throw_exception");
                <D.28362>:
                D.24302 = iftmp.228;
              }
              if (D.24302 == 0) goto <D.28363>; else goto <D.28364>;
              <D.28363>:
              target = mono_get_throw_exception ();
              goto <D.28365>;
              <D.28364>:
              D.28233 = ji->data.name;
              D.28366 = strstr (D.28233, "trampoline_func_");
              D.28233 = ji->data.name;
              if (D.28366 == D.28233) goto <D.28367>; else goto <D.28368>;
              <D.28367>:
              {
                int tramp_type2;

                D.28233 = ji->data.name;
                D.28369 = D.28233 + 16;
                tramp_type2 = atoi (D.28369);
                tramp_type2.229 = (<unnamed type>) tramp_type2;
                target = mono_get_trampoline_func (tramp_type2.229);
              }
              goto <D.28371>;
              <D.28368>:
              D.28233 = ji->data.name;
              D.28372 = strstr (D.28233, "specific_trampoline_lazy_fetch_");
              D.28233 = ji->data.name;
              if (D.28372 == D.28233) goto <D.28373>; else goto <D.28374>;
              <D.28373>:
              {
                guint32 slot;
                int res;

                try
                  {
                    D.28233 = ji->data.name;
                    res = sscanf (D.28233, "specific_trampoline_lazy_fetch_%u", &slot);
                    D.28375 = res != 1;
                    D.28376 = (long int) D.28375;
                    D.28377 = __builtin_expect (D.28376, 0);
                    if (D.28377 != 0) goto <D.28378>; else goto <D.28379>;
                    <D.28378>:
                    monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "aot-runtime.c", 4182, "res == 1");
                    <D.28379>:
                    D.28380 = mono_get_root_domain ();
                    slot.230 = slot;
                    slot.231 = (void *) slot.230;
                    target = mono_create_specific_trampoline (slot.231, 4, D.28380, 0B);
                    target = mono_create_ftnptr_malloc (target);
                  }
                finally
                  {
                    slot = {CLOBBER};
                  }
              }
              goto <D.28383>;
              <D.28374>:
              {
                size_t __s1_len;
                size_t __s2_len;

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

                  __s2 = ji->data.name;
                  D.28387 = "specific_trampoline_monitor_enter";
                  D.28388 = MEM[(const unsigned char *)D.28387];
                  D.28389 = (int) D.28388;
                  D.28390 = *__s2;
                  D.28391 = (int) D.28390;
                  __result = D.28389 - D.28391;
                  {
                    D.28392 = __s2_len != 0;
                    D.28393 = __result == 0;
                    D.28394 = D.28392 & D.28393;
                    if (D.28394 != 0) goto <D.28395>; else goto <D.28396>;
                    <D.28395>:
                    D.28397 = &MEM[(void *)"specific_trampoline_monitor_enter" + 1B];
                    D.28398 = *D.28397;
                    D.28399 = (int) D.28398;
                    D.28400 = __s2 + 1;
                    D.28401 = *D.28400;
                    D.28402 = (int) D.28401;
                    __result = D.28399 - D.28402;
                    D.28403 = __s2_len > 1;
                    D.28393 = __result == 0;
                    D.28404 = D.28403 & D.28393;
                    if (D.28404 != 0) goto <D.28405>; else goto <D.28406>;
                    <D.28405>:
                    D.28407 = &MEM[(void *)"specific_trampoline_monitor_enter" + 2B];
                    D.28408 = *D.28407;
                    D.28409 = (int) D.28408;
                    D.28410 = __s2 + 2;
                    D.28411 = *D.28410;
                    D.28412 = (int) D.28411;
                    __result = D.28409 - D.28412;
                    D.28413 = __s2_len > 2;
                    D.28393 = __result == 0;
                    D.28414 = D.28413 & D.28393;
                    if (D.28414 != 0) goto <D.28415>; else goto <D.28416>;
                    <D.28415>:
                    D.28417 = &MEM[(void *)"specific_trampoline_monitor_enter" + 3B];
                    D.28418 = *D.28417;
                    D.28419 = (int) D.28418;
                    D.28420 = __s2 + 3;
                    D.28421 = *D.28420;
                    D.28422 = (int) D.28421;
                    __result = D.28419 - D.28422;
                    <D.28416>:
                    <D.28406>:
                    <D.28396>:
                  }
                  D.24313 = __result;
                }
                iftmp.232 = -D.24313;
                goto <D.28423>;
                <D.28386>:
                D.28233 = ji->data.name;
                iftmp.232 = __builtin_strcmp (D.28233, "specific_trampoline_monitor_enter");
                <D.28423>:
                D.24314 = iftmp.232;
              }
              if (D.24314 == 0) goto <D.28424>; else goto <D.28425>;
              <D.28424>:
              D.28426 = mono_get_root_domain ();
              target = mono_create_specific_trampoline (0B, 10, D.28426, 0B);
              target = mono_create_ftnptr_malloc (target);
              goto <D.28427>;
              <D.28425>:
              {
                size_t __s1_len;
                size_t __s2_len;

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

                  __s2 = ji->data.name;
                  D.28431 = "specific_trampoline_monitor_exit";
                  D.28432 = MEM[(const unsigned char *)D.28431];
                  D.28433 = (int) D.28432;
                  D.28434 = *__s2;
                  D.28435 = (int) D.28434;
                  __result = D.28433 - D.28435;
                  {
                    D.28436 = __s2_len != 0;
                    D.28437 = __result == 0;
                    D.28438 = D.28436 & D.28437;
                    if (D.28438 != 0) goto <D.28439>; else goto <D.28440>;
                    <D.28439>:
                    D.28441 = &MEM[(void *)"specific_trampoline_monitor_exit" + 1B];
                    D.28442 = *D.28441;
                    D.28443 = (int) D.28442;
                    D.28444 = __s2 + 1;
                    D.28445 = *D.28444;
                    D.28446 = (int) D.28445;
                    __result = D.28443 - D.28446;
                    D.28447 = __s2_len > 1;
                    D.28437 = __result == 0;
                    D.28448 = D.28447 & D.28437;
                    if (D.28448 != 0) goto <D.28449>; else goto <D.28450>;
                    <D.28449>:
                    D.28451 = &MEM[(void *)"specific_trampoline_monitor_exit" + 2B];
                    D.28452 = *D.28451;
                    D.28453 = (int) D.28452;
                    D.28454 = __s2 + 2;
                    D.28455 = *D.28454;
                    D.28456 = (int) D.28455;
                    __result = D.28453 - D.28456;
                    D.28457 = __s2_len > 2;
                    D.28437 = __result == 0;
                    D.28458 = D.28457 & D.28437;
                    if (D.28458 != 0) goto <D.28459>; else goto <D.28460>;
                    <D.28459>:
                    D.28461 = &MEM[(void *)"specific_trampoline_monitor_exit" + 3B];
                    D.28462 = *D.28461;
                    D.28463 = (int) D.28462;
                    D.28464 = __s2 + 3;
                    D.28465 = *D.28464;
                    D.28466 = (int) D.28465;
                    __result = D.28463 - D.28466;
                    <D.28460>:
                    <D.28450>:
                    <D.28440>:
                  }
                  D.24322 = __result;
                }
                iftmp.233 = -D.24322;
                goto <D.28467>;
                <D.28430>:
                D.28233 = ji->data.name;
                iftmp.233 = __builtin_strcmp (D.28233, "specific_trampoline_monitor_exit");
                <D.28467>:
                D.24323 = iftmp.233;
              }
              if (D.24323 == 0) goto <D.28468>; else goto <D.28469>;
              <D.28468>:
              D.28470 = mono_get_root_domain ();
              target = mono_create_specific_trampoline (0B, 11, D.28470, 0B);
              target = mono_create_ftnptr_malloc (target);
              goto <D.28471>;
              <D.28469>:
              {
                size_t __s1_len;
                size_t __s2_len;

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

                  __s2 = ji->data.name;
                  D.28475 = "specific_trampoline_generic_class_init";
                  D.28476 = MEM[(const unsigned char *)D.28475];
                  D.28477 = (int) D.28476;
                  D.28478 = *__s2;
                  D.28479 = (int) D.28478;
                  __result = D.28477 - D.28479;
                  {
                    D.28480 = __s2_len != 0;
                    D.28481 = __result == 0;
                    D.28482 = D.28480 & D.28481;
                    if (D.28482 != 0) goto <D.28483>; else goto <D.28484>;
                    <D.28483>:
                    D.28485 = &MEM[(void *)"specific_trampoline_generic_class_init" + 1B];
                    D.28486 = *D.28485;
                    D.28487 = (int) D.28486;
                    D.28488 = __s2 + 1;
                    D.28489 = *D.28488;
                    D.28490 = (int) D.28489;
                    __result = D.28487 - D.28490;
                    D.28491 = __s2_len > 1;
                    D.28481 = __result == 0;
                    D.28492 = D.28491 & D.28481;
                    if (D.28492 != 0) goto <D.28493>; else goto <D.28494>;
                    <D.28493>:
                    D.28495 = &MEM[(void *)"specific_trampoline_generic_class_init" + 2B];
                    D.28496 = *D.28495;
                    D.28497 = (int) D.28496;
                    D.28498 = __s2 + 2;
                    D.28499 = *D.28498;
                    D.28500 = (int) D.28499;
                    __result = D.28497 - D.28500;
                    D.28501 = __s2_len > 2;
                    D.28481 = __result == 0;
                    D.28502 = D.28501 & D.28481;
                    if (D.28502 != 0) goto <D.28503>; else goto <D.28504>;
                    <D.28503>:
                    D.28505 = &MEM[(void *)"specific_trampoline_generic_class_init" + 3B];
                    D.28506 = *D.28505;
                    D.28507 = (int) D.28506;
                    D.28508 = __s2 + 3;
                    D.28509 = *D.28508;
                    D.28510 = (int) D.28509;
                    __result = D.28507 - D.28510;
                    <D.28504>:
                    <D.28494>:
                    <D.28484>:
                  }
                  D.24331 = __result;
                }
                iftmp.234 = -D.24331;
                goto <D.28511>;
                <D.28474>:
                D.28233 = ji->data.name;
                iftmp.234 = __builtin_strcmp (D.28233, "specific_trampoline_generic_class_init");
                <D.28511>:
                D.24332 = iftmp.234;
              }
              if (D.24332 == 0) goto <D.28512>; else goto <D.28513>;
              <D.28512>:
              D.28514 = mono_get_root_domain ();
              target = mono_create_specific_trampoline (0B, 3, D.28514, 0B);
              target = mono_create_ftnptr_malloc (target);
              goto <D.28515>;
              <D.28513>:
              {
                size_t __s1_len;
                size_t __s2_len;

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

                  __s2 = ji->data.name;
                  D.28519 = "mono_thread_get_and_clear_pending_exception";
                  D.28520 = MEM[(const unsigned char *)D.28519];
                  D.28521 = (int) D.28520;
                  D.28522 = *__s2;
                  D.28523 = (int) D.28522;
                  __result = D.28521 - D.28523;
                  {
                    D.28524 = __s2_len != 0;
                    D.28525 = __result == 0;
                    D.28526 = D.28524 & D.28525;
                    if (D.28526 != 0) goto <D.28527>; else goto <D.28528>;
                    <D.28527>:
                    D.28529 = &MEM[(void *)"mono_thread_get_and_clear_pending_exception" + 1B];
                    D.28530 = *D.28529;
                    D.28531 = (int) D.28530;
                    D.28532 = __s2 + 1;
                    D.28533 = *D.28532;
                    D.28534 = (int) D.28533;
                    __result = D.28531 - D.28534;
                    D.28535 = __s2_len > 1;
                    D.28525 = __result == 0;
                    D.28536 = D.28535 & D.28525;
                    if (D.28536 != 0) goto <D.28537>; else goto <D.28538>;
                    <D.28537>:
                    D.28539 = &MEM[(void *)"mono_thread_get_and_clear_pending_exception" + 2B];
                    D.28540 = *D.28539;
                    D.28541 = (int) D.28540;
                    D.28542 = __s2 + 2;
                    D.28543 = *D.28542;
                    D.28544 = (int) D.28543;
                    __result = D.28541 - D.28544;
                    D.28545 = __s2_len > 2;
                    D.28525 = __result == 0;
                    D.28546 = D.28545 & D.28525;
                    if (D.28546 != 0) goto <D.28547>; else goto <D.28548>;
                    <D.28547>:
                    D.28549 = &MEM[(void *)"mono_thread_get_and_clear_pending_exception" + 3B];
                    D.28550 = *D.28549;
                    D.28551 = (int) D.28550;
                    D.28552 = __s2 + 3;
                    D.28553 = *D.28552;
                    D.28554 = (int) D.28553;
                    __result = D.28551 - D.28554;
                    <D.28548>:
                    <D.28538>:
                    <D.28528>:
                  }
                  D.24340 = __result;
                }
                iftmp.235 = -D.24340;
                goto <D.28555>;
                <D.28518>:
                D.28233 = ji->data.name;
                iftmp.235 = __builtin_strcmp (D.28233, "mono_thread_get_and_clear_pending_exception");
                <D.28555>:
                D.24341 = iftmp.235;
              }
              if (D.24341 == 0) goto <D.28556>; else goto <D.28557>;
              <D.28556>:
              target = mono_thread_get_and_clear_pending_exception;
              goto <D.28558>;
              <D.28557>:
              D.28233 = ji->data.name;
              D.28559 = strstr (D.28233, "generic_trampoline_");
              if (D.28559 != 0B) goto <D.28560>; else goto <D.28561>;
              <D.28560>:
              D.28233 = ji->data.name;
              target = mono_aot_get_trampoline (D.28233);
              goto <D.28562>;
              <D.28561>:
              aot_jit_icall_hash.236 = aot_jit_icall_hash;
              if (aot_jit_icall_hash.236 != 0B) goto <D.28566>; else goto <D.28563>;
              <D.28566>:
              D.28233 = ji->data.name;
              aot_jit_icall_hash.236 = aot_jit_icall_hash;
              D.28567 = monoeg_g_hash_table_lookup (aot_jit_icall_hash.236, D.28233);
              if (D.28567 != 0B) goto <D.28568>; else goto <D.28563>;
              <D.28568>:
              D.28233 = ji->data.name;
              aot_jit_icall_hash.236 = aot_jit_icall_hash;
              target = monoeg_g_hash_table_lookup (aot_jit_icall_hash.236, D.28233);
              goto <D.28564>;
              <D.28563>:
              D.28233 = ji->data.name;
              stderr.237 = stderr;
              fprintf (stderr.237, "Unknown relocation \'%s\'\n", D.28233);
              monoeg_assertion_message ("* Assertion: should not be reached at %s:%d\n", "aot-runtime.c", 4203);
              target = 0B;
              <D.28564>:
              <D.28562>:
              <D.28558>:
              <D.28515>:
              <D.28471>:
              <D.28427>:
              <D.28383>:
              <D.28371>:
              <D.28365>:
              <D.28322>:
              <D.28279>:
              <D.28236>:
              goto <D.28570>;
              <D.28192>:
              code.217 = code;
              target = mono_resolve_patch_target (0B, 0B, code.217, ji, 0);
              D.28571 = target == 0B;
              D.28572 = (long int) D.28571;
              D.28573 = __builtin_expect (D.28572, 0);
              if (D.28573 != 0) goto <D.28574>; else goto <D.28575>;
              <D.28574>:
              monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "aot-runtime.c", 4211, "target");
              <D.28575>:
              <D.28570>:
              D.28180 = amodule->got;
              got_slots.224 = got_slots;
              pindex.223 = (unsigned int) pindex;
              D.28182 = pindex.223 * 4;
              D.28183 = got_slots.224 + D.28182;
              D.28184 = *D.28183;
              D.28185 = D.28184 * 4;
              D.28186 = D.28180 + D.28185;
              *D.28186 = target;
            }
            <D.24266>:
            pindex = pindex + 1;
            <D.24343>:
            if (pindex < n_patches) goto <D.24342>; else goto <D.24344>;
            <D.24344>:
            got_slots.224 = got_slots;
            monoeg_g_free (got_slots.224);
            mono_mempool_destroy (mp);
          }
        finally
          {
            got_slots = {CLOBBER};
          }
      }
      <D.28172>:
      D.28161 = code;
      return D.28161;
    }
  finally
    {
      p = {CLOBBER};
      code = {CLOBBER};
    }
}


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

  D.28578 = code;
  return D.28578;
}


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

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


mono_aot_create_specific_trampoline (struct MonoImage * image, void * arg1, MonoTrampolineType tramp_type, struct MonoDomain * domain, guint32 * code_len)
{
  int inited.238;
  _Bool D.28587;
  long int D.28588;
  long int D.28589;
  _Bool D.28596;
  long int D.28597;
  long int D.28598;
  unsigned int num_trampolines.239;
  unsigned int num_trampolines.240;
  void * D.28603;
  void * D.28606;
  _Bool D.28607;
  long int D.28608;
  long int D.28609;
  struct MonoAotModule * amodule.241;
  void * * D.28616;
  unsigned int got_offset.242;
  unsigned int D.28618;
  void * * D.28619;
  sizetype D.28620;
  sizetype D.28621;
  void * * D.28622;
  unsigned int tramp_size.243;
  void * D.28626;
  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.238 = inited;
      if (inited.238 == 0) goto <D.28583>; else goto <D.28584>;
      <D.28583>:
      {
        int ret;

        ret = pthread_mutex_lock (&aot_mutex.mutex);
        if (ret != 0) goto <D.28585>; else goto <D.28586>;
        <D.28585>:
        monoeg_g_log (0B, 16, "Bad call to mono_mutex_lock result %d", ret);
        <D.28586>:
        D.28587 = ret != 0;
        D.28588 = (long int) D.28587;
        D.28589 = __builtin_expect (D.28588, 0);
        if (D.28589 != 0) goto <D.28590>; else goto <D.28591>;
        <D.28590>:
        monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "aot-runtime.c", 4494, "ret == 0");
        <D.28591>:
      }
      inited.238 = inited;
      if (inited.238 == 0) goto <D.28592>; else goto <D.28593>;
      <D.28592>:
      mono_counters_register ("Specific trampolines", 256, &num_trampolines);
      inited = 1;
      <D.28593>:
      {
        int ret;

        ret = pthread_mutex_unlock (&aot_mutex.mutex);
        if (ret != 0) goto <D.28594>; else goto <D.28595>;
        <D.28594>:
        monoeg_g_log (0B, 16, "Bad call to mono_mutex_unlock result %d", ret);
        <D.28595>:
        D.28596 = ret != 0;
        D.28597 = (long int) D.28596;
        D.28598 = __builtin_expect (D.28597, 0);
        if (D.28598 != 0) goto <D.28599>; else goto <D.28600>;
        <D.28599>:
        monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "aot-runtime.c", 4501, "ret == 0");
        <D.28600>:
      }
      <D.28584>:
      num_trampolines.239 = num_trampolines;
      num_trampolines.240 = num_trampolines.239 + 1;
      num_trampolines = num_trampolines.240;
      D.28603 = generic_trampolines[tramp_type];
      if (D.28603 == 0B) goto <D.28604>; else goto <D.28605>;
      <D.28604>:
      {
        char * symbol;

        symbol = mono_get_generic_trampoline_name (tramp_type);
        D.28606 = mono_aot_get_trampoline (symbol);
        generic_trampolines[tramp_type] = D.28606;
        monoeg_g_free (symbol);
      }
      <D.28605>:
      tramp = generic_trampolines[tramp_type];
      D.28607 = tramp == 0B;
      D.28608 = (long int) D.28607;
      D.28609 = __builtin_expect (D.28608, 0);
      if (D.28609 != 0) goto <D.28610>; else goto <D.28611>;
      <D.28610>:
      monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "aot-runtime.c", 4515, "tramp");
      <D.28611>:
      if (0 != 0) goto <D.28612>; else goto <D.28613>;
      <D.28612>:
      code = get_new_specific_trampoline_from_page (tramp, arg1);
      tramp_size = 8;
      goto <D.28614>;
      <D.28613>:
      code = get_numerous_trampoline (0, 2, &amodule, &got_offset, &tramp_size);
      amodule.241 = amodule;
      D.28616 = amodule.241->got;
      got_offset.242 = got_offset;
      D.28618 = got_offset.242 * 4;
      D.28619 = D.28616 + D.28618;
      *D.28619 = tramp;
      amodule.241 = amodule;
      D.28616 = amodule.241->got;
      got_offset.242 = got_offset;
      D.28620 = got_offset.242 + 1;
      D.28621 = D.28620 * 4;
      D.28622 = D.28616 + D.28621;
      *D.28622 = arg1;
      <D.28614>:
      if (code_len != 0B) goto <D.28623>; else goto <D.28624>;
      <D.28623>:
      tramp_size.243 = tramp_size;
      *code_len = tramp_size.243;
      <D.28624>:
      D.28626 = code;
      return D.28626;
    }
  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.28629;
  long int D.28630;
  long int D.28631;
  _Bool D.28636;
  long int D.28637;
  long int D.28638;
  _Bool D.28641;
  long int D.28642;
  long int D.28643;
  unsigned int D.28646;
  unsigned int D.28647;
  char * D.28650;
  unsigned int D.28651;
  unsigned int D.28652;
  _Bool D.28655;
  long int D.28656;
  long int D.28657;
  unsigned int D.28660;
  int D.28661;
  unsigned int D.28662;
  unsigned int D.28663;
  unsigned int D.28664;
  unsigned int tramp_size.244;
  void * D.28668;
  guint8 * D.28669;
  int D.28670;
  sizetype D.28671;
  struct MonoAotModule * amodule;
  int index;
  int tramp_size;
  struct MonoImage * image;

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

    ret = pthread_mutex_lock (&aot_mutex.mutex);
    if (ret != 0) goto <D.28634>; else goto <D.28635>;
    <D.28634>:
    monoeg_g_log (0B, 16, "Bad call to mono_mutex_lock result %d", ret);
    <D.28635>:
    D.28636 = ret != 0;
    D.28637 = (long int) D.28636;
    D.28638 = __builtin_expect (D.28637, 0);
    if (D.28638 != 0) goto <D.28639>; else goto <D.28640>;
    <D.28639>:
    monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "aot-runtime.c", 4450, "ret == 0");
    <D.28640>:
  }
  amodule = image->aot_module;
  D.28641 = amodule == 0B;
  D.28642 = (long int) D.28641;
  D.28643 = __builtin_expect (D.28642, 0);
  if (D.28643 != 0) goto <D.28644>; else goto <D.28645>;
  <D.28644>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "aot-runtime.c", 4453, "amodule");
  <D.28645>:
  *out_amodule = amodule;
  D.28646 = amodule->trampoline_index[tramp_type];
  D.28647 = amodule->info.num_trampolines[tramp_type];
  if (D.28646 == D.28647) goto <D.28648>; else goto <D.28649>;
  <D.28648>:
  D.28647 = amodule->info.num_trampolines[tramp_type];
  D.28650 = image->name;
  monoeg_g_log (0B, 4, "Ran out of trampolines of type %d in \'%s\' (%d)%s\n", tramp_type, D.28650, D.28647, "");
  <D.24397>:
  goto <D.24397>;
  <D.28649>:
  D.28646 = amodule->trampoline_index[tramp_type];
  D.28651 = D.28646;
  D.28652 = D.28651 + 1;
  amodule->trampoline_index[tramp_type] = D.28652;
  index = (int) D.28651;
  {
    int ret;

    ret = pthread_mutex_unlock (&aot_mutex.mutex);
    if (ret != 0) goto <D.28653>; else goto <D.28654>;
    <D.28653>:
    monoeg_g_log (0B, 16, "Bad call to mono_mutex_unlock result %d", ret);
    <D.28654>:
    D.28655 = ret != 0;
    D.28656 = (long int) D.28655;
    D.28657 = __builtin_expect (D.28656, 0);
    if (D.28657 != 0) goto <D.28658>; else goto <D.28659>;
    <D.28658>:
    monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "aot-runtime.c", 4468, "ret == 0");
    <D.28659>:
  }
  D.28660 = amodule->info.trampoline_got_offset_base[tramp_type];
  D.28661 = index * n_got_slots;
  D.28662 = (unsigned int) D.28661;
  D.28663 = D.28660 + D.28662;
  *got_offset = D.28663;
  D.28664 = amodule->info.trampoline_size[tramp_type];
  tramp_size = (int) D.28664;
  if (out_tramp_size != 0B) goto <D.28665>; else goto <D.28666>;
  <D.28665>:
  tramp_size.244 = (unsigned int) tramp_size;
  *out_tramp_size = tramp_size.244;
  <D.28666>:
  D.28669 = amodule->trampolines[tramp_type];
  D.28670 = index * tramp_size;
  D.28671 = (sizetype) D.28670;
  D.28668 = D.28669 + D.28671;
  return D.28668;
}


mono_aot_get_static_rgctx_trampoline (void * ctx, void * addr)
{
  struct MonoAotModule * amodule.245;
  void * * D.28677;
  unsigned int got_offset.246;
  unsigned int D.28679;
  void * * D.28680;
  sizetype D.28681;
  sizetype D.28682;
  void * * D.28683;
  void * D.28684;
  struct MonoDomain * D.28685;
  struct MonoAotModule * amodule;
  guint8 * code;
  guint32 got_offset;

  try
    {
      if (0 != 0) goto <D.28673>; else goto <D.28674>;
      <D.28673>:
      code = get_new_rgctx_trampoline_from_page (addr, ctx);
      goto <D.28675>;
      <D.28674>:
      code = get_numerous_trampoline (1, 2, &amodule, &got_offset, 0B);
      amodule.245 = amodule;
      D.28677 = amodule.245->got;
      got_offset.246 = got_offset;
      D.28679 = got_offset.246 * 4;
      D.28680 = D.28677 + D.28679;
      *D.28680 = ctx;
      amodule.245 = amodule;
      D.28677 = amodule.245->got;
      got_offset.246 = got_offset;
      D.28681 = got_offset.246 + 1;
      D.28682 = D.28681 * 4;
      D.28683 = D.28677 + D.28682;
      *D.28683 = addr;
      <D.28675>:
      D.28685 = mono_domain_get ();
      D.28684 = mono_create_ftnptr (D.28685, code);
      return D.28684;
    }
  finally
    {
      amodule = {CLOBBER};
      got_offset = {CLOBBER};
    }
}


mono_aot_get_unbox_trampoline (struct MonoMethod * method)
{
  unsigned int D.28688;
  unsigned int D.28689;
  unsigned char D.28692;
  unsigned char D.28693;
  int D.28695;
  int D.28699;
  _Bool D.28702;
  long int D.28703;
  long int D.28704;
  struct MonoClass * D.28707;
  struct MonoImage * D.28708;
  void * amodule.247;
  struct MonoAotModule * amodule.248;
  _Bool D.28711;
  long int D.28712;
  long int D.28713;
  int ut_end.249;
  int ut.250;
  int D.28718;
  int D.28719;
  int D.28720;
  unsigned int entry_index.251;
  unsigned int D.28722;
  unsigned int D.28723;
  unsigned int D.28730;
  unsigned int D.28731;
  guint32 * D.28734;
  guint8 * D.28736;
  unsigned int D.28737;
  _Bool D.28738;
  long int D.28739;
  long int D.28740;
  void * D.28743;
  struct MonoDomain * D.28744;
  guint32 method_index;
  struct MonoAotModule * amodule;
  void * code;
  guint32 * ut;
  guint32 * ut_end;
  guint32 * entry;
  int low;
  int high;
  int entry_index;

  try
    {
      D.28688 = method->token;
      D.28689 = D.28688 & 16777215;
      method_index = D.28689 + 4294967295;
      D.28692 = BIT_FIELD_REF <*method, 8, 168>;
      D.28693 = D.28692 & 16;
      if (D.28693 != 0) goto <D.28694>; else goto <D.28690>;
      <D.28694>:
      D.28695 = mono_method_is_generic_sharable_full (method, 0, 0, 0);
      if (D.28695 == 0) goto <D.28696>; else goto <D.28690>;
      <D.28696>:
      method_index = find_extra_method (method, &amodule);
      if (method_index == 16777215) goto <D.28697>; else goto <D.28698>;
      <D.28697>:
      D.28699 = mono_method_is_generic_sharable_full (method, 0, 0, 1);
      if (D.28699 != 0) goto <D.28700>; else goto <D.28701>;
      <D.28700>:
      {
        struct MonoMethod * shared;

        shared = mini_get_shared_method_full (method, 1, 1);
        method_index = find_extra_method (shared, &amodule);
      }
      <D.28701>:
      <D.28698>:
      D.28702 = method_index == 16777215;
      D.28703 = (long int) D.28702;
      D.28704 = __builtin_expect (D.28703, 0);
      if (D.28704 != 0) goto <D.28705>; else goto <D.28706>;
      <D.28705>:
      monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "aot-runtime.c", 4568, "method_index != 0xffffff");
      <D.28706>:
      goto <D.28691>;
      <D.28690>:
      D.28707 = method->klass;
      D.28708 = D.28707->image;
      amodule.247 = D.28708->aot_module;
      amodule = amodule.247;
      amodule.248 = amodule;
      D.28711 = amodule.248 == 0B;
      D.28712 = (long int) D.28711;
      D.28713 = __builtin_expect (D.28712, 0);
      if (D.28713 != 0) goto <D.28714>; else goto <D.28715>;
      <D.28714>:
      monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "aot-runtime.c", 4571, "amodule");
      <D.28715>:
      <D.28691>:
      amodule.248 = amodule;
      ut = amodule.248->unbox_trampolines;
      amodule.248 = amodule;
      ut_end = amodule.248->unbox_trampolines_end;
      code = 0B;
      low = 0;
      ut_end.249 = (int) ut_end;
      ut.250 = (int) ut;
      D.28718 = ut_end.249 - ut.250;
      D.28719 = D.28718 /[ex] 4;
      high = D.28719 / 2;
      goto <D.24439>;
      <D.24438>:
      D.28720 = low + high;
      entry_index = D.28720 / 2;
      entry_index.251 = (unsigned int) entry_index;
      D.28722 = entry_index.251 * 8;
      entry = ut + D.28722;
      D.28723 = *entry;
      if (D.28723 < method_index) goto <D.28724>; else goto <D.28725>;
      <D.28724>:
      low = entry_index + 1;
      goto <D.28726>;
      <D.28725>:
      D.28723 = *entry;
      if (D.28723 > method_index) goto <D.28727>; else goto <D.28728>;
      <D.28727>:
      high = entry_index;
      goto <D.28729>;
      <D.28728>:
      amodule.248 = amodule;
      D.28730 = amodule.248->info.flags;
      D.28731 = D.28730 & 8;
      if (D.28731 != 0) goto <D.28732>; else goto <D.28733>;
      <D.28732>:
      D.28734 = entry + 4;
      code = get_arm_bl_target (D.28734);
      goto <D.28735>;
      <D.28733>:
      amodule.248 = amodule;
      D.28736 = amodule.248->code;
      D.28734 = entry + 4;
      D.28737 = *D.28734;
      code = D.28736 + D.28737;
      <D.28735>:
      goto <D.24437>;
      <D.28729>:
      <D.28726>:
      <D.24439>:
      if (low < high) goto <D.24438>; else goto <D.24437>;
      <D.24437>:
      D.28738 = code == 0B;
      D.28739 = (long int) D.28738;
      D.28740 = __builtin_expect (D.28739, 0);
      if (D.28740 != 0) goto <D.28741>; else goto <D.28742>;
      <D.28741>:
      monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "aot-runtime.c", 4596, "code");
      <D.28742>:
      D.28744 = mono_domain_get ();
      D.28743 = mono_create_ftnptr (D.28744, code);
      return D.28743;
    }
  finally
    {
      amodule = {CLOBBER};
    }
}


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

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


mono_aot_get_lazy_fetch_trampoline (guint32 slot)
{
  struct MonoImage * D.28749;
  int count.252;
  int count.253;
  unsigned int D.28752;
  void * addr.254;
  void * addr.255;
  struct MonoDomain * D.28759;
  void * slot.256;
  void * * D.28761;
  struct MonoDomain * D.28762;
  void * D.28763;
  void * D.28764;
  struct MonoDomain * D.28765;
  int slot.257;
  void * D.28767;
  struct MonoDomain * D.28768;
  char * symbol;
  void * code;
  struct MonoAotModule * amodule;
  guint32 index;
  static int count = 0;

  D.28749 = mono_defaults.corlib;
  amodule = D.28749->aot_module;
  index = slot & 2147483647;
  count.252 = count;
  count.253 = count.252 + 1;
  count = count.253;
  D.28752 = amodule->info.num_rgctx_fetch_trampolines;
  if (D.28752 <= index) goto <D.28753>; else goto <D.28754>;
  <D.28753>:
  {
    static void * addr;
    void * * info;

    addr.254 = addr;
    if (addr.254 == 0B) goto <D.28756>; else goto <D.28757>;
    <D.28756>:
    addr.255 = load_function (amodule, "rgctx_fetch_trampoline_general");
    addr = addr.255;
    <D.28757>:
    D.28759 = mono_get_root_domain ();
    info = mono_domain_alloc0 (D.28759, 8);
    slot.256 = (void *) slot;
    *info = slot.256;
    D.28761 = info + 4;
    D.28762 = mono_get_root_domain ();
    slot.256 = (void *) slot;
    D.28763 = mono_create_specific_trampoline (slot.256, 4, D.28762, 0B);
    *D.28761 = D.28763;
    addr.254 = addr;
    code = mono_aot_get_static_rgctx_trampoline (info, addr.254);
    D.28765 = mono_domain_get ();
    D.28764 = mono_create_ftnptr (D.28765, code);
    return D.28764;
  }
  <D.28754>:
  slot.257 = (int) slot;
  symbol = mono_get_rgctx_fetch_trampoline_name (slot.257);
  D.28749 = mono_defaults.corlib;
  D.28767 = D.28749->aot_module;
  code = load_function (D.28767, symbol);
  monoeg_g_free (symbol);
  D.28768 = mono_domain_get ();
  D.28764 = mono_create_ftnptr (D.28768, code);
  return D.28764;
}


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

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


mono_aot_get_imt_thunk (struct MonoVTable * vtable, struct MonoDomain * domain, struct MonoIMTCheckItem * * imt_entries, int count, void * fail_tramp)
{
  unsigned int i.258;
  unsigned int D.28773;
  struct MonoIMTCheckItem * * D.28774;
  unsigned char D.28775;
  int D.28778;
  unsigned int D.28779;
  unsigned int D.28780;
  unsigned char D.28781;
  void * D.28784;
  _Bool D.28785;
  long int D.28786;
  long int D.28787;
  unsigned int index.259;
  unsigned int D.28791;
  void * * D.28792;
  unsigned char D.28793;
  void * D.28796;
  sizetype index.260;
  sizetype D.28798;
  sizetype D.28799;
  void * * D.28800;
  int D.28802;
  void * * D.28803;
  struct MonoAotModule * amodule.261;
  void * * D.28808;
  unsigned int got_offset.262;
  unsigned int D.28810;
  void * * D.28811;
  void * D.28812;
  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.24466>;
      <D.24465>:
      {
        struct MonoIMTCheckItem * item;

        i.258 = (unsigned int) i;
        D.28773 = i.258 * 4;
        D.28774 = imt_entries + D.28773;
        item = *D.28774;
        D.28775 = item->is_equals;
        if (D.28775 != 0) goto <D.28776>; else goto <D.28777>;
        <D.28776>:
        real_count = real_count + 1;
        <D.28777>:
      }
      i = i + 1;
      <D.24466>:
      if (i < count) goto <D.24465>; else goto <D.24467>;
      <D.24467>:
      D.28778 = real_count + 1;
      D.28779 = (unsigned int) D.28778;
      D.28780 = D.28779 * 8;
      buf = mono_domain_alloc (domain, D.28780);
      index = 0;
      i = 0;
      goto <D.24472>;
      <D.24471>:
      {
        struct MonoIMTCheckItem * item;

        i.258 = (unsigned int) i;
        D.28773 = i.258 * 4;
        D.28774 = imt_entries + D.28773;
        item = *D.28774;
        D.28781 = item->is_equals;
        if (D.28781 == 0) goto <D.28782>; else goto <D.28783>;
        <D.28782>:
        // predicted unlikely by continue predictor.
        goto <D.24469>;
        <D.28783>:
        D.28784 = item->key;
        D.28785 = D.28784 == 0B;
        D.28786 = (long int) D.28785;
        D.28787 = __builtin_expect (D.28786, 0);
        if (D.28787 != 0) goto <D.28788>; else goto <D.28789>;
        <D.28788>:
        monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "aot-runtime.c", 4661, "item->key");
        <D.28789>:
        index.259 = (unsigned int) index;
        D.28791 = index.259 * 8;
        D.28792 = buf + D.28791;
        D.28784 = item->key;
        *D.28792 = D.28784;
        D.28793 = item->has_target_code;
        if (D.28793 != 0) goto <D.28794>; else goto <D.28795>;
        <D.28794>:
        {
          void * * p;

          p = mono_domain_alloc (domain, 4);
          D.28796 = item->value.target_code;
          *p = D.28796;
          index.260 = (sizetype) index;
          D.28798 = index.260 * 8;
          D.28799 = D.28798 + 4;
          D.28800 = buf + D.28799;
          *D.28800 = p;
        }
        goto <D.28801>;
        <D.28795>:
        index.260 = (sizetype) index;
        D.28798 = index.260 * 8;
        D.28799 = D.28798 + 4;
        D.28800 = buf + D.28799;
        D.28802 = item->value.vtable_slot;
        D.28803 = &vtable->vtable[D.28802];
        *D.28800 = D.28803;
        <D.28801>:
        index = index + 1;
      }
      <D.24469>:
      i = i + 1;
      <D.24472>:
      if (i < count) goto <D.24471>; else goto <D.24473>;
      <D.24473>:
      index.259 = (unsigned int) index;
      D.28791 = index.259 * 8;
      D.28792 = buf + D.28791;
      *D.28792 = 0B;
      index.260 = (sizetype) index;
      D.28798 = index.260 * 8;
      D.28799 = D.28798 + 4;
      D.28800 = buf + D.28799;
      *D.28800 = fail_tramp;
      if (0 != 0) goto <D.28804>; else goto <D.28805>;
      <D.28804>:
      code = get_new_imt_trampoline_from_page (buf);
      goto <D.28806>;
      <D.28805>:
      code = get_numerous_trampoline (2, 1, &amodule, &got_offset, 0B);
      amodule.261 = amodule;
      D.28808 = amodule.261->got;
      got_offset.262 = got_offset;
      D.28810 = got_offset.262 * 4;
      D.28811 = D.28808 + D.28810;
      *D.28811 = buf;
      <D.28806>:
      D.28812 = code;
      return D.28812;
    }
  finally
    {
      got_offset = {CLOBBER};
      amodule = {CLOBBER};
    }
}


mono_aot_get_gsharedvt_arg_trampoline (void * arg, void * addr)
{
  struct MonoAotModule * amodule.263;
  void * * D.28819;
  unsigned int got_offset.264;
  unsigned int D.28821;
  void * * D.28822;
  sizetype D.28823;
  sizetype D.28824;
  void * * D.28825;
  void * D.28826;
  struct MonoDomain * D.28827;
  struct MonoAotModule * amodule;
  guint8 * code;
  guint32 got_offset;

  try
    {
      if (0 != 0) goto <D.28815>; else goto <D.28816>;
      <D.28815>:
      code = get_new_gsharedvt_arg_trampoline_from_page (addr, arg);
      goto <D.28817>;
      <D.28816>:
      code = get_numerous_trampoline (3, 2, &amodule, &got_offset, 0B);
      amodule.263 = amodule;
      D.28819 = amodule.263->got;
      got_offset.264 = got_offset;
      D.28821 = got_offset.264 * 4;
      D.28822 = D.28819 + D.28821;
      *D.28822 = arg;
      amodule.263 = amodule;
      D.28819 = amodule.263->got;
      got_offset.264 = got_offset;
      D.28823 = got_offset.264 + 1;
      D.28824 = D.28823 * 4;
      D.28825 = D.28819 + D.28824;
      *D.28825 = addr;
      <D.28817>:
      D.28827 = mono_domain_get ();
      D.28826 = mono_create_ftnptr (D.28827, code);
      return D.28826;
    }
  finally
    {
      amodule = {CLOBBER};
      got_offset = {CLOBBER};
    }
}


mono_aot_set_make_unreadable (gboolean unreadable)
{
  int make_unreadable.265;
  int inited.266;
  static int inited;

  make_unreadable = unreadable;
  make_unreadable.265 = make_unreadable;
  if (make_unreadable.265 != 0) goto <D.28831>; else goto <D.28832>;
  <D.28831>:
  inited.266 = inited;
  if (inited.266 == 0) goto <D.28834>; else goto <D.28835>;
  <D.28834>:
  mono_counters_register ("AOT pagefaults", 256, &n_pagefaults);
  <D.28835>:
  <D.28832>:
}


mono_aot_is_pagefault (void * ptr)
{
  int make_unreadable.267;
  gboolean D.28839;
  struct MonoAotModule * D.28840;
  _Bool D.28841;

  make_unreadable.267 = make_unreadable;
  if (make_unreadable.267 == 0) goto <D.28837>; else goto <D.28838>;
  <D.28837>:
  D.28839 = 0;
  return D.28839;
  <D.28838>:
  D.28840 = find_module_for_addr (ptr);
  D.28841 = D.28840 != 0B;
  D.28839 = (gboolean) D.28841;
  return D.28839;
}


find_module_for_addr (void * ptr)
{
  int make_unreadable.268;
  struct MonoAotModule * D.28846;
  _Bool D.28849;
  long int D.28850;
  long int D.28851;
  struct GHashTable * aot_modules.269;
  _Bool D.28857;
  long int D.28858;
  long int D.28859;
  struct FindMapUserData data;

  try
    {
      make_unreadable.268 = make_unreadable;
      if (make_unreadable.268 == 0) goto <D.28844>; else goto <D.28845>;
      <D.28844>:
      D.28846 = 0B;
      return D.28846;
      <D.28845>:
      data.module = 0B;
      data.ptr = ptr;
      {
        int ret;

        ret = pthread_mutex_lock (&aot_mutex.mutex);
        if (ret != 0) goto <D.28847>; else goto <D.28848>;
        <D.28847>:
        monoeg_g_log (0B, 16, "Bad call to mono_mutex_lock result %d", ret);
        <D.28848>:
        D.28849 = ret != 0;
        D.28850 = (long int) D.28849;
        D.28851 = __builtin_expect (D.28850, 0);
        if (D.28851 != 0) goto <D.28852>; else goto <D.28853>;
        <D.28852>:
        monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "aot-runtime.c", 4752, "ret == 0");
        <D.28853>:
      }
      aot_modules.269 = aot_modules;
      monoeg_g_hash_table_foreach (aot_modules.269, find_map, &data);
      {
        int ret;

        ret = pthread_mutex_unlock (&aot_mutex.mutex);
        if (ret != 0) goto <D.28855>; else goto <D.28856>;
        <D.28855>:
        monoeg_g_log (0B, 16, "Bad call to mono_mutex_unlock result %d", ret);
        <D.28856>:
        D.28857 = ret != 0;
        D.28858 = (long int) D.28857;
        D.28859 = __builtin_expect (D.28858, 0);
        if (D.28859 != 0) goto <D.28860>; else goto <D.28861>;
        <D.28860>:
        monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "aot-runtime.c", 4754, "ret == 0");
        <D.28861>:
      }
      D.28846 = data.module;
      return D.28846;
    }
  finally
    {
      data = {CLOBBER};
    }
}


find_map (void * key, void * value, void * user_data)
{
  struct MonoAotModule * D.28864;
  guint8 * D.28867;
  guint8 * D.28868;
  guint8 * D.28871;
  struct MonoAotModule * module;
  struct FindMapUserData * data;

  module = value;
  data = user_data;
  D.28864 = data->module;
  if (D.28864 == 0B) goto <D.28865>; else goto <D.28866>;
  <D.28865>:
  D.28867 = data->ptr;
  D.28868 = module->mem_begin;
  if (D.28867 >= D.28868) goto <D.28869>; else goto <D.28870>;
  <D.28869>:
  D.28867 = data->ptr;
  D.28871 = module->mem_end;
  if (D.28867 < D.28871) goto <D.28872>; else goto <D.28873>;
  <D.28872>:
  data->module = module;
  <D.28873>:
  <D.28870>:
  <D.28866>:
}


mono_aot_handle_pagefault (void * ptr)
{
  int D.28874;
  int D.28875;
  int ptr.270;
  int D.28877;
  _Bool D.28880;
  long int D.28881;
  long int D.28882;
  int D.28885;
  unsigned int D.28886;
  _Bool D.28887;
  long int D.28888;
  long int D.28889;
  unsigned int n_pagefaults.271;
  unsigned int n_pagefaults.272;
  _Bool D.28896;
  long int D.28897;
  long int D.28898;
  guint8 * start;
  int res;

  D.28874 = mono_pagesize ();
  D.28875 = -D.28874;
  ptr.270 = (int) ptr;
  D.28877 = D.28875 & ptr.270;
  start = (guint8 *) D.28877;
  {
    int ret;

    ret = pthread_mutex_lock (&aot_mutex.mutex);
    if (ret != 0) goto <D.28878>; else goto <D.28879>;
    <D.28878>:
    monoeg_g_log (0B, 16, "Bad call to mono_mutex_lock result %d", ret);
    <D.28879>:
    D.28880 = ret != 0;
    D.28881 = (long int) D.28880;
    D.28882 = __builtin_expect (D.28881, 0);
    if (D.28882 != 0) goto <D.28883>; else goto <D.28884>;
    <D.28883>:
    monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "aot-runtime.c", 4790, "ret == 0");
    <D.28884>:
  }
  D.28885 = mono_pagesize ();
  D.28886 = (unsigned int) D.28885;
  res = mono_mprotect (start, D.28886, 7);
  D.28887 = res != 0;
  D.28888 = (long int) D.28887;
  D.28889 = __builtin_expect (D.28888, 0);
  if (D.28889 != 0) goto <D.28890>; else goto <D.28891>;
  <D.28890>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "aot-runtime.c", 4792, "res == 0");
  <D.28891>:
  n_pagefaults.271 = n_pagefaults;
  n_pagefaults.272 = n_pagefaults.271 + 1;
  n_pagefaults = n_pagefaults.272;
  {
    int ret;

    ret = pthread_mutex_unlock (&aot_mutex.mutex);
    if (ret != 0) goto <D.28894>; else goto <D.28895>;
    <D.28894>:
    monoeg_g_log (0B, 16, "Bad call to mono_mutex_unlock result %d", ret);
    <D.28895>:
    D.28896 = ret != 0;
    D.28897 = (long int) D.28896;
    D.28898 = __builtin_expect (D.28897, 0);
    if (D.28898 != 0) goto <D.28899>; else goto <D.28900>;
    <D.28899>:
    monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "aot-runtime.c", 4795, "ret == 0");
    <D.28900>:
  }
}