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.24949;
  _Bool D.24950;
  long int D.24951;
  long int D.24952;
  _Bool D.24955;
  long int D.24956;
  long int D.24957;
  struct GHashTable * aot_modules.0;
  _Bool D.24965;
  long int D.24966;
  long int D.24967;
  struct GHashTable * static_aot_modules.1;
  struct GHashTable * static_aot_modules.2;
  _Bool D.24978;
  long int D.24979;
  long int D.24980;
  void * * globals;
  char * aname;
  struct MonoAotFileInfo * info;

  info = aot_info;
  D.24949 = info->version;
  D.24950 = D.24949 != 97;
  D.24951 = (long int) D.24950;
  D.24952 = __builtin_expect (D.24951, 0);
  if (D.24952 != 0) goto <D.24953>; else goto <D.24954>;
  <D.24953>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "aot-runtime.c", 1889, "info->version == MONO_AOT_FILE_VERSION");
  <D.24954>:
  globals = info->globals;
  D.24955 = globals == 0B;
  D.24956 = (long int) D.24955;
  D.24957 = __builtin_expect (D.24956, 0);
  if (D.24957 != 0) goto <D.24958>; else goto <D.24959>;
  <D.24958>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "aot-runtime.c", 1892, "globals");
  <D.24959>:
  aname = info->assembly_name;
  aot_modules.0 = aot_modules;
  if (aot_modules.0 != 0B) goto <D.24961>; else goto <D.24962>;
  <D.24961>:
  {
    int ret;

    ret = pthread_mutex_lock (&aot_mutex.mutex);
    if (ret != 0) goto <D.24963>; else goto <D.24964>;
    <D.24963>:
    monoeg_g_log (0B, 16, "Bad call to mono_mutex_lock result %d", ret);
    <D.24964>:
    D.24965 = ret != 0;
    D.24966 = (long int) D.24965;
    D.24967 = __builtin_expect (D.24966, 0);
    if (D.24967 != 0) goto <D.24968>; else goto <D.24969>;
    <D.24968>:
    monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "aot-runtime.c", 1898, "ret == 0");
    <D.24969>:
  }
  <D.24962>:
  static_aot_modules.1 = static_aot_modules;
  if (static_aot_modules.1 == 0B) goto <D.24971>; else goto <D.24972>;
  <D.24971>:
  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.24972>:
  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.24974>; else goto <D.24975>;
  <D.24974>:
  {
    int ret;

    ret = pthread_mutex_unlock (&aot_mutex.mutex);
    if (ret != 0) goto <D.24976>; else goto <D.24977>;
    <D.24976>:
    monoeg_g_log (0B, 16, "Bad call to mono_mutex_unlock result %d", ret);
    <D.24977>:
    D.24978 = ret != 0;
    D.24979 = (long int) D.24978;
    D.24980 = __builtin_expect (D.24979, 0);
    if (D.24980 != 0) goto <D.24981>; else goto <D.24982>;
    <D.24981>:
    monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "aot-runtime.c", 1906, "ret == 0");
    <D.24982>:
  }
  <D.24975>:
}


mono_aot_init ()
{
  struct GHashTable * aot_modules.3;
  const gchar * D.24984;
  const gchar * D.24987;
  int mono_last_aot_method.4;
  const gchar * D.24989;

  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.24984 = monoeg_g_getenv ("MONO_LASTAOT");
  if (D.24984 != 0B) goto <D.24985>; else goto <D.24986>;
  <D.24985>:
  D.24987 = monoeg_g_getenv ("MONO_LASTAOT");
  mono_last_aot_method.4 = atoi (D.24987);
  mono_last_aot_method = mono_last_aot_method.4;
  <D.24986>:
  D.24989 = monoeg_g_getenv ("MONO_AOT_CACHE");
  if (D.24989 != 0B) goto <D.24990>; else goto <D.24991>;
  <D.24990>:
  use_aot_cache = 1;
  <D.24991>:
}


load_aot_module (struct MonoAssembly * assembly, void * user_data)
{
  int mono_compile_aot.5;
  struct MonoImage * D.24995;
  void * D.24996;
  unsigned char D.25001;
  unsigned char D.25002;
  int D.25004;
  <unnamed type> D.25005;
  _Bool D.25010;
  long int D.25011;
  long int D.25012;
  struct GHashTable * static_aot_modules.6;
  const char * D.25018;
  void * info.7;
  _Bool D.25023;
  long int D.25024;
  long int D.25025;
  struct MonoAotFileInfo * info.8;
  gchar * aot_name.9;
  char * aot_name.10;
  int use_aot_cache.11;
  char * D.25038;
  gchar * aot_name.12;
  char * err.13;
  _Bool D.25043;
  _Bool D.25044;
  _Bool D.25045;
  int mono_aot_only.14;
  unsigned int D.25051;
  unsigned int D.25052;
  struct _IO_FILE * stderr.15;
  char * version_symbol.16;
  _Bool D.25062;
  long int D.25063;
  long int D.25064;
  unsigned int D.25067;
  gchar * msg.17;
  char * msg.18;
  unsigned int D.25079;
  unsigned int align_double.19;
  _Bool D.25081;
  long int D.25082;
  long int D.25083;
  unsigned int D.25086;
  unsigned int align_int64.20;
  _Bool D.25088;
  long int D.25089;
  long int D.25090;
  unsigned int D.25093;
  _Bool D.25094;
  long int D.25095;
  long int D.25096;
  struct MonoAotFileInfo * D.25099;
  void * D.25100;
  void * * D.25101;
  struct GHashTable * D.25102;
  _Bool D.25103;
  long int D.25104;
  long int D.25105;
  long unsigned int D.25108;
  long unsigned int D.25109;
  void * D.25110;
  long unsigned int D.25111;
  void * D.25112;
  void * D.25113;
  struct MonoAssemblyName * D.25114;
  long unsigned int D.25115;
  long unsigned int D.25116;
  gchar * D.25117;
  long unsigned int D.25118;
  sizetype D.25119;
  char * * D.25120;
  long unsigned int D.25121;
  char * * D.25122;
  gchar * D.25123;
  long unsigned int D.25124;
  sizetype D.25125;
  char D.25126;
  gchar * D.25129;
  long unsigned int D.25130;
  sizetype D.25131;
  long unsigned int D.25132;
  long unsigned int D.25133;
  mono_byte[17] * D.25134;
  long unsigned int D.25135;
  sizetype D.25136;
  long int table.21;
  long int D.25138;
  long int D.25139;
  unsigned int D.25140;
  short unsigned int D.25141;
  void * D.25142;
  void * D.25143;
  void * D.25144;
  void * D.25145;
  void * D.25146;
  void * D.25147;
  void * D.25148;
  void * D.25149;
  void * D.25150;
  void * D.25151;
  void * D.25152;
  void * D.25153;
  void * D.25154;
  void * D.25155;
  void * D.25156;
  guint8 * D.25157;
  void * D.25158;
  void * D.25159;
  void * D.25160;
  void * D.25161;
  void * D.25162;
  void * D.25163;
  void * D.25164;
  void * D.25165;
  int make_unreadable.22;
  guint8 * D.25169;
  long int D.25170;
  guint8 * D.25171;
  long int D.25172;
  long int D.25173;
  int D.25174;
  sizetype D.25175;
  int D.25176;
  int D.25177;
  long int D.25178;
  long int addr.23;
  long int D.25180;
  sizetype D.25181;
  sizetype D.25182;
  sizetype D.25183;
  guint8 * D.25184;
  long int D.25185;
  int D.25186;
  int D.25187;
  long int D.25188;
  long int D.25189;
  long int page_end.24;
  long int page_start.25;
  long int D.25194;
  long unsigned int D.25195;
  _Bool D.25196;
  long int D.25197;
  long int D.25198;
  _Bool D.25203;
  long int D.25204;
  long int D.25205;
  long unsigned int D.25208;
  long unsigned int aot_code_low_addr.26;
  long unsigned int aot_code_low_addr.27;
  guint8 * D.25211;
  long unsigned int D.25212;
  long unsigned int aot_code_high_addr.28;
  long unsigned int aot_code_high_addr.29;
  struct GHashTable * aot_modules.30;
  _Bool D.25218;
  long int D.25219;
  long int D.25220;
  void * * D.25225;
  struct MonoDl * D.25226;
  char * code.31;
  _Bool D.25228;
  int D.25229;
  struct MonoImage * D.25230;
  void * * D.25233;
  void * * D.25234;
  int D.25236;
  void * * D.25239;
  struct MonoDomain * D.25240;
  void * D.25241;
  unsigned int i.32;
  unsigned int D.25245;
  int D.25246;
  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.24993>; else goto <D.24994>;
      <D.24993>:
      return;
      <D.24994>:
      D.24995 = assembly->image;
      D.24996 = D.24995->aot_module;
      if (D.24996 != 0B) goto <D.24997>; else goto <D.24998>;
      <D.24997>:
      return;
      <D.24998>:
      D.24995 = assembly->image;
      D.25001 = BIT_FIELD_REF <*D.24995, 8, 224>;
      D.25002 = D.25001 & 8;
      if (D.25002 != 0) goto <D.24999>; else goto <D.25003>;
      <D.25003>:
      D.25004 = assembly->ref_only;
      if (D.25004 != 0) goto <D.24999>; else goto <D.25000>;
      <D.24999>:
      return;
      <D.25000>:
      D.25005 = mono_security_get_mode ();
      if (D.25005 == 2) goto <D.25006>; else goto <D.25007>;
      <D.25006>:
      return;
      <D.25007>:
      {
        int ret;

        ret = pthread_mutex_lock (&aot_mutex.mutex);
        if (ret != 0) goto <D.25008>; else goto <D.25009>;
        <D.25008>:
        monoeg_g_log (0B, 16, "Bad call to mono_mutex_lock result %d", ret);
        <D.25009>:
        D.25010 = ret != 0;
        D.25011 = (long int) D.25010;
        D.25012 = __builtin_expect (D.25011, 0);
        if (D.25012 != 0) goto <D.25013>; else goto <D.25014>;
        <D.25013>:
        monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "aot-runtime.c", 1577, "ret == 0");
        <D.25014>:
      }
      static_aot_modules.6 = static_aot_modules;
      if (static_aot_modules.6 != 0B) goto <D.25016>; else goto <D.25017>;
      <D.25016>:
      D.25018 = assembly->aname.name;
      static_aot_modules.6 = static_aot_modules;
      info.7 = monoeg_g_hash_table_lookup (static_aot_modules.6, D.25018);
      info = info.7;
      goto <D.25020>;
      <D.25017>:
      info = 0B;
      <D.25020>:
      {
        int ret;

        ret = pthread_mutex_unlock (&aot_mutex.mutex);
        if (ret != 0) goto <D.25021>; else goto <D.25022>;
        <D.25021>:
        monoeg_g_log (0B, 16, "Bad call to mono_mutex_unlock result %d", ret);
        <D.25022>:
        D.25023 = ret != 0;
        D.25024 = (long int) D.25023;
        D.25025 = __builtin_expect (D.25024, 0);
        if (D.25025 != 0) goto <D.25026>; else goto <D.25027>;
        <D.25026>:
        monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "aot-runtime.c", 1582, "ret == 0");
        <D.25027>:
      }
      info.8 = info;
      if (info.8 != 0B) goto <D.25029>; else goto <D.25030>;
      <D.25029>:
      sofile = 0B;
      D.25018 = assembly->aname.name;
      aot_name.9 = monoeg_g_strdup_printf ("%s", D.25018);
      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.25033>;
      <D.25030>:
      use_aot_cache.11 = use_aot_cache;
      if (use_aot_cache.11 != 0) goto <D.25035>; else goto <D.25036>;
      <D.25035>:
      sofile = load_aot_module_from_cache (assembly, &aot_name);
      goto <D.25037>;
      <D.25036>:
      {
        char * err;

        try
          {
            D.24995 = assembly->image;
            D.25038 = D.24995->name;
            aot_name.12 = monoeg_g_strdup_printf ("%s%s", D.25038, ".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.25040>; else goto <D.25041>;
            <D.25040>:
            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.25041>:
          }
        finally
          {
            err = {CLOBBER};
          }
      }
      <D.25037>:
      <D.25033>:
      D.25043 = sofile == 0B;
      D.25044 = globals == 0B;
      D.25045 = D.25043 & D.25044;
      if (D.25045 != 0) goto <D.25046>; else goto <D.25047>;
      <D.25046>:
      mono_aot_only.14 = mono_aot_only;
      if (mono_aot_only.14 != 0) goto <D.25049>; else goto <D.25050>;
      <D.25049>:
      D.24995 = assembly->image;
      D.25051 = BIT_FIELD_REF <*D.24995, 32, 2368>;
      D.25052 = D.25051 & 16777215;
      if (D.25052 != 0) goto <D.25053>; else goto <D.25054>;
      <D.25053>:
      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.25054>:
      <D.25050>:
      aot_name.10 = aot_name;
      monoeg_g_free (aot_name.10);
      return;
      <D.25047>:
      info.8 = info;
      if (info.8 == 0B) goto <D.25056>; else goto <D.25057>;
      <D.25056>:
      find_symbol (sofile, globals, "mono_aot_version", &version_symbol);
      find_symbol (sofile, globals, "mono_aot_file_info", &info);
      <D.25057>:
      version_symbol.16 = version_symbol;
      if (version_symbol.16 != 0B) goto <D.25059>; else goto <D.25060>;
      <D.25059>:
      version_symbol.16 = version_symbol;
      version = atoi (version_symbol.16);
      goto <D.25061>;
      <D.25060>:
      info.8 = info;
      D.25062 = info.8 == 0B;
      D.25063 = (long int) D.25062;
      D.25064 = __builtin_expect (D.25063, 0);
      if (D.25064 != 0) goto <D.25065>; else goto <D.25066>;
      <D.25065>:
      monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "aot-runtime.c", 1624, "info");
      <D.25066>:
      info.8 = info;
      D.25067 = info.8->version;
      version = (int) D.25067;
      <D.25061>:
      if (version != 97) goto <D.25068>; else goto <D.25069>;
      <D.25068>:
      msg.17 = monoeg_g_strdup_printf ("wrong file format version (expected %d got %d)", 97, version);
      msg = msg.17;
      usable = 0;
      goto <D.25071>;
      <D.25069>:
      info.8 = info;
      usable = check_usable (assembly, info.8, &msg);
      <D.25071>:
      if (usable == 0) goto <D.25072>; else goto <D.25073>;
      <D.25072>:
      mono_aot_only.14 = mono_aot_only;
      if (mono_aot_only.14 != 0) goto <D.25074>; else goto <D.25075>;
      <D.25074>:
      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.25075>:
      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.25077>; else goto <D.25078>;
      <D.25077>:
      mono_dl_close (sofile);
      <D.25078>:
      D.24995 = assembly->image;
      D.24995->aot_module = 0B;
      return;
      <D.25073>:
      align_double = 8;
      align_int64 = 8;
      info.8 = info;
      D.25079 = info.8->double_align;
      align_double.19 = (unsigned int) align_double;
      D.25081 = D.25079 != align_double.19;
      D.25082 = (long int) D.25081;
      D.25083 = __builtin_expect (D.25082, 0);
      if (D.25083 != 0) goto <D.25084>; else goto <D.25085>;
      <D.25084>:
      monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "aot-runtime.c", 1670, "info->double_align == align_double");
      <D.25085>:
      info.8 = info;
      D.25086 = info.8->long_align;
      align_int64.20 = (unsigned int) align_int64;
      D.25088 = D.25086 != align_int64.20;
      D.25089 = (long int) D.25088;
      D.25090 = __builtin_expect (D.25089, 0);
      if (D.25090 != 0) goto <D.25091>; else goto <D.25092>;
      <D.25091>:
      monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "aot-runtime.c", 1671, "info->long_align == align_int64");
      <D.25092>:
      info.8 = info;
      D.25093 = info.8->generic_tramp_num;
      D.25094 = D.25093 != 14;
      D.25095 = (long int) D.25094;
      D.25096 = __builtin_expect (D.25095, 0);
      if (D.25096 != 0) goto <D.25097>; else goto <D.25098>;
      <D.25097>:
      monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "aot-runtime.c", 1672, "info->generic_tramp_num == MONO_TRAMPOLINE_NUM");
      <D.25098>:
      info.8 = info;
      blob = info.8->blob;
      amodule = monoeg_malloc0 (736);
      aot_name.10 = aot_name;
      amodule->aot_name = aot_name.10;
      amodule->assembly = assembly;
      info.8 = info;
      D.25099 = &amodule->info;
      memcpy (D.25099, info.8, 368);
      D.25100 = amodule->info.got;
      amodule->got = D.25100;
      D.25101 = amodule->got;
      D.24995 = assembly->image;
      *D.25101 = D.24995;
      amodule->globals = globals;
      amodule->sofile = sofile;
      D.25102 = monoeg_g_hash_table_new (mono_aligned_addr_hash, 0B);
      amodule->method_to_code = D.25102;
      amodule->blob = blob;
      {
        guint32 table_len;
        guint32 i;
        char * table;

        table = 0B;
        info.8 = info;
        table = info.8->image_table;
        D.25103 = table == 0B;
        D.25104 = (long int) D.25103;
        D.25105 = __builtin_expect (D.25104, 0);
        if (D.25105 != 0) goto <D.25106>; else goto <D.25107>;
        <D.25106>:
        monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "aot-runtime.c", 1695, "table");
        <D.25107>:
        table_len = MEM[(guint32 *)table];
        table = table + 4;
        D.25108 = (long unsigned int) table_len;
        D.25109 = D.25108 * 8;
        D.25110 = monoeg_malloc0 (D.25109);
        amodule->image_table = D.25110;
        D.25108 = (long unsigned int) table_len;
        D.25111 = D.25108 * 80;
        D.25112 = monoeg_malloc0 (D.25111);
        amodule->image_names = D.25112;
        D.25108 = (long unsigned int) table_len;
        D.25109 = D.25108 * 8;
        D.25113 = monoeg_malloc0 (D.25109);
        amodule->image_guids = D.25113;
        amodule->image_table_len = table_len;
        i = 0;
        goto <D.23895>;
        <D.23894>:
        {
          struct MonoAssemblyName * aname;

          D.25114 = amodule->image_names;
          D.25115 = (long unsigned int) i;
          D.25116 = D.25115 * 80;
          aname = D.25114 + D.25116;
          D.25117 = monoeg_strdup (table);
          aname->name = D.25117;
          D.25118 = strlen (table);
          D.25119 = D.25118 + 1;
          table = table + D.25119;
          D.25120 = amodule->image_guids;
          D.25115 = (long unsigned int) i;
          D.25121 = D.25115 * 8;
          D.25122 = D.25120 + D.25121;
          D.25123 = monoeg_strdup (table);
          *D.25122 = D.25123;
          D.25124 = strlen (table);
          D.25125 = D.25124 + 1;
          table = table + D.25125;
          D.25126 = *table;
          if (D.25126 != 0) goto <D.25127>; else goto <D.25128>;
          <D.25127>:
          D.25129 = monoeg_strdup (table);
          aname->culture = D.25129;
          <D.25128>:
          D.25130 = strlen (table);
          D.25131 = D.25130 + 1;
          table = table + D.25131;
          D.25132 = strlen (table);
          D.25133 = D.25132 + 1;
          D.25134 = &aname->public_key_token;
          memcpy (D.25134, table, D.25133);
          D.25135 = strlen (table);
          D.25136 = D.25135 + 1;
          table = table + D.25136;
          table.21 = (long int) table;
          D.25138 = table.21 + 7;
          D.25139 = D.25138 & -8;
          table = (char *) D.25139;
          D.25140 = MEM[(guint32 *)table];
          aname->flags = D.25140;
          table = table + 4;
          D.25140 = MEM[(guint32 *)table];
          D.25141 = (short unsigned int) D.25140;
          aname->major = D.25141;
          table = table + 4;
          D.25140 = MEM[(guint32 *)table];
          D.25141 = (short unsigned int) D.25140;
          aname->minor = D.25141;
          table = table + 4;
          D.25140 = MEM[(guint32 *)table];
          D.25141 = (short unsigned int) D.25140;
          aname->build = D.25141;
          table = table + 4;
          D.25140 = MEM[(guint32 *)table];
          D.25141 = (short unsigned int) D.25140;
          aname->revision = D.25141;
          table = table + 4;
        }
        i = i + 1;
        <D.23895>:
        if (i < table_len) goto <D.23894>; else goto <D.23896>;
        <D.23896>:
      }
      info.8 = info;
      D.25142 = info.8->code_offsets;
      amodule->code_offsets = D.25142;
      info.8 = info;
      D.25143 = info.8->method_addresses;
      amodule->method_addresses = D.25143;
      info.8 = info;
      D.25144 = info.8->methods;
      amodule->code = D.25144;
      info.8 = info;
      D.25145 = info.8->methods_end;
      amodule->code_end = D.25145;
      info.8 = info;
      D.25146 = info.8->method_info_offsets;
      amodule->method_info_offsets = D.25146;
      info.8 = info;
      D.25147 = info.8->ex_info_offsets;
      amodule->ex_info_offsets = D.25147;
      info.8 = info;
      D.25148 = info.8->class_info_offsets;
      amodule->class_info_offsets = D.25148;
      info.8 = info;
      D.25149 = info.8->class_name_table;
      amodule->class_name_table = D.25149;
      info.8 = info;
      D.25150 = info.8->extra_method_table;
      amodule->extra_method_table = D.25150;
      info.8 = info;
      D.25151 = info.8->extra_method_info_offsets;
      amodule->extra_method_info_offsets = D.25151;
      info.8 = info;
      D.25152 = info.8->unbox_trampolines;
      amodule->unbox_trampolines = D.25152;
      info.8 = info;
      D.25153 = info.8->unbox_trampolines_end;
      amodule->unbox_trampolines_end = D.25153;
      info.8 = info;
      D.25154 = info.8->got_info_offsets;
      amodule->got_info_offsets = D.25154;
      info.8 = info;
      D.25155 = info.8->unwind_info;
      amodule->unwind_info = D.25155;
      info.8 = info;
      D.25156 = info.8->mem_end;
      amodule->mem_end = D.25156;
      D.25157 = amodule->code;
      amodule->mem_begin = D.25157;
      info.8 = info;
      D.25158 = info.8->plt;
      amodule->plt = D.25158;
      info.8 = info;
      D.25159 = info.8->plt_end;
      amodule->plt_end = D.25159;
      info.8 = info;
      D.25160 = info.8->mono_eh_frame;
      amodule->mono_eh_frame = D.25160;
      info.8 = info;
      D.25161 = info.8->specific_trampolines;
      amodule->trampolines[0] = D.25161;
      info.8 = info;
      D.25162 = info.8->static_rgctx_trampolines;
      amodule->trampolines[1] = D.25162;
      info.8 = info;
      D.25163 = info.8->imt_thunks;
      amodule->trampolines[2] = D.25163;
      info.8 = info;
      D.25164 = info.8->gsharedvt_arg_trampolines;
      amodule->trampolines[3] = D.25164;
      info.8 = info;
      D.25165 = info.8->thumb_end;
      amodule->thumb_end = D.25165;
      make_unreadable.22 = make_unreadable;
      if (make_unreadable.22 != 0) goto <D.25167>; else goto <D.25168>;
      <D.25167>:
      {
        guint8 * addr;
        guint8 * page_start;
        guint8 * page_end;
        int err;
        int len;

        addr = amodule->mem_begin;
        D.25169 = amodule->mem_end;
        D.25170 = (long int) D.25169;
        D.25171 = amodule->mem_begin;
        D.25172 = (long int) D.25171;
        D.25173 = D.25170 - D.25172;
        len = (int) D.25173;
        D.25174 = mono_pagesize ();
        D.25175 = (sizetype) D.25174;
        D.25176 = mono_pagesize ();
        D.25177 = -D.25176;
        D.25178 = (long int) D.25177;
        addr.23 = (long int) addr;
        D.25180 = D.25178 & addr.23;
        D.25181 = (sizetype) D.25180;
        D.25182 = D.25175 + D.25181;
        page_start = (guint8 *) D.25182;
        D.25183 = (sizetype) len;
        D.25184 = addr + D.25183;
        D.25185 = (long int) D.25184;
        D.25186 = mono_pagesize ();
        D.25187 = -D.25186;
        D.25188 = (long int) D.25187;
        D.25189 = D.25185 & D.25188;
        page_end = (guint8 *) D.25189;
        if (page_end > page_start) goto <D.25190>; else goto <D.25191>;
        <D.25190>:
        page_end.24 = (long int) page_end;
        page_start.25 = (long int) page_start;
        D.25194 = page_end.24 - page_start.25;
        D.25195 = (long unsigned int) D.25194;
        err = mono_mprotect (page_start, D.25195, 0);
        D.25196 = err != 0;
        D.25197 = (long int) D.25196;
        D.25198 = __builtin_expect (D.25197, 0);
        if (D.25198 != 0) goto <D.25199>; else goto <D.25200>;
        <D.25199>:
        monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "aot-runtime.c", 1789, "err == 0");
        <D.25200>:
        <D.25191>:
      }
      <D.25168>:
      {
        int ret;

        ret = pthread_mutex_lock (&aot_mutex.mutex);
        if (ret != 0) goto <D.25201>; else goto <D.25202>;
        <D.25201>:
        monoeg_g_log (0B, 16, "Bad call to mono_mutex_lock result %d", ret);
        <D.25202>:
        D.25203 = ret != 0;
        D.25204 = (long int) D.25203;
        D.25205 = __builtin_expect (D.25204, 0);
        if (D.25205 != 0) goto <D.25206>; else goto <D.25207>;
        <D.25206>:
        monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "aot-runtime.c", 1794, "ret == 0");
        <D.25207>:
      }
      D.25157 = amodule->code;
      D.25208 = (long unsigned int) D.25157;
      aot_code_low_addr.26 = aot_code_low_addr;
      aot_code_low_addr.27 = MIN_EXPR <D.25208, aot_code_low_addr.26>;
      aot_code_low_addr = aot_code_low_addr.27;
      D.25211 = amodule->code_end;
      D.25212 = (long unsigned int) D.25211;
      aot_code_high_addr.28 = aot_code_high_addr;
      aot_code_high_addr.29 = MAX_EXPR <D.25212, aot_code_high_addr.28>;
      aot_code_high_addr = aot_code_high_addr.29;
      aot_modules.30 = aot_modules;
      monoeg_g_hash_table_insert_replace (aot_modules.30, assembly, amodule, 0);
      {
        int ret;

        ret = pthread_mutex_unlock (&aot_mutex.mutex);
        if (ret != 0) goto <D.25216>; else goto <D.25217>;
        <D.25216>:
        monoeg_g_log (0B, 16, "Bad call to mono_mutex_unlock result %d", ret);
        <D.25217>:
        D.25218 = ret != 0;
        D.25219 = (long int) D.25218;
        D.25220 = __builtin_expect (D.25219, 0);
        if (D.25220 != 0) goto <D.25221>; else goto <D.25222>;
        <D.25221>:
        monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "aot-runtime.c", 1800, "ret == 0");
        <D.25222>:
      }
      D.25211 = amodule->code_end;
      D.25157 = amodule->code;
      D.24995 = assembly->image;
      mono_jit_info_add_aot_module (D.24995, D.25157, D.25211);
      D.24995 = assembly->image;
      D.24995->aot_module = amodule;
      mono_aot_only.14 = mono_aot_only;
      if (mono_aot_only.14 != 0) goto <D.25223>; else goto <D.25224>;
      <D.25223>:
      {
        char * code;

        try
          {
            D.25225 = amodule->globals;
            D.25226 = amodule->sofile;
            find_symbol (D.25226, D.25225, "specific_trampolines_page", &code);
            code.31 = code;
            D.25228 = code.31 != 0B;
            D.25229 = (int) D.25228;
            amodule->use_page_trampolines = D.25229;
            D.25230 = mono_defaults.corlib;
            if (D.25230 != 0B) goto <D.25231>; else goto <D.25232>;
            <D.25231>:
            {
              struct MonoAotModule * mscorlib_amodule;

              D.25230 = mono_defaults.corlib;
              mscorlib_amodule = D.25230->aot_module;
              D.25101 = amodule->got;
              D.25233 = D.25101 + 8;
              D.25234 = mscorlib_amodule->got;
              *D.25233 = D.25234;
            }
            goto <D.25235>;
            <D.25232>:
            D.25101 = amodule->got;
            D.25233 = D.25101 + 8;
            D.25101 = amodule->got;
            *D.25233 = D.25101;
            <D.25235>:
          }
        finally
          {
            code = {CLOBBER};
          }
      }
      <D.25224>:
      D.25236 = mono_gc_is_moving ();
      if (D.25236 != 0) goto <D.25237>; else goto <D.25238>;
      <D.25237>:
      {
        struct MonoJumpInfo ji;

        try
          {
            memset (&ji, 0, 40);
            ji.type = 42;
            D.25101 = amodule->got;
            D.25239 = D.25101 + 16;
            D.25240 = mono_get_root_domain ();
            D.25241 = mono_resolve_patch_target (0B, D.25240, 0B, &ji, 0);
            *D.25239 = D.25241;
          }
        finally
          {
            ji = {CLOBBER};
          }
      }
      <D.25238>:
      if (do_load_image != 0) goto <D.25242>; else goto <D.25243>;
      <D.25242>:
      i = 0;
      goto <D.23908>;
      <D.23907>:
      load_image (amodule, i, 0);
      i = i + 1;
      <D.23908>:
      i.32 = (unsigned int) i;
      D.25245 = amodule->image_table_len;
      if (i.32 < D.25245) goto <D.23907>; else goto <D.23909>;
      <D.23909>:
      <D.25243>:
      D.25246 = amodule->out_of_date;
      if (D.25246 != 0) goto <D.25247>; else goto <D.25248>;
      <D.25247>:
      D.24995 = assembly->image;
      D.25038 = D.24995->name;
      mono_trace (64, 32, "AOT Module %s is unusable because a dependency is out-of-date.\n", D.25038);
      mono_aot_only.14 = mono_aot_only;
      if (mono_aot_only.14 != 0) goto <D.25249>; else goto <D.25250>;
      <D.25249>:
      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.25250>:
      goto <D.25251>;
      <D.25248>:
      D.24995 = assembly->image;
      D.25038 = D.24995->name;
      mono_trace (64, 32, "AOT loaded AOT Module for %s.\n", D.25038);
      <D.25251>:
    }
  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.25255;
  unsigned char D.25256;
  unsigned char D.25257;
  struct MonoDl * D.25260;
  char * D.25261;
  const char * D.25262;
  char * D.25265;
  int spawn_compiler.33;
  union 
{
  gint __in;
  int __i;
} D.23794;
  int exit_status.34;
  int D.25274;
  int D.25275;
  union 
{
  gint __in;
  int __i;
} D.23798;
  int D.25277;
  int D.25278;
  int D.25279;
  gchar * err.35;
  gchar * out.36;
  int D.25284;
  unsigned int D.25285;
  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.25255 = assembly->image;
      D.25256 = BIT_FIELD_REF <*D.25255, 8, 224>;
      D.25257 = D.25256 & 8;
      if (D.25257 != 0) goto <D.25258>; else goto <D.25259>;
      <D.25258>:
      D.25260 = 0B;
      return D.25260;
      <D.25259>:
      create_cache_structure ();
      home = monoeg_g_get_home_dir ();
      D.25255 = assembly->image;
      D.25261 = D.25255->guid;
      D.25255 = assembly->image;
      D.25262 = D.25255->assembly_name;
      tmp2 = monoeg_g_strdup_printf ("%s-%s%s", D.25262, D.25261, ".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.25263>; else goto <D.25264>;
      <D.25263>:
      mono_trace (64, 32, "AOT not found.");
      D.25255 = assembly->image;
      D.25265 = D.25255->name;
      mono_trace (32, 32, "AOT precompiling assembly \'%s\'... ", D.25265);
      aot_options = monoeg_g_strdup_printf ("outfile=%s", fname);
      spawn_compiler.33 = spawn_compiler;
      if (spawn_compiler.33 != 0) goto <D.25267>; else goto <D.25268>;
      <D.25267>:
      D.25255 = assembly->image;
      D.25265 = D.25255->name;
      cmd = monoeg_g_strdup_printf ("mono -O=all --aot=%s %s", aot_options, D.25265);
      res = monoeg_g_spawn_command_line_sync (cmd, &out, &err, &exit_status, 0B);
      if (res != 0) goto <D.25269>; else goto <D.25270>;
      <D.25269>:
      {
        typedef union 
      {
        gint __in;
        int __i;
      } unionunion 
      {
        gint __in;
        int __i;
      };
        typedef union 
      {
        gint __in;
        int __i;
      } unionunion 
      {
        gint __in;
        int __i;
      };

        exit_status.34 = exit_status;
        D.23794.__in = exit_status.34;
        D.25274 = D.23794.__i;
        D.25275 = D.25274 & 127;
        if (D.25275 != 0) goto <D.25276>; else goto <D.25271>;
        <D.25276>:
        exit_status.34 = exit_status;
        D.23798.__in = exit_status.34;
        D.25277 = D.23798.__i;
        D.25278 = D.25277 & 65280;
        D.25279 = D.25278 >> 8;
        if (D.25279 == 0) goto <D.25280>; else goto <D.25271>;
        <D.25280>:
        err.35 = err;
        mono_trace (32, 32, "AOT failed: %s.", err.35);
        goto <D.25272>;
        <D.25271>:
        mono_trace (32, 32, "AOT succeeded.");
        <D.25272>:
        out.36 = out;
        monoeg_g_free (out.36);
        err.35 = err;
        monoeg_g_free (err.35);
      }
      <D.25270>:
      monoeg_g_free (cmd);
      goto <D.25283>;
      <D.25268>:
      D.25284 = mono_parse_default_optimizations (0B);
      D.25285 = (unsigned int) D.25284;
      res = mono_compile_assembly (assembly, D.25285, aot_options);
      if (res == 0) goto <D.25286>; else goto <D.25287>;
      <D.25286>:
      mono_trace (32, 32, "AOT failed.");
      goto <D.25288>;
      <D.25287>:
      mono_trace (32, 32, "AOT succeeded.");
      <D.25288>:
      <D.25283>:
      module = mono_dl_open (fname, 1, 0B);
      monoeg_g_free (aot_options);
      <D.25264>:
      D.25260 = module;
      return D.25260;
    }
  finally
    {
      out = {CLOBBER};
      err = {CLOBBER};
      exit_status = {CLOBBER};
    }
}


create_cache_structure ()
{
  int D.25293;
  int * D.25298;
  int D.25299;
  const gchar * D.25300;
  int D.25301;
  const gchar * D.25306;
  const char * home;
  char * tmp;
  int err;

  home = monoeg_g_get_home_dir ();
  if (home == 0B) goto <D.25291>; else goto <D.25292>;
  <D.25291>:
  return;
  <D.25292>:
  tmp = monoeg_g_build_path ("/", home, ".mono", 0B);
  D.25293 = monoeg_g_file_test (tmp, 4);
  if (D.25293 == 0) goto <D.25294>; else goto <D.25295>;
  <D.25294>:
  mono_trace (64, 32, "AOT creating directory %s", tmp);
  err = mkdir (tmp, 511);
  if (err != 0) goto <D.25296>; else goto <D.25297>;
  <D.25296>:
  D.25298 = __errno_location ();
  D.25299 = *D.25298;
  D.25300 = monoeg_g_strerror (D.25299);
  mono_trace (64, 32, "AOT failed: %s", D.25300);
  monoeg_g_free (tmp);
  return;
  <D.25297>:
  <D.25295>:
  monoeg_g_free (tmp);
  tmp = monoeg_g_build_path ("/", home, ".mono", "aot-cache", 0B);
  D.25301 = monoeg_g_file_test (tmp, 4);
  if (D.25301 == 0) goto <D.25302>; else goto <D.25303>;
  <D.25302>:
  mono_trace (64, 32, "AOT creating directory %s", tmp);
  err = mkdir (tmp, 511);
  if (err != 0) goto <D.25304>; else goto <D.25305>;
  <D.25304>:
  D.25298 = __errno_location ();
  D.25299 = *D.25298;
  D.25306 = monoeg_g_strerror (D.25299);
  mono_trace (64, 32, "AOT failed: %s", D.25306);
  monoeg_g_free (tmp);
  return;
  <D.25305>:
  <D.25303>:
  monoeg_g_free (tmp);
}


check_usable (struct MonoAssembly * assembly, struct MonoAotFileInfo * info, char * * out_msg)
{
  int D.23845;
  void * D.25308;
  struct MonoImage * D.25309;
  char * D.25310;
  void * D.25313;
  char D.25314;
  int D.23854;
  unsigned int D.25319;
  int D.25320;
  int mono_aot_only.37;
  struct MonoDebugOptions * D.25330;
  int D.25331;
  unsigned int D.25334;
  unsigned int D.25339;
  unsigned int excluded_cpu_optimizations.38;
  unsigned int D.25341;
  unsigned int D.25346;
  unsigned int D.25347;
  unsigned int D.25348;
  unsigned int D.25349;
  int D.25352;
  sizetype D.25355;
  int D.23865;
  gboolean D.25358;
  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.25308 = info->assembly_guid;
        D.25309 = assembly->image;
        D.25310 = D.25309->guid;
        D.23845 = __builtin_strcmp (D.25310, D.25308);
      }
      if (D.23845 != 0) goto <D.25311>; else goto <D.25312>;
      <D.25311>:
      msg = monoeg_g_strdup_printf ("doesn\'t match assembly");
      usable = 0;
      <D.25312>:
      build_info = mono_get_runtime_build_info ();
      D.25313 = info->runtime_version;
      D.25314 = MEM[(const char *)D.25313];
      if (D.25314 != 0) goto <D.25315>; else goto <D.25316>;
      <D.25315>:
      {
        size_t __s1_len;
        size_t __s2_len;

        D.25313 = info->runtime_version;
        D.23854 = __builtin_strcmp (D.25313, build_info);
      }
      if (D.23854 != 0) goto <D.25317>; else goto <D.25318>;
      <D.25317>:
      D.25313 = info->runtime_version;
      msg = monoeg_g_strdup_printf ("compiled against runtime version \'%s\' while this runtime has version \'%s\'", D.25313, build_info);
      usable = 0;
      <D.25318>:
      <D.25316>:
      monoeg_g_free (build_info);
      D.25319 = info->flags;
      D.25320 = (int) D.25319;
      full_aot = D.25320 & 2;
      mono_aot_only.37 = mono_aot_only;
      if (mono_aot_only.37 != 0) goto <D.25322>; else goto <D.25323>;
      <D.25322>:
      if (full_aot == 0) goto <D.25324>; else goto <D.25325>;
      <D.25324>:
      msg = monoeg_g_strdup_printf ("not compiled with --aot=full");
      usable = 0;
      <D.25325>:
      <D.25323>:
      mono_aot_only.37 = mono_aot_only;
      if (mono_aot_only.37 == 0) goto <D.25326>; else goto <D.25327>;
      <D.25326>:
      if (full_aot != 0) goto <D.25328>; else goto <D.25329>;
      <D.25328>:
      msg = monoeg_g_strdup_printf ("compiled with --aot=full");
      usable = 0;
      <D.25329>:
      <D.25327>:
      D.25330 = mini_get_debug_options ();
      D.25331 = D.25330->mdb_optimizations;
      if (D.25331 != 0) goto <D.25332>; else goto <D.25333>;
      <D.25332>:
      D.25319 = info->flags;
      D.25334 = D.25319 & 4;
      if (D.25334 == 0) goto <D.25335>; else goto <D.25336>;
      <D.25335>:
      if (full_aot == 0) goto <D.25337>; else goto <D.25338>;
      <D.25337>:
      msg = monoeg_g_strdup_printf ("not compiled for debugging");
      usable = 0;
      <D.25338>:
      <D.25336>:
      <D.25333>:
      mono_arch_cpu_optimizations (&excluded_cpu_optimizations);
      D.25339 = info->opts;
      excluded_cpu_optimizations.38 = excluded_cpu_optimizations;
      D.25341 = D.25339 & excluded_cpu_optimizations.38;
      if (D.25341 != 0) goto <D.25342>; else goto <D.25343>;
      <D.25342>:
      msg = monoeg_g_strdup_printf ("compiled with unsupported CPU optimizations");
      usable = 0;
      <D.25343>:
      mono_aot_only.37 = mono_aot_only;
      if (mono_aot_only.37 == 0) goto <D.25344>; else goto <D.25345>;
      <D.25344>:
      D.25346 = info->simd_opts;
      D.25347 = mono_arch_cpu_enumerate_simd_versions ();
      D.25348 = ~D.25347;
      D.25349 = D.25346 & D.25348;
      if (D.25349 != 0) goto <D.25350>; else goto <D.25351>;
      <D.25350>:
      msg = monoeg_g_strdup_printf ("compiled with unsupported SIMD extensions");
      usable = 0;
      <D.25351>:
      <D.25345>:
      blob = info->blob;
      D.25352 = info->gc_name_index;
      if (D.25352 != -1) goto <D.25353>; else goto <D.25354>;
      <D.25353>:
      {
        char * gc_name;
        const char * current_gc_name;

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

          D.23865 = __builtin_strcmp (current_gc_name, gc_name);
        }
        if (D.23865 != 0) goto <D.25356>; else goto <D.25357>;
        <D.25356>:
        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.25357>:
      }
      <D.25354>:
      *out_msg = msg;
      D.25358 = usable;
      return D.25358;
    }
  finally
    {
      excluded_cpu_optimizations = {CLOBBER};
    }
}


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

  if (str != 0B) goto <D.25361>; else goto <D.25362>;
  <D.25361>:
  D.25363 = __strdup (str);
  return D.25363;
  <D.25362>:
  D.25363 = 0B;
  return D.25363;
}


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

  D.25366 = __builtin_object_size (__dest, 0);
  D.25365 = __builtin___memcpy_chk (__dest, __src, __len, D.25366);
  return D.25365;
}


find_symbol (struct MonoDl * module, void * * globals, const char * name, void * * value)
{
  unsigned int D.25370;
  unsigned int D.25371;
  unsigned int D.25372;
  long unsigned int D.25373;
  long unsigned int D.25374;
  short unsigned int D.25375;
  int D.25376;
  int D.25377;
  guint16 * D.25378;
  short unsigned int D.25379;
  int D.23821;
  unsigned int D.25380;
  long unsigned int D.25381;
  long unsigned int D.25382;
  void * * D.25383;
  void * D.25384;
  unsigned int D.25388;
  long unsigned int D.25389;
  long unsigned int D.25390;
  int D.25393;
  sizetype D.25394;
  sizetype D.25395;
  sizetype D.25396;
  void * * D.25397;
  void * D.25398;

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

    symbol = name;
    table = *globals;
    globals = globals + 8;
    table_size = *table;
    table = table + 2;
    D.25370 = mono_metadata_str_hash (symbol);
    D.25371 = (unsigned int) table_size;
    hash = D.25370 % D.25371;
    D.25372 = hash * 2;
    D.25373 = (long unsigned int) D.25372;
    D.25374 = D.25373 * 2;
    entry = table + D.25374;
    global_index = -1;
    goto <D.23824>;
    <D.23823>:
    {
      guint32 index;
      guint32 next;

      D.25375 = *entry;
      D.25376 = (int) D.25375;
      D.25377 = D.25376 + -1;
      index = (guint32) D.25377;
      D.25378 = entry + 2;
      D.25379 = *D.25378;
      next = (guint32) D.25379;
      {
        size_t __s1_len;
        size_t __s2_len;

        D.25380 = index * 2;
        D.25381 = (long unsigned int) D.25380;
        D.25382 = D.25381 * 8;
        D.25383 = globals + D.25382;
        D.25384 = *D.25383;
        D.23821 = __builtin_strcmp (D.25384, symbol);
      }
      if (D.23821 == 0) goto <D.25385>; else goto <D.25386>;
      <D.25385>:
      global_index = (int) index;
      goto <D.23822>;
      <D.25386>:
      if (next != 0) goto <D.25387>; else goto <D.23822>;
      <D.25387>:
      D.25388 = next * 2;
      D.25389 = (long unsigned int) D.25388;
      D.25390 = D.25389 * 2;
      entry = table + D.25390;
    }
    <D.23824>:
    D.25375 = *entry;
    if (D.25375 != 0) goto <D.23823>; else goto <D.23822>;
    <D.23822>:
    if (global_index != -1) goto <D.25391>; else goto <D.25392>;
    <D.25391>:
    D.25393 = global_index * 2;
    D.25394 = (sizetype) D.25393;
    D.25395 = D.25394 + 1;
    D.25396 = D.25395 * 8;
    D.25397 = globals + D.25396;
    D.25398 = *D.25397;
    *value = D.25398;
    goto <D.25399>;
    <D.25392>:
    *value = 0B;
    <D.25399>:
    if (symbol != name) goto <D.25400>; else goto <D.25401>;
    <D.25400>:
    monoeg_g_free (symbol);
    <D.25401>:
  }
  goto <D.25402>;
  <D.25369>:
  {
    char * err;

    err = mono_dl_symbol (module, name, value);
    if (err != 0B) goto <D.25403>; else goto <D.25404>;
    <D.25403>:
    monoeg_g_free (err);
    <D.25404>:
  }
  <D.25402>:
}


memset (void * __dest, int __ch, size_t __len)
{
  int D.25407;
  int D.25412;
  void * D.25414;
  long unsigned int D.25415;

  D.25407 = __builtin_constant_p (__len);
  if (D.25407 != 0) goto <D.25408>; else goto <D.25409>;
  <D.25408>:
  if (__len == 0) goto <D.25410>; else goto <D.25411>;
  <D.25410>:
  D.25412 = __builtin_constant_p (__ch);
  if (D.25412 == 0) goto <D.25405>; else goto <D.25413>;
  <D.25413>:
  if (__ch != 0) goto <D.25405>; else goto <D.25406>;
  <D.25405>:
  __warn_memset_zero_len ();
  D.25414 = __dest;
  return D.25414;
  <D.25406>:
  <D.25411>:
  <D.25409>:
  D.25415 = __builtin_object_size (__dest, 0);
  D.25414 = __builtin___memset_chk (__dest, __ch, __len, D.25415);
  return D.25414;
}


load_image (struct MonoAotModule * amodule, int index, gboolean set_error)
{
  unsigned int index.39;
  unsigned int D.25418;
  _Bool D.25419;
  long int D.25420;
  long int D.25421;
  struct MonoImage * * D.25424;
  long unsigned int D.25425;
  long unsigned int D.25426;
  struct MonoImage * * D.25427;
  struct MonoImage * D.25428;
  struct MonoImage * D.25431;
  int D.25432;
  struct MonoAssembly * D.25435;
  char * D.25436;
  struct MonoAssemblyName * D.25437;
  long unsigned int D.25438;
  struct MonoAssemblyName * D.25439;
  const char * D.25442;
  char * D.25443;
  int D.23432;
  char * * D.25446;
  char * * D.25447;
  char * D.25448;
  struct MonoImage * D.25449;
  char * D.25450;
  struct MonoAssembly * assembly;
  MonoImageOpenStatus status;

  try
    {
      index.39 = (unsigned int) index;
      D.25418 = amodule->image_table_len;
      D.25419 = index.39 >= D.25418;
      D.25420 = (long int) D.25419;
      D.25421 = __builtin_expect (D.25420, 0);
      if (D.25421 != 0) goto <D.25422>; else goto <D.25423>;
      <D.25422>:
      monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "aot-runtime.c", 223, "index < amodule->image_table_len");
      <D.25423>:
      D.25424 = amodule->image_table;
      D.25425 = (long unsigned int) index;
      D.25426 = D.25425 * 8;
      D.25427 = D.25424 + D.25426;
      D.25428 = *D.25427;
      if (D.25428 != 0B) goto <D.25429>; else goto <D.25430>;
      <D.25429>:
      D.25424 = amodule->image_table;
      D.25425 = (long unsigned int) index;
      D.25426 = D.25425 * 8;
      D.25427 = D.25424 + D.25426;
      D.25431 = *D.25427;
      return D.25431;
      <D.25430>:
      D.25432 = amodule->out_of_date;
      if (D.25432 != 0) goto <D.25433>; else goto <D.25434>;
      <D.25433>:
      D.25431 = 0B;
      return D.25431;
      <D.25434>:
      D.25435 = amodule->assembly;
      D.25436 = D.25435->basedir;
      D.25437 = amodule->image_names;
      D.25425 = (long unsigned int) index;
      D.25438 = D.25425 * 80;
      D.25439 = D.25437 + D.25438;
      assembly = mono_assembly_load (D.25439, D.25436, &status);
      if (assembly == 0B) goto <D.25440>; else goto <D.25441>;
      <D.25440>:
      D.25437 = amodule->image_names;
      D.25425 = (long unsigned int) index;
      D.25438 = D.25425 * 80;
      D.25439 = D.25437 + D.25438;
      D.25442 = D.25439->name;
      D.25443 = amodule->aot_name;
      mono_trace (64, 32, "AOT module %s is unusable because dependency %s is not found.\n", D.25443, D.25442);
      amodule->out_of_date = 1;
      if (set_error != 0) goto <D.25444>; else goto <D.25445>;
      <D.25444>:
      {
        char * full_name;

        D.25437 = amodule->image_names;
        D.25425 = (long unsigned int) index;
        D.25438 = D.25425 * 80;
        D.25439 = D.25437 + D.25438;
        full_name = mono_stringify_assembly_name (D.25439);
        mono_loader_set_error_assembly_load (full_name, 0);
        monoeg_g_free (full_name);
      }
      <D.25445>:
      D.25431 = 0B;
      return D.25431;
      <D.25441>:
      {
        size_t __s1_len;
        size_t __s2_len;

        D.25446 = amodule->image_guids;
        D.25425 = (long unsigned int) index;
        D.25426 = D.25425 * 8;
        D.25447 = D.25446 + D.25426;
        D.25448 = *D.25447;
        D.25449 = assembly->image;
        D.25450 = D.25449->guid;
        D.23432 = __builtin_strcmp (D.25450, D.25448);
      }
      if (D.23432 != 0) goto <D.25451>; else goto <D.25452>;
      <D.25451>:
      D.25449 = assembly->image;
      D.25450 = D.25449->guid;
      D.25446 = amodule->image_guids;
      D.25425 = (long unsigned int) index;
      D.25426 = D.25425 * 8;
      D.25447 = D.25446 + D.25426;
      D.25448 = *D.25447;
      D.25437 = amodule->image_names;
      D.25425 = (long unsigned int) index;
      D.25438 = D.25425 * 80;
      D.25439 = D.25437 + D.25438;
      D.25442 = D.25439->name;
      D.25443 = 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.25443, D.25442, D.25448, D.25450);
      amodule->out_of_date = 1;
      D.25431 = 0B;
      return D.25431;
      <D.25452>:
      D.25424 = amodule->image_table;
      D.25425 = (long unsigned int) index;
      D.25426 = D.25425 * 8;
      D.25427 = D.25424 + D.25426;
      D.25449 = assembly->image;
      *D.25427 = D.25449;
      D.25431 = assembly->image;
      return D.25431;
    }
  finally
    {
      status = {CLOBBER};
    }
}


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

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


atoi (const char * __nptr)
{
  int D.25457;
  long int D.25458;

  D.25458 = strtol (__nptr, 0B, 10);
  D.25457 = (int) D.25458;
  return D.25457;
}


mono_aot_cleanup ()
{
  struct GHashTable * aot_jit_icall_hash.40;
  struct GHashTable * aot_modules.41;

  aot_jit_icall_hash.40 = aot_jit_icall_hash;
  if (aot_jit_icall_hash.40 != 0B) goto <D.25461>; else goto <D.25462>;
  <D.25461>:
  aot_jit_icall_hash.40 = aot_jit_icall_hash;
  monoeg_g_hash_table_destroy (aot_jit_icall_hash.40);
  <D.25462>:
  aot_modules.41 = aot_modules;
  if (aot_modules.41 != 0B) goto <D.25464>; else goto <D.25465>;
  <D.25464>:
  aot_modules.41 = aot_modules;
  monoeg_g_hash_table_destroy (aot_modules.41);
  <D.25465>:
}


mono_aot_get_method_from_vt_slot (struct MonoDomain * domain, struct MonoVTable * vtable, int slot)
{
  struct MonoImage * D.25466;
  unsigned int D.25469;
  unsigned int D.25470;
  unsigned char D.25472;
  unsigned char D.25475;
  void * D.25477;
  guint8 * D.25478;
  unsigned int D.25479;
  unsigned int D.25480;
  unsigned int D.25481;
  int D.25482;
  guint32 * D.25483;
  unsigned int D.25484;
  sizetype D.25485;
  guint8 * p.42;
  int D.25491;
  unsigned int D.25496;
  unsigned int D.25497;
  unsigned int D.25499;
  struct MonoImage * D.25500;
  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.25466 = klass->image;
      amodule = D.25466->aot_module;
      D.25469 = klass->flags;
      D.25470 = D.25469 & 32;
      if (D.25470 != 0) goto <D.25467>; else goto <D.25471>;
      <D.25471>:
      D.25472 = klass->byval_arg.type;
      if (D.25472 == 19) goto <D.25467>; else goto <D.25473>;
      <D.25473>:
      D.25472 = klass->byval_arg.type;
      if (D.25472 == 30) goto <D.25467>; else goto <D.25474>;
      <D.25474>:
      D.25475 = klass->rank;
      if (D.25475 != 0) goto <D.25467>; else goto <D.25476>;
      <D.25476>:
      if (amodule == 0B) goto <D.25467>; else goto <D.25468>;
      <D.25467>:
      D.25477 = 0B;
      return D.25477;
      <D.25468>:
      D.25478 = amodule->blob;
      D.25479 = klass->type_token;
      D.25480 = D.25479 & 16777215;
      D.25481 = D.25480 + 4294967295;
      D.25482 = (int) D.25481;
      D.25483 = amodule->class_info_offsets;
      D.25484 = mono_aot_get_offset (D.25483, D.25482);
      D.25485 = (sizetype) D.25484;
      info = D.25478 + D.25485;
      p = info;
      p.42 = p;
      err = decode_cached_class_info (amodule, &class_info, p.42, &p);
      if (err == 0) goto <D.25487>; else goto <D.25488>;
      <D.25487>:
      D.25477 = 0B;
      return D.25477;
      <D.25488>:
      i = 0;
      goto <D.23951>;
      <D.23950>:
      p.42 = p;
      decode_method_ref (amodule, &ref, p.42, &p);
      i = i + 1;
      <D.23951>:
      if (i < slot) goto <D.23950>; else goto <D.23952>;
      <D.23952>:
      p.42 = p;
      res = decode_method_ref (amodule, &ref, p.42, &p);
      if (res == 0) goto <D.25489>; else goto <D.25490>;
      <D.25489>:
      D.25477 = 0B;
      return D.25477;
      <D.25490>:
      D.25491 = ref.no_aot_trampoline;
      if (D.25491 != 0) goto <D.25492>; else goto <D.25493>;
      <D.25492>:
      D.25477 = 0B;
      return D.25477;
      <D.25493>:
      D.25496 = ref.token;
      D.25497 = D.25496 & 16777215;
      if (D.25497 == 0) goto <D.25494>; else goto <D.25498>;
      <D.25498>:
      D.25496 = ref.token;
      D.25499 = D.25496 >> 24;
      if (D.25499 != 6) goto <D.25494>; else goto <D.25495>;
      <D.25494>:
      D.25477 = 0B;
      return D.25477;
      <D.25495>:
      D.25496 = ref.token;
      D.25500 = ref.image;
      D.25477 = mono_aot_get_method_from_token (domain, D.25500, D.25496);
      return D.25477;
    }
  finally
    {
      p = {CLOBBER};
      class_info = {CLOBBER};
      ref = {CLOBBER};
    }
}


mono_aot_get_offset (guint32 * table, int index)
{
  unsigned int D.25503;
  guint32 * D.25504;
  unsigned int D.25505;
  guint32 * D.25506;
  unsigned int D.25507;
  guint32 * D.25508;
  unsigned int D.25509;
  long unsigned int D.25512;
  long unsigned int D.25513;
  long unsigned int D.25514;
  long unsigned int D.25515;
  guint16 * D.25516;
  short unsigned int D.25517;
  sizetype D.25518;
  guint8 * p.43;
  long unsigned int D.25521;
  long unsigned int D.25522;
  guint32 * D.25523;
  unsigned int D.25524;
  sizetype D.25525;
  guint8 * p.44;
  guint8 * p.45;
  int D.25528;
  int D.25529;
  guint32 D.25530;
  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.25503 = *table;
      noffsets = (int) D.25503;
      D.25504 = table + 4;
      D.25505 = *D.25504;
      group_size = (int) D.25505;
      D.25506 = table + 8;
      D.25507 = *D.25506;
      ngroups = (int) D.25507;
      D.25508 = table + 12;
      D.25509 = *D.25508;
      index_entry_size = (int) D.25509;
      group = index / group_size;
      if (index_entry_size == 2) goto <D.25510>; else goto <D.25511>;
      <D.25510>:
      index16 = table + 16;
      D.25512 = (long unsigned int) ngroups;
      D.25513 = D.25512 * 2;
      data_start = index16 + D.25513;
      D.25514 = (long unsigned int) group;
      D.25515 = D.25514 * 2;
      D.25516 = index16 + D.25515;
      D.25517 = *D.25516;
      D.25518 = (sizetype) D.25517;
      p.43 = data_start + D.25518;
      p = p.43;
      goto <D.25520>;
      <D.25511>:
      index32 = table + 16;
      D.25512 = (long unsigned int) ngroups;
      D.25521 = D.25512 * 4;
      data_start = index32 + D.25521;
      D.25514 = (long unsigned int) group;
      D.25522 = D.25514 * 4;
      D.25523 = index32 + D.25522;
      D.25524 = *D.25523;
      D.25525 = (sizetype) D.25524;
      p.44 = data_start + D.25525;
      p = p.44;
      <D.25520>:
      p.45 = p;
      start_offset = decode_value (p.45, &p);
      offset = start_offset;
      D.25528 = group * group_size;
      i = D.25528 + 1;
      goto <D.23456>;
      <D.23455>:
      p.45 = p;
      D.25529 = decode_value (p.45, &p);
      offset = D.25529 + offset;
      i = i + 1;
      <D.23456>:
      if (i <= index) goto <D.23455>; else goto <D.23457>;
      <D.23457>:
      D.25530 = (guint32) offset;
      return D.25530;
    }
  finally
    {
      p = {CLOBBER};
    }
}


decode_value (guint8 * ptr, guint8 * * rptr)
{
  signed char b.46;
  int D.25537;
  int D.25538;
  int D.25541;
  int D.25542;
  guint8 * D.25543;
  unsigned char D.25544;
  int D.25545;
  int D.25549;
  int D.25550;
  int D.25551;
  int D.25552;
  guint8 * D.25553;
  unsigned char D.25554;
  int D.25555;
  int D.25556;
  int D.25557;
  guint8 * D.25558;
  unsigned char D.25559;
  int D.25560;
  int D.25562;
  int D.25563;
  int D.25564;
  int D.25565;
  int D.25566;
  guint8 * D.25567;
  unsigned char D.25568;
  int D.25569;
  gint32 D.25572;
  guint8 b;
  gint32 len;

  b = *ptr;
  b.46 = (signed char) b;
  if (b.46 >= 0) goto <D.25534>; else goto <D.25535>;
  <D.25534>:
  len = (gint32) b;
  ptr = ptr + 1;
  goto <D.25536>;
  <D.25535>:
  D.25537 = (int) b;
  D.25538 = D.25537 & 64;
  if (D.25538 == 0) goto <D.25539>; else goto <D.25540>;
  <D.25539>:
  D.25537 = (int) b;
  D.25541 = D.25537 & 63;
  D.25542 = D.25541 << 8;
  D.25543 = ptr + 1;
  D.25544 = *D.25543;
  D.25545 = (int) D.25544;
  len = D.25542 | D.25545;
  ptr = ptr + 2;
  goto <D.25546>;
  <D.25540>:
  if (b != 255) goto <D.25547>; else goto <D.25548>;
  <D.25547>:
  D.25537 = (int) b;
  D.25549 = D.25537 & 31;
  D.25550 = D.25549 << 24;
  D.25543 = ptr + 1;
  D.25544 = *D.25543;
  D.25545 = (int) D.25544;
  D.25551 = D.25545 << 16;
  D.25552 = D.25550 | D.25551;
  D.25553 = ptr + 2;
  D.25554 = *D.25553;
  D.25555 = (int) D.25554;
  D.25556 = D.25555 << 8;
  D.25557 = D.25552 | D.25556;
  D.25558 = ptr + 3;
  D.25559 = *D.25558;
  D.25560 = (int) D.25559;
  len = D.25557 | D.25560;
  ptr = ptr + 4;
  goto <D.25561>;
  <D.25548>:
  D.25543 = ptr + 1;
  D.25544 = *D.25543;
  D.25545 = (int) D.25544;
  D.25562 = D.25545 << 24;
  D.25553 = ptr + 2;
  D.25554 = *D.25553;
  D.25555 = (int) D.25554;
  D.25563 = D.25555 << 16;
  D.25564 = D.25562 | D.25563;
  D.25558 = ptr + 3;
  D.25559 = *D.25558;
  D.25560 = (int) D.25559;
  D.25565 = D.25560 << 8;
  D.25566 = D.25564 | D.25565;
  D.25567 = ptr + 4;
  D.25568 = *D.25567;
  D.25569 = (int) D.25568;
  len = D.25566 | D.25569;
  ptr = ptr + 5;
  <D.25561>:
  <D.25546>:
  <D.25536>:
  if (rptr != 0B) goto <D.25570>; else goto <D.25571>;
  <D.25570>:
  *rptr = ptr;
  <D.25571>:
  D.25572 = len;
  return D.25572;
}


decode_cached_class_info (struct MonoAotModule * module, struct MonoCachedClassInfo * info, guint8 * buf, guint8 * * endbuf)
{
  guint8 * buf.47;
  int D.25575;
  unsigned int D.25576;
  unsigned int D.25577;
  gboolean D.25580;
  int D.25581;
  unsigned char D.25582;
  <unnamed-unsigned:1> D.25583;
  unsigned int D.25584;
  unsigned char D.25585;
  <unnamed-unsigned:1> D.25586;
  unsigned int D.25587;
  unsigned char D.25588;
  <unnamed-unsigned:1> D.25589;
  unsigned int D.25590;
  unsigned char D.25591;
  <unnamed-unsigned:1> D.25592;
  unsigned int D.25593;
  unsigned char D.25594;
  <unnamed-unsigned:1> D.25595;
  unsigned int D.25596;
  unsigned char D.25597;
  <unnamed-unsigned:1> D.25598;
  unsigned int D.25599;
  unsigned char D.25600;
  <unnamed-unsigned:1> D.25601;
  unsigned int D.25602;
  unsigned char D.25603;
  <unnamed-unsigned:1> D.25604;
  unsigned int D.25605;
  unsigned char D.25606;
  <unnamed-unsigned:1> D.25607;
  unsigned char D.25608;
  unsigned char D.25609;
  unsigned int D.25614;
  unsigned char D.25615;
  struct MonoImage * D.25620;
  int D.25621;
  unsigned int D.25622;
  int D.25623;
  unsigned int D.25624;
  int D.25625;
  unsigned int D.25626;
  int D.25627;
  unsigned int D.25628;
  guint32 flags;
  struct MethodRef ref;
  gboolean res;

  try
    {
      buf.47 = buf;
      D.25575 = decode_value (buf.47, &buf);
      D.25576 = (unsigned int) D.25575;
      info->vtable_size = D.25576;
      D.25577 = info->vtable_size;
      if (D.25577 == 4294967295) goto <D.25578>; else goto <D.25579>;
      <D.25578>:
      D.25580 = 0;
      return D.25580;
      <D.25579>:
      buf.47 = buf;
      D.25581 = decode_value (buf.47, &buf);
      flags = (guint32) D.25581;
      D.25582 = (unsigned char) flags;
      D.25583 = (<unnamed-unsigned:1>) D.25582;
      info->ghcimpl = D.25583;
      D.25584 = flags >> 1;
      D.25585 = (unsigned char) D.25584;
      D.25586 = (<unnamed-unsigned:1>) D.25585;
      info->has_finalize = D.25586;
      D.25587 = flags >> 2;
      D.25588 = (unsigned char) D.25587;
      D.25589 = (<unnamed-unsigned:1>) D.25588;
      info->has_cctor = D.25589;
      D.25590 = flags >> 3;
      D.25591 = (unsigned char) D.25590;
      D.25592 = (<unnamed-unsigned:1>) D.25591;
      info->has_nested_classes = D.25592;
      D.25593 = flags >> 4;
      D.25594 = (unsigned char) D.25593;
      D.25595 = (<unnamed-unsigned:1>) D.25594;
      info->blittable = D.25595;
      D.25596 = flags >> 5;
      D.25597 = (unsigned char) D.25596;
      D.25598 = (<unnamed-unsigned:1>) D.25597;
      info->has_references = D.25598;
      D.25599 = flags >> 6;
      D.25600 = (unsigned char) D.25599;
      D.25601 = (<unnamed-unsigned:1>) D.25600;
      info->has_static_refs = D.25601;
      D.25602 = flags >> 7;
      D.25603 = (unsigned char) D.25602;
      D.25604 = (<unnamed-unsigned:1>) D.25603;
      info->no_special_static_fields = D.25604;
      D.25605 = flags >> 8;
      D.25606 = (unsigned char) D.25605;
      D.25607 = (<unnamed-unsigned:1>) D.25606;
      info->is_generic_container = D.25607;
      D.25608 = BIT_FIELD_REF <*info, 8, 32>;
      D.25609 = D.25608 & 4;
      if (D.25609 != 0) goto <D.25610>; else goto <D.25611>;
      <D.25610>:
      buf.47 = buf;
      res = decode_method_ref (module, &ref, buf.47, &buf);
      if (res == 0) goto <D.25612>; else goto <D.25613>;
      <D.25612>:
      D.25580 = 0;
      return D.25580;
      <D.25613>:
      D.25614 = ref.token;
      info->cctor_token = D.25614;
      <D.25611>:
      D.25608 = BIT_FIELD_REF <*info, 8, 32>;
      D.25615 = D.25608 & 1;
      if (D.25615 != 0) goto <D.25616>; else goto <D.25617>;
      <D.25616>:
      buf.47 = buf;
      res = decode_method_ref (module, &ref, buf.47, &buf);
      if (res == 0) goto <D.25618>; else goto <D.25619>;
      <D.25618>:
      D.25580 = 0;
      return D.25580;
      <D.25619>:
      D.25620 = ref.image;
      info->finalize_image = D.25620;
      D.25614 = ref.token;
      info->finalize_token = D.25614;
      <D.25617>:
      buf.47 = buf;
      D.25621 = decode_value (buf.47, &buf);
      D.25622 = (unsigned int) D.25621;
      info->instance_size = D.25622;
      buf.47 = buf;
      D.25623 = decode_value (buf.47, &buf);
      D.25624 = (unsigned int) D.25623;
      info->class_size = D.25624;
      buf.47 = buf;
      D.25625 = decode_value (buf.47, &buf);
      D.25626 = (unsigned int) D.25625;
      info->packing_size = D.25626;
      buf.47 = buf;
      D.25627 = decode_value (buf.47, &buf);
      D.25628 = (unsigned int) D.25627;
      info->min_align = D.25628;
      buf.47 = buf;
      *endbuf = buf.47;
      D.25580 = 1;
      return D.25580;
    }
  finally
    {
      ref = {CLOBBER};
    }
}


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

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


decode_method_ref_with_target (struct MonoAotModule * module, struct MethodRef * ref, struct MonoMethod * target, guint8 * buf, guint8 * * endbuf)
{
  guint8 * p.48;
  int D.25634;
  int D.25637;
  _Bool D.25640;
  _Bool D.25641;
  _Bool D.25642;
  unsigned char D.25646;
  unsigned char D.25647;
  gboolean D.25650;
  int D.25653;
  <unnamed-unsigned:5> D.25656;
  unsigned int D.25657;
  struct MonoClass * D.25662;
  struct MonoMethod * D.25663;
  struct MonoMethod * D.25666;
  struct MonoType * D.25671;
  struct MonoMethod * D.25672;
  struct MonoMethod * D.25676;
  struct MonoMethod * D.25680;
  struct MonoMethod * D.25684;
  struct MonoMethod * D.25686;
  struct MonoMethod * D.25687;
  struct MonoMethod * D.25688;
  struct MonoMethod * D.25689;
  _Bool D.25690;
  long int D.25691;
  long int D.25692;
  struct MonoMethod * D.25695;
  struct MonoMethod * D.25698;
  _Bool D.25706;
  long int D.25707;
  long int D.25708;
  <unnamed type> D.25713;
  unsigned int subtype.49;
  int D.25716;
  struct MonoMethod * D.25722;
  unsigned int subtype.50;
  unsigned int D.25724;
  struct MonoClass * D.25731;
  int D.23675;
  int iftmp.51;
  int D.23674;
  const char[15] * D.25739;
  unsigned char D.25740;
  int D.25741;
  unsigned char D.25742;
  int D.25743;
  _Bool D.25744;
  _Bool D.25745;
  _Bool D.25746;
  const unsigned char * D.25749;
  unsigned char D.25750;
  int D.25751;
  const unsigned char * D.25752;
  unsigned char D.25753;
  int D.25754;
  _Bool D.25755;
  _Bool D.25756;
  const unsigned char * D.25759;
  unsigned char D.25760;
  int D.25761;
  const unsigned char * D.25762;
  unsigned char D.25763;
  int D.25764;
  _Bool D.25765;
  _Bool D.25766;
  const unsigned char * D.25769;
  unsigned char D.25770;
  int D.25771;
  const unsigned char * D.25772;
  unsigned char D.25773;
  int D.25774;
  const char * D.25776;
  struct MonoMethod * D.25779;
  int D.23684;
  int iftmp.52;
  int D.23683;
  const char[15] * D.25784;
  unsigned char D.25785;
  int D.25786;
  unsigned char D.25787;
  int D.25788;
  _Bool D.25789;
  _Bool D.25790;
  _Bool D.25791;
  const unsigned char * D.25794;
  unsigned char D.25795;
  int D.25796;
  const unsigned char * D.25797;
  unsigned char D.25798;
  int D.25799;
  _Bool D.25800;
  _Bool D.25801;
  const unsigned char * D.25804;
  unsigned char D.25805;
  int D.25806;
  const unsigned char * D.25807;
  unsigned char D.25808;
  int D.25809;
  _Bool D.25810;
  _Bool D.25811;
  const unsigned char * D.25814;
  unsigned char D.25815;
  int D.25816;
  const unsigned char * D.25817;
  unsigned char D.25818;
  int D.25819;
  struct MonoMethod * D.25823;
  struct MonoMethod * D.25829;
  struct MonoMethod * D.25835;
  struct MonoMethod * D.25839;
  struct MonoMethod * D.25843;
  struct MonoClass * D.25854;
  _Bool D.25855;
  long int D.25856;
  long int D.25857;
  struct MonoMethod * D.25860;
  struct MonoMethod * D.25863;
  _Bool D.25871;
  long int D.25872;
  long int D.25873;
  <unnamed type> D.25879;
  unsigned int subtype.53;
  struct MonoMethod * D.25882;
  int D.23705;
  struct MonoMethod * D.25895;
  struct MonoMethod * D.25901;
  struct MonoMethod * D.25905;
  int D.23718;
  int iftmp.54;
  int D.23717;
  const char[23] * D.25914;
  unsigned char D.25915;
  int D.25916;
  unsigned char D.25917;
  int D.25918;
  _Bool D.25919;
  _Bool D.25920;
  _Bool D.25921;
  const unsigned char * D.25924;
  unsigned char D.25925;
  int D.25926;
  const unsigned char * D.25927;
  unsigned char D.25928;
  int D.25929;
  _Bool D.25930;
  _Bool D.25931;
  const unsigned char * D.25934;
  unsigned char D.25935;
  int D.25936;
  const unsigned char * D.25937;
  unsigned char D.25938;
  int D.25939;
  _Bool D.25940;
  _Bool D.25941;
  const unsigned char * D.25944;
  unsigned char D.25945;
  int D.25946;
  const unsigned char * D.25947;
  unsigned char D.25948;
  int D.25949;
  struct MonoMethod * D.25958;
  struct MonoMethod * D.25964;
  _Bool D.25966;
  long int D.25967;
  long int D.25968;
  <unnamed type> D.25971;
  unsigned int subtype.55;
  struct MonoMethodSignature * D.25975;
  _Bool D.25976;
  long int D.25977;
  long int D.25978;
  int D.25981;
  _Bool D.25989;
  _Bool D.25990;
  _Bool D.25991;
  int D.25999;
  <unnamed type> D.26002;
  int D.26008;
  struct MonoMethod * D.26016;
  int D.26020;
  int D.26021;
  unsigned int D.26022;
  int image_index.56;
  int D.26035;
  int D.26036;
  unsigned int D.26037;
  unsigned int D.26040;
  struct MonoMethod * D.26041;
  struct MonoGenericClass * D.26046;
  struct MonoGenericInst * D.26047;
  struct MonoMethod * D.26048;
  int D.26049;
  struct MonoMethod * D.26052;
  unsigned char D.26058;
  int D.26059;
  struct MonoMethod * D.26060;
  int D.26061;
  struct MonoMethod * D.26062;
  struct MonoMethod * D.26063;
  struct MonoMethod * D.26064;
  struct MonoMethod * D.26065;
  int D.26069;
  int D.26070;
  unsigned int D.26071;
  unsigned int D.26072;
  guint32 image_index;
  guint32 value;
  struct MonoImage * image;
  guint8 * p;

  try
    {
      image = 0B;
      p = buf;
      memset (ref, 0, 32);
      p.48 = p;
      D.25634 = decode_value (p.48, &p);
      value = (guint32) D.25634;
      image_index = value >> 24;
      if (image_index == 251) goto <D.25635>; else goto <D.25636>;
      <D.25635>:
      ref->no_aot_trampoline = 1;
      p.48 = p;
      D.25637 = decode_value (p.48, &p);
      value = (guint32) D.25637;
      image_index = value >> 24;
      <D.25636>:
      D.25640 = image_index <= 239;
      D.25641 = image_index == 254;
      D.25642 = D.25640 | D.25641;
      if (D.25642 != 0) goto <D.25638>; else goto <D.25643>;
      <D.25643>:
      if (image_index == 253) goto <D.25638>; else goto <D.25639>;
      <D.25638>:
      if (target != 0B) goto <D.25644>; else goto <D.25645>;
      <D.25644>:
      D.25646 = BIT_FIELD_REF <*target, 8, 256>;
      D.25647 = D.25646 & 124;
      if (D.25647 != 0) goto <D.25648>; else goto <D.25649>;
      <D.25648>:
      D.25650 = 0;
      return D.25650;
      <D.25649>:
      <D.25645>:
      <D.25639>:
      if (image_index == 252) goto <D.25651>; else goto <D.25652>;
      <D.25651>:
      {
        guint32 wrapper_type;

        p.48 = p;
        D.25653 = decode_value (p.48, &p);
        wrapper_type = (guint32) D.25653;
        if (target != 0B) goto <D.25654>; else goto <D.25655>;
        <D.25654>:
        D.25656 = target->wrapper_type;
        D.25657 = (unsigned int) D.25656;
        if (D.25657 != wrapper_type) goto <D.25658>; else goto <D.25659>;
        <D.25658>:
        D.25650 = 0;
        return D.25650;
        <D.25659>:
        <D.25655>:
        image = mono_defaults.corlib;
        switch (wrapper_type) <default: <D.23740>, case 1: <D.23723>, case 2: <D.23724>, case 3: <D.23725>, case 4: <D.23708>, case 5: <D.23737>, case 6: <D.23693>, case 7: <D.23687>, case 9: <D.23641>, case 12: <D.23646>, case 13: <D.23648>, case 14: <D.23651>, case 15: <D.23652>, case 16: <D.23660>, case 18: <D.23649>, case 19: <D.23706>, case 20: <D.23644>, case 21: <D.23656>, case 23: <D.23647>, case 24: <D.23655>, case 25: <D.23662>, case 28: <D.23653>>
        <D.23641>:
        {
          struct MonoMethod * m;

          p.48 = p;
          m = decode_resolve_method_ref (module, p.48, &p);
          if (m == 0B) goto <D.25660>; else goto <D.25661>;
          <D.25660>:
          D.25650 = 0;
          return D.25650;
          <D.25661>:
          D.25662 = m->klass;
          mono_class_init (D.25662);
          D.25663 = mono_marshal_get_remoting_invoke_with_check (m);
          ref->method = D.25663;
          goto <D.23643>;
        }
        <D.23644>:
        {
          struct MonoClass * klass;

          p.48 = p;
          klass = decode_klass_ref (module, p.48, &p);
          if (klass == 0B) goto <D.25664>; else goto <D.25665>;
          <D.25664>:
          D.25650 = 0;
          return D.25650;
          <D.25665>:
          D.25666 = mono_marshal_get_proxy_cancast (klass);
          ref->method = D.25666;
          goto <D.23643>;
        }
        <D.23646>:
        <D.23647>:
        <D.23648>:
        <D.23649>:
        {
          struct MonoClass * klass;

          p.48 = p;
          klass = decode_klass_ref (module, p.48, &p);
          if (klass == 0B) goto <D.25667>; else goto <D.25668>;
          <D.25667>:
          D.25650 = 0;
          return D.25650;
          <D.25668>:
          if (wrapper_type == 12) goto <D.25669>; else goto <D.25670>;
          <D.25669>:
          D.25671 = &klass->byval_arg;
          D.25672 = mono_marshal_get_ldfld_wrapper (D.25671);
          ref->method = D.25672;
          goto <D.25673>;
          <D.25670>:
          if (wrapper_type == 23) goto <D.25674>; else goto <D.25675>;
          <D.25674>:
          D.25671 = &klass->byval_arg;
          D.25676 = mono_marshal_get_ldflda_wrapper (D.25671);
          ref->method = D.25676;
          goto <D.25677>;
          <D.25675>:
          if (wrapper_type == 13) goto <D.25678>; else goto <D.25679>;
          <D.25678>:
          D.25671 = &klass->byval_arg;
          D.25680 = mono_marshal_get_stfld_wrapper (D.25671);
          ref->method = D.25680;
          goto <D.25681>;
          <D.25679>:
          if (wrapper_type == 18) goto <D.25682>; else goto <D.25683>;
          <D.25682>:
          D.25684 = mono_marshal_get_isinst (klass);
          ref->method = D.25684;
          goto <D.25685>;
          <D.25683>:
          monoeg_assertion_message ("* Assertion: should not be reached at %s:%d\n", "aot-runtime.c", 831);
          <D.25685>:
          <D.25681>:
          <D.25677>:
          <D.25673>:
          goto <D.23643>;
        }
        <D.23651>:
        D.25686 = mono_marshal_get_ldfld_remote_wrapper (0B);
        ref->method = D.25686;
        goto <D.23643>;
        <D.23652>:
        D.25687 = mono_marshal_get_stfld_remote_wrapper (0B);
        ref->method = D.25687;
        goto <D.23643>;
        <D.23653>:
        {
          int atype;

          p.48 = p;
          atype = decode_value (p.48, &p);
          D.25688 = mono_gc_get_managed_allocator_by_type (atype);
          ref->method = D.25688;
          D.25689 = ref->method;
          D.25690 = D.25689 == 0B;
          D.25691 = (long int) D.25690;
          D.25692 = __builtin_expect (D.25691, 0);
          if (D.25692 != 0) goto <D.25693>; else goto <D.25694>;
          <D.25693>:
          monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "aot-runtime.c", 845, "ref->method");
          <D.25694>:
          goto <D.23643>;
        }
        <D.23655>:
        D.25695 = mono_gc_get_write_barrier ();
        ref->method = D.25695;
        goto <D.23643>;
        <D.23656>:
        {
          int subtype;

          p.48 = p;
          subtype = decode_value (p.48, &p);
          if (subtype == 0) goto <D.25696>; else goto <D.25697>;
          <D.25696>:
          D.25698 = mono_marshal_get_stelemref ();
          ref->method = D.25698;
          goto <D.25699>;
          <D.25697>:
          if (subtype == 3) goto <D.25700>; else goto <D.25701>;
          <D.25700>:
          {
            int kind;
            struct WrapperInfo * info;

            p.48 = p;
            kind = decode_value (p.48, &p);
            if (target == 0B) goto <D.25702>; else goto <D.25703>;
            <D.25702>:
            D.25650 = 0;
            return D.25650;
            <D.25703>:
            D.25646 = BIT_FIELD_REF <*target, 8, 256>;
            D.25647 = D.25646 & 124;
            if (D.25647 == 84) goto <D.25704>; else goto <D.25705>;
            <D.25704>:
            info = mono_marshal_get_wrapper_info (target);
            D.25706 = info == 0B;
            D.25707 = (long int) D.25706;
            D.25708 = __builtin_expect (D.25707, 0);
            if (D.25708 != 0) goto <D.25709>; else goto <D.25710>;
            <D.25709>:
            monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "aot-runtime.c", 868, "info");
            <D.25710>:
            D.25713 = info->subtype;
            subtype.49 = (unsigned int) subtype;
            if (D.25713 == subtype.49) goto <D.25715>; else goto <D.25711>;
            <D.25715>:
            D.25716 = info->d.virtual_stelemref.kind;
            if (D.25716 == kind) goto <D.25717>; else goto <D.25711>;
            <D.25717>:
            ref->method = target;
            goto <D.25712>;
            <D.25711>:
            D.25650 = 0;
            return D.25650;
            <D.25712>:
            goto <D.25718>;
            <D.25705>:
            D.25650 = 0;
            return D.25650;
            <D.25718>:
          }
          goto <D.25719>;
          <D.25701>:
          monoeg_assertion_message ("* Assertion: should not be reached at %s:%d\n", "aot-runtime.c", 877);
          <D.25719>:
          <D.25699>:
          goto <D.23643>;
        }
        <D.23660>:
        {
          struct MonoMethod * m;

          p.48 = p;
          m = decode_resolve_method_ref (module, p.48, &p);
          if (m == 0B) goto <D.25720>; else goto <D.25721>;
          <D.25720>:
          D.25650 = 0;
          return D.25650;
          <D.25721>:
          D.25722 = mono_marshal_get_synchronized_wrapper (m);
          ref->method = D.25722;
          goto <D.23643>;
        }
        <D.23662>:
        {
          struct MonoMethodDesc * desc;
          struct MonoMethod * orig_method;
          int subtype;

          p.48 = p;
          subtype = decode_value (p.48, &p);
          subtype.50 = (unsigned int) subtype;
          D.25724 = subtype.50 + 4294967289;
          if (D.25724 <= 1) goto <D.25725>; else goto <D.25726>;
          <D.25725>:
          {
            struct MonoClass * klass;

            p.48 = p;
            klass = decode_klass_ref (module, p.48, &p);
            if (klass == 0B) goto <D.25727>; else goto <D.25728>;
            <D.25727>:
            D.25650 = 0;
            return D.25650;
            <D.25728>:
            if (target == 0B) goto <D.25729>; else goto <D.25730>;
            <D.25729>:
            D.25650 = 0;
            return D.25650;
            <D.25730>:
            D.25731 = target->klass;
            if (D.25731 != klass) goto <D.25732>; else goto <D.25733>;
            <D.25732>:
            D.25650 = 0;
            return D.25650;
            <D.25733>:
            if (subtype == 7) goto <D.25734>; else goto <D.25735>;
            <D.25734>:
            {
              size_t __s1_len;
              size_t __s2_len;

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

                __s2 = target->name;
                D.25739 = "PtrToStructure";
                D.25740 = MEM[(const unsigned char *)D.25739];
                D.25741 = (int) D.25740;
                D.25742 = *__s2;
                D.25743 = (int) D.25742;
                __result = D.25741 - D.25743;
                {
                  D.25744 = __s2_len != 0;
                  D.25745 = __result == 0;
                  D.25746 = D.25744 & D.25745;
                  if (D.25746 != 0) goto <D.25747>; else goto <D.25748>;
                  <D.25747>:
                  D.25749 = &MEM[(void *)"PtrToStructure" + 1B];
                  D.25750 = *D.25749;
                  D.25751 = (int) D.25750;
                  D.25752 = __s2 + 1;
                  D.25753 = *D.25752;
                  D.25754 = (int) D.25753;
                  __result = D.25751 - D.25754;
                  D.25755 = __s2_len > 1;
                  D.25745 = __result == 0;
                  D.25756 = D.25755 & D.25745;
                  if (D.25756 != 0) goto <D.25757>; else goto <D.25758>;
                  <D.25757>:
                  D.25759 = &MEM[(void *)"PtrToStructure" + 2B];
                  D.25760 = *D.25759;
                  D.25761 = (int) D.25760;
                  D.25762 = __s2 + 2;
                  D.25763 = *D.25762;
                  D.25764 = (int) D.25763;
                  __result = D.25761 - D.25764;
                  D.25765 = __s2_len > 2;
                  D.25745 = __result == 0;
                  D.25766 = D.25765 & D.25745;
                  if (D.25766 != 0) goto <D.25767>; else goto <D.25768>;
                  <D.25767>:
                  D.25769 = &MEM[(void *)"PtrToStructure" + 3B];
                  D.25770 = *D.25769;
                  D.25771 = (int) D.25770;
                  D.25772 = __s2 + 3;
                  D.25773 = *D.25772;
                  D.25774 = (int) D.25773;
                  __result = D.25771 - D.25774;
                  <D.25768>:
                  <D.25758>:
                  <D.25748>:
                }
                D.23674 = __result;
              }
              iftmp.51 = -D.23674;
              goto <D.25775>;
              <D.25738>:
              D.25776 = target->name;
              iftmp.51 = __builtin_strcmp (D.25776, "PtrToStructure");
              <D.25775>:
              D.23675 = iftmp.51;
            }
            if (D.23675 != 0) goto <D.25777>; else goto <D.25778>;
            <D.25777>:
            D.25650 = 0;
            return D.25650;
            <D.25778>:
            D.25779 = mono_marshal_get_ptr_to_struct (klass);
            ref->method = D.25779;
            goto <D.25780>;
            <D.25735>:
            {
              size_t __s1_len;
              size_t __s2_len;

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

                __s2 = target->name;
                D.25784 = "StructureToPtr";
                D.25785 = MEM[(const unsigned char *)D.25784];
                D.25786 = (int) D.25785;
                D.25787 = *__s2;
                D.25788 = (int) D.25787;
                __result = D.25786 - D.25788;
                {
                  D.25789 = __s2_len != 0;
                  D.25790 = __result == 0;
                  D.25791 = D.25789 & D.25790;
                  if (D.25791 != 0) goto <D.25792>; else goto <D.25793>;
                  <D.25792>:
                  D.25794 = &MEM[(void *)"StructureToPtr" + 1B];
                  D.25795 = *D.25794;
                  D.25796 = (int) D.25795;
                  D.25797 = __s2 + 1;
                  D.25798 = *D.25797;
                  D.25799 = (int) D.25798;
                  __result = D.25796 - D.25799;
                  D.25800 = __s2_len > 1;
                  D.25790 = __result == 0;
                  D.25801 = D.25800 & D.25790;
                  if (D.25801 != 0) goto <D.25802>; else goto <D.25803>;
                  <D.25802>:
                  D.25804 = &MEM[(void *)"StructureToPtr" + 2B];
                  D.25805 = *D.25804;
                  D.25806 = (int) D.25805;
                  D.25807 = __s2 + 2;
                  D.25808 = *D.25807;
                  D.25809 = (int) D.25808;
                  __result = D.25806 - D.25809;
                  D.25810 = __s2_len > 2;
                  D.25790 = __result == 0;
                  D.25811 = D.25810 & D.25790;
                  if (D.25811 != 0) goto <D.25812>; else goto <D.25813>;
                  <D.25812>:
                  D.25814 = &MEM[(void *)"StructureToPtr" + 3B];
                  D.25815 = *D.25814;
                  D.25816 = (int) D.25815;
                  D.25817 = __s2 + 3;
                  D.25818 = *D.25817;
                  D.25819 = (int) D.25818;
                  __result = D.25816 - D.25819;
                  <D.25813>:
                  <D.25803>:
                  <D.25793>:
                }
                D.23683 = __result;
              }
              iftmp.52 = -D.23683;
              goto <D.25820>;
              <D.25783>:
              D.25776 = target->name;
              iftmp.52 = __builtin_strcmp (D.25776, "StructureToPtr");
              <D.25820>:
              D.23684 = iftmp.52;
            }
            if (D.23684 != 0) goto <D.25821>; else goto <D.25822>;
            <D.25821>:
            D.25650 = 0;
            return D.25650;
            <D.25822>:
            D.25823 = mono_marshal_get_struct_to_ptr (klass);
            ref->method = D.25823;
            <D.25780>:
          }
          goto <D.25824>;
          <D.25726>:
          if (subtype == 17) goto <D.25825>; else goto <D.25826>;
          <D.25825>:
          {
            struct MonoMethod * m;

            p.48 = p;
            m = decode_resolve_method_ref (module, p.48, &p);
            if (m == 0B) goto <D.25827>; else goto <D.25828>;
            <D.25827>:
            D.25650 = 0;
            return D.25650;
            <D.25828>:
            D.25829 = mono_marshal_get_synchronized_inner_wrapper (m);
            ref->method = D.25829;
          }
          goto <D.25830>;
          <D.25826>:
          if (subtype == 20) goto <D.25831>; else goto <D.25832>;
          <D.25831>:
          {
            struct MonoMethod * m;

            p.48 = p;
            m = decode_resolve_method_ref (module, p.48, &p);
            if (m == 0B) goto <D.25833>; else goto <D.25834>;
            <D.25833>:
            D.25650 = 0;
            return D.25650;
            <D.25834>:
            D.25835 = mono_marshal_get_array_accessor_wrapper (m);
            ref->method = D.25835;
          }
          goto <D.25836>;
          <D.25832>:
          if (subtype == 18) goto <D.25837>; else goto <D.25838>;
          <D.25837>:
          D.25839 = mono_marshal_get_gsharedvt_in_wrapper ();
          ref->method = D.25839;
          goto <D.25840>;
          <D.25838>:
          if (subtype == 19) goto <D.25841>; else goto <D.25842>;
          <D.25841>:
          D.25843 = mono_marshal_get_gsharedvt_out_wrapper ();
          ref->method = D.25843;
          goto <D.25844>;
          <D.25842>:
          if (subtype == 4) goto <D.25845>; else goto <D.25846>;
          <D.25845>:
          desc = mono_method_desc_new ("Monitor:Enter", 0);
          goto <D.25847>;
          <D.25846>:
          if (subtype == 6) goto <D.25848>; else goto <D.25849>;
          <D.25848>:
          desc = mono_method_desc_new ("Monitor:Exit", 0);
          goto <D.25850>;
          <D.25849>:
          if (subtype == 5) goto <D.25851>; else goto <D.25852>;
          <D.25851>:
          desc = mono_method_desc_new ("Monitor:Enter(object,bool&)", 0);
          goto <D.25853>;
          <D.25852>:
          monoeg_assertion_message ("* Assertion: should not be reached at %s:%d\n", "aot-runtime.c", 938);
          <D.25853>:
          <D.25850>:
          <D.25847>:
          D.25854 = mono_defaults.monitor_class;
          orig_method = mono_method_desc_search_in_class (desc, D.25854);
          D.25855 = orig_method == 0B;
          D.25856 = (long int) D.25855;
          D.25857 = __builtin_expect (D.25856, 0);
          if (D.25857 != 0) goto <D.25858>; else goto <D.25859>;
          <D.25858>:
          monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "aot-runtime.c", 940, "orig_method");
          <D.25859>:
          mono_method_desc_free (desc);
          D.25860 = mono_monitor_get_fast_path (orig_method);
          ref->method = D.25860;
          <D.25844>:
          <D.25840>:
          <D.25836>:
          <D.25830>:
          <D.25824>:
          goto <D.23643>;
        }
        <D.23687>:
        {
          int subtype;

          p.48 = p;
          subtype = decode_value (p.48, &p);
          if (subtype == 1) goto <D.25861>; else goto <D.25862>;
          <D.25861>:
          {
            int rank;
            int elem_size;

            p.48 = p;
            rank = decode_value (p.48, &p);
            p.48 = p;
            elem_size = decode_value (p.48, &p);
            D.25863 = mono_marshal_get_array_address (rank, elem_size);
            ref->method = D.25863;
          }
          goto <D.25864>;
          <D.25862>:
          if (subtype == 2) goto <D.25865>; else goto <D.25866>;
          <D.25865>:
          {
            struct WrapperInfo * info;
            struct MonoMethod * m;

            p.48 = p;
            m = decode_resolve_method_ref (module, p.48, &p);
            if (m == 0B) goto <D.25867>; else goto <D.25868>;
            <D.25867>:
            D.25650 = 0;
            return D.25650;
            <D.25868>:
            if (target == 0B) goto <D.25869>; else goto <D.25870>;
            <D.25869>:
            D.25650 = 0;
            return D.25650;
            <D.25870>:
            D.25646 = BIT_FIELD_REF <*target, 8, 256>;
            D.25647 = D.25646 & 124;
            D.25871 = D.25647 != 28;
            D.25872 = (long int) D.25871;
            D.25873 = __builtin_expect (D.25872, 0);
            if (D.25873 != 0) goto <D.25874>; else goto <D.25875>;
            <D.25874>:
            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.25875>:
            info = mono_marshal_get_wrapper_info (target);
            if (info != 0B) goto <D.25878>; else goto <D.25876>;
            <D.25878>:
            D.25879 = info->subtype;
            subtype.53 = (unsigned int) subtype;
            if (D.25879 == subtype.53) goto <D.25881>; else goto <D.25876>;
            <D.25881>:
            D.25882 = info->d.string_ctor.method;
            if (D.25882 == m) goto <D.25883>; else goto <D.25876>;
            <D.25883>:
            ref->method = target;
            goto <D.25877>;
            <D.25876>:
            D.25650 = 0;
            return D.25650;
            <D.25877>:
          }
          <D.25866>:
          <D.25864>:
          goto <D.23643>;
        }
        <D.23693>:
        {
          struct MonoMethod * m;
          int subtype;
          char * name;

          p.48 = p;
          subtype = decode_value (p.48, &p);
          if (subtype == 15) goto <D.25884>; else goto <D.25885>;
          <D.25884>:
          if (target == 0B) goto <D.25886>; else goto <D.25887>;
          <D.25886>:
          D.25650 = 0;
          return D.25650;
          <D.25887>:
          name = p;
          {
            size_t __s1_len;
            size_t __s2_len;

            D.25776 = target->name;
            D.23705 = __builtin_strcmp (D.25776, name);
          }
          if (D.23705 != 0) goto <D.25888>; else goto <D.25889>;
          <D.25888>:
          D.25650 = 0;
          return D.25650;
          <D.25889>:
          ref->method = target;
          goto <D.25890>;
          <D.25885>:
          p.48 = p;
          m = decode_resolve_method_ref (module, p.48, &p);
          if (m == 0B) goto <D.25891>; else goto <D.25892>;
          <D.25891>:
          D.25650 = 0;
          return D.25650;
          <D.25892>:
          if (target == 0B) goto <D.25893>; else goto <D.25894>;
          <D.25893>:
          D.25650 = 0;
          return D.25650;
          <D.25894>:
          D.25895 = mono_marshal_method_from_wrapper (target);
          if (D.25895 == m) goto <D.25896>; else goto <D.25897>;
          <D.25896>:
          ref->method = target;
          goto <D.25898>;
          <D.25897>:
          D.25650 = 0;
          return D.25650;
          <D.25898>:
          <D.25890>:
          goto <D.23643>;
        }
        <D.23706>:
        {
          int subtype;

          p.48 = p;
          subtype = decode_value (p.48, &p);
          if (subtype == 9) goto <D.25899>; else goto <D.25900>;
          <D.25899>:
          D.25901 = mono_marshal_get_castclass_with_cache ();
          ref->method = D.25901;
          goto <D.25902>;
          <D.25900>:
          if (subtype == 10) goto <D.25903>; else goto <D.25904>;
          <D.25903>:
          D.25905 = mono_marshal_get_isinst_with_cache ();
          ref->method = D.25905;
          goto <D.25906>;
          <D.25904>:
          monoeg_assertion_message ("* Assertion: should not be reached at %s:%d\n", "aot-runtime.c", 1011);
          <D.25906>:
          <D.25902>:
          goto <D.23643>;
        }
        <D.23708>:
        {
          int subtype;

          p.48 = p;
          subtype = decode_value (p.48, &p);
          if (target == 0B) goto <D.25907>; else goto <D.25908>;
          <D.25907>:
          D.25650 = 0;
          return D.25650;
          <D.25908>:
          if (subtype == 12) goto <D.25909>; else goto <D.25910>;
          <D.25909>:
          {
            size_t __s1_len;
            size_t __s2_len;

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

              __s2 = target->name;
              D.25914 = "runtime_invoke_dynamic";
              D.25915 = MEM[(const unsigned char *)D.25914];
              D.25916 = (int) D.25915;
              D.25917 = *__s2;
              D.25918 = (int) D.25917;
              __result = D.25916 - D.25918;
              {
                D.25919 = __s2_len != 0;
                D.25920 = __result == 0;
                D.25921 = D.25919 & D.25920;
                if (D.25921 != 0) goto <D.25922>; else goto <D.25923>;
                <D.25922>:
                D.25924 = &MEM[(void *)"runtime_invoke_dynamic" + 1B];
                D.25925 = *D.25924;
                D.25926 = (int) D.25925;
                D.25927 = __s2 + 1;
                D.25928 = *D.25927;
                D.25929 = (int) D.25928;
                __result = D.25926 - D.25929;
                D.25930 = __s2_len > 1;
                D.25920 = __result == 0;
                D.25931 = D.25930 & D.25920;
                if (D.25931 != 0) goto <D.25932>; else goto <D.25933>;
                <D.25932>:
                D.25934 = &MEM[(void *)"runtime_invoke_dynamic" + 2B];
                D.25935 = *D.25934;
                D.25936 = (int) D.25935;
                D.25937 = __s2 + 2;
                D.25938 = *D.25937;
                D.25939 = (int) D.25938;
                __result = D.25936 - D.25939;
                D.25940 = __s2_len > 2;
                D.25920 = __result == 0;
                D.25941 = D.25940 & D.25920;
                if (D.25941 != 0) goto <D.25942>; else goto <D.25943>;
                <D.25942>:
                D.25944 = &MEM[(void *)"runtime_invoke_dynamic" + 3B];
                D.25945 = *D.25944;
                D.25946 = (int) D.25945;
                D.25947 = __s2 + 3;
                D.25948 = *D.25947;
                D.25949 = (int) D.25948;
                __result = D.25946 - D.25949;
                <D.25943>:
                <D.25933>:
                <D.25923>:
              }
              D.23717 = __result;
            }
            iftmp.54 = -D.23717;
            goto <D.25950>;
            <D.25913>:
            D.25776 = target->name;
            iftmp.54 = __builtin_strcmp (D.25776, "runtime_invoke_dynamic");
            <D.25950>:
            D.23718 = iftmp.54;
          }
          if (D.23718 != 0) goto <D.25951>; else goto <D.25952>;
          <D.25951>:
          D.25650 = 0;
          return D.25650;
          <D.25952>:
          ref->method = target;
          goto <D.25953>;
          <D.25910>:
          if (subtype == 13) goto <D.25954>; else goto <D.25955>;
          <D.25954>:
          {
            struct MonoMethod * m;

            p.48 = p;
            m = decode_resolve_method_ref (module, p.48, &p);
            if (m == 0B) goto <D.25956>; else goto <D.25957>;
            <D.25956>:
            D.25650 = 0;
            return D.25650;
            <D.25957>:
            D.25958 = mono_marshal_get_runtime_invoke (m, 0);
            ref->method = D.25958;
          }
          goto <D.25959>;
          <D.25955>:
          if (subtype == 14) goto <D.25960>; else goto <D.25961>;
          <D.25960>:
          {
            struct MonoMethod * m;

            p.48 = p;
            m = decode_resolve_method_ref (module, p.48, &p);
            if (m == 0B) goto <D.25962>; else goto <D.25963>;
            <D.25962>:
            D.25650 = 0;
            return D.25650;
            <D.25963>:
            D.25964 = mono_marshal_get_runtime_invoke (m, 1);
            ref->method = D.25964;
          }
          goto <D.25965>;
          <D.25961>:
          {
            struct MonoMethodSignature * sig;
            struct WrapperInfo * info;

            p.48 = p;
            sig = decode_signature_with_target (module, 0B, p.48, &p);
            info = mono_marshal_get_wrapper_info (target);
            D.25966 = info == 0B;
            D.25967 = (long int) D.25966;
            D.25968 = __builtin_expect (D.25967, 0);
            if (D.25968 != 0) goto <D.25969>; else goto <D.25970>;
            <D.25969>:
            monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "aot-runtime.c", 1044, "info");
            <D.25970>:
            D.25971 = info->subtype;
            subtype.55 = (unsigned int) subtype;
            if (D.25971 != subtype.55) goto <D.25973>; else goto <D.25974>;
            <D.25973>:
            D.25650 = 0;
            return D.25650;
            <D.25974>:
            D.25975 = info->d.runtime_invoke.sig;
            D.25976 = D.25975 == 0B;
            D.25977 = (long int) D.25976;
            D.25978 = __builtin_expect (D.25977, 0);
            if (D.25978 != 0) goto <D.25979>; else goto <D.25980>;
            <D.25979>:
            monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "aot-runtime.c", 1048, "info->d.runtime_invoke.sig");
            <D.25980>:
            D.25975 = info->d.runtime_invoke.sig;
            D.25981 = mono_metadata_signature_equal (sig, D.25975);
            if (D.25981 != 0) goto <D.25982>; else goto <D.25983>;
            <D.25982>:
            ref->method = target;
            goto <D.25984>;
            <D.25983>:
            D.25650 = 0;
            return D.25650;
            <D.25984>:
          }
          <D.25965>:
          <D.25959>:
          <D.25953>:
          goto <D.23643>;
        }
        <D.23723>:
        <D.23724>:
        <D.23725>:
        {
          gboolean is_inflated;
          WrapperSubtype subtype;

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

            p.48 = p;
            klass = decode_klass_ref (module, p.48, &p);
            if (klass == 0B) goto <D.25987>; else goto <D.25988>;
            <D.25987>:
            D.25650 = 0;
            return D.25650;
            <D.25988>:
            switch (wrapper_type) <default: <D.23735>, case 1: <D.23731>, case 2: <D.23733>, case 3: <D.23734>>
            <D.23731>:
            invoke = mono_get_delegate_invoke (klass);
            wrapper = mono_marshal_get_delegate_invoke (invoke, 0B);
            goto <D.23732>;
            <D.23733>:
            invoke = mono_get_delegate_begin_invoke (klass);
            wrapper = mono_marshal_get_delegate_begin_invoke (invoke);
            goto <D.23732>;
            <D.23734>:
            invoke = mono_get_delegate_end_invoke (klass);
            wrapper = mono_marshal_get_delegate_end_invoke (invoke);
            goto <D.23732>;
            <D.23735>:
            monoeg_assertion_message ("* Assertion: should not be reached at %s:%d\n", "aot-runtime.c", 1084);
            <D.23732>:
            D.25989 = target != 0B;
            D.25990 = wrapper != target;
            D.25991 = D.25989 & D.25990;
            if (D.25991 != 0) goto <D.25992>; else goto <D.25993>;
            <D.25992>:
            D.25650 = 0;
            return D.25650;
            <D.25993>:
            ref->method = wrapper;
          }
          goto <D.25994>;
          <D.25986>:
          if (target == 0B) goto <D.25995>; else goto <D.25996>;
          <D.25995>:
          D.25650 = 0;
          return D.25650;
          <D.25996>:
          if (wrapper_type == 1) goto <D.25997>; else goto <D.25998>;
          <D.25997>:
          {
            struct WrapperInfo * info;

            p.48 = p;
            D.25999 = decode_value (p.48, &p);
            subtype = (WrapperSubtype) D.25999;
            info = mono_marshal_get_wrapper_info (target);
            if (info != 0B) goto <D.26000>; else goto <D.26001>;
            <D.26000>:
            D.26002 = info->subtype;
            if (D.26002 != subtype) goto <D.26003>; else goto <D.26004>;
            <D.26003>:
            D.25650 = 0;
            return D.25650;
            <D.26004>:
            goto <D.26005>;
            <D.26001>:
            if (subtype != 0) goto <D.26006>; else goto <D.26007>;
            <D.26006>:
            D.25650 = 0;
            return D.25650;
            <D.26007>:
            <D.26005>:
          }
          <D.25998>:
          p.48 = p;
          D.26008 = sig_matches_target (module, target, p.48, &p);
          if (D.26008 != 0) goto <D.26009>; else goto <D.26010>;
          <D.26009>:
          ref->method = target;
          goto <D.26011>;
          <D.26010>:
          D.25650 = 0;
          return D.25650;
          <D.26011>:
          <D.25994>:
          goto <D.23643>;
        }
        <D.23737>:
        {
          struct MonoMethod * m;
          struct MonoClass * klass;

          p.48 = p;
          m = decode_resolve_method_ref (module, p.48, &p);
          if (m == 0B) goto <D.26012>; else goto <D.26013>;
          <D.26012>:
          D.25650 = 0;
          return D.25650;
          <D.26013>:
          p.48 = p;
          klass = decode_klass_ref (module, p.48, &p);
          if (klass == 0B) goto <D.26014>; else goto <D.26015>;
          <D.26014>:
          D.25650 = 0;
          return D.25650;
          <D.26015>:
          D.26016 = mono_marshal_get_managed_wrapper (m, klass, 0);
          ref->method = D.26016;
          goto <D.23643>;
        }
        <D.23740>:
        monoeg_assertion_message ("* Assertion: should not be reached at %s:%d\n", "aot-runtime.c", 1132);
        <D.23643>:
      }
      goto <D.26017>;
      <D.25652>:
      if (image_index == 254) goto <D.26018>; else goto <D.26019>;
      <D.26018>:
      p.48 = p;
      D.26020 = decode_value (p.48, &p);
      image_index = (guint32) D.26020;
      p.48 = p;
      D.26021 = decode_value (p.48, &p);
      D.26022 = (unsigned int) D.26021;
      ref->token = D.26022;
      image_index.56 = (int) image_index;
      image = load_image (module, image_index.56, 1);
      if (image == 0B) goto <D.26024>; else goto <D.26025>;
      <D.26024>:
      D.25650 = 0;
      return D.25650;
      <D.26025>:
      goto <D.26026>;
      <D.26019>:
      if (image_index == 253) goto <D.26027>; else goto <D.26028>;
      <D.26027>:
      {
        struct MonoClass * klass;
        struct MonoGenericContext ctx;

        try
          {
            p.48 = p;
            klass = decode_klass_ref (module, p.48, &p);
            if (klass == 0B) goto <D.26029>; else goto <D.26030>;
            <D.26029>:
            D.25650 = 0;
            return D.25650;
            <D.26030>:
            if (target != 0B) goto <D.26031>; else goto <D.26032>;
            <D.26031>:
            D.25731 = target->klass;
            if (D.25731 != klass) goto <D.26033>; else goto <D.26034>;
            <D.26033>:
            D.25650 = 0;
            return D.25650;
            <D.26034>:
            <D.26032>:
            p.48 = p;
            D.26035 = decode_value (p.48, &p);
            image_index = (guint32) D.26035;
            p.48 = p;
            D.26036 = decode_value (p.48, &p);
            D.26037 = (unsigned int) D.26036;
            ref->token = D.26037;
            image_index.56 = (int) image_index;
            image = load_image (module, image_index.56, 1);
            if (image == 0B) goto <D.26038>; else goto <D.26039>;
            <D.26038>:
            D.25650 = 0;
            return D.25650;
            <D.26039>:
            D.26040 = ref->token;
            D.26041 = mono_get_method_full (image, D.26040, 0B, 0B);
            ref->method = D.26041;
            D.25689 = ref->method;
            if (D.25689 == 0B) goto <D.26042>; else goto <D.26043>;
            <D.26042>:
            D.25650 = 0;
            return D.25650;
            <D.26043>:
            memset (&ctx, 0, 16);
            if (0 != 0) goto <D.26044>; else goto <D.26045>;
            <D.26044>:
            D.26046 = klass->generic_class;
            D.26047 = D.26046->context.class_inst;
            ctx.class_inst = D.26047;
            ctx.method_inst = 0B;
            D.25689 = ref->method;
            D.26048 = mono_class_inflate_generic_method_full (D.25689, klass, &ctx);
            ref->method = D.26048;
            <D.26045>:
            memset (&ctx, 0, 16);
            p.48 = p;
            D.26049 = decode_generic_context (module, &ctx, p.48, &p);
            if (D.26049 == 0) goto <D.26050>; else goto <D.26051>;
            <D.26050>:
            D.25650 = 0;
            return D.25650;
            <D.26051>:
            D.25689 = ref->method;
            D.26052 = mono_class_inflate_generic_method_full (D.25689, klass, &ctx);
            ref->method = D.26052;
          }
        finally
          {
            ctx = {CLOBBER};
          }
      }
      goto <D.26053>;
      <D.26028>:
      if (image_index == 250) goto <D.26054>; else goto <D.26055>;
      <D.26054>:
      {
        struct MonoClass * klass;
        int method_type;

        p.48 = p;
        klass = decode_klass_ref (module, p.48, &p);
        if (klass == 0B) goto <D.26056>; else goto <D.26057>;
        <D.26056>:
        D.25650 = 0;
        return D.25650;
        <D.26057>:
        p.48 = p;
        method_type = decode_value (p.48, &p);
        switch (method_type) <default: <D.23751>, case 0: <D.23745>, case 1: <D.23747>, case 2: <D.23748>, case 3: <D.23749>, case 4: <D.23750>>
        <D.23745>:
        D.26058 = klass->rank;
        D.26059 = (int) D.26058;
        D.26060 = mono_class_get_method_from_name (klass, ".ctor", D.26059);
        ref->method = D.26060;
        goto <D.23746>;
        <D.23747>:
        D.26058 = klass->rank;
        D.26059 = (int) D.26058;
        D.26061 = D.26059 * 2;
        D.26062 = mono_class_get_method_from_name (klass, ".ctor", D.26061);
        ref->method = D.26062;
        goto <D.23746>;
        <D.23748>:
        D.26063 = mono_class_get_method_from_name (klass, "Get", -1);
        ref->method = D.26063;
        goto <D.23746>;
        <D.23749>:
        D.26064 = mono_class_get_method_from_name (klass, "Address", -1);
        ref->method = D.26064;
        goto <D.23746>;
        <D.23750>:
        D.26065 = mono_class_get_method_from_name (klass, "Set", -1);
        ref->method = D.26065;
        goto <D.23746>;
        <D.23751>:
        monoeg_assertion_message ("* Assertion: should not be reached at %s:%d\n", "aot-runtime.c", 1207);
        <D.23746>:
      }
      goto <D.26066>;
      <D.26055>:
      if (image_index == 249) goto <D.26067>; else goto <D.26068>;
      <D.26067>:
      p.48 = p;
      D.26069 = decode_value (p.48, &p);
      image_index = (guint32) D.26069;
      p.48 = p;
      D.26070 = decode_value (p.48, &p);
      value = (guint32) D.26070;
      <D.26068>:
      D.26071 = value & 16777215;
      D.26072 = D.26071 | 100663296;
      ref->token = D.26072;
      image_index.56 = (int) image_index;
      image = load_image (module, image_index.56, 1);
      if (image == 0B) goto <D.26073>; else goto <D.26074>;
      <D.26073>:
      D.25650 = 0;
      return D.25650;
      <D.26074>:
      <D.26066>:
      <D.26053>:
      <D.26026>:
      <D.26017>:
      p.48 = p;
      *endbuf = p.48;
      ref->image = image;
      D.25650 = 1;
      return D.25650;
    }
  finally
    {
      p = {CLOBBER};
    }
}


decode_signature_with_target (struct MonoAotModule * module, struct MonoMethodSignature * target, guint8 * buf, guint8 * * endbuf)
{
  guint8 * p.57;
  unsigned char D.26080;
  guint8 * p.58;
  unsigned int D.26082;
  _Bool D.26083;
  unsigned int D.26084;
  _Bool D.26085;
  unsigned int D.26086;
  _Bool D.26087;
  int flags.59;
  short unsigned int D.26093;
  int D.26094;
  struct MonoMethodSignature * D.26097;
  long unsigned int D.26098;
  long unsigned int D.26099;
  long unsigned int D.26100;
  short unsigned int D.26101;
  unsigned char D.26102;
  <unnamed-unsigned:1> D.26103;
  unsigned char D.26104;
  <unnamed-unsigned:1> D.26105;
  unsigned char D.26106;
  <unnamed-unsigned:6> D.26107;
  struct MonoType * D.26108;
  unsigned char D.26111;
  unsigned char D.26112;
  _Bool D.26113;
  long int D.26114;
  long int D.26115;
  short int D.26118;
  struct MonoType * D.26119;
  long unsigned int D.26120;
  long unsigned int D.26121;
  short unsigned int D.26124;
  short int D.26125;
  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.57 = p;
      D.26080 = *p.57;
      flags = (guint32) D.26080;
      p.57 = p;
      p.58 = p.57 + 1;
      p = p.58;
      D.26082 = flags & 16;
      D.26083 = D.26082 != 0;
      has_gen_params = (gboolean) D.26083;
      D.26084 = flags & 32;
      D.26085 = D.26084 != 0;
      hasthis = (gboolean) D.26085;
      D.26086 = flags & 64;
      D.26087 = D.26086 != 0;
      explicit_this = (gboolean) D.26087;
      flags.59 = (int) flags;
      call_conv = flags.59 & 15;
      if (has_gen_params != 0) goto <D.26089>; else goto <D.26090>;
      <D.26089>:
      p.57 = p;
      gen_param_count = decode_value (p.57, &p);
      <D.26090>:
      p.57 = p;
      param_count = decode_value (p.57, &p);
      if (target != 0B) goto <D.26091>; else goto <D.26092>;
      <D.26091>:
      D.26093 = target->param_count;
      D.26094 = (int) D.26093;
      if (D.26094 != param_count) goto <D.26095>; else goto <D.26096>;
      <D.26095>:
      D.26097 = 0B;
      return D.26097;
      <D.26096>:
      <D.26092>:
      D.26098 = (long unsigned int) param_count;
      D.26099 = D.26098 + 2;
      D.26100 = D.26099 * 8;
      sig = monoeg_malloc0 (D.26100);
      D.26101 = (short unsigned int) param_count;
      sig->param_count = D.26101;
      sig->sentinelpos = -1;
      D.26102 = (unsigned char) hasthis;
      D.26103 = (<unnamed-unsigned:1>) D.26102;
      sig->hasthis = D.26103;
      D.26104 = (unsigned char) explicit_this;
      D.26105 = (<unnamed-unsigned:1>) D.26104;
      sig->explicit_this = D.26105;
      D.26106 = (unsigned char) call_conv;
      D.26107 = (<unnamed-unsigned:6>) D.26106;
      sig->call_convention = D.26107;
      D.26101 = (short unsigned int) param_count;
      sig->param_count = D.26101;
      p.57 = p;
      D.26108 = decode_type (module, p.57, &p);
      sig->ret = D.26108;
      i = 0;
      goto <D.23607>;
      <D.23606>:
      p.57 = p;
      D.26080 = *p.57;
      if (D.26080 == 65) goto <D.26109>; else goto <D.26110>;
      <D.26109>:
      D.26111 = BIT_FIELD_REF <*sig, 8, 112>;
      D.26112 = D.26111 & 63;
      D.26113 = D.26112 != 5;
      D.26114 = (long int) D.26113;
      D.26115 = __builtin_expect (D.26114, 0);
      if (D.26115 != 0) goto <D.26116>; else goto <D.26117>;
      <D.26116>:
      monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "aot-runtime.c", 706, "sig->call_convention == MONO_CALL_VARARG");
      <D.26117>:
      D.26118 = (short int) i;
      sig->sentinelpos = D.26118;
      p.57 = p;
      p.58 = p.57 + 1;
      p = p.58;
      <D.26110>:
      p.57 = p;
      D.26119 = decode_type (module, p.57, &p);
      sig->params[i] = D.26119;
      i = i + 1;
      <D.23607>:
      if (i < param_count) goto <D.23606>; else goto <D.23608>;
      <D.23608>:
      D.26120 = BIT_FIELD_REF <*sig, 64, 64>;
      D.26121 = D.26120 & 17732927827673088;
      if (D.26121 == 1407379178455040) goto <D.26122>; else goto <D.26123>;
      <D.26122>:
      D.26124 = sig->param_count;
      D.26125 = (short int) D.26124;
      sig->sentinelpos = D.26125;
      <D.26123>:
      p.57 = p;
      *endbuf = p.57;
      D.26097 = sig;
      return D.26097;
    }
  finally
    {
      p = {CLOBBER};
    }
}


decode_type (struct MonoAotModule * module, guint8 * buf, guint8 * * endbuf)
{
  guint8 * p.60;
  unsigned char D.26129;
  guint8 * p.61;
  unsigned char D.26135;
  int D.26136;
  struct MonoClass * D.26137;
  struct MonoClass * D.26138;
  struct MonoClass * D.26139;
  struct MonoType * D.26142;
  struct MonoType * D.26143;
  struct MonoGenericContainer * D.26146;
  _Bool D.26147;
  long int D.26148;
  long int D.26149;
  struct MonoGenericInst * D.26152;
  struct MonoGenericInst * D.26153;
  struct MonoType * D.26156;
  struct MonoGenericClass * D.26157;
  struct MonoClass * D.26158;
  struct MonoClass * D.26159;
  int D.26162;
  unsigned char D.26163;
  int D.26164;
  unsigned char D.26165;
  unsigned char D.26166;
  long unsigned int D.26169;
  long unsigned int D.26170;
  void * D.26171;
  int * D.26172;
  long unsigned int D.26173;
  long unsigned int D.26174;
  int * D.26175;
  int D.26176;
  int D.26177;
  int D.26178;
  unsigned char D.26179;
  unsigned char D.26180;
  long unsigned int D.26183;
  long unsigned int D.26184;
  void * D.26185;
  int * D.26186;
  int * D.26187;
  int D.26188;
  int D.26189;
  struct MonoGenericParam * D.26192;
  guint8 * p;
  struct MonoType * t;

  try
    {
      p = buf;
      t = monoeg_malloc0 (16);
      <D.23548>:
      p.60 = p;
      D.26129 = *p.60;
      if (D.26129 == 69) goto <D.26130>; else goto <D.26131>;
      <D.26130>:
      t->pinned = 1;
      p.60 = p;
      p.61 = p.60 + 1;
      p = p.61;
      goto <D.26133>;
      <D.26131>:
      p.60 = p;
      D.26129 = *p.60;
      if (D.26129 == 16) goto <D.26134>; else goto <D.23547>;
      <D.26134>:
      t->byref = 1;
      p.60 = p;
      p.61 = p.60 + 1;
      p = p.61;
      <D.26133>:
      goto <D.23548>;
      <D.23547>:
      p.60 = p;
      D.26129 = *p.60;
      t->type = D.26129;
      p.60 = p;
      p.61 = p.60 + 1;
      p = p.61;
      D.26135 = t->type;
      D.26136 = (int) D.26135;
      switch (D.26136) <default: <D.23589>, case 1: <D.23549>, case 2: <D.23550>, case 3: <D.23551>, case 4: <D.23552>, case 5: <D.23553>, case 6: <D.23554>, case 7: <D.23555>, case 8: <D.23556>, case 9: <D.23557>, case 10: <D.23558>, case 11: <D.23559>, case 12: <D.23560>, case 13: <D.23561>, case 14: <D.23564>, case 15: <D.23571>, case 17: <D.23568>, case 18: <D.23569>, case 19: <D.23586>, case 20: <D.23577>, case 21: <D.23572>, case 22: <D.23566>, case 24: <D.23562>, case 25: <D.23563>, case 28: <D.23565>, case 29: <D.23570>, case 30: <D.23587>>
      <D.23549>:
      <D.23550>:
      <D.23551>:
      <D.23552>:
      <D.23553>:
      <D.23554>:
      <D.23555>:
      <D.23556>:
      <D.23557>:
      <D.23558>:
      <D.23559>:
      <D.23560>:
      <D.23561>:
      <D.23562>:
      <D.23563>:
      <D.23564>:
      <D.23565>:
      <D.23566>:
      goto <D.23567>;
      <D.23568>:
      <D.23569>:
      p.60 = p;
      D.26137 = decode_klass_ref (module, p.60, &p);
      t->data.klass = D.26137;
      goto <D.23567>;
      <D.23570>:
      p.60 = p;
      D.26138 = decode_klass_ref (module, p.60, &p);
      t->data.klass = D.26138;
      D.26139 = t->data.klass;
      if (D.26139 == 0B) goto <D.26140>; else goto <D.26141>;
      <D.26140>:
      D.26142 = 0B;
      return D.26142;
      <D.26141>:
      goto <D.23567>;
      <D.23571>:
      p.60 = p;
      D.26143 = decode_type (module, p.60, &p);
      t->data.type = D.26143;
      goto <D.23567>;
      <D.23572>:
      {
        struct MonoClass * gclass;
        struct MonoGenericContext ctx;
        struct MonoType * type;
        struct MonoClass * klass;

        try
          {
            p.60 = p;
            gclass = decode_klass_ref (module, p.60, &p);
            if (gclass == 0B) goto <D.26144>; else goto <D.26145>;
            <D.26144>:
            D.26142 = 0B;
            return D.26142;
            <D.26145>:
            D.26146 = gclass->generic_container;
            D.26147 = D.26146 == 0B;
            D.26148 = (long int) D.26147;
            D.26149 = __builtin_expect (D.26148, 0);
            if (D.26149 != 0) goto <D.26150>; else goto <D.26151>;
            <D.26150>:
            monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "aot-runtime.c", 620, "gclass->generic_container");
            <D.26151>:
            memset (&ctx, 0, 16);
            p.60 = p;
            D.26152 = decode_generic_inst (module, p.60, &p);
            ctx.class_inst = D.26152;
            D.26153 = ctx.class_inst;
            if (D.26153 == 0B) goto <D.26154>; else goto <D.26155>;
            <D.26154>:
            D.26142 = 0B;
            return D.26142;
            <D.26155>:
            D.26156 = &gclass->byval_arg;
            type = mono_class_inflate_generic_type (D.26156, &ctx);
            klass = mono_class_from_mono_type (type);
            D.26157 = klass->generic_class;
            t->data.generic_class = D.26157;
            goto <D.23567>;
          }
        finally
          {
            ctx = {CLOBBER};
          }
      }
      <D.23577>:
      {
        struct MonoArrayType * array;
        int i;

        array = monoeg_malloc0 (32);
        p.60 = p;
        D.26158 = decode_klass_ref (module, p.60, &p);
        array->eklass = D.26158;
        D.26159 = array->eklass;
        if (D.26159 == 0B) goto <D.26160>; else goto <D.26161>;
        <D.26160>:
        D.26142 = 0B;
        return D.26142;
        <D.26161>:
        p.60 = p;
        D.26162 = decode_value (p.60, &p);
        D.26163 = (unsigned char) D.26162;
        array->rank = D.26163;
        p.60 = p;
        D.26164 = decode_value (p.60, &p);
        D.26165 = (unsigned char) D.26164;
        array->numsizes = D.26165;
        D.26166 = array->numsizes;
        if (D.26166 != 0) goto <D.26167>; else goto <D.26168>;
        <D.26167>:
        D.26166 = array->numsizes;
        D.26169 = (long unsigned int) D.26166;
        D.26170 = D.26169 * 4;
        D.26171 = monoeg_malloc0 (D.26170);
        array->sizes = D.26171;
        <D.26168>:
        i = 0;
        goto <D.23581>;
        <D.23580>:
        D.26172 = array->sizes;
        D.26173 = (long unsigned int) i;
        D.26174 = D.26173 * 4;
        D.26175 = D.26172 + D.26174;
        p.60 = p;
        D.26176 = decode_value (p.60, &p);
        *D.26175 = D.26176;
        i = i + 1;
        <D.23581>:
        D.26166 = array->numsizes;
        D.26177 = (int) D.26166;
        if (D.26177 > i) goto <D.23580>; else goto <D.23582>;
        <D.23582>:
        p.60 = p;
        D.26178 = decode_value (p.60, &p);
        D.26179 = (unsigned char) D.26178;
        array->numlobounds = D.26179;
        D.26180 = array->numlobounds;
        if (D.26180 != 0) goto <D.26181>; else goto <D.26182>;
        <D.26181>:
        D.26180 = array->numlobounds;
        D.26183 = (long unsigned int) D.26180;
        D.26184 = D.26183 * 4;
        D.26185 = monoeg_malloc0 (D.26184);
        array->lobounds = D.26185;
        <D.26182>:
        i = 0;
        goto <D.23584>;
        <D.23583>:
        D.26186 = array->lobounds;
        D.26173 = (long unsigned int) i;
        D.26174 = D.26173 * 4;
        D.26187 = D.26186 + D.26174;
        p.60 = p;
        D.26188 = decode_value (p.60, &p);
        *D.26187 = D.26188;
        i = i + 1;
        <D.23584>:
        D.26180 = array->numlobounds;
        D.26189 = (int) D.26180;
        if (D.26189 > i) goto <D.23583>; else goto <D.23585>;
        <D.23585>:
        t->data.array = array;
        goto <D.23567>;
      }
      <D.23586>:
      <D.23587>:
      {
        struct MonoClass * klass;

        p.60 = p;
        klass = decode_klass_ref (module, p.60, &p);
        if (klass == 0B) goto <D.26190>; else goto <D.26191>;
        <D.26190>:
        D.26142 = 0B;
        return D.26142;
        <D.26191>:
        D.26192 = klass->byval_arg.data.generic_param;
        t->data.generic_param = D.26192;
        goto <D.23567>;
      }
      <D.23589>:
      monoeg_assertion_message ("* Assertion: should not be reached at %s:%d\n", "aot-runtime.c", 665);
      <D.23567>:
      p.60 = p;
      *endbuf = p.60;
      D.26142 = t;
      return D.26142;
    }
  finally
    {
      p = {CLOBBER};
    }
}


decode_generic_inst (struct MonoAotModule * module, guint8 * buf, guint8 * * endbuf)
{
  guint8 * p.62;
  long unsigned int D.26199;
  long unsigned int D.26200;
  struct MonoGenericInst * D.26203;
  long unsigned int D.26204;
  long unsigned int D.26205;
  struct MonoType * * D.26206;
  struct MonoType * D.26207;
  int type_argc;
  int i;
  struct MonoType * * type_argv;
  struct MonoGenericInst * inst;
  guint8 * p;

  try
    {
      p = buf;
      p.62 = p;
      type_argc = decode_value (p.62, &p);
      D.26199 = (long unsigned int) type_argc;
      D.26200 = D.26199 * 8;
      type_argv = monoeg_malloc0 (D.26200);
      i = 0;
      goto <D.23482>;
      <D.23481>:
      {
        struct MonoClass * pclass;

        p.62 = p;
        pclass = decode_klass_ref (module, p.62, &p);
        if (pclass == 0B) goto <D.26201>; else goto <D.26202>;
        <D.26201>:
        monoeg_g_free (type_argv);
        D.26203 = 0B;
        return D.26203;
        <D.26202>:
        D.26204 = (long unsigned int) i;
        D.26205 = D.26204 * 8;
        D.26206 = type_argv + D.26205;
        D.26207 = &pclass->byval_arg;
        *D.26206 = D.26207;
      }
      i = i + 1;
      <D.23482>:
      if (i < type_argc) goto <D.23481>; else goto <D.23483>;
      <D.23483>:
      inst = mono_metadata_get_generic_inst (type_argc, type_argv);
      monoeg_g_free (type_argv);
      p.62 = p;
      *endbuf = p.62;
      D.26203 = inst;
      return D.26203;
    }
  finally
    {
      p = {CLOBBER};
    }
}


sig_matches_target (struct MonoAotModule * module, struct MonoMethod * target, guint8 * buf, guint8 * * endbuf)
{
  guint8 * p.63;
  struct MonoMethodSignature * D.26211;
  int iftmp.64;
  struct MonoMethodSignature * D.26216;
  int D.26217;
  gboolean D.26219;
  struct MonoMethodSignature * sig;
  gboolean res;
  guint8 * p;

  try
    {
      p = buf;
      p.63 = p;
      D.26211 = mono_method_signature (target);
      sig = decode_signature_with_target (module, D.26211, p.63, &p);
      if (sig != 0B) goto <D.26215>; else goto <D.26213>;
      <D.26215>:
      D.26216 = mono_method_signature (target);
      D.26217 = mono_metadata_signature_equal (D.26216, sig);
      if (D.26217 != 0) goto <D.26218>; else goto <D.26213>;
      <D.26218>:
      iftmp.64 = 1;
      goto <D.26214>;
      <D.26213>:
      iftmp.64 = 0;
      <D.26214>:
      res = iftmp.64;
      monoeg_g_free (sig);
      p.63 = p;
      *endbuf = p.63;
      D.26219 = res;
      return D.26219;
    }
  finally
    {
      p = {CLOBBER};
    }
}


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

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


decode_resolve_method_ref_with_target (struct MonoAotModule * module, struct MonoMethod * target, guint8 * buf, guint8 * * endbuf)
{
  struct MonoMethod * D.26226;
  struct MonoMethod * D.26227;
  struct MonoImage * D.26230;
  unsigned int D.26233;
  struct MethodRef ref;
  gboolean res;

  try
    {
      res = decode_method_ref_with_target (module, &ref, target, buf, endbuf);
      if (res == 0) goto <D.26224>; else goto <D.26225>;
      <D.26224>:
      D.26226 = 0B;
      return D.26226;
      <D.26225>:
      D.26227 = ref.method;
      if (D.26227 != 0B) goto <D.26228>; else goto <D.26229>;
      <D.26228>:
      D.26226 = ref.method;
      return D.26226;
      <D.26229>:
      D.26230 = ref.image;
      if (D.26230 == 0B) goto <D.26231>; else goto <D.26232>;
      <D.26231>:
      D.26226 = 0B;
      return D.26226;
      <D.26232>:
      D.26233 = ref.token;
      D.26230 = ref.image;
      D.26226 = mono_get_method (D.26230, D.26233, 0B);
      return D.26226;
    }
  finally
    {
      ref = {CLOBBER};
    }
}


decode_generic_context (struct MonoAotModule * module, struct MonoGenericContext * ctx, guint8 * buf, guint8 * * endbuf)
{
  guint8 * p.65;
  struct MonoGenericInst * D.26239;
  struct MonoGenericInst * D.26240;
  gboolean D.26243;
  struct MonoGenericInst * D.26246;
  struct MonoGenericInst * D.26247;
  guint8 * p;
  guint8 * p2;
  int argc;

  try
    {
      p = buf;
      p2 = p;
      p.65 = p;
      argc = decode_value (p.65, &p);
      if (argc != 0) goto <D.26237>; else goto <D.26238>;
      <D.26237>:
      p = p2;
      p.65 = p;
      D.26239 = decode_generic_inst (module, p.65, &p);
      ctx->class_inst = D.26239;
      D.26240 = ctx->class_inst;
      if (D.26240 == 0B) goto <D.26241>; else goto <D.26242>;
      <D.26241>:
      D.26243 = 0;
      return D.26243;
      <D.26242>:
      <D.26238>:
      p2 = p;
      p.65 = p;
      argc = decode_value (p.65, &p);
      if (argc != 0) goto <D.26244>; else goto <D.26245>;
      <D.26244>:
      p = p2;
      p.65 = p;
      D.26246 = decode_generic_inst (module, p.65, &p);
      ctx->method_inst = D.26246;
      D.26247 = ctx->method_inst;
      if (D.26247 == 0B) goto <D.26248>; else goto <D.26249>;
      <D.26248>:
      D.26243 = 0;
      return D.26243;
      <D.26249>:
      <D.26245>:
      p.65 = p;
      *endbuf = p.65;
      D.26243 = 1;
      return D.26243;
    }
  finally
    {
      p = {CLOBBER};
    }
}


decode_klass_ref (struct MonoAotModule * module, guint8 * buf, guint8 * * endbuf)
{
  guint8 * p.66;
  struct MonoClass * D.26255;
  int D.26256;
  unsigned int D.26259;
  int D.26260;
  int D.26261;
  int D.26264;
  struct MonoAssembly * D.26265;
  struct MonoGenericContainer * D.26270;
  _Bool D.26271;
  long int D.26272;
  long int D.26273;
  struct MonoGenericInst * D.26276;
  struct MonoGenericInst * D.26277;
  struct MonoType * D.26280;
  _Bool D.26285;
  long int D.26286;
  long int D.26287;
  _Bool D.26293;
  long int D.26294;
  long int D.26295;
  unsigned char D.26301;
  struct MonoGenericParamFull * D.26304;
  long unsigned int D.26305;
  long unsigned int D.26306;
  struct MonoGenericParam * D.26307;
  _Bool D.26308;
  long int D.26309;
  long int D.26310;
  short unsigned int D.26314;
  short unsigned int D.26315;
  struct MonoImage * D.26316;
  int D.26317;
  int D.26320;
  guint8 * D.26321;
  sizetype D.26322;
  guint8 * p2.67;
  guint8 * p2.68;
  _Bool D.26325;
  long int D.26326;
  long int D.26327;
  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.66 = p;
      reftype = decode_value (p.66, &p);
      if (reftype == 0) goto <D.26253>; else goto <D.26254>;
      <D.26253>:
      p.66 = p;
      *endbuf = p.66;
      D.26255 = 0B;
      return D.26255;
      <D.26254>:
      switch (reftype) <default: <D.23531>, case 1: <D.23506>, case 2: <D.23508>, case 3: <D.23509>, case 4: <D.23510>, case 5: <D.23514>, case 6: <D.23525>, case 7: <D.23528>, case 8: <D.23526>>
      <D.23506>:
      p.66 = p;
      D.26256 = decode_value (p.66, &p);
      idx = (guint32) D.26256;
      image = load_image (module, 0, 1);
      if (image == 0B) goto <D.26257>; else goto <D.26258>;
      <D.26257>:
      D.26255 = 0B;
      return D.26255;
      <D.26258>:
      D.26259 = idx + 33554432;
      klass = mono_class_get (image, D.26259);
      goto <D.23507>;
      <D.23508>:
      p.66 = p;
      D.26260 = decode_value (p.66, &p);
      idx = (guint32) D.26260;
      p.66 = p;
      D.26261 = decode_value (p.66, &p);
      image = load_image (module, D.26261, 1);
      if (image == 0B) goto <D.26262>; else goto <D.26263>;
      <D.26262>:
      D.26255 = 0B;
      return D.26255;
      <D.26263>:
      D.26259 = idx + 33554432;
      klass = mono_class_get (image, D.26259);
      goto <D.23507>;
      <D.23509>:
      p.66 = p;
      D.26264 = decode_value (p.66, &p);
      token = (guint32) D.26264;
      D.26265 = module->assembly;
      image = D.26265->image;
      if (image == 0B) goto <D.26266>; else goto <D.26267>;
      <D.26266>:
      D.26255 = 0B;
      return D.26255;
      <D.26267>:
      klass = mono_class_get (image, token);
      goto <D.23507>;
      <D.23510>:
      {
        struct MonoClass * gclass;
        struct MonoGenericContext ctx;
        struct MonoType * type;

        try
          {
            p.66 = p;
            gclass = decode_klass_ref (module, p.66, &p);
            if (gclass == 0B) goto <D.26268>; else goto <D.26269>;
            <D.26268>:
            D.26255 = 0B;
            return D.26255;
            <D.26269>:
            D.26270 = gclass->generic_container;
            D.26271 = D.26270 == 0B;
            D.26272 = (long int) D.26271;
            D.26273 = __builtin_expect (D.26272, 0);
            if (D.26273 != 0) goto <D.26274>; else goto <D.26275>;
            <D.26274>:
            monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "aot-runtime.c", 435, "gclass->generic_container");
            <D.26275>:
            memset (&ctx, 0, 16);
            p.66 = p;
            D.26276 = decode_generic_inst (module, p.66, &p);
            ctx.class_inst = D.26276;
            D.26277 = ctx.class_inst;
            if (D.26277 == 0B) goto <D.26278>; else goto <D.26279>;
            <D.26278>:
            D.26255 = 0B;
            return D.26255;
            <D.26279>:
            D.26280 = &gclass->byval_arg;
            type = mono_class_inflate_generic_type (D.26280, &ctx);
            klass = mono_class_from_mono_type (type);
            mono_metadata_free_type (type);
            goto <D.23507>;
          }
        finally
          {
            ctx = {CLOBBER};
          }
      }
      <D.23514>:
      {
        struct MonoType * t;
        struct MonoGenericContainer * container;
        int type;
        int num;
        gboolean has_container;
        int serial;

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

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

            D.26285 = type != 30;
            D.26286 = (long int) D.26285;
            D.26287 = __builtin_expect (D.26286, 0);
            if (D.26287 != 0) goto <D.26288>; else goto <D.26289>;
            <D.26288>:
            monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "aot-runtime.c", 459, "type == MONO_TYPE_MVAR");
            <D.26289>:
            p.66 = p;
            method_def = decode_resolve_method_ref (module, p.66, &p);
            if (method_def == 0B) goto <D.26290>; else goto <D.26291>;
            <D.26290>:
            D.26255 = 0B;
            return D.26255;
            <D.26291>:
            container = mono_method_get_generic_container (method_def);
          }
          goto <D.26292>;
          <D.26284>:
          {
            struct MonoClass * class_def;

            D.26293 = type != 19;
            D.26294 = (long int) D.26293;
            D.26295 = __builtin_expect (D.26294, 0);
            if (D.26295 != 0) goto <D.26296>; else goto <D.26297>;
            <D.26296>:
            monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "aot-runtime.c", 467, "type == MONO_TYPE_VAR");
            <D.26297>:
            p.66 = p;
            class_def = decode_klass_ref (module, p.66, &p);
            if (class_def == 0B) goto <D.26298>; else goto <D.26299>;
            <D.26298>:
            D.26255 = 0B;
            return D.26255;
            <D.26299>:
            container = class_def->generic_container;
          }
          <D.26292>:
        }
        goto <D.26300>;
        <D.26282>:
        p.66 = p;
        serial = decode_value (p.66, &p);
        <D.26300>:
        t = monoeg_malloc0 (16);
        D.26301 = (unsigned char) type;
        t->type = D.26301;
        if (container != 0B) goto <D.26302>; else goto <D.26303>;
        <D.26302>:
        D.26304 = container->type_params;
        D.26305 = (long unsigned int) num;
        D.26306 = D.26305 * 56;
        D.26307 = D.26304 + D.26306;
        t->data.generic_param = D.26307;
        D.26308 = serial != 0;
        D.26309 = (long int) D.26308;
        D.26310 = __builtin_expect (D.26309, 0);
        if (D.26310 != 0) goto <D.26311>; else goto <D.26312>;
        <D.26311>:
        monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "aot-runtime.c", 483, "serial == 0");
        <D.26312>:
        goto <D.26313>;
        <D.26303>:
        {
          struct MonoGenericParam * par;

          par = monoeg_malloc0 (56);
          D.26314 = (short unsigned int) num;
          par->num = D.26314;
          D.26315 = (short unsigned int) serial;
          par->serial = D.26315;
          D.26316 = mono_defaults.corlib;
          par->image = D.26316;
          t->data.generic_param = par;
        }
        <D.26313>:
        klass = mono_class_from_mono_type (t);
        monoeg_g_free (t);
        goto <D.23507>;
      }
      <D.23525>:
      p.66 = p;
      D.26317 = decode_value (p.66, &p);
      rank = (guint32) D.26317;
      p.66 = p;
      eklass = decode_klass_ref (module, p.66, &p);
      klass = mono_array_class_get (eklass, rank);
      goto <D.23507>;
      <D.23526>:
      {
        struct MonoType * t;

        p.66 = p;
        t = decode_type (module, p.66, &p);
        if (t == 0B) goto <D.26318>; else goto <D.26319>;
        <D.26318>:
        D.26255 = 0B;
        return D.26255;
        <D.26319>:
        klass = mono_class_from_mono_type (t);
        monoeg_g_free (t);
        goto <D.23507>;
      }
      <D.23528>:
      {
        guint32 offset;
        guint8 * p2;

        try
          {
            p.66 = p;
            D.26320 = decode_value (p.66, &p);
            offset = (guint32) D.26320;
            D.26321 = module->blob;
            D.26322 = (sizetype) offset;
            p2.67 = D.26321 + D.26322;
            p2 = p2.67;
            p2.68 = p2;
            klass = decode_klass_ref (module, p2.68, &p2);
            goto <D.23507>;
          }
        finally
          {
            p2 = {CLOBBER};
          }
      }
      <D.23531>:
      monoeg_assertion_message ("* Assertion: should not be reached at %s:%d\n", "aot-runtime.c", 526);
      <D.23507>:
      D.26325 = klass == 0B;
      D.26326 = (long int) D.26325;
      D.26327 = __builtin_expect (D.26326, 0);
      if (D.26327 != 0) goto <D.26328>; else goto <D.26329>;
      <D.26328>:
      monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "aot-runtime.c", 528, "klass");
      <D.26329>:
      p.66 = p;
      *endbuf = p.66;
      D.26255 = klass;
      return D.26255;
    }
  finally
    {
      p = {CLOBBER};
    }
}


mono_aot_get_cached_class_info (struct MonoClass * klass, struct MonoCachedClassInfo * res)
{
  struct MonoImage * D.26335;
  unsigned char D.26338;
  gboolean D.26340;
  guint8 * D.26341;
  unsigned int D.26342;
  unsigned int D.26343;
  unsigned int D.26344;
  int D.26345;
  guint32 * D.26346;
  unsigned int D.26347;
  sizetype D.26348;
  guint8 * p.69;
  guint8 * p.70;
  struct MonoAotModule * amodule;
  guint8 * p;
  gboolean err;

  try
    {
      D.26335 = klass->image;
      amodule = D.26335->aot_module;
      D.26338 = klass->rank;
      if (D.26338 != 0) goto <D.26336>; else goto <D.26339>;
      <D.26339>:
      if (amodule == 0B) goto <D.26336>; else goto <D.26337>;
      <D.26336>:
      D.26340 = 0;
      return D.26340;
      <D.26337>:
      D.26341 = amodule->blob;
      D.26342 = klass->type_token;
      D.26343 = D.26342 & 16777215;
      D.26344 = D.26343 + 4294967295;
      D.26345 = (int) D.26344;
      D.26346 = amodule->class_info_offsets;
      D.26347 = mono_aot_get_offset (D.26346, D.26345);
      D.26348 = (sizetype) D.26347;
      p.69 = D.26341 + D.26348;
      p = p.69;
      p.70 = p;
      err = decode_cached_class_info (amodule, res, p.70, &p);
      if (err == 0) goto <D.26351>; else goto <D.26352>;
      <D.26351>:
      D.26340 = 0;
      return D.26340;
      <D.26352>:
      D.26340 = 1;
      return D.26340;
    }
  finally
    {
      p = {CLOBBER};
    }
}


mono_aot_get_class_from_name (struct MonoImage * image, const char * name_space, const char * name, struct MonoClass * * klass)
{
  guint16 * D.26358;
  gboolean D.26359;
  _Bool D.26362;
  long int D.26363;
  long int D.26364;
  struct GHashTable * D.26367;
  struct GHashTable * D.26370;
  void * D.26373;
  struct MonoClass * D.26374;
  _Bool D.26379;
  long int D.26380;
  long int D.26381;
  char D.26384;
  long unsigned int D.26388;
  long unsigned int D.26389;
  long unsigned int D.26390;
  unsigned int D.26394;
  unsigned int D.26395;
  unsigned int D.26398;
  long unsigned int D.26399;
  long unsigned int D.26400;
  short unsigned int D.26401;
  guint16 * D.26404;
  short unsigned int D.26405;
  unsigned int name_table_accesses.71;
  unsigned int name_table_accesses.72;
  unsigned int D.26408;
  int D.26409;
  unsigned int D.26410;
  unsigned int D.26411;
  int D.23991;
  int D.24000;
  _Bool D.26418;
  long int D.26419;
  long int D.26420;
  struct MonoClass * D.26423;
  _Bool D.26428;
  long int D.26429;
  long int D.26430;
  _Bool D.26437;
  long int D.26438;
  long int D.26439;
  unsigned int D.26443;
  long unsigned int D.26444;
  long unsigned int D.26445;
  _Bool D.26448;
  long int D.26449;
  long int D.26450;
  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.26355>; else goto <D.26357>;
      <D.26357>:
      D.26358 = amodule->class_name_table;
      if (D.26358 == 0B) goto <D.26355>; else goto <D.26356>;
      <D.26355>:
      D.26359 = 0;
      return D.26359;
      <D.26356>:
      {
        int ret;

        ret = pthread_mutex_lock (&aot_mutex.mutex);
        if (ret != 0) goto <D.26360>; else goto <D.26361>;
        <D.26360>:
        monoeg_g_log (0B, 16, "Bad call to mono_mutex_lock result %d", ret);
        <D.26361>:
        D.26362 = ret != 0;
        D.26363 = (long int) D.26362;
        D.26364 = __builtin_expect (D.26363, 0);
        if (D.26364 != 0) goto <D.26365>; else goto <D.26366>;
        <D.26365>:
        monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "aot-runtime.c", 2065, "ret == 0");
        <D.26366>:
      }
      *klass = 0B;
      D.26367 = amodule->name_cache;
      if (D.26367 == 0B) goto <D.26368>; else goto <D.26369>;
      <D.26368>:
      D.26370 = monoeg_g_hash_table_new (monoeg_g_str_hash, monoeg_g_str_equal);
      amodule->name_cache = D.26370;
      <D.26369>:
      D.26367 = amodule->name_cache;
      nspace_table = monoeg_g_hash_table_lookup (D.26367, name_space);
      if (nspace_table != 0B) goto <D.26371>; else goto <D.26372>;
      <D.26371>:
      D.26373 = monoeg_g_hash_table_lookup (nspace_table, name);
      *klass = D.26373;
      D.26374 = *klass;
      if (D.26374 != 0B) goto <D.26375>; else goto <D.26376>;
      <D.26375>:
      {
        int ret;

        ret = pthread_mutex_unlock (&aot_mutex.mutex);
        if (ret != 0) goto <D.26377>; else goto <D.26378>;
        <D.26377>:
        monoeg_g_log (0B, 16, "Bad call to mono_mutex_unlock result %d", ret);
        <D.26378>:
        D.26379 = ret != 0;
        D.26380 = (long int) D.26379;
        D.26381 = __builtin_expect (D.26380, 0);
        if (D.26381 != 0) goto <D.26382>; else goto <D.26383>;
        <D.26382>:
        monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "aot-runtime.c", 2076, "ret == 0");
        <D.26383>:
      }
      D.26359 = 1;
      return D.26359;
      <D.26376>:
      <D.26372>:
      D.26358 = amodule->class_name_table;
      table_size = *D.26358;
      D.26358 = amodule->class_name_table;
      table = D.26358 + 2;
      D.26384 = *name_space;
      if (D.26384 == 0) goto <D.26385>; else goto <D.26386>;
      <D.26385>:
      full_name = monoeg_g_strdup_printf ("%s", name);
      goto <D.26387>;
      <D.26386>:
      D.26388 = strlen (name_space);
      D.26389 = strlen (name);
      D.26390 = D.26388 + D.26389;
      if (D.26390 <= 999) goto <D.26391>; else goto <D.26392>;
      <D.26391>:
      sprintf (&full_name_buf, "%s.%s", name_space, name);
      full_name = &full_name_buf;
      goto <D.26393>;
      <D.26392>:
      full_name = monoeg_g_strdup_printf ("%s.%s", name_space, name);
      <D.26393>:
      <D.26387>:
      D.26394 = mono_metadata_str_hash (full_name);
      D.26395 = (unsigned int) table_size;
      hash = D.26394 % D.26395;
      if (&full_name_buf != full_name) goto <D.26396>; else goto <D.26397>;
      <D.26396>:
      monoeg_g_free (full_name);
      <D.26397>:
      D.26398 = hash * 2;
      D.26399 = (long unsigned int) D.26398;
      D.26400 = D.26399 * 2;
      entry = table + D.26400;
      D.26401 = *entry;
      if (D.26401 != 0) goto <D.26402>; else goto <D.26403>;
      <D.26402>:
      t = &image->tables[2];
      <D.24005>:
      {
        guint32 index;
        guint32 next;
        guint32 token;

        D.26401 = *entry;
        index = (guint32) D.26401;
        D.26404 = entry + 2;
        D.26405 = *D.26404;
        next = (guint32) D.26405;
        token = index | 33554432;
        name_table_accesses.71 = name_table_accesses;
        name_table_accesses.72 = name_table_accesses.71 + 1;
        name_table_accesses = name_table_accesses.72;
        D.26408 = index + 4294967295;
        D.26409 = (int) D.26408;
        mono_metadata_decode_row (t, D.26409, &cols, 6);
        D.26410 = cols[1];
        name2 = mono_metadata_string_heap (image, D.26410);
        D.26411 = cols[2];
        name_space2 = mono_metadata_string_heap (image, D.26411);
        {
          size_t __s1_len;
          size_t __s2_len;

          D.23991 = __builtin_strcmp (name, name2);
        }
        if (D.23991 == 0) goto <D.26412>; else goto <D.26413>;
        <D.26412>:
        {
          size_t __s1_len;
          size_t __s2_len;

          D.24000 = __builtin_strcmp (name_space, name_space2);
        }
        if (D.24000 == 0) goto <D.26414>; else goto <D.26415>;
        <D.26414>:
        {
          int ret;

          ret = pthread_mutex_unlock (&aot_mutex.mutex);
          if (ret != 0) goto <D.26416>; else goto <D.26417>;
          <D.26416>:
          monoeg_g_log (0B, 16, "Bad call to mono_mutex_unlock result %d", ret);
          <D.26417>:
          D.26418 = ret != 0;
          D.26419 = (long int) D.26418;
          D.26420 = __builtin_expect (D.26419, 0);
          if (D.26420 != 0) goto <D.26421>; else goto <D.26422>;
          <D.26421>:
          monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "aot-runtime.c", 2116, "ret == 0");
          <D.26422>:
        }
        D.26423 = mono_class_get (image, token);
        *klass = D.26423;
        D.26374 = *klass;
        if (D.26374 != 0B) goto <D.26424>; else goto <D.26425>;
        <D.26424>:
        {
          int ret;

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

          ret = pthread_mutex_unlock (&aot_mutex.mutex);
          if (ret != 0) goto <D.26435>; else goto <D.26436>;
          <D.26435>:
          monoeg_g_log (0B, 16, "Bad call to mono_mutex_unlock result %d", ret);
          <D.26436>:
          D.26437 = ret != 0;
          D.26438 = (long int) D.26437;
          D.26439 = __builtin_expect (D.26438, 0);
          if (D.26439 != 0) goto <D.26440>; else goto <D.26441>;
          <D.26440>:
          monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "aot-runtime.c", 2128, "ret == 0");
          <D.26441>:
        }
        <D.26425>:
        D.26359 = 1;
        return D.26359;
        <D.26415>:
        <D.26413>:
        if (next != 0) goto <D.26442>; else goto <D.24004>;
        <D.26442>:
        D.26443 = next * 2;
        D.26444 = (long unsigned int) D.26443;
        D.26445 = D.26444 * 2;
        entry = table + D.26445;
      }
      goto <D.24005>;
      <D.24004>:
      <D.26403>:
      {
        int ret;

        ret = pthread_mutex_unlock (&aot_mutex.mutex);
        if (ret != 0) goto <D.26446>; else goto <D.26447>;
        <D.26446>:
        monoeg_g_log (0B, 16, "Bad call to mono_mutex_unlock result %d", ret);
        <D.26447>:
        D.26448 = ret != 0;
        D.26449 = (long int) D.26448;
        D.26450 = __builtin_expect (D.26449, 0);
        if (D.26450 != 0) goto <D.26451>; else goto <D.26452>;
        <D.26451>:
        monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "aot-runtime.c", 2141, "ret == 0");
        <D.26452>:
      }
      D.26359 = 1;
      return D.26359;
    }
  finally
    {
      full_name_buf = {CLOBBER};
      cols = {CLOBBER};
    }
}


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

  D.26456 = __builtin_object_size (__s, 1);
  D.26455 = __builtin___sprintf_chk (__s, 1, D.26456, __fmt, __builtin_va_arg_pack ());
  return D.26455;
}


mono_aot_get_unwind_info (struct MonoJitInfo * ji, guint32 * unwind_info_len)
{
  unsigned char D.26458;
  unsigned char D.26459;
  struct MonoMethod * D.26463;
  struct MonoClass * D.26464;
  struct MonoImage * D.26465;
  _Bool D.26466;
  long int D.26467;
  long int D.26468;
  unsigned char D.26471;
  unsigned char D.26472;
  _Bool D.26473;
  long int D.26474;
  long int D.26475;
  guint8 * D.26480;
  guint8 * D.26482;
  _Bool D.26485;
  long int D.26486;
  long int D.26487;
  struct GHashTable * ji_to_amodule.73;
  _Bool D.26491;
  long int D.26492;
  long int D.26493;
  int iftmp.74;
  _Bool D.26503;
  long int D.26504;
  long int D.26505;
  _Bool D.26510;
  long int D.26511;
  long int D.26512;
  guint8 * D.26515;
  unsigned int D.26516;
  sizetype D.26517;
  guint8 * p.75;
  guint8 * p.76;
  int D.26520;
  unsigned int D.26521;
  guint8 * D.26522;
  struct MonoAotModule * amodule;
  guint8 * p;
  guint8 * code;

  try
    {
      code = ji->code_start;
      D.26458 = BIT_FIELD_REF <*ji, 8, 280>;
      D.26459 = D.26458 & 1;
      if (D.26459 != 0) goto <D.26460>; else goto <D.26461>;
      <D.26460>:
      amodule = ji->d.aot_info;
      goto <D.26462>;
      <D.26461>:
      D.26463 = jinfo_get_method (ji);
      D.26464 = D.26463->klass;
      D.26465 = D.26464->image;
      amodule = D.26465->aot_module;
      <D.26462>:
      D.26466 = amodule == 0B;
      D.26467 = (long int) D.26466;
      D.26468 = __builtin_expect (D.26467, 0);
      if (D.26468 != 0) goto <D.26469>; else goto <D.26470>;
      <D.26469>:
      monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "aot-runtime.c", 2655, "amodule");
      <D.26470>:
      D.26471 = BIT_FIELD_REF <*ji, 8, 272>;
      D.26472 = D.26471 & 16;
      D.26473 = D.26472 == 0;
      D.26474 = (long int) D.26473;
      D.26475 = __builtin_expect (D.26474, 0);
      if (D.26475 != 0) goto <D.26476>; else goto <D.26477>;
      <D.26476>:
      monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "aot-runtime.c", 2656, "ji->from_aot");
      <D.26477>:
      D.26480 = amodule->code;
      if (D.26480 > code) goto <D.26478>; else goto <D.26481>;
      <D.26481>:
      D.26482 = amodule->code_end;
      if (D.26482 < code) goto <D.26478>; else goto <D.26479>;
      <D.26478>:
      {
        int ret;

        ret = pthread_mutex_lock (&aot_mutex.mutex);
        if (ret != 0) goto <D.26483>; else goto <D.26484>;
        <D.26483>:
        monoeg_g_log (0B, 16, "Bad call to mono_mutex_lock result %d", ret);
        <D.26484>:
        D.26485 = ret != 0;
        D.26486 = (long int) D.26485;
        D.26487 = __builtin_expect (D.26486, 0);
        if (D.26487 != 0) goto <D.26488>; else goto <D.26489>;
        <D.26488>:
        monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "aot-runtime.c", 2660, "ret == 0");
        <D.26489>:
      }
      ji_to_amodule.73 = ji_to_amodule;
      D.26491 = ji_to_amodule.73 == 0B;
      D.26492 = (long int) D.26491;
      D.26493 = __builtin_expect (D.26492, 0);
      if (D.26493 != 0) goto <D.26494>; else goto <D.26495>;
      <D.26494>:
      monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "aot-runtime.c", 2661, "ji_to_amodule");
      <D.26495>:
      ji_to_amodule.73 = ji_to_amodule;
      amodule = monoeg_g_hash_table_lookup (ji_to_amodule.73, ji);
      D.26466 = amodule == 0B;
      D.26467 = (long int) D.26466;
      D.26468 = __builtin_expect (D.26467, 0);
      if (D.26468 != 0) goto <D.26496>; else goto <D.26497>;
      <D.26496>:
      monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "aot-runtime.c", 2663, "amodule");
      <D.26497>:
      D.26480 = amodule->code;
      if (D.26480 > code) goto <D.26499>; else goto <D.26502>;
      <D.26502>:
      D.26482 = amodule->code_end;
      if (D.26482 < code) goto <D.26499>; else goto <D.26500>;
      <D.26499>:
      iftmp.74 = 1;
      goto <D.26501>;
      <D.26500>:
      iftmp.74 = 0;
      <D.26501>:
      D.26503 = iftmp.74 != 0;
      D.26504 = (long int) D.26503;
      D.26505 = __builtin_expect (D.26504, 0);
      if (D.26505 != 0) goto <D.26506>; else goto <D.26507>;
      <D.26506>:
      monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "aot-runtime.c", 2664, "code >= amodule->code && code <= amodule->code_end");
      <D.26507>:
      {
        int ret;

        ret = pthread_mutex_unlock (&aot_mutex.mutex);
        if (ret != 0) goto <D.26508>; else goto <D.26509>;
        <D.26508>:
        monoeg_g_log (0B, 16, "Bad call to mono_mutex_unlock result %d", ret);
        <D.26509>:
        D.26510 = ret != 0;
        D.26511 = (long int) D.26510;
        D.26512 = __builtin_expect (D.26511, 0);
        if (D.26512 != 0) goto <D.26513>; else goto <D.26514>;
        <D.26513>:
        monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "aot-runtime.c", 2665, "ret == 0");
        <D.26514>:
      }
      <D.26479>:
      D.26515 = amodule->unwind_info;
      D.26516 = ji->used_regs;
      D.26517 = (sizetype) D.26516;
      p.75 = D.26515 + D.26517;
      p = p.75;
      p.76 = p;
      D.26520 = decode_value (p.76, &p);
      D.26521 = (unsigned int) D.26520;
      *unwind_info_len = D.26521;
      D.26522 = p;
      return D.26522;
    }
  finally
    {
      p = {CLOBBER};
    }
}


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

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


mono_aot_find_jit_info (struct MonoDomain * domain, struct MonoImage * image, void * addr)
{
  unsigned int D.26527;
  struct MonoJitInfo * D.26530;
  struct MonoDomain * D.26531;
  long int addr.77;
  guint8 * D.26535;
  long int D.26536;
  long int D.26537;
  gint32 * D.26538;
  int D.26541;
  long unsigned int D.26542;
  long unsigned int D.26543;
  gint32 * D.26544;
  long unsigned int D.26545;
  long unsigned int D.26546;
  gint32 * D.26547;
  int D.26548;
  int D.26551;
  long unsigned int D.26552;
  long unsigned int D.26553;
  gint32 * D.26554;
  sizetype D.26555;
  sizetype D.26556;
  sizetype D.26557;
  gint32 * D.26558;
  int D.26559;
  long unsigned int D.26560;
  long unsigned int D.26561;
  gint32 * D.26562;
  int D.26563;
  int D.26564;
  int D.26565;
  long unsigned int D.26566;
  long unsigned int D.26567;
  gint32 * D.26568;
  int D.26569;
  _Bool D.26570;
  long int D.26571;
  long int D.26572;
  int D.26575;
  gint32 * * D.26576;
  void * D.26577;
  int D.26584;
  long int D.26586;
  guint8 * D.26587;
  long int D.26588;
  long int D.26589;
  int D.26590;
  int D.26591;
  long unsigned int D.26592;
  long unsigned int D.26593;
  gint32 * D.26594;
  int D.26595;
  int D.26599;
  long unsigned int D.26600;
  long unsigned int D.26601;
  gint32 * D.26602;
  int D.26607;
  _Bool D.26608;
  long int D.26609;
  long int D.26610;
  int D.26615;
  _Bool D.26616;
  long int D.26617;
  long int D.26618;
  sizetype D.26621;
  sizetype D.26622;
  sizetype D.26623;
  gint32 * D.26624;
  long unsigned int D.26629;
  struct JitInfoMap * D.26630;
  int D.26631;
  long unsigned int D.26634;
  long unsigned int D.26635;
  gint32 * D.26636;
  int D.26637;
  sizetype D.26638;
  guint8 * D.26639;
  guint32 * D.26640;
  unsigned int D.26641;
  sizetype D.26642;
  long int code.78;
  long int D.26646;
  int iftmp.79;
  sizetype D.26653;
  guint8 * D.26654;
  _Bool D.26655;
  long int D.26656;
  long int D.26657;
  struct GHashTable * D.26662;
  _Bool D.26667;
  long int D.26668;
  long int D.26669;
  const void * D.26672;
  _Bool D.26675;
  long int D.26676;
  long int D.26677;
  <unnamed-unsigned:24> D.26683;
  int D.26684;
  guint32 * D.26687;
  unsigned int D.26688;
  _Bool D.26689;
  long int D.26690;
  long int D.26691;
  guint32 * D.26694;
  unsigned int D.26695;
  unsigned int method_index.80;
  guint32 * D.26701;
  unsigned int D.26702;
  sizetype D.26703;
  guint8 * p.81;
  guint8 * p.82;
  int D.26709;
  int D.26710;
  _Bool D.26711;
  long int D.26712;
  long int D.26713;
  unsigned int code_len.83;
  void * D.26717;
  _Bool D.26718;
  long int D.26719;
  long int D.26720;
  int D.26723;
  sizetype D.26724;
  guint8 * D.26725;
  _Bool D.26726;
  long int D.26727;
  long int D.26728;
  int D.26736;
  unsigned int D.26737;
  unsigned int D.26738;
  int D.26739;
  long unsigned int D.26742;
  long unsigned int D.26743;
  struct JitInfoMap * D.26744;
  struct JitInfoMap * * D.26745;
  void * D.26746;
  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.26527 = amodule->info.nmethods;
      nmethods = (int) D.26527;
      if (amodule == 0B) goto <D.26528>; else goto <D.26529>;
      <D.26528>:
      D.26530 = 0B;
      return D.26530;
      <D.26529>:
      D.26531 = mono_get_root_domain ();
      if (D.26531 != domain) goto <D.26532>; else goto <D.26533>;
      <D.26532>:
      D.26530 = 0B;
      return D.26530;
      <D.26533>:
      async = mono_thread_info_is_async_context ();
      addr.77 = (long int) addr;
      D.26535 = amodule->code;
      D.26536 = (long int) D.26535;
      D.26537 = addr.77 - D.26536;
      offset = (int) D.26537;
      D.26538 = amodule->sorted_code_offsets;
      if (D.26538 == 0B) goto <D.26539>; else goto <D.26540>;
      <D.26539>:
      D.26541 = nmethods * 2;
      D.26542 = (long unsigned int) D.26541;
      D.26543 = D.26542 * 4;
      code_offsets = monoeg_malloc0 (D.26543);
      offsets_len = 0;
      i = 0;
      goto <D.24245>;
      <D.24244>:
      D.26544 = amodule->code_offsets;
      D.26545 = (long unsigned int) i;
      D.26546 = D.26545 * 4;
      D.26547 = D.26544 + D.26546;
      D.26548 = *D.26547;
      if (D.26548 == -1) goto <D.26549>; else goto <D.26550>;
      <D.26549>:
      // predicted unlikely by continue predictor.
      goto <D.24243>;
      <D.26550>:
      D.26551 = offsets_len * 2;
      D.26552 = (long unsigned int) D.26551;
      D.26553 = D.26552 * 4;
      D.26554 = code_offsets + D.26553;
      D.26544 = amodule->code_offsets;
      D.26545 = (long unsigned int) i;
      D.26546 = D.26545 * 4;
      D.26547 = D.26544 + D.26546;
      D.26548 = *D.26547;
      *D.26554 = D.26548;
      D.26551 = offsets_len * 2;
      D.26555 = (sizetype) D.26551;
      D.26556 = D.26555 + 1;
      D.26557 = D.26556 * 4;
      D.26558 = code_offsets + D.26557;
      *D.26558 = i;
      offsets_len = offsets_len + 1;
      <D.24243>:
      i = i + 1;
      <D.24245>:
      if (i < nmethods) goto <D.24244>; else goto <D.24246>;
      <D.24246>:
      msort_code_offsets (code_offsets, offsets_len);
      i = 0;
      goto <D.24248>;
      <D.24247>:
      D.26559 = i * 2;
      D.26560 = (long unsigned int) D.26559;
      D.26561 = D.26560 * 4;
      D.26562 = code_offsets + D.26561;
      D.26563 = *D.26562;
      D.26564 = i + 1;
      D.26565 = D.26564 * 2;
      D.26566 = (long unsigned int) D.26565;
      D.26567 = D.26566 * 4;
      D.26568 = code_offsets + D.26567;
      D.26569 = *D.26568;
      D.26570 = D.26563 > D.26569;
      D.26571 = (long int) D.26570;
      D.26572 = __builtin_expect (D.26571, 0);
      if (D.26572 != 0) goto <D.26573>; else goto <D.26574>;
      <D.26573>:
      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.26574>:
      i = i + 1;
      <D.24248>:
      D.26575 = offsets_len + -1;
      if (D.26575 > i) goto <D.24247>; else goto <D.24249>;
      <D.24249>:
      amodule->sorted_code_offsets_len = offsets_len;
      mono_memory_barrier ();
      D.26576 = &amodule->sorted_code_offsets;
      D.26577 = InterlockedCompareExchangePointer (D.26576, code_offsets, 0B);
      if (D.26577 != 0B) goto <D.26578>; else goto <D.26579>;
      <D.26578>:
      monoeg_g_free (code_offsets);
      <D.26579>:
      <D.26540>:
      code_offsets = amodule->sorted_code_offsets;
      offsets_len = amodule->sorted_code_offsets_len;
      if (offsets_len > 0) goto <D.26582>; else goto <D.26583>;
      <D.26582>:
      D.26584 = *code_offsets;
      if (D.26584 > offset) goto <D.26580>; else goto <D.26585>;
      <D.26585>:
      D.26586 = (long int) offset;
      D.26587 = amodule->code_end;
      D.26588 = (long int) D.26587;
      D.26535 = amodule->code;
      D.26536 = (long int) D.26535;
      D.26589 = D.26588 - D.26536;
      if (D.26586 >= D.26589) goto <D.26580>; else goto <D.26581>;
      <D.26580>:
      D.26530 = 0B;
      return D.26530;
      <D.26581>:
      <D.26583>:
      left = 0;
      right = offsets_len;
      <D.24251>:
      D.26590 = left + right;
      pos = D.26590 / 2;
      D.26591 = pos * 2;
      D.26592 = (long unsigned int) D.26591;
      D.26593 = D.26592 * 4;
      D.26594 = code_offsets + D.26593;
      offset1 = *D.26594;
      D.26595 = pos + 1;
      if (D.26595 == offsets_len) goto <D.26596>; else goto <D.26597>;
      <D.26596>:
      D.26587 = amodule->code_end;
      D.26588 = (long int) D.26587;
      D.26535 = amodule->code;
      D.26536 = (long int) D.26535;
      D.26589 = D.26588 - D.26536;
      offset2 = (int) D.26589;
      goto <D.26598>;
      <D.26597>:
      D.26595 = pos + 1;
      D.26599 = D.26595 * 2;
      D.26600 = (long unsigned int) D.26599;
      D.26601 = D.26600 * 4;
      D.26602 = code_offsets + D.26601;
      offset2 = *D.26602;
      <D.26598>:
      if (offset < offset1) goto <D.26603>; else goto <D.26604>;
      <D.26603>:
      right = pos;
      goto <D.26605>;
      <D.26604>:
      if (offset >= offset2) goto <D.26606>; else goto <D.24250>;
      <D.26606>:
      left = pos + 1;
      <D.26605>:
      goto <D.24251>;
      <D.24250>:
      D.26591 = pos * 2;
      D.26592 = (long unsigned int) D.26591;
      D.26593 = D.26592 * 4;
      D.26594 = code_offsets + D.26593;
      D.26607 = *D.26594;
      D.26608 = D.26607 > offset;
      D.26609 = (long int) D.26608;
      D.26610 = __builtin_expect (D.26609, 0);
      if (D.26610 != 0) goto <D.26611>; else goto <D.26612>;
      <D.26611>:
      monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "aot-runtime.c", 2819, "offset >= code_offsets [(pos * 2)]");
      <D.26612>:
      D.26595 = pos + 1;
      if (D.26595 < offsets_len) goto <D.26613>; else goto <D.26614>;
      <D.26613>:
      D.26595 = pos + 1;
      D.26599 = D.26595 * 2;
      D.26600 = (long unsigned int) D.26599;
      D.26601 = D.26600 * 4;
      D.26602 = code_offsets + D.26601;
      D.26615 = *D.26602;
      D.26616 = D.26615 <= offset;
      D.26617 = (long int) D.26616;
      D.26618 = __builtin_expect (D.26617, 0);
      if (D.26618 != 0) goto <D.26619>; else goto <D.26620>;
      <D.26619>:
      monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "aot-runtime.c", 2821, "offset < code_offsets [((pos + 1) * 2)]");
      <D.26620>:
      <D.26614>:
      D.26591 = pos * 2;
      D.26621 = (sizetype) D.26591;
      D.26622 = D.26621 + 1;
      D.26623 = D.26622 * 4;
      D.26624 = code_offsets + D.26623;
      method_index = *D.26624;
      if (async != 0) goto <D.26625>; else goto <D.26626>;
      <D.26625>:
      {
        struct JitInfoMap * table;
        int len;

        table = amodule->async_jit_info_table;
        if (table != 0B) goto <D.26627>; else goto <D.26628>;
        <D.26627>:
        len = table->method_index;
        i = 1;
        goto <D.24255>;
        <D.24254>:
        D.26545 = (long unsigned int) i;
        D.26629 = D.26545 * 16;
        D.26630 = table + D.26629;
        D.26631 = D.26630->method_index;
        if (D.26631 == method_index) goto <D.26632>; else goto <D.26633>;
        <D.26632>:
        D.26545 = (long unsigned int) i;
        D.26629 = D.26545 * 16;
        D.26630 = table + D.26629;
        D.26530 = D.26630->jinfo;
        return D.26530;
        <D.26633>:
        i = i + 1;
        <D.24255>:
        if (i < len) goto <D.24254>; else goto <D.24256>;
        <D.24256>:
        <D.26628>:
      }
      <D.26626>:
      D.26535 = amodule->code;
      D.26544 = amodule->code_offsets;
      D.26634 = (long unsigned int) method_index;
      D.26635 = D.26634 * 4;
      D.26636 = D.26544 + D.26635;
      D.26637 = *D.26636;
      D.26638 = (sizetype) D.26637;
      code = D.26535 + D.26638;
      D.26639 = amodule->blob;
      D.26640 = amodule->ex_info_offsets;
      D.26641 = mono_aot_get_offset (D.26640, method_index);
      D.26642 = (sizetype) D.26641;
      ex_info = D.26639 + D.26642;
      D.26575 = offsets_len + -1;
      if (D.26575 == pos) goto <D.26643>; else goto <D.26644>;
      <D.26643>:
      D.26587 = amodule->code_end;
      D.26588 = (long int) D.26587;
      code.78 = (long int) code;
      D.26646 = D.26588 - code.78;
      code_len = (int) D.26646;
      goto <D.26647>;
      <D.26644>:
      D.26595 = pos + 1;
      D.26599 = D.26595 * 2;
      D.26600 = (long unsigned int) D.26599;
      D.26601 = D.26600 * 4;
      D.26602 = code_offsets + D.26601;
      D.26615 = *D.26602;
      D.26591 = pos * 2;
      D.26592 = (long unsigned int) D.26591;
      D.26593 = D.26592 * 4;
      D.26594 = code_offsets + D.26593;
      D.26607 = *D.26594;
      code_len = D.26615 - D.26607;
      <D.26647>:
      if (code > addr) goto <D.26649>; else goto <D.26652>;
      <D.26652>:
      D.26653 = (sizetype) code_len;
      D.26654 = code + D.26653;
      if (D.26654 <= addr) goto <D.26649>; else goto <D.26650>;
      <D.26649>:
      iftmp.79 = 1;
      goto <D.26651>;
      <D.26650>:
      iftmp.79 = 0;
      <D.26651>:
      D.26655 = iftmp.79 != 0;
      D.26656 = (long int) D.26655;
      D.26657 = __builtin_expect (D.26656, 0);
      if (D.26657 != 0) goto <D.26658>; else goto <D.26659>;
      <D.26658>:
      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.26659>:
      if (async == 0) goto <D.26660>; else goto <D.26661>;
      <D.26660>:
      D.26662 = amodule->extra_methods;
      if (D.26662 != 0B) goto <D.26663>; else goto <D.26664>;
      <D.26663>:
      {
        int ret;

        ret = pthread_mutex_lock (&aot_mutex.mutex);
        if (ret != 0) goto <D.26665>; else goto <D.26666>;
        <D.26665>:
        monoeg_g_log (0B, 16, "Bad call to mono_mutex_lock result %d", ret);
        <D.26666>:
        D.26667 = ret != 0;
        D.26668 = (long int) D.26667;
        D.26669 = __builtin_expect (D.26668, 0);
        if (D.26669 != 0) goto <D.26670>; else goto <D.26671>;
        <D.26670>:
        monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "aot-runtime.c", 2851, "ret == 0");
        <D.26671>:
      }
      D.26634 = (long unsigned int) method_index;
      D.26672 = (const void *) D.26634;
      D.26662 = amodule->extra_methods;
      method = monoeg_g_hash_table_lookup (D.26662, D.26672);
      {
        int ret;

        ret = pthread_mutex_unlock (&aot_mutex.mutex);
        if (ret != 0) goto <D.26673>; else goto <D.26674>;
        <D.26673>:
        monoeg_g_log (0B, 16, "Bad call to mono_mutex_unlock result %d", ret);
        <D.26674>:
        D.26675 = ret != 0;
        D.26676 = (long int) D.26675;
        D.26677 = __builtin_expect (D.26676, 0);
        if (D.26677 != 0) goto <D.26678>; else goto <D.26679>;
        <D.26678>:
        monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "aot-runtime.c", 2853, "ret == 0");
        <D.26679>:
      }
      goto <D.26680>;
      <D.26664>:
      method = 0B;
      <D.26680>:
      if (method == 0B) goto <D.26681>; else goto <D.26682>;
      <D.26681>:
      D.26683 = image->tables[6].rows;
      D.26684 = (int) D.26683;
      if (D.26684 <= method_index) goto <D.26685>; else goto <D.26686>;
      <D.26685>:
      D.26687 = amodule->extra_method_info_offsets;
      D.26688 = *D.26687;
      table_len = (int) D.26688;
      D.26687 = amodule->extra_method_info_offsets;
      table = D.26687 + 4;
      left = 0;
      right = table_len;
      pos = 0;
      <D.24260>:
      D.26590 = left + right;
      pos = D.26590 / 2;
      D.26689 = pos >= table_len;
      D.26690 = (long int) D.26689;
      D.26691 = __builtin_expect (D.26690, 0);
      if (D.26691 != 0) goto <D.26692>; else goto <D.26693>;
      <D.26692>:
      monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "aot-runtime.c", 2874, "pos < table_len");
      <D.26693>:
      D.26591 = pos * 2;
      D.26592 = (long unsigned int) D.26591;
      D.26593 = D.26592 * 4;
      D.26694 = table + D.26593;
      D.26695 = *D.26694;
      method_index.80 = (unsigned int) method_index;
      if (D.26695 < method_index.80) goto <D.26697>; else goto <D.26698>;
      <D.26697>:
      left = pos + 1;
      goto <D.26699>;
      <D.26698>:
      D.26591 = pos * 2;
      D.26592 = (long unsigned int) D.26591;
      D.26593 = D.26592 * 4;
      D.26694 = table + D.26593;
      D.26695 = *D.26694;
      method_index.80 = (unsigned int) method_index;
      if (D.26695 > method_index.80) goto <D.26700>; else goto <D.24259>;
      <D.26700>:
      right = pos;
      <D.26699>:
      goto <D.24260>;
      <D.24259>:
      D.26639 = amodule->blob;
      D.26591 = pos * 2;
      D.26621 = (sizetype) D.26591;
      D.26622 = D.26621 + 1;
      D.26623 = D.26622 * 4;
      D.26701 = table + D.26623;
      D.26702 = *D.26701;
      D.26703 = (sizetype) D.26702;
      p.81 = D.26639 + D.26703;
      p = p.81;
      p.82 = p;
      method = decode_resolve_method_ref (amodule, p.82, &p);
      if (method == 0B) goto <D.26706>; else goto <D.26707>;
      <D.26706>:
      D.26530 = 0B;
      return D.26530;
      <D.26707>:
      goto <D.26708>;
      <D.26686>:
      D.26709 = method_index + 1;
      D.26710 = D.26709 | 100663296;
      token = (guint32) D.26710;
      method = mono_get_method (image, token, 0B);
      <D.26708>:
      <D.26682>:
      D.26711 = method == 0B;
      D.26712 = (long int) D.26711;
      D.26713 = __builtin_expect (D.26712, 0);
      if (D.26713 != 0) goto <D.26714>; else goto <D.26715>;
      <D.26714>:
      monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "aot-runtime.c", 2895, "method");
      <D.26715>:
      <D.26661>:
      code_len.83 = (unsigned int) code_len;
      jinfo = decode_exception_debug_info (amodule, domain, method, ex_info, addr, code, code_len.83);
      D.26717 = jinfo->code_start;
      D.26718 = D.26717 > addr;
      D.26719 = (long int) D.26718;
      D.26720 = __builtin_expect (D.26719, 0);
      if (D.26720 != 0) goto <D.26721>; else goto <D.26722>;
      <D.26721>:
      monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "aot-runtime.c", 2902, "(guint8*)addr >= (guint8*)jinfo->code_start");
      <D.26722>:
      D.26717 = jinfo->code_start;
      D.26723 = jinfo->code_size;
      D.26724 = (sizetype) D.26723;
      D.26725 = D.26717 + D.26724;
      D.26726 = D.26725 <= addr;
      D.26727 = (long int) D.26726;
      D.26728 = __builtin_expect (D.26727, 0);
      if (D.26728 != 0) goto <D.26729>; else goto <D.26730>;
      <D.26729>:
      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.26730>:
      if (async != 0) goto <D.26731>; else goto <D.26732>;
      <D.26731>:
      {
        struct JitInfoMap * old_table;
        struct JitInfoMap * new_table;
        int len;

        <D.24265>:
        old_table = amodule->async_jit_info_table;
        if (old_table != 0B) goto <D.26733>; else goto <D.26734>;
        <D.26733>:
        len = old_table->method_index;
        goto <D.26735>;
        <D.26734>:
        len = 1;
        <D.26735>:
        D.26736 = len + 1;
        D.26737 = (unsigned int) D.26736;
        D.26738 = D.26737 * 16;
        D.26739 = (int) D.26738;
        new_table = alloc0_jit_info_data (domain, D.26739, async);
        if (old_table != 0B) goto <D.26740>; else goto <D.26741>;
        <D.26740>:
        D.26742 = (long unsigned int) len;
        D.26743 = D.26742 * 16;
        memcpy (new_table, old_table, D.26743);
        <D.26741>:
        D.26736 = len + 1;
        new_table->method_index = D.26736;
        D.26742 = (long unsigned int) len;
        D.26743 = D.26742 * 16;
        D.26744 = new_table + D.26743;
        D.26744->method_index = method_index;
        D.26742 = (long unsigned int) len;
        D.26743 = D.26742 * 16;
        D.26744 = new_table + D.26743;
        D.26744->jinfo = jinfo;
        mono_memory_barrier ();
        D.26745 = &amodule->async_jit_info_table;
        D.26746 = InterlockedCompareExchangePointer (D.26745, new_table, old_table);
        if (D.26746 == old_table) goto <D.24264>; else goto <D.26747>;
        <D.26747>:
        goto <D.24265>;
        <D.24264>:
      }
      goto <D.26748>;
      <D.26732>:
      mono_jit_info_table_add (domain, jinfo);
      <D.26748>:
      D.26530 = jinfo;
      return D.26530;
    }
  finally
    {
      p = {CLOBBER};
    }
}


msort_code_offsets (gint32 * array, int len)
{
  int D.26751;
  long unsigned int D.26752;
  long unsigned int D.26753;
  int D.26754;
  gint32 * scratch;

  D.26751 = len * 2;
  D.26752 = (long unsigned int) D.26751;
  D.26753 = D.26752 * 4;
  scratch = monoeg_malloc (D.26753);
  D.26754 = len + -1;
  msort_code_offsets_internal (array, 0, D.26754, scratch);
  monoeg_g_free (scratch);
}


msort_code_offsets_internal (gint32 * array, int lo, int hi, gint32 * scratch)
{
  int D.26755;
  int D.26758;
  int D.26761;
  long unsigned int D.26762;
  long unsigned int D.26763;
  gint32 * D.26764;
  int D.26765;
  sizetype D.26766;
  sizetype D.26767;
  sizetype D.26768;
  gint32 * D.26769;
  int D.26770;
  int D.26774;
  int D.26775;
  long unsigned int D.26776;
  long unsigned int D.26777;
  gint32 * D.26778;
  int D.26779;
  int D.26780;
  long unsigned int D.26781;
  long unsigned int D.26782;
  gint32 * D.26783;
  int D.26784;
  int D.26792;
  long unsigned int D.26793;
  long unsigned int D.26794;
  gint32 * D.26795;
  int D.26796;
  int D.26797;
  long unsigned int D.26798;
  long unsigned int D.26799;
  gint32 * D.26800;
  int D.26801;
  gint32 * D.26802;
  sizetype D.26803;
  sizetype D.26804;
  gint32 * D.26805;
  sizetype D.26806;
  sizetype D.26807;
  sizetype D.26808;
  gint32 * D.26809;
  int D.26810;
  sizetype D.26811;
  sizetype D.26812;
  sizetype D.26813;
  gint32 * D.26814;
  int D.26815;
  int D.26816;
  gint32 * D.26817;
  int D.26818;
  int mid;
  int i;
  int t_lo;
  int t_hi;

  D.26755 = lo + hi;
  mid = D.26755 / 2;
  if (lo >= hi) goto <D.26756>; else goto <D.26757>;
  <D.26756>:
  return;
  <D.26757>:
  D.26758 = hi - lo;
  if (D.26758 <= 31) goto <D.26759>; else goto <D.26760>;
  <D.26759>:
  i = lo;
  goto <D.24204>;
  <D.24203>:
  D.26761 = i * 2;
  D.26762 = (long unsigned int) D.26761;
  D.26763 = D.26762 * 4;
  D.26764 = array + D.26763;
  D.26765 = *D.26764;
  D.26761 = i * 2;
  D.26766 = (sizetype) D.26761;
  D.26767 = D.26766 + 2;
  D.26768 = D.26767 * 4;
  D.26769 = array + D.26768;
  D.26770 = *D.26769;
  if (D.26765 > D.26770) goto <D.24202>; else goto <D.26771>;
  <D.26771>:
  i = i + 1;
  <D.24204>:
  if (i < hi) goto <D.24203>; else goto <D.24202>;
  <D.24202>:
  if (i == hi) goto <D.26772>; else goto <D.26773>;
  <D.26772>:
  return;
  <D.26773>:
  <D.26760>:
  msort_code_offsets_internal (array, lo, mid, scratch);
  D.26774 = mid + 1;
  msort_code_offsets_internal (array, D.26774, hi, scratch);
  D.26775 = mid * 2;
  D.26776 = (long unsigned int) D.26775;
  D.26777 = D.26776 * 4;
  D.26778 = array + D.26777;
  D.26779 = *D.26778;
  D.26774 = mid + 1;
  D.26780 = D.26774 * 2;
  D.26781 = (long unsigned int) D.26780;
  D.26782 = D.26781 * 4;
  D.26783 = array + D.26782;
  D.26784 = *D.26783;
  if (D.26779 < D.26784) goto <D.26785>; else goto <D.26786>;
  <D.26785>:
  return;
  <D.26786>:
  t_lo = lo;
  t_hi = mid + 1;
  i = lo;
  goto <D.24206>;
  <D.24205>:
  if (t_lo <= mid) goto <D.26790>; else goto <D.26787>;
  <D.26790>:
  if (t_hi > hi) goto <D.26788>; else goto <D.26791>;
  <D.26791>:
  D.26792 = t_lo * 2;
  D.26793 = (long unsigned int) D.26792;
  D.26794 = D.26793 * 4;
  D.26795 = array + D.26794;
  D.26796 = *D.26795;
  D.26797 = t_hi * 2;
  D.26798 = (long unsigned int) D.26797;
  D.26799 = D.26798 * 4;
  D.26800 = array + D.26799;
  D.26801 = *D.26800;
  if (D.26796 < D.26801) goto <D.26788>; else goto <D.26787>;
  <D.26788>:
  D.26761 = i * 2;
  D.26762 = (long unsigned int) D.26761;
  D.26763 = D.26762 * 4;
  D.26802 = scratch + D.26763;
  D.26792 = t_lo * 2;
  D.26793 = (long unsigned int) D.26792;
  D.26794 = D.26793 * 4;
  D.26795 = array + D.26794;
  D.26796 = *D.26795;
  *D.26802 = D.26796;
  D.26761 = i * 2;
  D.26766 = (sizetype) D.26761;
  D.26803 = D.26766 + 1;
  D.26804 = D.26803 * 4;
  D.26805 = scratch + D.26804;
  D.26792 = t_lo * 2;
  D.26806 = (sizetype) D.26792;
  D.26807 = D.26806 + 1;
  D.26808 = D.26807 * 4;
  D.26809 = array + D.26808;
  D.26810 = *D.26809;
  *D.26805 = D.26810;
  t_lo = t_lo + 1;
  goto <D.26789>;
  <D.26787>:
  D.26761 = i * 2;
  D.26762 = (long unsigned int) D.26761;
  D.26763 = D.26762 * 4;
  D.26802 = scratch + D.26763;
  D.26797 = t_hi * 2;
  D.26798 = (long unsigned int) D.26797;
  D.26799 = D.26798 * 4;
  D.26800 = array + D.26799;
  D.26801 = *D.26800;
  *D.26802 = D.26801;
  D.26761 = i * 2;
  D.26766 = (sizetype) D.26761;
  D.26803 = D.26766 + 1;
  D.26804 = D.26803 * 4;
  D.26805 = scratch + D.26804;
  D.26797 = t_hi * 2;
  D.26811 = (sizetype) D.26797;
  D.26812 = D.26811 + 1;
  D.26813 = D.26812 * 4;
  D.26814 = array + D.26813;
  D.26815 = *D.26814;
  *D.26805 = D.26815;
  t_hi = t_hi + 1;
  <D.26789>:
  i = i + 1;
  <D.24206>:
  if (i <= hi) goto <D.24205>; else goto <D.24207>;
  <D.24207>:
  i = lo;
  goto <D.24209>;
  <D.24208>:
  D.26761 = i * 2;
  D.26762 = (long unsigned int) D.26761;
  D.26763 = D.26762 * 4;
  D.26764 = array + D.26763;
  D.26761 = i * 2;
  D.26762 = (long unsigned int) D.26761;
  D.26763 = D.26762 * 4;
  D.26802 = scratch + D.26763;
  D.26816 = *D.26802;
  *D.26764 = D.26816;
  D.26761 = i * 2;
  D.26766 = (sizetype) D.26761;
  D.26803 = D.26766 + 1;
  D.26804 = D.26803 * 4;
  D.26817 = array + D.26804;
  D.26761 = i * 2;
  D.26766 = (sizetype) D.26761;
  D.26803 = D.26766 + 1;
  D.26804 = D.26803 * 4;
  D.26805 = scratch + D.26804;
  D.26818 = *D.26805;
  *D.26817 = D.26818;
  i = i + 1;
  <D.24209>:
  if (i <= hi) goto <D.24208>; else goto <D.24210>;
  <D.24210>:
}


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.84;
  int D.26821;
  unsigned int D.26822;
  _Bool D.26823;
  unsigned int D.26824;
  _Bool D.26825;
  unsigned int D.26826;
  _Bool D.26827;
  unsigned int D.26828;
  _Bool D.26829;
  unsigned int D.26830;
  _Bool D.26831;
  unsigned int D.26832;
  _Bool D.26833;
  unsigned int D.26834;
  _Bool D.26835;
  unsigned int D.26836;
  _Bool D.26837;
  int D.26840;
  _Bool D.26841;
  long int D.26842;
  long int D.26843;
  int D.26847;
  long unsigned int D.26853;
  unsigned int D.26854;
  unsigned int D.26855;
  unsigned int D.26856;
  _Bool D.26866;
  long int D.26867;
  long int D.26868;
  long unsigned int D.26871;
  long unsigned int D.26872;
  long unsigned int D.26873;
  long unsigned int D.26874;
  long unsigned int D.26875;
  int D.26876;
  unsigned int D.26877;
  int D.26878;
  struct MonoClass * D.26881;
  long unsigned int D.26883;
  struct GSList * * D.26884;
  long int D.26885;
  void * D.26886;
  struct GSList * D.26887;
  struct GSList * D.26888;
  int D.26889;
  int D.26890;
  unsigned int D.26892;
  unsigned int D.26893;
  unsigned int generic_info_size.85;
  unsigned int D.26895;
  unsigned int try_holes_info_size.86;
  unsigned int D.26897;
  unsigned int arch_eh_jit_info_size.87;
  unsigned int D.26899;
  unsigned int D.26900;
  short unsigned int D.26901;
  <unnamed-unsigned:15> D.26902;
  int D.26903;
  unsigned int D.26904;
  int D.26905;
  unsigned int D.26906;
  unsigned int D.26907;
  int D.26910;
  sizetype D.26911;
  void * D.26912;
  sizetype D.26918;
  guint8 * p.88;
  struct MonoClass * D.26921;
  int D.26922;
  sizetype D.26923;
  void * D.26924;
  int D.26925;
  sizetype D.26926;
  void * D.26927;
  int D.26928;
  sizetype D.26929;
  void * D.26930;
  <unnamed-unsigned:15> D.26931;
  int D.26932;
  int code_len.89;
  _Bool D.26936;
  long int D.26937;
  long int D.26938;
  short unsigned int D.26941;
  int D.26942;
  short unsigned int D.26943;
  int D.26944;
  short unsigned int D.26945;
  int D.26946;
  unsigned int D.26947;
  int D.26950;
  unsigned int D.26951;
  struct MonoJitInfo * D.26954;
  _Bool D.26957;
  long int D.26958;
  long int D.26959;
  int D.26962;
  int D.26963;
  unsigned int D.26966;
  unsigned int D.26967;
  int D.26968;
  void * D.26969;
  struct MonoDwarfLocListEntry * D.26970;
  long unsigned int D.26971;
  int D.26972;
  int D.26973;
  int D.26974;
  int D.26977;
  int D.26980;
  int D.26981;
  int this_reg.90;
  _Bool D.26986;
  <unnamed-signed:1> D.26987;
  unsigned char D.26988;
  int this_offset.91;
  int D.26991;
  signed char D.26992;
  <unnamed-signed:1> D.26993;
  int D.26994;
  unsigned char D.26995;
  int D.26996;
  sizetype D.26999;
  guint8 * p.92;
  struct MonoMethod * D.27002;
  void * D.27003;
  int D.27004;
  unsigned int n.93;
  unsigned int D.27010;
  int D.27011;
  void * D.27012;
  gboolean * D.27013;
  long unsigned int D.27014;
  long unsigned int D.27015;
  gboolean * D.27016;
  int D.27017;
  void * D.27020;
  gboolean * D.27021;
  gboolean * D.27022;
  int D.27023;
  _Bool D.27024;
  _Bool D.27025;
  _Bool D.27026;
  long unsigned int D.27029;
  long unsigned int D.27030;
  long unsigned int D.27031;
  int D.27032;
  int D.27033;
  int D.27034;
  int D.27035;
  int D.27036;
  long unsigned int D.27037;
  long unsigned int D.27038;
  void * D.27039;
  int * D.27040;
  long unsigned int D.27041;
  long unsigned int D.27042;
  int * D.27043;
  int D.27044;
  union mono_mutex_t * D.27045;
  _Bool D.27048;
  long int D.27049;
  long int D.27050;
  void * D.27053;
  struct GHashTable * D.27054;
  _Bool D.27057;
  long int D.27058;
  long int D.27059;
  unsigned int buf_len.94;
  sizetype D.27065;
  guint8 * p.95;
  guint8 * p.96;
  long unsigned int p.97;
  long unsigned int D.27071;
  sizetype D.27072;
  guint8 * p.98;
  struct MonoMethod * D.27074;
  struct MonoClass * D.27075;
  struct MonoImage * D.27076;
  void * D.27077;
  _Bool D.27082;
  long int D.27083;
  long int D.27084;
  struct GHashTable * ji_to_amodule.99;
  struct GHashTable * ji_to_amodule.100;
  _Bool D.27093;
  long int D.27094;
  long int D.27095;
  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.84 = p;
      D.26821 = decode_value (p.84, &p);
      flags = (guint) D.26821;
      D.26822 = flags & 1;
      D.26823 = D.26822 != 0;
      has_generic_jit_info = (gboolean) D.26823;
      D.26824 = flags & 2;
      D.26825 = D.26824 != 0;
      has_dwarf_unwind_info = (gboolean) D.26825;
      D.26826 = flags & 4;
      D.26827 = D.26826 != 0;
      has_clauses = (gboolean) D.26827;
      D.26828 = flags & 8;
      D.26829 = D.26828 != 0;
      has_seq_points = (gboolean) D.26829;
      D.26830 = flags & 16;
      D.26831 = D.26830 != 0;
      from_llvm = (gboolean) D.26831;
      D.26832 = flags & 32;
      D.26833 = D.26832 != 0;
      has_try_block_holes = (gboolean) D.26833;
      D.26834 = flags & 64;
      D.26835 = D.26834 != 0;
      has_gc_map = (gboolean) D.26835;
      D.26836 = flags & 128;
      D.26837 = D.26836 != 0;
      has_arch_eh_jit_info = (gboolean) D.26837;
      if (has_dwarf_unwind_info != 0) goto <D.26838>; else goto <D.26839>;
      <D.26838>:
      {
        guint32 offset;

        p.84 = p;
        D.26840 = decode_value (p.84, &p);
        offset = (guint32) D.26840;
        D.26841 = offset > 1073741823;
        D.26842 = (long int) D.26841;
        D.26843 = __builtin_expect (D.26842, 0);
        if (D.26843 != 0) goto <D.26844>; else goto <D.26845>;
        <D.26844>:
        monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "aot-runtime.c", 2383, "offset < (1 << 30)");
        <D.26845>:
        used_int_regs = offset;
      }
      goto <D.26846>;
      <D.26839>:
      p.84 = p;
      D.26847 = decode_value (p.84, &p);
      used_int_regs = (guint) D.26847;
      <D.26846>:
      if (has_generic_jit_info != 0) goto <D.26848>; else goto <D.26849>;
      <D.26848>:
      generic_info_size = 32;
      goto <D.26850>;
      <D.26849>:
      generic_info_size = 0;
      <D.26850>:
      if (has_try_block_holes != 0) goto <D.26851>; else goto <D.26852>;
      <D.26851>:
      p.84 = p;
      num_holes = decode_value (p.84, &p);
      D.26853 = (long unsigned int) num_holes;
      D.26854 = (unsigned int) D.26853;
      D.26855 = D.26854 * 8;
      D.26856 = D.26855 + 4;
      try_holes_info_size = (int) D.26856;
      goto <D.26857>;
      <D.26852>:
      try_holes_info_size = 0;
      num_holes = try_holes_info_size;
      <D.26857>:
      if (has_clauses != 0) goto <D.26858>; else goto <D.26859>;
      <D.26858>:
      p.84 = p;
      num_clauses = decode_value (p.84, &p);
      goto <D.26860>;
      <D.26859>:
      num_clauses = 0;
      <D.26860>:
      if (has_arch_eh_jit_info != 0) goto <D.26861>; else goto <D.26862>;
      <D.26861>:
      arch_eh_jit_info_size = 4;
      goto <D.26863>;
      <D.26862>:
      arch_eh_jit_info_size = 0;
      <D.26863>:
      if (from_llvm != 0) goto <D.26864>; else goto <D.26865>;
      <D.26864>:
      {
        struct MonoJitExceptionInfo * clauses;
        struct GSList * * nesting;

        D.26866 = async != 0;
        D.26867 = (long int) D.26866;
        D.26868 = __builtin_expect (D.26867, 0);
        if (D.26868 != 0) goto <D.26869>; else goto <D.26870>;
        <D.26869>:
        monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "aot-runtime.c", 2414, "!async");
        <D.26870>:
        D.26871 = (long unsigned int) num_clauses;
        D.26872 = D.26871 * 40;
        clauses = monoeg_malloc0 (D.26872);
        D.26871 = (long unsigned int) num_clauses;
        D.26873 = D.26871 * 8;
        nesting = monoeg_malloc0 (D.26873);
        i = 0;
        goto <D.24126>;
        <D.24125>:
        {
          struct MonoJitExceptionInfo * ei;

          D.26874 = (long unsigned int) i;
          D.26875 = D.26874 * 40;
          ei = clauses + D.26875;
          p.84 = p;
          D.26876 = decode_value (p.84, &p);
          D.26877 = (unsigned int) D.26876;
          ei->flags = D.26877;
          p.84 = p;
          D.26878 = decode_value (p.84, &p);
          if (D.26878 != 0) goto <D.26879>; else goto <D.26880>;
          <D.26879>:
          p.84 = p;
          D.26881 = decode_klass_ref (amodule, p.84, &p);
          ei->data.catch_class = D.26881;
          <D.26880>:
          <D.24124>:
          {
            int nesting_index;

            p.84 = p;
            nesting_index = decode_value (p.84, &p);
            if (nesting_index == -1) goto <D.24123>; else goto <D.26882>;
            <D.26882>:
            D.26874 = (long unsigned int) i;
            D.26883 = D.26874 * 8;
            D.26884 = nesting + D.26883;
            D.26885 = (long int) nesting_index;
            D.26886 = (void *) D.26885;
            D.26874 = (long unsigned int) i;
            D.26883 = D.26874 * 8;
            D.26884 = nesting + D.26883;
            D.26887 = *D.26884;
            D.26888 = monoeg_g_slist_prepend (D.26887, D.26886);
            *D.26884 = D.26888;
          }
          goto <D.24124>;
          <D.24123>:
        }
        i = i + 1;
        <D.24126>:
        if (i < num_clauses) goto <D.24125>; else goto <D.24127>;
        <D.24127>:
        D.26889 = generic_info_size + try_holes_info_size;
        D.26890 = D.26889 + arch_eh_jit_info_size;
        jinfo = decode_llvm_mono_eh_frame (amodule, domain, method, code, clauses, num_clauses, D.26890, nesting, &this_reg, &this_offset);
        jinfo->from_llvm = -1;
        monoeg_g_free (clauses);
        i = 0;
        goto <D.24129>;
        <D.24128>:
        D.26874 = (long unsigned int) i;
        D.26883 = D.26874 * 8;
        D.26884 = nesting + D.26883;
        D.26887 = *D.26884;
        monoeg_g_slist_free (D.26887);
        i = i + 1;
        <D.24129>:
        if (i < num_clauses) goto <D.24128>; else goto <D.24130>;
        <D.24130>:
        monoeg_g_free (nesting);
      }
      goto <D.26891>;
      <D.26865>:
      D.26871 = (long unsigned int) num_clauses;
      D.26892 = (unsigned int) D.26871;
      D.26893 = D.26892 * 40;
      generic_info_size.85 = (unsigned int) generic_info_size;
      D.26895 = D.26893 + generic_info_size.85;
      try_holes_info_size.86 = (unsigned int) try_holes_info_size;
      D.26897 = D.26895 + try_holes_info_size.86;
      arch_eh_jit_info_size.87 = (unsigned int) arch_eh_jit_info_size;
      D.26899 = D.26897 + arch_eh_jit_info_size.87;
      D.26900 = D.26899 + 48;
      len = (int) D.26900;
      jinfo = alloc0_jit_info_data (domain, len, async);
      D.26901 = (short unsigned int) num_clauses;
      D.26902 = (<unnamed-unsigned:15>) D.26901;
      jinfo->num_clauses = D.26902;
      i = 0;
      goto <D.24134>;
      <D.24133>:
      {
        struct MonoJitExceptionInfo * ei;

        ei = &jinfo->clauses[i];
        p.84 = p;
        D.26903 = decode_value (p.84, &p);
        D.26904 = (unsigned int) D.26903;
        ei->flags = D.26904;
        p.84 = p;
        D.26905 = decode_value (p.84, &p);
        ei->exvar_offset = D.26905;
        D.26906 = ei->flags;
        D.26907 = D.26906 + 4294967295;
        if (D.26907 <= 1) goto <D.26908>; else goto <D.26909>;
        <D.26908>:
        p.84 = p;
        D.26910 = decode_value (p.84, &p);
        D.26911 = (sizetype) D.26910;
        D.26912 = code + D.26911;
        ei->data.filter = D.26912;
        goto <D.26913>;
        <D.26909>:
        {
          int len;

          p.84 = p;
          len = decode_value (p.84, &p);
          if (len > 0) goto <D.26914>; else goto <D.26915>;
          <D.26914>:
          if (async != 0) goto <D.26916>; else goto <D.26917>;
          <D.26916>:
          p.84 = p;
          D.26918 = (sizetype) len;
          p.88 = p.84 + D.26918;
          p = p.88;
          goto <D.26920>;
          <D.26917>:
          p.84 = p;
          D.26921 = decode_klass_ref (amodule, p.84, &p);
          ei->data.catch_class = D.26921;
          <D.26920>:
          <D.26915>:
        }
        <D.26913>:
        p.84 = p;
        D.26922 = decode_value (p.84, &p);
        D.26923 = (sizetype) D.26922;
        D.26924 = code + D.26923;
        ei->try_start = D.26924;
        p.84 = p;
        D.26925 = decode_value (p.84, &p);
        D.26926 = (sizetype) D.26925;
        D.26927 = code + D.26926;
        ei->try_end = D.26927;
        p.84 = p;
        D.26928 = decode_value (p.84, &p);
        D.26929 = (sizetype) D.26928;
        D.26930 = code + D.26929;
        ei->handler_start = D.26930;
      }
      i = i + 1;
      <D.24134>:
      D.26931 = jinfo->num_clauses;
      D.26932 = (int) D.26931;
      if (D.26932 > i) goto <D.24133>; else goto <D.24135>;
      <D.24135>:
      code_len.89 = (int) code_len;
      jinfo->code_size = code_len.89;
      jinfo->used_regs = used_int_regs;
      jinfo->d.method = method;
      jinfo->code_start = code;
      jinfo->domain_neutral = 0;
      jinfo->from_aot = -1;
      <D.26891>:
      if (has_try_block_holes != 0) goto <D.26934>; else goto <D.26935>;
      <D.26934>:
      {
        struct MonoTryBlockHoleTableJitInfo * table;

        jinfo->has_try_block_holes = -1;
        table = mono_jit_info_get_try_block_hole_table_info (jinfo);
        D.26936 = table == 0B;
        D.26937 = (long int) D.26936;
        D.26938 = __builtin_expect (D.26937, 0);
        if (D.26938 != 0) goto <D.26939>; else goto <D.26940>;
        <D.26939>:
        monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "aot-runtime.c", 2491, "table");
        <D.26940>:
        D.26941 = (short unsigned int) num_holes;
        table->num_holes = D.26941;
        i = 0;
        goto <D.24139>;
        <D.24138>:
        {
          struct MonoTryBlockHoleJitInfo * hole;

          hole = &table->holes[i];
          p.84 = p;
          D.26942 = decode_value (p.84, &p);
          D.26943 = (short unsigned int) D.26942;
          hole->clause = D.26943;
          p.84 = p;
          D.26944 = decode_value (p.84, &p);
          D.26945 = (short unsigned int) D.26944;
          hole->length = D.26945;
          p.84 = p;
          D.26946 = decode_value (p.84, &p);
          D.26947 = (unsigned int) D.26946;
          hole->offset = D.26947;
        }
        i = i + 1;
        <D.24139>:
        if (i < num_holes) goto <D.24138>; else goto <D.24140>;
        <D.24140>:
      }
      <D.26935>:
      if (has_arch_eh_jit_info != 0) goto <D.26948>; else goto <D.26949>;
      <D.26948>:
      {
        struct MonoArchEHJitInfo * eh_info;

        jinfo->has_arch_eh_info = -1;
        eh_info = mono_jit_info_get_arch_eh_info (jinfo);
        p.84 = p;
        D.26950 = decode_value (p.84, &p);
        D.26951 = (unsigned int) D.26950;
        eh_info->stack_size = D.26951;
      }
      <D.26949>:
      if (async != 0) goto <D.26952>; else goto <D.26953>;
      <D.26952>:
      jinfo->async = -1;
      jinfo->d.aot_info = amodule;
      D.26954 = jinfo;
      return D.26954;
      <D.26953>:
      if (has_generic_jit_info != 0) goto <D.26955>; else goto <D.26956>;
      <D.26955>:
      {
        struct MonoGenericJitInfo * gi;
        int len;

        jinfo->has_generic_jit_info = -1;
        gi = mono_jit_info_get_generic_jit_info (jinfo);
        D.26957 = gi == 0B;
        D.26958 = (long int) D.26957;
        D.26959 = __builtin_expect (D.26958, 0);
        if (D.26959 != 0) goto <D.26960>; else goto <D.26961>;
        <D.26960>:
        monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "aot-runtime.c", 2526, "gi");
        <D.26961>:
        p.84 = p;
        D.26962 = decode_value (p.84, &p);
        gi->nlocs = D.26962;
        D.26963 = gi->nlocs;
        if (D.26963 != 0) goto <D.26964>; else goto <D.26965>;
        <D.26964>:
        D.26963 = gi->nlocs;
        D.26966 = (unsigned int) D.26963;
        D.26967 = D.26966 * 20;
        D.26968 = (int) D.26967;
        D.26969 = alloc0_jit_info_data (domain, D.26968, async);
        gi->locations = D.26969;
        i = 0;
        goto <D.24146>;
        <D.24145>:
        {
          struct MonoDwarfLocListEntry * entry;

          D.26970 = gi->locations;
          D.26874 = (long unsigned int) i;
          D.26971 = D.26874 * 20;
          entry = D.26970 + D.26971;
          p.84 = p;
          D.26972 = decode_value (p.84, &p);
          entry->is_reg = D.26972;
          p.84 = p;
          D.26973 = decode_value (p.84, &p);
          entry->reg = D.26973;
          D.26974 = entry->is_reg;
          if (D.26974 == 0) goto <D.26975>; else goto <D.26976>;
          <D.26975>:
          p.84 = p;
          D.26977 = decode_value (p.84, &p);
          entry->offset = D.26977;
          <D.26976>:
          if (i > 0) goto <D.26978>; else goto <D.26979>;
          <D.26978>:
          p.84 = p;
          D.26980 = decode_value (p.84, &p);
          entry->from = D.26980;
          <D.26979>:
          p.84 = p;
          D.26981 = decode_value (p.84, &p);
          entry->to = D.26981;
        }
        i = i + 1;
        <D.24146>:
        D.26963 = gi->nlocs;
        if (D.26963 > i) goto <D.24145>; else goto <D.24147>;
        <D.24147>:
        goto <D.26982>;
        <D.26965>:
        if (from_llvm != 0) goto <D.26983>; else goto <D.26984>;
        <D.26983>:
        this_reg.90 = this_reg;
        D.26986 = this_reg.90 != -1;
        D.26987 = (<unnamed-signed:1>) D.26986;
        gi->has_this = D.26987;
        this_reg.90 = this_reg;
        D.26988 = (unsigned char) this_reg.90;
        gi->this_reg = D.26988;
        this_offset.91 = this_offset;
        gi->this_offset = this_offset.91;
        goto <D.26990>;
        <D.26984>:
        p.84 = p;
        D.26991 = decode_value (p.84, &p);
        D.26992 = (signed char) D.26991;
        D.26993 = (<unnamed-signed:1>) D.26992;
        gi->has_this = D.26993;
        p.84 = p;
        D.26994 = decode_value (p.84, &p);
        D.26995 = (unsigned char) D.26994;
        gi->this_reg = D.26995;
        p.84 = p;
        D.26996 = decode_value (p.84, &p);
        gi->this_offset = D.26996;
        <D.26990>:
        <D.26982>:
        p.84 = p;
        len = decode_value (p.84, &p);
        if (async != 0) goto <D.26997>; else goto <D.26998>;
        <D.26997>:
        p.84 = p;
        D.26999 = (sizetype) len;
        p.92 = p.84 + D.26999;
        p = p.92;
        goto <D.27001>;
        <D.26998>:
        p.84 = p;
        D.27002 = decode_resolve_method_ref (amodule, p.84, &p);
        jinfo->d.method = D.27002;
        <D.27001>:
        D.27003 = monoeg_malloc0 (16);
        gi->generic_sharing_context = D.27003;
        p.84 = p;
        D.27004 = decode_value (p.84, &p);
        if (D.27004 != 0) goto <D.27005>; else goto <D.27006>;
        <D.27005>:
        {
          int i;
          int n;
          struct MonoGenericSharingContext * gsctx;

          gsctx = gi->generic_sharing_context;
          p.84 = p;
          n = decode_value (p.84, &p);
          if (n != 0) goto <D.27007>; else goto <D.27008>;
          <D.27007>:
          n.93 = (unsigned int) n;
          D.27010 = n.93 * 4;
          D.27011 = (int) D.27010;
          D.27012 = alloc0_jit_info_data (domain, D.27011, async);
          gsctx->var_is_vt = D.27012;
          i = 0;
          goto <D.24152>;
          <D.24151>:
          D.27013 = gsctx->var_is_vt;
          D.27014 = (long unsigned int) i;
          D.27015 = D.27014 * 4;
          D.27016 = D.27013 + D.27015;
          p.84 = p;
          D.27017 = decode_value (p.84, &p);
          *D.27016 = D.27017;
          i = i + 1;
          <D.24152>:
          if (i < n) goto <D.24151>; else goto <D.24153>;
          <D.24153>:
          <D.27008>:
          p.84 = p;
          n = decode_value (p.84, &p);
          if (n != 0) goto <D.27018>; else goto <D.27019>;
          <D.27018>:
          n.93 = (unsigned int) n;
          D.27010 = n.93 * 4;
          D.27011 = (int) D.27010;
          D.27020 = alloc0_jit_info_data (domain, D.27011, async);
          gsctx->mvar_is_vt = D.27020;
          i = 0;
          goto <D.24155>;
          <D.24154>:
          D.27021 = gsctx->mvar_is_vt;
          D.27014 = (long unsigned int) i;
          D.27015 = D.27014 * 4;
          D.27022 = D.27021 + D.27015;
          p.84 = p;
          D.27023 = decode_value (p.84, &p);
          *D.27022 = D.27023;
          i = i + 1;
          <D.24155>:
          if (i < n) goto <D.24154>; else goto <D.24156>;
          <D.24156>:
          <D.27019>:
        }
        <D.27006>:
      }
      <D.26956>:
      D.27024 = method != 0B;
      D.27025 = has_seq_points != 0;
      D.27026 = D.27024 & D.27025;
      if (D.27026 != 0) goto <D.27027>; else goto <D.27028>;
      <D.27027>:
      {
        struct MonoSeqPointInfo * seq_points;
        int il_offset;
        int native_offset;
        int last_il_offset;
        int last_native_offset;
        int j;
        int len;

        p.84 = p;
        len = decode_value (p.84, &p);
        D.27029 = (long unsigned int) len;
        D.27030 = D.27029 * 32;
        D.27031 = D.27030 + 8;
        seq_points = monoeg_malloc0 (D.27031);
        seq_points->len = len;
        last_native_offset = 0;
        last_il_offset = last_native_offset;
        i = 0;
        goto <D.24169>;
        <D.24168>:
        {
          struct SeqPoint * sp;

          sp = &seq_points->seq_points[i];
          p.84 = p;
          D.27032 = decode_value (p.84, &p);
          il_offset = D.27032 + last_il_offset;
          p.84 = p;
          D.27033 = decode_value (p.84, &p);
          native_offset = D.27033 + last_native_offset;
          sp->il_offset = il_offset;
          sp->native_offset = native_offset;
          p.84 = p;
          D.27034 = decode_value (p.84, &p);
          sp->flags = D.27034;
          p.84 = p;
          D.27035 = decode_value (p.84, &p);
          sp->next_len = D.27035;
          D.27036 = sp->next_len;
          D.27037 = (long unsigned int) D.27036;
          D.27038 = D.27037 * 4;
          D.27039 = monoeg_malloc (D.27038);
          sp->next = D.27039;
          j = 0;
          goto <D.24166>;
          <D.24165>:
          D.27040 = sp->next;
          D.27041 = (long unsigned int) j;
          D.27042 = D.27041 * 4;
          D.27043 = D.27040 + D.27042;
          p.84 = p;
          D.27044 = decode_value (p.84, &p);
          *D.27043 = D.27044;
          j = j + 1;
          <D.24166>:
          D.27036 = sp->next_len;
          if (D.27036 > j) goto <D.24165>; else goto <D.24167>;
          <D.24167>:
          last_il_offset = il_offset;
          last_native_offset = native_offset;
        }
        i = i + 1;
        <D.24169>:
        if (i < len) goto <D.24168>; else goto <D.24170>;
        <D.24170>:
        {
          int ret;

          D.27045 = &domain->lock.mutex;
          ret = pthread_mutex_lock (D.27045);
          if (ret != 0) goto <D.27046>; else goto <D.27047>;
          <D.27046>:
          monoeg_g_log (0B, 16, "Bad call to mono_mutex_lock result %d", ret);
          <D.27047>:
          D.27048 = ret != 0;
          D.27049 = (long int) D.27048;
          D.27050 = __builtin_expect (D.27049, 0);
          if (D.27050 != 0) goto <D.27051>; else goto <D.27052>;
          <D.27051>:
          monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "aot-runtime.c", 2608, "ret == 0");
          <D.27052>:
        }
        D.27053 = domain->runtime_info;
        D.27054 = MEM[(struct MonoJitDomainInfo *)D.27053].seq_points;
        monoeg_g_hash_table_insert_replace (D.27054, method, seq_points, 0);
        {
          int ret;

          D.27045 = &domain->lock.mutex;
          ret = pthread_mutex_unlock (D.27045);
          if (ret != 0) goto <D.27055>; else goto <D.27056>;
          <D.27055>:
          monoeg_g_log (0B, 16, "Bad call to mono_mutex_unlock result %d", ret);
          <D.27056>:
          D.27057 = ret != 0;
          D.27058 = (long int) D.27057;
          D.27059 = __builtin_expect (D.27058, 0);
          if (D.27059 != 0) goto <D.27060>; else goto <D.27061>;
          <D.27060>:
          monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "aot-runtime.c", 2610, "ret == 0");
          <D.27061>:
        }
      }
      <D.27028>:
      p.84 = p;
      buf_len = decode_value (p.84, &p);
      if (async == 0) goto <D.27062>; else goto <D.27063>;
      <D.27062>:
      buf_len.94 = (unsigned int) buf_len;
      p.84 = p;
      mono_debug_add_aot_method (domain, method, code, p.84, buf_len.94);
      <D.27063>:
      p.84 = p;
      D.27065 = (sizetype) buf_len;
      p.95 = p.84 + D.27065;
      p = p.95;
      if (has_gc_map != 0) goto <D.27067>; else goto <D.27068>;
      <D.27067>:
      {
        int map_size;

        p.84 = p;
        map_size = decode_value (p.84, &p);
        goto <D.24175>;
        <D.24174>:
        p.84 = p;
        p.96 = p.84 + 1;
        p = p.96;
        <D.24175>:
        p.84 = p;
        p.97 = (long unsigned int) p.84;
        D.27071 = p.97 & 3;
        if (D.27071 != 0) goto <D.24174>; else goto <D.24176>;
        <D.24176>:
        p.84 = p;
        jinfo->gc_info = p.84;
        p.84 = p;
        D.27072 = (sizetype) map_size;
        p.98 = p.84 + D.27072;
        p = p.98;
      }
      <D.27068>:
      D.27074 = jinfo->d.method;
      D.27075 = D.27074->klass;
      D.27076 = D.27075->image;
      D.27077 = D.27076->aot_module;
      if (D.27077 != amodule) goto <D.27078>; else goto <D.27079>;
      <D.27078>:
      {
        int ret;

        ret = pthread_mutex_lock (&aot_mutex.mutex);
        if (ret != 0) goto <D.27080>; else goto <D.27081>;
        <D.27080>:
        monoeg_g_log (0B, 16, "Bad call to mono_mutex_lock result %d", ret);
        <D.27081>:
        D.27082 = ret != 0;
        D.27083 = (long int) D.27082;
        D.27084 = __builtin_expect (D.27083, 0);
        if (D.27084 != 0) goto <D.27085>; else goto <D.27086>;
        <D.27085>:
        monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "aot-runtime.c", 2629, "ret == 0");
        <D.27086>:
      }
      ji_to_amodule.99 = ji_to_amodule;
      if (ji_to_amodule.99 == 0B) goto <D.27088>; else goto <D.27089>;
      <D.27088>:
      ji_to_amodule.100 = monoeg_g_hash_table_new (0B, 0B);
      ji_to_amodule = ji_to_amodule.100;
      <D.27089>:
      ji_to_amodule.99 = ji_to_amodule;
      monoeg_g_hash_table_insert_replace (ji_to_amodule.99, jinfo, amodule, 0);
      {
        int ret;

        ret = pthread_mutex_unlock (&aot_mutex.mutex);
        if (ret != 0) goto <D.27091>; else goto <D.27092>;
        <D.27091>:
        monoeg_g_log (0B, 16, "Bad call to mono_mutex_unlock result %d", ret);
        <D.27092>:
        D.27093 = ret != 0;
        D.27094 = (long int) D.27093;
        D.27095 = __builtin_expect (D.27094, 0);
        if (D.27095 != 0) goto <D.27096>; else goto <D.27097>;
        <D.27096>:
        monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "aot-runtime.c", 2633, "ret == 0");
        <D.27097>:
      }
      <D.27079>:
      D.26954 = jinfo;
      return D.26954;
    }
  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.27100;
  _Bool D.27101;
  long int D.27102;
  long int D.27103;
  unsigned char D.27106;
  _Bool D.27107;
  long int D.27108;
  long int D.27109;
  long int p.101;
  long int D.27113;
  long int D.27114;
  unsigned int D.27115;
  int D.27116;
  int D.27117;
  sizetype D.27118;
  long int code.102;
  guint8 * D.27120;
  long int D.27121;
  long int D.27122;
  int D.27123;
  int D.27124;
  long unsigned int D.27125;
  long unsigned int D.27126;
  gint32 * D.27127;
  int D.27128;
  _Bool D.27129;
  long int D.27130;
  long int D.27131;
  gint32 * D.27134;
  long unsigned int D.27135;
  long unsigned int D.27136;
  gint32 * D.27137;
  int D.27138;
  guint8 * D.27141;
  long int D.27142;
  long int D.27143;
  int D.27145;
  long unsigned int D.27146;
  long unsigned int D.27147;
  gint32 * D.27148;
  int D.27149;
  _Bool D.27150;
  long int D.27151;
  long int D.27152;
  long unsigned int D.27155;
  long unsigned int D.27156;
  gint32 * D.27157;
  int D.27162;
  sizetype D.27163;
  sizetype D.27166;
  int D.27168;
  sizetype D.27169;
  long int code_end.103;
  long int code_start.104;
  long int D.27172;
  _Bool D.27173;
  _Bool D.27174;
  _Bool D.27175;
  int D.27176;
  _Bool D.27177;
  long int D.27178;
  long int D.27179;
  guint8 * D.27182;
  long int D.27187;
  sizetype D.27188;
  sizetype D.27189;
  sizetype D.27190;
  gint32 * D.27191;
  int D.27192;
  sizetype D.27193;
  sizetype D.27194;
  sizetype D.27195;
  sizetype D.27196;
  gint32 * D.27197;
  int D.27198;
  int D.27199;
  int fde_len.105;
  int D.27201;
  int D.27202;
  long unsigned int D.27203;
  long unsigned int D.27204;
  void * * D.27205;
  void * D.27206;
  unsigned int D.27207;
  long unsigned int D.27208;
  long unsigned int D.27209;
  struct GSList * * D.27210;
  void * D.27211;
  long int D.27212;
  long unsigned int D.27213;
  long unsigned int D.27214;
  void * * D.27215;
  void * D.27216;
  unsigned int D.27217;
  unsigned int j.106;
  unsigned int i.107;
  unsigned int D.27222;
  unsigned int D.27223;
  unsigned int extra_size.108;
  unsigned int D.27225;
  unsigned int D.27226;
  unsigned int D.27227;
  guint8 * D.27228;
  unsigned int D.27229;
  short unsigned int D.27230;
  short unsigned int D.27231;
  short unsigned int D.27232;
  <unnamed-unsigned:15> D.27233;
  long unsigned int D.27234;
  long unsigned int D.27235;
  _Bool D.27236;
  long int D.27237;
  long int D.27238;
  unsigned int D.27241;
  struct MonoClass * D.27242;
  long unsigned int D.27243;
  struct MonoJitExceptionInfo * D.27244;
  void * D.27245;
  void * D.27246;
  void * D.27247;
  void * D.27250;
  long int D.27253;
  long int D.27254;
  void * D.27255;
  long unsigned int D.27256;
  long unsigned int D.27257;
  struct GSList * * D.27258;
  void * D.27259;
  long int D.27260;
  struct MonoJitExceptionInfo * D.27263;
  struct MonoJitExceptionInfo * D.27264;
  void * D.27265;
  void * D.27266;
  _Bool D.27267;
  long int D.27268;
  long int D.27269;
  struct MonoJitInfo * D.27272;
  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.27100 = amodule->mono_eh_frame;
      D.27101 = D.27100 == 0B;
      D.27102 = (long int) D.27101;
      D.27103 = __builtin_expect (D.27102, 0);
      if (D.27103 != 0) goto <D.27104>; else goto <D.27105>;
      <D.27104>:
      monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "aot-runtime.c", 2171, "amodule->mono_eh_frame");
      <D.27105>:
      p = amodule->mono_eh_frame;
      D.27106 = *p;
      version = (int) D.27106;
      D.27107 = version != 3;
      D.27108 = (long int) D.27107;
      D.27109 = __builtin_expect (D.27108, 0);
      if (D.27109 != 0) goto <D.27110>; else goto <D.27111>;
      <D.27110>:
      monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "aot-runtime.c", 2179, "version == 3");
      <D.27111>:
      p = p + 1;
      D.27106 = *p;
      func_encoding = (int) D.27106;
      p = p + 1;
      p.101 = (long int) p;
      D.27113 = p.101 + 3;
      D.27114 = D.27113 & -4;
      p = (guint8 *) D.27114;
      D.27115 = MEM[(guint32 *)p];
      fde_count = (int) D.27115;
      p = p + 4;
      table = p;
      D.27116 = fde_count + 1;
      D.27117 = D.27116 * 8;
      D.27118 = (sizetype) D.27117;
      cie = p + D.27118;
      code.102 = (long int) code;
      D.27120 = amodule->code;
      D.27121 = (long int) D.27120;
      D.27122 = code.102 - D.27121;
      offset = (int) D.27122;
      left = 0;
      right = fde_count;
      <D.24046>:
      D.27123 = left + right;
      pos = D.27123 / 2;
      D.27124 = pos * 2;
      D.27125 = (long unsigned int) D.27124;
      D.27126 = D.27125 * 4;
      D.27127 = table + D.27126;
      D.27128 = *D.27127;
      D.27129 = D.27128 == -1;
      D.27130 = (long int) D.27129;
      D.27131 = __builtin_expect (D.27130, 0);
      if (D.27131 != 0) goto <D.27132>; else goto <D.27133>;
      <D.27132>:
      monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "aot-runtime.c", 2200, "table [(pos * 2)] != -1");
      <D.27133>:
      D.27134 = amodule->code_offsets;
      D.27124 = pos * 2;
      D.27125 = (long unsigned int) D.27124;
      D.27126 = D.27125 * 4;
      D.27127 = table + D.27126;
      D.27128 = *D.27127;
      D.27135 = (long unsigned int) D.27128;
      D.27136 = D.27135 * 4;
      D.27137 = D.27134 + D.27136;
      offset1 = *D.27137;
      D.27138 = pos + 1;
      if (D.27138 == fde_count) goto <D.27139>; else goto <D.27140>;
      <D.27139>:
      D.27141 = amodule->code_end;
      D.27142 = (long int) D.27141;
      D.27120 = amodule->code;
      D.27121 = (long int) D.27120;
      D.27143 = D.27142 - D.27121;
      offset2 = (int) D.27143;
      goto <D.27144>;
      <D.27140>:
      D.27138 = pos + 1;
      D.27145 = D.27138 * 2;
      D.27146 = (long unsigned int) D.27145;
      D.27147 = D.27146 * 4;
      D.27148 = table + D.27147;
      D.27149 = *D.27148;
      D.27150 = D.27149 == -1;
      D.27151 = (long int) D.27150;
      D.27152 = __builtin_expect (D.27151, 0);
      if (D.27152 != 0) goto <D.27153>; else goto <D.27154>;
      <D.27153>:
      monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "aot-runtime.c", 2205, "table [(pos + 1) * 2] != -1");
      <D.27154>:
      D.27134 = amodule->code_offsets;
      D.27138 = pos + 1;
      D.27145 = D.27138 * 2;
      D.27146 = (long unsigned int) D.27145;
      D.27147 = D.27146 * 4;
      D.27148 = table + D.27147;
      D.27149 = *D.27148;
      D.27155 = (long unsigned int) D.27149;
      D.27156 = D.27155 * 4;
      D.27157 = D.27134 + D.27156;
      offset2 = *D.27157;
      <D.27144>:
      if (offset < offset1) goto <D.27158>; else goto <D.27159>;
      <D.27158>:
      right = pos;
      goto <D.27160>;
      <D.27159>:
      if (offset >= offset2) goto <D.27161>; else goto <D.24045>;
      <D.27161>:
      left = pos + 1;
      <D.27160>:
      goto <D.24046>;
      <D.24045>:
      D.27120 = amodule->code;
      D.27134 = amodule->code_offsets;
      D.27124 = pos * 2;
      D.27125 = (long unsigned int) D.27124;
      D.27126 = D.27125 * 4;
      D.27127 = table + D.27126;
      D.27128 = *D.27127;
      D.27135 = (long unsigned int) D.27128;
      D.27136 = D.27135 * 4;
      D.27137 = D.27134 + D.27136;
      D.27162 = *D.27137;
      D.27163 = (sizetype) D.27162;
      code_start = D.27120 + D.27163;
      D.27138 = pos + 1;
      if (D.27138 == fde_count) goto <D.27164>; else goto <D.27165>;
      <D.27164>:
      {
        int len;

        D.27138 = pos + 1;
        D.27145 = D.27138 * 2;
        D.27146 = (long unsigned int) D.27145;
        D.27147 = D.27146 * 4;
        D.27148 = table + D.27147;
        len = *D.27148;
        D.27166 = (sizetype) len;
        code_end = code_start + D.27166;
      }
      goto <D.27167>;
      <D.27165>:
      D.27120 = amodule->code;
      D.27134 = amodule->code_offsets;
      D.27138 = pos + 1;
      D.27145 = D.27138 * 2;
      D.27146 = (long unsigned int) D.27145;
      D.27147 = D.27146 * 4;
      D.27148 = table + D.27147;
      D.27149 = *D.27148;
      D.27155 = (long unsigned int) D.27149;
      D.27156 = D.27155 * 4;
      D.27157 = D.27134 + D.27156;
      D.27168 = *D.27157;
      D.27169 = (sizetype) D.27168;
      code_end = D.27120 + D.27169;
      <D.27167>:
      code_end.103 = (long int) code_end;
      code_start.104 = (long int) code_start;
      D.27172 = code_end.103 - code_start.104;
      code_len = (int) D.27172;
      D.27173 = code < code_start;
      D.27174 = code >= code_end;
      D.27175 = D.27173 | D.27174;
      D.27176 = (int) D.27175;
      D.27177 = D.27176 != 0;
      D.27178 = (long int) D.27177;
      D.27179 = __builtin_expect (D.27178, 0);
      if (D.27179 != 0) goto <D.27180>; else goto <D.27181>;
      <D.27180>:
      monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "aot-runtime.c", 2227, "code >= code_start && code < code_end");
      <D.27181>:
      D.27182 = amodule->thumb_end;
      if (D.27182 != 0B) goto <D.27183>; else goto <D.27184>;
      <D.27183>:
      D.27182 = amodule->thumb_end;
      if (D.27182 > code_start) goto <D.27185>; else goto <D.27186>;
      <D.27185>:
      code_start.104 = (long int) code_start;
      D.27187 = code_start.104 & -2;
      code_start = (guint8 *) D.27187;
      <D.27186>:
      <D.27184>:
      D.27100 = amodule->mono_eh_frame;
      D.27124 = pos * 2;
      D.27188 = (sizetype) D.27124;
      D.27189 = D.27188 + 1;
      D.27190 = D.27189 * 4;
      D.27191 = table + D.27190;
      D.27192 = *D.27191;
      D.27193 = (sizetype) D.27192;
      fde = D.27100 + D.27193;
      D.27138 = pos + 1;
      D.27145 = D.27138 * 2;
      D.27194 = (sizetype) D.27145;
      D.27195 = D.27194 + 1;
      D.27196 = D.27195 * 4;
      D.27197 = table + D.27196;
      D.27198 = *D.27197;
      D.27124 = pos * 2;
      D.27188 = (sizetype) D.27124;
      D.27189 = D.27188 + 1;
      D.27190 = D.27189 * 4;
      D.27191 = table + D.27190;
      D.27192 = *D.27191;
      D.27199 = D.27198 - D.27192;
      fde_len = (guint32) D.27199;
      fde_len.105 = (int) fde_len;
      mono_unwind_decode_llvm_mono_fde (fde, fde_len.105, cie, code_start, &info);
      ei = info.ex_info;
      ei_len = info.ex_info_len;
      type_info = info.type_info;
      D.27201 = info.this_reg;
      *this_reg = D.27201;
      D.27202 = info.this_offset;
      *this_offset = D.27202;
      nested_len = 0;
      i = 0;
      goto <D.24059>;
      <D.24058>:
      {
        gint32 cindex1;
        struct GSList * l;

        D.27203 = (long unsigned int) i;
        D.27204 = D.27203 * 8;
        D.27205 = type_info + D.27204;
        D.27206 = *D.27205;
        D.27207 = MEM[(const guint32 *)D.27206];
        cindex1 = (gint32) D.27207;
        D.27208 = (long unsigned int) cindex1;
        D.27209 = D.27208 * 8;
        D.27210 = nesting + D.27209;
        l = *D.27210;
        goto <D.24056>;
        <D.24055>:
        {
          gint32 nesting_cindex;

          D.27211 = l->data;
          D.27212 = (long int) D.27211;
          nesting_cindex = (gint32) D.27212;
          j = 0;
          goto <D.24053>;
          <D.24052>:
          {
            gint32 cindex2;

            D.27213 = (long unsigned int) j;
            D.27214 = D.27213 * 8;
            D.27215 = type_info + D.27214;
            D.27216 = *D.27215;
            D.27217 = MEM[(const guint32 *)D.27216];
            cindex2 = (gint32) D.27217;
            if (cindex2 == nesting_cindex) goto <D.27218>; else goto <D.27219>;
            <D.27218>:
            nested_len = nested_len + 1;
            <D.27219>:
          }
          j = j + 1;
          <D.24053>:
          j.106 = (unsigned int) j;
          if (j.106 < ei_len) goto <D.24052>; else goto <D.24054>;
          <D.24054>:
        }
        l = l->next;
        <D.24056>:
        if (l != 0B) goto <D.24055>; else goto <D.24057>;
        <D.24057>:
      }
      i = i + 1;
      <D.24059>:
      i.107 = (unsigned int) i;
      if (i.107 < ei_len) goto <D.24058>; else goto <D.24060>;
      <D.24060>:
      D.27222 = ei_len + nested_len;
      D.27223 = D.27222 * 40;
      extra_size.108 = (unsigned int) extra_size;
      D.27225 = D.27223 + extra_size.108;
      D.27226 = D.27225 + 48;
      jinfo = mono_domain_alloc0_lock_free (domain, D.27226);
      jinfo->code_size = code_len;
      D.27227 = info.unw_info_len;
      D.27228 = info.unw_info;
      D.27229 = mono_cache_unwind_info (D.27228, D.27227);
      jinfo->used_regs = D.27229;
      jinfo->d.method = method;
      jinfo->code_start = code;
      jinfo->domain_neutral = 0;
      jinfo->from_aot = 0;
      D.27230 = (short unsigned int) ei_len;
      D.27231 = (short unsigned int) nested_len;
      D.27232 = D.27230 + D.27231;
      D.27233 = (<unnamed-unsigned:15>) D.27232;
      jinfo->num_clauses = D.27233;
      i = 0;
      goto <D.24065>;
      <D.24064>:
      {
        int clause_index;
        struct MonoJitExceptionInfo * jei;
        struct MonoJitExceptionInfo * orig_jei;

        D.27203 = (long unsigned int) i;
        D.27204 = D.27203 * 8;
        D.27205 = type_info + D.27204;
        D.27206 = *D.27205;
        D.27207 = MEM[(const guint32 *)D.27206];
        clause_index = (int) D.27207;
        jei = &jinfo->clauses[i];
        D.27234 = (long unsigned int) clause_index;
        D.27235 = D.27234 * 40;
        orig_jei = clauses + D.27235;
        D.27236 = clause_index >= num_clauses;
        D.27237 = (long int) D.27236;
        D.27238 = __builtin_expect (D.27237, 0);
        if (D.27238 != 0) goto <D.27239>; else goto <D.27240>;
        <D.27239>:
        monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "aot-runtime.c", 2289, "clause_index < num_clauses");
        <D.27240>:
        D.27241 = orig_jei->flags;
        jei->flags = D.27241;
        D.27242 = orig_jei->data.catch_class;
        jei->data.catch_class = D.27242;
        D.27203 = (long unsigned int) i;
        D.27243 = D.27203 * 40;
        D.27244 = ei + D.27243;
        D.27245 = D.27244->try_start;
        jei->try_start = D.27245;
        D.27203 = (long unsigned int) i;
        D.27243 = D.27203 * 40;
        D.27244 = ei + D.27243;
        D.27246 = D.27244->try_end;
        jei->try_end = D.27246;
        D.27203 = (long unsigned int) i;
        D.27243 = D.27203 * 40;
        D.27244 = ei + D.27243;
        D.27247 = D.27244->handler_start;
        jei->handler_start = D.27247;
        D.27182 = amodule->thumb_end;
        if (D.27182 != 0B) goto <D.27248>; else goto <D.27249>;
        <D.27248>:
        D.27250 = jei->handler_start;
        D.27182 = amodule->thumb_end;
        if (D.27250 < D.27182) goto <D.27251>; else goto <D.27252>;
        <D.27251>:
        D.27250 = jei->handler_start;
        D.27253 = (long int) D.27250;
        D.27254 = D.27253 + 1;
        D.27255 = (void *) D.27254;
        jei->handler_start = D.27255;
        <D.27252>:
        <D.27249>:
      }
      i = i + 1;
      <D.24065>:
      i.107 = (unsigned int) i;
      if (i.107 < ei_len) goto <D.24064>; else goto <D.24066>;
      <D.24066>:
      nindex = ei_len;
      i = 0;
      goto <D.24078>;
      <D.24077>:
      {
        gint32 cindex1;
        struct GSList * l;

        D.27203 = (long unsigned int) i;
        D.27204 = D.27203 * 8;
        D.27205 = type_info + D.27204;
        D.27206 = *D.27205;
        D.27207 = MEM[(const guint32 *)D.27206];
        cindex1 = (gint32) D.27207;
        D.27256 = (long unsigned int) cindex1;
        D.27257 = D.27256 * 8;
        D.27258 = nesting + D.27257;
        l = *D.27258;
        goto <D.24075>;
        <D.24074>:
        {
          gint32 nesting_cindex;

          D.27259 = l->data;
          D.27260 = (long int) D.27259;
          nesting_cindex = (gint32) D.27260;
          j = 0;
          goto <D.24072>;
          <D.24071>:
          {
            gint32 cindex2;

            D.27213 = (long unsigned int) j;
            D.27214 = D.27213 * 8;
            D.27215 = type_info + D.27214;
            D.27216 = *D.27215;
            D.27217 = MEM[(const guint32 *)D.27216];
            cindex2 = (gint32) D.27217;
            if (cindex2 == nesting_cindex) goto <D.27261>; else goto <D.27262>;
            <D.27261>:
            D.27263 = &jinfo->clauses[j];
            D.27264 = &jinfo->clauses[nindex];
            memcpy (D.27264, D.27263, 40);
            D.27265 = jinfo->clauses[i].try_start;
            jinfo->clauses[nindex].try_start = D.27265;
            D.27266 = jinfo->clauses[i].try_end;
            jinfo->clauses[nindex].try_end = D.27266;
            nindex = nindex + 1;
            <D.27262>:
          }
          j = j + 1;
          <D.24072>:
          j.106 = (unsigned int) j;
          if (j.106 < ei_len) goto <D.24071>; else goto <D.24073>;
          <D.24073>:
        }
        l = l->next;
        <D.24075>:
        if (l != 0B) goto <D.24074>; else goto <D.24076>;
        <D.24076>:
      }
      i = i + 1;
      <D.24078>:
      i.107 = (unsigned int) i;
      if (i.107 < ei_len) goto <D.24077>; else goto <D.24079>;
      <D.24079>:
      D.27222 = ei_len + nested_len;
      D.27267 = D.27222 != nindex;
      D.27268 = (long int) D.27267;
      D.27269 = __builtin_expect (D.27268, 0);
      if (D.27269 != 0) goto <D.27270>; else goto <D.27271>;
      <D.27270>:
      monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "aot-runtime.c", 2327, "nindex == ei_len + nested_len");
      <D.27271>:
      D.27272 = jinfo;
      return D.27272;
    }
  finally
    {
      info = {CLOBBER};
    }
}


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

  if (async_context != 0) goto <D.27275>; else goto <D.27276>;
  <D.27275>:
  size.109 = (unsigned int) size;
  res = mono_domain_alloc0_lock_free (domain, size.109);
  InterlockedExchangeAdd (&async_jit_info_size, size);
  goto <D.27278>;
  <D.27276>:
  size.109 = (unsigned int) size;
  res = mono_domain_alloc0 (domain, size.109);
  <D.27278>:
  D.27279 = res;
  return D.27279;
}


InterlockedExchangeAdd (volatile gint32 * val, gint32 add)
{
  gint32 D.27281;
  unsigned int add.110;
  unsigned int D.27283;

  add.110 = (unsigned int) add;
  D.27283 = __sync_fetch_and_add_4 (val, add.110);
  D.27281 = (gint32) D.27283;
  return D.27281;
}


mono_memory_barrier ()
{
  __sync_synchronize ();
}


InterlockedCompareExchangePointer (void * volatile * dest, void * exch, void * comp)
{
  void * D.27285;
  long unsigned int exch.111;
  long unsigned int comp.112;
  long unsigned int D.27288;

  exch.111 = (long unsigned int) exch;
  comp.112 = (long unsigned int) comp;
  D.27288 = __sync_val_compare_and_swap_8 (dest, comp.112, exch.111);
  D.27285 = (void *) D.27288;
  return D.27285;
}


mono_aot_get_method (struct MonoDomain * domain, struct MonoMethod * method)
{
  struct MonoImage * D.27290;
  void * amodule.113;
  struct MonoAotModule * amodule.114;
  void * D.27295;
  int D.27296;
  short unsigned int D.27301;
  int D.27302;
  int D.27303;
  short unsigned int D.27305;
  int D.27306;
  int D.27307;
  int D.27309;
  int D.27311;
  int mono_aot_only.115;
  unsigned char D.27315;
  unsigned char D.27316;
  struct MonoMethod * D.27319;
  unsigned char D.27320;
  unsigned char D.27321;
  _Bool D.27322;
  long int D.27323;
  long int D.27324;
  short unsigned int D.27329;
  short unsigned int D.27330;
  int D.27332;
  unsigned int D.27334;
  unsigned int D.27335;
  unsigned char D.27339;
  unsigned char D.27340;
  _Bool D.27344;
  long int D.27345;
  long int D.27346;
  struct GHashTable * D.27349;
  _Bool D.27352;
  long int D.27353;
  long int D.27354;
  struct MonoClass * D.27363;
  unsigned char D.27364;
  const char * D.27367;
  char * D.27368;
  int D.27373;
  void * D.27376;
  struct MonoClass * D.27381;
  int D.24479;
  int iftmp.116;
  int D.24478;
  const char[20] * D.27387;
  unsigned char D.27388;
  int D.27389;
  unsigned char D.27390;
  int D.27391;
  _Bool D.27392;
  _Bool D.27393;
  _Bool D.27394;
  const unsigned char * D.27397;
  unsigned char D.27398;
  int D.27399;
  const unsigned char * D.27400;
  unsigned char D.27401;
  int D.27402;
  _Bool D.27403;
  _Bool D.27404;
  const unsigned char * D.27407;
  unsigned char D.27408;
  int D.27409;
  const unsigned char * D.27410;
  unsigned char D.27411;
  int D.27412;
  _Bool D.27413;
  _Bool D.27414;
  const unsigned char * D.27417;
  unsigned char D.27418;
  int D.27419;
  const unsigned char * D.27420;
  unsigned char D.27421;
  int D.27422;
  struct MonoMethodSignature * D.27426;
  struct MonoType * D.27427;
  unsigned char D.27428;
  _Bool D.27431;
  long int D.27432;
  long int D.27433;
  struct MonoClass * D.27436;
  struct MonoType * D.27437;
  struct MonoGenericInst * D.27438;
  struct MonoMethod * D.27439;
  struct MonoImage * D.27451;
  struct MonoImage * D.27452;
  int D.24491;
  int iftmp.117;
  int D.24490;
  const char[17] * D.27458;
  unsigned char D.27459;
  int D.27460;
  unsigned char D.27461;
  int D.27462;
  _Bool D.27463;
  _Bool D.27464;
  _Bool D.27465;
  const unsigned char * D.27468;
  unsigned char D.27469;
  int D.27470;
  const unsigned char * D.27471;
  unsigned char D.27472;
  int D.27473;
  _Bool D.27474;
  _Bool D.27475;
  const unsigned char * D.27478;
  unsigned char D.27479;
  int D.27480;
  const unsigned char * D.27481;
  unsigned char D.27482;
  int D.27483;
  _Bool D.27484;
  _Bool D.27485;
  const unsigned char * D.27488;
  unsigned char D.27489;
  int D.27490;
  const unsigned char * D.27491;
  unsigned char D.27492;
  int D.27493;
  const char * D.27495;
  int D.24500;
  int iftmp.118;
  int D.24499;
  const char[12] * D.27500;
  unsigned char D.27501;
  int D.27502;
  unsigned char D.27503;
  int D.27504;
  _Bool D.27505;
  _Bool D.27506;
  _Bool D.27507;
  const unsigned char * D.27510;
  unsigned char D.27511;
  int D.27512;
  const unsigned char * D.27513;
  unsigned char D.27514;
  int D.27515;
  _Bool D.27516;
  _Bool D.27517;
  const unsigned char * D.27520;
  unsigned char D.27521;
  int D.27522;
  const unsigned char * D.27523;
  unsigned char D.27524;
  int D.27525;
  _Bool D.27526;
  _Bool D.27527;
  const unsigned char * D.27530;
  unsigned char D.27531;
  int D.27532;
  const unsigned char * D.27533;
  unsigned char D.27534;
  int D.27535;
  const char * D.27537;
  int D.24509;
  int iftmp.119;
  int D.24508;
  const char[16] * D.27542;
  unsigned char D.27543;
  int D.27544;
  unsigned char D.27545;
  int D.27546;
  _Bool D.27547;
  _Bool D.27548;
  _Bool D.27549;
  const unsigned char * D.27552;
  unsigned char D.27553;
  int D.27554;
  const unsigned char * D.27555;
  unsigned char D.27556;
  int D.27557;
  _Bool D.27558;
  _Bool D.27559;
  const unsigned char * D.27562;
  unsigned char D.27563;
  int D.27564;
  const unsigned char * D.27565;
  unsigned char D.27566;
  int D.27567;
  _Bool D.27568;
  _Bool D.27569;
  const unsigned char * D.27572;
  unsigned char D.27573;
  int D.27574;
  const unsigned char * D.27575;
  unsigned char D.27576;
  int D.27577;
  int D.24518;
  int iftmp.120;
  int D.24517;
  const char[9] * D.27583;
  unsigned char D.27584;
  int D.27585;
  unsigned char D.27586;
  int D.27587;
  _Bool D.27588;
  _Bool D.27589;
  _Bool D.27590;
  const unsigned char * D.27593;
  unsigned char D.27594;
  int D.27595;
  const unsigned char * D.27596;
  unsigned char D.27597;
  int D.27598;
  _Bool D.27599;
  _Bool D.27600;
  const unsigned char * D.27603;
  unsigned char D.27604;
  int D.27605;
  const unsigned char * D.27606;
  unsigned char D.27607;
  int D.27608;
  _Bool D.27609;
  _Bool D.27610;
  const unsigned char * D.27613;
  unsigned char D.27614;
  int D.27615;
  const unsigned char * D.27616;
  unsigned char D.27617;
  int D.27618;
  struct MonoMethodSignature * D.27620;
  struct MonoType * D.27621;
  int D.27622;
  int D.24527;
  int iftmp.121;
  int D.24526;
  unsigned char D.27626;
  int D.27627;
  _Bool D.27628;
  _Bool D.27629;
  _Bool D.27630;
  const unsigned char * D.27633;
  unsigned char D.27634;
  int D.27635;
  _Bool D.27636;
  _Bool D.27637;
  const unsigned char * D.27640;
  unsigned char D.27641;
  int D.27642;
  _Bool D.27643;
  _Bool D.27644;
  const unsigned char * D.27647;
  unsigned char D.27648;
  int D.27649;
  int D.24536;
  int iftmp.122;
  int D.24535;
  const char[9] * D.27655;
  unsigned char D.27656;
  int D.27657;
  unsigned char D.27658;
  int D.27659;
  _Bool D.27660;
  _Bool D.27661;
  _Bool D.27662;
  const unsigned char * D.27665;
  unsigned char D.27666;
  int D.27667;
  const unsigned char * D.27668;
  unsigned char D.27669;
  int D.27670;
  _Bool D.27671;
  _Bool D.27672;
  const unsigned char * D.27675;
  unsigned char D.27676;
  int D.27677;
  const unsigned char * D.27678;
  unsigned char D.27679;
  int D.27680;
  _Bool D.27681;
  _Bool D.27682;
  const unsigned char * D.27685;
  unsigned char D.27686;
  int D.27687;
  const unsigned char * D.27688;
  unsigned char D.27689;
  int D.27690;
  int D.24545;
  int iftmp.123;
  int D.24544;
  const char[5] * D.27696;
  unsigned char D.27697;
  int D.27698;
  unsigned char D.27699;
  int D.27700;
  _Bool D.27701;
  _Bool D.27702;
  _Bool D.27703;
  const unsigned char * D.27706;
  unsigned char D.27707;
  int D.27708;
  const unsigned char * D.27709;
  unsigned char D.27710;
  int D.27711;
  _Bool D.27712;
  _Bool D.27713;
  const unsigned char * D.27716;
  unsigned char D.27717;
  int D.27718;
  const unsigned char * D.27719;
  unsigned char D.27720;
  int D.27721;
  _Bool D.27722;
  _Bool D.27723;
  const unsigned char * D.27726;
  unsigned char D.27727;
  int D.27728;
  const unsigned char * D.27729;
  unsigned char D.27730;
  int D.27731;
  struct MonoMethodSignature * D.27734;
  struct MonoType * D.27735;
  int D.27736;
  int D.24554;
  int iftmp.124;
  int D.24553;
  unsigned char D.27740;
  int D.27741;
  _Bool D.27742;
  _Bool D.27743;
  _Bool D.27744;
  const unsigned char * D.27747;
  unsigned char D.27748;
  int D.27749;
  _Bool D.27750;
  _Bool D.27751;
  const unsigned char * D.27754;
  unsigned char D.27755;
  int D.27756;
  _Bool D.27757;
  _Bool D.27758;
  const unsigned char * D.27761;
  unsigned char D.27762;
  int D.27763;
  int D.24563;
  int iftmp.125;
  int D.24562;
  unsigned char D.27769;
  int D.27770;
  _Bool D.27771;
  _Bool D.27772;
  _Bool D.27773;
  const unsigned char * D.27776;
  unsigned char D.27777;
  int D.27778;
  _Bool D.27779;
  _Bool D.27780;
  const unsigned char * D.27783;
  unsigned char D.27784;
  int D.27785;
  _Bool D.27786;
  _Bool D.27787;
  const unsigned char * D.27790;
  unsigned char D.27791;
  int D.27792;
  int D.24572;
  int iftmp.126;
  int D.24571;
  const char[6] * D.27798;
  unsigned char D.27799;
  int D.27800;
  unsigned char D.27801;
  int D.27802;
  _Bool D.27803;
  _Bool D.27804;
  _Bool D.27805;
  const unsigned char * D.27808;
  unsigned char D.27809;
  int D.27810;
  const unsigned char * D.27811;
  unsigned char D.27812;
  int D.27813;
  _Bool D.27814;
  _Bool D.27815;
  const unsigned char * D.27818;
  unsigned char D.27819;
  int D.27820;
  const unsigned char * D.27821;
  unsigned char D.27822;
  int D.27823;
  _Bool D.27824;
  _Bool D.27825;
  const unsigned char * D.27828;
  unsigned char D.27829;
  int D.27830;
  const unsigned char * D.27831;
  unsigned char D.27832;
  int D.27833;
  struct MonoMethodSignature * D.27836;
  struct MonoType * D.27837;
  int D.27838;
  struct MonoMethodSignature * D.27839;
  short unsigned int D.27840;
  int D.24585;
  const char * D.27843;
  _Bool D.27845;
  long int D.27846;
  long int D.27847;
  struct MonoGenericInst * D.27850;
  struct MonoMethod * D.27851;
  int D.27860;
  int D.27869;
  struct MonoMethod * D.27872;
  int D.27879;
  _Bool D.27886;
  long int D.27887;
  long int D.27888;
  struct GHashTable * D.27891;
  struct GHashTable * D.27894;
  long unsigned int D.27895;
  void * D.27896;
  _Bool D.27899;
  long int D.27900;
  long int D.27901;
  int method_index.127;
  struct MonoClass * klass;
  guint32 method_index;
  struct MonoAotModule * amodule;
  guint8 * code;

  try
    {
      klass = method->klass;
      D.27290 = klass->image;
      amodule.113 = D.27290->aot_module;
      amodule = amodule.113;
      amodule.114 = amodule;
      if (amodule.114 == 0B) goto <D.27293>; else goto <D.27294>;
      <D.27293>:
      D.27295 = 0B;
      return D.27295;
      <D.27294>:
      amodule.114 = amodule;
      D.27296 = amodule.114->out_of_date;
      if (D.27296 != 0) goto <D.27297>; else goto <D.27298>;
      <D.27297>:
      D.27295 = 0B;
      return D.27295;
      <D.27298>:
      D.27301 = method->iflags;
      D.27302 = (int) D.27301;
      D.27303 = D.27302 & 4096;
      if (D.27303 != 0) goto <D.27299>; else goto <D.27304>;
      <D.27304>:
      D.27305 = method->flags;
      D.27306 = (int) D.27305;
      D.27307 = D.27306 & 8192;
      if (D.27307 != 0) goto <D.27299>; else goto <D.27308>;
      <D.27308>:
      D.27301 = method->iflags;
      D.27302 = (int) D.27301;
      D.27309 = D.27302 & 3;
      if (D.27309 != 0) goto <D.27299>; else goto <D.27310>;
      <D.27310>:
      D.27305 = method->flags;
      D.27306 = (int) D.27305;
      D.27311 = D.27306 & 1024;
      if (D.27311 != 0) goto <D.27299>; else goto <D.27300>;
      <D.27299>:
      D.27295 = 0B;
      return D.27295;
      <D.27300>:
      mono_aot_only.115 = mono_aot_only;
      if (mono_aot_only.115 != 0) goto <D.27313>; else goto <D.27314>;
      <D.27313>:
      D.27315 = BIT_FIELD_REF <*method, 8, 256>;
      D.27316 = D.27315 & 124;
      if (D.27316 == 36) goto <D.27317>; else goto <D.27318>;
      <D.27317>:
      D.27319 = mono_marshal_method_from_wrapper (method);
      D.27295 = mono_aot_get_method (domain, D.27319);
      return D.27295;
      <D.27318>:
      <D.27314>:
      D.27320 = BIT_FIELD_REF <*klass, 8, 256>;
      D.27321 = D.27320 & 1;
      D.27322 = D.27321 == 0;
      D.27323 = (long int) D.27322;
      D.27324 = __builtin_expect (D.27323, 0);
      if (D.27324 != 0) goto <D.27325>; else goto <D.27326>;
      <D.27325>:
      monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "aot-runtime.c", 3615, "klass->inited");
      <D.27326>:
      method_index = 16777215;
      D.27329 = BIT_FIELD_REF <*method, 16, 256>;
      D.27330 = D.27329 & 4220;
      if (D.27330 == 4096) goto <D.27331>; else goto <D.27327>;
      <D.27331>:
      D.27332 = mono_method_is_generic_sharable_full (method, 0, 0, 0);
      if (D.27332 != 0) goto <D.27333>; else goto <D.27327>;
      <D.27333>:
      method = mono_method_get_declaring_generic_method (method);
      D.27334 = method->token;
      D.27335 = D.27334 & 16777215;
      method_index = D.27335 + 4294967295;
      goto <D.27328>;
      <D.27327>:
      D.27339 = BIT_FIELD_REF <*method, 8, 264>;
      D.27340 = D.27339 & 16;
      if (D.27340 != 0) goto <D.27336>; else goto <D.27341>;
      <D.27341>:
      D.27334 = method->token;
      if (D.27334 == 0) goto <D.27336>; else goto <D.27337>;
      <D.27336>:
      {
        int ret;

        ret = pthread_mutex_lock (&aot_mutex.mutex);
        if (ret != 0) goto <D.27342>; else goto <D.27343>;
        <D.27342>:
        monoeg_g_log (0B, 16, "Bad call to mono_mutex_lock result %d", ret);
        <D.27343>:
        D.27344 = ret != 0;
        D.27345 = (long int) D.27344;
        D.27346 = __builtin_expect (D.27345, 0);
        if (D.27346 != 0) goto <D.27347>; else goto <D.27348>;
        <D.27347>:
        monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "aot-runtime.c", 3628, "ret == 0");
        <D.27348>:
      }
      amodule.114 = amodule;
      D.27349 = amodule.114->method_to_code;
      code = monoeg_g_hash_table_lookup (D.27349, method);
      {
        int ret;

        ret = pthread_mutex_unlock (&aot_mutex.mutex);
        if (ret != 0) goto <D.27350>; else goto <D.27351>;
        <D.27350>:
        monoeg_g_log (0B, 16, "Bad call to mono_mutex_unlock result %d", ret);
        <D.27351>:
        D.27352 = ret != 0;
        D.27353 = (long int) D.27352;
        D.27354 = __builtin_expect (D.27353, 0);
        if (D.27354 != 0) goto <D.27355>; else goto <D.27356>;
        <D.27355>:
        monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "aot-runtime.c", 3630, "ret == 0");
        <D.27356>:
      }
      if (code != 0B) goto <D.27357>; else goto <D.27358>;
      <D.27357>:
      D.27295 = code;
      return D.27295;
      <D.27358>:
      method_index = find_extra_method (method, &amodule);
      if (method_index == 16777215) goto <D.27359>; else goto <D.27360>;
      <D.27359>:
      D.27315 = BIT_FIELD_REF <*method, 8, 256>;
      D.27316 = D.27315 & 124;
      if (D.27316 == 28) goto <D.27361>; else goto <D.27362>;
      <D.27361>:
      D.27363 = method->klass;
      D.27364 = D.27363->rank;
      if (D.27364 != 0) goto <D.27365>; else goto <D.27366>;
      <D.27365>:
      D.27367 = method->name;
      D.27368 = strstr (D.27367, "System.Collections.Generic");
      if (D.27368 != 0B) goto <D.27369>; else goto <D.27370>;
      <D.27369>:
      {
        struct MonoMethod * m;

        m = mono_aot_get_array_helper_from_wrapper (method);
        code = mono_aot_get_method (domain, m);
        if (code != 0B) goto <D.27371>; else goto <D.27372>;
        <D.27371>:
        D.27373 = mono_method_needs_static_rgctx_invoke (m, 0);
        if (D.27373 != 0) goto <D.27374>; else goto <D.27375>;
        <D.27374>:
        D.27376 = mono_create_ftnptr (domain, code);
        code = mono_create_static_rgctx_trampoline (m, D.27376);
        code = mono_get_addr_from_ftnptr (code);
        <D.27375>:
        D.27295 = code;
        return D.27295;
        <D.27372>:
      }
      <D.27370>:
      <D.27366>:
      <D.27362>:
      <D.27360>:
      if (method_index == 16777215) goto <D.27377>; else goto <D.27378>;
      <D.27377>:
      D.27315 = BIT_FIELD_REF <*method, 8, 256>;
      D.27316 = D.27315 & 124;
      if (D.27316 == 24) goto <D.27379>; else goto <D.27380>;
      <D.27379>:
      D.27363 = method->klass;
      D.27381 = mono_defaults.array_class;
      if (D.27363 == D.27381) goto <D.27382>; else goto <D.27383>;
      <D.27382>:
      {
        size_t __s1_len;
        size_t __s2_len;

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

          __s2 = method->name;
          D.27387 = "GetGenericValueImpl";
          D.27388 = MEM[(const unsigned char *)D.27387];
          D.27389 = (int) D.27388;
          D.27390 = *__s2;
          D.27391 = (int) D.27390;
          __result = D.27389 - D.27391;
          {
            D.27392 = __s2_len != 0;
            D.27393 = __result == 0;
            D.27394 = D.27392 & D.27393;
            if (D.27394 != 0) goto <D.27395>; else goto <D.27396>;
            <D.27395>:
            D.27397 = &MEM[(void *)"GetGenericValueImpl" + 1B];
            D.27398 = *D.27397;
            D.27399 = (int) D.27398;
            D.27400 = __s2 + 1;
            D.27401 = *D.27400;
            D.27402 = (int) D.27401;
            __result = D.27399 - D.27402;
            D.27403 = __s2_len > 1;
            D.27393 = __result == 0;
            D.27404 = D.27403 & D.27393;
            if (D.27404 != 0) goto <D.27405>; else goto <D.27406>;
            <D.27405>:
            D.27407 = &MEM[(void *)"GetGenericValueImpl" + 2B];
            D.27408 = *D.27407;
            D.27409 = (int) D.27408;
            D.27410 = __s2 + 2;
            D.27411 = *D.27410;
            D.27412 = (int) D.27411;
            __result = D.27409 - D.27412;
            D.27413 = __s2_len > 2;
            D.27393 = __result == 0;
            D.27414 = D.27413 & D.27393;
            if (D.27414 != 0) goto <D.27415>; else goto <D.27416>;
            <D.27415>:
            D.27417 = &MEM[(void *)"GetGenericValueImpl" + 3B];
            D.27418 = *D.27417;
            D.27419 = (int) D.27418;
            D.27420 = __s2 + 3;
            D.27421 = *D.27420;
            D.27422 = (int) D.27421;
            __result = D.27419 - D.27422;
            <D.27416>:
            <D.27406>:
            <D.27396>:
          }
          D.24478 = __result;
        }
        iftmp.116 = -D.24478;
        goto <D.27423>;
        <D.27386>:
        D.27367 = method->name;
        iftmp.116 = __builtin_strcmp (D.27367, "GetGenericValueImpl");
        <D.27423>:
        D.24479 = iftmp.116;
      }
      if (D.24479 == 0) goto <D.27424>; else goto <D.27425>;
      <D.27424>:
      {
        struct MonoMethod * m;
        struct MonoGenericContext ctx;
        struct MonoType * args[16];

        try
          {
            D.27426 = mono_method_signature (method);
            D.27427 = D.27426->params[1];
            D.27428 = D.27427->type;
            if (D.27428 == 28) goto <D.27429>; else goto <D.27430>;
            <D.27429>:
            D.27295 = 0B;
            return D.27295;
            <D.27430>:
            D.27381 = mono_defaults.array_class;
            m = mono_class_get_method_from_name (D.27381, "GetGenericValueImpl", 2);
            D.27431 = m == 0B;
            D.27432 = (long int) D.27431;
            D.27433 = __builtin_expect (D.27432, 0);
            if (D.27433 != 0) goto <D.27434>; else goto <D.27435>;
            <D.27434>:
            monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "aot-runtime.c", 3670, "m");
            <D.27435>:
            memset (&ctx, 0, 16);
            D.27436 = mono_defaults.object_class;
            D.27437 = &D.27436->byval_arg;
            args[0] = D.27437;
            D.27438 = mono_metadata_get_generic_inst (1, &args);
            ctx.method_inst = D.27438;
            D.27439 = mono_class_inflate_generic_method (m, &ctx);
            m = mono_marshal_get_native_wrapper (D.27439, 1, 1);
            code = mono_aot_get_method (domain, m);
            if (code != 0B) goto <D.27440>; else goto <D.27441>;
            <D.27440>:
            D.27295 = code;
            return D.27295;
            <D.27441>:
          }
        finally
          {
            ctx = {CLOBBER};
            args = {CLOBBER};
          }
      }
      <D.27425>:
      <D.27383>:
      <D.27380>:
      <D.27378>:
      if (method_index == 16777215) goto <D.27447>; else goto <D.27448>;
      <D.27447>:
      D.27315 = BIT_FIELD_REF <*method, 8, 256>;
      D.27316 = D.27315 & 124;
      if (D.27316 == 24) goto <D.27449>; else goto <D.27450>;
      <D.27449>:
      D.27363 = method->klass;
      D.27451 = D.27363->image;
      D.27452 = mono_defaults.corlib;
      if (D.27451 == D.27452) goto <D.27453>; else goto <D.27454>;
      <D.27453>:
      {
        size_t __s1_len;
        size_t __s2_len;

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

          D.27363 = method->klass;
          __s2 = D.27363->name_space;
          D.27458 = "System.Threading";
          D.27459 = MEM[(const unsigned char *)D.27458];
          D.27460 = (int) D.27459;
          D.27461 = *__s2;
          D.27462 = (int) D.27461;
          __result = D.27460 - D.27462;
          {
            D.27463 = __s2_len != 0;
            D.27464 = __result == 0;
            D.27465 = D.27463 & D.27464;
            if (D.27465 != 0) goto <D.27466>; else goto <D.27467>;
            <D.27466>:
            D.27468 = &MEM[(void *)"System.Threading" + 1B];
            D.27469 = *D.27468;
            D.27470 = (int) D.27469;
            D.27471 = __s2 + 1;
            D.27472 = *D.27471;
            D.27473 = (int) D.27472;
            __result = D.27470 - D.27473;
            D.27474 = __s2_len > 1;
            D.27464 = __result == 0;
            D.27475 = D.27474 & D.27464;
            if (D.27475 != 0) goto <D.27476>; else goto <D.27477>;
            <D.27476>:
            D.27478 = &MEM[(void *)"System.Threading" + 2B];
            D.27479 = *D.27478;
            D.27480 = (int) D.27479;
            D.27481 = __s2 + 2;
            D.27482 = *D.27481;
            D.27483 = (int) D.27482;
            __result = D.27480 - D.27483;
            D.27484 = __s2_len > 2;
            D.27464 = __result == 0;
            D.27485 = D.27484 & D.27464;
            if (D.27485 != 0) goto <D.27486>; else goto <D.27487>;
            <D.27486>:
            D.27488 = &MEM[(void *)"System.Threading" + 3B];
            D.27489 = *D.27488;
            D.27490 = (int) D.27489;
            D.27491 = __s2 + 3;
            D.27492 = *D.27491;
            D.27493 = (int) D.27492;
            __result = D.27490 - D.27493;
            <D.27487>:
            <D.27477>:
            <D.27467>:
          }
          D.24490 = __result;
        }
        iftmp.117 = -D.24490;
        goto <D.27494>;
        <D.27457>:
        D.27363 = method->klass;
        D.27495 = D.27363->name_space;
        iftmp.117 = __builtin_strcmp (D.27495, "System.Threading");
        <D.27494>:
        D.24491 = iftmp.117;
      }
      if (D.24491 == 0) goto <D.27496>; else goto <D.27442>;
      <D.27496>:
      {
        size_t __s1_len;
        size_t __s2_len;

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

          D.27363 = method->klass;
          __s2 = D.27363->name;
          D.27500 = "Interlocked";
          D.27501 = MEM[(const unsigned char *)D.27500];
          D.27502 = (int) D.27501;
          D.27503 = *__s2;
          D.27504 = (int) D.27503;
          __result = D.27502 - D.27504;
          {
            D.27505 = __s2_len != 0;
            D.27506 = __result == 0;
            D.27507 = D.27505 & D.27506;
            if (D.27507 != 0) goto <D.27508>; else goto <D.27509>;
            <D.27508>:
            D.27510 = &MEM[(void *)"Interlocked" + 1B];
            D.27511 = *D.27510;
            D.27512 = (int) D.27511;
            D.27513 = __s2 + 1;
            D.27514 = *D.27513;
            D.27515 = (int) D.27514;
            __result = D.27512 - D.27515;
            D.27516 = __s2_len > 1;
            D.27506 = __result == 0;
            D.27517 = D.27516 & D.27506;
            if (D.27517 != 0) goto <D.27518>; else goto <D.27519>;
            <D.27518>:
            D.27520 = &MEM[(void *)"Interlocked" + 2B];
            D.27521 = *D.27520;
            D.27522 = (int) D.27521;
            D.27523 = __s2 + 2;
            D.27524 = *D.27523;
            D.27525 = (int) D.27524;
            __result = D.27522 - D.27525;
            D.27526 = __s2_len > 2;
            D.27506 = __result == 0;
            D.27527 = D.27526 & D.27506;
            if (D.27527 != 0) goto <D.27528>; else goto <D.27529>;
            <D.27528>:
            D.27530 = &MEM[(void *)"Interlocked" + 3B];
            D.27531 = *D.27530;
            D.27532 = (int) D.27531;
            D.27533 = __s2 + 3;
            D.27534 = *D.27533;
            D.27535 = (int) D.27534;
            __result = D.27532 - D.27535;
            <D.27529>:
            <D.27519>:
            <D.27509>:
          }
          D.24499 = __result;
        }
        iftmp.118 = -D.24499;
        goto <D.27536>;
        <D.27499>:
        D.27363 = method->klass;
        D.27537 = D.27363->name;
        iftmp.118 = __builtin_strcmp (D.27537, "Interlocked");
        <D.27536>:
        D.24500 = iftmp.118;
      }
      if (D.24500 == 0) goto <D.27538>; else goto <D.27442>;
      <D.27538>:
      {
        size_t __s1_len;
        size_t __s2_len;

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

          __s2 = method->name;
          D.27542 = "CompareExchange";
          D.27543 = MEM[(const unsigned char *)D.27542];
          D.27544 = (int) D.27543;
          D.27545 = *__s2;
          D.27546 = (int) D.27545;
          __result = D.27544 - D.27546;
          {
            D.27547 = __s2_len != 0;
            D.27548 = __result == 0;
            D.27549 = D.27547 & D.27548;
            if (D.27549 != 0) goto <D.27550>; else goto <D.27551>;
            <D.27550>:
            D.27552 = &MEM[(void *)"CompareExchange" + 1B];
            D.27553 = *D.27552;
            D.27554 = (int) D.27553;
            D.27555 = __s2 + 1;
            D.27556 = *D.27555;
            D.27557 = (int) D.27556;
            __result = D.27554 - D.27557;
            D.27558 = __s2_len > 1;
            D.27548 = __result == 0;
            D.27559 = D.27558 & D.27548;
            if (D.27559 != 0) goto <D.27560>; else goto <D.27561>;
            <D.27560>:
            D.27562 = &MEM[(void *)"CompareExchange" + 2B];
            D.27563 = *D.27562;
            D.27564 = (int) D.27563;
            D.27565 = __s2 + 2;
            D.27566 = *D.27565;
            D.27567 = (int) D.27566;
            __result = D.27564 - D.27567;
            D.27568 = __s2_len > 2;
            D.27548 = __result == 0;
            D.27569 = D.27568 & D.27548;
            if (D.27569 != 0) goto <D.27570>; else goto <D.27571>;
            <D.27570>:
            D.27572 = &MEM[(void *)"CompareExchange" + 3B];
            D.27573 = *D.27572;
            D.27574 = (int) D.27573;
            D.27575 = __s2 + 3;
            D.27576 = *D.27575;
            D.27577 = (int) D.27576;
            __result = D.27574 - D.27577;
            <D.27571>:
            <D.27561>:
            <D.27551>:
          }
          D.24508 = __result;
        }
        iftmp.119 = -D.24508;
        goto <D.27578>;
        <D.27541>:
        D.27367 = method->name;
        iftmp.119 = __builtin_strcmp (D.27367, "CompareExchange");
        <D.27578>:
        D.24509 = iftmp.119;
      }
      if (D.24509 == 0) goto <D.27443>; else goto <D.27579>;
      <D.27579>:
      {
        size_t __s1_len;
        size_t __s2_len;

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

          __s2 = method->name;
          D.27583 = "Exchange";
          D.27584 = MEM[(const unsigned char *)D.27583];
          D.27585 = (int) D.27584;
          D.27586 = *__s2;
          D.27587 = (int) D.27586;
          __result = D.27585 - D.27587;
          {
            D.27588 = __s2_len != 0;
            D.27589 = __result == 0;
            D.27590 = D.27588 & D.27589;
            if (D.27590 != 0) goto <D.27591>; else goto <D.27592>;
            <D.27591>:
            D.27593 = &MEM[(void *)"Exchange" + 1B];
            D.27594 = *D.27593;
            D.27595 = (int) D.27594;
            D.27596 = __s2 + 1;
            D.27597 = *D.27596;
            D.27598 = (int) D.27597;
            __result = D.27595 - D.27598;
            D.27599 = __s2_len > 1;
            D.27589 = __result == 0;
            D.27600 = D.27599 & D.27589;
            if (D.27600 != 0) goto <D.27601>; else goto <D.27602>;
            <D.27601>:
            D.27603 = &MEM[(void *)"Exchange" + 2B];
            D.27604 = *D.27603;
            D.27605 = (int) D.27604;
            D.27606 = __s2 + 2;
            D.27607 = *D.27606;
            D.27608 = (int) D.27607;
            __result = D.27605 - D.27608;
            D.27609 = __s2_len > 2;
            D.27589 = __result == 0;
            D.27610 = D.27609 & D.27589;
            if (D.27610 != 0) goto <D.27611>; else goto <D.27612>;
            <D.27611>:
            D.27613 = &MEM[(void *)"Exchange" + 3B];
            D.27614 = *D.27613;
            D.27615 = (int) D.27614;
            D.27616 = __s2 + 3;
            D.27617 = *D.27616;
            D.27618 = (int) D.27617;
            __result = D.27615 - D.27618;
            <D.27612>:
            <D.27602>:
            <D.27592>:
          }
          D.24517 = __result;
        }
        iftmp.120 = -D.24517;
        goto <D.27619>;
        <D.27582>:
        D.27367 = method->name;
        iftmp.120 = __builtin_strcmp (D.27367, "Exchange");
        <D.27619>:
        D.24518 = iftmp.120;
      }
      if (D.24518 == 0) goto <D.27443>; else goto <D.27442>;
      <D.27443>:
      D.27620 = mono_method_signature (method);
      D.27621 = D.27620->params[1];
      D.27622 = mono_type_is_reference (D.27621);
      if (D.27622 != 0) goto <D.27444>; else goto <D.27442>;
      <D.27442>:
      {
        size_t __s1_len;
        size_t __s2_len;

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

          D.27363 = method->klass;
          __s2 = D.27363->name_space;
          D.27458 = "System.Threading";
          D.27459 = MEM[(const unsigned char *)D.27458];
          D.27460 = (int) D.27459;
          D.27626 = *__s2;
          D.27627 = (int) D.27626;
          __result = D.27460 - D.27627;
          {
            D.27628 = __s2_len != 0;
            D.27629 = __result == 0;
            D.27630 = D.27628 & D.27629;
            if (D.27630 != 0) goto <D.27631>; else goto <D.27632>;
            <D.27631>:
            D.27468 = &MEM[(void *)"System.Threading" + 1B];
            D.27469 = *D.27468;
            D.27470 = (int) D.27469;
            D.27633 = __s2 + 1;
            D.27634 = *D.27633;
            D.27635 = (int) D.27634;
            __result = D.27470 - D.27635;
            D.27636 = __s2_len > 1;
            D.27629 = __result == 0;
            D.27637 = D.27636 & D.27629;
            if (D.27637 != 0) goto <D.27638>; else goto <D.27639>;
            <D.27638>:
            D.27478 = &MEM[(void *)"System.Threading" + 2B];
            D.27479 = *D.27478;
            D.27480 = (int) D.27479;
            D.27640 = __s2 + 2;
            D.27641 = *D.27640;
            D.27642 = (int) D.27641;
            __result = D.27480 - D.27642;
            D.27643 = __s2_len > 2;
            D.27629 = __result == 0;
            D.27644 = D.27643 & D.27629;
            if (D.27644 != 0) goto <D.27645>; else goto <D.27646>;
            <D.27645>:
            D.27488 = &MEM[(void *)"System.Threading" + 3B];
            D.27489 = *D.27488;
            D.27490 = (int) D.27489;
            D.27647 = __s2 + 3;
            D.27648 = *D.27647;
            D.27649 = (int) D.27648;
            __result = D.27490 - D.27649;
            <D.27646>:
            <D.27639>:
            <D.27632>:
          }
          D.24526 = __result;
        }
        iftmp.121 = -D.24526;
        goto <D.27650>;
        <D.27625>:
        D.27363 = method->klass;
        D.27495 = D.27363->name_space;
        iftmp.121 = __builtin_strcmp (D.27495, "System.Threading");
        <D.27650>:
        D.24527 = iftmp.121;
      }
      if (D.24527 == 0) goto <D.27651>; else goto <D.27445>;
      <D.27651>:
      {
        size_t __s1_len;
        size_t __s2_len;

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

          D.27363 = method->klass;
          __s2 = D.27363->name;
          D.27655 = "Volatile";
          D.27656 = MEM[(const unsigned char *)D.27655];
          D.27657 = (int) D.27656;
          D.27658 = *__s2;
          D.27659 = (int) D.27658;
          __result = D.27657 - D.27659;
          {
            D.27660 = __s2_len != 0;
            D.27661 = __result == 0;
            D.27662 = D.27660 & D.27661;
            if (D.27662 != 0) goto <D.27663>; else goto <D.27664>;
            <D.27663>:
            D.27665 = &MEM[(void *)"Volatile" + 1B];
            D.27666 = *D.27665;
            D.27667 = (int) D.27666;
            D.27668 = __s2 + 1;
            D.27669 = *D.27668;
            D.27670 = (int) D.27669;
            __result = D.27667 - D.27670;
            D.27671 = __s2_len > 1;
            D.27661 = __result == 0;
            D.27672 = D.27671 & D.27661;
            if (D.27672 != 0) goto <D.27673>; else goto <D.27674>;
            <D.27673>:
            D.27675 = &MEM[(void *)"Volatile" + 2B];
            D.27676 = *D.27675;
            D.27677 = (int) D.27676;
            D.27678 = __s2 + 2;
            D.27679 = *D.27678;
            D.27680 = (int) D.27679;
            __result = D.27677 - D.27680;
            D.27681 = __s2_len > 2;
            D.27661 = __result == 0;
            D.27682 = D.27681 & D.27661;
            if (D.27682 != 0) goto <D.27683>; else goto <D.27684>;
            <D.27683>:
            D.27685 = &MEM[(void *)"Volatile" + 3B];
            D.27686 = *D.27685;
            D.27687 = (int) D.27686;
            D.27688 = __s2 + 3;
            D.27689 = *D.27688;
            D.27690 = (int) D.27689;
            __result = D.27687 - D.27690;
            <D.27684>:
            <D.27674>:
            <D.27664>:
          }
          D.24535 = __result;
        }
        iftmp.122 = -D.24535;
        goto <D.27691>;
        <D.27654>:
        D.27363 = method->klass;
        D.27537 = D.27363->name;
        iftmp.122 = __builtin_strcmp (D.27537, "Volatile");
        <D.27691>:
        D.24536 = iftmp.122;
      }
      if (D.24536 == 0) goto <D.27692>; else goto <D.27445>;
      <D.27692>:
      {
        size_t __s1_len;
        size_t __s2_len;

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

          __s2 = method->name;
          D.27696 = "Read";
          D.27697 = MEM[(const unsigned char *)D.27696];
          D.27698 = (int) D.27697;
          D.27699 = *__s2;
          D.27700 = (int) D.27699;
          __result = D.27698 - D.27700;
          {
            D.27701 = __s2_len != 0;
            D.27702 = __result == 0;
            D.27703 = D.27701 & D.27702;
            if (D.27703 != 0) goto <D.27704>; else goto <D.27705>;
            <D.27704>:
            D.27706 = &MEM[(void *)"Read" + 1B];
            D.27707 = *D.27706;
            D.27708 = (int) D.27707;
            D.27709 = __s2 + 1;
            D.27710 = *D.27709;
            D.27711 = (int) D.27710;
            __result = D.27708 - D.27711;
            D.27712 = __s2_len > 1;
            D.27702 = __result == 0;
            D.27713 = D.27712 & D.27702;
            if (D.27713 != 0) goto <D.27714>; else goto <D.27715>;
            <D.27714>:
            D.27716 = &MEM[(void *)"Read" + 2B];
            D.27717 = *D.27716;
            D.27718 = (int) D.27717;
            D.27719 = __s2 + 2;
            D.27720 = *D.27719;
            D.27721 = (int) D.27720;
            __result = D.27718 - D.27721;
            D.27722 = __s2_len > 2;
            D.27702 = __result == 0;
            D.27723 = D.27722 & D.27702;
            if (D.27723 != 0) goto <D.27724>; else goto <D.27725>;
            <D.27724>:
            D.27726 = &MEM[(void *)"Read" + 3B];
            D.27727 = *D.27726;
            D.27728 = (int) D.27727;
            D.27729 = __s2 + 3;
            D.27730 = *D.27729;
            D.27731 = (int) D.27730;
            __result = D.27728 - D.27731;
            <D.27725>:
            <D.27715>:
            <D.27705>:
          }
          D.24544 = __result;
        }
        iftmp.123 = -D.24544;
        goto <D.27732>;
        <D.27695>:
        D.27367 = method->name;
        iftmp.123 = __builtin_strcmp (D.27367, "Read");
        <D.27732>:
        D.24545 = iftmp.123;
      }
      if (D.24545 == 0) goto <D.27733>; else goto <D.27445>;
      <D.27733>:
      D.27734 = mono_method_signature (method);
      D.27735 = D.27734->ret;
      D.27736 = mono_type_is_reference (D.27735);
      if (D.27736 != 0) goto <D.27444>; else goto <D.27445>;
      <D.27445>:
      {
        size_t __s1_len;
        size_t __s2_len;

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

          D.27363 = method->klass;
          __s2 = D.27363->name_space;
          D.27458 = "System.Threading";
          D.27459 = MEM[(const unsigned char *)D.27458];
          D.27460 = (int) D.27459;
          D.27740 = *__s2;
          D.27741 = (int) D.27740;
          __result = D.27460 - D.27741;
          {
            D.27742 = __s2_len != 0;
            D.27743 = __result == 0;
            D.27744 = D.27742 & D.27743;
            if (D.27744 != 0) goto <D.27745>; else goto <D.27746>;
            <D.27745>:
            D.27468 = &MEM[(void *)"System.Threading" + 1B];
            D.27469 = *D.27468;
            D.27470 = (int) D.27469;
            D.27747 = __s2 + 1;
            D.27748 = *D.27747;
            D.27749 = (int) D.27748;
            __result = D.27470 - D.27749;
            D.27750 = __s2_len > 1;
            D.27743 = __result == 0;
            D.27751 = D.27750 & D.27743;
            if (D.27751 != 0) goto <D.27752>; else goto <D.27753>;
            <D.27752>:
            D.27478 = &MEM[(void *)"System.Threading" + 2B];
            D.27479 = *D.27478;
            D.27480 = (int) D.27479;
            D.27754 = __s2 + 2;
            D.27755 = *D.27754;
            D.27756 = (int) D.27755;
            __result = D.27480 - D.27756;
            D.27757 = __s2_len > 2;
            D.27743 = __result == 0;
            D.27758 = D.27757 & D.27743;
            if (D.27758 != 0) goto <D.27759>; else goto <D.27760>;
            <D.27759>:
            D.27488 = &MEM[(void *)"System.Threading" + 3B];
            D.27489 = *D.27488;
            D.27490 = (int) D.27489;
            D.27761 = __s2 + 3;
            D.27762 = *D.27761;
            D.27763 = (int) D.27762;
            __result = D.27490 - D.27763;
            <D.27760>:
            <D.27753>:
            <D.27746>:
          }
          D.24553 = __result;
        }
        iftmp.124 = -D.24553;
        goto <D.27764>;
        <D.27739>:
        D.27363 = method->klass;
        D.27495 = D.27363->name_space;
        iftmp.124 = __builtin_strcmp (D.27495, "System.Threading");
        <D.27764>:
        D.24554 = iftmp.124;
      }
      if (D.24554 == 0) goto <D.27765>; else goto <D.27446>;
      <D.27765>:
      {
        size_t __s1_len;
        size_t __s2_len;

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

          D.27363 = method->klass;
          __s2 = D.27363->name;
          D.27655 = "Volatile";
          D.27656 = MEM[(const unsigned char *)D.27655];
          D.27657 = (int) D.27656;
          D.27769 = *__s2;
          D.27770 = (int) D.27769;
          __result = D.27657 - D.27770;
          {
            D.27771 = __s2_len != 0;
            D.27772 = __result == 0;
            D.27773 = D.27771 & D.27772;
            if (D.27773 != 0) goto <D.27774>; else goto <D.27775>;
            <D.27774>:
            D.27665 = &MEM[(void *)"Volatile" + 1B];
            D.27666 = *D.27665;
            D.27667 = (int) D.27666;
            D.27776 = __s2 + 1;
            D.27777 = *D.27776;
            D.27778 = (int) D.27777;
            __result = D.27667 - D.27778;
            D.27779 = __s2_len > 1;
            D.27772 = __result == 0;
            D.27780 = D.27779 & D.27772;
            if (D.27780 != 0) goto <D.27781>; else goto <D.27782>;
            <D.27781>:
            D.27675 = &MEM[(void *)"Volatile" + 2B];
            D.27676 = *D.27675;
            D.27677 = (int) D.27676;
            D.27783 = __s2 + 2;
            D.27784 = *D.27783;
            D.27785 = (int) D.27784;
            __result = D.27677 - D.27785;
            D.27786 = __s2_len > 2;
            D.27772 = __result == 0;
            D.27787 = D.27786 & D.27772;
            if (D.27787 != 0) goto <D.27788>; else goto <D.27789>;
            <D.27788>:
            D.27685 = &MEM[(void *)"Volatile" + 3B];
            D.27686 = *D.27685;
            D.27687 = (int) D.27686;
            D.27790 = __s2 + 3;
            D.27791 = *D.27790;
            D.27792 = (int) D.27791;
            __result = D.27687 - D.27792;
            <D.27789>:
            <D.27782>:
            <D.27775>:
          }
          D.24562 = __result;
        }
        iftmp.125 = -D.24562;
        goto <D.27793>;
        <D.27768>:
        D.27363 = method->klass;
        D.27537 = D.27363->name;
        iftmp.125 = __builtin_strcmp (D.27537, "Volatile");
        <D.27793>:
        D.24563 = iftmp.125;
      }
      if (D.24563 == 0) goto <D.27794>; else goto <D.27446>;
      <D.27794>:
      {
        size_t __s1_len;
        size_t __s2_len;

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

          __s2 = method->name;
          D.27798 = "Write";
          D.27799 = MEM[(const unsigned char *)D.27798];
          D.27800 = (int) D.27799;
          D.27801 = *__s2;
          D.27802 = (int) D.27801;
          __result = D.27800 - D.27802;
          {
            D.27803 = __s2_len != 0;
            D.27804 = __result == 0;
            D.27805 = D.27803 & D.27804;
            if (D.27805 != 0) goto <D.27806>; else goto <D.27807>;
            <D.27806>:
            D.27808 = &MEM[(void *)"Write" + 1B];
            D.27809 = *D.27808;
            D.27810 = (int) D.27809;
            D.27811 = __s2 + 1;
            D.27812 = *D.27811;
            D.27813 = (int) D.27812;
            __result = D.27810 - D.27813;
            D.27814 = __s2_len > 1;
            D.27804 = __result == 0;
            D.27815 = D.27814 & D.27804;
            if (D.27815 != 0) goto <D.27816>; else goto <D.27817>;
            <D.27816>:
            D.27818 = &MEM[(void *)"Write" + 2B];
            D.27819 = *D.27818;
            D.27820 = (int) D.27819;
            D.27821 = __s2 + 2;
            D.27822 = *D.27821;
            D.27823 = (int) D.27822;
            __result = D.27820 - D.27823;
            D.27824 = __s2_len > 2;
            D.27804 = __result == 0;
            D.27825 = D.27824 & D.27804;
            if (D.27825 != 0) goto <D.27826>; else goto <D.27827>;
            <D.27826>:
            D.27828 = &MEM[(void *)"Write" + 3B];
            D.27829 = *D.27828;
            D.27830 = (int) D.27829;
            D.27831 = __s2 + 3;
            D.27832 = *D.27831;
            D.27833 = (int) D.27832;
            __result = D.27830 - D.27833;
            <D.27827>:
            <D.27817>:
            <D.27807>:
          }
          D.24571 = __result;
        }
        iftmp.126 = -D.24571;
        goto <D.27834>;
        <D.27797>:
        D.27367 = method->name;
        iftmp.126 = __builtin_strcmp (D.27367, "Write");
        <D.27834>:
        D.24572 = iftmp.126;
      }
      if (D.24572 == 0) goto <D.27835>; else goto <D.27446>;
      <D.27835>:
      D.27836 = mono_method_signature (method);
      D.27837 = D.27836->params[1];
      D.27838 = mono_type_is_reference (D.27837);
      if (D.27838 != 0) goto <D.27444>; else goto <D.27446>;
      <D.27444>:
      {
        struct MonoMethod * m;
        struct MonoGenericContext ctx;
        struct MonoType * args[16];
        void * iter;

        try
          {
            iter = 0B;
            goto <D.24588>;
            <D.24587>:
            D.27839 = mono_method_signature (m);
            D.27840 = D.27839->generic_param_count;
            if (D.27840 != 0) goto <D.27841>; else goto <D.27842>;
            <D.27841>:
            {
              size_t __s1_len;
              size_t __s2_len;

              D.27367 = method->name;
              D.27843 = m->name;
              D.24585 = __builtin_strcmp (D.27843, D.27367);
            }
            if (D.24585 == 0) goto <D.24586>; else goto <D.27844>;
            <D.27844>:
            <D.27842>:
            <D.24588>:
            D.27363 = method->klass;
            m = mono_class_get_methods (D.27363, &iter);
            if (m != 0B) goto <D.24587>; else goto <D.24586>;
            <D.24586>:
            D.27845 = m == 0B;
            D.27846 = (long int) D.27845;
            D.27847 = __builtin_expect (D.27846, 0);
            if (D.27847 != 0) goto <D.27848>; else goto <D.27849>;
            <D.27848>:
            monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "aot-runtime.c", 3702, "m");
            <D.27849>:
            memset (&ctx, 0, 16);
            D.27436 = mono_defaults.object_class;
            D.27437 = &D.27436->byval_arg;
            args[0] = D.27437;
            D.27850 = mono_metadata_get_generic_inst (1, &args);
            ctx.method_inst = D.27850;
            D.27851 = mono_class_inflate_generic_method (m, &ctx);
            m = mono_marshal_get_native_wrapper (D.27851, 1, 1);
            if (method == m) goto <D.27852>; else goto <D.27853>;
            <D.27852>:
            D.27295 = 0B;
            return D.27295;
            <D.27853>:
            code = mono_aot_get_method (domain, m);
            if (code != 0B) goto <D.27854>; else goto <D.27855>;
            <D.27854>:
            D.27295 = code;
            return D.27295;
            <D.27855>:
          }
        finally
          {
            ctx = {CLOBBER};
            args = {CLOBBER};
            iter = {CLOBBER};
          }
      }
      <D.27446>:
      <D.27454>:
      <D.27450>:
      <D.27448>:
      if (method_index == 16777215) goto <D.27856>; else goto <D.27857>;
      <D.27856>:
      D.27339 = BIT_FIELD_REF <*method, 8, 264>;
      D.27340 = D.27339 & 16;
      if (D.27340 != 0) goto <D.27858>; else goto <D.27859>;
      <D.27858>:
      D.27860 = mono_method_is_generic_sharable_full (method, 0, 1, 0);
      if (D.27860 != 0) goto <D.27861>; else goto <D.27862>;
      <D.27861>:
      {
        struct MonoMethod * shared;

        shared = mini_get_shared_method (method);
        method_index = find_extra_method (shared, &amodule);
        if (method_index != 16777215) goto <D.27863>; else goto <D.27864>;
        <D.27863>:
        method = shared;
        <D.27864>:
      }
      <D.27862>:
      <D.27859>:
      <D.27857>:
      if (method_index == 16777215) goto <D.27865>; else goto <D.27866>;
      <D.27865>:
      D.27339 = BIT_FIELD_REF <*method, 8, 264>;
      D.27340 = D.27339 & 16;
      if (D.27340 != 0) goto <D.27867>; else goto <D.27868>;
      <D.27867>:
      D.27869 = mono_method_is_generic_sharable_full (method, 0, 0, 1);
      if (D.27869 != 0) goto <D.27870>; else goto <D.27871>;
      <D.27870>:
      D.27872 = mini_get_shared_method_full (method, 1, 1);
      method_index = find_extra_method (D.27872, &amodule);
      if (method_index != 16777215) goto <D.27873>; else goto <D.27874>;
      <D.27873>:
      method = mini_get_shared_method_full (method, 1, 0);
      <D.27874>:
      <D.27871>:
      <D.27868>:
      <D.27866>:
      if (method_index == 16777215) goto <D.27875>; else goto <D.27876>;
      <D.27875>:
      mono_aot_only.115 = mono_aot_only;
      if (mono_aot_only.115 != 0) goto <D.27877>; else goto <D.27878>;
      <D.27877>:
      D.27879 = mono_trace_is_traced (128, 32);
      if (D.27879 != 0) goto <D.27880>; else goto <D.27881>;
      <D.27880>:
      {
        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.27881>:
      <D.27878>:
      D.27295 = 0B;
      return D.27295;
      <D.27876>:
      if (method_index == 16777215) goto <D.27882>; else goto <D.27883>;
      <D.27882>:
      D.27295 = 0B;
      return D.27295;
      <D.27883>:
      {
        int ret;

        ret = pthread_mutex_lock (&aot_mutex.mutex);
        if (ret != 0) goto <D.27884>; else goto <D.27885>;
        <D.27884>:
        monoeg_g_log (0B, 16, "Bad call to mono_mutex_lock result %d", ret);
        <D.27885>:
        D.27886 = ret != 0;
        D.27887 = (long int) D.27886;
        D.27888 = __builtin_expect (D.27887, 0);
        if (D.27888 != 0) goto <D.27889>; else goto <D.27890>;
        <D.27889>:
        monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "aot-runtime.c", 3756, "ret == 0");
        <D.27890>:
      }
      amodule.114 = amodule;
      D.27891 = amodule.114->extra_methods;
      if (D.27891 == 0B) goto <D.27892>; else goto <D.27893>;
      <D.27892>:
      amodule.114 = amodule;
      D.27894 = monoeg_g_hash_table_new (0B, 0B);
      amodule.114->extra_methods = D.27894;
      <D.27893>:
      D.27895 = (long unsigned int) method_index;
      D.27896 = (void *) D.27895;
      amodule.114 = amodule;
      D.27891 = amodule.114->extra_methods;
      monoeg_g_hash_table_insert_replace (D.27891, D.27896, method, 0);
      {
        int ret;

        ret = pthread_mutex_unlock (&aot_mutex.mutex);
        if (ret != 0) goto <D.27897>; else goto <D.27898>;
        <D.27897>:
        monoeg_g_log (0B, 16, "Bad call to mono_mutex_unlock result %d", ret);
        <D.27898>:
        D.27899 = ret != 0;
        D.27900 = (long int) D.27899;
        D.27901 = __builtin_expect (D.27900, 0);
        if (D.27901 != 0) goto <D.27902>; else goto <D.27903>;
        <D.27902>:
        monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "aot-runtime.c", 3760, "ret == 0");
        <D.27903>:
      }
      goto <D.27338>;
      <D.27337>:
      D.27334 = method->token;
      D.27335 = D.27334 & 16777215;
      method_index = D.27335 + 4294967295;
      <D.27338>:
      <D.27328>:
      method_index.127 = (int) method_index;
      D.27334 = method->token;
      D.27290 = klass->image;
      amodule.114 = amodule;
      D.27295 = load_method (domain, amodule.114, D.27290, method, D.27334, method_index.127);
      return D.27295;
    }
  finally
    {
      amodule = {CLOBBER};
    }
}


find_extra_method (struct MonoMethod * method, struct MonoAotModule * * out_amodule)
{
  struct MonoClass * D.27911;
  struct MonoImage * D.27912;
  void * D.27913;
  guint32 D.27916;
  _Bool D.27919;
  long int D.27920;
  long int D.27921;
  struct GHashTable * aot_modules.128;
  _Bool D.27927;
  long int D.27928;
  long int D.27929;
  void * * D.27932;
  long unsigned int D.27933;
  long unsigned int D.27934;
  void * * D.27935;
  unsigned int i.129;
  unsigned int D.27941;
  guint32 index;
  struct GPtrArray * modules;
  int i;

  D.27911 = method->klass;
  D.27912 = D.27911->image;
  D.27913 = D.27912->aot_module;
  *out_amodule = D.27913;
  D.27911 = method->klass;
  D.27912 = D.27911->image;
  D.27913 = D.27912->aot_module;
  index = find_extra_method_in_amodule (D.27913, method);
  if (index != 16777215) goto <D.27914>; else goto <D.27915>;
  <D.27914>:
  D.27916 = index;
  return D.27916;
  <D.27915>:
  modules = monoeg_g_ptr_array_new ();
  {
    int ret;

    ret = pthread_mutex_lock (&aot_mutex.mutex);
    if (ret != 0) goto <D.27917>; else goto <D.27918>;
    <D.27917>:
    monoeg_g_log (0B, 16, "Bad call to mono_mutex_lock result %d", ret);
    <D.27918>:
    D.27919 = ret != 0;
    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", 3559, "ret == 0");
    <D.27923>:
  }
  aot_modules.128 = aot_modules;
  monoeg_g_hash_table_foreach (aot_modules.128, add_module_cb, modules);
  {
    int ret;

    ret = pthread_mutex_unlock (&aot_mutex.mutex);
    if (ret != 0) goto <D.27925>; else goto <D.27926>;
    <D.27925>:
    monoeg_g_log (0B, 16, "Bad call to mono_mutex_unlock result %d", ret);
    <D.27926>:
    D.27927 = ret != 0;
    D.27928 = (long int) D.27927;
    D.27929 = __builtin_expect (D.27928, 0);
    if (D.27929 != 0) goto <D.27930>; else goto <D.27931>;
    <D.27930>:
    monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "aot-runtime.c", 3561, "ret == 0");
    <D.27931>:
  }
  index = 16777215;
  i = 0;
  goto <D.24459>;
  <D.24458>:
  {
    struct MonoAotModule * amodule;

    D.27932 = modules->pdata;
    D.27933 = (long unsigned int) i;
    D.27934 = D.27933 * 8;
    D.27935 = D.27932 + D.27934;
    amodule = *D.27935;
    D.27911 = method->klass;
    D.27912 = D.27911->image;
    D.27913 = D.27912->aot_module;
    if (D.27913 != amodule) goto <D.27936>; else goto <D.27937>;
    <D.27936>:
    index = find_extra_method_in_amodule (amodule, method);
    <D.27937>:
    if (index != 16777215) goto <D.27938>; else goto <D.27939>;
    <D.27938>:
    *out_amodule = amodule;
    goto <D.24457>;
    <D.27939>:
  }
  i = i + 1;
  <D.24459>:
  i.129 = (unsigned int) i;
  D.27941 = modules->len;
  if (i.129 < D.27941) goto <D.24458>; else goto <D.24457>;
  <D.24457>:
  monoeg_g_ptr_array_free (modules, 1);
  D.27916 = index;
  return D.27916;
}


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.27946;
  guint32 D.27947;
  guint32 * D.27948;
  unsigned int D.27949;
  unsigned int D.27950;
  long unsigned int D.27951;
  long unsigned int D.27952;
  unsigned int D.27953;
  unsigned int D.27956;
  long unsigned int D.27957;
  long unsigned int D.27958;
  guint32 * D.27959;
  guint8 * D.27960;
  sizetype D.27961;
  guint8 * p.130;
  _Bool D.27965;
  long int D.27966;
  long int D.27967;
  struct GHashTable * D.27970;
  struct GHashTable * D.27973;
  guint8 * p.131;
  _Bool D.27977;
  long int D.27978;
  long int D.27979;
  _Bool D.27988;
  long int D.27989;
  long int D.27990;
  _Bool D.27995;
  long int D.27996;
  long int D.27997;
  unsigned char D.28004;
  unsigned char D.28005;
  unsigned char D.28010;
  unsigned char D.28011;
  struct MonoMethod * D.28014;
  unsigned int n_extra_decodes.132;
  unsigned int n_extra_decodes.133;
  unsigned int D.28022;
  long unsigned int D.28023;
  long unsigned int D.28024;
  guint32 table_size;
  guint32 entry_size;
  guint32 hash;
  guint32 * table;
  guint32 * entry;
  guint32 index;
  static guint32 n_extra_decodes;

  if (amodule == 0B) goto <D.27943>; else goto <D.27945>;
  <D.27945>:
  D.27946 = amodule->out_of_date;
  if (D.27946 != 0) goto <D.27943>; else goto <D.27944>;
  <D.27943>:
  D.27947 = 16777215;
  return D.27947;
  <D.27944>:
  D.27948 = amodule->extra_method_table;
  table_size = *D.27948;
  D.27948 = amodule->extra_method_table;
  table = D.27948 + 4;
  entry_size = 3;
  D.27949 = mono_aot_method_hash (method);
  hash = D.27949 % table_size;
  D.27950 = hash * entry_size;
  D.27951 = (long unsigned int) D.27950;
  D.27952 = D.27951 * 4;
  entry = table + D.27952;
  D.27953 = *entry;
  if (D.27953 == 0) goto <D.27954>; else goto <D.27955>;
  <D.27954>:
  D.27947 = 16777215;
  return D.27947;
  <D.27955>:
  index = 16777215;
  <D.24441>:
  {
    guint32 key;
    guint32 value;
    guint32 next;
    struct MonoMethod * m;
    guint8 * p;
    guint8 * orig_p;

    try
      {
        key = *entry;
        value = MEM[(guint32 *)entry + 4B];
        D.27956 = entry_size + 4294967295;
        D.27957 = (long unsigned int) D.27956;
        D.27958 = D.27957 * 4;
        D.27959 = entry + D.27958;
        next = *D.27959;
        D.27960 = amodule->blob;
        D.27961 = (sizetype) key;
        p.130 = D.27960 + D.27961;
        p = p.130;
        orig_p = p;
        {
          int ret;

          ret = pthread_mutex_lock (&aot_mutex.mutex);
          if (ret != 0) goto <D.27963>; else goto <D.27964>;
          <D.27963>:
          monoeg_g_log (0B, 16, "Bad call to mono_mutex_lock result %d", ret);
          <D.27964>:
          D.27965 = ret != 0;
          D.27966 = (long int) D.27965;
          D.27967 = __builtin_expect (D.27966, 0);
          if (D.27967 != 0) goto <D.27968>; else goto <D.27969>;
          <D.27968>:
          monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "aot-runtime.c", 3479, "ret == 0");
          <D.27969>:
        }
        D.27970 = amodule->method_ref_to_method;
        if (D.27970 == 0B) goto <D.27971>; else goto <D.27972>;
        <D.27971>:
        D.27973 = monoeg_g_hash_table_new (0B, 0B);
        amodule->method_ref_to_method = D.27973;
        <D.27972>:
        p.131 = p;
        D.27970 = amodule->method_ref_to_method;
        m = monoeg_g_hash_table_lookup (D.27970, p.131);
        {
          int ret;

          ret = pthread_mutex_unlock (&aot_mutex.mutex);
          if (ret != 0) goto <D.27975>; else goto <D.27976>;
          <D.27975>:
          monoeg_g_log (0B, 16, "Bad call to mono_mutex_unlock result %d", ret);
          <D.27976>:
          D.27977 = ret != 0;
          D.27978 = (long int) D.27977;
          D.27979 = __builtin_expect (D.27978, 0);
          if (D.27979 != 0) goto <D.27980>; else goto <D.27981>;
          <D.27980>:
          monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "aot-runtime.c", 3483, "ret == 0");
          <D.27981>:
        }
        if (m == 0B) goto <D.27982>; else goto <D.27983>;
        <D.27982>:
        p.131 = p;
        m = decode_resolve_method_ref_with_target (amodule, method, p.131, &p);
        if (m != 0B) goto <D.27984>; else goto <D.27985>;
        <D.27984>:
        {
          int ret;

          ret = pthread_mutex_lock (&aot_mutex.mutex);
          if (ret != 0) goto <D.27986>; else goto <D.27987>;
          <D.27986>:
          monoeg_g_log (0B, 16, "Bad call to mono_mutex_lock result %d", ret);
          <D.27987>:
          D.27988 = ret != 0;
          D.27989 = (long int) D.27988;
          D.27990 = __builtin_expect (D.27989, 0);
          if (D.27990 != 0) goto <D.27991>; else goto <D.27992>;
          <D.27991>:
          monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "aot-runtime.c", 3487, "ret == 0");
          <D.27992>:
        }
        D.27970 = amodule->method_ref_to_method;
        monoeg_g_hash_table_insert_replace (D.27970, orig_p, m, 0);
        {
          int ret;

          ret = pthread_mutex_unlock (&aot_mutex.mutex);
          if (ret != 0) goto <D.27993>; else goto <D.27994>;
          <D.27993>:
          monoeg_g_log (0B, 16, "Bad call to mono_mutex_unlock result %d", ret);
          <D.27994>:
          D.27995 = ret != 0;
          D.27996 = (long int) D.27995;
          D.27997 = __builtin_expect (D.27996, 0);
          if (D.27997 != 0) goto <D.27998>; else goto <D.27999>;
          <D.27998>:
          monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "aot-runtime.c", 3489, "ret == 0");
          <D.27999>:
        }
        <D.27985>:
        <D.27983>:
        if (m == method) goto <D.28000>; else goto <D.28001>;
        <D.28000>:
        index = value;
        goto <D.24438>;
        <D.28001>:
        if (m != 0B) goto <D.28002>; else goto <D.28003>;
        <D.28002>:
        D.28004 = BIT_FIELD_REF <*method, 8, 256>;
        D.28005 = D.28004 & 124;
        if (D.28005 != 0) goto <D.28006>; else goto <D.28007>;
        <D.28006>:
        D.28004 = BIT_FIELD_REF <*method, 8, 256>;
        D.28005 = D.28004 & 124;
        if (D.28005 == 64) goto <D.28008>; else goto <D.28009>;
        <D.28008>:
        {
          struct MonoMethod * w1;
          struct MonoMethod * w2;

          w1 = mono_marshal_method_from_wrapper (method);
          w2 = mono_marshal_method_from_wrapper (m);
          D.28010 = BIT_FIELD_REF <*w1, 8, 264>;
          D.28011 = D.28010 & 16;
          if (D.28011 != 0) goto <D.28012>; else goto <D.28013>;
          <D.28012>:
          D.28014 = MEM[(struct MonoMethodInflated *)w1].declaring;
          if (D.28014 == w2) goto <D.28015>; else goto <D.28016>;
          <D.28015>:
          index = value;
          goto <D.24438>;
          <D.28016>:
          <D.28013>:
        }
        <D.28009>:
        <D.28007>:
        <D.28003>:
        if (m != 0B) goto <D.28017>; else goto <D.28018>;
        <D.28017>:
        n_extra_decodes.132 = n_extra_decodes;
        n_extra_decodes.133 = n_extra_decodes.132 + 1;
        n_extra_decodes = n_extra_decodes.133;
        <D.28018>:
        if (next != 0) goto <D.28021>; else goto <D.24438>;
        <D.28021>:
        D.28022 = next * entry_size;
        D.28023 = (long unsigned int) D.28022;
        D.28024 = D.28023 * 4;
        entry = table + D.28024;
      }
    finally
      {
        p = {CLOBBER};
      }
  }
  goto <D.24441>;
  <D.24438>:
  D.27947 = index;
  return D.27947;
}


load_method (struct MonoDomain * domain, struct MonoAotModule * amodule, struct MonoImage * image, struct MonoMethod * method, guint32 token, int method_index)
{
  _Bool D.28028;
  <unnamed type> D.28029;
  unsigned int D.28030;
  void * D.28033;
  struct MonoDomain * D.28034;
  unsigned int D.28037;
  unsigned int D.28038;
  int D.28041;
  gint32 * D.28044;
  long unsigned int D.28045;
  long unsigned int D.28046;
  gint32 * D.28047;
  int D.28048;
  int D.28051;
  guint8 * D.28056;
  sizetype D.28057;
  guint8 * D.28058;
  guint32 * D.28059;
  unsigned int D.28060;
  sizetype D.28061;
  guint8 * D.28062;
  unsigned int D.28067;
  unsigned int D.28068;
  int D.28071;
  _Bool D.28072;
  long int D.28073;
  long int D.28074;
  sizetype D.28077;
  _Bool D.28080;
  long int D.28081;
  long int D.28082;
  guint32 * D.28085;
  unsigned int D.28088;
  unsigned int D.28089;
  unsigned int D.28090;
  long unsigned int D.28091;
  long unsigned int D.28092;
  void * D.28093;
  _Bool D.28096;
  long int D.28097;
  long int D.28098;
  int D.28101;
  long unsigned int D.28102;
  long unsigned int D.28103;
  guint32 * D.28104;
  unsigned int D.28105;
  int D.28106;
  unsigned int D.28107;
  unsigned int D.28108;
  int mono_last_aot_method.134;
  int D.28114;
  int D.28117;
  guint8 * p.135;
  int D.28132;
  unsigned int D.28133;
  struct MonoDomain * D.28134;
  long unsigned int D.28143;
  long unsigned int D.28144;
  void * * D.28145;
  guint32 * got_slots.136;
  long unsigned int D.28147;
  guint32 * D.28148;
  unsigned int D.28149;
  long unsigned int D.28150;
  long unsigned int D.28151;
  void * * D.28152;
  void * D.28153;
  void * D.28156;
  <unnamed type> D.28157;
  void * D.28160;
  struct MonoMethod * D.28163;
  struct MonoDebugOptions * D.28166;
  int D.28167;
  struct MonoAssembly * D.28170;
  struct MonoImage * D.28171;
  int D.28172;
  int D.28179;
  sizetype D.28180;
  guint8 * D.28181;
  _Bool D.28184;
  long int D.28185;
  long int D.28186;
  int D.28189;
  long unsigned int D.28190;
  long unsigned int D.28191;
  guint32 * D.28192;
  unsigned int D.28193;
  int D.28194;
  unsigned int D.28195;
  unsigned int D.28196;
  unsigned char D.28199;
  unsigned char D.28200;
  struct GHashTable * D.28203;
  _Bool D.28206;
  long int D.28207;
  long int D.28208;
  <unnamed type> D.28211;
  unsigned int D.28212;
  long int D.28217;
  long int D.28218;
  _Bool D.28221;
  long int D.28222;
  long int D.28223;
  _Bool D.28226;
  _Bool D.28227;
  _Bool D.28228;
  struct MonoGenericContainer * D.28231;
  struct MonoVTable * D.28234;
  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.28028 = method == 0B;
      from_plt = (gboolean) D.28028;
      keep_patches = 1;
      jinfo = 0B;
      D.28029 = mono_profiler_get_events ();
      D.28030 = D.28029 & 4096;
      if (D.28030 != 0) goto <D.28031>; else goto <D.28032>;
      <D.28031>:
      D.28033 = 0B;
      return D.28033;
      <D.28032>:
      D.28034 = mono_get_root_domain ();
      if (D.28034 != domain) goto <D.28035>; else goto <D.28036>;
      <D.28035>:
      D.28037 = amodule->info.opts;
      D.28038 = D.28037 & 512;
      if (D.28038 == 0) goto <D.28039>; else goto <D.28040>;
      <D.28039>:
      D.28033 = 0B;
      return D.28033;
      <D.28040>:
      <D.28036>:
      D.28041 = amodule->out_of_date;
      if (D.28041 != 0) goto <D.28042>; else goto <D.28043>;
      <D.28042>:
      D.28033 = 0B;
      return D.28033;
      <D.28043>:
      D.28044 = amodule->code_offsets;
      D.28045 = (long unsigned int) method_index;
      D.28046 = D.28045 * 4;
      D.28047 = D.28044 + D.28046;
      D.28048 = *D.28047;
      if (D.28048 == -1) goto <D.28049>; else goto <D.28050>;
      <D.28049>:
      D.28051 = mono_trace_is_traced (128, 32);
      if (D.28051 != 0) goto <D.28052>; else goto <D.28053>;
      <D.28052>:
      {
        char * full_name;

        if (method == 0B) goto <D.28054>; else goto <D.28055>;
        <D.28054>:
        method = mono_get_method (image, token, 0B);
        <D.28055>:
        full_name = mono_method_full_name (method, 1);
        mono_trace (128, 32, "AOT NOT FOUND: %s.", full_name);
        monoeg_g_free (full_name);
      }
      <D.28053>:
      D.28033 = 0B;
      return D.28033;
      <D.28050>:
      D.28056 = amodule->code;
      D.28044 = amodule->code_offsets;
      D.28045 = (long unsigned int) method_index;
      D.28046 = D.28045 * 4;
      D.28047 = D.28044 + D.28046;
      D.28048 = *D.28047;
      D.28057 = (sizetype) D.28048;
      code = D.28056 + D.28057;
      D.28058 = amodule->blob;
      D.28059 = amodule->method_info_offsets;
      D.28060 = mono_aot_get_offset (D.28059, method_index);
      D.28061 = (sizetype) D.28060;
      info = D.28058 + D.28061;
      D.28062 = amodule->thumb_end;
      if (D.28062 != 0B) goto <D.28063>; else goto <D.28064>;
      <D.28063>:
      D.28062 = amodule->thumb_end;
      if (D.28062 > code) goto <D.28065>; else goto <D.28066>;
      <D.28065>:
      D.28067 = amodule->info.flags;
      D.28068 = D.28067 & 8;
      if (D.28068 == 0) goto <D.28069>; else goto <D.28070>;
      <D.28069>:
      D.28044 = amodule->code_offsets;
      D.28045 = (long unsigned int) method_index;
      D.28046 = D.28045 * 4;
      D.28047 = D.28044 + D.28046;
      D.28048 = *D.28047;
      D.28071 = D.28048 & 1;
      D.28072 = D.28071 != 0;
      D.28073 = (long int) D.28072;
      D.28074 = __builtin_expect (D.28073, 0);
      if (D.28074 != 0) goto <D.28075>; else goto <D.28076>;
      <D.28075>:
      monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "aot-runtime.c", 3299, "(amodule->code_offsets [method_index] & 0x1) == 0");
      <D.28076>:
      D.28056 = amodule->code;
      D.28044 = amodule->code_offsets;
      D.28045 = (long unsigned int) method_index;
      D.28046 = D.28045 * 4;
      D.28047 = D.28044 + D.28046;
      D.28048 = *D.28047;
      D.28057 = (sizetype) D.28048;
      D.28077 = D.28057 + 1;
      code = D.28056 + D.28077;
      <D.28070>:
      <D.28066>:
      <D.28064>:
      {
        int ret;

        ret = pthread_mutex_lock (&aot_mutex.mutex);
        if (ret != 0) goto <D.28078>; else goto <D.28079>;
        <D.28078>:
        monoeg_g_log (0B, 16, "Bad call to mono_mutex_lock result %d", ret);
        <D.28079>:
        D.28080 = ret != 0;
        D.28081 = (long int) D.28080;
        D.28082 = __builtin_expect (D.28081, 0);
        if (D.28082 != 0) goto <D.28083>; else goto <D.28084>;
        <D.28083>:
        monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "aot-runtime.c", 3303, "ret == 0");
        <D.28084>:
      }
      D.28085 = amodule->methods_loaded;
      if (D.28085 == 0B) goto <D.28086>; else goto <D.28087>;
      <D.28086>:
      D.28088 = amodule->info.nmethods;
      D.28089 = D.28088 / 32;
      D.28090 = D.28089 + 1;
      D.28091 = (long unsigned int) D.28090;
      D.28092 = D.28091 * 4;
      D.28093 = monoeg_malloc0 (D.28092);
      amodule->methods_loaded = D.28093;
      <D.28087>:
      {
        int ret;

        ret = pthread_mutex_unlock (&aot_mutex.mutex);
        if (ret != 0) goto <D.28094>; else goto <D.28095>;
        <D.28094>:
        monoeg_g_log (0B, 16, "Bad call to mono_mutex_unlock result %d", ret);
        <D.28095>:
        D.28096 = ret != 0;
        D.28097 = (long int) D.28096;
        D.28098 = __builtin_expect (D.28097, 0);
        if (D.28098 != 0) goto <D.28099>; else goto <D.28100>;
        <D.28099>:
        monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "aot-runtime.c", 3306, "ret == 0");
        <D.28100>:
      }
      D.28085 = amodule->methods_loaded;
      D.28101 = method_index / 32;
      D.28102 = (long unsigned int) D.28101;
      D.28103 = D.28102 * 4;
      D.28104 = D.28085 + D.28103;
      D.28105 = *D.28104;
      D.28106 = method_index % 32;
      D.28107 = D.28105 >> D.28106;
      D.28108 = D.28107 & 1;
      if (D.28108 != 0) goto <D.28109>; else goto <D.28110>;
      <D.28109>:
      D.28033 = code;
      return D.28033;
      <D.28110>:
      mono_last_aot_method.134 = mono_last_aot_method;
      if (mono_last_aot_method.134 != -1) goto <D.28112>; else goto <D.28113>;
      <D.28112>:
      D.28114 = mono_jit_stats.methods_aot;
      mono_last_aot_method.134 = mono_last_aot_method;
      if (D.28114 >= mono_last_aot_method.134) goto <D.28115>; else goto <D.28116>;
      <D.28115>:
      D.28033 = 0B;
      return D.28033;
      <D.28116>:
      D.28114 = mono_jit_stats.methods_aot;
      mono_last_aot_method.134 = mono_last_aot_method;
      D.28117 = mono_last_aot_method.134 + -1;
      if (D.28114 == D.28117) goto <D.28118>; else goto <D.28119>;
      <D.28118>:
      if (method == 0B) goto <D.28120>; else goto <D.28121>;
      <D.28120>:
      method = mono_get_method (image, token, 0B);
      <D.28121>:
      if (method != 0B) goto <D.28122>; else goto <D.28123>;
      <D.28122>:
      {
        char * name;

        name = mono_method_full_name (method, 1);
        printf ("LAST AOT METHOD: %s.\n", name);
        monoeg_g_free (name);
      }
      goto <D.28124>;
      <D.28123>:
      printf ("LAST AOT METHOD: %p %d\n", code, method_index);
      <D.28124>:
      <D.28119>:
      <D.28113>:
      p = info;
      if (method != 0B) goto <D.28125>; else goto <D.28126>;
      <D.28125>:
      klass = method->klass;
      p.135 = p;
      decode_klass_ref (amodule, p.135, &p);
      goto <D.28128>;
      <D.28126>:
      p.135 = p;
      klass = decode_klass_ref (amodule, p.135, &p);
      <D.28128>:
      D.28037 = amodule->info.opts;
      D.28038 = D.28037 & 512;
      if (D.28038 != 0) goto <D.28129>; else goto <D.28130>;
      <D.28129>:
      p.135 = p;
      used_strings = decode_value (p.135, &p);
      goto <D.28131>;
      <D.28130>:
      used_strings = 0;
      <D.28131>:
      i = 0;
      goto <D.24404>;
      <D.24403>:
      {
        guint token;

        p.135 = p;
        D.28132 = decode_value (p.135, &p);
        token = (guint) D.28132;
        D.28133 = token & 16777215;
        D.28134 = mono_get_root_domain ();
        mono_ldstr (D.28134, image, D.28133);
      }
      i = i + 1;
      <D.24404>:
      if (i < used_strings) goto <D.24403>; else goto <D.24405>;
      <D.24405>:
      D.28037 = amodule->info.opts;
      D.28038 = D.28037 & 512;
      if (D.28038 != 0) goto <D.28135>; else goto <D.28136>;
      <D.28135>:
      keep_patches = 0;
      <D.28136>:
      p.135 = p;
      n_patches = decode_value (p.135, &p);
      keep_patches = 0;
      if (n_patches != 0) goto <D.28137>; else goto <D.28138>;
      <D.28137>:
      {
        struct MonoJumpInfo * patches;
        guint32 * got_slots;

        try
          {
            if (keep_patches != 0) goto <D.28139>; else goto <D.28140>;
            <D.28139>:
            mp = domain->mp;
            goto <D.28141>;
            <D.28140>:
            mp = mono_mempool_new ();
            <D.28141>:
            p.135 = p;
            patches = load_patch_info (amodule, mp, n_patches, &got_slots, p.135, &p);
            if (patches == 0B) goto cleanup; else goto <D.28142>;
            <D.28142>:
            pindex = 0;
            goto <D.24411>;
            <D.24410>:
            {
              struct MonoJumpInfo * ji;

              D.28143 = (long unsigned int) pindex;
              D.28144 = D.28143 * 40;
              ji = patches + D.28144;
              D.28145 = amodule->got;
              got_slots.136 = got_slots;
              D.28143 = (long unsigned int) pindex;
              D.28147 = D.28143 * 4;
              D.28148 = got_slots.136 + D.28147;
              D.28149 = *D.28148;
              D.28150 = (long unsigned int) D.28149;
              D.28151 = D.28150 * 8;
              D.28152 = D.28145 + D.28151;
              D.28153 = *D.28152;
              if (D.28153 == 0B) goto <D.28154>; else goto <D.28155>;
              <D.28154>:
              D.28145 = amodule->got;
              got_slots.136 = got_slots;
              D.28143 = (long unsigned int) pindex;
              D.28147 = D.28143 * 4;
              D.28148 = got_slots.136 + D.28147;
              D.28149 = *D.28148;
              D.28150 = (long unsigned int) D.28149;
              D.28151 = D.28150 * 8;
              D.28152 = D.28145 + D.28151;
              D.28156 = mono_resolve_patch_target (method, domain, code, ji, 1);
              *D.28152 = D.28156;
              D.28157 = ji->type;
              if (D.28157 == 4) goto <D.28158>; else goto <D.28159>;
              <D.28158>:
              D.28145 = amodule->got;
              got_slots.136 = got_slots;
              D.28143 = (long unsigned int) pindex;
              D.28147 = D.28143 * 4;
              D.28148 = got_slots.136 + D.28147;
              D.28149 = *D.28148;
              D.28150 = (long unsigned int) D.28149;
              D.28151 = D.28150 * 8;
              D.28152 = D.28145 + D.28151;
              D.28145 = amodule->got;
              got_slots.136 = got_slots;
              D.28143 = (long unsigned int) pindex;
              D.28147 = D.28143 * 4;
              D.28148 = got_slots.136 + D.28147;
              D.28149 = *D.28148;
              D.28150 = (long unsigned int) D.28149;
              D.28151 = D.28150 * 8;
              D.28152 = D.28145 + D.28151;
              D.28153 = *D.28152;
              D.28160 = mono_create_ftnptr (domain, D.28153);
              *D.28152 = D.28160;
              <D.28159>:
              D.28157 = ji->type;
              if (D.28157 == 4) goto <D.28161>; else goto <D.28162>;
              <D.28161>:
              D.28145 = amodule->got;
              got_slots.136 = got_slots;
              D.28143 = (long unsigned int) pindex;
              D.28147 = D.28143 * 4;
              D.28148 = got_slots.136 + D.28147;
              D.28149 = *D.28148;
              D.28150 = (long unsigned int) D.28149;
              D.28151 = D.28150 * 8;
              D.28152 = D.28145 + D.28151;
              D.28163 = ji->data.method;
              register_jump_target_got_slot (domain, D.28163, D.28152);
              <D.28162>:
              <D.28155>:
              ji->type = 51;
            }
            pindex = pindex + 1;
            <D.24411>:
            if (pindex < n_patches) goto <D.24410>; else goto <D.24412>;
            <D.24412>:
            got_slots.136 = got_slots;
            monoeg_g_free (got_slots.136);
            if (keep_patches == 0) goto <D.28164>; else goto <D.28165>;
            <D.28164>:
            mono_mempool_destroy (mp);
            <D.28165>:
          }
        finally
          {
            got_slots = {CLOBBER};
          }
      }
      <D.28138>:
      D.28166 = mini_get_debug_options ();
      D.28167 = D.28166->load_aot_jit_info_eagerly;
      if (D.28167 != 0) goto <D.28168>; else goto <D.28169>;
      <D.28168>:
      D.28170 = amodule->assembly;
      D.28171 = D.28170->image;
      jinfo = mono_aot_find_jit_info (domain, D.28171, code);
      <D.28169>:
      D.28172 = mono_trace_is_traced (128, 32);
      if (D.28172 != 0) goto <D.28173>; else goto <D.28174>;
      <D.28173>:
      {
        char * full_name;

        if (method == 0B) goto <D.28175>; else goto <D.28176>;
        <D.28175>:
        method = mono_get_method (image, token, 0B);
        <D.28176>:
        full_name = mono_method_full_name (method, 1);
        if (jinfo == 0B) goto <D.28177>; else goto <D.28178>;
        <D.28177>:
        D.28170 = amodule->assembly;
        D.28171 = D.28170->image;
        jinfo = mono_aot_find_jit_info (domain, D.28171, code);
        <D.28178>:
        D.28179 = jinfo->code_size;
        D.28180 = (sizetype) D.28179;
        D.28181 = code + D.28180;
        mono_trace (128, 32, "AOT FOUND method %s [%p - %p %p]", full_name, code, D.28181, info);
        monoeg_g_free (full_name);
      }
      <D.28174>:
      {
        int ret;

        ret = pthread_mutex_lock (&aot_mutex.mutex);
        if (ret != 0) goto <D.28182>; else goto <D.28183>;
        <D.28182>:
        monoeg_g_log (0B, 16, "Bad call to mono_mutex_lock result %d", ret);
        <D.28183>:
        D.28184 = ret != 0;
        D.28185 = (long int) D.28184;
        D.28186 = __builtin_expect (D.28185, 0);
        if (D.28186 != 0) goto <D.28187>; else goto <D.28188>;
        <D.28187>:
        monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "aot-runtime.c", 3403, "ret == 0");
        <D.28188>:
      }
      InterlockedIncrement (&mono_jit_stats.methods_aot);
      D.28085 = amodule->methods_loaded;
      D.28189 = method_index / 32;
      D.28190 = (long unsigned int) D.28189;
      D.28191 = D.28190 * 4;
      D.28192 = D.28085 + D.28191;
      D.28085 = amodule->methods_loaded;
      D.28190 = (long unsigned int) D.28189;
      D.28191 = D.28190 * 4;
      D.28192 = D.28085 + D.28191;
      D.28193 = *D.28192;
      D.28106 = method_index % 32;
      D.28194 = 1 << D.28106;
      D.28195 = (unsigned int) D.28194;
      D.28196 = D.28193 | D.28195;
      *D.28192 = D.28196;
      init_plt (amodule);
      if (method != 0B) goto <D.28197>; else goto <D.28198>;
      <D.28197>:
      D.28199 = BIT_FIELD_REF <*method, 8, 256>;
      D.28200 = D.28199 & 124;
      if (D.28200 != 0) goto <D.28201>; else goto <D.28202>;
      <D.28201>:
      D.28203 = amodule->method_to_code;
      monoeg_g_hash_table_insert_replace (D.28203, method, code, 0);
      <D.28202>:
      <D.28198>:
      {
        int ret;

        ret = pthread_mutex_unlock (&aot_mutex.mutex);
        if (ret != 0) goto <D.28204>; else goto <D.28205>;
        <D.28204>:
        monoeg_g_log (0B, 16, "Bad call to mono_mutex_unlock result %d", ret);
        <D.28205>:
        D.28206 = ret != 0;
        D.28207 = (long int) D.28206;
        D.28208 = __builtin_expect (D.28207, 0);
        if (D.28208 != 0) goto <D.28209>; else goto <D.28210>;
        <D.28209>:
        monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "aot-runtime.c", 3414, "ret == 0");
        <D.28210>:
      }
      D.28211 = mono_profiler_get_events ();
      D.28212 = D.28211 & 16;
      if (D.28212 != 0) goto <D.28213>; else goto <D.28214>;
      <D.28213>:
      {
        struct MonoJitInfo * jinfo;

        if (method == 0B) goto <D.28215>; else goto <D.28216>;
        <D.28215>:
        method = mono_get_method (image, token, 0B);
        D.28028 = method == 0B;
        D.28217 = (long int) D.28028;
        D.28218 = __builtin_expect (D.28217, 0);
        if (D.28218 != 0) goto <D.28219>; else goto <D.28220>;
        <D.28219>:
        monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "aot-runtime.c", 3421, "method");
        <D.28220>:
        <D.28216>:
        mono_profiler_method_jit (method);
        jinfo = mono_jit_info_table_find (domain, code);
        D.28221 = jinfo == 0B;
        D.28222 = (long int) D.28221;
        D.28223 = __builtin_expect (D.28222, 0);
        if (D.28223 != 0) goto <D.28224>; else goto <D.28225>;
        <D.28224>:
        monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "aot-runtime.c", 3425, "jinfo");
        <D.28225>:
        mono_profiler_method_end_jit (method, jinfo, 0);
      }
      <D.28214>:
      D.28226 = from_plt != 0;
      D.28227 = klass != 0B;
      D.28228 = D.28226 & D.28227;
      if (D.28228 != 0) goto <D.28229>; else goto <D.28230>;
      <D.28229>:
      D.28231 = klass->generic_container;
      if (D.28231 == 0B) goto <D.28232>; else goto <D.28233>;
      <D.28232>:
      D.28234 = mono_class_vtable (domain, klass);
      mono_runtime_class_init (D.28234);
      <D.28233>:
      <D.28230>:
      D.28033 = code;
      return D.28033;
      cleanup:
      D.28037 = amodule->info.opts;
      D.28038 = D.28037 & 512;
      if (D.28038 != 0) goto <D.28235>; else goto <D.28236>;
      <D.28235>:
      mono_mempool_destroy (mp);
      <D.28236>:
      if (jinfo != 0B) goto <D.28237>; else goto <D.28238>;
      <D.28237>:
      monoeg_g_free (jinfo);
      <D.28238>:
      D.28033 = 0B;
      return D.28033;
    }
  finally
    {
      p = {CLOBBER};
    }
}


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

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


load_patch_info (struct MonoAotModule * aot_module, struct MonoMemPool * mp, int n_patches, guint32 * * got_slots, guint8 * buf, guint8 * * endbuf)
{
  long unsigned int D.28245;
  unsigned int D.28246;
  unsigned int D.28247;
  long unsigned int D.28248;
  void * D.28249;
  long unsigned int D.28250;
  long unsigned int D.28251;
  guint8 * p.137;
  int D.28253;
  void * * D.28254;
  long unsigned int D.28255;
  long unsigned int D.28256;
  void * * D.28257;
  void * D.28258;
  guint8 * D.28262;
  int got_offset.138;
  guint32 * D.28264;
  unsigned int D.28265;
  sizetype D.28266;
  guint8 * shared_p.139;
  guint8 * shared_p.140;
  int D.28269;
  <unnamed type> D.28270;
  guint32 * D.28272;
  long unsigned int D.28273;
  guint32 * D.28274;
  struct MonoJumpInfo * D.28275;
  struct MonoJumpInfo * patches;
  int pindex;
  guint8 * p;
  void cleanup = <<< error >>>;

  try
    {
      p = buf;
      D.28245 = (long unsigned int) n_patches;
      D.28246 = (unsigned int) D.28245;
      D.28247 = D.28246 * 40;
      patches = mono_mempool_alloc0 (mp, D.28247);
      D.28245 = (long unsigned int) n_patches;
      D.28248 = D.28245 * 4;
      D.28249 = monoeg_malloc (D.28248);
      *got_slots = D.28249;
      pindex = 0;
      goto <D.24367>;
      <D.24366>:
      {
        struct MonoJumpInfo * ji;
        guint8 * shared_p;
        gboolean res;
        guint32 got_offset;

        try
          {
            D.28250 = (long unsigned int) pindex;
            D.28251 = D.28250 * 40;
            ji = patches + D.28251;
            p.137 = p;
            D.28253 = decode_value (p.137, &p);
            got_offset = (guint32) D.28253;
            D.28254 = aot_module->got;
            D.28255 = (long unsigned int) got_offset;
            D.28256 = D.28255 * 8;
            D.28257 = D.28254 + D.28256;
            D.28258 = *D.28257;
            if (D.28258 != 0B) goto <D.28259>; else goto <D.28260>;
            <D.28259>:
            goto <D.28261>;
            <D.28260>:
            D.28262 = aot_module->blob;
            got_offset.138 = (int) got_offset;
            D.28264 = aot_module->got_info_offsets;
            D.28265 = mono_aot_get_offset (D.28264, got_offset.138);
            D.28266 = (sizetype) D.28265;
            shared_p.139 = D.28262 + D.28266;
            shared_p = shared_p.139;
            shared_p.140 = shared_p;
            D.28269 = decode_value (shared_p.140, &shared_p);
            D.28270 = (<unnamed type>) D.28269;
            ji->type = D.28270;
            shared_p.140 = shared_p;
            res = decode_patch (aot_module, mp, ji, shared_p.140, &shared_p);
            if (res == 0) goto cleanup; else goto <D.28271>;
            <D.28271>:
            <D.28261>:
            D.28272 = *got_slots;
            D.28250 = (long unsigned int) pindex;
            D.28273 = D.28250 * 4;
            D.28274 = D.28272 + D.28273;
            *D.28274 = got_offset;
          }
        finally
          {
            shared_p = {CLOBBER};
          }
      }
      pindex = pindex + 1;
      <D.24367>:
      if (pindex < n_patches) goto <D.24366>; else goto <D.24368>;
      <D.24368>:
      p.137 = p;
      *endbuf = p.137;
      D.28275 = patches;
      return D.28275;
      cleanup:
      D.28272 = *got_slots;
      monoeg_g_free (D.28272);
      *got_slots = 0B;
      D.28275 = 0B;
      return D.28275;
    }
  finally
    {
      p = {CLOBBER};
    }
}


decode_patch (struct MonoAotModule * aot_module, struct MonoMemPool * mp, struct MonoJumpInfo * ji, guint8 * buf, guint8 * * endbuf)
{
  <unnamed type> D.28280;
  guint8 * p.141;
  struct MonoMethod * D.28285;
  int mono_aot_only.142;
  int D.28289;
  unsigned int D.28292;
  unsigned int D.28293;
  struct MonoImage * D.28295;
  void * D.28296;
  struct MonoDomain * D.28297;
  void * D.28298;
  struct MonoMethod * D.28302;
  struct MonoMethod * D.28303;
  _Bool D.28304;
  long int D.28305;
  long int D.28306;
  struct MonoClass * D.28309;
  int D.28310;
  unsigned int D.28311;
  sizetype D.28312;
  guint8 * p.143;
  struct MonoMethod * D.28314;
  struct MonoClass * D.28316;
  struct MonoClass * D.28317;
  struct MonoClass * D.28319;
  int D.28321;
  struct MonoImage * D.28322;
  struct MonoImage * D.28323;
  struct MonoClassField * D.28325;
  struct MonoClassField * D.28326;
  void * D.28328;
  struct MonoJumpInfoBBTable * D.28329;
  int D.28330;
  int D.28331;
  long unsigned int D.28332;
  unsigned int D.28333;
  unsigned int D.28334;
  struct MonoDomain * D.28335;
  long unsigned int D.28336;
  long unsigned int D.28337;
  void * * D.28338;
  int D.28339;
  long int D.28340;
  void * D.28341;
  struct MonoDomain * D.28342;
  void * D.28343;
  int D.28344;
  unsigned int val.144;
  const void * D.28346;
  guint32 * val.145;
  float D.28348;
  struct MonoDomain * D.28349;
  void * D.28350;
  int D.28351;
  unsigned int D.28352;
  int D.28353;
  unsigned int D.28354;
  unsigned int D.28355;
  long unsigned int D.28356;
  long unsigned int D.28357;
  unsigned int D.28358;
  long unsigned int D.28359;
  long unsigned int v.146;
  guint64 * v.147;
  double D.28362;
  int D.28363;
  int D.28365;
  int D.28366;
  unsigned int D.28367;
  struct MonoJumpInfoToken * D.28368;
  int D.28369;
  int D.28371;
  unsigned int D.28372;
  struct MonoJumpInfoToken * D.28373;
  struct MonoJumpInfoToken * D.28374;
  int D.28375;
  int D.28376;
  struct MonoGenericContext * D.28379;
  struct MonoClass * D.28381;
  const char * D.28383;
  int D.28384;
  long int D.28385;
  int D.28386;
  int D.28387;
  guint8 * D.28388;
  sizetype D.28389;
  guint8 * p2.148;
  guint8 * p2.149;
  struct MonoMethod * D.28392;
  unsigned int D.28393;
  _Bool D.28394;
  int D.28395;
  unsigned int D.28396;
  unsigned int D.28397;
  void * D.28398;
  struct MonoJumpInfo * D.28399;
  unsigned int D.28400;
  unsigned int D.28401;
  struct MonoMethod * D.28403;
  int D.28404;
  struct MonoMethodSignature * D.28405;
  int D.28406;
  long int D.28407;
  const void * D.28408;
  struct MonoMethodSignature * D.28409;
  struct MonoMethodSignature * D.28410;
  _Bool D.28411;
  long int D.28412;
  long int D.28413;
  struct MonoMethod * D.28416;
  struct MonoMethod * D.28417;
  _Bool D.28418;
  long int D.28419;
  long int D.28420;
  struct MonoMethod * D.28423;
  struct MonoMethod * D.28424;
  _Bool D.28425;
  long int D.28426;
  long int D.28427;
  struct GPtrArray * D.28430;
  int D.28431;
  <unnamed type> D.28432;
  <unnamed type> D.28433;
  <unnamed type> D.28434;
  struct MonoType * D.28436;
  struct MonoClassField * D.28437;
  void * D.28438;
  struct GPtrArray * D.28440;
  gboolean D.28441;
  guint8 * p;
  void * * table;
  struct MonoImage * image;
  int i;
  void cleanup = <<< error >>>;

  try
    {
      p = buf;
      D.28280 = ji->type;
      switch (D.28280) <default: <D.24349>, case 3: <D.24277>, case 4: <D.24278>, case 5: <D.24315>, case 6: <D.24289>, case 7: <D.24286>, case 8: <D.24299>, case 10: <D.24314>, case 11: <D.24291>, case 12: <D.24296>, case 13: <D.24297>, case 14: <D.24290>, case 15: <D.24294>, case 16: <D.24298>, case 17: <D.24308>, case 18: <D.24311>, case 19: <D.24312>, case 20: <D.24303>, case 21: <D.24305>, case 23: <D.24292>, case 24: <D.24293>, case 28: <D.24310>, case 29: <D.24309>, case 30: <D.24295>, case 31: <D.24279>, case 32: <D.24287>, case 33: <D.24316>, case 34: <D.24280>, case 35: <D.24323>, case 36: <D.24317>, case 37: <D.24318>, case 38: <D.24319>, case 40: <D.24329>, case 41: <D.24330>, case 42: <D.24320>, case 43: <D.24321>, case 44: <D.24332>, case 45: <D.24334>, case 46: <D.24336>, case 47: <D.24322>, case 48: <D.24333>, case 50: <D.24281>>
      <D.24277>:
      <D.24278>:
      <D.24279>:
      <D.24280>:
      <D.24281>:
      {
        struct MethodRef ref;
        gboolean res;

        try
          {
            p.141 = p;
            res = decode_method_ref (aot_module, &ref, p.141, &p);
            if (res == 0) goto cleanup; else goto <D.28282>;
            <D.28282>:
            D.28285 = ref.method;
            if (D.28285 == 0B) goto <D.28286>; else goto <D.28283>;
            <D.28286>:
            mono_aot_only.142 = mono_aot_only;
            if (mono_aot_only.142 == 0) goto <D.28288>; else goto <D.28283>;
            <D.28288>:
            D.28289 = ref.no_aot_trampoline;
            if (D.28289 == 0) goto <D.28290>; else goto <D.28283>;
            <D.28290>:
            D.28280 = ji->type;
            if (D.28280 == 3) goto <D.28291>; else goto <D.28283>;
            <D.28291>:
            D.28292 = ref.token;
            D.28293 = D.28292 >> 24;
            if (D.28293 == 6) goto <D.28294>; else goto <D.28283>;
            <D.28294>:
            D.28292 = ref.token;
            D.28295 = ref.image;
            D.28296 = mono_create_jit_trampoline_from_token (D.28295, D.28292);
            D.28297 = mono_domain_get ();
            D.28298 = mono_create_ftnptr (D.28297, D.28296);
            ji->data.target = D.28298;
            ji->type = 1;
            goto <D.28284>;
            <D.28283>:
            D.28285 = ref.method;
            if (D.28285 != 0B) goto <D.28299>; else goto <D.28300>;
            <D.28299>:
            D.28285 = ref.method;
            ji->data.method = D.28285;
            goto <D.28301>;
            <D.28300>:
            D.28292 = ref.token;
            D.28295 = ref.image;
            D.28302 = mono_get_method (D.28295, D.28292, 0B);
            ji->data.method = D.28302;
            <D.28301>:
            D.28303 = ji->data.method;
            D.28304 = D.28303 == 0B;
            D.28305 = (long int) D.28304;
            D.28306 = __builtin_expect (D.28305, 0);
            if (D.28306 != 0) goto <D.28307>; else goto <D.28308>;
            <D.28307>:
            monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "aot-runtime.c", 2969, "ji->data.method");
            <D.28308>:
            D.28303 = ji->data.method;
            D.28309 = D.28303->klass;
            mono_class_init (D.28309);
            <D.28284>:
            goto <D.24285>;
          }
        finally
          {
            ref = {CLOBBER};
          }
      }
      <D.24286>:
      <D.24287>:
      {
        guint32 len;

        p.141 = p;
        D.28310 = decode_value (p.141, &p);
        len = (guint32) D.28310;
        p.141 = p;
        ji->data.name = p.141;
        p.141 = p;
        D.28311 = len + 1;
        D.28312 = (sizetype) D.28311;
        p.143 = p.141 + D.28312;
        p = p.143;
        goto <D.24285>;
      }
      <D.24289>:
      p.141 = p;
      D.28314 = decode_resolve_method_ref (aot_module, p.141, &p);
      ji->data.method = D.28314;
      D.28303 = ji->data.method;
      if (D.28303 == 0B) goto cleanup; else goto <D.28315>;
      <D.28315>:
      goto <D.24285>;
      <D.24290>:
      <D.24291>:
      <D.24292>:
      <D.24293>:
      p.141 = p;
      D.28316 = decode_klass_ref (aot_module, p.141, &p);
      ji->data.klass = D.28316;
      D.28317 = ji->data.klass;
      if (D.28317 == 0B) goto cleanup; else goto <D.28318>;
      <D.28318>:
      goto <D.24285>;
      <D.24294>:
      <D.24295>:
      p.141 = p;
      D.28319 = decode_klass_ref (aot_module, p.141, &p);
      ji->data.klass = D.28319;
      D.28317 = ji->data.klass;
      if (D.28317 == 0B) goto cleanup; else goto <D.28320>;
      <D.28320>:
      goto <D.24285>;
      <D.24296>:
      p.141 = p;
      D.28321 = decode_value (p.141, &p);
      D.28322 = load_image (aot_module, D.28321, 1);
      ji->data.image = D.28322;
      D.28323 = ji->data.image;
      if (D.28323 == 0B) goto cleanup; else goto <D.28324>;
      <D.28324>:
      goto <D.24285>;
      <D.24297>:
      <D.24298>:
      p.141 = p;
      D.28325 = decode_field_info (aot_module, p.141, &p);
      ji->data.field = D.28325;
      D.28326 = ji->data.field;
      if (D.28326 == 0B) goto cleanup; else goto <D.28327>;
      <D.28327>:
      goto <D.24285>;
      <D.24299>:
      D.28328 = mono_mempool_alloc0 (mp, 16);
      ji->data.table = D.28328;
      D.28329 = ji->data.table;
      p.141 = p;
      D.28330 = decode_value (p.141, &p);
      D.28329->table_size = D.28330;
      D.28329 = ji->data.table;
      D.28331 = D.28329->table_size;
      D.28332 = (long unsigned int) D.28331;
      D.28333 = (unsigned int) D.28332;
      D.28334 = D.28333 * 8;
      D.28335 = mono_domain_get ();
      table = mono_domain_alloc (D.28335, D.28334);
      D.28329 = ji->data.table;
      D.28329->table = table;
      i = 0;
      goto <D.24301>;
      <D.24300>:
      D.28336 = (long unsigned int) i;
      D.28337 = D.28336 * 8;
      D.28338 = table + D.28337;
      p.141 = p;
      D.28339 = decode_value (p.141, &p);
      D.28340 = (long int) D.28339;
      D.28341 = (void *) D.28340;
      *D.28338 = D.28341;
      i = i + 1;
      <D.24301>:
      D.28329 = ji->data.table;
      D.28331 = D.28329->table_size;
      if (D.28331 > i) goto <D.24300>; else goto <D.24302>;
      <D.24302>:
      goto <D.24285>;
      <D.24303>:
      {
        guint32 val;

        try
          {
            D.28342 = mono_domain_get ();
            D.28343 = mono_domain_alloc0 (D.28342, 4);
            ji->data.target = D.28343;
            p.141 = p;
            D.28344 = decode_value (p.141, &p);
            val.144 = (unsigned int) D.28344;
            val = val.144;
            D.28346 = ji->data.target;
            val.145 = &val;
            D.28348 = MEM[(float *)val.145];
            MEM[(float *)D.28346] = D.28348;
            goto <D.24285>;
          }
        finally
          {
            val = {CLOBBER};
          }
      }
      <D.24305>:
      {
        guint32 val[2];
        guint64 v;

        try
          {
            D.28349 = mono_domain_get ();
            D.28350 = mono_domain_alloc0 (D.28349, 8);
            ji->data.target = D.28350;
            p.141 = p;
            D.28351 = decode_value (p.141, &p);
            D.28352 = (unsigned int) D.28351;
            val[0] = D.28352;
            p.141 = p;
            D.28353 = decode_value (p.141, &p);
            D.28354 = (unsigned int) D.28353;
            val[1] = D.28354;
            D.28355 = val[1];
            D.28356 = (long unsigned int) D.28355;
            D.28357 = D.28356 << 32;
            D.28358 = val[0];
            D.28359 = (long unsigned int) D.28358;
            v.146 = D.28357 | D.28359;
            v = v.146;
            D.28346 = ji->data.target;
            v.147 = &v;
            D.28362 = MEM[(double *)v.147];
            MEM[(double *)D.28346] = D.28362;
            goto <D.24285>;
          }
        finally
          {
            val = {CLOBBER};
            v = {CLOBBER};
          }
      }
      <D.24308>:
      p.141 = p;
      D.28363 = decode_value (p.141, &p);
      image = load_image (aot_module, D.28363, 1);
      if (image == 0B) goto cleanup; else goto <D.28364>;
      <D.28364>:
      p.141 = p;
      D.28365 = decode_value (p.141, &p);
      D.28366 = D.28365 + 1879048192;
      D.28367 = (unsigned int) D.28366;
      D.28368 = mono_jump_info_token_new (mp, image, D.28367);
      ji->data.token = D.28368;
      goto <D.24285>;
      <D.24309>:
      <D.24310>:
      <D.24311>:
      <D.24312>:
      p.141 = p;
      D.28369 = decode_value (p.141, &p);
      image = load_image (aot_module, D.28369, 1);
      if (image == 0B) goto cleanup; else goto <D.28370>;
      <D.28370>:
      p.141 = p;
      D.28371 = decode_value (p.141, &p);
      D.28372 = (unsigned int) D.28371;
      D.28373 = mono_jump_info_token_new (mp, image, D.28372);
      ji->data.token = D.28373;
      D.28374 = ji->data.token;
      p.141 = p;
      D.28375 = decode_value (p.141, &p);
      D.28374->has_context = D.28375;
      D.28374 = ji->data.token;
      D.28376 = D.28374->has_context;
      if (D.28376 != 0) goto <D.28377>; else goto <D.28378>;
      <D.28377>:
      {
        gboolean res;

        p.141 = p;
        D.28374 = ji->data.token;
        D.28379 = &D.28374->context;
        res = decode_generic_context (aot_module, D.28379, p.141, &p);
        if (res == 0) goto cleanup; else goto <D.28380>;
        <D.28380>:
      }
      <D.28378>:
      goto <D.24285>;
      <D.24314>:
      p.141 = p;
      D.28381 = decode_klass_ref (aot_module, p.141, &p);
      ji->data.klass = D.28381;
      D.28317 = ji->data.klass;
      if (D.28317 == 0B) goto cleanup; else goto <D.28382>;
      <D.28382>:
      D.28317 = ji->data.klass;
      D.28383 = D.28317->name;
      ji->data.name = D.28383;
      goto <D.24285>;
      <D.24315>:
      p.141 = p;
      D.28384 = decode_value (p.141, &p);
      D.28385 = (long int) D.28384;
      ji->data.offset = D.28385;
      goto <D.24285>;
      <D.24316>:
      <D.24317>:
      <D.24318>:
      <D.24319>:
      <D.24320>:
      <D.24321>:
      <D.24322>:
      goto <D.24285>;
      <D.24323>:
      {
        gboolean res;
        struct MonoJumpInfoRgctxEntry * entry;
        guint32 offset;
        guint32 val;
        guint8 * p2;

        try
          {
            p.141 = p;
            D.28386 = decode_value (p.141, &p);
            offset = (guint32) D.28386;
            p.141 = p;
            D.28387 = decode_value (p.141, &p);
            val = (guint32) D.28387;
            entry = mono_mempool_alloc0 (mp, 32);
            D.28388 = aot_module->blob;
            D.28389 = (sizetype) offset;
            p2.148 = D.28388 + D.28389;
            p2 = p2.148;
            p2.149 = p2;
            D.28392 = decode_resolve_method_ref (aot_module, p2.149, &p2);
            entry->method = D.28392;
            D.28393 = val & 1;
            D.28394 = D.28393 != 0;
            D.28395 = (int) D.28394;
            entry->in_mrgctx = D.28395;
            D.28396 = val >> 1;
            D.28397 = D.28396 & 255;
            entry->info_type = D.28397;
            D.28398 = mono_mempool_alloc0 (mp, 40);
            entry->data = D.28398;
            D.28399 = entry->data;
            D.28400 = val >> 9;
            D.28401 = D.28400 & 255;
            D.28399->type = D.28401;
            p.141 = p;
            D.28399 = entry->data;
            res = decode_patch (aot_module, mp, D.28399, p.141, &p);
            if (res == 0) goto cleanup; else goto <D.28402>;
            <D.28402>:
            ji->data.rgctx_entry = entry;
            goto <D.24285>;
          }
        finally
          {
            p2 = {CLOBBER};
          }
      }
      <D.24329>:
      goto <D.24285>;
      <D.24330>:
      {
        struct MonoJumpInfoImtTramp * imt_tramp;

        imt_tramp = mono_mempool_alloc0 (mp, 16);
        p.141 = p;
        D.28403 = decode_resolve_method_ref (aot_module, p.141, &p);
        imt_tramp->method = D.28403;
        p.141 = p;
        D.28404 = decode_value (p.141, &p);
        imt_tramp->vt_offset = D.28404;
        ji->data.imt_tramp = imt_tramp;
        goto <D.24285>;
      }
      <D.24332>:
      p.141 = p;
      D.28405 = decode_signature (aot_module, p.141, &p);
      ji->data.target = D.28405;
      goto <D.24285>;
      <D.24333>:
      p.141 = p;
      D.28406 = decode_value (p.141, &p);
      D.28407 = (long int) D.28406;
      D.28408 = (const void *) D.28407;
      ji->data.target = D.28408;
      goto <D.24285>;
      <D.24334>:
      {
        struct MonoJumpInfoGSharedVtCall * info;

        info = monoeg_malloc0 (16);
        p.141 = p;
        D.28409 = decode_signature (aot_module, p.141, &p);
        info->sig = D.28409;
        D.28410 = info->sig;
        D.28411 = D.28410 == 0B;
        D.28412 = (long int) D.28411;
        D.28413 = __builtin_expect (D.28412, 0);
        if (D.28413 != 0) goto <D.28414>; else goto <D.28415>;
        <D.28414>:
        monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "aot-runtime.c", 3126, "info->sig");
        <D.28415>:
        p.141 = p;
        D.28416 = decode_resolve_method_ref (aot_module, p.141, &p);
        info->method = D.28416;
        D.28417 = info->method;
        D.28418 = D.28417 == 0B;
        D.28419 = (long int) D.28418;
        D.28420 = __builtin_expect (D.28419, 0);
        if (D.28420 != 0) goto <D.28421>; else goto <D.28422>;
        <D.28421>:
        monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "aot-runtime.c", 3128, "info->method");
        <D.28422>:
        ji->data.target = info;
        goto <D.24285>;
      }
      <D.24336>:
      {
        struct MonoGSharedVtMethodInfo * info;
        int i;
        int nentries;

        info = monoeg_malloc0 (16);
        p.141 = p;
        D.28423 = decode_resolve_method_ref (aot_module, p.141, &p);
        info->method = D.28423;
        D.28424 = info->method;
        D.28425 = D.28424 == 0B;
        D.28426 = (long int) D.28425;
        D.28427 = __builtin_expect (D.28426, 0);
        if (D.28427 != 0) goto <D.28428>; else goto <D.28429>;
        <D.28428>:
        monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "aot-runtime.c", 3138, "info->method");
        <D.28429>:
        p.141 = p;
        nentries = decode_value (p.141, &p);
        D.28430 = monoeg_g_ptr_array_new ();
        info->entries = D.28430;
        i = 0;
        goto <D.24347>;
        <D.24346>:
        {
          struct MonoRuntimeGenericContextInfoTemplate * template;

          template = monoeg_malloc0 (24);
          p.141 = p;
          D.28431 = decode_value (p.141, &p);
          D.28432 = (<unnamed type>) D.28431;
          template->info_type = D.28432;
          D.28433 = template->info_type;
          D.28434 = mini_rgctx_info_type_to_patch_info_type (D.28433);
          switch (D.28434) <default: <D.24345>, case 11: <D.24341>, case 13: <D.24344>>
          <D.24341>:
          {
            struct MonoClass * klass;

            p.141 = p;
            klass = decode_klass_ref (aot_module, p.141, &p);
            if (klass == 0B) goto cleanup; else goto <D.28435>;
            <D.28435>:
            D.28436 = &klass->byval_arg;
            template->data = D.28436;
            goto <D.24343>;
          }
          <D.24344>:
          p.141 = p;
          D.28437 = decode_field_info (aot_module, p.141, &p);
          template->data = D.28437;
          D.28438 = template->data;
          if (D.28438 == 0B) goto cleanup; else goto <D.28439>;
          <D.28439>:
          goto <D.24343>;
          <D.24345>:
          monoeg_assertion_message ("* Assertion: should not be reached at %s:%d\n", "aot-runtime.c", 3159);
          <D.24343>:
          D.28440 = info->entries;
          monoeg_g_ptr_array_add (D.28440, template);
        }
        i = i + 1;
        <D.24347>:
        if (i < nentries) goto <D.24346>; else goto <D.24348>;
        <D.24348>:
        ji->data.target = info;
        goto <D.24285>;
      }
      <D.24349>:
      D.28280 = ji->type;
      monoeg_g_log (0B, 16, "unhandled type %d", D.28280);
      monoeg_assertion_message ("* Assertion: should not be reached at %s:%d\n", "aot-runtime.c", 3170);
      <D.24285>:
      p.141 = p;
      *endbuf = p.141;
      D.28441 = 1;
      return D.28441;
      cleanup:
      D.28441 = 0;
      return D.28441;
    }
  finally
    {
      p = {CLOBBER};
    }
}


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

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


decode_field_info (struct MonoAotModule * module, guint8 * buf, guint8 * * endbuf)
{
  guint8 * buf.150;
  struct MonoClassField * D.28456;
  guint8 * p.151;
  int D.28458;
  int D.28459;
  struct MonoClass * klass;
  guint32 token;
  guint8 * p;

  try
    {
      buf.150 = buf;
      klass = decode_klass_ref (module, buf.150, &buf);
      buf.150 = buf;
      p = buf.150;
      if (klass == 0B) goto <D.28454>; else goto <D.28455>;
      <D.28454>:
      D.28456 = 0B;
      return D.28456;
      <D.28455>:
      p.151 = p;
      D.28458 = decode_value (p.151, &p);
      D.28459 = D.28458 + 67108864;
      token = (guint32) D.28459;
      p.151 = p;
      *endbuf = p.151;
      D.28456 = mono_class_get_field (klass, token);
      return D.28456;
    }
  finally
    {
      p = {CLOBBER};
    }
}


register_jump_target_got_slot (struct MonoDomain * domain, struct MonoMethod * method, void * * got_slot)
{
  union mono_mutex_t * D.28462;
  _Bool D.28465;
  long int D.28466;
  long int D.28467;
  struct GHashTable * D.28470;
  struct GHashTable * D.28473;
  _Bool D.28476;
  long int D.28477;
  long int D.28478;
  struct MonoJitDomainInfo * info;
  struct GSList * list;

  info = domain->runtime_info;
  {
    int ret;

    D.28462 = &domain->lock.mutex;
    ret = pthread_mutex_lock (D.28462);
    if (ret != 0) goto <D.28463>; else goto <D.28464>;
    <D.28463>:
    monoeg_g_log (0B, 16, "Bad call to mono_mutex_lock result %d", ret);
    <D.28464>:
    D.28465 = ret != 0;
    D.28466 = (long int) D.28465;
    D.28467 = __builtin_expect (D.28466, 0);
    if (D.28467 != 0) goto <D.28468>; else goto <D.28469>;
    <D.28468>:
    monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "aot-runtime.c", 3242, "ret == 0");
    <D.28469>:
  }
  D.28470 = info->jump_target_got_slot_hash;
  if (D.28470 == 0B) goto <D.28471>; else goto <D.28472>;
  <D.28471>:
  D.28473 = monoeg_g_hash_table_new (0B, 0B);
  info->jump_target_got_slot_hash = D.28473;
  <D.28472>:
  D.28470 = info->jump_target_got_slot_hash;
  list = monoeg_g_hash_table_lookup (D.28470, method);
  list = monoeg_g_slist_prepend (list, got_slot);
  D.28470 = info->jump_target_got_slot_hash;
  monoeg_g_hash_table_insert_replace (D.28470, method, list, 0);
  {
    int ret;

    D.28462 = &domain->lock.mutex;
    ret = pthread_mutex_unlock (D.28462);
    if (ret != 0) goto <D.28474>; else goto <D.28475>;
    <D.28474>:
    monoeg_g_log (0B, 16, "Bad call to mono_mutex_unlock result %d", ret);
    <D.28475>:
    D.28476 = ret != 0;
    D.28477 = (long int) D.28476;
    D.28478 = __builtin_expect (D.28477, 0);
    if (D.28478 != 0) goto <D.28479>; else goto <D.28480>;
    <D.28479>:
    monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "aot-runtime.c", 3248, "ret == 0");
    <D.28480>:
  }
}


InterlockedIncrement (volatile gint32 * val)
{
  gint32 D.28481;
  unsigned int D.28482;

  D.28482 = __sync_add_and_fetch_4 (val, 1);
  D.28481 = (gint32) D.28482;
  return D.28481;
}


init_plt (struct MonoAotModule * amodule)
{
  int D.28484;
  struct MonoDomain * D.28487;
  struct MonoDomain * D.28488;
  void * * D.28489;
  unsigned int D.28490;
  unsigned int i.152;
  unsigned int D.28492;
  long unsigned int D.28493;
  long unsigned int D.28494;
  void * * D.28495;
  unsigned int D.28496;
  int i;
  void * tramp;

  D.28484 = amodule->plt_inited;
  if (D.28484 != 0) goto <D.28485>; else goto <D.28486>;
  <D.28485>:
  return;
  <D.28486>:
  D.28487 = mono_get_root_domain ();
  tramp = mono_create_specific_trampoline (amodule, 6, D.28487, 0B);
  D.28488 = mono_domain_get ();
  tramp = mono_create_ftnptr (D.28488, tramp);
  i = 1;
  goto <D.24661>;
  <D.24660>:
  D.28489 = amodule->got;
  D.28490 = amodule->info.plt_got_offset_base;
  i.152 = (unsigned int) i;
  D.28492 = D.28490 + i.152;
  D.28493 = (long unsigned int) D.28492;
  D.28494 = D.28493 * 8;
  D.28495 = D.28489 + D.28494;
  *D.28495 = tramp;
  i = i + 1;
  <D.24661>:
  i.152 = (unsigned int) i;
  D.28496 = amodule->info.plt_size;
  if (i.152 < D.28496) goto <D.24660>; else goto <D.24662>;
  <D.24662>:
  amodule->plt_inited = 1;
}


mono_aot_get_method_from_token (struct MonoDomain * domain, struct MonoImage * image, guint32 token)
{
  void * D.28500;
  unsigned int D.28501;
  unsigned int D.28502;
  struct MonoAotModule * aot_module;
  int method_index;

  aot_module = image->aot_module;
  if (aot_module == 0B) goto <D.28498>; else goto <D.28499>;
  <D.28498>:
  D.28500 = 0B;
  return D.28500;
  <D.28499>:
  D.28501 = token & 16777215;
  D.28502 = D.28501 + 4294967295;
  method_index = (int) D.28502;
  D.28500 = load_method (domain, aot_module, image, 0B, token, method_index);
  return D.28500;
}


mono_aot_is_got_entry (guint8 * code, guint8 * addr)
{
  struct GHashTable * aot_modules.153;
  gboolean D.28507;
  _Bool D.28510;
  long int D.28511;
  long int D.28512;
  _Bool D.28517;
  long int D.28518;
  long int D.28519;
  struct IsGotEntryUserData user_data;

  try
    {
      aot_modules.153 = aot_modules;
      if (aot_modules.153 == 0B) goto <D.28505>; else goto <D.28506>;
      <D.28505>:
      D.28507 = 0;
      return D.28507;
      <D.28506>:
      user_data.addr = addr;
      user_data.res = 0;
      {
        int ret;

        ret = pthread_mutex_lock (&aot_mutex.mutex);
        if (ret != 0) goto <D.28508>; else goto <D.28509>;
        <D.28508>:
        monoeg_g_log (0B, 16, "Bad call to mono_mutex_lock result %d", ret);
        <D.28509>:
        D.28510 = ret != 0;
        D.28511 = (long int) D.28510;
        D.28512 = __builtin_expect (D.28511, 0);
        if (D.28512 != 0) goto <D.28513>; else goto <D.28514>;
        <D.28513>:
        monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "aot-runtime.c", 3812, "ret == 0");
        <D.28514>:
      }
      aot_modules.153 = aot_modules;
      monoeg_g_hash_table_foreach (aot_modules.153, check_is_got_entry, &user_data);
      {
        int ret;

        ret = pthread_mutex_unlock (&aot_mutex.mutex);
        if (ret != 0) goto <D.28515>; else goto <D.28516>;
        <D.28515>:
        monoeg_g_log (0B, 16, "Bad call to mono_mutex_unlock result %d", ret);
        <D.28516>:
        D.28517 = ret != 0;
        D.28518 = (long int) D.28517;
        D.28519 = __builtin_expect (D.28518, 0);
        if (D.28519 != 0) goto <D.28520>; else goto <D.28521>;
        <D.28520>:
        monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "aot-runtime.c", 3814, "ret == 0");
        <D.28521>:
      }
      D.28507 = user_data.res;
      return D.28507;
    }
  finally
    {
      user_data = {CLOBBER};
    }
}


check_is_got_entry (void * key, void * value, void * user_data)
{
  void * * D.28524;
  guint8 * D.28527;
  unsigned int D.28530;
  long unsigned int D.28531;
  long unsigned int D.28532;
  guint8 * D.28533;
  struct IsGotEntryUserData * data;
  struct MonoAotModule * aot_module;

  data = user_data;
  aot_module = value;
  D.28524 = aot_module->got;
  if (D.28524 != 0B) goto <D.28525>; else goto <D.28526>;
  <D.28525>:
  D.28527 = data->addr;
  D.28524 = aot_module->got;
  if (D.28527 >= D.28524) goto <D.28528>; else goto <D.28529>;
  <D.28528>:
  D.28527 = data->addr;
  D.28524 = aot_module->got;
  D.28530 = aot_module->info.got_size;
  D.28531 = (long unsigned int) D.28530;
  D.28532 = D.28531 * 8;
  D.28533 = D.28524 + D.28532;
  if (D.28527 < D.28533) goto <D.28534>; else goto <D.28535>;
  <D.28534>:
  data->res = 1;
  <D.28535>:
  <D.28529>:
  <D.28526>:
}


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

  D.28536 = mono_domain_get ();
  D.28537 = mono_get_root_domain ();
  if (D.28536 == D.28537) goto <D.28538>; else goto <D.28539>;
  <D.28538>:
  mono_arch_patch_plt_entry (code, got, regs, addr);
  <D.28539>:
}


mono_aot_plt_resolve (void * aot_module, guint32 plt_info_offset, guint8 * code)
{
  guint8 * D.28540;
  sizetype D.28541;
  guint8 * p.154;
  guint8 * p.155;
  int D.28544;
  <unnamed type> D.28545;
  void * D.28548;
  int mono_aot_only.156;
  <unnamed type> D.28553;
  struct MonoMethod * D.28555;
  unsigned char D.28556;
  unsigned char D.28557;
  int D.28559;
  short unsigned int D.28561;
  int D.28562;
  int D.28563;
  int D.28565;
  struct MonoDomain * D.28568;
  <unnamed type> D.28569;
  _Bool D.28570;
  _Bool D.28571;
  _Bool D.28572;
  struct MonoDomain * D.28586;
  _Bool D.28587;
  long int D.28588;
  long int D.28589;
  void * * D.28592;
  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.28540 = module->blob;
      D.28541 = (sizetype) plt_info_offset;
      p.154 = D.28540 + D.28541;
      p = p.154;
      p.155 = p;
      D.28544 = decode_value (p.155, &p);
      D.28545 = (<unnamed type>) D.28544;
      ji.type = D.28545;
      mp = mono_mempool_new_size (512);
      p.155 = p;
      res = decode_patch (module, mp, &ji, p.155, &p);
      if (res == 0) goto <D.28546>; else goto <D.28547>;
      <D.28546>:
      mono_mempool_destroy (mp);
      D.28548 = 0B;
      return D.28548;
      <D.28547>:
      mono_aot_only.156 = mono_aot_only;
      if (mono_aot_only.156 != 0) goto <D.28552>; else goto <D.28549>;
      <D.28552>:
      D.28553 = ji.type;
      if (D.28553 == 3) goto <D.28554>; else goto <D.28549>;
      <D.28554>:
      D.28555 = ji.data.method;
      D.28556 = BIT_FIELD_REF <*D.28555, 8, 264>;
      D.28557 = D.28556 & 8;
      if (D.28557 == 0) goto <D.28558>; else goto <D.28549>;
      <D.28558>:
      D.28555 = ji.data.method;
      D.28559 = mono_method_check_context_used (D.28555);
      if (D.28559 == 0) goto <D.28560>; else goto <D.28549>;
      <D.28560>:
      D.28555 = ji.data.method;
      D.28561 = D.28555->iflags;
      D.28562 = (int) D.28561;
      D.28563 = D.28562 & 32;
      if (D.28563 == 0) goto <D.28564>; else goto <D.28549>;
      <D.28564>:
      D.28555 = ji.data.method;
      D.28565 = mono_method_needs_static_rgctx_invoke (D.28555, 0);
      if (D.28565 == 0) goto <D.28566>; else goto <D.28549>;
      <D.28566>:
      if (using_gsharedvt == 0) goto <D.28567>; else goto <D.28549>;
      <D.28567>:
      D.28555 = ji.data.method;
      target = mono_jit_compile_method (D.28555);
      no_ftnptr = 1;
      goto <D.28550>;
      <D.28549>:
      D.28568 = mono_domain_get ();
      target = mono_resolve_patch_target (0B, D.28568, 0B, &ji, 1);
      <D.28550>:
      D.28569 = ji.type;
      D.28570 = D.28569 == 1;
      D.28571 = D.28569 == 7;
      D.28572 = D.28570 | D.28571;
      if (D.28572 != 0) goto <D.28573>; else goto <D.28574>;
      <D.28574>:
      D.28553 = ji.type;
      if (D.28553 == 15) goto <D.28575>; else goto <D.28576>;
      <D.28576>:
      D.28553 = ji.type;
      if (D.28553 == 31) goto <D.28577>; else goto <D.28578>;
      <D.28578>:
      D.28553 = ji.type;
      if (D.28553 == 32) goto <D.28579>; else goto <D.28580>;
      <D.28580>:
      D.28553 = ji.type;
      if (D.28553 == 35) goto <D.28581>; else goto <D.28582>;
      <D.28581>:
      goto <D.28583>;
      <D.28582>:
      if (no_ftnptr == 0) goto <D.28584>; else goto <D.28585>;
      <D.28584>:
      D.28586 = mono_domain_get ();
      target = mono_create_ftnptr (D.28586, target);
      <D.28585>:
      <D.28583>:
      <D.28579>:
      <D.28577>:
      <D.28575>:
      <D.28573>:
      mono_mempool_destroy (mp);
      plt_entry = mono_aot_get_plt_entry (code);
      D.28587 = plt_entry == 0B;
      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", 3944, "plt_entry");
      <D.28591>:
      D.28592 = module->got;
      mono_aot_patch_plt_entry (plt_entry, D.28592, 0B, target);
      D.28548 = target;
      return D.28548;
    }
  finally
    {
      p = {CLOBBER};
      ji = {CLOBBER};
    }
}


mono_aot_get_plt_entry (guint8 * code)
{
  guint8 * D.28597;
  guint8 * D.28599;
  guint8 * D.28601;
  struct MonoAotModule * amodule;
  guint8 * target;

  amodule = find_aot_module (code);
  target = 0B;
  if (amodule == 0B) goto <D.28595>; else goto <D.28596>;
  <D.28595>:
  D.28597 = 0B;
  return D.28597;
  <D.28596>:
  target = mono_arch_get_call_target (code);
  D.28599 = amodule->plt;
  if (D.28599 <= target) goto <D.28600>; else goto <D.28598>;
  <D.28600>:
  D.28601 = amodule->plt_end;
  if (D.28601 > target) goto <D.28602>; else goto <D.28598>;
  <D.28602>:
  D.28597 = target;
  return D.28597;
  <D.28598>:
  D.28597 = 0B;
  return D.28597;
}


find_aot_module (guint8 * code)
{
  struct GHashTable * aot_modules.157;
  struct MonoAotModule * D.28607;
  long unsigned int code.158;
  long unsigned int aot_code_low_addr.159;
  long unsigned int aot_code_high_addr.160;
  _Bool D.28616;
  long int D.28617;
  long int D.28618;
  _Bool D.28623;
  long int D.28624;
  long int D.28625;
  struct FindAotModuleUserData user_data;

  try
    {
      aot_modules.157 = aot_modules;
      if (aot_modules.157 == 0B) goto <D.28605>; else goto <D.28606>;
      <D.28605>:
      D.28607 = 0B;
      return D.28607;
      <D.28606>:
      code.158 = (long unsigned int) code;
      aot_code_low_addr.159 = aot_code_low_addr;
      if (code.158 < aot_code_low_addr.159) goto <D.28608>; else goto <D.28612>;
      <D.28612>:
      code.158 = (long unsigned int) code;
      aot_code_high_addr.160 = aot_code_high_addr;
      if (code.158 > aot_code_high_addr.160) goto <D.28608>; else goto <D.28609>;
      <D.28608>:
      D.28607 = 0B;
      return D.28607;
      <D.28609>:
      user_data.addr = code;
      user_data.module = 0B;
      {
        int ret;

        ret = pthread_mutex_lock (&aot_mutex.mutex);
        if (ret != 0) goto <D.28614>; else goto <D.28615>;
        <D.28614>:
        monoeg_g_log (0B, 16, "Bad call to mono_mutex_lock result %d", ret);
        <D.28615>:
        D.28616 = ret != 0;
        D.28617 = (long int) D.28616;
        D.28618 = __builtin_expect (D.28617, 0);
        if (D.28618 != 0) goto <D.28619>; else goto <D.28620>;
        <D.28619>:
        monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "aot-runtime.c", 3849, "ret == 0");
        <D.28620>:
      }
      aot_modules.157 = aot_modules;
      monoeg_g_hash_table_foreach (aot_modules.157, find_aot_module_cb, &user_data);
      {
        int ret;

        ret = pthread_mutex_unlock (&aot_mutex.mutex);
        if (ret != 0) goto <D.28621>; else goto <D.28622>;
        <D.28621>:
        monoeg_g_log (0B, 16, "Bad call to mono_mutex_unlock result %d", ret);
        <D.28622>:
        D.28623 = ret != 0;
        D.28624 = (long int) D.28623;
        D.28625 = __builtin_expect (D.28624, 0);
        if (D.28625 != 0) goto <D.28626>; else goto <D.28627>;
        <D.28626>:
        monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "aot-runtime.c", 3851, "ret == 0");
        <D.28627>:
      }
      D.28607 = user_data.module;
      return D.28607;
    }
  finally
    {
      user_data = {CLOBBER};
    }
}


find_aot_module_cb (void * key, void * value, void * user_data)
{
  guint8 * D.28630;
  guint8 * D.28631;
  guint8 * D.28634;
  struct FindAotModuleUserData * data;
  struct MonoAotModule * aot_module;

  data = user_data;
  aot_module = value;
  D.28630 = data->addr;
  D.28631 = aot_module->code;
  if (D.28630 >= D.28631) goto <D.28632>; else goto <D.28633>;
  <D.28632>:
  D.28630 = data->addr;
  D.28634 = aot_module->code_end;
  if (D.28630 < D.28634) goto <D.28635>; else goto <D.28636>;
  <D.28635>:
  data->module = aot_module;
  <D.28636>:
  <D.28633>:
}


mono_aot_get_plt_info_offset (mgreg_t * regs, guint8 * code)
{
  _Bool D.28637;
  long int D.28638;
  long int D.28639;
  guint32 D.28642;
  guint8 * plt_entry;

  plt_entry = mono_aot_get_plt_entry (code);
  D.28637 = plt_entry == 0B;
  D.28638 = (long int) D.28637;
  D.28639 = __builtin_expect (D.28638, 0);
  if (D.28639 != 0) goto <D.28640>; else goto <D.28641>;
  <D.28640>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "aot-runtime.c", 4039, "plt_entry");
  <D.28641>:
  D.28642 = mono_arch_get_plt_info_offset (plt_entry, regs, code);
  return D.28642;
}


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

  aot_jit_icall_hash.161 = aot_jit_icall_hash;
  if (aot_jit_icall_hash.161 == 0B) goto <D.28645>; else goto <D.28646>;
  <D.28645>:
  aot_jit_icall_hash.162 = monoeg_g_hash_table_new (monoeg_g_str_hash, monoeg_g_str_equal);
  aot_jit_icall_hash = aot_jit_icall_hash.162;
  <D.28646>:
  aot_jit_icall_hash.161 = aot_jit_icall_hash;
  monoeg_g_hash_table_insert_replace (aot_jit_icall_hash.161, name, addr, 0);
}


mono_aot_get_trampoline_full (const char * name, struct MonoTrampInfo * * out_tinfo)
{
  _Bool D.28648;
  long int D.28649;
  long int D.28650;
  _Bool D.28653;
  long int D.28654;
  long int D.28655;
  void * D.28658;
  void * D.28659;
  struct MonoImage * image;
  struct MonoAotModule * amodule;

  image = mono_defaults.corlib;
  D.28648 = image == 0B;
  D.28649 = (long int) D.28648;
  D.28650 = __builtin_expect (D.28649, 0);
  if (D.28650 != 0) goto <D.28651>; else goto <D.28652>;
  <D.28651>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "aot-runtime.c", 4242, "image");
  <D.28652>:
  amodule = image->aot_module;
  D.28653 = amodule == 0B;
  D.28654 = (long int) D.28653;
  D.28655 = __builtin_expect (D.28654, 0);
  if (D.28655 != 0) goto <D.28656>; else goto <D.28657>;
  <D.28656>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "aot-runtime.c", 4245, "amodule");
  <D.28657>:
  D.28659 = load_function_full (amodule, name, out_tinfo);
  D.28658 = mono_create_ftnptr_malloc (D.28659);
  return D.28658;
}


load_function_full (struct MonoAotModule * amodule, const char * name, struct MonoTrampInfo * * out_tinfo)
{
  void * * D.28661;
  struct MonoDl * D.28662;
  void * code.163;
  char * D.28666;
  guint8 * p.164;
  void * D.28670;
  guint8 * p.165;
  guint8 * D.28674;
  sizetype D.28675;
  guint8 * uw_info.166;
  guint8 * uw_info.167;
  int D.28678;
  guint8 * D.28679;
  sizetype D.28680;
  guint8 * p.168;
  _Bool D.28684;
  long int D.28685;
  long int D.28686;
  long unsigned int D.28689;
  long unsigned int D.28690;
  void * * D.28691;
  guint32 * got_slots.169;
  long unsigned int D.28693;
  guint32 * D.28694;
  unsigned int D.28695;
  long unsigned int D.28696;
  long unsigned int D.28697;
  void * * D.28698;
  void * D.28699;
  <unnamed type> D.28702;
  int D.24711;
  int iftmp.170;
  int D.24710;
  const char[18] * D.28708;
  unsigned char D.28709;
  int D.28710;
  unsigned char D.28711;
  int D.28712;
  _Bool D.28713;
  _Bool D.28714;
  _Bool D.28715;
  const unsigned char * D.28718;
  unsigned char D.28719;
  int D.28720;
  const unsigned char * D.28721;
  unsigned char D.28722;
  int D.28723;
  _Bool D.28724;
  _Bool D.28725;
  const unsigned char * D.28728;
  unsigned char D.28729;
  int D.28730;
  const unsigned char * D.28731;
  unsigned char D.28732;
  int D.28733;
  _Bool D.28734;
  _Bool D.28735;
  const unsigned char * D.28738;
  unsigned char D.28739;
  int D.28740;
  const unsigned char * D.28741;
  unsigned char D.28742;
  int D.28743;
  const char * D.28745;
  int D.24720;
  int iftmp.171;
  int D.24719;
  const char[42] * D.28752;
  unsigned char D.28753;
  int D.28754;
  unsigned char D.28755;
  int D.28756;
  _Bool D.28757;
  _Bool D.28758;
  _Bool D.28759;
  const unsigned char * D.28762;
  unsigned char D.28763;
  int D.28764;
  const unsigned char * D.28765;
  unsigned char D.28766;
  int D.28767;
  _Bool D.28768;
  _Bool D.28769;
  const unsigned char * D.28772;
  unsigned char D.28773;
  int D.28774;
  const unsigned char * D.28775;
  unsigned char D.28776;
  int D.28777;
  _Bool D.28778;
  _Bool D.28779;
  const unsigned char * D.28782;
  unsigned char D.28783;
  int D.28784;
  const unsigned char * D.28785;
  unsigned char D.28786;
  int D.28787;
  int D.24729;
  int iftmp.172;
  int D.24728;
  const char[26] * D.28795;
  unsigned char D.28796;
  int D.28797;
  unsigned char D.28798;
  int D.28799;
  _Bool D.28800;
  _Bool D.28801;
  _Bool D.28802;
  const unsigned char * D.28805;
  unsigned char D.28806;
  int D.28807;
  const unsigned char * D.28808;
  unsigned char D.28809;
  int D.28810;
  _Bool D.28811;
  _Bool D.28812;
  const unsigned char * D.28815;
  unsigned char D.28816;
  int D.28817;
  const unsigned char * D.28818;
  unsigned char D.28819;
  int D.28820;
  _Bool D.28821;
  _Bool D.28822;
  const unsigned char * D.28825;
  unsigned char D.28826;
  int D.28827;
  const unsigned char * D.28828;
  unsigned char D.28829;
  int D.28830;
  int D.24738;
  int iftmp.173;
  int D.24737;
  const char[21] * D.28838;
  unsigned char D.28839;
  int D.28840;
  unsigned char D.28841;
  int D.28842;
  _Bool D.28843;
  _Bool D.28844;
  _Bool D.28845;
  const unsigned char * D.28848;
  unsigned char D.28849;
  int D.28850;
  const unsigned char * D.28851;
  unsigned char D.28852;
  int D.28853;
  _Bool D.28854;
  _Bool D.28855;
  const unsigned char * D.28858;
  unsigned char D.28859;
  int D.28860;
  const unsigned char * D.28861;
  unsigned char D.28862;
  int D.28863;
  _Bool D.28864;
  _Bool D.28865;
  const unsigned char * D.28868;
  unsigned char D.28869;
  int D.28870;
  const unsigned char * D.28871;
  unsigned char D.28872;
  int D.28873;
  char * D.28878;
  const char * D.28881;
  <unnamed type> tramp_type2.174;
  char * D.28884;
  _Bool D.28887;
  long int D.28888;
  long int D.28889;
  struct MonoDomain * D.28892;
  unsigned int slot.175;
  long unsigned int D.28894;
  void * D.28895;
  int D.24750;
  int iftmp.176;
  int D.24749;
  const char[34] * D.28900;
  unsigned char D.28901;
  int D.28902;
  unsigned char D.28903;
  int D.28904;
  _Bool D.28905;
  _Bool D.28906;
  _Bool D.28907;
  const unsigned char * D.28910;
  unsigned char D.28911;
  int D.28912;
  const unsigned char * D.28913;
  unsigned char D.28914;
  int D.28915;
  _Bool D.28916;
  _Bool D.28917;
  const unsigned char * D.28920;
  unsigned char D.28921;
  int D.28922;
  const unsigned char * D.28923;
  unsigned char D.28924;
  int D.28925;
  _Bool D.28926;
  _Bool D.28927;
  const unsigned char * D.28930;
  unsigned char D.28931;
  int D.28932;
  const unsigned char * D.28933;
  unsigned char D.28934;
  int D.28935;
  struct MonoDomain * D.28939;
  int D.24759;
  int iftmp.177;
  int D.24758;
  const char[33] * D.28944;
  unsigned char D.28945;
  int D.28946;
  unsigned char D.28947;
  int D.28948;
  _Bool D.28949;
  _Bool D.28950;
  _Bool D.28951;
  const unsigned char * D.28954;
  unsigned char D.28955;
  int D.28956;
  const unsigned char * D.28957;
  unsigned char D.28958;
  int D.28959;
  _Bool D.28960;
  _Bool D.28961;
  const unsigned char * D.28964;
  unsigned char D.28965;
  int D.28966;
  const unsigned char * D.28967;
  unsigned char D.28968;
  int D.28969;
  _Bool D.28970;
  _Bool D.28971;
  const unsigned char * D.28974;
  unsigned char D.28975;
  int D.28976;
  const unsigned char * D.28977;
  unsigned char D.28978;
  int D.28979;
  struct MonoDomain * D.28983;
  int D.24768;
  int iftmp.178;
  int D.24767;
  const char[39] * D.28988;
  unsigned char D.28989;
  int D.28990;
  unsigned char D.28991;
  int D.28992;
  _Bool D.28993;
  _Bool D.28994;
  _Bool D.28995;
  const unsigned char * D.28998;
  unsigned char D.28999;
  int D.29000;
  const unsigned char * D.29001;
  unsigned char D.29002;
  int D.29003;
  _Bool D.29004;
  _Bool D.29005;
  const unsigned char * D.29008;
  unsigned char D.29009;
  int D.29010;
  const unsigned char * D.29011;
  unsigned char D.29012;
  int D.29013;
  _Bool D.29014;
  _Bool D.29015;
  const unsigned char * D.29018;
  unsigned char D.29019;
  int D.29020;
  const unsigned char * D.29021;
  unsigned char D.29022;
  int D.29023;
  struct MonoDomain * D.29027;
  int D.24777;
  int iftmp.179;
  int D.24776;
  const char[44] * D.29032;
  unsigned char D.29033;
  int D.29034;
  unsigned char D.29035;
  int D.29036;
  _Bool D.29037;
  _Bool D.29038;
  _Bool D.29039;
  const unsigned char * D.29042;
  unsigned char D.29043;
  int D.29044;
  const unsigned char * D.29045;
  unsigned char D.29046;
  int D.29047;
  _Bool D.29048;
  _Bool D.29049;
  const unsigned char * D.29052;
  unsigned char D.29053;
  int D.29054;
  const unsigned char * D.29055;
  unsigned char D.29056;
  int D.29057;
  _Bool D.29058;
  _Bool D.29059;
  const unsigned char * D.29062;
  unsigned char D.29063;
  int D.29064;
  const unsigned char * D.29065;
  unsigned char D.29066;
  int D.29067;
  char * D.29072;
  struct GHashTable * aot_jit_icall_hash.180;
  void * D.29080;
  struct _IO_FILE * stderr.181;
  _Bool D.29084;
  long int D.29085;
  long int D.29086;
  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.28661 = amodule->globals;
      D.28662 = amodule->sofile;
      find_symbol (D.28662, D.28661, symbol, &code);
      monoeg_g_free (symbol);
      code.163 = code;
      if (code.163 == 0B) goto <D.28664>; else goto <D.28665>;
      <D.28664>:
      D.28666 = amodule->aot_name;
      monoeg_g_log (0B, 4, "Symbol \'%s\' not found in AOT file \'%s\'.\n", name, D.28666);
      <D.24692>:
      goto <D.24692>;
      <D.28665>:
      D.28666 = amodule->aot_name;
      mono_trace (128, 32, "AOT FOUND function \'%s\' in AOT file \'%s\'.", name, D.28666);
      symbol = monoeg_g_strdup_printf ("%s_p", name);
      D.28661 = amodule->globals;
      D.28662 = amodule->sofile;
      find_symbol (D.28662, D.28661, symbol, &p);
      monoeg_g_free (symbol);
      p.164 = p;
      if (p.164 == 0B) goto <D.28668>; else goto <D.28669>;
      <D.28668>:
      D.28670 = code;
      return D.28670;
      <D.28669>:
      p.164 = p;
      info_offset = MEM[(guint32 *)p.164];
      if (out_tinfo != 0B) goto <D.28671>; else goto <D.28672>;
      <D.28671>:
      {
        struct MonoTrampInfo * tinfo;
        guint32 code_size;
        guint32 uw_info_len;
        guint32 uw_offset;
        guint8 * uw_info;

        try
          {
            p.164 = p;
            p.165 = p.164 + 4;
            p = p.165;
            p.164 = p;
            code_size = MEM[(guint32 *)p.164];
            p.164 = p;
            p.165 = p.164 + 4;
            p = p.165;
            p.164 = p;
            uw_offset = MEM[(guint32 *)p.164];
            D.28674 = amodule->unwind_info;
            D.28675 = (sizetype) uw_offset;
            uw_info.166 = D.28674 + D.28675;
            uw_info = uw_info.166;
            uw_info.167 = uw_info;
            D.28678 = decode_value (uw_info.167, &uw_info);
            uw_info_len = (guint32) D.28678;
            tinfo = monoeg_malloc0 (56);
            code.163 = code;
            tinfo->code = code.163;
            tinfo->code_size = code_size;
            uw_info.167 = uw_info;
            tinfo->uw_info = uw_info.167;
            tinfo->uw_info_len = uw_info_len;
            *out_tinfo = tinfo;
          }
        finally
          {
            uw_info = {CLOBBER};
          }
      }
      <D.28672>:
      D.28679 = amodule->blob;
      D.28680 = (sizetype) info_offset;
      p.168 = D.28679 + D.28680;
      p = p.168;
      p.164 = p;
      n_patches = decode_value (p.164, &p);
      if (n_patches != 0) goto <D.28682>; else goto <D.28683>;
      <D.28682>:
      {
        struct MonoJumpInfo * patches;
        guint32 * got_slots;

        try
          {
            mp = mono_mempool_new ();
            p.164 = p;
            patches = load_patch_info (amodule, mp, n_patches, &got_slots, p.164, &p);
            D.28684 = patches == 0B;
            D.28685 = (long int) D.28684;
            D.28686 = __builtin_expect (D.28685, 0);
            if (D.28686 != 0) goto <D.28687>; else goto <D.28688>;
            <D.28687>:
            monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "aot-runtime.c", 4151, "patches");
            <D.28688>:
            pindex = 0;
            goto <D.24779>;
            <D.24778>:
            {
              struct MonoJumpInfo * ji;
              void * target;

              D.28689 = (long unsigned int) pindex;
              D.28690 = D.28689 * 40;
              ji = patches + D.28690;
              D.28691 = amodule->got;
              got_slots.169 = got_slots;
              D.28689 = (long unsigned int) pindex;
              D.28693 = D.28689 * 4;
              D.28694 = got_slots.169 + D.28693;
              D.28695 = *D.28694;
              D.28696 = (long unsigned int) D.28695;
              D.28697 = D.28696 * 8;
              D.28698 = D.28691 + D.28697;
              D.28699 = *D.28698;
              if (D.28699 != 0B) goto <D.28700>; else goto <D.28701>;
              <D.28700>:
              // predicted unlikely by continue predictor.
              goto <D.24702>;
              <D.28701>:
              D.28702 = ji->type;
              if (D.28702 == 32) goto <D.28703>; else goto <D.28704>;
              <D.28703>:
              {
                size_t __s1_len;
                size_t __s2_len;

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

                  __s2 = ji->data.name;
                  D.28708 = "mono_get_lmf_addr";
                  D.28709 = MEM[(const unsigned char *)D.28708];
                  D.28710 = (int) D.28709;
                  D.28711 = *__s2;
                  D.28712 = (int) D.28711;
                  __result = D.28710 - D.28712;
                  {
                    D.28713 = __s2_len != 0;
                    D.28714 = __result == 0;
                    D.28715 = D.28713 & D.28714;
                    if (D.28715 != 0) goto <D.28716>; else goto <D.28717>;
                    <D.28716>:
                    D.28718 = &MEM[(void *)"mono_get_lmf_addr" + 1B];
                    D.28719 = *D.28718;
                    D.28720 = (int) D.28719;
                    D.28721 = __s2 + 1;
                    D.28722 = *D.28721;
                    D.28723 = (int) D.28722;
                    __result = D.28720 - D.28723;
                    D.28724 = __s2_len > 1;
                    D.28714 = __result == 0;
                    D.28725 = D.28724 & D.28714;
                    if (D.28725 != 0) goto <D.28726>; else goto <D.28727>;
                    <D.28726>:
                    D.28728 = &MEM[(void *)"mono_get_lmf_addr" + 2B];
                    D.28729 = *D.28728;
                    D.28730 = (int) D.28729;
                    D.28731 = __s2 + 2;
                    D.28732 = *D.28731;
                    D.28733 = (int) D.28732;
                    __result = D.28730 - D.28733;
                    D.28734 = __s2_len > 2;
                    D.28714 = __result == 0;
                    D.28735 = D.28734 & D.28714;
                    if (D.28735 != 0) goto <D.28736>; else goto <D.28737>;
                    <D.28736>:
                    D.28738 = &MEM[(void *)"mono_get_lmf_addr" + 3B];
                    D.28739 = *D.28738;
                    D.28740 = (int) D.28739;
                    D.28741 = __s2 + 3;
                    D.28742 = *D.28741;
                    D.28743 = (int) D.28742;
                    __result = D.28740 - D.28743;
                    <D.28737>:
                    <D.28727>:
                    <D.28717>:
                  }
                  D.24710 = __result;
                }
                iftmp.170 = -D.24710;
                goto <D.28744>;
                <D.28707>:
                D.28745 = ji->data.name;
                iftmp.170 = __builtin_strcmp (D.28745, "mono_get_lmf_addr");
                <D.28744>:
                D.24711 = iftmp.170;
              }
              if (D.24711 == 0) goto <D.28746>; else goto <D.28747>;
              <D.28746>:
              target = mono_get_lmf_addr;
              goto <D.28748>;
              <D.28747>:
              {
                size_t __s1_len;
                size_t __s2_len;

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

                  __s2 = ji->data.name;
                  D.28752 = "mono_thread_force_interruption_checkpoint";
                  D.28753 = MEM[(const unsigned char *)D.28752];
                  D.28754 = (int) D.28753;
                  D.28755 = *__s2;
                  D.28756 = (int) D.28755;
                  __result = D.28754 - D.28756;
                  {
                    D.28757 = __s2_len != 0;
                    D.28758 = __result == 0;
                    D.28759 = D.28757 & D.28758;
                    if (D.28759 != 0) goto <D.28760>; else goto <D.28761>;
                    <D.28760>:
                    D.28762 = &MEM[(void *)"mono_thread_force_interruption_checkpoint" + 1B];
                    D.28763 = *D.28762;
                    D.28764 = (int) D.28763;
                    D.28765 = __s2 + 1;
                    D.28766 = *D.28765;
                    D.28767 = (int) D.28766;
                    __result = D.28764 - D.28767;
                    D.28768 = __s2_len > 1;
                    D.28758 = __result == 0;
                    D.28769 = D.28768 & D.28758;
                    if (D.28769 != 0) goto <D.28770>; else goto <D.28771>;
                    <D.28770>:
                    D.28772 = &MEM[(void *)"mono_thread_force_interruption_checkpoint" + 2B];
                    D.28773 = *D.28772;
                    D.28774 = (int) D.28773;
                    D.28775 = __s2 + 2;
                    D.28776 = *D.28775;
                    D.28777 = (int) D.28776;
                    __result = D.28774 - D.28777;
                    D.28778 = __s2_len > 2;
                    D.28758 = __result == 0;
                    D.28779 = D.28778 & D.28758;
                    if (D.28779 != 0) goto <D.28780>; else goto <D.28781>;
                    <D.28780>:
                    D.28782 = &MEM[(void *)"mono_thread_force_interruption_checkpoint" + 3B];
                    D.28783 = *D.28782;
                    D.28784 = (int) D.28783;
                    D.28785 = __s2 + 3;
                    D.28786 = *D.28785;
                    D.28787 = (int) D.28786;
                    __result = D.28784 - D.28787;
                    <D.28781>:
                    <D.28771>:
                    <D.28761>:
                  }
                  D.24719 = __result;
                }
                iftmp.171 = -D.24719;
                goto <D.28788>;
                <D.28751>:
                D.28745 = ji->data.name;
                iftmp.171 = __builtin_strcmp (D.28745, "mono_thread_force_interruption_checkpoint");
                <D.28788>:
                D.24720 = iftmp.171;
              }
              if (D.24720 == 0) goto <D.28789>; else goto <D.28790>;
              <D.28789>:
              target = mono_thread_force_interruption_checkpoint;
              goto <D.28791>;
              <D.28790>:
              {
                size_t __s1_len;
                size_t __s2_len;

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

                  __s2 = ji->data.name;
                  D.28795 = "mono_exception_from_token";
                  D.28796 = MEM[(const unsigned char *)D.28795];
                  D.28797 = (int) D.28796;
                  D.28798 = *__s2;
                  D.28799 = (int) D.28798;
                  __result = D.28797 - D.28799;
                  {
                    D.28800 = __s2_len != 0;
                    D.28801 = __result == 0;
                    D.28802 = D.28800 & D.28801;
                    if (D.28802 != 0) goto <D.28803>; else goto <D.28804>;
                    <D.28803>:
                    D.28805 = &MEM[(void *)"mono_exception_from_token" + 1B];
                    D.28806 = *D.28805;
                    D.28807 = (int) D.28806;
                    D.28808 = __s2 + 1;
                    D.28809 = *D.28808;
                    D.28810 = (int) D.28809;
                    __result = D.28807 - D.28810;
                    D.28811 = __s2_len > 1;
                    D.28801 = __result == 0;
                    D.28812 = D.28811 & D.28801;
                    if (D.28812 != 0) goto <D.28813>; else goto <D.28814>;
                    <D.28813>:
                    D.28815 = &MEM[(void *)"mono_exception_from_token" + 2B];
                    D.28816 = *D.28815;
                    D.28817 = (int) D.28816;
                    D.28818 = __s2 + 2;
                    D.28819 = *D.28818;
                    D.28820 = (int) D.28819;
                    __result = D.28817 - D.28820;
                    D.28821 = __s2_len > 2;
                    D.28801 = __result == 0;
                    D.28822 = D.28821 & D.28801;
                    if (D.28822 != 0) goto <D.28823>; else goto <D.28824>;
                    <D.28823>:
                    D.28825 = &MEM[(void *)"mono_exception_from_token" + 3B];
                    D.28826 = *D.28825;
                    D.28827 = (int) D.28826;
                    D.28828 = __s2 + 3;
                    D.28829 = *D.28828;
                    D.28830 = (int) D.28829;
                    __result = D.28827 - D.28830;
                    <D.28824>:
                    <D.28814>:
                    <D.28804>:
                  }
                  D.24728 = __result;
                }
                iftmp.172 = -D.24728;
                goto <D.28831>;
                <D.28794>:
                D.28745 = ji->data.name;
                iftmp.172 = __builtin_strcmp (D.28745, "mono_exception_from_token");
                <D.28831>:
                D.24729 = iftmp.172;
              }
              if (D.24729 == 0) goto <D.28832>; else goto <D.28833>;
              <D.28832>:
              target = mono_exception_from_token;
              goto <D.28834>;
              <D.28833>:
              {
                size_t __s1_len;
                size_t __s2_len;

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

                  __s2 = ji->data.name;
                  D.28838 = "mono_throw_exception";
                  D.28839 = MEM[(const unsigned char *)D.28838];
                  D.28840 = (int) D.28839;
                  D.28841 = *__s2;
                  D.28842 = (int) D.28841;
                  __result = D.28840 - D.28842;
                  {
                    D.28843 = __s2_len != 0;
                    D.28844 = __result == 0;
                    D.28845 = D.28843 & D.28844;
                    if (D.28845 != 0) goto <D.28846>; else goto <D.28847>;
                    <D.28846>:
                    D.28848 = &MEM[(void *)"mono_throw_exception" + 1B];
                    D.28849 = *D.28848;
                    D.28850 = (int) D.28849;
                    D.28851 = __s2 + 1;
                    D.28852 = *D.28851;
                    D.28853 = (int) D.28852;
                    __result = D.28850 - D.28853;
                    D.28854 = __s2_len > 1;
                    D.28844 = __result == 0;
                    D.28855 = D.28854 & D.28844;
                    if (D.28855 != 0) goto <D.28856>; else goto <D.28857>;
                    <D.28856>:
                    D.28858 = &MEM[(void *)"mono_throw_exception" + 2B];
                    D.28859 = *D.28858;
                    D.28860 = (int) D.28859;
                    D.28861 = __s2 + 2;
                    D.28862 = *D.28861;
                    D.28863 = (int) D.28862;
                    __result = D.28860 - D.28863;
                    D.28864 = __s2_len > 2;
                    D.28844 = __result == 0;
                    D.28865 = D.28864 & D.28844;
                    if (D.28865 != 0) goto <D.28866>; else goto <D.28867>;
                    <D.28866>:
                    D.28868 = &MEM[(void *)"mono_throw_exception" + 3B];
                    D.28869 = *D.28868;
                    D.28870 = (int) D.28869;
                    D.28871 = __s2 + 3;
                    D.28872 = *D.28871;
                    D.28873 = (int) D.28872;
                    __result = D.28870 - D.28873;
                    <D.28867>:
                    <D.28857>:
                    <D.28847>:
                  }
                  D.24737 = __result;
                }
                iftmp.173 = -D.24737;
                goto <D.28874>;
                <D.28837>:
                D.28745 = ji->data.name;
                iftmp.173 = __builtin_strcmp (D.28745, "mono_throw_exception");
                <D.28874>:
                D.24738 = iftmp.173;
              }
              if (D.24738 == 0) goto <D.28875>; else goto <D.28876>;
              <D.28875>:
              target = mono_get_throw_exception ();
              goto <D.28877>;
              <D.28876>:
              D.28745 = ji->data.name;
              D.28878 = strstr (D.28745, "trampoline_func_");
              D.28745 = ji->data.name;
              if (D.28878 == D.28745) goto <D.28879>; else goto <D.28880>;
              <D.28879>:
              {
                int tramp_type2;

                D.28745 = ji->data.name;
                D.28881 = D.28745 + 16;
                tramp_type2 = atoi (D.28881);
                tramp_type2.174 = (<unnamed type>) tramp_type2;
                target = mono_get_trampoline_func (tramp_type2.174);
              }
              goto <D.28883>;
              <D.28880>:
              D.28745 = ji->data.name;
              D.28884 = strstr (D.28745, "specific_trampoline_lazy_fetch_");
              D.28745 = ji->data.name;
              if (D.28884 == D.28745) goto <D.28885>; else goto <D.28886>;
              <D.28885>:
              {
                guint32 slot;
                int res;

                try
                  {
                    D.28745 = ji->data.name;
                    res = sscanf (D.28745, "specific_trampoline_lazy_fetch_%u", &slot);
                    D.28887 = res != 1;
                    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", 4182, "res == 1");
                    <D.28891>:
                    D.28892 = mono_get_root_domain ();
                    slot.175 = slot;
                    D.28894 = (long unsigned int) slot.175;
                    D.28895 = (void *) D.28894;
                    target = mono_create_specific_trampoline (D.28895, 4, D.28892, 0B);
                    target = mono_create_ftnptr_malloc (target);
                  }
                finally
                  {
                    slot = {CLOBBER};
                  }
              }
              goto <D.28896>;
              <D.28886>:
              {
                size_t __s1_len;
                size_t __s2_len;

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

                  __s2 = ji->data.name;
                  D.28900 = "specific_trampoline_monitor_enter";
                  D.28901 = MEM[(const unsigned char *)D.28900];
                  D.28902 = (int) D.28901;
                  D.28903 = *__s2;
                  D.28904 = (int) D.28903;
                  __result = D.28902 - D.28904;
                  {
                    D.28905 = __s2_len != 0;
                    D.28906 = __result == 0;
                    D.28907 = D.28905 & D.28906;
                    if (D.28907 != 0) goto <D.28908>; else goto <D.28909>;
                    <D.28908>:
                    D.28910 = &MEM[(void *)"specific_trampoline_monitor_enter" + 1B];
                    D.28911 = *D.28910;
                    D.28912 = (int) D.28911;
                    D.28913 = __s2 + 1;
                    D.28914 = *D.28913;
                    D.28915 = (int) D.28914;
                    __result = D.28912 - D.28915;
                    D.28916 = __s2_len > 1;
                    D.28906 = __result == 0;
                    D.28917 = D.28916 & D.28906;
                    if (D.28917 != 0) goto <D.28918>; else goto <D.28919>;
                    <D.28918>:
                    D.28920 = &MEM[(void *)"specific_trampoline_monitor_enter" + 2B];
                    D.28921 = *D.28920;
                    D.28922 = (int) D.28921;
                    D.28923 = __s2 + 2;
                    D.28924 = *D.28923;
                    D.28925 = (int) D.28924;
                    __result = D.28922 - D.28925;
                    D.28926 = __s2_len > 2;
                    D.28906 = __result == 0;
                    D.28927 = D.28926 & D.28906;
                    if (D.28927 != 0) goto <D.28928>; else goto <D.28929>;
                    <D.28928>:
                    D.28930 = &MEM[(void *)"specific_trampoline_monitor_enter" + 3B];
                    D.28931 = *D.28930;
                    D.28932 = (int) D.28931;
                    D.28933 = __s2 + 3;
                    D.28934 = *D.28933;
                    D.28935 = (int) D.28934;
                    __result = D.28932 - D.28935;
                    <D.28929>:
                    <D.28919>:
                    <D.28909>:
                  }
                  D.24749 = __result;
                }
                iftmp.176 = -D.24749;
                goto <D.28936>;
                <D.28899>:
                D.28745 = ji->data.name;
                iftmp.176 = __builtin_strcmp (D.28745, "specific_trampoline_monitor_enter");
                <D.28936>:
                D.24750 = iftmp.176;
              }
              if (D.24750 == 0) goto <D.28937>; else goto <D.28938>;
              <D.28937>:
              D.28939 = mono_get_root_domain ();
              target = mono_create_specific_trampoline (0B, 10, D.28939, 0B);
              target = mono_create_ftnptr_malloc (target);
              goto <D.28940>;
              <D.28938>:
              {
                size_t __s1_len;
                size_t __s2_len;

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

                  __s2 = ji->data.name;
                  D.28944 = "specific_trampoline_monitor_exit";
                  D.28945 = MEM[(const unsigned char *)D.28944];
                  D.28946 = (int) D.28945;
                  D.28947 = *__s2;
                  D.28948 = (int) D.28947;
                  __result = D.28946 - D.28948;
                  {
                    D.28949 = __s2_len != 0;
                    D.28950 = __result == 0;
                    D.28951 = D.28949 & D.28950;
                    if (D.28951 != 0) goto <D.28952>; else goto <D.28953>;
                    <D.28952>:
                    D.28954 = &MEM[(void *)"specific_trampoline_monitor_exit" + 1B];
                    D.28955 = *D.28954;
                    D.28956 = (int) D.28955;
                    D.28957 = __s2 + 1;
                    D.28958 = *D.28957;
                    D.28959 = (int) D.28958;
                    __result = D.28956 - D.28959;
                    D.28960 = __s2_len > 1;
                    D.28950 = __result == 0;
                    D.28961 = D.28960 & D.28950;
                    if (D.28961 != 0) goto <D.28962>; else goto <D.28963>;
                    <D.28962>:
                    D.28964 = &MEM[(void *)"specific_trampoline_monitor_exit" + 2B];
                    D.28965 = *D.28964;
                    D.28966 = (int) D.28965;
                    D.28967 = __s2 + 2;
                    D.28968 = *D.28967;
                    D.28969 = (int) D.28968;
                    __result = D.28966 - D.28969;
                    D.28970 = __s2_len > 2;
                    D.28950 = __result == 0;
                    D.28971 = D.28970 & D.28950;
                    if (D.28971 != 0) goto <D.28972>; else goto <D.28973>;
                    <D.28972>:
                    D.28974 = &MEM[(void *)"specific_trampoline_monitor_exit" + 3B];
                    D.28975 = *D.28974;
                    D.28976 = (int) D.28975;
                    D.28977 = __s2 + 3;
                    D.28978 = *D.28977;
                    D.28979 = (int) D.28978;
                    __result = D.28976 - D.28979;
                    <D.28973>:
                    <D.28963>:
                    <D.28953>:
                  }
                  D.24758 = __result;
                }
                iftmp.177 = -D.24758;
                goto <D.28980>;
                <D.28943>:
                D.28745 = ji->data.name;
                iftmp.177 = __builtin_strcmp (D.28745, "specific_trampoline_monitor_exit");
                <D.28980>:
                D.24759 = iftmp.177;
              }
              if (D.24759 == 0) goto <D.28981>; else goto <D.28982>;
              <D.28981>:
              D.28983 = mono_get_root_domain ();
              target = mono_create_specific_trampoline (0B, 11, D.28983, 0B);
              target = mono_create_ftnptr_malloc (target);
              goto <D.28984>;
              <D.28982>:
              {
                size_t __s1_len;
                size_t __s2_len;

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

                  __s2 = ji->data.name;
                  D.28988 = "specific_trampoline_generic_class_init";
                  D.28989 = MEM[(const unsigned char *)D.28988];
                  D.28990 = (int) D.28989;
                  D.28991 = *__s2;
                  D.28992 = (int) D.28991;
                  __result = D.28990 - D.28992;
                  {
                    D.28993 = __s2_len != 0;
                    D.28994 = __result == 0;
                    D.28995 = D.28993 & D.28994;
                    if (D.28995 != 0) goto <D.28996>; else goto <D.28997>;
                    <D.28996>:
                    D.28998 = &MEM[(void *)"specific_trampoline_generic_class_init" + 1B];
                    D.28999 = *D.28998;
                    D.29000 = (int) D.28999;
                    D.29001 = __s2 + 1;
                    D.29002 = *D.29001;
                    D.29003 = (int) D.29002;
                    __result = D.29000 - D.29003;
                    D.29004 = __s2_len > 1;
                    D.28994 = __result == 0;
                    D.29005 = D.29004 & D.28994;
                    if (D.29005 != 0) goto <D.29006>; else goto <D.29007>;
                    <D.29006>:
                    D.29008 = &MEM[(void *)"specific_trampoline_generic_class_init" + 2B];
                    D.29009 = *D.29008;
                    D.29010 = (int) D.29009;
                    D.29011 = __s2 + 2;
                    D.29012 = *D.29011;
                    D.29013 = (int) D.29012;
                    __result = D.29010 - D.29013;
                    D.29014 = __s2_len > 2;
                    D.28994 = __result == 0;
                    D.29015 = D.29014 & D.28994;
                    if (D.29015 != 0) goto <D.29016>; else goto <D.29017>;
                    <D.29016>:
                    D.29018 = &MEM[(void *)"specific_trampoline_generic_class_init" + 3B];
                    D.29019 = *D.29018;
                    D.29020 = (int) D.29019;
                    D.29021 = __s2 + 3;
                    D.29022 = *D.29021;
                    D.29023 = (int) D.29022;
                    __result = D.29020 - D.29023;
                    <D.29017>:
                    <D.29007>:
                    <D.28997>:
                  }
                  D.24767 = __result;
                }
                iftmp.178 = -D.24767;
                goto <D.29024>;
                <D.28987>:
                D.28745 = ji->data.name;
                iftmp.178 = __builtin_strcmp (D.28745, "specific_trampoline_generic_class_init");
                <D.29024>:
                D.24768 = iftmp.178;
              }
              if (D.24768 == 0) goto <D.29025>; else goto <D.29026>;
              <D.29025>:
              D.29027 = mono_get_root_domain ();
              target = mono_create_specific_trampoline (0B, 3, D.29027, 0B);
              target = mono_create_ftnptr_malloc (target);
              goto <D.29028>;
              <D.29026>:
              {
                size_t __s1_len;
                size_t __s2_len;

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

                  __s2 = ji->data.name;
                  D.29032 = "mono_thread_get_and_clear_pending_exception";
                  D.29033 = MEM[(const unsigned char *)D.29032];
                  D.29034 = (int) D.29033;
                  D.29035 = *__s2;
                  D.29036 = (int) D.29035;
                  __result = D.29034 - D.29036;
                  {
                    D.29037 = __s2_len != 0;
                    D.29038 = __result == 0;
                    D.29039 = D.29037 & D.29038;
                    if (D.29039 != 0) goto <D.29040>; else goto <D.29041>;
                    <D.29040>:
                    D.29042 = &MEM[(void *)"mono_thread_get_and_clear_pending_exception" + 1B];
                    D.29043 = *D.29042;
                    D.29044 = (int) D.29043;
                    D.29045 = __s2 + 1;
                    D.29046 = *D.29045;
                    D.29047 = (int) D.29046;
                    __result = D.29044 - D.29047;
                    D.29048 = __s2_len > 1;
                    D.29038 = __result == 0;
                    D.29049 = D.29048 & D.29038;
                    if (D.29049 != 0) goto <D.29050>; else goto <D.29051>;
                    <D.29050>:
                    D.29052 = &MEM[(void *)"mono_thread_get_and_clear_pending_exception" + 2B];
                    D.29053 = *D.29052;
                    D.29054 = (int) D.29053;
                    D.29055 = __s2 + 2;
                    D.29056 = *D.29055;
                    D.29057 = (int) D.29056;
                    __result = D.29054 - D.29057;
                    D.29058 = __s2_len > 2;
                    D.29038 = __result == 0;
                    D.29059 = D.29058 & D.29038;
                    if (D.29059 != 0) goto <D.29060>; else goto <D.29061>;
                    <D.29060>:
                    D.29062 = &MEM[(void *)"mono_thread_get_and_clear_pending_exception" + 3B];
                    D.29063 = *D.29062;
                    D.29064 = (int) D.29063;
                    D.29065 = __s2 + 3;
                    D.29066 = *D.29065;
                    D.29067 = (int) D.29066;
                    __result = D.29064 - D.29067;
                    <D.29061>:
                    <D.29051>:
                    <D.29041>:
                  }
                  D.24776 = __result;
                }
                iftmp.179 = -D.24776;
                goto <D.29068>;
                <D.29031>:
                D.28745 = ji->data.name;
                iftmp.179 = __builtin_strcmp (D.28745, "mono_thread_get_and_clear_pending_exception");
                <D.29068>:
                D.24777 = iftmp.179;
              }
              if (D.24777 == 0) goto <D.29069>; else goto <D.29070>;
              <D.29069>:
              target = mono_thread_get_and_clear_pending_exception;
              goto <D.29071>;
              <D.29070>:
              D.28745 = ji->data.name;
              D.29072 = strstr (D.28745, "generic_trampoline_");
              if (D.29072 != 0B) goto <D.29073>; else goto <D.29074>;
              <D.29073>:
              D.28745 = ji->data.name;
              target = mono_aot_get_trampoline (D.28745);
              goto <D.29075>;
              <D.29074>:
              aot_jit_icall_hash.180 = aot_jit_icall_hash;
              if (aot_jit_icall_hash.180 != 0B) goto <D.29079>; else goto <D.29076>;
              <D.29079>:
              D.28745 = ji->data.name;
              aot_jit_icall_hash.180 = aot_jit_icall_hash;
              D.29080 = monoeg_g_hash_table_lookup (aot_jit_icall_hash.180, D.28745);
              if (D.29080 != 0B) goto <D.29081>; else goto <D.29076>;
              <D.29081>:
              D.28745 = ji->data.name;
              aot_jit_icall_hash.180 = aot_jit_icall_hash;
              target = monoeg_g_hash_table_lookup (aot_jit_icall_hash.180, D.28745);
              goto <D.29077>;
              <D.29076>:
              D.28745 = ji->data.name;
              stderr.181 = stderr;
              fprintf (stderr.181, "Unknown relocation \'%s\'\n", D.28745);
              monoeg_assertion_message ("* Assertion: should not be reached at %s:%d\n", "aot-runtime.c", 4203);
              target = 0B;
              <D.29077>:
              <D.29075>:
              <D.29071>:
              <D.29028>:
              <D.28984>:
              <D.28940>:
              <D.28896>:
              <D.28883>:
              <D.28877>:
              <D.28834>:
              <D.28791>:
              <D.28748>:
              goto <D.29083>;
              <D.28704>:
              code.163 = code;
              target = mono_resolve_patch_target (0B, 0B, code.163, ji, 0);
              D.29084 = target == 0B;
              D.29085 = (long int) D.29084;
              D.29086 = __builtin_expect (D.29085, 0);
              if (D.29086 != 0) goto <D.29087>; else goto <D.29088>;
              <D.29087>:
              monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "aot-runtime.c", 4211, "target");
              <D.29088>:
              <D.29083>:
              D.28691 = amodule->got;
              got_slots.169 = got_slots;
              D.28689 = (long unsigned int) pindex;
              D.28693 = D.28689 * 4;
              D.28694 = got_slots.169 + D.28693;
              D.28695 = *D.28694;
              D.28696 = (long unsigned int) D.28695;
              D.28697 = D.28696 * 8;
              D.28698 = D.28691 + D.28697;
              *D.28698 = target;
            }
            <D.24702>:
            pindex = pindex + 1;
            <D.24779>:
            if (pindex < n_patches) goto <D.24778>; else goto <D.24780>;
            <D.24780>:
            got_slots.169 = got_slots;
            monoeg_g_free (got_slots.169);
            mono_mempool_destroy (mp);
          }
        finally
          {
            got_slots = {CLOBBER};
          }
      }
      <D.28683>:
      D.28670 = code;
      return D.28670;
    }
  finally
    {
      p = {CLOBBER};
      code = {CLOBBER};
    }
}


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

  D.29091 = code;
  return D.29091;
}


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

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


mono_aot_create_specific_trampoline (struct MonoImage * image, void * arg1, MonoTrampolineType tramp_type, struct MonoDomain * domain, guint32 * code_len)
{
  int inited.182;
  _Bool D.29100;
  long int D.29101;
  long int D.29102;
  _Bool D.29109;
  long int D.29110;
  long int D.29111;
  unsigned int num_trampolines.183;
  unsigned int num_trampolines.184;
  void * D.29116;
  void * D.29119;
  _Bool D.29120;
  long int D.29121;
  long int D.29122;
  struct MonoAotModule * amodule.185;
  void * * D.29129;
  unsigned int got_offset.186;
  long unsigned int D.29131;
  long unsigned int D.29132;
  void * * D.29133;
  unsigned int D.29134;
  long unsigned int D.29135;
  long unsigned int D.29136;
  void * * D.29137;
  unsigned int tramp_size.187;
  void * D.29141;
  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.182 = inited;
      if (inited.182 == 0) goto <D.29096>; else goto <D.29097>;
      <D.29096>:
      {
        int ret;

        ret = pthread_mutex_lock (&aot_mutex.mutex);
        if (ret != 0) goto <D.29098>; else goto <D.29099>;
        <D.29098>:
        monoeg_g_log (0B, 16, "Bad call to mono_mutex_lock result %d", ret);
        <D.29099>:
        D.29100 = ret != 0;
        D.29101 = (long int) D.29100;
        D.29102 = __builtin_expect (D.29101, 0);
        if (D.29102 != 0) goto <D.29103>; else goto <D.29104>;
        <D.29103>:
        monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "aot-runtime.c", 4494, "ret == 0");
        <D.29104>:
      }
      inited.182 = inited;
      if (inited.182 == 0) goto <D.29105>; else goto <D.29106>;
      <D.29105>:
      mono_counters_register ("Specific trampolines", 256, &num_trampolines);
      inited = 1;
      <D.29106>:
      {
        int ret;

        ret = pthread_mutex_unlock (&aot_mutex.mutex);
        if (ret != 0) goto <D.29107>; else goto <D.29108>;
        <D.29107>:
        monoeg_g_log (0B, 16, "Bad call to mono_mutex_unlock result %d", ret);
        <D.29108>:
        D.29109 = ret != 0;
        D.29110 = (long int) D.29109;
        D.29111 = __builtin_expect (D.29110, 0);
        if (D.29111 != 0) goto <D.29112>; else goto <D.29113>;
        <D.29112>:
        monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "aot-runtime.c", 4501, "ret == 0");
        <D.29113>:
      }
      <D.29097>:
      num_trampolines.183 = num_trampolines;
      num_trampolines.184 = num_trampolines.183 + 1;
      num_trampolines = num_trampolines.184;
      D.29116 = generic_trampolines[tramp_type];
      if (D.29116 == 0B) goto <D.29117>; else goto <D.29118>;
      <D.29117>:
      {
        char * symbol;

        symbol = mono_get_generic_trampoline_name (tramp_type);
        D.29119 = mono_aot_get_trampoline (symbol);
        generic_trampolines[tramp_type] = D.29119;
        monoeg_g_free (symbol);
      }
      <D.29118>:
      tramp = generic_trampolines[tramp_type];
      D.29120 = tramp == 0B;
      D.29121 = (long int) D.29120;
      D.29122 = __builtin_expect (D.29121, 0);
      if (D.29122 != 0) goto <D.29123>; else goto <D.29124>;
      <D.29123>:
      monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "aot-runtime.c", 4515, "tramp");
      <D.29124>:
      if (0 != 0) goto <D.29125>; else goto <D.29126>;
      <D.29125>:
      code = get_new_specific_trampoline_from_page (tramp, arg1);
      tramp_size = 8;
      goto <D.29127>;
      <D.29126>:
      code = get_numerous_trampoline (0, 2, &amodule, &got_offset, &tramp_size);
      amodule.185 = amodule;
      D.29129 = amodule.185->got;
      got_offset.186 = got_offset;
      D.29131 = (long unsigned int) got_offset.186;
      D.29132 = D.29131 * 8;
      D.29133 = D.29129 + D.29132;
      *D.29133 = tramp;
      amodule.185 = amodule;
      D.29129 = amodule.185->got;
      got_offset.186 = got_offset;
      D.29134 = got_offset.186 + 1;
      D.29135 = (long unsigned int) D.29134;
      D.29136 = D.29135 * 8;
      D.29137 = D.29129 + D.29136;
      *D.29137 = arg1;
      <D.29127>:
      if (code_len != 0B) goto <D.29138>; else goto <D.29139>;
      <D.29138>:
      tramp_size.187 = tramp_size;
      *code_len = tramp_size.187;
      <D.29139>:
      D.29141 = code;
      return D.29141;
    }
  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.29144;
  long int D.29145;
  long int D.29146;
  _Bool D.29151;
  long int D.29152;
  long int D.29153;
  _Bool D.29156;
  long int D.29157;
  long int D.29158;
  unsigned int D.29161;
  unsigned int D.29162;
  char * D.29165;
  unsigned int D.29166;
  unsigned int D.29167;
  _Bool D.29170;
  long int D.29171;
  long int D.29172;
  unsigned int D.29175;
  int D.29176;
  unsigned int D.29177;
  unsigned int D.29178;
  unsigned int D.29179;
  unsigned int tramp_size.188;
  void * D.29183;
  guint8 * D.29184;
  int D.29185;
  sizetype D.29186;
  struct MonoAotModule * amodule;
  int index;
  int tramp_size;
  struct MonoImage * image;

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

    ret = pthread_mutex_lock (&aot_mutex.mutex);
    if (ret != 0) goto <D.29149>; else goto <D.29150>;
    <D.29149>:
    monoeg_g_log (0B, 16, "Bad call to mono_mutex_lock result %d", ret);
    <D.29150>:
    D.29151 = ret != 0;
    D.29152 = (long int) D.29151;
    D.29153 = __builtin_expect (D.29152, 0);
    if (D.29153 != 0) goto <D.29154>; else goto <D.29155>;
    <D.29154>:
    monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "aot-runtime.c", 4450, "ret == 0");
    <D.29155>:
  }
  amodule = image->aot_module;
  D.29156 = amodule == 0B;
  D.29157 = (long int) D.29156;
  D.29158 = __builtin_expect (D.29157, 0);
  if (D.29158 != 0) goto <D.29159>; else goto <D.29160>;
  <D.29159>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "aot-runtime.c", 4453, "amodule");
  <D.29160>:
  *out_amodule = amodule;
  D.29161 = amodule->trampoline_index[tramp_type];
  D.29162 = amodule->info.num_trampolines[tramp_type];
  if (D.29161 == D.29162) goto <D.29163>; else goto <D.29164>;
  <D.29163>:
  D.29162 = amodule->info.num_trampolines[tramp_type];
  D.29165 = image->name;
  monoeg_g_log (0B, 4, "Ran out of trampolines of type %d in \'%s\' (%d)%s\n", tramp_type, D.29165, D.29162, "");
  <D.24833>:
  goto <D.24833>;
  <D.29164>:
  D.29161 = amodule->trampoline_index[tramp_type];
  D.29166 = D.29161;
  D.29167 = D.29166 + 1;
  amodule->trampoline_index[tramp_type] = D.29167;
  index = (int) D.29166;
  {
    int ret;

    ret = pthread_mutex_unlock (&aot_mutex.mutex);
    if (ret != 0) goto <D.29168>; else goto <D.29169>;
    <D.29168>:
    monoeg_g_log (0B, 16, "Bad call to mono_mutex_unlock result %d", ret);
    <D.29169>:
    D.29170 = ret != 0;
    D.29171 = (long int) D.29170;
    D.29172 = __builtin_expect (D.29171, 0);
    if (D.29172 != 0) goto <D.29173>; else goto <D.29174>;
    <D.29173>:
    monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "aot-runtime.c", 4468, "ret == 0");
    <D.29174>:
  }
  D.29175 = amodule->info.trampoline_got_offset_base[tramp_type];
  D.29176 = index * n_got_slots;
  D.29177 = (unsigned int) D.29176;
  D.29178 = D.29175 + D.29177;
  *got_offset = D.29178;
  D.29179 = amodule->info.trampoline_size[tramp_type];
  tramp_size = (int) D.29179;
  if (out_tramp_size != 0B) goto <D.29180>; else goto <D.29181>;
  <D.29180>:
  tramp_size.188 = (unsigned int) tramp_size;
  *out_tramp_size = tramp_size.188;
  <D.29181>:
  D.29184 = amodule->trampolines[tramp_type];
  D.29185 = index * tramp_size;
  D.29186 = (sizetype) D.29185;
  D.29183 = D.29184 + D.29186;
  return D.29183;
}


mono_aot_get_static_rgctx_trampoline (void * ctx, void * addr)
{
  struct MonoAotModule * amodule.189;
  void * * D.29192;
  unsigned int got_offset.190;
  long unsigned int D.29194;
  long unsigned int D.29195;
  void * * D.29196;
  unsigned int D.29197;
  long unsigned int D.29198;
  long unsigned int D.29199;
  void * * D.29200;
  void * D.29201;
  struct MonoDomain * D.29202;
  struct MonoAotModule * amodule;
  guint8 * code;
  guint32 got_offset;

  try
    {
      if (0 != 0) goto <D.29188>; else goto <D.29189>;
      <D.29188>:
      code = get_new_rgctx_trampoline_from_page (addr, ctx);
      goto <D.29190>;
      <D.29189>:
      code = get_numerous_trampoline (1, 2, &amodule, &got_offset, 0B);
      amodule.189 = amodule;
      D.29192 = amodule.189->got;
      got_offset.190 = got_offset;
      D.29194 = (long unsigned int) got_offset.190;
      D.29195 = D.29194 * 8;
      D.29196 = D.29192 + D.29195;
      *D.29196 = ctx;
      amodule.189 = amodule;
      D.29192 = amodule.189->got;
      got_offset.190 = got_offset;
      D.29197 = got_offset.190 + 1;
      D.29198 = (long unsigned int) D.29197;
      D.29199 = D.29198 * 8;
      D.29200 = D.29192 + D.29199;
      *D.29200 = addr;
      <D.29190>:
      D.29202 = mono_domain_get ();
      D.29201 = mono_create_ftnptr (D.29202, code);
      return D.29201;
    }
  finally
    {
      amodule = {CLOBBER};
      got_offset = {CLOBBER};
    }
}


mono_aot_get_unbox_trampoline (struct MonoMethod * method)
{
  unsigned int D.29205;
  unsigned int D.29206;
  unsigned char D.29209;
  unsigned char D.29210;
  int D.29212;
  int D.29216;
  _Bool D.29219;
  long int D.29220;
  long int D.29221;
  struct MonoClass * D.29224;
  struct MonoImage * D.29225;
  void * amodule.191;
  struct MonoAotModule * amodule.192;
  _Bool D.29228;
  long int D.29229;
  long int D.29230;
  long int ut_end.193;
  long int ut.194;
  long int D.29235;
  long int D.29236;
  long int D.29237;
  int D.29238;
  int D.29239;
  long unsigned int D.29240;
  long unsigned int D.29241;
  unsigned int D.29242;
  unsigned int D.29249;
  unsigned int D.29250;
  guint32 * D.29253;
  guint8 * D.29255;
  unsigned int D.29256;
  sizetype D.29257;
  _Bool D.29258;
  long int D.29259;
  long int D.29260;
  void * D.29263;
  struct MonoDomain * D.29264;
  guint32 method_index;
  struct MonoAotModule * amodule;
  void * code;
  guint32 * ut;
  guint32 * ut_end;
  guint32 * entry;
  int low;
  int high;
  int entry_index;

  try
    {
      D.29205 = method->token;
      D.29206 = D.29205 & 16777215;
      method_index = D.29206 + 4294967295;
      D.29209 = BIT_FIELD_REF <*method, 8, 264>;
      D.29210 = D.29209 & 16;
      if (D.29210 != 0) goto <D.29211>; else goto <D.29207>;
      <D.29211>:
      D.29212 = mono_method_is_generic_sharable_full (method, 0, 0, 0);
      if (D.29212 == 0) goto <D.29213>; else goto <D.29207>;
      <D.29213>:
      method_index = find_extra_method (method, &amodule);
      if (method_index == 16777215) goto <D.29214>; else goto <D.29215>;
      <D.29214>:
      D.29216 = mono_method_is_generic_sharable_full (method, 0, 0, 1);
      if (D.29216 != 0) goto <D.29217>; else goto <D.29218>;
      <D.29217>:
      {
        struct MonoMethod * shared;

        shared = mini_get_shared_method_full (method, 1, 1);
        method_index = find_extra_method (shared, &amodule);
      }
      <D.29218>:
      <D.29215>:
      D.29219 = method_index == 16777215;
      D.29220 = (long int) D.29219;
      D.29221 = __builtin_expect (D.29220, 0);
      if (D.29221 != 0) goto <D.29222>; else goto <D.29223>;
      <D.29222>:
      monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "aot-runtime.c", 4568, "method_index != 0xffffff");
      <D.29223>:
      goto <D.29208>;
      <D.29207>:
      D.29224 = method->klass;
      D.29225 = D.29224->image;
      amodule.191 = D.29225->aot_module;
      amodule = amodule.191;
      amodule.192 = amodule;
      D.29228 = amodule.192 == 0B;
      D.29229 = (long int) D.29228;
      D.29230 = __builtin_expect (D.29229, 0);
      if (D.29230 != 0) goto <D.29231>; else goto <D.29232>;
      <D.29231>:
      monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "aot-runtime.c", 4571, "amodule");
      <D.29232>:
      <D.29208>:
      amodule.192 = amodule;
      ut = amodule.192->unbox_trampolines;
      amodule.192 = amodule;
      ut_end = amodule.192->unbox_trampolines_end;
      code = 0B;
      low = 0;
      ut_end.193 = (long int) ut_end;
      ut.194 = (long int) ut;
      D.29235 = ut_end.193 - ut.194;
      D.29236 = D.29235 /[ex] 4;
      D.29237 = D.29236 / 2;
      high = (int) D.29237;
      goto <D.24875>;
      <D.24874>:
      D.29238 = low + high;
      entry_index = D.29238 / 2;
      D.29239 = entry_index * 2;
      D.29240 = (long unsigned int) D.29239;
      D.29241 = D.29240 * 4;
      entry = ut + D.29241;
      D.29242 = *entry;
      if (D.29242 < method_index) goto <D.29243>; else goto <D.29244>;
      <D.29243>:
      low = entry_index + 1;
      goto <D.29245>;
      <D.29244>:
      D.29242 = *entry;
      if (D.29242 > method_index) goto <D.29246>; else goto <D.29247>;
      <D.29246>:
      high = entry_index;
      goto <D.29248>;
      <D.29247>:
      amodule.192 = amodule;
      D.29249 = amodule.192->info.flags;
      D.29250 = D.29249 & 8;
      if (D.29250 != 0) goto <D.29251>; else goto <D.29252>;
      <D.29251>:
      D.29253 = entry + 4;
      code = get_arm_bl_target (D.29253);
      goto <D.29254>;
      <D.29252>:
      amodule.192 = amodule;
      D.29255 = amodule.192->code;
      D.29253 = entry + 4;
      D.29256 = *D.29253;
      D.29257 = (sizetype) D.29256;
      code = D.29255 + D.29257;
      <D.29254>:
      goto <D.24873>;
      <D.29248>:
      <D.29245>:
      <D.24875>:
      if (low < high) goto <D.24874>; else goto <D.24873>;
      <D.24873>:
      D.29258 = code == 0B;
      D.29259 = (long int) D.29258;
      D.29260 = __builtin_expect (D.29259, 0);
      if (D.29260 != 0) goto <D.29261>; else goto <D.29262>;
      <D.29261>:
      monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "aot-runtime.c", 4596, "code");
      <D.29262>:
      D.29264 = mono_domain_get ();
      D.29263 = mono_create_ftnptr (D.29264, code);
      return D.29263;
    }
  finally
    {
      amodule = {CLOBBER};
    }
}


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

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


mono_aot_get_lazy_fetch_trampoline (guint32 slot)
{
  struct MonoImage * D.29269;
  int count.195;
  int count.196;
  unsigned int D.29272;
  void * addr.197;
  void * addr.198;
  struct MonoDomain * D.29279;
  long unsigned int D.29280;
  void * D.29281;
  void * * D.29282;
  struct MonoDomain * D.29283;
  void * D.29284;
  void * D.29285;
  struct MonoDomain * D.29286;
  int slot.199;
  void * D.29288;
  struct MonoDomain * D.29289;
  char * symbol;
  void * code;
  struct MonoAotModule * amodule;
  guint32 index;
  static int count = 0;

  D.29269 = mono_defaults.corlib;
  amodule = D.29269->aot_module;
  index = slot & 2147483647;
  count.195 = count;
  count.196 = count.195 + 1;
  count = count.196;
  D.29272 = amodule->info.num_rgctx_fetch_trampolines;
  if (D.29272 <= index) goto <D.29273>; else goto <D.29274>;
  <D.29273>:
  {
    static void * addr;
    void * * info;

    addr.197 = addr;
    if (addr.197 == 0B) goto <D.29276>; else goto <D.29277>;
    <D.29276>:
    addr.198 = load_function (amodule, "rgctx_fetch_trampoline_general");
    addr = addr.198;
    <D.29277>:
    D.29279 = mono_get_root_domain ();
    info = mono_domain_alloc0 (D.29279, 16);
    D.29280 = (long unsigned int) slot;
    D.29281 = (void *) D.29280;
    *info = D.29281;
    D.29282 = info + 8;
    D.29283 = mono_get_root_domain ();
    D.29280 = (long unsigned int) slot;
    D.29281 = (void *) D.29280;
    D.29284 = mono_create_specific_trampoline (D.29281, 4, D.29283, 0B);
    *D.29282 = D.29284;
    addr.197 = addr;
    code = mono_aot_get_static_rgctx_trampoline (info, addr.197);
    D.29286 = mono_domain_get ();
    D.29285 = mono_create_ftnptr (D.29286, code);
    return D.29285;
  }
  <D.29274>:
  slot.199 = (int) slot;
  symbol = mono_get_rgctx_fetch_trampoline_name (slot.199);
  D.29269 = mono_defaults.corlib;
  D.29288 = D.29269->aot_module;
  code = load_function (D.29288, symbol);
  monoeg_g_free (symbol);
  D.29289 = mono_domain_get ();
  D.29285 = mono_create_ftnptr (D.29289, code);
  return D.29285;
}


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

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


mono_aot_get_imt_thunk (struct MonoVTable * vtable, struct MonoDomain * domain, struct MonoIMTCheckItem * * imt_entries, int count, void * fail_tramp)
{
  long unsigned int D.29293;
  long unsigned int D.29294;
  struct MonoIMTCheckItem * * D.29295;
  unsigned char D.29296;
  int D.29299;
  int D.29300;
  long unsigned int D.29301;
  unsigned int D.29302;
  unsigned int D.29303;
  unsigned char D.29304;
  void * D.29307;
  _Bool D.29308;
  long int D.29309;
  long int D.29310;
  int D.29313;
  long unsigned int D.29314;
  long unsigned int D.29315;
  void * * D.29316;
  unsigned char D.29317;
  void * D.29320;
  sizetype D.29321;
  sizetype D.29322;
  sizetype D.29323;
  void * * D.29324;
  int D.29326;
  void * * D.29327;
  struct MonoAotModule * amodule.200;
  void * * D.29332;
  unsigned int got_offset.201;
  long unsigned int D.29334;
  long unsigned int D.29335;
  void * * D.29336;
  void * D.29337;
  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.24902>;
      <D.24901>:
      {
        struct MonoIMTCheckItem * item;

        D.29293 = (long unsigned int) i;
        D.29294 = D.29293 * 8;
        D.29295 = imt_entries + D.29294;
        item = *D.29295;
        D.29296 = item->is_equals;
        if (D.29296 != 0) goto <D.29297>; else goto <D.29298>;
        <D.29297>:
        real_count = real_count + 1;
        <D.29298>:
      }
      i = i + 1;
      <D.24902>:
      if (i < count) goto <D.24901>; else goto <D.24903>;
      <D.24903>:
      D.29299 = real_count + 1;
      D.29300 = D.29299 * 2;
      D.29301 = (long unsigned int) D.29300;
      D.29302 = (unsigned int) D.29301;
      D.29303 = D.29302 * 8;
      buf = mono_domain_alloc (domain, D.29303);
      index = 0;
      i = 0;
      goto <D.24908>;
      <D.24907>:
      {
        struct MonoIMTCheckItem * item;

        D.29293 = (long unsigned int) i;
        D.29294 = D.29293 * 8;
        D.29295 = imt_entries + D.29294;
        item = *D.29295;
        D.29304 = item->is_equals;
        if (D.29304 == 0) goto <D.29305>; else goto <D.29306>;
        <D.29305>:
        // predicted unlikely by continue predictor.
        goto <D.24905>;
        <D.29306>:
        D.29307 = item->key;
        D.29308 = D.29307 == 0B;
        D.29309 = (long int) D.29308;
        D.29310 = __builtin_expect (D.29309, 0);
        if (D.29310 != 0) goto <D.29311>; else goto <D.29312>;
        <D.29311>:
        monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "aot-runtime.c", 4661, "item->key");
        <D.29312>:
        D.29313 = index * 2;
        D.29314 = (long unsigned int) D.29313;
        D.29315 = D.29314 * 8;
        D.29316 = buf + D.29315;
        D.29307 = item->key;
        *D.29316 = D.29307;
        D.29317 = item->has_target_code;
        if (D.29317 != 0) goto <D.29318>; else goto <D.29319>;
        <D.29318>:
        {
          void * * p;

          p = mono_domain_alloc (domain, 8);
          D.29320 = item->value.target_code;
          *p = D.29320;
          D.29313 = index * 2;
          D.29321 = (sizetype) D.29313;
          D.29322 = D.29321 + 1;
          D.29323 = D.29322 * 8;
          D.29324 = buf + D.29323;
          *D.29324 = p;
        }
        goto <D.29325>;
        <D.29319>:
        D.29313 = index * 2;
        D.29321 = (sizetype) D.29313;
        D.29322 = D.29321 + 1;
        D.29323 = D.29322 * 8;
        D.29324 = buf + D.29323;
        D.29326 = item->value.vtable_slot;
        D.29327 = &vtable->vtable[D.29326];
        *D.29324 = D.29327;
        <D.29325>:
        index = index + 1;
      }
      <D.24905>:
      i = i + 1;
      <D.24908>:
      if (i < count) goto <D.24907>; else goto <D.24909>;
      <D.24909>:
      D.29313 = index * 2;
      D.29314 = (long unsigned int) D.29313;
      D.29315 = D.29314 * 8;
      D.29316 = buf + D.29315;
      *D.29316 = 0B;
      D.29313 = index * 2;
      D.29321 = (sizetype) D.29313;
      D.29322 = D.29321 + 1;
      D.29323 = D.29322 * 8;
      D.29324 = buf + D.29323;
      *D.29324 = fail_tramp;
      if (0 != 0) goto <D.29328>; else goto <D.29329>;
      <D.29328>:
      code = get_new_imt_trampoline_from_page (buf);
      goto <D.29330>;
      <D.29329>:
      code = get_numerous_trampoline (2, 1, &amodule, &got_offset, 0B);
      amodule.200 = amodule;
      D.29332 = amodule.200->got;
      got_offset.201 = got_offset;
      D.29334 = (long unsigned int) got_offset.201;
      D.29335 = D.29334 * 8;
      D.29336 = D.29332 + D.29335;
      *D.29336 = buf;
      <D.29330>:
      D.29337 = code;
      return D.29337;
    }
  finally
    {
      got_offset = {CLOBBER};
      amodule = {CLOBBER};
    }
}


mono_aot_get_gsharedvt_arg_trampoline (void * arg, void * addr)
{
  struct MonoAotModule * amodule.202;
  void * * D.29344;
  unsigned int got_offset.203;
  long unsigned int D.29346;
  long unsigned int D.29347;
  void * * D.29348;
  unsigned int D.29349;
  long unsigned int D.29350;
  long unsigned int D.29351;
  void * * D.29352;
  void * D.29353;
  struct MonoDomain * D.29354;
  struct MonoAotModule * amodule;
  guint8 * code;
  guint32 got_offset;

  try
    {
      if (0 != 0) goto <D.29340>; else goto <D.29341>;
      <D.29340>:
      code = get_new_gsharedvt_arg_trampoline_from_page (addr, arg);
      goto <D.29342>;
      <D.29341>:
      code = get_numerous_trampoline (3, 2, &amodule, &got_offset, 0B);
      amodule.202 = amodule;
      D.29344 = amodule.202->got;
      got_offset.203 = got_offset;
      D.29346 = (long unsigned int) got_offset.203;
      D.29347 = D.29346 * 8;
      D.29348 = D.29344 + D.29347;
      *D.29348 = arg;
      amodule.202 = amodule;
      D.29344 = amodule.202->got;
      got_offset.203 = got_offset;
      D.29349 = got_offset.203 + 1;
      D.29350 = (long unsigned int) D.29349;
      D.29351 = D.29350 * 8;
      D.29352 = D.29344 + D.29351;
      *D.29352 = addr;
      <D.29342>:
      D.29354 = mono_domain_get ();
      D.29353 = mono_create_ftnptr (D.29354, code);
      return D.29353;
    }
  finally
    {
      amodule = {CLOBBER};
      got_offset = {CLOBBER};
    }
}


mono_aot_set_make_unreadable (gboolean unreadable)
{
  int make_unreadable.204;
  int inited.205;
  static int inited;

  make_unreadable = unreadable;
  make_unreadable.204 = make_unreadable;
  if (make_unreadable.204 != 0) goto <D.29358>; else goto <D.29359>;
  <D.29358>:
  inited.205 = inited;
  if (inited.205 == 0) goto <D.29361>; else goto <D.29362>;
  <D.29361>:
  mono_counters_register ("AOT pagefaults", 256, &n_pagefaults);
  <D.29362>:
  <D.29359>:
}


mono_aot_is_pagefault (void * ptr)
{
  int make_unreadable.206;
  gboolean D.29366;
  struct MonoAotModule * D.29367;
  _Bool D.29368;

  make_unreadable.206 = make_unreadable;
  if (make_unreadable.206 == 0) goto <D.29364>; else goto <D.29365>;
  <D.29364>:
  D.29366 = 0;
  return D.29366;
  <D.29365>:
  D.29367 = find_module_for_addr (ptr);
  D.29368 = D.29367 != 0B;
  D.29366 = (gboolean) D.29368;
  return D.29366;
}


find_module_for_addr (void * ptr)
{
  int make_unreadable.207;
  struct MonoAotModule * D.29373;
  _Bool D.29376;
  long int D.29377;
  long int D.29378;
  struct GHashTable * aot_modules.208;
  _Bool D.29384;
  long int D.29385;
  long int D.29386;
  struct FindMapUserData data;

  try
    {
      make_unreadable.207 = make_unreadable;
      if (make_unreadable.207 == 0) goto <D.29371>; else goto <D.29372>;
      <D.29371>:
      D.29373 = 0B;
      return D.29373;
      <D.29372>:
      data.module = 0B;
      data.ptr = ptr;
      {
        int ret;

        ret = pthread_mutex_lock (&aot_mutex.mutex);
        if (ret != 0) goto <D.29374>; else goto <D.29375>;
        <D.29374>:
        monoeg_g_log (0B, 16, "Bad call to mono_mutex_lock result %d", ret);
        <D.29375>:
        D.29376 = ret != 0;
        D.29377 = (long int) D.29376;
        D.29378 = __builtin_expect (D.29377, 0);
        if (D.29378 != 0) goto <D.29379>; else goto <D.29380>;
        <D.29379>:
        monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "aot-runtime.c", 4752, "ret == 0");
        <D.29380>:
      }
      aot_modules.208 = aot_modules;
      monoeg_g_hash_table_foreach (aot_modules.208, find_map, &data);
      {
        int ret;

        ret = pthread_mutex_unlock (&aot_mutex.mutex);
        if (ret != 0) goto <D.29382>; else goto <D.29383>;
        <D.29382>:
        monoeg_g_log (0B, 16, "Bad call to mono_mutex_unlock result %d", ret);
        <D.29383>:
        D.29384 = ret != 0;
        D.29385 = (long int) D.29384;
        D.29386 = __builtin_expect (D.29385, 0);
        if (D.29386 != 0) goto <D.29387>; else goto <D.29388>;
        <D.29387>:
        monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "aot-runtime.c", 4754, "ret == 0");
        <D.29388>:
      }
      D.29373 = data.module;
      return D.29373;
    }
  finally
    {
      data = {CLOBBER};
    }
}


find_map (void * key, void * value, void * user_data)
{
  struct MonoAotModule * D.29391;
  guint8 * D.29394;
  guint8 * D.29395;
  guint8 * D.29398;
  struct MonoAotModule * module;
  struct FindMapUserData * data;

  module = value;
  data = user_data;
  D.29391 = data->module;
  if (D.29391 == 0B) goto <D.29392>; else goto <D.29393>;
  <D.29392>:
  D.29394 = data->ptr;
  D.29395 = module->mem_begin;
  if (D.29394 >= D.29395) goto <D.29396>; else goto <D.29397>;
  <D.29396>:
  D.29394 = data->ptr;
  D.29398 = module->mem_end;
  if (D.29394 < D.29398) goto <D.29399>; else goto <D.29400>;
  <D.29399>:
  data->module = module;
  <D.29400>:
  <D.29397>:
  <D.29393>:
}


mono_aot_handle_pagefault (void * ptr)
{
  int D.29401;
  int D.29402;
  long int D.29403;
  long int ptr.209;
  long int D.29405;
  _Bool D.29408;
  long int D.29409;
  long int D.29410;
  int D.29413;
  long unsigned int D.29414;
  _Bool D.29415;
  long int D.29416;
  long int D.29417;
  unsigned int n_pagefaults.210;
  unsigned int n_pagefaults.211;
  _Bool D.29424;
  long int D.29425;
  long int D.29426;
  guint8 * start;
  int res;

  D.29401 = mono_pagesize ();
  D.29402 = -D.29401;
  D.29403 = (long int) D.29402;
  ptr.209 = (long int) ptr;
  D.29405 = D.29403 & ptr.209;
  start = (guint8 *) D.29405;
  {
    int ret;

    ret = pthread_mutex_lock (&aot_mutex.mutex);
    if (ret != 0) goto <D.29406>; else goto <D.29407>;
    <D.29406>:
    monoeg_g_log (0B, 16, "Bad call to mono_mutex_lock result %d", ret);
    <D.29407>:
    D.29408 = ret != 0;
    D.29409 = (long int) D.29408;
    D.29410 = __builtin_expect (D.29409, 0);
    if (D.29410 != 0) goto <D.29411>; else goto <D.29412>;
    <D.29411>:
    monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "aot-runtime.c", 4790, "ret == 0");
    <D.29412>:
  }
  D.29413 = mono_pagesize ();
  D.29414 = (long unsigned int) D.29413;
  res = mono_mprotect (start, D.29414, 7);
  D.29415 = res != 0;
  D.29416 = (long int) D.29415;
  D.29417 = __builtin_expect (D.29416, 0);
  if (D.29417 != 0) goto <D.29418>; else goto <D.29419>;
  <D.29418>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "aot-runtime.c", 4792, "res == 0");
  <D.29419>:
  n_pagefaults.210 = n_pagefaults;
  n_pagefaults.211 = n_pagefaults.210 + 1;
  n_pagefaults = n_pagefaults.211;
  {
    int ret;

    ret = pthread_mutex_unlock (&aot_mutex.mutex);
    if (ret != 0) goto <D.29422>; else goto <D.29423>;
    <D.29422>:
    monoeg_g_log (0B, 16, "Bad call to mono_mutex_unlock result %d", ret);
    <D.29423>:
    D.29424 = ret != 0;
    D.29425 = (long int) D.29424;
    D.29426 = __builtin_expect (D.29425, 0);
    if (D.29426 != 0) goto <D.29427>; else goto <D.29428>;
    <D.29427>:
    monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "aot-runtime.c", 4795, "ret == 0");
    <D.29428>:
  }
}