__attribute__((visibility ("hidden")))
mono_aot_readonly_field_override (struct MonoClassField * field)
{
  struct MonoClass * D.25834;
  const char * D.25835;
  long unsigned int D.25836;
  long unsigned int D.25837;
  int D.25838;
  sizetype D.25841;
  char * p.0;
  char D.25843;
  const char * D.25846;
  long unsigned int D.25847;
  int D.25848;
  char * p.1;
  char D.25852;
  const char * D.25855;
  int D.25856;
  int D.25859;
  void * D.25860;
  struct ReadOnlyValue * rdv;

  rdv = readonly_values;
  goto <D.25170>;
  <D.25169>:
  {
    char * p;
    int len;

    p = rdv->name;
    D.25834 = field->parent;
    D.25835 = D.25834->name_space;
    D.25836 = __strlen_g (D.25835);
    len = (int) D.25836;
    D.25834 = field->parent;
    D.25835 = D.25834->name_space;
    D.25837 = (long unsigned int) len;
    D.25838 = strncmp (p, D.25835, D.25837);
    if (D.25838 != 0) goto <D.25839>; else goto <D.25840>;
    <D.25839>:
    // predicted unlikely by continue predictor.
    goto <D.25163>;
    <D.25840>:
    D.25841 = (sizetype) len;
    p = p + D.25841;
    p.0 = p;
    p = p.0 + 1;
    D.25843 = *p.0;
    if (D.25843 != 46) goto <D.25844>; else goto <D.25845>;
    <D.25844>:
    // predicted unlikely by continue predictor.
    goto <D.25163>;
    <D.25845>:
    D.25834 = field->parent;
    D.25846 = D.25834->name;
    D.25847 = __strlen_g (D.25846);
    len = (int) D.25847;
    D.25834 = field->parent;
    D.25846 = D.25834->name;
    D.25837 = (long unsigned int) len;
    D.25848 = strncmp (p, D.25846, D.25837);
    if (D.25848 != 0) goto <D.25849>; else goto <D.25850>;
    <D.25849>:
    // predicted unlikely by continue predictor.
    goto <D.25163>;
    <D.25850>:
    D.25841 = (sizetype) len;
    p = p + D.25841;
    p.1 = p;
    p = p.1 + 1;
    D.25852 = *p.1;
    if (D.25852 != 46) goto <D.25853>; else goto <D.25854>;
    <D.25853>:
    // predicted unlikely by continue predictor.
    goto <D.25163>;
    <D.25854>:
    D.25855 = field->name;
    D.25856 = strcmp (p, D.25855);
    if (D.25856 != 0) goto <D.25857>; else goto <D.25858>;
    <D.25857>:
    // predicted unlikely by continue predictor.
    goto <D.25163>;
    <D.25858>:
    D.25859 = rdv->type;
    switch (D.25859) <default: <D.25167>, case 4: <D.25164>, case 6: <D.25165>, case 8: <D.25166>>
    <D.25164>:
    D.25860 = &rdv->value.i1;
    return D.25860;
    <D.25165>:
    D.25860 = &rdv->value.i2;
    return D.25860;
    <D.25166>:
    D.25860 = &rdv->value.i4;
    return D.25860;
    <D.25167>:
    goto <D.25168>;
    <D.25168>:
  }
  <D.25163>:
  rdv = rdv->next;
  <D.25170>:
  if (rdv != 0B) goto <D.25169>; else goto <D.25171>;
  <D.25171>:
  D.25860 = 0B;
  return D.25860;
}


__attribute__((__gnu_inline__))
__strlen_g (const char * __str)
{
  size_t D.25863;
  long int __ptr.2;
  long int __str.3;
  long int D.25866;
  char * __ptr;
  char * __tmp;

  __ptr = 0B;
  __tmp = __str;
  __asm__ __volatile__("   la    0,0
0: srst  %0,%1
   jo    0b
" : "=&a" __ptr, "=&a" __tmp : "0" __ptr, "1" __tmp : "0", "memory", "cc");
  __ptr.2 = (long int) __ptr;
  __str.3 = (long int) __str;
  D.25866 = __ptr.2 - __str.3;
  D.25863 = (size_t) D.25866;
  return D.25863;
}


__attribute__((__gnu_inline__, nothrow, leaf, pure))
strcmp (const char * __s1, const char * __s2)
{
  int iftmp.4;
  int iftmp.5;
  int D.25876;
  char * __p1;
  char * __p2;
  int __ret;

  __p1 = __s1;
  __p2 = __s2;
  __asm__ __volatile__("   slr   0,0
0: clst  %1,%2
   jo    0b
   ipm   %0
   srl   %0,28" : "=d" __ret, "=&a" __p1, "=&a" __p2 : "1" __p1, "2" __p2 : "0", "memory", "cc");
  if (__ret != 0) goto <D.25869>; else goto <D.25870>;
  <D.25869>:
  if (__ret == 1) goto <D.25872>; else goto <D.25873>;
  <D.25872>:
  iftmp.5 = -1;
  goto <D.25874>;
  <D.25873>:
  iftmp.5 = 1;
  <D.25874>:
  iftmp.4 = iftmp.5;
  goto <D.25875>;
  <D.25870>:
  iftmp.4 = 0;
  <D.25875>:
  __ret = iftmp.4;
  D.25876 = __ret;
  return D.25876;
}


__attribute__((visibility ("hidden")))
mono_aot_get_got_offset (struct MonoJumpInfo * ji)
{
  guint32 D.25878;
  struct MonoAotCompile * llvm_acfg.6;

  llvm_acfg.6 = llvm_acfg;
  D.25878 = get_got_offset (llvm_acfg.6, ji);
  return D.25878;
}


get_got_offset (struct MonoAotCompile * acfg, struct MonoJumpInfo * ji)
{
  struct GHashTable * * D.25881;
  <unnamed type> D.25882;
  long unsigned int D.25883;
  long unsigned int D.25884;
  struct GHashTable * * D.25885;
  struct GHashTable * D.25886;
  void * D.25887;
  long int D.25888;
  guint32 D.25891;
  unsigned int D.25892;
  unsigned int D.25893;
  unsigned int D.25894;
  _Bool D.25897;
  long int D.25898;
  long int D.25899;
  int D.25902;
  int D.25903;
  int D.25904;
  int D.25905;
  struct GHashTable * D.25906;
  unsigned int D.25907;
  long unsigned int D.25908;
  void * D.25909;
  struct GPtrArray * D.25910;
  guint32 got_offset;

  D.25881 = acfg->patch_to_got_offset_by_type;
  D.25882 = ji->type;
  D.25883 = (long unsigned int) D.25882;
  D.25884 = D.25883 * 8;
  D.25885 = D.25881 + D.25884;
  D.25886 = *D.25885;
  D.25887 = monoeg_g_hash_table_lookup (D.25886, ji);
  D.25888 = (long int) D.25887;
  got_offset = (guint32) D.25888;
  if (got_offset != 0) goto <D.25889>; else goto <D.25890>;
  <D.25889>:
  D.25891 = got_offset + 4294967295;
  return D.25891;
  <D.25890>:
  got_offset = acfg->got_offset;
  D.25892 = acfg->got_offset;
  D.25893 = D.25892 + 1;
  acfg->got_offset = D.25893;
  D.25894 = acfg->final_got_size;
  if (D.25894 != 0) goto <D.25895>; else goto <D.25896>;
  <D.25895>:
  D.25894 = acfg->final_got_size;
  D.25897 = D.25894 <= got_offset;
  D.25898 = (long int) D.25897;
  D.25899 = __builtin_expect (D.25898, 0);
  if (D.25899 != 0) goto <D.25900>; else goto <D.25901>;
  <D.25900>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "aot-compiler.c", 2978, "got_offset < acfg->final_got_size");
  <D.25901>:
  <D.25896>:
  D.25902 = acfg->stats.got_slots;
  D.25903 = D.25902 + 1;
  acfg->stats.got_slots = D.25903;
  D.25882 = ji->type;
  D.25904 = acfg->stats.got_slot_types[D.25882];
  D.25905 = D.25904 + 1;
  acfg->stats.got_slot_types[D.25882] = D.25905;
  D.25906 = acfg->patch_to_got_offset;
  D.25907 = got_offset + 1;
  D.25908 = (long unsigned int) D.25907;
  D.25909 = (void *) D.25908;
  monoeg_g_hash_table_insert_replace (D.25906, ji, D.25909, 0);
  D.25881 = acfg->patch_to_got_offset_by_type;
  D.25882 = ji->type;
  D.25883 = (long unsigned int) D.25882;
  D.25884 = D.25883 * 8;
  D.25885 = D.25881 + D.25884;
  D.25886 = *D.25885;
  D.25907 = got_offset + 1;
  D.25908 = (long unsigned int) D.25907;
  D.25909 = (void *) D.25908;
  monoeg_g_hash_table_insert_replace (D.25886, ji, D.25909, 0);
  D.25910 = acfg->got_patches;
  monoeg_g_ptr_array_add (D.25910, ji);
  D.25891 = got_offset;
  return D.25891;
}


__attribute__((visibility ("hidden")))
mono_aot_get_method_name (struct MonoCompile * cfg)
{
  struct MonoAotCompile * llvm_acfg.7;
  int D.25913;
  char * D.25916;
  char * D.25917;
  struct MonoMethod * D.25918;
  struct GHashTable * D.25919;
  char * D.25920;

  llvm_acfg.7 = llvm_acfg;
  D.25913 = llvm_acfg.7->aot_opts.static_link;
  if (D.25913 != 0) goto <D.25914>; else goto <D.25915>;
  <D.25914>:
  llvm_acfg.7 = llvm_acfg;
  D.25917 = llvm_acfg.7->assembly_name_sym;
  D.25918 = cfg->orig_method;
  llvm_acfg.7 = llvm_acfg;
  D.25919 = llvm_acfg.7->method_label_hash;
  D.25920 = get_debug_sym (D.25918, "", D.25919);
  D.25916 = monoeg_g_strdup_printf ("%s_%s", D.25917, D.25920);
  return D.25916;
  <D.25915>:
  D.25918 = cfg->orig_method;
  llvm_acfg.7 = llvm_acfg;
  D.25919 = llvm_acfg.7->method_label_hash;
  D.25916 = get_debug_sym (D.25918, "", D.25919);
  return D.25916;
}


get_debug_sym (struct MonoMethod * method, const char * prefix, struct GHashTable * cache)
{
  long unsigned int D.25922;
  long unsigned int D.25923;
  long unsigned int D.25924;
  long unsigned int D.25925;
  long unsigned int D.25926;
  long unsigned int D.25927;
  long unsigned int D.25928;
  const short unsigned int * * D.25929;
  const short unsigned int * D.25930;
  sizetype D.25931;
  char * D.25932;
  char D.25933;
  long unsigned int D.25934;
  long unsigned int D.25935;
  const short unsigned int * D.25936;
  short unsigned int D.25937;
  int D.25938;
  int D.25939;
  int j.8;
  sizetype D.25943;
  char * D.25944;
  sizetype D.25949;
  char * D.25950;
  char D.25951;
  sizetype D.25953;
  char * D.25954;
  char D.25955;
  int j.9;
  sizetype D.25962;
  char * D.25963;
  char D.25964;
  int j.10;
  sizetype D.25971;
  char * D.25972;
  sizetype D.25973;
  char * D.25974;
  void * D.25975;
  char * D.25976;
  char * name1;
  char * name2;
  char * cached;
  int i;
  int j;
  int len;
  int count;

  name1 = mono_method_full_name (method, 1);
  D.25922 = __strlen_g (name1);
  len = (int) D.25922;
  D.25923 = __strlen_g (prefix);
  D.25924 = (long unsigned int) len;
  D.25925 = D.25923 + D.25924;
  D.25926 = D.25925 + 16;
  name2 = malloc (D.25926);
  D.25927 = __strlen_g (prefix);
  memcpy (name2, prefix, D.25927);
  D.25928 = __strlen_g (prefix);
  j = (int) D.25928;
  i = 0;
  goto <D.24812>;
  <D.24811>:
  D.25929 = __ctype_b_loc ();
  D.25930 = *D.25929;
  D.25931 = (sizetype) i;
  D.25932 = name1 + D.25931;
  D.25933 = *D.25932;
  D.25934 = (long unsigned int) D.25933;
  D.25935 = D.25934 * 2;
  D.25936 = D.25930 + D.25935;
  D.25937 = *D.25936;
  D.25938 = (int) D.25937;
  D.25939 = D.25938 & 2048;
  if (D.25939 != 0) goto <D.25940>; else goto <D.25941>;
  <D.25940>:
  j.8 = j;
  j = j.8 + 1;
  D.25943 = (sizetype) j.8;
  D.25944 = name2 + D.25943;
  D.25931 = (sizetype) i;
  D.25932 = name1 + D.25931;
  D.25933 = *D.25932;
  *D.25944 = D.25933;
  goto <D.25945>;
  <D.25941>:
  D.25931 = (sizetype) i;
  D.25932 = name1 + D.25931;
  D.25933 = *D.25932;
  if (D.25933 == 32) goto <D.25948>; else goto <D.25946>;
  <D.25948>:
  D.25931 = (sizetype) i;
  D.25949 = D.25931 + 1;
  D.25950 = name1 + D.25949;
  D.25951 = *D.25950;
  if (D.25951 == 40) goto <D.25952>; else goto <D.25946>;
  <D.25952>:
  D.25931 = (sizetype) i;
  D.25953 = D.25931 + 2;
  D.25954 = name1 + D.25953;
  D.25955 = *D.25954;
  if (D.25955 == 41) goto <D.25956>; else goto <D.25946>;
  <D.25956>:
  i = i + 2;
  goto <D.25947>;
  <D.25946>:
  D.25931 = (sizetype) i;
  D.25932 = name1 + D.25931;
  D.25933 = *D.25932;
  if (D.25933 == 44) goto <D.25959>; else goto <D.25957>;
  <D.25959>:
  D.25931 = (sizetype) i;
  D.25949 = D.25931 + 1;
  D.25950 = name1 + D.25949;
  D.25951 = *D.25950;
  if (D.25951 == 32) goto <D.25960>; else goto <D.25957>;
  <D.25960>:
  j.9 = j;
  j = j.9 + 1;
  D.25962 = (sizetype) j.9;
  D.25963 = name2 + D.25962;
  *D.25963 = 95;
  i = i + 1;
  goto <D.25958>;
  <D.25957>:
  D.25931 = (sizetype) i;
  D.25932 = name1 + D.25931;
  D.25933 = *D.25932;
  D.25964 = D.25933 + 216;
  if (D.25964 <= 1) goto <D.25965>; else goto <D.25966>;
  <D.25966>:
  D.25931 = (sizetype) i;
  D.25932 = name1 + D.25931;
  D.25933 = *D.25932;
  if (D.25933 == 62) goto <D.25967>; else goto <D.25968>;
  <D.25967>:
  goto <D.25969>;
  <D.25968>:
  j.10 = j;
  j = j.10 + 1;
  D.25971 = (sizetype) j.10;
  D.25972 = name2 + D.25971;
  *D.25972 = 95;
  <D.25969>:
  <D.25965>:
  <D.25958>:
  <D.25947>:
  <D.25945>:
  i = i + 1;
  <D.24812>:
  if (i < len) goto <D.24811>; else goto <D.24813>;
  <D.24813>:
  D.25973 = (sizetype) j;
  D.25974 = name2 + D.25973;
  *D.25974 = 0;
  monoeg_g_free (name1);
  count = 0;
  goto <D.24815>;
  <D.24814>:
  D.25973 = (sizetype) j;
  D.25974 = name2 + D.25973;
  sprintf (D.25974, "_%d", count);
  count = count + 1;
  <D.24815>:
  D.25975 = monoeg_g_hash_table_lookup (cache, name2);
  if (D.25975 != 0B) goto <D.24814>; else goto <D.24816>;
  <D.24816>:
  cached = monoeg_strdup (name2);
  monoeg_g_hash_table_insert_replace (cache, cached, cached, 0);
  D.25976 = name2;
  return D.25976;
}


__attribute__((__artificial__, __gnu_inline__, __always_inline__, __nothrow__, __leaf__))
memcpy (void * restrict __dest, const void * restrict __src, size_t __len)
{
  void * D.25978;
  long unsigned int D.25979;

  D.25979 = __builtin_object_size (__dest, 0);
  D.25978 = __builtin___memcpy_chk (__dest, __src, __len, D.25979);
  return D.25978;
}


__attribute__((__artificial__, __gnu_inline__, __always_inline__, __leaf__, __nothrow__))
sprintf (char * restrict __s, const char * restrict __fmt)
{
  int D.25981;
  long unsigned int D.25982;

  D.25982 = __builtin_object_size (__s, 1);
  D.25981 = __builtin___sprintf_chk (__s, 1, D.25982, __fmt, __builtin_va_arg_pack ());
  return D.25981;
}


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

  if (str != 0B) goto <D.25984>; else goto <D.25985>;
  <D.25984>:
  D.25986 = __strdup (str);
  return D.25986;
  <D.25985>:
  D.25986 = 0B;
  return D.25986;
}


__attribute__((visibility ("hidden")))
mono_aot_get_plt_symbol (MonoJumpInfoType type, const void * data)
{
  struct MonoAotCompile * llvm_acfg.11;
  struct MonoMemPool * D.25989;
  int D.25990;
  char * D.25993;
  char * D.25994;
  struct MonoJumpInfo * ji;
  struct MonoPltEntry * plt_entry;

  llvm_acfg.11 = llvm_acfg;
  D.25989 = llvm_acfg.11->mempool;
  ji = mono_mempool_alloc (D.25989, 40);
  ji->type = type;
  ji->data.target = data;
  llvm_acfg.11 = llvm_acfg;
  D.25990 = can_encode_patch (llvm_acfg.11, ji);
  if (D.25990 == 0) goto <D.25991>; else goto <D.25992>;
  <D.25991>:
  D.25993 = 0B;
  return D.25993;
  <D.25992>:
  llvm_acfg.11 = llvm_acfg;
  plt_entry = get_plt_entry (llvm_acfg.11, ji);
  plt_entry->llvm_used = 1;
  D.25994 = plt_entry->llvm_symbol;
  D.25993 = monoeg_g_strdup_printf (D.25994);
  return D.25993;
}


can_encode_patch (struct MonoAotCompile * acfg, struct MonoJumpInfo * patch_info)
{
  <unnamed type> D.25996;
  gboolean D.25997;
  struct MonoClass * D.25998;
  int D.25999;
  struct MonoMethod * D.26002;
  int D.26003;
  struct MonoJumpInfo * D.26006;
  int D.26007;

  D.25996 = patch_info->type;
  switch (D.25996) <default: <D.25247>, case 3: <D.25234>, case 6: <D.25235>, case 11: <D.25241>, case 14: <D.25238>, case 15: <D.25239>, case 23: <D.25242>, case 24: <D.25243>, case 30: <D.25240>, case 35: <D.25245>, case 50: <D.25236>>
  <D.25234>:
  <D.25235>:
  <D.25236>:
  {
    struct MonoMethod * method;

    method = patch_info->data.method;
    D.25997 = can_encode_method (acfg, method);
    return D.25997;
  }
  <D.25238>:
  <D.25239>:
  <D.25240>:
  <D.25241>:
  <D.25242>:
  <D.25243>:
  D.25998 = patch_info->data.klass;
  D.25999 = can_encode_class (acfg, D.25998);
  if (D.25999 == 0) goto <D.26000>; else goto <D.26001>;
  <D.26000>:
  D.25997 = 0;
  return D.25997;
  <D.26001>:
  goto <D.25244>;
  <D.25245>:
  {
    struct MonoJumpInfoRgctxEntry * entry;

    entry = patch_info->data.rgctx_entry;
    D.26002 = entry->method;
    D.26003 = can_encode_method (acfg, D.26002);
    if (D.26003 == 0) goto <D.26004>; else goto <D.26005>;
    <D.26004>:
    D.25997 = 0;
    return D.25997;
    <D.26005>:
    D.26006 = entry->data;
    D.26007 = can_encode_patch (acfg, D.26006);
    if (D.26007 == 0) goto <D.26008>; else goto <D.26009>;
    <D.26008>:
    D.25997 = 0;
    return D.25997;
    <D.26009>:
    goto <D.25244>;
  }
  <D.25247>:
  goto <D.25244>;
  <D.25244>:
  D.25997 = 1;
  return D.25997;
}


can_encode_class (struct MonoAotCompile * acfg, struct MonoClass * klass)
{
  unsigned int D.26012;
  gboolean D.26015;
  unsigned char D.26018;
  unsigned char D.26021;
  struct MonoClass * D.26024;

  D.26012 = klass->type_token;
  if (D.26012 != 0) goto <D.26013>; else goto <D.26014>;
  <D.26013>:
  D.26015 = 1;
  return D.26015;
  <D.26014>:
  D.26018 = klass->byval_arg.type;
  if (D.26018 == 19) goto <D.26016>; else goto <D.26019>;
  <D.26019>:
  D.26018 = klass->byval_arg.type;
  if (D.26018 == 30) goto <D.26016>; else goto <D.26020>;
  <D.26020>:
  D.26018 = klass->byval_arg.type;
  if (D.26018 == 15) goto <D.26016>; else goto <D.26017>;
  <D.26016>:
  D.26015 = 1;
  return D.26015;
  <D.26017>:
  D.26021 = klass->rank;
  if (D.26021 != 0) goto <D.26022>; else goto <D.26023>;
  <D.26022>:
  D.26024 = klass->element_class;
  D.26015 = can_encode_class (acfg, D.26024);
  return D.26015;
  <D.26023>:
  D.26015 = 0;
  return D.26015;
}


can_encode_method (struct MonoAotCompile * acfg, struct MonoMethod * method)
{
  long unsigned int D.26026;
  long unsigned int D.26027;
  <unnamed-unsigned:5> D.26030;
  int D.26031;
  gboolean D.26034;
  unsigned int D.26036;
  struct GHashTable * D.26039;
  void * D.26040;
  struct MonoClass * D.26043;
  unsigned char D.26044;

  D.26026 = BIT_FIELD_REF <*method, 64, 256>;
  D.26027 = D.26026 & 4467570830351532032;
  if (D.26027 != 0) goto <D.26028>; else goto <D.26029>;
  <D.26028>:
  D.26030 = method->wrapper_type;
  D.26031 = (int) D.26030;
  switch (D.26031) <default: <D.25229>, case 0: <D.25206>, case 1: <D.25221>, case 2: <D.25222>, case 3: <D.25223>, case 7: <D.25226>, case 8: <D.25218>, case 9: <D.25207>, case 10: <D.25208>, case 12: <D.25210>, case 13: <D.25209>, case 14: <D.25212>, case 15: <D.25213>, case 16: <D.25224>, case 18: <D.25215>, case 19: <D.25227>, case 20: <D.25216>, case 21: <D.25214>, case 23: <D.25211>, case 24: <D.25220>, case 25: <D.25219>, case 28: <D.25217>>
  <D.25206>:
  <D.25207>:
  <D.25208>:
  <D.25209>:
  <D.25210>:
  <D.25211>:
  <D.25212>:
  <D.25213>:
  <D.25214>:
  <D.25215>:
  <D.25216>:
  <D.25217>:
  <D.25218>:
  <D.25219>:
  <D.25220>:
  <D.25221>:
  <D.25222>:
  <D.25223>:
  <D.25224>:
  goto <D.25225>;
  <D.25226>:
  <D.25227>:
  {
    struct WrapperInfo * info;

    info = mono_marshal_get_wrapper_info (method);
    if (info != 0B) goto <D.26032>; else goto <D.26033>;
    <D.26032>:
    D.26034 = 1;
    return D.26034;
    <D.26033>:
    D.26034 = 0;
    return D.26034;
  }
  <D.25229>:
  D.26034 = 0;
  return D.26034;
  <D.25225>:
  goto <D.26035>;
  <D.26029>:
  D.26036 = method->token;
  if (D.26036 == 0) goto <D.26037>; else goto <D.26038>;
  <D.26037>:
  D.26039 = acfg->token_info_hash;
  D.26040 = monoeg_g_hash_table_lookup (D.26039, method);
  if (D.26040 == 0B) goto <D.26041>; else goto <D.26042>;
  <D.26041>:
  D.26043 = method->klass;
  D.26044 = D.26043->rank;
  if (D.26044 != 0) goto <D.26045>; else goto <D.26046>;
  <D.26045>:
  D.26034 = 1;
  return D.26034;
  <D.26046>:
  D.26034 = 0;
  return D.26034;
  <D.26042>:
  <D.26038>:
  <D.26035>:
  D.26034 = 1;
  return D.26034;
}


get_plt_entry (struct MonoAotCompile * acfg, struct MonoJumpInfo * patch_info)
{
  int D.26050;
  struct MonoPltEntry * D.26053;
  struct GHashTable * * D.26054;
  <unnamed type> D.26055;
  long unsigned int D.26056;
  long unsigned int D.26057;
  struct GHashTable * * D.26058;
  struct GHashTable * D.26059;
  struct GHashTable * D.26062;
  int D.26063;
  struct MonoMethod * D.26068;
  short unsigned int D.26069;
  int D.26070;
  int D.26071;
  unsigned int D.26076;
  _Bool D.26077;
  long int D.26078;
  long int D.26079;
  struct MonoMemPool * D.26082;
  unsigned int D.26083;
  int D.26084;
  int D.26085;
  char * D.26086;
  int D.26087;
  struct MonoJumpInfo * D.26090;
  struct GHashTable * D.26091;
  char * D.26092;
  char * D.26093;
  char * D.26096;
  gchar * D.26097;
  gchar * D.26099;
  <unnamed type> D.26100;
  long unsigned int D.26101;
  long unsigned int D.26102;
  struct GHashTable * * D.26103;
  struct GHashTable * D.26104;
  struct GHashTable * D.26105;
  long unsigned int D.26106;
  void * D.26107;
  unsigned int D.26108;
  struct MonoPltEntry * res;

  D.26050 = is_plt_patch (patch_info);
  if (D.26050 == 0) goto <D.26051>; else goto <D.26052>;
  <D.26051>:
  D.26053 = 0B;
  return D.26053;
  <D.26052>:
  D.26054 = acfg->patch_to_plt_entry;
  D.26055 = patch_info->type;
  D.26056 = (long unsigned int) D.26055;
  D.26057 = D.26056 * 8;
  D.26058 = D.26054 + D.26057;
  D.26059 = *D.26058;
  if (D.26059 == 0B) goto <D.26060>; else goto <D.26061>;
  <D.26060>:
  D.26054 = acfg->patch_to_plt_entry;
  D.26055 = patch_info->type;
  D.26056 = (long unsigned int) D.26055;
  D.26057 = D.26056 * 8;
  D.26058 = D.26054 + D.26057;
  D.26062 = monoeg_g_hash_table_new (mono_patch_info_hash, mono_patch_info_equal);
  *D.26058 = D.26062;
  <D.26061>:
  D.26054 = acfg->patch_to_plt_entry;
  D.26055 = patch_info->type;
  D.26056 = (long unsigned int) D.26055;
  D.26057 = D.26056 * 8;
  D.26058 = D.26054 + D.26057;
  D.26059 = *D.26058;
  res = monoeg_g_hash_table_lookup (D.26059, patch_info);
  D.26063 = acfg->llvm;
  if (D.26063 == 0) goto <D.26064>; else goto <D.26065>;
  <D.26064>:
  D.26055 = patch_info->type;
  if (D.26055 == 3) goto <D.26066>; else goto <D.26067>;
  <D.26066>:
  D.26068 = patch_info->data.method;
  D.26069 = D.26068->iflags;
  D.26070 = (int) D.26069;
  D.26071 = D.26070 & 32;
  if (D.26071 != 0) goto <D.26072>; else goto <D.26073>;
  <D.26072>:
  res = 0B;
  <D.26073>:
  <D.26067>:
  <D.26065>:
  if (res == 0B) goto <D.26074>; else goto <D.26075>;
  <D.26074>:
  {
    struct MonoJumpInfo * new_ji;

    D.26076 = acfg->final_got_size;
    D.26077 = D.26076 != 0;
    D.26078 = (long int) D.26077;
    D.26079 = __builtin_expect (D.26078, 0);
    if (D.26079 != 0) goto <D.26080>; else goto <D.26081>;
    <D.26080>:
    monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "aot-compiler.c", 2930, "!acfg->final_got_size");
    <D.26081>:
    D.26082 = acfg->mempool;
    new_ji = mono_patch_info_dup_mp (D.26082, patch_info);
    D.26082 = acfg->mempool;
    res = mono_mempool_alloc0 (D.26082, 48);
    D.26083 = acfg->plt_offset;
    D.26084 = (int) D.26083;
    res->plt_offset = D.26084;
    res->ji = new_ji;
    D.26085 = res->plt_offset;
    D.26086 = get_plt_symbol (acfg, D.26085, patch_info);
    res->symbol = D.26086;
    D.26087 = acfg->aot_opts.write_symbols;
    if (D.26087 != 0) goto <D.26088>; else goto <D.26089>;
    <D.26088>:
    D.26090 = res->ji;
    D.26091 = acfg->plt_entry_debug_sym_cache;
    D.26092 = get_plt_entry_debug_sym (acfg, D.26090, D.26091);
    res->debug_sym = D.26092;
    <D.26089>:
    D.26093 = res->debug_sym;
    if (D.26093 != 0B) goto <D.26094>; else goto <D.26095>;
    <D.26094>:
    D.26096 = res->symbol;
    D.26093 = res->debug_sym;
    D.26097 = monoeg_g_strdup_printf ("%s_%s_llvm", D.26096, D.26093);
    res->llvm_symbol = D.26097;
    goto <D.26098>;
    <D.26095>:
    D.26096 = res->symbol;
    D.26099 = monoeg_g_strdup_printf ("%s_llvm", D.26096);
    res->llvm_symbol = D.26099;
    <D.26098>:
    D.26054 = acfg->patch_to_plt_entry;
    D.26100 = new_ji->type;
    D.26101 = (long unsigned int) D.26100;
    D.26102 = D.26101 * 8;
    D.26103 = D.26054 + D.26102;
    D.26104 = *D.26103;
    monoeg_g_hash_table_insert_replace (D.26104, new_ji, res, 0);
    D.26105 = acfg->plt_offset_to_entry;
    D.26085 = res->plt_offset;
    D.26106 = (long unsigned int) D.26085;
    D.26107 = (void *) D.26106;
    monoeg_g_hash_table_insert_replace (D.26105, D.26107, res, 0);
    D.26083 = acfg->plt_offset;
    D.26108 = D.26083 + 1;
    acfg->plt_offset = D.26108;
  }
  <D.26075>:
  D.26053 = res;
  return D.26053;
}


is_plt_patch (struct MonoJumpInfo * patch_info)
{
  <unnamed type> D.26110;
  gboolean D.26111;

  D.26110 = patch_info->type;
  switch (D.26110) <default: <D.24301>, case 3: <D.24291>, case 7: <D.24292>, case 15: <D.24295>, case 31: <D.24294>, case 32: <D.24293>, case 35: <D.24296>, case 36: <D.24297>, case 37: <D.24298>, case 38: <D.24299>, case 41: <D.24300>>
  <D.24291>:
  <D.24292>:
  <D.24293>:
  <D.24294>:
  <D.24295>:
  <D.24296>:
  <D.24297>:
  <D.24298>:
  <D.24299>:
  <D.24300>:
  D.26111 = 1;
  return D.26111;
  <D.24301>:
  D.26111 = 0;
  return D.26111;
}


get_plt_symbol (struct MonoAotCompile * acfg, int plt_offset, struct MonoJumpInfo * patch_info)
{
  char * D.26113;
  const char * D.26114;

  D.26114 = acfg->temp_prefix;
  D.26113 = monoeg_g_strdup_printf ("%sp_%d", D.26114, plt_offset);
  return D.26113;
}


get_plt_entry_debug_sym (struct MonoAotCompile * acfg, struct MonoJumpInfo * ji, struct GHashTable * cache)
{
  <unnamed type> D.26116;
  struct MonoMethod * D.26117;
  const char * D.26118;
  struct MonoClass * D.26119;
  struct MonoType * D.26120;
  unsigned int D.26121;
  unsigned int D.26122;
  unsigned int D.26123;
  char * D.26124;
  char * debug_sym;
  char * s;

  debug_sym = 0B;
  D.26116 = ji->type;
  switch (D.26116) <default: <D.25072>, case 3: <D.25063>, case 7: <D.25065>, case 15: <D.25066>, case 31: <D.25068>, case 32: <D.25070>, case 35: <D.25067>, case 36: <D.25071>>
  <D.25063>:
  D.26117 = ji->data.method;
  debug_sym = get_debug_sym (D.26117, "plt_", cache);
  goto <D.25064>;
  <D.25065>:
  D.26118 = ji->data.name;
  debug_sym = monoeg_g_strdup_printf ("plt__jit_icall_%s", D.26118);
  goto <D.25064>;
  <D.25066>:
  D.26119 = ji->data.klass;
  D.26120 = &D.26119->byval_arg;
  s = mono_type_get_name (D.26120);
  debug_sym = monoeg_g_strdup_printf ("plt__class_init_%s", s);
  monoeg_g_free (s);
  goto <D.25064>;
  <D.25067>:
  D.26121 = acfg->label_generator;
  D.26122 = D.26121;
  D.26123 = D.26122 + 1;
  acfg->label_generator = D.26123;
  debug_sym = monoeg_g_strdup_printf ("plt__rgctx_fetch_%d", D.26122);
  goto <D.25064>;
  <D.25068>:
  {
    char * s;

    D.26117 = ji->data.method;
    s = get_debug_sym (D.26117, "", cache);
    debug_sym = monoeg_g_strdup_printf ("plt__icall_native_%s", s);
    monoeg_g_free (s);
    goto <D.25064>;
  }
  <D.25070>:
  D.26118 = ji->data.name;
  debug_sym = monoeg_g_strdup_printf ("plt__jit_icall_native_%s", D.26118);
  goto <D.25064>;
  <D.25071>:
  debug_sym = monoeg_g_strdup_printf ("plt__generic_class_init");
  goto <D.25064>;
  <D.25072>:
  goto <D.25064>;
  <D.25064>:
  D.26124 = sanitize_symbol (acfg, debug_sym);
  return D.26124;
}


sanitize_symbol (struct MonoAotCompile * acfg, char * s)
{
  char * D.26129;
  long unsigned int D.26130;
  sizetype D.26133;
  char * D.26134;
  char D.26135;
  signed char D.26136;
  const short unsigned int * * D.26138;
  const short unsigned int * D.26139;
  long unsigned int D.26140;
  long unsigned int D.26141;
  const short unsigned int * D.26142;
  short unsigned int D.26143;
  int D.26144;
  int D.26145;
  long unsigned int D.26149;
  signed char c.12;
  long unsigned int D.26155;
  long unsigned int D.26156;
  const short unsigned int * D.26157;
  short unsigned int D.26158;
  int D.26159;
  int D.26160;
  int D.26164;
  unsigned char D.26165;
  struct MonoMemPool * D.26167;
  char * D.26168;
  gboolean process;
  int i;
  int len;
  struct GString * gs;
  char * res;

  process = 0;
  if (s == 0B) goto <D.26127>; else goto <D.26128>;
  <D.26127>:
  D.26129 = s;
  return D.26129;
  <D.26128>:
  D.26130 = __strlen_g (s);
  len = (int) D.26130;
  i = 0;
  goto <D.24790>;
  <D.24789>:
  D.26133 = (sizetype) i;
  D.26134 = s + D.26133;
  D.26135 = *D.26134;
  D.26136 = (signed char) D.26135;
  if (D.26136 < 0) goto <D.26131>; else goto <D.26137>;
  <D.26137>:
  D.26138 = __ctype_b_loc ();
  D.26139 = *D.26138;
  D.26133 = (sizetype) i;
  D.26134 = s + D.26133;
  D.26135 = *D.26134;
  D.26140 = (long unsigned int) D.26135;
  D.26141 = D.26140 * 2;
  D.26142 = D.26139 + D.26141;
  D.26143 = *D.26142;
  D.26144 = (int) D.26143;
  D.26145 = D.26144 & 2048;
  if (D.26145 == 0) goto <D.26146>; else goto <D.26132>;
  <D.26146>:
  D.26133 = (sizetype) i;
  D.26134 = s + D.26133;
  D.26135 = *D.26134;
  if (D.26135 != 95) goto <D.26131>; else goto <D.26132>;
  <D.26131>:
  process = 1;
  <D.26132>:
  i = i + 1;
  <D.24790>:
  if (i < len) goto <D.24789>; else goto <D.24791>;
  <D.24791>:
  if (process == 0) goto <D.26147>; else goto <D.26148>;
  <D.26147>:
  D.26129 = s;
  return D.26129;
  <D.26148>:
  D.26149 = (long unsigned int) len;
  gs = monoeg_g_string_sized_new (D.26149);
  i = 0;
  goto <D.24797>;
  <D.24796>:
  {
    guint8 c;

    D.26133 = (sizetype) i;
    D.26134 = s + D.26133;
    c = *D.26134;
    c.12 = (signed char) c;
    if (c.12 >= 0) goto <D.26154>; else goto <D.26150>;
    <D.26154>:
    D.26138 = __ctype_b_loc ();
    D.26139 = *D.26138;
    D.26155 = (long unsigned int) c;
    D.26156 = D.26155 * 2;
    D.26157 = D.26139 + D.26156;
    D.26158 = *D.26157;
    D.26159 = (int) D.26158;
    D.26160 = D.26159 & 2048;
    if (D.26160 != 0) goto <D.26151>; else goto <D.26161>;
    <D.26161>:
    if (c == 95) goto <D.26151>; else goto <D.26150>;
    <D.26151>:
    monoeg_g_string_append_c (gs, c);
    goto <D.26152>;
    <D.26150>:
    c.12 = (signed char) c;
    if (c.12 < 0) goto <D.26162>; else goto <D.26163>;
    <D.26162>:
    D.26164 = (int) c;
    monoeg_g_string_append_printf (gs, "_0x%x", D.26164);
    i = i + 1;
    D.26133 = (sizetype) i;
    D.26134 = s + D.26133;
    c = *D.26134;
    goto <D.24794>;
    <D.24793>:
    D.26164 = (int) c;
    monoeg_g_string_append_printf (gs, "%x", D.26164);
    i = i + 1;
    D.26133 = (sizetype) i;
    D.26134 = s + D.26133;
    c = *D.26134;
    <D.24794>:
    D.26165 = c >> 6;
    if (D.26165 == 2) goto <D.24793>; else goto <D.24795>;
    <D.24795>:
    monoeg_g_string_append_printf (gs, "_");
    i = i + -1;
    goto <D.26166>;
    <D.26163>:
    monoeg_g_string_append_c (gs, 95);
    <D.26166>:
    <D.26152>:
  }
  i = i + 1;
  <D.24797>:
  if (i < len) goto <D.24796>; else goto <D.24798>;
  <D.24798>:
  D.26167 = acfg->mempool;
  D.26168 = gs->str;
  res = mono_mempool_strdup (D.26167, D.26168);
  monoeg_g_string_free (gs, 1);
  D.26129 = res;
  return D.26129;
}


__attribute__((visibility ("hidden")))
mono_aot_get_method_index (struct MonoMethod * method)
{
  struct MonoAotCompile * llvm_acfg.13;
  _Bool D.26171;
  long int D.26172;
  long int D.26173;
  int D.26176;
  unsigned int D.26177;

  llvm_acfg.13 = llvm_acfg;
  D.26171 = llvm_acfg.13 == 0B;
  D.26172 = (long int) D.26171;
  D.26173 = __builtin_expect (D.26172, 0);
  if (D.26173 != 0) goto <D.26174>; else goto <D.26175>;
  <D.26174>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "aot-compiler.c", 6895, "llvm_acfg");
  <D.26175>:
  llvm_acfg.13 = llvm_acfg;
  D.26177 = get_method_index (llvm_acfg.13, method);
  D.26176 = (int) D.26177;
  return D.26176;
}


get_method_index (struct MonoAotCompile * acfg, struct MonoMethod * method)
{
  struct GHashTable * D.26179;
  void * D.26180;
  long int D.26181;
  _Bool D.26182;
  long int D.26183;
  long int D.26184;
  guint32 D.26187;
  int D.26188;
  int index;

  D.26179 = acfg->method_indexes;
  D.26180 = monoeg_g_hash_table_lookup (D.26179, method);
  D.26181 = (long int) D.26180;
  index = (int) D.26181;
  D.26182 = index == 0;
  D.26183 = (long int) D.26182;
  D.26184 = __builtin_expect (D.26183, 0);
  if (D.26184 != 0) goto <D.26185>; else goto <D.26186>;
  <D.26185>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "aot-compiler.c", 3010, "index");
  <D.26186>:
  D.26188 = index + -1;
  D.26187 = (guint32) D.26188;
  return D.26187;
}


__attribute__((visibility ("hidden")))
mono_aot_patch_info_dup (struct MonoJumpInfo * ji)
{
  struct MonoAotCompile * llvm_acfg.14;
  union mono_mutex_t * D.26191;
  _Bool D.26194;
  long int D.26195;
  long int D.26196;
  struct MonoMemPool * D.26199;
  _Bool D.26202;
  long int D.26203;
  long int D.26204;
  struct MonoJumpInfo * D.26207;
  struct MonoJumpInfo * res;

  {
    int ret;

    llvm_acfg.14 = llvm_acfg;
    D.26191 = &llvm_acfg.14->mutex.mutex;
    ret = pthread_mutex_lock (D.26191);
    if (ret != 0) goto <D.26192>; else goto <D.26193>;
    <D.26192>:
    monoeg_g_log (0B, 16, "Bad call to mono_mutex_lock result %d", ret);
    <D.26193>:
    D.26194 = ret != 0;
    D.26195 = (long int) D.26194;
    D.26196 = __builtin_expect (D.26195, 0);
    if (D.26196 != 0) goto <D.26197>; else goto <D.26198>;
    <D.26197>:
    monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "aot-compiler.c", 6904, "ret == 0");
    <D.26198>:
  }
  llvm_acfg.14 = llvm_acfg;
  D.26199 = llvm_acfg.14->mempool;
  res = mono_patch_info_dup_mp (D.26199, ji);
  {
    int ret;

    llvm_acfg.14 = llvm_acfg;
    D.26191 = &llvm_acfg.14->mutex.mutex;
    ret = pthread_mutex_unlock (D.26191);
    if (ret != 0) goto <D.26200>; else goto <D.26201>;
    <D.26200>:
    monoeg_g_log (0B, 16, "Bad call to mono_mutex_unlock result %d", ret);
    <D.26201>:
    D.26202 = ret != 0;
    D.26203 = (long int) D.26202;
    D.26204 = __builtin_expect (D.26203, 0);
    if (D.26204 != 0) goto <D.26205>; else goto <D.26206>;
    <D.26205>:
    monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "aot-compiler.c", 6906, "ret == 0");
    <D.26206>:
  }
  D.26207 = res;
  return D.26207;
}


__attribute__((visibility ("hidden")))
mono_aot_method_hash (struct MonoMethod * method)
{
  long unsigned int D.26209;
  long unsigned int D.26210;
  short unsigned int D.26213;
  int D.26214;
  int D.26215;
  int iftmp.15;
  <unnamed-unsigned:22> D.26219;
  long unsigned int D.26221;
  long unsigned int D.26222;
  long unsigned int D.26226;
  struct MonoType * D.26230;
  unsigned int D.26231;
  guint32 * D.26232;
  const char * D.26234;
  unsigned int D.26235;
  const char * D.26236;
  unsigned int D.26237;
  guint32 * D.26243;
  const char * D.26244;
  unsigned int D.26245;
  guint32 * D.26246;
  <unnamed-unsigned:5> D.26247;
  unsigned int D.26248;
  guint32 * D.26249;
  struct MonoType * D.26250;
  unsigned int D.26251;
  int hindex.16;
  long unsigned int D.26253;
  long unsigned int D.26254;
  guint32 * D.26255;
  struct MonoType * D.26256;
  unsigned int D.26257;
  int hindex.17;
  long unsigned int D.26261;
  long unsigned int D.26262;
  guint32 * D.26263;
  struct MonoType * D.26264;
  unsigned int D.26265;
  int D.26266;
  _Bool D.26267;
  long int D.26268;
  long int D.26269;
  unsigned int hashes_count.18;
  unsigned int D.26273;
  unsigned int D.26274;
  unsigned int D.26275;
  unsigned int D.26276;
  unsigned int D.26277;
  unsigned int D.26278;
  unsigned int D.26279;
  unsigned int D.26280;
  unsigned int D.26281;
  unsigned int D.26282;
  unsigned int D.26283;
  unsigned int D.26284;
  unsigned int D.26285;
  unsigned int D.26286;
  unsigned int D.26287;
  unsigned int D.26288;
  guint32 D.26290;
  struct MonoMethodSignature * sig;
  struct MonoClass * klass;
  int i;
  int hindex;
  int hashes_count;
  guint32 * hashes_start;
  guint32 * hashes;
  guint32 a;
  guint32 b;
  guint32 c;
  struct MonoGenericInst * ginst;

  ginst = 0B;
  sig = mono_method_signature (method);
  D.26209 = BIT_FIELD_REF <*method, 64, 256>;
  D.26210 = D.26209 & 2251799813685248;
  if (D.26210 != 0) goto <D.26211>; else goto <D.26212>;
  <D.26211>:
  ginst = MEM[(struct MonoMethodInflated *)method].context.method_inst;
  <D.26212>:
  D.26213 = sig->param_count;
  D.26214 = (int) D.26213;
  D.26215 = D.26214 + 5;
  if (ginst != 0B) goto <D.26217>; else goto <D.26218>;
  <D.26217>:
  D.26219 = ginst->type_argc;
  iftmp.15 = (int) D.26219;
  goto <D.26220>;
  <D.26218>:
  iftmp.15 = 0;
  <D.26220>:
  hashes_count = D.26215 + iftmp.15;
  D.26221 = (long unsigned int) hashes_count;
  D.26222 = D.26221 * 4;
  hashes_start = monoeg_malloc0 (D.26222);
  hashes = hashes_start;
  D.26209 = BIT_FIELD_REF <*method, 64, 256>;
  D.26226 = D.26209 & 4467570830351532032;
  if (D.26226 == 0) goto <D.26223>; else goto <D.26227>;
  <D.26227>:
  D.26209 = BIT_FIELD_REF <*method, 64, 256>;
  D.26226 = D.26209 & 4467570830351532032;
  if (D.26226 == 1297036692682702848) goto <D.26223>; else goto <D.26224>;
  <D.26223>:
  klass = method->klass;
  goto <D.26225>;
  <D.26224>:
  klass = mono_defaults.object_class;
  <D.26225>:
  D.26209 = BIT_FIELD_REF <*method, 64, 256>;
  D.26226 = D.26209 & 4467570830351532032;
  if (D.26226 == 0) goto <D.26228>; else goto <D.26229>;
  <D.26228>:
  {
    char * full_name;

    D.26230 = &klass->byval_arg;
    full_name = mono_type_full_name (D.26230);
    D.26231 = mono_metadata_str_hash (full_name);
    *hashes = D.26231;
    D.26232 = hashes + 4;
    *D.26232 = 0;
    monoeg_g_free (full_name);
  }
  goto <D.26233>;
  <D.26229>:
  D.26234 = klass->name;
  D.26235 = mono_metadata_str_hash (D.26234);
  *hashes = D.26235;
  D.26232 = hashes + 4;
  D.26236 = klass->name_space;
  D.26237 = mono_metadata_str_hash (D.26236);
  *D.26232 = D.26237;
  <D.26233>:
  D.26209 = BIT_FIELD_REF <*method, 64, 256>;
  D.26226 = D.26209 & 4467570830351532032;
  if (D.26226 == 1873497444986126336) goto <D.26238>; else goto <D.26241>;
  <D.26241>:
  D.26209 = BIT_FIELD_REF <*method, 64, 256>;
  D.26226 = D.26209 & 4467570830351532032;
  if (D.26226 == 1729382256910270464) goto <D.26238>; else goto <D.26242>;
  <D.26242>:
  D.26209 = BIT_FIELD_REF <*method, 64, 256>;
  D.26226 = D.26209 & 4467570830351532032;
  if (D.26226 == 3314649325744685056) goto <D.26238>; else goto <D.26239>;
  <D.26238>:
  D.26243 = hashes + 8;
  *D.26243 = 0;
  goto <D.26240>;
  <D.26239>:
  D.26243 = hashes + 8;
  D.26244 = method->name;
  D.26245 = mono_metadata_str_hash (D.26244);
  *D.26243 = D.26245;
  <D.26240>:
  D.26246 = hashes + 12;
  D.26247 = method->wrapper_type;
  D.26248 = (unsigned int) D.26247;
  *D.26246 = D.26248;
  D.26249 = hashes + 16;
  D.26250 = sig->ret;
  D.26251 = mono_aot_type_hash (D.26250);
  *D.26249 = D.26251;
  hindex = 5;
  i = 0;
  goto <D.25460>;
  <D.25459>:
  hindex.16 = hindex;
  hindex = hindex.16 + 1;
  D.26253 = (long unsigned int) hindex.16;
  D.26254 = D.26253 * 4;
  D.26255 = hashes + D.26254;
  D.26256 = sig->params[i];
  D.26257 = mono_aot_type_hash (D.26256);
  *D.26255 = D.26257;
  i = i + 1;
  <D.25460>:
  D.26213 = sig->param_count;
  D.26214 = (int) D.26213;
  if (D.26214 > i) goto <D.25459>; else goto <D.25461>;
  <D.25461>:
  if (ginst != 0B) goto <D.26258>; else goto <D.26259>;
  <D.26258>:
  i = 0;
  goto <D.25463>;
  <D.25462>:
  hindex.17 = hindex;
  hindex = hindex.17 + 1;
  D.26261 = (long unsigned int) hindex.17;
  D.26262 = D.26261 * 4;
  D.26263 = hashes + D.26262;
  D.26264 = ginst->type_argv[i];
  D.26265 = mono_aot_type_hash (D.26264);
  *D.26263 = D.26265;
  i = i + 1;
  <D.25463>:
  D.26219 = ginst->type_argc;
  D.26266 = (int) D.26219;
  if (D.26266 > i) goto <D.25462>; else goto <D.25464>;
  <D.25464>:
  <D.26259>:
  D.26267 = hindex != hashes_count;
  D.26268 = (long int) D.26267;
  D.26269 = __builtin_expect (D.26268, 0);
  if (D.26269 != 0) goto <D.26270>; else goto <D.26271>;
  <D.26270>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "aot-compiler.c", 7387, "hindex == hashes_count");
  <D.26271>:
  hashes_count.18 = (unsigned int) hashes_count;
  D.26273 = hashes_count.18 << 2;
  c = D.26273 + 3735928559;
  b = c;
  a = b;
  goto <D.25466>;
  <D.25465>:
  D.26274 = *hashes;
  a = D.26274 + a;
  D.26232 = hashes + 4;
  D.26275 = *D.26232;
  b = D.26275 + b;
  D.26243 = hashes + 8;
  D.26276 = *D.26243;
  c = D.26276 + c;
  a = a - c;
  D.26277 = c r>> 28;
  a = D.26277 ^ a;
  c = c + b;
  b = b - a;
  D.26278 = a r>> 26;
  b = D.26278 ^ b;
  a = a + c;
  c = c - b;
  D.26279 = b r>> 24;
  c = D.26279 ^ c;
  b = b + a;
  a = a - c;
  D.26280 = c r>> 16;
  a = D.26280 ^ a;
  c = c + b;
  b = b - a;
  D.26281 = a r>> 13;
  b = D.26281 ^ b;
  a = a + c;
  c = c - b;
  D.26282 = b r>> 28;
  c = D.26282 ^ c;
  b = b + a;
  hashes_count = hashes_count + -3;
  hashes = hashes + 12;
  <D.25466>:
  if (hashes_count > 3) goto <D.25465>; else goto <D.25467>;
  <D.25467>:
  switch (hashes_count) <default: <D.26289>, case 0: <D.25471>, case 1: <D.25470>, case 2: <D.25469>, case 3: <D.25468>>
  <D.25468>:
  D.26243 = hashes + 8;
  D.26276 = *D.26243;
  c = D.26276 + c;
  <D.25469>:
  D.26232 = hashes + 4;
  D.26275 = *D.26232;
  b = D.26275 + b;
  <D.25470>:
  D.26274 = *hashes;
  a = D.26274 + a;
  c = c ^ b;
  D.26283 = b r>> 18;
  c = c - D.26283;
  a = a ^ c;
  D.26284 = c r>> 21;
  a = a - D.26284;
  b = b ^ a;
  D.26285 = a r>> 7;
  b = b - D.26285;
  c = c ^ b;
  D.26286 = b r>> 16;
  c = c - D.26286;
  a = a ^ c;
  D.26277 = c r>> 28;
  a = a - D.26277;
  b = b ^ a;
  D.26287 = a r>> 18;
  b = b - D.26287;
  c = c ^ b;
  D.26288 = b r>> 8;
  c = c - D.26288;
  <D.25471>:
  goto <D.25472>;
  <D.26289>:
  <D.25472>:
  free (hashes_start);
  D.26290 = c;
  return D.26290;
}


mono_aot_type_hash (struct MonoType * t1)
{
  unsigned char D.26292;
  <unnamed-unsigned:1> D.26293;
  int D.26294;
  int D.26295;
  unsigned int D.26296;
  int D.26297;
  guint D.26298;
  unsigned int D.26299;
  unsigned int D.26300;
  struct MonoClass * D.26301;
  const char * D.26302;
  unsigned int D.26303;
  struct MonoType * D.26304;
  unsigned int D.26305;
  struct MonoArrayType * D.26306;
  struct MonoClass * D.26307;
  struct MonoType * D.26308;
  unsigned int D.26309;
  guint hash;

  D.26292 = t1->type;
  hash = (guint) D.26292;
  D.26293 = t1->byref;
  D.26294 = (int) D.26293;
  D.26295 = D.26294 << 6;
  D.26296 = (unsigned int) D.26295;
  hash = D.26296 | hash;
  D.26292 = t1->type;
  D.26297 = (int) D.26292;
  switch (D.26297) <default: <D.25443>, case 15: <D.25440>, case 17: <D.25437>, case 18: <D.25438>, case 20: <D.25441>, case 21: <D.25442>, case 29: <D.25439>>
  <D.25437>:
  <D.25438>:
  <D.25439>:
  D.26299 = hash << 5;
  D.26300 = D.26299 - hash;
  D.26301 = t1->data.klass;
  D.26302 = D.26301->name;
  D.26303 = mono_metadata_str_hash (D.26302);
  D.26298 = D.26300 ^ D.26303;
  return D.26298;
  <D.25440>:
  D.26299 = hash << 5;
  D.26300 = D.26299 - hash;
  D.26304 = t1->data.type;
  D.26305 = mono_metadata_type_hash (D.26304);
  D.26298 = D.26300 ^ D.26305;
  return D.26298;
  <D.25441>:
  D.26299 = hash << 5;
  D.26300 = D.26299 - hash;
  D.26306 = t1->data.array;
  D.26307 = D.26306->eklass;
  D.26308 = &D.26307->byval_arg;
  D.26309 = mono_metadata_type_hash (D.26308);
  D.26298 = D.26300 ^ D.26309;
  return D.26298;
  <D.25442>:
  D.26299 = hash << 5;
  D.26298 = D.26299 - hash;
  return D.26298;
  <D.25443>:
  D.26298 = hash;
  return D.26298;
}


__attribute__((visibility ("hidden")))
mono_aot_get_array_helper_from_wrapper (struct MonoMethod * method)
{
  const char * D.26311;
  long unsigned int D.26312;
  sizetype D.26313;
  const char * D.26314;
  _Bool D.26315;
  long int D.26316;
  long int D.26317;
  int D.26320;
  struct MonoClass * D.26324;
  struct MonoMethodSignature * D.26325;
  short unsigned int D.26326;
  int D.26327;
  _Bool D.26328;
  long int D.26329;
  long int D.26330;
  long unsigned int D.26333;
  long unsigned int D.26334;
  struct MonoClass * D.26337;
  struct MonoClass * D.26338;
  struct MonoType * D.26339;
  struct MonoGenericInst * D.26340;
  struct MonoMethod * D.26341;
  struct MonoMethod * m;
  const char * prefix;
  struct MonoGenericContext ctx;
  struct MonoType * args[16];
  char * mname;
  char * iname;
  char * s;
  char * s2;
  char * helper_name;

  try
    {
      helper_name = 0B;
      prefix = "System.Collections.Generic";
      D.26311 = method->name;
      D.26312 = __strlen_g (prefix);
      D.26313 = D.26312 + 1;
      D.26314 = D.26311 + D.26313;
      s = monoeg_g_strdup_printf ("%s", D.26314);
      s2 = strstr (s, "`1.");
      D.26315 = s2 == 0B;
      D.26316 = (long int) D.26315;
      D.26317 = __builtin_expect (D.26316, 0);
      if (D.26317 != 0) goto <D.26318>; else goto <D.26319>;
      <D.26318>:
      monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "aot-compiler.c", 7437, "s2");
      <D.26319>:
      *s2 = 0;
      iname = s;
      mname = s2 + 3;
      D.26320 = strcmp (iname, "IList");
      if (D.26320 == 0) goto <D.26321>; else goto <D.26322>;
      <D.26321>:
      helper_name = monoeg_g_strdup_printf ("InternalArray__%s", mname);
      goto <D.26323>;
      <D.26322>:
      helper_name = monoeg_g_strdup_printf ("InternalArray__%s_%s", iname, mname);
      <D.26323>:
      D.26324 = mono_defaults.array_class;
      D.26325 = mono_method_signature (method);
      D.26326 = D.26325->param_count;
      D.26327 = (int) D.26326;
      m = mono_class_get_method_from_name (D.26324, helper_name, D.26327);
      D.26328 = m == 0B;
      D.26329 = (long int) D.26328;
      D.26330 = __builtin_expect (D.26329, 0);
      if (D.26330 != 0) goto <D.26331>; else goto <D.26332>;
      <D.26331>:
      monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "aot-compiler.c", 7449, "m");
      <D.26332>:
      monoeg_g_free (helper_name);
      monoeg_g_free (s);
      D.26333 = BIT_FIELD_REF <*m, 64, 256>;
      D.26334 = D.26333 & 4503599627370496;
      if (D.26334 != 0) goto <D.26335>; else goto <D.26336>;
      <D.26335>:
      memset (&ctx, 0, 16);
      D.26337 = method->klass;
      D.26338 = D.26337->element_class;
      D.26339 = &D.26338->byval_arg;
      args[0] = D.26339;
      D.26340 = mono_metadata_get_generic_inst (1, &args);
      ctx.method_inst = D.26340;
      m = mono_class_inflate_generic_method (m, &ctx);
      <D.26336>:
      D.26341 = m;
      return D.26341;
    }
  finally
    {
      ctx = {CLOBBER};
      args = {CLOBBER};
    }
}


__attribute__((__artificial__, __gnu_inline__, __always_inline__, __nothrow__, __leaf__))
memset (void * __dest, int __ch, size_t __len)
{
  void * D.26344;
  long unsigned int D.26345;

  D.26345 = __builtin_object_size (__dest, 0);
  D.26344 = __builtin___memset_chk (__dest, __ch, __len, D.26345);
  return D.26344;
}


__attribute__((visibility ("hidden")))
mono_compile_assembly (struct MonoAssembly * ass, guint32 opts, const char * aot_options)
{
  unsigned int D.26347;
  struct _IO_FILE * stderr.19;
  char * D.26351;
  struct MonoAotOptions * D.26352;
  gchar * D.26353;
  int D.26354;
  int D.26357;
  int D.26360;
  int D.26361;
  int D.26368;
  int D.26371;
  <unnamed type> D.26374;
  unsigned int D.26375;
  int mono_use_llvm.20;
  unsigned int D.26379;
  unsigned int D.26384;
  guint32 iftmp.21;
  int D.26388;
  guint32 iftmp.22;
  int D.26393;
  guint32 iftmp.23;
  int D.26398;
  const char * D.26400;
  struct MonoImage * D.26401;
  struct MonoAssembly * D.26402;
  const char * D.26403;
  gchar * D.26404;
  const char * D.26405;
  gchar * D.26406;
  gchar * D.26407;
  const short unsigned int * * D.26408;
  const short unsigned int * D.26409;
  char D.26410;
  long unsigned int D.26411;
  long unsigned int D.26412;
  const short unsigned int * D.26413;
  short unsigned int D.26414;
  int D.26415;
  int D.26416;
  struct GPtrArray * D.26429;
  unsigned int D.26430;
  unsigned int D.26431;
  int D.26432;
  int D.26433;
  long unsigned int D.26434;
  long unsigned int D.26435;
  void * D.26436;
  struct MonoMemPool * D.26437;
  long int D.26438;
  long int D.26439;
  int D.26440;
  int D.26443;
  int D.26445;
  int D.26447;
  char * D.26449;
  char * D.26453;
  struct FILE * D.26454;
  struct FILE * D.26455;
  int * D.26458;
  int D.26459;
  char * D.26460;
  struct MonoImageWriter * D.26461;
  int D.26462;
  char * D.26465;
  struct FILE * D.26466;
  gchar * D.26472;
  gchar * D.26474;
  struct FILE * D.26475;
  char * * D.26477;
  struct FILE * D.26478;
  char * D.26481;
  struct MonoImageWriter * D.26482;
  char * D.26483;
  gchar * D.26484;
  struct MonoCompile * * D.26485;
  long unsigned int D.26486;
  long unsigned int D.26487;
  struct MonoCompile * * D.26488;
  struct MonoCompile * D.26489;
  struct MonoMethod * D.26492;
  unsigned int D.26493;
  char * D.26496;
  gchar * D.26497;
  int D.26499;
  struct MonoMethod * D.26502;
  struct GHashTable * D.26503;
  char * D.26504;
  const char * D.26506;
  gchar * D.26507;
  unsigned int D.26508;
  unsigned int i.24;
  int D.26510;
  int D.26515;
  int D.26520;
  int D.26524;
  struct MonoImageWriter * D.26527;
  int D.26528;
  _Bool D.26529;
  int D.26530;
  struct MonoDwarfWriter * D.26531;
  struct MonoDwarfWriter * D.26532;
  gchar * D.26535;
  struct GSList * D.26536;
  int D.26537;
  int D.26542;
  int D.26545;
  unsigned int D.26550;
  unsigned int D.26551;
  _Bool D.26552;
  long int D.26553;
  long int D.26554;
  int D.26559;
  int iftmp.25;
  int D.26561;
  int D.26564;
  int D.26567;
  int D.26568;
  int D.26569;
  int D.26570;
  int D.26571;
  unsigned int D.26572;
  int D.26573;
  unsigned int D.26574;
  int D.26575;
  int D.26576;
  int D.26577;
  int iftmp.26;
  int D.26581;
  int D.26583;
  int iftmp.27;
  int D.26587;
  int D.26589;
  int iftmp.28;
  int D.26591;
  int D.26594;
  int D.26596;
  int iftmp.29;
  int D.26602;
  int D.26604;
  int iftmp.30;
  int D.26610;
  int D.26612;
  int iftmp.31;
  int D.26618;
  int D.26620;
  int iftmp.32;
  int D.26626;
  char * D.26634;
  int D.26638;
  int D.26641;
  const char * D.26644;
  int D.26645;
  int D.26646;
  int D.26647;
  int D.26648;
  int D.26649;
  int D.26650;
  int D.26651;
  struct MonoImage * image;
  int i;
  int res;
  struct MonoAotCompile * acfg;
  char * outfile_name;
  char * tmp_outfile_name;
  char * p;
  char llvm_stats_msg[256];
  gint64 atv;
  gint64 btv;

  try
    {
      image = ass->image;
      D.26347 = opts & 16777216;
      if (D.26347 != 0) goto <D.26348>; else goto <D.26349>;
      <D.26348>:
      stderr.19 = stderr;
      fprintf (stderr.19, "-O=gsharedvt not supported on this platform.\n");
      exit (1);
      <D.26349>:
      D.26351 = image->name;
      printf ("Mono Ahead of Time compiler - compiling assembly %s\n", D.26351);
      acfg = acfg_create (ass, opts);
      D.26352 = &acfg->aot_opts;
      memset (D.26352, 0, 152);
      acfg->aot_opts.write_symbols = 1;
      acfg->aot_opts.ntrampolines = 1024;
      acfg->aot_opts.nrgctx_trampolines = 1024;
      acfg->aot_opts.nimt_trampolines = 128;
      acfg->aot_opts.nrgctx_fetch_trampolines = 128;
      acfg->aot_opts.ngsharedvt_arg_trampolines = 128;
      D.26353 = monoeg_strdup ("");
      acfg->aot_opts.llvm_path = D.26353;
      D.26352 = &acfg->aot_opts;
      mono_aot_parse_options (aot_options, D.26352);
      D.26354 = acfg->aot_opts.static_link;
      if (D.26354 != 0) goto <D.26355>; else goto <D.26356>;
      <D.26355>:
      acfg->aot_opts.autoreg = 1;
      <D.26356>:
      D.26357 = acfg->aot_opts.full_aot;
      if (D.26357 != 0) goto <D.26358>; else goto <D.26359>;
      <D.26358>:
      printf ("--aot=full is not supported on this platform.\n");
      D.26360 = 1;
      return D.26360;
      <D.26359>:
      D.26361 = acfg->aot_opts.direct_pinvoke;
      if (D.26361 != 0) goto <D.26362>; else goto <D.26363>;
      <D.26362>:
      D.26354 = acfg->aot_opts.static_link;
      if (D.26354 == 0) goto <D.26364>; else goto <D.26365>;
      <D.26364>:
      stderr.19 = stderr;
      fprintf (stderr.19, "The \'direct-pinvoke\' AOT option also requires the \'static\' AOT option.\n");
      exit (1);
      <D.26365>:
      <D.26363>:
      D.26354 = acfg->aot_opts.static_link;
      if (D.26354 != 0) goto <D.26366>; else goto <D.26367>;
      <D.26366>:
      acfg->aot_opts.asm_writer = 1;
      <D.26367>:
      D.26368 = acfg->aot_opts.soft_debug;
      if (D.26368 != 0) goto <D.26369>; else goto <D.26370>;
      <D.26369>:
      {
        struct MonoDebugOptions * opt;

        opt = mini_get_debug_options ();
        opt->mdb_optimizations = 1;
        opt->gen_seq_points = 1;
        D.26371 = mono_debug_enabled ();
        if (D.26371 == 0) goto <D.26372>; else goto <D.26373>;
        <D.26372>:
        stderr.19 = stderr;
        fprintf (stderr.19, "The soft-debug AOT option requires the --debug option.\n");
        D.26360 = 1;
        return D.26360;
        <D.26373>:
        D.26374 = acfg->flags;
        D.26375 = D.26374 | 4;
        acfg->flags = D.26375;
      }
      <D.26370>:
      mono_use_llvm.20 = mono_use_llvm;
      if (mono_use_llvm.20 != 0) goto <D.26377>; else goto <D.26378>;
      <D.26377>:
      acfg->llvm = 1;
      acfg->aot_opts.asm_writer = 1;
      D.26374 = acfg->flags;
      D.26379 = D.26374 | 1;
      acfg->flags = D.26379;
      D.26368 = acfg->aot_opts.soft_debug;
      if (D.26368 != 0) goto <D.26380>; else goto <D.26381>;
      <D.26380>:
      stderr.19 = stderr;
      fprintf (stderr.19, "The \'soft-debug\' option is not supported when compiling with LLVM.\n");
      exit (1);
      <D.26381>:
      <D.26378>:
      D.26357 = acfg->aot_opts.full_aot;
      if (D.26357 != 0) goto <D.26382>; else goto <D.26383>;
      <D.26382>:
      D.26374 = acfg->flags;
      D.26384 = D.26374 | 2;
      acfg->flags = D.26384;
      <D.26383>:
      load_profile_files (acfg);
      D.26357 = acfg->aot_opts.full_aot;
      if (D.26357 != 0) goto <D.26386>; else goto <D.26387>;
      <D.26386>:
      D.26388 = acfg->aot_opts.ntrampolines;
      iftmp.21 = (guint32) D.26388;
      goto <D.26389>;
      <D.26387>:
      iftmp.21 = 0;
      <D.26389>:
      acfg->num_trampolines[0] = iftmp.21;
      D.26357 = acfg->aot_opts.full_aot;
      if (D.26357 != 0) goto <D.26391>; else goto <D.26392>;
      <D.26391>:
      D.26393 = acfg->aot_opts.nrgctx_trampolines;
      iftmp.22 = (guint32) D.26393;
      goto <D.26394>;
      <D.26392>:
      iftmp.22 = 0;
      <D.26394>:
      acfg->num_trampolines[1] = iftmp.22;
      D.26357 = acfg->aot_opts.full_aot;
      if (D.26357 != 0) goto <D.26396>; else goto <D.26397>;
      <D.26396>:
      D.26398 = acfg->aot_opts.nimt_trampolines;
      iftmp.23 = (guint32) D.26398;
      goto <D.26399>;
      <D.26397>:
      iftmp.23 = 0;
      <D.26399>:
      acfg->num_trampolines[2] = iftmp.23;
      D.26400 = img_writer_get_temp_label_prefix (0B);
      acfg->temp_prefix = D.26400;
      arch_init (acfg);
      D.26401 = acfg->image;
      D.26402 = D.26401->assembly;
      D.26403 = D.26402->aname.name;
      D.26404 = monoeg_g_strdup_printf ("mono_aot_%s_got", D.26403);
      acfg->got_symbol_base = D.26404;
      D.26405 = acfg->llvm_label_prefix;
      D.26401 = acfg->image;
      D.26402 = D.26401->assembly;
      D.26403 = D.26402->aname.name;
      D.26406 = monoeg_g_strdup_printf ("%smono_aot_%s_plt", D.26405, D.26403);
      acfg->plt_symbol = D.26406;
      D.26401 = acfg->image;
      D.26402 = D.26401->assembly;
      D.26403 = D.26402->aname.name;
      D.26407 = monoeg_strdup (D.26403);
      acfg->assembly_name_sym = D.26407;
      p = acfg->got_symbol_base;
      goto <D.25812>;
      <D.25811>:
      D.26408 = __ctype_b_loc ();
      D.26409 = *D.26408;
      D.26410 = *p;
      D.26411 = (long unsigned int) D.26410;
      D.26412 = D.26411 * 2;
      D.26413 = D.26409 + D.26412;
      D.26414 = *D.26413;
      D.26415 = (int) D.26414;
      D.26416 = D.26415 & 2048;
      if (D.26416 == 0) goto <D.26417>; else goto <D.26418>;
      <D.26417>:
      D.26410 = *p;
      if (D.26410 != 95) goto <D.26419>; else goto <D.26420>;
      <D.26419>:
      *p = 95;
      <D.26420>:
      <D.26418>:
      p = p + 1;
      <D.25812>:
      D.26410 = *p;
      if (D.26410 != 0) goto <D.25811>; else goto <D.25813>;
      <D.25813>:
      p = acfg->plt_symbol;
      goto <D.25815>;
      <D.25814>:
      D.26408 = __ctype_b_loc ();
      D.26409 = *D.26408;
      D.26410 = *p;
      D.26411 = (long unsigned int) D.26410;
      D.26412 = D.26411 * 2;
      D.26413 = D.26409 + D.26412;
      D.26414 = *D.26413;
      D.26415 = (int) D.26414;
      D.26416 = D.26415 & 2048;
      if (D.26416 == 0) goto <D.26421>; else goto <D.26422>;
      <D.26421>:
      D.26410 = *p;
      if (D.26410 != 95) goto <D.26423>; else goto <D.26424>;
      <D.26423>:
      *p = 95;
      <D.26424>:
      <D.26422>:
      p = p + 1;
      <D.25815>:
      D.26410 = *p;
      if (D.26410 != 0) goto <D.25814>; else goto <D.25816>;
      <D.25816>:
      p = acfg->assembly_name_sym;
      goto <D.25818>;
      <D.25817>:
      D.26408 = __ctype_b_loc ();
      D.26409 = *D.26408;
      D.26410 = *p;
      D.26411 = (long unsigned int) D.26410;
      D.26412 = D.26411 * 2;
      D.26413 = D.26409 + D.26412;
      D.26414 = *D.26413;
      D.26415 = (int) D.26414;
      D.26416 = D.26415 & 2048;
      if (D.26416 == 0) goto <D.26425>; else goto <D.26426>;
      <D.26425>:
      D.26410 = *p;
      if (D.26410 != 95) goto <D.26427>; else goto <D.26428>;
      <D.26427>:
      *p = 95;
      <D.26428>:
      <D.26426>:
      p = p + 1;
      <D.25818>:
      D.26410 = *p;
      if (D.26410 != 0) goto <D.25817>; else goto <D.25819>;
      <D.25819>:
      acfg->method_index = 1;
      collect_methods (acfg);
      D.26429 = acfg->methods;
      D.26430 = D.26429->len;
      D.26431 = D.26430 + 32;
      D.26432 = (int) D.26431;
      acfg->cfgs_size = D.26432;
      D.26433 = acfg->cfgs_size;
      D.26434 = (long unsigned int) D.26433;
      D.26435 = D.26434 * 8;
      D.26436 = monoeg_malloc0 (D.26435);
      acfg->cfgs = D.26436;
      acfg->plt_offset = 1;
      {
        struct MonoJumpInfo * ji;

        D.26437 = acfg->mempool;
        ji = mono_mempool_alloc0 (D.26437, 1304);
        ji->type = 12;
        D.26401 = acfg->image;
        ji->data.image = D.26401;
        get_got_offset (acfg, ji);
        D.26437 = acfg->mempool;
        ji = mono_mempool_alloc0 (D.26437, 1304);
        ji->type = 39;
        get_got_offset (acfg, ji);
        D.26437 = acfg->mempool;
        ji = mono_mempool_alloc0 (D.26437, 1304);
        ji->type = 42;
        get_got_offset (acfg, ji);
        D.26437 = acfg->mempool;
        ji = mono_mempool_alloc0 (D.26437, 1304);
        ji->type = 47;
        get_got_offset (acfg, ji);
      }
      atv = mono_100ns_ticks ();
      compile_methods (acfg);
      btv = mono_100ns_ticks ();
      D.26438 = btv - atv;
      D.26439 = D.26438 / 10;
      D.26440 = (int) D.26439;
      acfg->stats.jit_time = D.26440;
      atv = mono_100ns_ticks ();
      D.26443 = acfg->aot_opts.asm_only;
      if (D.26443 == 0) goto <D.26444>; else goto <D.26441>;
      <D.26444>:
      D.26445 = acfg->aot_opts.asm_writer;
      if (D.26445 == 0) goto <D.26446>; else goto <D.26441>;
      <D.26446>:
      D.26447 = bin_writer_supported ();
      if (D.26447 != 0) goto <D.26448>; else goto <D.26441>;
      <D.26448>:
      D.26449 = acfg->aot_opts.outfile;
      if (D.26449 != 0B) goto <D.26450>; else goto <D.26451>;
      <D.26450>:
      D.26449 = acfg->aot_opts.outfile;
      outfile_name = monoeg_g_strdup_printf ("%s", D.26449);
      goto <D.26452>;
      <D.26451>:
      D.26401 = acfg->image;
      D.26453 = D.26401->name;
      outfile_name = monoeg_g_strdup_printf ("%s%s", D.26453, ".so");
      <D.26452>:
      tmp_outfile_name = monoeg_g_strdup_printf ("%s.tmp", outfile_name);
      D.26454 = fopen (tmp_outfile_name, "w");
      acfg->fp = D.26454;
      D.26455 = acfg->fp;
      if (D.26455 == 0B) goto <D.26456>; else goto <D.26457>;
      <D.26456>:
      D.26458 = __errno_location ();
      D.26459 = *D.26458;
      D.26460 = strerror (D.26459);
      printf ("Unable to create temporary file \'%s\': %s\n", tmp_outfile_name, D.26460);
      D.26360 = 1;
      return D.26360;
      <D.26457>:
      D.26455 = acfg->fp;
      D.26461 = img_writer_create (D.26455, 1);
      acfg->w = D.26461;
      acfg->use_bin_writer = 1;
      goto <D.26442>;
      <D.26441>:
      D.26462 = acfg->llvm;
      if (D.26462 != 0) goto <D.26463>; else goto <D.26464>;
      <D.26463>:
      D.26465 = acfg->tmpfname;
      D.26466 = fopen (D.26465, "a+");
      acfg->fp = D.26466;
      goto <D.26467>;
      <D.26464>:
      D.26443 = acfg->aot_opts.asm_only;
      if (D.26443 != 0) goto <D.26468>; else goto <D.26469>;
      <D.26468>:
      D.26449 = acfg->aot_opts.outfile;
      if (D.26449 != 0B) goto <D.26470>; else goto <D.26471>;
      <D.26470>:
      D.26449 = acfg->aot_opts.outfile;
      D.26472 = monoeg_g_strdup_printf ("%s", D.26449);
      acfg->tmpfname = D.26472;
      goto <D.26473>;
      <D.26471>:
      D.26401 = acfg->image;
      D.26453 = D.26401->name;
      D.26474 = monoeg_g_strdup_printf ("%s.s", D.26453);
      acfg->tmpfname = D.26474;
      <D.26473>:
      D.26465 = acfg->tmpfname;
      D.26475 = fopen (D.26465, "w+");
      acfg->fp = D.26475;
      goto <D.26476>;
      <D.26469>:
      {
        int i;

        D.26477 = &acfg->tmpfname;
        i = monoeg_g_file_open_tmp ("mono_aot_XXXXXX", D.26477, 0B);
        D.26478 = fdopen (i, "w+");
        acfg->fp = D.26478;
      }
      <D.26476>:
      <D.26467>:
      D.26455 = acfg->fp;
      if (D.26455 == 0B) goto <D.26479>; else goto <D.26480>;
      <D.26479>:
      stderr.19 = stderr;
      D.26465 = acfg->tmpfname;
      D.26458 = __errno_location ();
      D.26459 = *D.26458;
      D.26481 = strerror (D.26459);
      fprintf (stderr.19, "Unable to open file \'%s\': %s\n", D.26465, D.26481);
      D.26360 = 1;
      return D.26360;
      <D.26480>:
      D.26455 = acfg->fp;
      D.26482 = img_writer_create (D.26455, 0);
      acfg->w = D.26482;
      tmp_outfile_name = 0B;
      outfile_name = 0B;
      <D.26442>:
      D.26405 = acfg->llvm_label_prefix;
      D.26483 = acfg->got_symbol_base;
      D.26484 = monoeg_g_strdup_printf ("%s%s", D.26405, D.26483);
      acfg->got_symbol = D.26484;
      i = 0;
      goto <D.25825>;
      <D.25824>:
      D.26485 = acfg->cfgs;
      D.26486 = (long unsigned int) i;
      D.26487 = D.26486 * 8;
      D.26488 = D.26485 + D.26487;
      D.26489 = *D.26488;
      if (D.26489 != 0B) goto <D.26490>; else goto <D.26491>;
      <D.26490>:
      {
        struct MonoCompile * cfg;
        int method_index;

        D.26485 = acfg->cfgs;
        D.26486 = (long unsigned int) i;
        D.26487 = D.26486 * 8;
        D.26488 = D.26485 + D.26487;
        cfg = *D.26488;
        D.26492 = cfg->orig_method;
        D.26493 = get_method_index (acfg, D.26492);
        method_index = (int) D.26493;
        if (0 != 0) goto <D.26494>; else goto <D.26495>;
        <D.26494>:
        D.26405 = acfg->llvm_label_prefix;
        D.26496 = cfg->llvm_method_name;
        D.26497 = monoeg_g_strdup_printf ("%s%s", D.26405, D.26496);
        cfg->asm_symbol = D.26497;
        goto <D.26498>;
        <D.26495>:
        D.26499 = acfg->global_symbols;
        if (D.26499 != 0) goto <D.26500>; else goto <D.26501>;
        <D.26500>:
        D.26502 = cfg->method;
        D.26503 = acfg->method_label_hash;
        D.26504 = get_debug_sym (D.26502, "", D.26503);
        cfg->asm_symbol = D.26504;
        goto <D.26505>;
        <D.26501>:
        D.26506 = acfg->temp_prefix;
        D.26405 = acfg->llvm_label_prefix;
        D.26507 = monoeg_g_strdup_printf ("%s%sm_%x", D.26506, D.26405, method_index);
        cfg->asm_symbol = D.26507;
        <D.26505>:
        <D.26498>:
      }
      <D.26491>:
      i = i + 1;
      <D.25825>:
      D.26508 = acfg->nmethods;
      i.24 = (unsigned int) i;
      if (D.26508 > i.24) goto <D.25824>; else goto <D.25826>;
      <D.25826>:
      D.26510 = acfg->aot_opts.dwarf_debug;
      if (D.26510 != 0) goto <D.26511>; else goto <D.26512>;
      <D.26511>:
      D.26443 = acfg->aot_opts.asm_only;
      if (D.26443 != 0) goto <D.26513>; else goto <D.26514>;
      <D.26513>:
      D.26515 = acfg->aot_opts.gnu_asm;
      if (D.26515 != 0) goto <D.26516>; else goto <D.26517>;
      <D.26516>:
      acfg->gas_line_numbers = 1;
      <D.26517>:
      <D.26514>:
      <D.26512>:
      D.26520 = acfg->aot_opts.nodebug;
      if (D.26520 == 0) goto <D.26518>; else goto <D.26521>;
      <D.26521>:
      D.26510 = acfg->aot_opts.dwarf_debug;
      if (D.26510 != 0) goto <D.26518>; else goto <D.26519>;
      <D.26518>:
      D.26510 = acfg->aot_opts.dwarf_debug;
      if (D.26510 != 0) goto <D.26522>; else goto <D.26523>;
      <D.26522>:
      D.26524 = mono_debug_enabled ();
      if (D.26524 == 0) goto <D.26525>; else goto <D.26526>;
      <D.26525>:
      stderr.19 = stderr;
      fprintf (stderr.19, "The dwarf AOT option requires the --debug option.\n");
      D.26360 = 1;
      return D.26360;
      <D.26526>:
      <D.26523>:
      D.26527 = acfg->w;
      D.26528 = acfg->gas_line_numbers;
      D.26529 = D.26528 == 0;
      D.26530 = (int) D.26529;
      D.26531 = mono_dwarf_writer_create (D.26527, 0B, 0, 0, D.26530);
      acfg->dwarf = D.26531;
      <D.26519>:
      D.26527 = acfg->w;
      img_writer_emit_start (D.26527);
      D.26532 = acfg->dwarf;
      if (D.26532 != 0B) goto <D.26533>; else goto <D.26534>;
      <D.26533>:
      D.26532 = acfg->dwarf;
      D.26401 = acfg->image;
      D.26453 = D.26401->name;
      D.26535 = monoeg_g_path_get_basename (D.26453);
      D.26536 = mono_unwind_get_cie_program ();
      mono_dwarf_writer_emit_base_info (D.26532, D.26535, D.26536);
      <D.26534>:
      D.26537 = acfg->thumb_mixed;
      if (D.26537 != 0) goto <D.26538>; else goto <D.26539>;
      <D.26538>:
      {
        char symbol[256];

        try
          {
            sprintf (&symbol, "thumb_end");
            emit_section_change (acfg, ".text", 0);
            emit_alignment (acfg, 8);
            emit_label (acfg, &symbol);
            emit_zero_bytes (acfg, 16);
            D.26455 = acfg->fp;
            fprintf (D.26455, ".arm\n");
          }
        finally
          {
            symbol = {CLOBBER};
          }
      }
      <D.26539>:
      emit_code (acfg);
      emit_info (acfg);
      emit_extra_methods (acfg);
      emit_trampolines (acfg);
      emit_class_name_table (acfg);
      emit_got_info (acfg);
      emit_exception_info (acfg);
      emit_unwind_info (acfg);
      emit_class_info (acfg);
      emit_plt (acfg);
      emit_image_table (acfg);
      emit_got (acfg);
      emit_file_info (acfg);
      emit_blob (acfg);
      emit_objc_selectors (acfg);
      emit_globals (acfg);
      emit_autoreg (acfg);
      D.26532 = acfg->dwarf;
      if (D.26532 != 0B) goto <D.26540>; else goto <D.26541>;
      <D.26540>:
      emit_dwarf_info (acfg);
      D.26532 = acfg->dwarf;
      mono_dwarf_writer_close (D.26532);
      <D.26541>:
      emit_mem_end (acfg);
      D.26542 = acfg->need_pt_gnu_stack;
      if (D.26542 != 0) goto <D.26543>; else goto <D.26544>;
      <D.26543>:
      D.26545 = acfg->use_bin_writer;
      if (D.26545 == 0) goto <D.26546>; else goto <D.26547>;
      <D.26546>:
      D.26455 = acfg->fp;
      fprintf (D.26455, "\n.section\t.note.GNU-stack,\"\",@progbits\n");
      <D.26547>:
      <D.26544>:
      btv = mono_100ns_ticks ();
      D.26438 = btv - atv;
      D.26439 = D.26438 / 10;
      D.26440 = (int) D.26439;
      acfg->stats.gen_time = D.26440;
      D.26462 = acfg->llvm;
      if (D.26462 != 0) goto <D.26548>; else goto <D.26549>;
      <D.26548>:
      D.26550 = acfg->got_offset;
      D.26551 = acfg->final_got_size;
      D.26552 = D.26550 > D.26551;
      D.26553 = (long int) D.26552;
      D.26554 = __builtin_expect (D.26553, 0);
      if (D.26554 != 0) goto <D.26555>; else goto <D.26556>;
      <D.26555>:
      monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "aot-compiler.c", 9004, "acfg->got_offset <= acfg->final_got_size");
      <D.26556>:
      <D.26549>:
      D.26462 = acfg->llvm;
      if (D.26462 != 0) goto <D.26557>; else goto <D.26558>;
      <D.26557>:
      D.26559 = acfg->stats.llvm_count;
      D.26561 = acfg->stats.mcount;
      if (D.26561 != 0) goto <D.26562>; else goto <D.26563>;
      <D.26562>:
      D.26559 = acfg->stats.llvm_count;
      D.26564 = D.26559 * 100;
      D.26561 = acfg->stats.mcount;
      iftmp.25 = D.26564 / D.26561;
      goto <D.26565>;
      <D.26563>:
      iftmp.25 = 100;
      <D.26565>:
      sprintf (&llvm_stats_msg, ", LLVM: %d (%d%%)", D.26559, iftmp.25);
      goto <D.26566>;
      <D.26558>:
      strcpy (&llvm_stats_msg, "");
      <D.26566>:
      D.26567 = acfg->stats.code_size;
      D.26568 = acfg->stats.info_size;
      D.26569 = acfg->stats.ex_info_size;
      D.26570 = acfg->stats.unwind_info_size;
      D.26571 = acfg->stats.class_info_size;
      D.26572 = acfg->plt_offset;
      D.26573 = acfg->stats.got_info_size;
      D.26550 = acfg->got_offset;
      D.26574 = D.26550 * 8;
      D.26575 = (int) D.26574;
      D.26576 = acfg->stats.offsets_size;
      printf ("Code: %d Info: %d Ex Info: %d Unwind Info: %d Class Info: %d PLT: %d GOT Info: %d GOT: %d Offsets: %d\n", D.26567, D.26568, D.26569, D.26570, D.26571, D.26572, D.26573, D.26575, D.26576);
      D.26577 = acfg->stats.ccount;
      D.26561 = acfg->stats.mcount;
      D.26561 = acfg->stats.mcount;
      if (D.26561 != 0) goto <D.26579>; else goto <D.26580>;
      <D.26579>:
      D.26577 = acfg->stats.ccount;
      D.26581 = D.26577 * 100;
      D.26561 = acfg->stats.mcount;
      iftmp.26 = D.26581 / D.26561;
      goto <D.26582>;
      <D.26580>:
      iftmp.26 = 100;
      <D.26582>:
      D.26583 = acfg->stats.methods_without_got_slots;
      D.26561 = acfg->stats.mcount;
      if (D.26561 != 0) goto <D.26585>; else goto <D.26586>;
      <D.26585>:
      D.26583 = acfg->stats.methods_without_got_slots;
      D.26587 = D.26583 * 100;
      D.26561 = acfg->stats.mcount;
      iftmp.27 = D.26587 / D.26561;
      goto <D.26588>;
      <D.26586>:
      iftmp.27 = 100;
      <D.26588>:
      D.26589 = acfg->stats.direct_calls;
      D.26591 = acfg->stats.all_calls;
      if (D.26591 != 0) goto <D.26592>; else goto <D.26593>;
      <D.26592>:
      D.26589 = acfg->stats.direct_calls;
      D.26594 = D.26589 * 100;
      D.26591 = acfg->stats.all_calls;
      iftmp.28 = D.26594 / D.26591;
      goto <D.26595>;
      <D.26593>:
      iftmp.28 = 100;
      <D.26595>:
      printf ("Compiled: %d/%d (%d%%)%s, No GOT slots: %d (%d%%), Direct calls: %d (%d%%)\n", D.26577, D.26561, iftmp.26, &llvm_stats_msg, D.26583, iftmp.27, D.26589, iftmp.28);
      D.26596 = acfg->stats.genericcount;
      if (D.26596 != 0) goto <D.26597>; else goto <D.26598>;
      <D.26597>:
      D.26596 = acfg->stats.genericcount;
      D.26561 = acfg->stats.mcount;
      if (D.26561 != 0) goto <D.26600>; else goto <D.26601>;
      <D.26600>:
      D.26596 = acfg->stats.genericcount;
      D.26602 = D.26596 * 100;
      D.26561 = acfg->stats.mcount;
      iftmp.29 = D.26602 / D.26561;
      goto <D.26603>;
      <D.26601>:
      iftmp.29 = 100;
      <D.26603>:
      printf ("%d methods are generic (%d%%)\n", D.26596, iftmp.29);
      <D.26598>:
      D.26604 = acfg->stats.abscount;
      if (D.26604 != 0) goto <D.26605>; else goto <D.26606>;
      <D.26605>:
      D.26604 = acfg->stats.abscount;
      D.26561 = acfg->stats.mcount;
      if (D.26561 != 0) goto <D.26608>; else goto <D.26609>;
      <D.26608>:
      D.26604 = acfg->stats.abscount;
      D.26610 = D.26604 * 100;
      D.26561 = acfg->stats.mcount;
      iftmp.30 = D.26610 / D.26561;
      goto <D.26611>;
      <D.26609>:
      iftmp.30 = 100;
      <D.26611>:
      printf ("%d methods contain absolute addresses (%d%%)\n", D.26604, iftmp.30);
      <D.26606>:
      D.26612 = acfg->stats.lmfcount;
      if (D.26612 != 0) goto <D.26613>; else goto <D.26614>;
      <D.26613>:
      D.26612 = acfg->stats.lmfcount;
      D.26561 = acfg->stats.mcount;
      if (D.26561 != 0) goto <D.26616>; else goto <D.26617>;
      <D.26616>:
      D.26612 = acfg->stats.lmfcount;
      D.26618 = D.26612 * 100;
      D.26561 = acfg->stats.mcount;
      iftmp.31 = D.26618 / D.26561;
      goto <D.26619>;
      <D.26617>:
      iftmp.31 = 100;
      <D.26619>:
      printf ("%d methods contain lmf pointers (%d%%)\n", D.26612, iftmp.31);
      <D.26614>:
      D.26620 = acfg->stats.ocount;
      if (D.26620 != 0) goto <D.26621>; else goto <D.26622>;
      <D.26621>:
      D.26620 = acfg->stats.ocount;
      D.26561 = acfg->stats.mcount;
      if (D.26561 != 0) goto <D.26624>; else goto <D.26625>;
      <D.26624>:
      D.26620 = acfg->stats.ocount;
      D.26626 = D.26620 * 100;
      D.26561 = acfg->stats.mcount;
      iftmp.32 = D.26626 / D.26561;
      goto <D.26627>;
      <D.26625>:
      iftmp.32 = 100;
      <D.26627>:
      printf ("%d methods have other problems (%d%%)\n", D.26620, iftmp.32);
      <D.26622>:
      atv = mono_100ns_ticks ();
      D.26527 = acfg->w;
      res = img_writer_emit_writeout (D.26527);
      if (res != 0) goto <D.26628>; else goto <D.26629>;
      <D.26628>:
      acfg_free (acfg);
      D.26360 = res;
      return D.26360;
      <D.26629>:
      D.26545 = acfg->use_bin_writer;
      if (D.26545 != 0) goto <D.26630>; else goto <D.26631>;
      <D.26630>:
      {
        int err;

        err = rename (tmp_outfile_name, outfile_name);
        if (err != 0) goto <D.26632>; else goto <D.26633>;
        <D.26632>:
        D.26458 = __errno_location ();
        D.26459 = *D.26458;
        D.26634 = strerror (D.26459);
        printf ("Unable to rename \'%s\' to \'%s\': %s\n", tmp_outfile_name, outfile_name, D.26634);
        D.26360 = 1;
        return D.26360;
        <D.26633>:
      }
      goto <D.26635>;
      <D.26631>:
      res = compile_asm (acfg);
      if (res != 0) goto <D.26636>; else goto <D.26637>;
      <D.26636>:
      acfg_free (acfg);
      D.26360 = res;
      return D.26360;
      <D.26637>:
      <D.26635>:
      btv = mono_100ns_ticks ();
      D.26438 = btv - atv;
      D.26439 = D.26438 / 10;
      D.26440 = (int) D.26439;
      acfg->stats.link_time = D.26440;
      D.26638 = acfg->aot_opts.stats;
      if (D.26638 != 0) goto <D.26639>; else goto <D.26640>;
      <D.26639>:
      {
        int i;

        printf ("GOT slot distribution:\n");
        i = 0;
        goto <D.25831>;
        <D.25830>:
        D.26641 = acfg->stats.got_slot_types[i];
        if (D.26641 != 0) goto <D.26642>; else goto <D.26643>;
        <D.26642>:
        D.26644 = get_patch_name (i);
        D.26641 = acfg->stats.got_slot_types[i];
        D.26645 = acfg->stats.got_slot_info_sizes[i];
        printf ("\t%s: %d (%d)\n", D.26644, D.26641, D.26645);
        <D.26643>:
        i = i + 1;
        <D.25831>:
        if (i <= 50) goto <D.25830>; else goto <D.25832>;
        <D.25832>:
      }
      <D.26640>:
      D.26646 = acfg->stats.jit_time;
      D.26647 = D.26646 / 1000;
      D.26648 = acfg->stats.gen_time;
      D.26649 = D.26648 / 1000;
      D.26650 = acfg->stats.link_time;
      D.26651 = D.26650 / 1000;
      printf ("JIT time: %d ms, Generation time: %d ms, Assembly+Link time: %d ms.\n", D.26647, D.26649, D.26651);
      acfg_free (acfg);
      D.26360 = 0;
      return D.26360;
    }
  finally
    {
      llvm_stats_msg = {CLOBBER};
    }
}


acfg_create (struct MonoAssembly * ass, guint32 opts)
{
  struct GPtrArray * D.26654;
  struct GHashTable * D.26655;
  struct GHashTable * D.26656;
  struct GHashTable * D.26657;
  void * D.26658;
  struct GHashTable * D.26659;
  void * D.26660;
  struct GHashTable * * D.26661;
  long unsigned int D.26662;
  long unsigned int D.26663;
  struct GHashTable * * D.26664;
  struct GHashTable * D.26665;
  struct GPtrArray * D.26666;
  struct GHashTable * D.26667;
  struct GHashTable * D.26668;
  struct GHashTable * D.26669;
  struct GHashTable * D.26670;
  struct GPtrArray * D.26671;
  struct GPtrArray * D.26672;
  unsigned int D.26673;
  struct MonoMemPool * D.26674;
  struct GPtrArray * D.26675;
  struct GHashTable * D.26676;
  struct GPtrArray * D.26677;
  struct GHashTable * D.26678;
  struct GPtrArray * D.26679;
  struct GHashTable * D.26680;
  struct GHashTable * D.26681;
  struct GHashTable * D.26682;
  struct GHashTable * D.26683;
  struct CRITICAL_SECTION * D.26684;
  struct MonoAotCompile * D.26685;
  struct MonoImage * image;
  struct MonoAotCompile * acfg;
  int i;

  image = ass->image;
  acfg = monoeg_malloc0 (1304);
  D.26654 = monoeg_g_ptr_array_new ();
  acfg->methods = D.26654;
  D.26655 = monoeg_g_hash_table_new (0B, 0B);
  acfg->method_indexes = D.26655;
  D.26656 = monoeg_g_hash_table_new (0B, 0B);
  acfg->method_depth = D.26656;
  D.26657 = monoeg_g_hash_table_new (0B, 0B);
  acfg->plt_offset_to_entry = D.26657;
  D.26658 = monoeg_malloc0 (416);
  acfg->patch_to_plt_entry = D.26658;
  D.26659 = monoeg_g_hash_table_new (mono_patch_info_hash, mono_patch_info_equal);
  acfg->patch_to_got_offset = D.26659;
  D.26660 = monoeg_malloc0 (416);
  acfg->patch_to_got_offset_by_type = D.26660;
  i = 0;
  goto <D.25780>;
  <D.25779>:
  D.26661 = acfg->patch_to_got_offset_by_type;
  D.26662 = (long unsigned int) i;
  D.26663 = D.26662 * 8;
  D.26664 = D.26661 + D.26663;
  D.26665 = monoeg_g_hash_table_new (mono_patch_info_hash, mono_patch_info_equal);
  *D.26664 = D.26665;
  i = i + 1;
  <D.25780>:
  if (i <= 51) goto <D.25779>; else goto <D.25781>;
  <D.25781>:
  D.26666 = monoeg_g_ptr_array_new ();
  acfg->got_patches = D.26666;
  D.26667 = monoeg_g_hash_table_new (0B, 0B);
  acfg->method_to_cfg = D.26667;
  D.26668 = monoeg_g_hash_table_new_full (0B, 0B, 0B, monoeg_g_free);
  acfg->token_info_hash = D.26668;
  D.26669 = monoeg_g_hash_table_new_full (0B, 0B, 0B, monoeg_g_free);
  acfg->method_to_pinvoke_import = D.26669;
  D.26670 = monoeg_g_hash_table_new (0B, 0B);
  acfg->image_hash = D.26670;
  D.26671 = monoeg_g_ptr_array_new ();
  acfg->image_table = D.26671;
  D.26672 = monoeg_g_ptr_array_new ();
  acfg->globals = D.26672;
  acfg->image = image;
  acfg->opts = opts;
  D.26673 = mono_arch_cpu_enumerate_simd_versions ();
  acfg->simd_opts = D.26673;
  D.26674 = mono_mempool_new ();
  acfg->mempool = D.26674;
  D.26675 = monoeg_g_ptr_array_new ();
  acfg->extra_methods = D.26675;
  D.26676 = monoeg_g_hash_table_new (0B, 0B);
  acfg->unwind_info_offsets = D.26676;
  D.26677 = monoeg_g_ptr_array_new ();
  acfg->unwind_ops = D.26677;
  D.26678 = monoeg_g_hash_table_new_full (monoeg_g_str_hash, monoeg_g_str_equal, monoeg_g_free, 0B);
  acfg->method_label_hash = D.26678;
  D.26679 = monoeg_g_ptr_array_new ();
  acfg->method_order = D.26679;
  D.26680 = monoeg_g_hash_table_new (0B, 0B);
  acfg->export_names = D.26680;
  D.26681 = monoeg_g_hash_table_new (0B, 0B);
  acfg->klass_blob_hash = D.26681;
  D.26682 = monoeg_g_hash_table_new (0B, 0B);
  acfg->method_blob_hash = D.26682;
  D.26683 = monoeg_g_hash_table_new (monoeg_g_str_hash, monoeg_g_str_equal);
  acfg->plt_entry_debug_sym_cache = D.26683;
  D.26684 = &acfg->mutex;
  InitializeCriticalSection (D.26684);
  D.26685 = acfg;
  return D.26685;
}


mono_aot_parse_options (const char * aot_options, struct MonoAotOptions * opts)
{
  const gchar * iftmp.33;
  int D.26691;
  long unsigned int D.26694;
  const char * D.26695;
  gchar * D.26696;
  int D.26698;
  int D.26702;
  int D.26706;
  int D.26710;
  int D.26714;
  int D.26718;
  int D.26722;
  int D.26726;
  long unsigned int D.26729;
  const char * D.26730;
  int D.26731;
  int D.26733;
  int D.26737;
  int D.26741;
  int D.26745;
  int D.26749;
  int D.26753;
  int D.26757;
  long unsigned int D.26760;
  const char * D.26761;
  int D.26762;
  int D.26764;
  long unsigned int D.26767;
  const char * D.26768;
  int D.26769;
  int D.26771;
  long unsigned int D.26774;
  const char * D.26775;
  int D.26776;
  int D.26778;
  long unsigned int D.26781;
  const char * D.26782;
  int D.26783;
  int D.26785;
  int D.26789;
  long unsigned int D.26792;
  const char * D.26793;
  gchar * D.26794;
  int D.26796;
  int D.26800;
  int D.26804;
  int D.26808;
  int D.26812;
  int D.26816;
  int D.26820;
  int D.26824;
  int D.26828;
  long unsigned int D.26831;
  const char * D.26832;
  gchar * D.26833;
  int D.26835;
  long unsigned int D.26838;
  const char * D.26839;
  gchar * D.26840;
  int D.26842;
  long unsigned int D.26845;
  const char * D.26846;
  int D.26848;
  int D.26851;
  int D.26857;
  int D.26859;
  struct _IO_FILE * stderr.34;
  gchar * D.26862;
  int D.26863;
  gchar * * args;
  gchar * * ptr;

  if (aot_options != 0B) goto <D.26688>; else goto <D.26689>;
  <D.26688>:
  iftmp.33 = aot_options;
  goto <D.26690>;
  <D.26689>:
  iftmp.33 = "";
  <D.26690>:
  args = monoeg_g_strsplit (iftmp.33, ",", -1);
  ptr = args;
  goto <D.25187>;
  <D.25186>:
  {
    const char * arg;

    arg = *ptr;
    D.26691 = str_begins_with (arg, "outfile=");
    if (D.26691 != 0) goto <D.26692>; else goto <D.26693>;
    <D.26692>:
    D.26694 = __strlen_g ("outfile=");
    D.26695 = arg + D.26694;
    D.26696 = monoeg_strdup (D.26695);
    opts->outfile = D.26696;
    goto <D.26697>;
    <D.26693>:
    D.26698 = str_begins_with (arg, "save-temps");
    if (D.26698 != 0) goto <D.26699>; else goto <D.26700>;
    <D.26699>:
    opts->save_temps = 1;
    goto <D.26701>;
    <D.26700>:
    D.26702 = str_begins_with (arg, "keep-temps");
    if (D.26702 != 0) goto <D.26703>; else goto <D.26704>;
    <D.26703>:
    opts->save_temps = 1;
    goto <D.26705>;
    <D.26704>:
    D.26706 = str_begins_with (arg, "write-symbols");
    if (D.26706 != 0) goto <D.26707>; else goto <D.26708>;
    <D.26707>:
    opts->write_symbols = 1;
    goto <D.26709>;
    <D.26708>:
    D.26710 = str_begins_with (arg, "no-write-symbols");
    if (D.26710 != 0) goto <D.26711>; else goto <D.26712>;
    <D.26711>:
    opts->write_symbols = 0;
    goto <D.26713>;
    <D.26712>:
    D.26714 = str_begins_with (arg, "metadata-only");
    if (D.26714 != 0) goto <D.26715>; else goto <D.26716>;
    <D.26715>:
    opts->metadata_only = 1;
    goto <D.26717>;
    <D.26716>:
    D.26718 = str_begins_with (arg, "bind-to-runtime-version");
    if (D.26718 != 0) goto <D.26719>; else goto <D.26720>;
    <D.26719>:
    opts->bind_to_runtime_version = 1;
    goto <D.26721>;
    <D.26720>:
    D.26722 = str_begins_with (arg, "full");
    if (D.26722 != 0) goto <D.26723>; else goto <D.26724>;
    <D.26723>:
    opts->full_aot = 1;
    goto <D.26725>;
    <D.26724>:
    D.26726 = str_begins_with (arg, "threads=");
    if (D.26726 != 0) goto <D.26727>; else goto <D.26728>;
    <D.26727>:
    D.26729 = __strlen_g ("threads=");
    D.26730 = arg + D.26729;
    D.26731 = atoi (D.26730);
    opts->nthreads = D.26731;
    goto <D.26732>;
    <D.26728>:
    D.26733 = str_begins_with (arg, "static");
    if (D.26733 != 0) goto <D.26734>; else goto <D.26735>;
    <D.26734>:
    opts->static_link = 1;
    opts->no_dlsym = 1;
    goto <D.26736>;
    <D.26735>:
    D.26737 = str_begins_with (arg, "asmonly");
    if (D.26737 != 0) goto <D.26738>; else goto <D.26739>;
    <D.26738>:
    opts->asm_only = 1;
    goto <D.26740>;
    <D.26739>:
    D.26741 = str_begins_with (arg, "asmwriter");
    if (D.26741 != 0) goto <D.26742>; else goto <D.26743>;
    <D.26742>:
    opts->asm_writer = 1;
    goto <D.26744>;
    <D.26743>:
    D.26745 = str_begins_with (arg, "nodebug");
    if (D.26745 != 0) goto <D.26746>; else goto <D.26747>;
    <D.26746>:
    opts->nodebug = 1;
    goto <D.26748>;
    <D.26747>:
    D.26749 = str_begins_with (arg, "dwarfdebug");
    if (D.26749 != 0) goto <D.26750>; else goto <D.26751>;
    <D.26750>:
    opts->dwarf_debug = 1;
    goto <D.26752>;
    <D.26751>:
    D.26753 = str_begins_with (arg, "nopagetrampolines");
    if (D.26753 != 0) goto <D.26754>; else goto <D.26755>;
    <D.26754>:
    opts->use_trampolines_page = 0;
    goto <D.26756>;
    <D.26755>:
    D.26757 = str_begins_with (arg, "ntrampolines=");
    if (D.26757 != 0) goto <D.26758>; else goto <D.26759>;
    <D.26758>:
    D.26760 = __strlen_g ("ntrampolines=");
    D.26761 = arg + D.26760;
    D.26762 = atoi (D.26761);
    opts->ntrampolines = D.26762;
    goto <D.26763>;
    <D.26759>:
    D.26764 = str_begins_with (arg, "nrgctx-trampolines=");
    if (D.26764 != 0) goto <D.26765>; else goto <D.26766>;
    <D.26765>:
    D.26767 = __strlen_g ("nrgctx-trampolines=");
    D.26768 = arg + D.26767;
    D.26769 = atoi (D.26768);
    opts->nrgctx_trampolines = D.26769;
    goto <D.26770>;
    <D.26766>:
    D.26771 = str_begins_with (arg, "nimt-trampolines=");
    if (D.26771 != 0) goto <D.26772>; else goto <D.26773>;
    <D.26772>:
    D.26774 = __strlen_g ("nimt-trampolines=");
    D.26775 = arg + D.26774;
    D.26776 = atoi (D.26775);
    opts->nimt_trampolines = D.26776;
    goto <D.26777>;
    <D.26773>:
    D.26778 = str_begins_with (arg, "ngsharedvt-trampolines=");
    if (D.26778 != 0) goto <D.26779>; else goto <D.26780>;
    <D.26779>:
    D.26781 = __strlen_g ("ngsharedvt-trampolines=");
    D.26782 = arg + D.26781;
    D.26783 = atoi (D.26782);
    opts->ngsharedvt_arg_trampolines = D.26783;
    goto <D.26784>;
    <D.26780>:
    D.26785 = str_begins_with (arg, "autoreg");
    if (D.26785 != 0) goto <D.26786>; else goto <D.26787>;
    <D.26786>:
    opts->autoreg = 1;
    goto <D.26788>;
    <D.26787>:
    D.26789 = str_begins_with (arg, "tool-prefix=");
    if (D.26789 != 0) goto <D.26790>; else goto <D.26791>;
    <D.26790>:
    D.26792 = __strlen_g ("tool-prefix=");
    D.26793 = arg + D.26792;
    D.26794 = monoeg_strdup (D.26793);
    opts->tool_prefix = D.26794;
    goto <D.26795>;
    <D.26791>:
    D.26796 = str_begins_with (arg, "soft-debug");
    if (D.26796 != 0) goto <D.26797>; else goto <D.26798>;
    <D.26797>:
    opts->soft_debug = 1;
    goto <D.26799>;
    <D.26798>:
    D.26800 = str_begins_with (arg, "direct-pinvoke");
    if (D.26800 != 0) goto <D.26801>; else goto <D.26802>;
    <D.26801>:
    opts->direct_pinvoke = 1;
    goto <D.26803>;
    <D.26802>:
    D.26804 = str_begins_with (arg, "direct-icalls");
    if (D.26804 != 0) goto <D.26805>; else goto <D.26806>;
    <D.26805>:
    opts->direct_icalls = 1;
    goto <D.26807>;
    <D.26806>:
    D.26808 = str_begins_with (arg, "no-direct-calls");
    if (D.26808 != 0) goto <D.26809>; else goto <D.26810>;
    <D.26809>:
    opts->no_direct_calls = 1;
    goto <D.26811>;
    <D.26810>:
    D.26812 = str_begins_with (arg, "print-skipped");
    if (D.26812 != 0) goto <D.26813>; else goto <D.26814>;
    <D.26813>:
    opts->print_skipped_methods = 1;
    goto <D.26815>;
    <D.26814>:
    D.26816 = str_begins_with (arg, "stats");
    if (D.26816 != 0) goto <D.26817>; else goto <D.26818>;
    <D.26817>:
    opts->stats = 1;
    goto <D.26819>;
    <D.26818>:
    D.26820 = str_begins_with (arg, "no-instances");
    if (D.26820 != 0) goto <D.26821>; else goto <D.26822>;
    <D.26821>:
    opts->no_instances = 1;
    goto <D.26823>;
    <D.26822>:
    D.26824 = str_begins_with (arg, "log-generics");
    if (D.26824 != 0) goto <D.26825>; else goto <D.26826>;
    <D.26825>:
    opts->log_generics = 1;
    goto <D.26827>;
    <D.26826>:
    D.26828 = str_begins_with (arg, "mtriple=");
    if (D.26828 != 0) goto <D.26829>; else goto <D.26830>;
    <D.26829>:
    D.26831 = __strlen_g ("mtriple=");
    D.26832 = arg + D.26831;
    D.26833 = monoeg_strdup (D.26832);
    opts->mtriple = D.26833;
    goto <D.26834>;
    <D.26830>:
    D.26835 = str_begins_with (arg, "llvm-path=");
    if (D.26835 != 0) goto <D.26836>; else goto <D.26837>;
    <D.26836>:
    D.26838 = __strlen_g ("llvm-path=");
    D.26839 = arg + D.26838;
    D.26840 = monoeg_strdup (D.26839);
    opts->llvm_path = D.26840;
    goto <D.26841>;
    <D.26837>:
    D.26842 = str_begins_with (arg, "readonly-value=");
    if (D.26842 != 0) goto <D.26843>; else goto <D.26844>;
    <D.26843>:
    D.26845 = __strlen_g ("readonly-value=");
    D.26846 = arg + D.26845;
    add_readonly_value (opts, D.26846);
    goto <D.26847>;
    <D.26844>:
    D.26848 = str_begins_with (arg, "info");
    if (D.26848 != 0) goto <D.26849>; else goto <D.26850>;
    <D.26849>:
    printf ("AOT target setup: %s.\n", "");
    exit (0);
    <D.26850>:
    D.26851 = str_begins_with (arg, "gc-maps");
    if (D.26851 != 0) goto <D.26852>; else goto <D.26853>;
    <D.26852>:
    mini_gc_enable_gc_maps_for_aot ();
    goto <D.26854>;
    <D.26853>:
    D.26857 = str_begins_with (arg, "help");
    if (D.26857 != 0) goto <D.26855>; else goto <D.26858>;
    <D.26858>:
    D.26859 = str_begins_with (arg, "?");
    if (D.26859 != 0) goto <D.26855>; else goto <D.26856>;
    <D.26855>:
    printf ("Supported options for --aot:\n");
    printf ("    outfile=\n");
    printf ("    save-temps\n");
    printf ("    keep-temps\n");
    printf ("    write-symbols\n");
    printf ("    metadata-only\n");
    printf ("    bind-to-runtime-version\n");
    printf ("    full\n");
    printf ("    threads=\n");
    printf ("    static\n");
    printf ("    asmonly\n");
    printf ("    asmwriter\n");
    printf ("    nodebug\n");
    printf ("    dwarfdebug\n");
    printf ("    ntrampolines=\n");
    printf ("    nrgctx-trampolines=\n");
    printf ("    nimt-trampolines=\n");
    printf ("    ngsharedvt-trampolines=\n");
    printf ("    autoreg\n");
    printf ("    tool-prefix=\n");
    printf ("    readonly-value=\n");
    printf ("    soft-debug\n");
    printf ("    gc-maps\n");
    printf ("    print-skipped\n");
    printf ("    no-instances\n");
    printf ("    stats\n");
    printf ("    info\n");
    printf ("    help/?\n");
    exit (0);
    <D.26856>:
    stderr.34 = stderr;
    fprintf (stderr.34, "AOT : Unknown argument \'%s\'.\n", arg);
    exit (1);
    <D.26854>:
    <D.26847>:
    <D.26841>:
    <D.26834>:
    <D.26827>:
    <D.26823>:
    <D.26819>:
    <D.26815>:
    <D.26811>:
    <D.26807>:
    <D.26803>:
    <D.26799>:
    <D.26795>:
    <D.26788>:
    <D.26784>:
    <D.26777>:
    <D.26770>:
    <D.26763>:
    <D.26756>:
    <D.26752>:
    <D.26748>:
    <D.26744>:
    <D.26740>:
    <D.26736>:
    <D.26732>:
    <D.26725>:
    <D.26721>:
    <D.26717>:
    <D.26713>:
    <D.26709>:
    <D.26705>:
    <D.26701>:
    <D.26697>:
  }
  ptr = ptr + 8;
  <D.25187>:
  if (ptr != 0B) goto <D.26861>; else goto <D.25188>;
  <D.26861>:
  D.26862 = *ptr;
  if (D.26862 != 0B) goto <D.25186>; else goto <D.25188>;
  <D.25188>:
  D.26863 = opts->use_trampolines_page;
  if (D.26863 != 0) goto <D.26864>; else goto <D.26865>;
  <D.26864>:
  opts->ntrampolines = 0;
  opts->nrgctx_trampolines = 0;
  opts->nimt_trampolines = 0;
  opts->ngsharedvt_arg_trampolines = 0;
  <D.26865>:
  monoeg_g_strfreev (args);
}


__attribute__((__gnu_inline__, __pure__, __leaf__, __nothrow__))
atoi (const char * __nptr)
{
  int D.26866;
  long int D.26867;

  D.26867 = strtol (__nptr, 0B, 10);
  D.26866 = (int) D.26867;
  return D.26866;
}


add_readonly_value (struct MonoAotOptions * opts, const char * val)
{
  struct _IO_FILE * stderr.35;
  long int tval.36;
  long int val.37;
  long int D.26876;
  long int D.26877;
  long unsigned int D.26878;
  void * D.26879;
  char * D.26880;
  long unsigned int D.26881;
  _Bool iftmp.38;
  long unsigned int D.26883;
  int D.26886;
  int D.26888;
  int D.26891;
  unsigned char D.26892;
  _Bool iftmp.39;
  long unsigned int D.26895;
  int D.26898;
  int D.26900;
  int D.26903;
  short unsigned int D.26904;
  _Bool iftmp.40;
  long unsigned int D.26907;
  int D.26910;
  int D.26912;
  int D.26915;
  unsigned int D.26916;
  struct ReadOnlyValue * readonly_values.41;
  struct ReadOnlyValue * rdv;
  const char * fval;
  const char * tval;

  fval = strrchr (val, 47);
  if (fval == 0B) goto <D.26869>; else goto <D.26870>;
  <D.26869>:
  stderr.35 = stderr;
  fprintf (stderr.35, "AOT : invalid format for readonly field \'%s\', missing /.\n", val);
  exit (1);
  <D.26870>:
  tval = strrchr (val, 61);
  if (tval == 0B) goto <D.26872>; else goto <D.26873>;
  <D.26872>:
  stderr.35 = stderr;
  fprintf (stderr.35, "AOT : invalid format for readonly field \'%s\', missing =.\n", val);
  exit (1);
  <D.26873>:
  rdv = monoeg_malloc0 (32);
  tval.36 = (long int) tval;
  val.37 = (long int) val;
  D.26876 = tval.36 - val.37;
  D.26877 = D.26876 + 1;
  D.26878 = (long unsigned int) D.26877;
  D.26879 = monoeg_malloc0 (D.26878);
  rdv->name = D.26879;
  D.26880 = rdv->name;
  tval.36 = (long int) tval;
  val.37 = (long int) val;
  D.26876 = tval.36 - val.37;
  D.26881 = (long unsigned int) D.26876;
  memcpy (D.26880, val, D.26881);
  tval = tval + 1;
  fval = fval + 1;
  D.26883 = __strlen_g ("i1");
  if (D.26883 <= 1) goto <D.26884>; else goto <D.26885>;
  <D.26884>:
  D.26886 = strcmp (tval, "i1");
  iftmp.38 = D.26886 == 0;
  goto <D.26887>;
  <D.26885>:
  D.26888 = strncmp (tval, "i1", 2);
  iftmp.38 = D.26888 == 0;
  <D.26887>:
  if (iftmp.38 != 0) goto <D.26889>; else goto <D.26890>;
  <D.26889>:
  D.26891 = atoi (fval);
  D.26892 = (unsigned char) D.26891;
  rdv->value.i1 = D.26892;
  rdv->type = 4;
  goto <D.26893>;
  <D.26890>:
  D.26895 = __strlen_g ("i2");
  if (D.26895 <= 1) goto <D.26896>; else goto <D.26897>;
  <D.26896>:
  D.26898 = strcmp (tval, "i2");
  iftmp.39 = D.26898 == 0;
  goto <D.26899>;
  <D.26897>:
  D.26900 = strncmp (tval, "i2", 2);
  iftmp.39 = D.26900 == 0;
  <D.26899>:
  if (iftmp.39 != 0) goto <D.26901>; else goto <D.26902>;
  <D.26901>:
  D.26903 = atoi (fval);
  D.26904 = (short unsigned int) D.26903;
  rdv->value.i2 = D.26904;
  rdv->type = 6;
  goto <D.26905>;
  <D.26902>:
  D.26907 = __strlen_g ("i4");
  if (D.26907 <= 1) goto <D.26908>; else goto <D.26909>;
  <D.26908>:
  D.26910 = strcmp (tval, "i4");
  iftmp.40 = D.26910 == 0;
  goto <D.26911>;
  <D.26909>:
  D.26912 = strncmp (tval, "i4", 2);
  iftmp.40 = D.26912 == 0;
  <D.26911>:
  if (iftmp.40 != 0) goto <D.26913>; else goto <D.26914>;
  <D.26913>:
  D.26915 = atoi (fval);
  D.26916 = (unsigned int) D.26915;
  rdv->value.i4 = D.26916;
  rdv->type = 8;
  goto <D.26917>;
  <D.26914>:
  stderr.35 = stderr;
  fprintf (stderr.35, "AOT : unsupported type for readonly field \'%s\'.\n", tval);
  exit (1);
  <D.26917>:
  <D.26905>:
  <D.26893>:
  readonly_values.41 = readonly_values;
  rdv->next = readonly_values.41;
  readonly_values = rdv;
}


str_begins_with (const char * str1, const char * str2)
{
  long unsigned int D.26919;
  gboolean D.26920;
  long unsigned int D.26921;
  int D.26922;
  _Bool D.26923;
  int len;

  D.26919 = __strlen_g (str2);
  len = (int) D.26919;
  D.26921 = (long unsigned int) len;
  D.26922 = strncmp (str1, str2, D.26921);
  D.26923 = D.26922 == 0;
  D.26920 = (gboolean) D.26923;
  return D.26920;
}


load_profile_files (struct MonoAotCompile * acfg)
{
  const gchar * D.26925;
  struct MonoImage * D.26926;
  const char * D.26927;
  int D.26928;
  _Bool D.26931;
  long int D.26932;
  long int D.26933;
  int D.26939;
  char * D.26940;
  long unsigned int D.26942;
  long unsigned int D.26945;
  long unsigned int D.26946;
  unsigned int D.26949;
  unsigned int D.26952;
  unsigned int D.26953;
  struct GPtrArray * D.26954;
  void * * D.26955;
  long unsigned int D.26956;
  long unsigned int D.26957;
  void * * D.26958;
  void * D.26959;
  long unsigned int D.26960;
  void * D.26961;
  unsigned int D.26964;
  unsigned int i.42;
  <unnamed-unsigned:24> D.26973;
  int D.26974;
  void * D.26975;
  struct FILE * infile;
  char * tmp;
  int file_index;
  int res;
  int method_index;
  int i;
  char ver[256];
  guint32 token;
  struct GList * unordered;
  struct GList * l;
  gboolean found;

  try
    {
      file_index = 0;
      <D.25363>:
      D.26925 = monoeg_g_get_home_dir ();
      D.26926 = acfg->image;
      D.26927 = D.26926->assembly_name;
      tmp = monoeg_g_strdup_printf ("%s/.mono/aot-profile-data/%s-%d", D.26925, D.26927, file_index);
      D.26928 = monoeg_g_file_test (tmp, 1);
      if (D.26928 == 0) goto <D.26929>; else goto <D.26930>;
      <D.26929>:
      monoeg_g_free (tmp);
      goto <D.25353>;
      <D.26930>:
      infile = fopen (tmp, "r");
      D.26931 = infile == 0B;
      D.26932 = (long int) D.26931;
      D.26933 = __builtin_expect (D.26932, 0);
      if (D.26933 != 0) goto <D.26934>; else goto <D.26935>;
      <D.26934>:
      monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "aot-compiler.c", 6785, "infile");
      <D.26935>:
      printf ("Using profile data file \'%s\'\n", tmp);
      monoeg_g_free (tmp);
      file_index = file_index + 1;
      res = fscanf (infile, "%32s\n", &ver);
      if (res != 1) goto <D.26936>; else goto <D.26938>;
      <D.26938>:
      D.26939 = strcmp (&ver, "#VER:2");
      if (D.26939 != 0) goto <D.26936>; else goto <D.26937>;
      <D.26936>:
      printf ("Profile file has wrong version or invalid.\n");
      fclose (infile);
      // predicted unlikely by continue predictor.
      goto <D.25354>;
      <D.26937>:
      <D.25362>:
      {
        char name[1024];
        struct MonoMethodDesc * desc;
        struct MonoMethod * method;

        try
          {
            D.26940 = fgets (&name, 1023, infile);
            if (D.26940 == 0B) goto <D.25358>; else goto <D.26941>;
            <D.26941>:
            D.26942 = __strlen_g (&name);
            if (D.26942 != 0) goto <D.26943>; else goto <D.26944>;
            <D.26943>:
            D.26945 = __strlen_g (&name);
            D.26946 = D.26945 + 18446744073709551615;
            name[D.26946] = 0;
            <D.26944>:
            desc = mono_method_desc_new (&name, 1);
            D.26926 = acfg->image;
            method = mono_method_desc_search_in_image (desc, D.26926);
            if (method != 0B) goto <D.26947>; else goto <D.26948>;
            <D.26947>:
            D.26949 = mono_method_get_token (method);
            if (D.26949 != 0) goto <D.26950>; else goto <D.26951>;
            <D.26950>:
            token = mono_method_get_token (method);
            D.26952 = token & 16777215;
            D.26953 = D.26952 + 4294967295;
            method_index = (int) D.26953;
            found = 0;
            i = 0;
            goto <D.25361>;
            <D.25360>:
            D.26954 = acfg->method_order;
            D.26955 = D.26954->pdata;
            D.26956 = (long unsigned int) i;
            D.26957 = D.26956 * 8;
            D.26958 = D.26955 + D.26957;
            D.26959 = *D.26958;
            D.26960 = (long unsigned int) method_index;
            D.26961 = (void *) D.26960;
            if (D.26959 == D.26961) goto <D.26962>; else goto <D.26963>;
            <D.26962>:
            found = 1;
            goto <D.25359>;
            <D.26963>:
            i = i + 1;
            <D.25361>:
            D.26954 = acfg->method_order;
            D.26964 = D.26954->len;
            i.42 = (unsigned int) i;
            if (D.26964 > i.42) goto <D.25360>; else goto <D.25359>;
            <D.25359>:
            if (found == 0) goto <D.26966>; else goto <D.26967>;
            <D.26966>:
            D.26954 = acfg->method_order;
            D.26960 = (long unsigned int) method_index;
            D.26961 = (void *) D.26960;
            monoeg_g_ptr_array_add (D.26954, D.26961);
            <D.26967>:
            goto <D.26968>;
            <D.26951>:
            <D.26968>:
            <D.26948>:
          }
        finally
          {
            name = {CLOBBER};
          }
      }
      goto <D.25362>;
      <D.25358>:
      fclose (infile);
      <D.25354>:
      goto <D.25363>;
      <D.25353>:
      unordered = 0B;
      method_index = 0;
      goto <D.25368>;
      <D.25367>:
      found = 0;
      i = 0;
      goto <D.25366>;
      <D.25365>:
      D.26954 = acfg->method_order;
      D.26955 = D.26954->pdata;
      D.26956 = (long unsigned int) i;
      D.26957 = D.26956 * 8;
      D.26958 = D.26955 + D.26957;
      D.26959 = *D.26958;
      D.26960 = (long unsigned int) method_index;
      D.26961 = (void *) D.26960;
      if (D.26959 == D.26961) goto <D.26969>; else goto <D.26970>;
      <D.26969>:
      found = 1;
      goto <D.25364>;
      <D.26970>:
      i = i + 1;
      <D.25366>:
      D.26954 = acfg->method_order;
      D.26964 = D.26954->len;
      i.42 = (unsigned int) i;
      if (D.26964 > i.42) goto <D.25365>; else goto <D.25364>;
      <D.25364>:
      if (found == 0) goto <D.26971>; else goto <D.26972>;
      <D.26971>:
      D.26960 = (long unsigned int) method_index;
      D.26961 = (void *) D.26960;
      unordered = monoeg_g_list_prepend (unordered, D.26961);
      <D.26972>:
      method_index = method_index + 1;
      <D.25368>:
      D.26926 = acfg->image;
      D.26973 = D.26926->tables[6].rows;
      D.26974 = (int) D.26973;
      if (D.26974 > method_index) goto <D.25367>; else goto <D.25369>;
      <D.25369>:
      unordered = monoeg_g_list_reverse (unordered);
      l = unordered;
      goto <D.25371>;
      <D.25370>:
      D.26954 = acfg->method_order;
      D.26975 = l->data;
      monoeg_g_ptr_array_add (D.26954, D.26975);
      l = l->next;
      <D.25371>:
      if (l != 0B) goto <D.25370>; else goto <D.25372>;
      <D.25372>:
    }
  finally
    {
      ver = {CLOBBER};
    }
}


__attribute__((__artificial__, __gnu_inline__, __always_inline__))
fgets (char * restrict __s, int __n, struct FILE * restrict __stream)
{
  long unsigned int D.26978;
  int D.26983;
  char * D.26985;
  long unsigned int D.26986;
  long unsigned int D.26987;
  long unsigned int D.26988;
  long unsigned int D.26991;

  D.26978 = __builtin_object_size (__s, 1);
  if (D.26978 != 18446744073709551615) goto <D.26979>; else goto <D.26980>;
  <D.26979>:
  D.26983 = __builtin_constant_p (__n);
  if (D.26983 == 0) goto <D.26981>; else goto <D.26984>;
  <D.26984>:
  if (__n <= 0) goto <D.26981>; else goto <D.26982>;
  <D.26981>:
  D.26986 = __builtin_object_size (__s, 1);
  D.26985 = __fgets_chk (__s, D.26986, __n, __stream);
  return D.26985;
  <D.26982>:
  D.26987 = (long unsigned int) __n;
  D.26988 = __builtin_object_size (__s, 1);
  if (D.26987 > D.26988) goto <D.26989>; else goto <D.26990>;
  <D.26989>:
  D.26991 = __builtin_object_size (__s, 1);
  D.26985 = __fgets_chk_warn (__s, D.26991, __n, __stream);
  return D.26985;
  <D.26990>:
  <D.26980>:
  D.26985 = __fgets_alias (__s, __n, __stream);
  return D.26985;
}


arch_init (struct MonoAotCompile * acfg)
{
  struct GString * D.26993;
  struct GString * D.26994;

  D.26993 = monoeg_g_string_new ("");
  acfg->llc_args = D.26993;
  D.26994 = monoeg_g_string_new ("");
  acfg->as_args = D.26994;
  acfg->llvm_label_prefix = "";
  acfg->user_symbol_prefix = "";
  acfg->need_pt_gnu_stack = 1;
}


collect_methods (struct MonoAotCompile * acfg)
{
  int D.26995;
  int D.26996;
  struct MonoImage * D.26997;
  char * D.27000;
  struct MonoClass * D.27001;
  int D.27002;
  short unsigned int D.27005;
  int D.27006;
  int D.27007;
  int check_for_pending_exc.43;
  int D.27011;
  int D.27012;
  <unnamed-unsigned:24> D.27013;
  int D.27014;
  int D.27015;
  int D.27016;
  unsigned int D.27017;
  unsigned int D.27018;
  long unsigned int D.27025;
  long unsigned int D.27026;
  struct MonoClass * D.27028;
  struct MonoGenericContainer * D.27029;
  int mindex;
  int i;
  struct MonoImage * image;

  image = acfg->image;
  i = 0;
  goto <D.25728>;
  <D.25727>:
  {
    struct MonoMethod * method;
    guint32 token;

    D.26995 = i + 1;
    D.26996 = D.26995 | 100663296;
    token = (guint32) D.26996;
    D.26997 = acfg->image;
    method = mono_get_method (D.26997, token, 0B);
    if (method == 0B) goto <D.26998>; else goto <D.26999>;
    <D.26998>:
    D.27000 = image->name;
    printf ("Failed to load method 0x%x from \'%s\'.\n", token, D.27000);
    exit (1);
    <D.26999>:
    D.27001 = method->klass;
    mono_class_setup_methods (D.27001);
    D.27002 = acfg->aot_opts.full_aot;
    if (D.27002 != 0) goto <D.27003>; else goto <D.27004>;
    <D.27003>:
    D.27005 = method->iflags;
    D.27006 = (int) D.27005;
    D.27007 = D.27006 & 4096;
    if (D.27007 != 0) goto <D.27008>; else goto <D.27009>;
    <D.27008>:
    {
      struct MonoMethod * wrapper;

      check_for_pending_exc.43 = check_for_pending_exc;
      wrapper = mono_marshal_get_native_wrapper (method, check_for_pending_exc.43, 1);
      method = wrapper;
    }
    <D.27009>:
    <D.27004>:
    add_method_with_index (acfg, method, i, 0);
    D.27011 = acfg->method_index;
    D.27012 = D.27011 + 1;
    acfg->method_index = D.27012;
  }
  i = i + 1;
  <D.25728>:
  D.27013 = image->tables[6].rows;
  D.27014 = (int) D.27013;
  if (D.27014 > i) goto <D.25727>; else goto <D.25729>;
  <D.25729>:
  mindex = 0;
  goto <D.25735>;
  <D.25734>:
  {
    struct MonoMethod * method;
    guint32 token;

    D.27015 = mindex + 1;
    D.27016 = D.27015 | 100663296;
    token = (guint32) D.27016;
    D.27017 = acfg->opts;
    D.27018 = D.27017 & 16777216;
    if (D.27018 == 0) goto <D.27019>; else goto <D.27020>;
    <D.27019>:
    // predicted unlikely by continue predictor.
    goto <D.25732>;
    <D.27020>:
    D.26997 = acfg->image;
    method = mono_get_method (D.26997, token, 0B);
    if (method == 0B) goto <D.27021>; else goto <D.27022>;
    <D.27021>:
    // predicted unlikely by continue predictor.
    goto <D.25732>;
    <D.27022>:
    D.27025 = BIT_FIELD_REF <*method, 64, 256>;
    D.27026 = D.27025 & 4503599627370496;
    if (D.27026 != 0) goto <D.27023>; else goto <D.27027>;
    <D.27027>:
    D.27028 = method->klass;
    D.27029 = D.27028->generic_container;
    if (D.27029 != 0B) goto <D.27023>; else goto <D.27024>;
    <D.27023>:
    {
      struct MonoMethod * gshared;

      gshared = mini_get_shared_method_full (method, 1, 1);
      add_extra_method (acfg, gshared);
    }
    <D.27024>:
  }
  <D.25732>:
  mindex = mindex + 1;
  <D.25735>:
  D.27013 = image->tables[6].rows;
  D.27014 = (int) D.27013;
  if (D.27014 > mindex) goto <D.25734>; else goto <D.25736>;
  <D.25736>:
  add_generic_instances (acfg);
  D.27002 = acfg->aot_opts.full_aot;
  if (D.27002 != 0) goto <D.27030>; else goto <D.27031>;
  <D.27030>:
  add_wrappers (acfg);
  <D.27031>:
}


add_method_with_index (struct MonoAotCompile * acfg, struct MonoMethod * method, int index, gboolean extra)
{
  _Bool D.27032;
  long int D.27033;
  long int D.27034;
  struct GHashTable * D.27037;
  void * D.27038;
  struct GPtrArray * D.27041;
  int D.27042;
  long unsigned int D.27043;
  void * D.27044;
  unsigned int D.27045;
  unsigned int D.27046;
  long unsigned int D.27049;
  long unsigned int D.27050;
  struct GPtrArray * D.27052;

  D.27032 = method == 0B;
  D.27033 = (long int) D.27032;
  D.27034 = __builtin_expect (D.27033, 0);
  if (D.27034 != 0) goto <D.27035>; else goto <D.27036>;
  <D.27035>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "aot-compiler.c", 2994, "method");
  <D.27036>:
  D.27037 = acfg->method_indexes;
  D.27038 = monoeg_g_hash_table_lookup (D.27037, method);
  if (D.27038 == 0B) goto <D.27039>; else goto <D.27040>;
  <D.27039>:
  D.27041 = acfg->methods;
  monoeg_g_ptr_array_add (D.27041, method);
  D.27037 = acfg->method_indexes;
  D.27042 = index + 1;
  D.27043 = (long unsigned int) D.27042;
  D.27044 = (void *) D.27043;
  monoeg_g_hash_table_insert_replace (D.27037, method, D.27044, 0);
  D.27041 = acfg->methods;
  D.27045 = D.27041->len;
  D.27046 = D.27045 + 1;
  acfg->nmethods = D.27046;
  <D.27040>:
  D.27049 = BIT_FIELD_REF <*method, 64, 256>;
  D.27050 = D.27049 & 4467570830351532032;
  if (D.27050 != 0) goto <D.27047>; else goto <D.27051>;
  <D.27051>:
  if (extra != 0) goto <D.27047>; else goto <D.27048>;
  <D.27047>:
  D.27052 = acfg->extra_methods;
  monoeg_g_ptr_array_add (D.27052, method);
  <D.27048>:
}


add_extra_method (struct MonoAotCompile * acfg, struct MonoMethod * method)
{
  add_extra_method_with_depth (acfg, method, 0);
}


add_extra_method_with_depth (struct MonoAotCompile * acfg, struct MonoMethod * method, int depth)
{
  int D.27053;
  int D.27056;
  char * D.27059;

  D.27053 = mono_method_is_generic_sharable_full (method, 0, 1, 0);
  if (D.27053 != 0) goto <D.27054>; else goto <D.27055>;
  <D.27054>:
  method = mini_get_shared_method (method);
  <D.27055>:
  D.27056 = acfg->aot_opts.log_generics;
  if (D.27056 != 0) goto <D.27057>; else goto <D.27058>;
  <D.27057>:
  D.27059 = mono_method_full_name (method, 1);
  printf ("%*sAdding method %s.\n", depth, "", D.27059);
  <D.27058>:
  add_method_full (acfg, method, 1, depth);
}


add_method_full (struct MonoAotCompile * acfg, struct MonoMethod * method, gboolean extra, int depth)
{
  struct GHashTable * D.27060;
  void * D.27061;
  long int D.27062;
  int D.27065;
  struct GPtrArray * D.27066;
  long unsigned int D.27067;
  void * D.27068;
  struct GHashTable * D.27069;
  long unsigned int D.27070;
  void * D.27071;
  int D.27072;
  int D.27073;
  int index;

  D.27060 = acfg->method_indexes;
  D.27061 = monoeg_g_hash_table_lookup (D.27060, method);
  D.27062 = (long int) D.27061;
  index = (int) D.27062;
  if (index != 0) goto <D.27063>; else goto <D.27064>;
  <D.27063>:
  D.27065 = index + -1;
  return D.27065;
  <D.27064>:
  index = acfg->method_index;
  add_method_with_index (acfg, method, index, extra);
  D.27066 = acfg->method_order;
  D.27067 = (long unsigned int) index;
  D.27068 = (void *) D.27067;
  monoeg_g_ptr_array_add (D.27066, D.27068);
  D.27069 = acfg->method_depth;
  D.27070 = (long unsigned int) depth;
  D.27071 = (void *) D.27070;
  monoeg_g_hash_table_insert_replace (D.27069, method, D.27071, 0);
  D.27072 = acfg->method_index;
  D.27073 = D.27072 + 1;
  acfg->method_index = D.27073;
  D.27065 = index;
  return D.27065;
}


add_generic_instances (struct MonoAotCompile * acfg)
{
  int D.27075;
  int D.27078;
  int D.27079;
  struct MonoImage * D.27080;
  struct MonoClass * D.27083;
  struct MonoImage * D.27084;
  struct MonoGenericInst * D.27089;
  long unsigned int D.27092;
  long unsigned int D.27093;
  struct MonoGenericInst * D.27098;
  long unsigned int D.27101;
  long unsigned int D.27102;
  struct MonoType * D.27109;
  int D.27110;
  unsigned char D.27112;
  int D.27114;
  <unnamed-unsigned:22> D.27117;
  int D.27118;
  int D.27123;
  int D.27126;
  long unsigned int D.27133;
  long unsigned int D.27134;
  int D.27138;
  long unsigned int D.27141;
  long unsigned int D.27142;
  struct MonoType * * D.27143;
  struct MonoClass * D.27144;
  struct MonoType * D.27145;
  struct MonoGenericInst * D.27146;
  int D.27152;
  struct MonoGenericInst * D.27155;
  long unsigned int D.27159;
  long unsigned int D.27160;
  struct MonoGenericContainer * D.27162;
  int D.27163;
  <unnamed-unsigned:24> D.27166;
  int D.27167;
  int D.27168;
  unsigned char D.27172;
  <unnamed-unsigned:24> D.27173;
  int D.27174;
  struct GPtrArray * D.27175;
  void * * D.27176;
  long unsigned int D.27177;
  long unsigned int D.27178;
  void * * D.27179;
  unsigned int D.27180;
  unsigned int i.44;
  struct MonoImage * D.27182;
  int ninsts.45;
  struct MonoClass * D.27186;
  struct MonoType * D.27187;
  int ninsts.46;
  struct MonoClass * D.27189;
  struct MonoType * D.27190;
  int ninsts.47;
  struct MonoClass * D.27192;
  struct MonoType * D.27193;
  int ninsts.48;
  struct MonoClass * D.27195;
  struct MonoType * D.27196;
  int ninsts.49;
  struct MonoClass * D.27198;
  struct MonoType * D.27199;
  int ninsts.50;
  struct MonoClass * D.27201;
  struct MonoType * D.27202;
  int ninsts.51;
  struct MonoClass * D.27204;
  struct MonoType * D.27205;
  int ninsts.52;
  struct MonoClass * D.27207;
  struct MonoType * D.27208;
  int ninsts.53;
  struct MonoClass * D.27210;
  struct MonoType * D.27211;
  int ninsts.54;
  struct MonoClass * D.27213;
  struct MonoType * D.27214;
  int ninsts.55;
  struct MonoClass * D.27216;
  struct MonoType * D.27217;
  int ninsts.56;
  struct MonoClass * D.27219;
  struct MonoType * D.27220;
  struct MonoClass * D.27231;
  struct MonoGenericInst * D.27234;
  struct MonoMethod * D.27235;
  struct MonoMethod * D.27236;
  const char * D.27239;
  int D.27240;
  int D.27242;
  long unsigned int D.27243;
  long unsigned int D.27244;
  struct MonoGenericInst * D.27247;
  struct MonoMethod * D.27248;
  struct MonoMethod * D.27249;
  const char * D.27254;
  int D.27255;
  int D.27257;
  long unsigned int D.27258;
  long unsigned int D.27259;
  struct MonoGenericInst * D.27262;
  struct MonoMethod * D.27263;
  struct MonoMethod * D.27264;
  int i;
  guint32 token;
  struct MonoMethod * method;
  struct MonoGenericContext * context;

  D.27075 = acfg->aot_opts.no_instances;
  if (D.27075 != 0) goto <D.27076>; else goto <D.27077>;
  <D.27076>:
  return;
  <D.27077>:
  i = 0;
  goto <D.24660>;
  <D.24659>:
  D.27078 = i + 1;
  D.27079 = D.27078 | 721420288;
  token = (guint32) D.27079;
  D.27080 = acfg->image;
  method = mono_get_method (D.27080, token, 0B);
  if (method == 0B) goto <D.27081>; else goto <D.27082>;
  <D.27081>:
  // predicted unlikely by continue predictor.
  goto <D.24638>;
  <D.27082>:
  D.27083 = method->klass;
  D.27084 = D.27083->image;
  D.27080 = acfg->image;
  if (D.27084 != D.27080) goto <D.27085>; else goto <D.27086>;
  <D.27085>:
  // predicted unlikely by continue predictor.
  goto <D.24638>;
  <D.27086>:
  context = mono_method_get_context (method);
  if (context != 0B) goto <D.27087>; else goto <D.27088>;
  <D.27087>:
  D.27089 = context->class_inst;
  if (D.27089 != 0B) goto <D.27090>; else goto <D.27091>;
  <D.27090>:
  D.27089 = context->class_inst;
  D.27092 = BIT_FIELD_REF <*D.27089, 64, 0>;
  D.27093 = D.27092 & 512;
  if (D.27093 != 0) goto <D.27094>; else goto <D.27095>;
  <D.27094>:
  // predicted unlikely by continue predictor.
  goto <D.24638>;
  <D.27095>:
  <D.27091>:
  <D.27088>:
  if (context != 0B) goto <D.27096>; else goto <D.27097>;
  <D.27096>:
  D.27098 = context->method_inst;
  if (D.27098 != 0B) goto <D.27099>; else goto <D.27100>;
  <D.27099>:
  D.27098 = context->method_inst;
  D.27101 = BIT_FIELD_REF <*D.27098, 64, 0>;
  D.27102 = D.27101 & 512;
  if (D.27102 != 0) goto <D.27103>; else goto <D.27104>;
  <D.27103>:
  {
    struct MonoGenericContext shared_context;
    struct MonoGenericInst * inst;
    struct MonoType * * type_argv;
    int i;
    struct MonoMethod * declaring_method;
    gboolean supported;

    try
      {
        supported = 1;
        D.27089 = context->class_inst;
        if (D.27089 != 0B) goto <D.27105>; else goto <D.27106>;
        <D.27105>:
        inst = context->class_inst;
        i = 0;
        goto <D.24647>;
        <D.24646>:
        D.27109 = inst->type_argv[i];
        D.27110 = mono_type_is_reference (D.27109);
        if (D.27110 != 0) goto <D.27107>; else goto <D.27111>;
        <D.27111>:
        D.27109 = inst->type_argv[i];
        D.27112 = D.27109->type;
        if (D.27112 == 19) goto <D.27107>; else goto <D.27113>;
        <D.27113>:
        D.27109 = inst->type_argv[i];
        D.27112 = D.27109->type;
        if (D.27112 == 30) goto <D.27107>; else goto <D.27108>;
        <D.27107>:
        // predicted unlikely by continue predictor.
        goto <D.24645>;
        <D.27108>:
        D.27109 = inst->type_argv[i];
        D.27114 = mono_class_is_open_constructed_type (D.27109);
        if (D.27114 != 0) goto <D.27115>; else goto <D.27116>;
        <D.27115>:
        supported = 0;
        <D.27116>:
        <D.24645>:
        i = i + 1;
        <D.24647>:
        D.27117 = inst->type_argc;
        D.27118 = (int) D.27117;
        if (D.27118 > i) goto <D.24646>; else goto <D.24648>;
        <D.24648>:
        <D.27106>:
        D.27098 = context->method_inst;
        if (D.27098 != 0B) goto <D.27119>; else goto <D.27120>;
        <D.27119>:
        inst = context->method_inst;
        i = 0;
        goto <D.24651>;
        <D.24650>:
        D.27109 = inst->type_argv[i];
        D.27123 = mono_type_is_reference (D.27109);
        if (D.27123 != 0) goto <D.27121>; else goto <D.27124>;
        <D.27124>:
        D.27109 = inst->type_argv[i];
        D.27112 = D.27109->type;
        if (D.27112 == 19) goto <D.27121>; else goto <D.27125>;
        <D.27125>:
        D.27109 = inst->type_argv[i];
        D.27112 = D.27109->type;
        if (D.27112 == 30) goto <D.27121>; else goto <D.27122>;
        <D.27121>:
        // predicted unlikely by continue predictor.
        goto <D.24649>;
        <D.27122>:
        D.27109 = inst->type_argv[i];
        D.27126 = mono_class_is_open_constructed_type (D.27109);
        if (D.27126 != 0) goto <D.27127>; else goto <D.27128>;
        <D.27127>:
        supported = 0;
        <D.27128>:
        <D.24649>:
        i = i + 1;
        <D.24651>:
        D.27117 = inst->type_argc;
        D.27118 = (int) D.27117;
        if (D.27118 > i) goto <D.24650>; else goto <D.24652>;
        <D.24652>:
        <D.27120>:
        if (supported == 0) goto <D.27129>; else goto <D.27130>;
        <D.27129>:
        // predicted unlikely by continue predictor.
        goto <D.24638>;
        <D.27130>:
        memset (&shared_context, 0, 16);
        inst = context->class_inst;
        if (inst != 0B) goto <D.27131>; else goto <D.27132>;
        <D.27131>:
        D.27117 = inst->type_argc;
        D.27133 = (long unsigned int) D.27117;
        D.27134 = D.27133 * 8;
        type_argv = monoeg_malloc0 (D.27134);
        i = 0;
        goto <D.24654>;
        <D.24653>:
        D.27109 = inst->type_argv[i];
        D.27138 = mono_type_is_reference (D.27109);
        if (D.27138 != 0) goto <D.27135>; else goto <D.27139>;
        <D.27139>:
        D.27109 = inst->type_argv[i];
        D.27112 = D.27109->type;
        if (D.27112 == 19) goto <D.27135>; else goto <D.27140>;
        <D.27140>:
        D.27109 = inst->type_argv[i];
        D.27112 = D.27109->type;
        if (D.27112 == 30) goto <D.27135>; else goto <D.27136>;
        <D.27135>:
        D.27141 = (long unsigned int) i;
        D.27142 = D.27141 * 8;
        D.27143 = type_argv + D.27142;
        D.27144 = mono_defaults.object_class;
        D.27145 = &D.27144->byval_arg;
        *D.27143 = D.27145;
        goto <D.27137>;
        <D.27136>:
        D.27141 = (long unsigned int) i;
        D.27142 = D.27141 * 8;
        D.27143 = type_argv + D.27142;
        D.27109 = inst->type_argv[i];
        *D.27143 = D.27109;
        <D.27137>:
        i = i + 1;
        <D.24654>:
        D.27117 = inst->type_argc;
        D.27118 = (int) D.27117;
        if (D.27118 > i) goto <D.24653>; else goto <D.24655>;
        <D.24655>:
        D.27117 = inst->type_argc;
        D.27118 = (int) D.27117;
        D.27146 = mono_metadata_get_generic_inst (D.27118, type_argv);
        shared_context.class_inst = D.27146;
        monoeg_g_free (type_argv);
        <D.27132>:
        inst = context->method_inst;
        if (inst != 0B) goto <D.27147>; else goto <D.27148>;
        <D.27147>:
        D.27117 = inst->type_argc;
        D.27133 = (long unsigned int) D.27117;
        D.27134 = D.27133 * 8;
        type_argv = monoeg_malloc0 (D.27134);
        i = 0;
        goto <D.24657>;
        <D.24656>:
        D.27109 = inst->type_argv[i];
        D.27152 = mono_type_is_reference (D.27109);
        if (D.27152 != 0) goto <D.27149>; else goto <D.27153>;
        <D.27153>:
        D.27109 = inst->type_argv[i];
        D.27112 = D.27109->type;
        if (D.27112 == 19) goto <D.27149>; else goto <D.27154>;
        <D.27154>:
        D.27109 = inst->type_argv[i];
        D.27112 = D.27109->type;
        if (D.27112 == 30) goto <D.27149>; else goto <D.27150>;
        <D.27149>:
        D.27141 = (long unsigned int) i;
        D.27142 = D.27141 * 8;
        D.27143 = type_argv + D.27142;
        D.27144 = mono_defaults.object_class;
        D.27145 = &D.27144->byval_arg;
        *D.27143 = D.27145;
        goto <D.27151>;
        <D.27150>:
        D.27141 = (long unsigned int) i;
        D.27142 = D.27141 * 8;
        D.27143 = type_argv + D.27142;
        D.27109 = inst->type_argv[i];
        *D.27143 = D.27109;
        <D.27151>:
        i = i + 1;
        <D.24657>:
        D.27117 = inst->type_argc;
        D.27118 = (int) D.27117;
        if (D.27118 > i) goto <D.24656>; else goto <D.24658>;
        <D.24658>:
        D.27117 = inst->type_argc;
        D.27118 = (int) D.27117;
        D.27155 = mono_metadata_get_generic_inst (D.27118, type_argv);
        shared_context.method_inst = D.27155;
        monoeg_g_free (type_argv);
        <D.27148>:
        D.27159 = BIT_FIELD_REF <*method, 64, 256>;
        D.27160 = D.27159 & 4503599627370496;
        if (D.27160 != 0) goto <D.27156>; else goto <D.27161>;
        <D.27161>:
        D.27083 = method->klass;
        D.27162 = D.27083->generic_container;
        if (D.27162 != 0B) goto <D.27156>; else goto <D.27157>;
        <D.27156>:
        declaring_method = method;
        goto <D.27158>;
        <D.27157>:
        declaring_method = mono_method_get_declaring_generic_method (method);
        <D.27158>:
        method = mono_class_inflate_generic_method (declaring_method, &shared_context);
      }
    finally
      {
        shared_context = {CLOBBER};
      }
  }
  <D.27104>:
  <D.27100>:
  <D.27097>:
  D.27163 = mono_method_is_generic_sharable_full (method, 0, 0, 0);
  if (D.27163 != 0) goto <D.27164>; else goto <D.27165>;
  <D.27164>:
  // predicted unlikely by continue predictor.
  goto <D.24638>;
  <D.27165>:
  add_extra_method (acfg, method);
  <D.24638>:
  i = i + 1;
  <D.24660>:
  D.27080 = acfg->image;
  D.27166 = D.27080->tables[43].rows;
  D.27167 = (int) D.27166;
  if (D.27167 > i) goto <D.24659>; else goto <D.24661>;
  <D.24661>:
  i = 0;
  goto <D.24665>;
  <D.24664>:
  {
    struct MonoClass * klass;

    D.27078 = i + 1;
    D.27168 = D.27078 | 452984832;
    token = (guint32) D.27168;
    D.27080 = acfg->image;
    klass = mono_class_get (D.27080, token);
    if (klass == 0B) goto <D.27169>; else goto <D.27171>;
    <D.27171>:
    D.27172 = klass->rank;
    if (D.27172 != 0) goto <D.27169>; else goto <D.27170>;
    <D.27169>:
    mono_loader_clear_error ();
    // predicted unlikely by continue predictor.
    goto <D.24663>;
    <D.27170>:
    add_generic_class (acfg, klass, 0, "typespec");
  }
  <D.24663>:
  i = i + 1;
  <D.24665>:
  D.27080 = acfg->image;
  D.27173 = D.27080->tables[27].rows;
  D.27174 = (int) D.27173;
  if (D.27174 > i) goto <D.24664>; else goto <D.24666>;
  <D.24666>:
  i = 0;
  goto <D.24668>;
  <D.24667>:
  D.27175 = acfg->methods;
  D.27176 = D.27175->pdata;
  D.27177 = (long unsigned int) i;
  D.27178 = D.27177 * 8;
  D.27179 = D.27176 + D.27178;
  method = *D.27179;
  add_types_from_method_header (acfg, method);
  i = i + 1;
  <D.24668>:
  D.27175 = acfg->methods;
  D.27180 = D.27175->len;
  i.44 = (unsigned int) i;
  if (D.27180 > i.44) goto <D.24667>; else goto <D.24669>;
  <D.24669>:
  D.27080 = acfg->image;
  D.27182 = mono_defaults.corlib;
  if (D.27080 == D.27182) goto <D.27183>; else goto <D.27184>;
  <D.27183>:
  {
    struct MonoClass * klass;
    struct MonoType * insts[256];
    int ninsts;

    try
      {
        ninsts = 0;
        ninsts.45 = ninsts;
        ninsts = ninsts.45 + 1;
        D.27186 = mono_defaults.byte_class;
        D.27187 = &D.27186->byval_arg;
        insts[ninsts.45] = D.27187;
        ninsts.46 = ninsts;
        ninsts = ninsts.46 + 1;
        D.27189 = mono_defaults.sbyte_class;
        D.27190 = &D.27189->byval_arg;
        insts[ninsts.46] = D.27190;
        ninsts.47 = ninsts;
        ninsts = ninsts.47 + 1;
        D.27192 = mono_defaults.int16_class;
        D.27193 = &D.27192->byval_arg;
        insts[ninsts.47] = D.27193;
        ninsts.48 = ninsts;
        ninsts = ninsts.48 + 1;
        D.27195 = mono_defaults.uint16_class;
        D.27196 = &D.27195->byval_arg;
        insts[ninsts.48] = D.27196;
        ninsts.49 = ninsts;
        ninsts = ninsts.49 + 1;
        D.27198 = mono_defaults.int32_class;
        D.27199 = &D.27198->byval_arg;
        insts[ninsts.49] = D.27199;
        ninsts.50 = ninsts;
        ninsts = ninsts.50 + 1;
        D.27201 = mono_defaults.uint32_class;
        D.27202 = &D.27201->byval_arg;
        insts[ninsts.50] = D.27202;
        ninsts.51 = ninsts;
        ninsts = ninsts.51 + 1;
        D.27204 = mono_defaults.int64_class;
        D.27205 = &D.27204->byval_arg;
        insts[ninsts.51] = D.27205;
        ninsts.52 = ninsts;
        ninsts = ninsts.52 + 1;
        D.27207 = mono_defaults.uint64_class;
        D.27208 = &D.27207->byval_arg;
        insts[ninsts.52] = D.27208;
        ninsts.53 = ninsts;
        ninsts = ninsts.53 + 1;
        D.27210 = mono_defaults.single_class;
        D.27211 = &D.27210->byval_arg;
        insts[ninsts.53] = D.27211;
        ninsts.54 = ninsts;
        ninsts = ninsts.54 + 1;
        D.27213 = mono_defaults.double_class;
        D.27214 = &D.27213->byval_arg;
        insts[ninsts.54] = D.27214;
        ninsts.55 = ninsts;
        ninsts = ninsts.55 + 1;
        D.27216 = mono_defaults.char_class;
        D.27217 = &D.27216->byval_arg;
        insts[ninsts.55] = D.27217;
        ninsts.56 = ninsts;
        ninsts = ninsts.56 + 1;
        D.27219 = mono_defaults.boolean_class;
        D.27220 = &D.27219->byval_arg;
        insts[ninsts.56] = D.27220;
        D.27080 = acfg->image;
        klass = mono_class_from_name (D.27080, "System.Collections.Generic", "GenericComparer`1");
        if (klass != 0B) goto <D.27221>; else goto <D.27222>;
        <D.27221>:
        add_instances_of (acfg, klass, &insts, ninsts, 1);
        <D.27222>:
        D.27080 = acfg->image;
        klass = mono_class_from_name (D.27080, "System.Collections.Generic", "GenericEqualityComparer`1");
        if (klass != 0B) goto <D.27223>; else goto <D.27224>;
        <D.27223>:
        add_instances_of (acfg, klass, &insts, ninsts, 1);
        <D.27224>:
        D.27080 = acfg->image;
        klass = mono_class_from_name (D.27080, "System.Collections.Generic", "ICollection`1");
        if (klass != 0B) goto <D.27225>; else goto <D.27226>;
        <D.27225>:
        add_instances_of (acfg, klass, &insts, ninsts, 1);
        <D.27226>:
        D.27080 = acfg->image;
        klass = mono_class_from_name (D.27080, "System.Collections.Generic", "IList`1");
        if (klass != 0B) goto <D.27227>; else goto <D.27228>;
        <D.27227>:
        add_instances_of (acfg, klass, &insts, ninsts, 1);
        <D.27228>:
        D.27080 = acfg->image;
        klass = mono_class_from_name (D.27080, "System.Collections.Generic", "IEnumerable`1");
        if (klass != 0B) goto <D.27229>; else goto <D.27230>;
        <D.27229>:
        add_instances_of (acfg, klass, &insts, ninsts, 1);
        <D.27230>:
        {
          struct MonoGenericContext ctx;
          struct MonoType * args[16];
          struct MonoMethod * get_method;
          struct MonoClass * array_klass;

          try
            {
              D.27144 = mono_defaults.object_class;
              D.27231 = mono_array_class_get (D.27144, 1);
              array_klass = D.27231->parent;
              get_method = mono_class_get_method_from_name (array_klass, "GetGenericValueImpl", 2);
              if (get_method != 0B) goto <D.27232>; else goto <D.27233>;
              <D.27232>:
              memset (&ctx, 0, 16);
              D.27144 = mono_defaults.object_class;
              D.27145 = &D.27144->byval_arg;
              args[0] = D.27145;
              D.27234 = mono_metadata_get_generic_inst (1, &args);
              ctx.method_inst = D.27234;
              D.27235 = mono_class_inflate_generic_method (get_method, &ctx);
              D.27236 = mono_marshal_get_native_wrapper (D.27235, 1, 1);
              add_extra_method (acfg, D.27236);
              <D.27233>:
            }
          finally
            {
              ctx = {CLOBBER};
              args = {CLOBBER};
            }
        }
        {
          struct MonoGenericContext ctx;
          struct MonoType * args[16];
          struct MonoMethod * m;
          struct MonoClass * interlocked_klass;
          void * iter;

          try
            {
              D.27182 = mono_defaults.corlib;
              interlocked_klass = mono_class_from_name (D.27182, "System.Threading", "Interlocked");
              iter = 0B;
              goto <D.24683>;
              <D.24682>:
              D.27239 = m->name;
              D.27240 = strcmp (D.27239, "CompareExchange");
              if (D.27240 == 0) goto <D.27237>; else goto <D.27241>;
              <D.27241>:
              D.27239 = m->name;
              D.27242 = strcmp (D.27239, "Exchange");
              if (D.27242 == 0) goto <D.27237>; else goto <D.27238>;
              <D.27237>:
              D.27243 = BIT_FIELD_REF <*m, 64, 256>;
              D.27244 = D.27243 & 4503599627370496;
              if (D.27244 != 0) goto <D.27245>; else goto <D.27246>;
              <D.27245>:
              memset (&ctx, 0, 16);
              D.27144 = mono_defaults.object_class;
              D.27145 = &D.27144->byval_arg;
              args[0] = D.27145;
              D.27247 = mono_metadata_get_generic_inst (1, &args);
              ctx.method_inst = D.27247;
              D.27248 = mono_class_inflate_generic_method (m, &ctx);
              D.27249 = mono_marshal_get_native_wrapper (D.27248, 1, 1);
              add_extra_method (acfg, D.27249);
              <D.27246>:
              <D.27238>:
              <D.24683>:
              m = mono_class_get_methods (interlocked_klass, &iter);
              if (m != 0B) goto <D.24682>; else goto <D.24684>;
              <D.24684>:
            }
          finally
            {
              ctx = {CLOBBER};
              args = {CLOBBER};
              iter = {CLOBBER};
            }
        }
        {
          struct MonoGenericContext ctx;
          struct MonoType * args[16];
          struct MonoMethod * m;
          struct MonoClass * volatile_klass;
          void * iter;

          try
            {
              D.27182 = mono_defaults.corlib;
              volatile_klass = mono_class_from_name (D.27182, "System.Threading", "Volatile");
              iter = 0B;
              if (volatile_klass != 0B) goto <D.27250>; else goto <D.27251>;
              <D.27250>:
              goto <D.24691>;
              <D.24690>:
              D.27254 = m->name;
              D.27255 = strcmp (D.27254, "Read");
              if (D.27255 == 0) goto <D.27252>; else goto <D.27256>;
              <D.27256>:
              D.27254 = m->name;
              D.27257 = strcmp (D.27254, "Write");
              if (D.27257 == 0) goto <D.27252>; else goto <D.27253>;
              <D.27252>:
              D.27258 = BIT_FIELD_REF <*m, 64, 256>;
              D.27259 = D.27258 & 4503599627370496;
              if (D.27259 != 0) goto <D.27260>; else goto <D.27261>;
              <D.27260>:
              memset (&ctx, 0, 16);
              D.27144 = mono_defaults.object_class;
              D.27145 = &D.27144->byval_arg;
              args[0] = D.27145;
              D.27262 = mono_metadata_get_generic_inst (1, &args);
              ctx.method_inst = D.27262;
              D.27263 = mono_class_inflate_generic_method (m, &ctx);
              D.27264 = mono_marshal_get_native_wrapper (D.27263, 1, 1);
              add_extra_method (acfg, D.27264);
              <D.27261>:
              <D.27253>:
              <D.24691>:
              m = mono_class_get_methods (volatile_klass, &iter);
              if (m != 0B) goto <D.24690>; else goto <D.24692>;
              <D.24692>:
              <D.27251>:
            }
          finally
            {
              ctx = {CLOBBER};
              args = {CLOBBER};
              iter = {CLOBBER};
            }
        }
      }
    finally
      {
        insts = {CLOBBER};
      }
  }
  <D.27184>:
}


add_generic_class (struct MonoAotCompile * acfg, struct MonoClass * klass, gboolean force, const char * ref)
{
  int D.27268;

  D.27268 = acfg->aot_opts.full_aot;
  if (D.27268 == 0) goto <D.27269>; else goto <D.27270>;
  <D.27269>:
  if (force == 0) goto <D.27271>; else goto <D.27272>;
  <D.27271>:
  return;
  <D.27272>:
  <D.27270>:
  add_generic_class_with_depth (acfg, klass, 0, ref);
}


add_generic_class_with_depth (struct MonoAotCompile * acfg, struct MonoClass * klass, int depth, const char * ref)
{
  struct GHashTable * D.27274;
  struct GHashTable * D.27277;
  struct MonoGenericClass * D.27278;
  struct MonoGenericInst * D.27281;
  long unsigned int D.27282;
  long unsigned int D.27283;
  int D.27286;
  unsigned char D.27291;
  unsigned char D.27294;
  struct GHashTable * D.27299;
  void * D.27300;
  struct MonoType * D.27303;
  int D.27304;
  int D.27307;
  char * D.27310;
  unsigned int D.27313;
  unsigned int D.27314;
  struct MonoImage * D.27317;
  struct MonoImage * D.27318;
  int D.27325;
  const char * D.27328;
  int D.27329;
  int D.27331;
  long unsigned int D.27334;
  long unsigned int D.27335;
  struct MonoGenericContext * D.27338;
  struct MonoGenericInst * D.27339;
  int D.27342;
  long unsigned int D.27345;
  int D.27348;
  struct MonoType * D.27349;
  unsigned char D.27350;
  struct MonoClass * D.27353;
  long unsigned int D.27354;
  long unsigned int D.27355;
  char * D.27360;
  struct MonoClass * D.27361;
  const char * D.27368;
  int D.27369;
  int D.27372;
  int D.27374;
  int D.27376;
  int D.27378;
  int D.27380;
  struct MonoType * D.27381;
  int D.27382;
  int D.27388;
  int D.27390;
  const char * D.27391;
  int D.27392;
  struct MonoClass * D.27394;
  _Bool D.27395;
  long int D.27396;
  long int D.27397;
  struct MonoGenericContext * D.27400;
  const char * D.27401;
  char * D.27402;
  int D.27407;
  int D.27410;
  _Bool D.27413;
  long int D.27414;
  long int D.27415;
  struct MonoType * D.27418;
  struct MonoGenericInst * D.27419;
  struct MonoClass * D.27420;
  int D.27421;
  _Bool D.27424;
  long int D.27425;
  long int D.27426;
  struct MonoClass * D.27429;
  int D.27432;
  int D.27435;
  _Bool D.27438;
  long int D.27439;
  long int D.27440;
  struct MonoType * D.27443;
  struct MonoGenericInst * D.27444;
  struct MonoClass * D.27445;
  int D.27446;
  _Bool D.27449;
  long int D.27450;
  long int D.27451;
  struct MonoClass * D.27454;
  struct MonoMethod * method;
  struct MonoClassField * field;
  void * iter;
  gboolean use_gsharedvt;

  try
    {
      use_gsharedvt = 0;
      D.27274 = acfg->ginst_hash;
      if (D.27274 == 0B) goto <D.27275>; else goto <D.27276>;
      <D.27275>:
      D.27277 = monoeg_g_hash_table_new (0B, 0B);
      acfg->ginst_hash = D.27277;
      <D.27276>:
      mono_class_init (klass);
      D.27278 = klass->generic_class;
      if (D.27278 != 0B) goto <D.27279>; else goto <D.27280>;
      <D.27279>:
      D.27278 = klass->generic_class;
      D.27281 = D.27278->context.class_inst;
      D.27282 = BIT_FIELD_REF <*D.27281, 64, 0>;
      D.27283 = D.27282 & 512;
      if (D.27283 != 0) goto <D.27284>; else goto <D.27285>;
      <D.27284>:
      return;
      <D.27285>:
      <D.27280>:
      D.27286 = has_type_vars (klass);
      if (D.27286 != 0) goto <D.27287>; else goto <D.27288>;
      <D.27287>:
      return;
      <D.27288>:
      D.27278 = klass->generic_class;
      if (D.27278 == 0B) goto <D.27289>; else goto <D.27290>;
      <D.27289>:
      D.27291 = klass->rank;
      if (D.27291 == 0) goto <D.27292>; else goto <D.27293>;
      <D.27292>:
      return;
      <D.27293>:
      <D.27290>:
      D.27294 = klass->exception_type;
      if (D.27294 != 0) goto <D.27295>; else goto <D.27296>;
      <D.27295>:
      return;
      <D.27296>:
      D.27274 = acfg->ginst_hash;
      if (D.27274 == 0B) goto <D.27297>; else goto <D.27298>;
      <D.27297>:
      D.27299 = monoeg_g_hash_table_new (0B, 0B);
      acfg->ginst_hash = D.27299;
      <D.27298>:
      D.27274 = acfg->ginst_hash;
      D.27300 = monoeg_g_hash_table_lookup (D.27274, klass);
      if (D.27300 != 0B) goto <D.27301>; else goto <D.27302>;
      <D.27301>:
      return;
      <D.27302>:
      D.27303 = &klass->byval_arg;
      D.27304 = check_type_depth (D.27303, 0);
      if (D.27304 != 0) goto <D.27305>; else goto <D.27306>;
      <D.27305>:
      return;
      <D.27306>:
      D.27307 = acfg->aot_opts.log_generics;
      if (D.27307 != 0) goto <D.27308>; else goto <D.27309>;
      <D.27308>:
      D.27303 = &klass->byval_arg;
      D.27310 = mono_type_full_name (D.27303);
      printf ("%*sAdding generic instance %s [%s].\n", depth, "", D.27310, ref);
      <D.27309>:
      D.27274 = acfg->ginst_hash;
      monoeg_g_hash_table_insert_replace (D.27274, klass, klass, 0);
      D.27313 = acfg->opts;
      D.27314 = D.27313 & 16777216;
      if (D.27314 != 0) goto <D.27315>; else goto <D.27316>;
      <D.27315>:
      D.27317 = klass->image;
      D.27318 = mono_defaults.corlib;
      if (D.27317 == D.27318) goto <D.27319>; else goto <D.27320>;
      <D.27319>:
      D.27278 = klass->generic_class;
      if (D.27278 != 0B) goto <D.27321>; else goto <D.27322>;
      <D.27321>:
      D.27278 = klass->generic_class;
      D.27281 = D.27278->context.class_inst;
      if (D.27281 != 0B) goto <D.27323>; else goto <D.27324>;
      <D.27323>:
      D.27278 = klass->generic_class;
      D.27281 = D.27278->context.class_inst;
      D.27325 = is_vt_inst (D.27281);
      if (D.27325 != 0) goto <D.27326>; else goto <D.27327>;
      <D.27326>:
      D.27328 = klass->name;
      D.27329 = strcmp (D.27328, "Dictionary`2");
      if (D.27329 == 0) goto <D.27311>; else goto <D.27330>;
      <D.27330>:
      D.27328 = klass->name;
      D.27331 = strcmp (D.27328, "List`1");
      if (D.27331 == 0) goto <D.27311>; else goto <D.27312>;
      <D.27311>:
      use_gsharedvt = 1;
      <D.27312>:
      <D.27327>:
      <D.27324>:
      <D.27322>:
      <D.27320>:
      <D.27316>:
      iter = 0B;
      goto <D.24576>;
      <D.24577>:
      D.27313 = acfg->opts;
      D.27314 = D.27313 & 16777216;
      if (D.27314 != 0) goto <D.27332>; else goto <D.27333>;
      <D.27332>:
      D.27334 = BIT_FIELD_REF <*method, 64, 256>;
      D.27335 = D.27334 & 2251799813685248;
      if (D.27335 != 0) goto <D.27336>; else goto <D.27337>;
      <D.27336>:
      D.27338 = mono_method_get_context (method);
      D.27339 = D.27338->method_inst;
      if (D.27339 != 0B) goto <D.27340>; else goto <D.27341>;
      <D.27340>:
      // predicted unlikely by continue predictor.
      goto <D.24576>;
      <D.27341>:
      <D.27337>:
      <D.27333>:
      D.27342 = mono_method_is_generic_sharable_full (method, 0, 0, use_gsharedvt);
      if (D.27342 != 0) goto <D.27343>; else goto <D.27344>;
      <D.27343>:
      add_types_from_method_header (acfg, method);
      // predicted unlikely by continue predictor.
      goto <D.24576>;
      <D.27344>:
      D.27334 = BIT_FIELD_REF <*method, 64, 256>;
      D.27345 = D.27334 & 4503599627370496;
      if (D.27345 != 0) goto <D.27346>; else goto <D.27347>;
      <D.27346>:
      // predicted unlikely by continue predictor.
      goto <D.24576>;
      <D.27347>:
      D.27348 = depth + 1;
      add_extra_method_with_depth (acfg, method, D.27348);
      <D.24576>:
      method = mono_class_get_methods (klass, &iter);
      if (method != 0B) goto <D.24577>; else goto <D.24578>;
      <D.24578>:
      iter = 0B;
      goto <D.24580>;
      <D.24579>:
      D.27349 = field->type;
      D.27350 = D.27349->type;
      if (D.27350 == 21) goto <D.27351>; else goto <D.27352>;
      <D.27351>:
      D.27349 = field->type;
      D.27353 = mono_class_from_mono_type (D.27349);
      D.27348 = depth + 1;
      add_generic_class_with_depth (acfg, D.27353, D.27348, "field");
      <D.27352>:
      <D.24580>:
      field = mono_class_get_fields (klass, &iter);
      if (field != 0B) goto <D.24579>; else goto <D.24581>;
      <D.24581>:
      D.27354 = BIT_FIELD_REF <*klass, 64, 256>;
      D.27355 = D.27354 & 549755813888;
      if (D.27355 != 0) goto <D.27356>; else goto <D.27357>;
      <D.27356>:
      method = mono_get_delegate_invoke (klass);
      method = mono_marshal_get_delegate_invoke (method, 0B);
      D.27307 = acfg->aot_opts.log_generics;
      if (D.27307 != 0) goto <D.27358>; else goto <D.27359>;
      <D.27358>:
      D.27360 = mono_method_full_name (method, 1);
      printf ("%*sAdding method %s.\n", depth, "", D.27360);
      <D.27359>:
      add_method (acfg, method);
      <D.27357>:
      D.27361 = klass->parent;
      if (D.27361 != 0B) goto <D.27362>; else goto <D.27363>;
      <D.27362>:
      D.27361 = klass->parent;
      add_generic_class_with_depth (acfg, D.27361, depth, "parent");
      <D.27363>:
      D.27317 = klass->image;
      D.27318 = mono_defaults.corlib;
      if (D.27317 == D.27318) goto <D.27366>; else goto <D.27367>;
      <D.27366>:
      D.27368 = klass->name_space;
      D.27369 = strcmp (D.27368, "System.Collections.Generic");
      if (D.27369 == 0) goto <D.27370>; else goto <D.27371>;
      <D.27370>:
      D.27328 = klass->name;
      D.27372 = strcmp (D.27328, "ICollection`1");
      if (D.27372 == 0) goto <D.27364>; else goto <D.27373>;
      <D.27373>:
      D.27328 = klass->name;
      D.27374 = strcmp (D.27328, "IEnumerable`1");
      if (D.27374 == 0) goto <D.27364>; else goto <D.27375>;
      <D.27375>:
      D.27328 = klass->name;
      D.27376 = strcmp (D.27328, "IList`1");
      if (D.27376 == 0) goto <D.27364>; else goto <D.27377>;
      <D.27377>:
      D.27328 = klass->name;
      D.27378 = strcmp (D.27328, "IEnumerator`1");
      if (D.27378 == 0) goto <D.27364>; else goto <D.27379>;
      <D.27379>:
      D.27328 = klass->name;
      D.27380 = strcmp (D.27328, "IReadOnlyList`1");
      if (D.27380 == 0) goto <D.27364>; else goto <D.27365>;
      <D.27364>:
      {
        struct MonoClass * tclass;
        struct MonoClass * array_class;
        void * iter;
        char * name_prefix;

        try
          {
            D.27278 = klass->generic_class;
            D.27281 = D.27278->context.class_inst;
            D.27381 = D.27281->type_argv[0];
            tclass = mono_class_from_mono_type (D.27381);
            array_class = mono_bounded_array_class_get (tclass, 1, 0);
            D.27328 = klass->name;
            D.27382 = strcmp (D.27328, "IEnumerator`1");
            if (D.27382 == 0) goto <D.27383>; else goto <D.27384>;
            <D.27383>:
            D.27368 = klass->name_space;
            name_prefix = monoeg_g_strdup_printf ("%s.%s", D.27368, "IEnumerable`1");
            goto <D.27385>;
            <D.27384>:
            D.27368 = klass->name_space;
            D.27328 = klass->name;
            name_prefix = monoeg_g_strdup_printf ("%s.%s", D.27368, D.27328);
            <D.27385>:
            D.27328 = klass->name;
            D.27388 = strcmp (D.27328, "IEnumerable`1");
            if (D.27388 == 0) goto <D.27386>; else goto <D.27389>;
            <D.27389>:
            D.27328 = klass->name;
            D.27390 = strcmp (D.27328, "IEnumerator`1");
            if (D.27390 == 0) goto <D.27386>; else goto <D.27387>;
            <D.27386>:
            {
              struct MonoClass * nclass;

              iter = 0B;
              goto <D.24589>;
              <D.24588>:
              D.27391 = nclass->name;
              D.27392 = strcmp (D.27391, "InternalEnumerator`1");
              if (D.27392 == 0) goto <D.24587>; else goto <D.27393>;
              <D.27393>:
              <D.24589>:
              D.27394 = array_class->parent;
              nclass = mono_class_get_nested_types (D.27394, &iter);
              if (nclass != 0B) goto <D.24588>; else goto <D.24587>;
              <D.24587>:
              D.27395 = nclass == 0B;
              D.27396 = (long int) D.27395;
              D.27397 = __builtin_expect (D.27396, 0);
              if (D.27397 != 0) goto <D.27398>; else goto <D.27399>;
              <D.27398>:
              monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "aot-compiler.c", 3948, "nclass");
              <D.27399>:
              D.27278 = klass->generic_class;
              D.27400 = mono_generic_class_get_context (D.27278);
              nclass = mono_class_inflate_generic_class (nclass, D.27400);
              add_generic_class (acfg, nclass, 0, "ICollection<T>");
            }
            <D.27387>:
            iter = 0B;
            goto <D.24592>;
            <D.24591>:
            D.27401 = method->name;
            D.27402 = strstr (D.27401, name_prefix);
            if (D.27402 != 0B) goto <D.27403>; else goto <D.27404>;
            <D.27403>:
            {
              struct MonoMethod * m;

              m = mono_aot_get_array_helper_from_wrapper (method);
              add_extra_method_with_depth (acfg, m, depth);
            }
            <D.27404>:
            <D.24592>:
            method = mono_class_get_methods (array_class, &iter);
            if (method != 0B) goto <D.24591>; else goto <D.24593>;
            <D.24593>:
            monoeg_g_free (name_prefix);
          }
        finally
          {
            iter = {CLOBBER};
          }
      }
      <D.27365>:
      <D.27371>:
      <D.27367>:
      D.27317 = klass->image;
      D.27318 = mono_defaults.corlib;
      if (D.27317 == D.27318) goto <D.27405>; else goto <D.27406>;
      <D.27405>:
      D.27368 = klass->name_space;
      D.27407 = strcmp (D.27368, "System.Collections.Generic");
      if (D.27407 == 0) goto <D.27408>; else goto <D.27409>;
      <D.27408>:
      D.27328 = klass->name;
      D.27410 = strcmp (D.27328, "Comparer`1");
      if (D.27410 == 0) goto <D.27411>; else goto <D.27412>;
      <D.27411>:
      {
        struct MonoClass * tclass;
        struct MonoClass * icomparable;
        struct MonoClass * gcomparer;
        struct MonoGenericContext ctx;
        struct MonoType * args[16];

        try
          {
            D.27278 = klass->generic_class;
            D.27281 = D.27278->context.class_inst;
            D.27381 = D.27281->type_argv[0];
            tclass = mono_class_from_mono_type (D.27381);
            memset (&ctx, 0, 16);
            D.27318 = mono_defaults.corlib;
            icomparable = mono_class_from_name (D.27318, "System", "IComparable`1");
            D.27413 = icomparable == 0B;
            D.27414 = (long int) D.27413;
            D.27415 = __builtin_expect (D.27414, 0);
            if (D.27415 != 0) goto <D.27416>; else goto <D.27417>;
            <D.27416>:
            monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "aot-compiler.c", 3975, "icomparable");
            <D.27417>:
            D.27418 = &tclass->byval_arg;
            args[0] = D.27418;
            D.27419 = mono_metadata_get_generic_inst (1, &args);
            ctx.class_inst = D.27419;
            D.27420 = mono_class_inflate_generic_class (icomparable, &ctx);
            D.27421 = mono_class_is_assignable_from (D.27420, tclass);
            if (D.27421 != 0) goto <D.27422>; else goto <D.27423>;
            <D.27422>:
            D.27318 = mono_defaults.corlib;
            gcomparer = mono_class_from_name (D.27318, "System.Collections.Generic", "GenericComparer`1");
            D.27424 = gcomparer == 0B;
            D.27425 = (long int) D.27424;
            D.27426 = __builtin_expect (D.27425, 0);
            if (D.27426 != 0) goto <D.27427>; else goto <D.27428>;
            <D.27427>:
            monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "aot-compiler.c", 3981, "gcomparer");
            <D.27428>:
            D.27429 = mono_class_inflate_generic_class (gcomparer, &ctx);
            add_generic_class (acfg, D.27429, 0, "Comparer<T>");
            <D.27423>:
          }
        finally
          {
            ctx = {CLOBBER};
            args = {CLOBBER};
          }
      }
      <D.27412>:
      <D.27409>:
      <D.27406>:
      D.27317 = klass->image;
      D.27318 = mono_defaults.corlib;
      if (D.27317 == D.27318) goto <D.27430>; else goto <D.27431>;
      <D.27430>:
      D.27368 = klass->name_space;
      D.27432 = strcmp (D.27368, "System.Collections.Generic");
      if (D.27432 == 0) goto <D.27433>; else goto <D.27434>;
      <D.27433>:
      D.27328 = klass->name;
      D.27435 = strcmp (D.27328, "EqualityComparer`1");
      if (D.27435 == 0) goto <D.27436>; else goto <D.27437>;
      <D.27436>:
      {
        struct MonoClass * tclass;
        struct MonoClass * iface;
        struct MonoClass * gcomparer;
        struct MonoGenericContext ctx;
        struct MonoType * args[16];

        try
          {
            D.27278 = klass->generic_class;
            D.27281 = D.27278->context.class_inst;
            D.27381 = D.27281->type_argv[0];
            tclass = mono_class_from_mono_type (D.27381);
            memset (&ctx, 0, 16);
            D.27318 = mono_defaults.corlib;
            iface = mono_class_from_name (D.27318, "System", "IEquatable`1");
            D.27438 = iface == 0B;
            D.27439 = (long int) D.27438;
            D.27440 = __builtin_expect (D.27439, 0);
            if (D.27440 != 0) goto <D.27441>; else goto <D.27442>;
            <D.27441>:
            monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "aot-compiler.c", 3996, "iface");
            <D.27442>:
            D.27443 = &tclass->byval_arg;
            args[0] = D.27443;
            D.27444 = mono_metadata_get_generic_inst (1, &args);
            ctx.class_inst = D.27444;
            D.27445 = mono_class_inflate_generic_class (iface, &ctx);
            D.27446 = mono_class_is_assignable_from (D.27445, tclass);
            if (D.27446 != 0) goto <D.27447>; else goto <D.27448>;
            <D.27447>:
            D.27318 = mono_defaults.corlib;
            gcomparer = mono_class_from_name (D.27318, "System.Collections.Generic", "GenericEqualityComparer`1");
            D.27449 = gcomparer == 0B;
            D.27450 = (long int) D.27449;
            D.27451 = __builtin_expect (D.27450, 0);
            if (D.27451 != 0) goto <D.27452>; else goto <D.27453>;
            <D.27452>:
            monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "aot-compiler.c", 4002, "gcomparer");
            <D.27453>:
            D.27454 = mono_class_inflate_generic_class (gcomparer, &ctx);
            add_generic_class (acfg, D.27454, 0, "EqualityComparer<T>");
            <D.27448>:
          }
        finally
          {
            ctx = {CLOBBER};
            args = {CLOBBER};
          }
      }
      <D.27437>:
      <D.27434>:
      <D.27431>:
    }
  finally
    {
      iter = {CLOBBER};
    }
}


has_type_vars (struct MonoClass * klass)
{
  unsigned char D.27460;
  gboolean D.27462;
  unsigned char D.27463;
  struct MonoClass * D.27466;
  struct MonoGenericClass * D.27467;
  struct MonoGenericInst * D.27470;
  struct MonoType * D.27473;
  struct MonoClass * D.27474;
  int D.27475;
  <unnamed-unsigned:22> D.27478;
  int D.27479;
  struct MonoGenericContainer * D.27480;

  D.27460 = klass->byval_arg.type;
  if (D.27460 == 19) goto <D.27458>; else goto <D.27461>;
  <D.27461>:
  D.27460 = klass->byval_arg.type;
  if (D.27460 == 30) goto <D.27458>; else goto <D.27459>;
  <D.27458>:
  D.27462 = 1;
  return D.27462;
  <D.27459>:
  D.27463 = klass->rank;
  if (D.27463 != 0) goto <D.27464>; else goto <D.27465>;
  <D.27464>:
  D.27466 = klass->element_class;
  D.27462 = has_type_vars (D.27466);
  return D.27462;
  <D.27465>:
  D.27467 = klass->generic_class;
  if (D.27467 != 0B) goto <D.27468>; else goto <D.27469>;
  <D.27468>:
  {
    struct MonoGenericContext * context;

    D.27467 = klass->generic_class;
    context = &D.27467->context;
    D.27470 = context->class_inst;
    if (D.27470 != 0B) goto <D.27471>; else goto <D.27472>;
    <D.27471>:
    {
      int i;

      i = 0;
      goto <D.24521>;
      <D.24520>:
      D.27470 = context->class_inst;
      D.27473 = D.27470->type_argv[i];
      D.27474 = mono_class_from_mono_type (D.27473);
      D.27475 = has_type_vars (D.27474);
      if (D.27475 != 0) goto <D.27476>; else goto <D.27477>;
      <D.27476>:
      D.27462 = 1;
      return D.27462;
      <D.27477>:
      i = i + 1;
      <D.24521>:
      D.27470 = context->class_inst;
      D.27478 = D.27470->type_argc;
      D.27479 = (int) D.27478;
      if (D.27479 > i) goto <D.24520>; else goto <D.24522>;
      <D.24522>:
    }
    <D.27472>:
  }
  <D.27469>:
  D.27480 = klass->generic_container;
  if (D.27480 != 0B) goto <D.27481>; else goto <D.27482>;
  <D.27481>:
  D.27462 = 1;
  return D.27462;
  <D.27482>:
  D.27462 = 0;
  return D.27462;
}


check_type_depth (struct MonoType * t, int depth)
{
  gboolean D.27486;
  unsigned char D.27487;
  int D.27488;
  struct MonoType * D.27491;
  int D.27492;
  int D.27493;
  <unnamed-unsigned:22> D.27496;
  int D.27497;
  int i;

  if (depth > 8) goto <D.27484>; else goto <D.27485>;
  <D.27484>:
  D.27486 = 1;
  return D.27486;
  <D.27485>:
  D.27487 = t->type;
  D.27488 = (int) D.27487;
  switch (D.27488) <default: <D.24562>, case 21: <D.24555>>
  <D.24555>:
  {
    struct MonoGenericClass * gklass;
    struct MonoGenericInst * ginst;

    gklass = t->data.generic_class;
    ginst = gklass->context.class_inst;
    if (ginst != 0B) goto <D.27489>; else goto <D.27490>;
    <D.27489>:
    i = 0;
    goto <D.24559>;
    <D.24558>:
    D.27491 = ginst->type_argv[i];
    D.27492 = depth + 1;
    D.27493 = check_type_depth (D.27491, D.27492);
    if (D.27493 != 0) goto <D.27494>; else goto <D.27495>;
    <D.27494>:
    D.27486 = 1;
    return D.27486;
    <D.27495>:
    i = i + 1;
    <D.24559>:
    D.27496 = ginst->type_argc;
    D.27497 = (int) D.27496;
    if (D.27497 > i) goto <D.24558>; else goto <D.24560>;
    <D.24560>:
    <D.27490>:
    goto <D.24561>;
  }
  <D.24562>:
  goto <D.24561>;
  <D.24561>:
  D.27486 = 0;
  return D.27486;
}


is_vt_inst (struct MonoGenericInst * inst)
{
  unsigned char D.27500;
  gboolean D.27503;
  <unnamed-unsigned:22> D.27504;
  int D.27505;
  int i;

  i = 0;
  goto <D.24529>;
  <D.24528>:
  {
    struct MonoType * t;

    t = inst->type_argv[i];
    D.27500 = t->type;
    if (D.27500 == 17) goto <D.27501>; else goto <D.27502>;
    <D.27501>:
    D.27503 = 1;
    return D.27503;
    <D.27502>:
  }
  i = i + 1;
  <D.24529>:
  D.27504 = inst->type_argc;
  D.27505 = (int) D.27504;
  if (D.27505 > i) goto <D.24528>; else goto <D.24530>;
  <D.24530>:
  D.27503 = 0;
  return D.27503;
}


add_method (struct MonoAotCompile * acfg, struct MonoMethod * method)
{
  int D.27507;

  D.27507 = add_method_full (acfg, method, 0, 0);
  return D.27507;
}


add_types_from_method_header (struct MonoAotCompile * acfg, struct MonoMethod * method)
{
  struct GHashTable * D.27509;
  void * D.27510;
  long int D.27511;
  struct MonoType * D.27514;
  unsigned char D.27515;
  struct MonoClass * D.27518;
  int D.27519;
  short unsigned int D.27520;
  int D.27521;
  struct MonoType * D.27524;
  unsigned char D.27525;
  struct MonoClass * D.27528;
  short unsigned int D.27529;
  int D.27530;
  struct MonoMethodHeader * header;
  struct MonoMethodSignature * sig;
  int j;
  int depth;

  D.27509 = acfg->method_depth;
  D.27510 = monoeg_g_hash_table_lookup (D.27509, method);
  D.27511 = (long int) D.27510;
  depth = (int) D.27511;
  sig = mono_method_signature (method);
  if (sig != 0B) goto <D.27512>; else goto <D.27513>;
  <D.27512>:
  j = 0;
  goto <D.24626>;
  <D.24625>:
  D.27514 = sig->params[j];
  D.27515 = D.27514->type;
  if (D.27515 == 21) goto <D.27516>; else goto <D.27517>;
  <D.27516>:
  D.27514 = sig->params[j];
  D.27518 = mono_class_from_mono_type (D.27514);
  D.27519 = depth + 1;
  add_generic_class_with_depth (acfg, D.27518, D.27519, "arg");
  <D.27517>:
  j = j + 1;
  <D.24626>:
  D.27520 = sig->param_count;
  D.27521 = (int) D.27520;
  if (D.27521 > j) goto <D.24625>; else goto <D.24627>;
  <D.24627>:
  <D.27513>:
  header = mono_method_get_header (method);
  if (header != 0B) goto <D.27522>; else goto <D.27523>;
  <D.27522>:
  j = 0;
  goto <D.24629>;
  <D.24628>:
  D.27524 = header->locals[j];
  D.27525 = D.27524->type;
  if (D.27525 == 21) goto <D.27526>; else goto <D.27527>;
  <D.27526>:
  D.27524 = header->locals[j];
  D.27528 = mono_class_from_mono_type (D.27524);
  D.27519 = depth + 1;
  add_generic_class_with_depth (acfg, D.27528, D.27519, "local");
  <D.27527>:
  j = j + 1;
  <D.24629>:
  D.27529 = header->num_locals;
  D.27530 = (int) D.27529;
  if (D.27530 > j) goto <D.24628>; else goto <D.24630>;
  <D.24630>:
  goto <D.27531>;
  <D.27523>:
  mono_loader_clear_error ();
  <D.27531>:
}


add_instances_of (struct MonoAotCompile * acfg, struct MonoClass * klass, struct MonoType * * insts, int ninsts, gboolean force)
{
  int D.27532;
  long unsigned int D.27535;
  long unsigned int D.27536;
  struct MonoType * * D.27537;
  struct MonoType * D.27538;
  struct MonoGenericInst * D.27539;
  struct MonoClass * D.27540;
  int i;
  struct MonoGenericContext ctx;
  struct MonoType * args[16];

  try
    {
      D.27532 = acfg->aot_opts.no_instances;
      if (D.27532 != 0) goto <D.27533>; else goto <D.27534>;
      <D.27533>:
      return;
      <D.27534>:
      memset (&ctx, 0, 16);
      i = 0;
      goto <D.24615>;
      <D.24614>:
      D.27535 = (long unsigned int) i;
      D.27536 = D.27535 * 8;
      D.27537 = insts + D.27536;
      D.27538 = *D.27537;
      args[0] = D.27538;
      D.27539 = mono_metadata_get_generic_inst (1, &args);
      ctx.class_inst = D.27539;
      D.27540 = mono_class_inflate_generic_class (klass, &ctx);
      add_generic_class (acfg, D.27540, force, "");
      i = i + 1;
      <D.24615>:
      if (i < ninsts) goto <D.24614>; else goto <D.24616>;
      <D.24616>:
    }
  finally
    {
      ctx = {CLOBBER};
      args = {CLOBBER};
    }
}


add_wrappers (struct MonoAotCompile * acfg)
{
  int D.27544;
  int D.27545;
  struct MonoImage * D.27546;
  short unsigned int D.27549;
  int D.27550;
  int D.27551;
  short unsigned int D.27553;
  int D.27554;
  int D.27555;
  int D.27557;
  struct MonoType * D.27562;
  unsigned char D.27563;
  int D.27565;
  struct MonoType * D.27568;
  unsigned char D.27569;
  int D.27572;
  short unsigned int D.27575;
  int D.27576;
  struct MonoMethod * D.27579;
  <unnamed-unsigned:24> D.27580;
  int D.27581;
  struct MonoAssembly * D.27582;
  const char * D.27583;
  int D.27584;
  struct MonoImage * D.27587;
  struct MonoClass * D.27588;
  struct MonoType * D.27589;
  struct MonoMethod * D.27590;
  struct MonoMethod * D.27591;
  struct MonoClass * D.27592;
  struct MonoType * D.27593;
  struct MonoMethod * D.27594;
  struct MonoMethod * D.27595;
  struct MonoMethod * D.27596;
  struct MonoClass * D.27597;
  struct MonoType * D.27598;
  struct MonoMethod * D.27599;
  struct MonoClass * D.27600;
  struct MonoType * D.27601;
  struct MonoClass * D.27602;
  struct MonoType * D.27603;
  struct MonoMethod * D.27604;
  struct MonoClass * D.27605;
  struct MonoMethod * D.27606;
  struct MonoMethod * D.27607;
  struct MonoMethod * D.27610;
  struct MonoMethod * D.27611;
  unsigned int D.27614;
  struct MonoClass * D.27617;
  _Bool D.27622;
  long int D.27623;
  long int D.27624;
  long unsigned int D.27629;
  long unsigned int D.27630;
  struct MonoMethod * * D.27631;
  struct MonoMethod * D.27632;
  int nwrappers.57;
  struct MonoMethod * D.27634;
  struct MonoMethod * D.27635;
  struct GHashTable * D.27636;
  int D.27637;
  long unsigned int D.27642;
  long unsigned int D.27643;
  struct MonoClass * D.27645;
  struct MonoClass * D.27647;
  struct MonoGenericContainer * D.27648;
  struct MonoMethod * D.27653;
  struct MonoMethod * D.27656;
  struct MonoMethod * D.27659;
  struct MonoClass * D.27662;
  const char * D.27663;
  int D.27664;
  int D.27666;
  int D.27668;
  struct MonoMethod * D.27671;
  unsigned int D.27673;
  unsigned int D.27674;
  long unsigned int D.27679;
  long unsigned int D.27680;
  _Bool D.27681;
  long int D.27682;
  long int D.27683;
  <unnamed-unsigned:24> D.27690;
  int D.27691;
  int D.27692;
  unsigned char D.27697;
  struct MonoClass * D.27700;
  long unsigned int D.27701;
  long unsigned int D.27702;
  unsigned char D.27705;
  unsigned char D.27706;
  unsigned char D.27708;
  _Bool D.27709;
  long int D.27710;
  long int D.27711;
  struct MonoMethod * D.27714;
  struct MonoMethod * D.27717;
  <unnamed-unsigned:24> D.27718;
  int D.27719;
  short unsigned int D.27720;
  int D.27721;
  int D.27722;
  long unsigned int D.27725;
  long unsigned int D.27726;
  struct MonoClass * D.27730;
  struct MonoGenericContainer * D.27731;
  long unsigned int D.27734;
  long unsigned int D.27735;
  _Bool D.27736;
  long int D.27737;
  long int D.27738;
  struct MonoMethod * D.27742;
  short unsigned int D.27745;
  int D.27746;
  int D.27747;
  short unsigned int D.27749;
  int D.27750;
  int D.27751;
  struct MonoMethod * D.27752;
  struct MonoMethod * D.27755;
  struct MonoClass * D.27758;
  const char * D.27759;
  int D.27760;
  int D.27762;
  struct MonoMethod * D.27765;
  const mono_byte * p.58;
  short unsigned int D.27767;
  int D.27768;
  int D.27769;
  char * D.27772;
  short unsigned int D.27773;
  _Bool D.27774;
  long int D.27775;
  long int D.27776;
  int iftmp.59;
  struct MonoType * D.27783;
  unsigned char D.27784;
  struct MonoClass * D.27786;
  const char * D.27787;
  int D.27788;
  _Bool D.27789;
  long int D.27790;
  long int D.27791;
  const char * p.60;
  const char * p.61;
  unsigned int D.27796;
  int D.27797;
  unsigned int D.27798;
  sizetype D.27799;
  char * D.27800;
  _Bool D.27801;
  long int D.27802;
  long int D.27803;
  struct MonoClass * D.27806;
  _Bool D.27807;
  long int D.27808;
  long int D.27809;
  const char * p.62;
  short unsigned int D.27813;
  short unsigned int D.27814;
  int D.27815;
  int D.27816;
  int D.27817;
  int D.27818;
  _Bool D.27819;
  long int D.27820;
  long int D.27821;
  const char * named.63;
  char D.27827;
  const char * named.64;
  unsigned int D.27829;
  int D.27830;
  long unsigned int D.27831;
  long unsigned int D.27832;
  sizetype D.27833;
  char * D.27834;
  const char * named.65;
  _Bool D.27836;
  long int D.27837;
  long int D.27838;
  int D.27841;
  _Bool D.27842;
  long int D.27843;
  long int D.27844;
  _Bool D.27847;
  long int D.27848;
  long int D.27849;
  unsigned int D.27852;
  long unsigned int D.27853;
  long unsigned int D.27854;
  char * D.27855;
  const char * named.66;
  struct GHashTable * D.27859;
  int D.27862;
  short unsigned int D.27864;
  int D.27865;
  int D.27866;
  struct MonoMethod * D.27867;
  long unsigned int D.27872;
  long unsigned int D.27873;
  struct MonoGenericContainer * D.27876;
  int D.27879;
  struct MonoClass * D.27882;
  const char * D.27884;
  char * D.27885;
  struct MonoMethod * D.27886;
  struct MonoMethod * D.27887;
  struct MonoMethod * method;
  struct MonoMethod * m;
  int i;
  int j;
  struct MonoMethodSignature * sig;
  struct MonoMethodSignature * csig;
  guint32 token;

  i = 0;
  goto <D.24439>;
  <D.24438>:
  {
    struct MonoMethod * method;
    guint32 token;
    gboolean skip;

    D.27544 = i + 1;
    D.27545 = D.27544 | 100663296;
    token = (guint32) D.27545;
    skip = 0;
    D.27546 = acfg->image;
    method = mono_get_method (D.27546, token, 0B);
    D.27549 = method->flags;
    D.27550 = (int) D.27549;
    D.27551 = D.27550 & 8192;
    if (D.27551 != 0) goto <D.27547>; else goto <D.27552>;
    <D.27552>:
    D.27553 = method->iflags;
    D.27554 = (int) D.27553;
    D.27555 = D.27554 & 3;
    if (D.27555 != 0) goto <D.27547>; else goto <D.27556>;
    <D.27556>:
    D.27549 = method->flags;
    D.27550 = (int) D.27549;
    D.27557 = D.27550 & 1024;
    if (D.27557 != 0) goto <D.27547>; else goto <D.27548>;
    <D.27547>:
    skip = 1;
    <D.27548>:
    sig = mono_method_signature (method);
    if (sig == 0B) goto <D.27558>; else goto <D.27559>;
    <D.27558>:
    // predicted unlikely by continue predictor.
    goto <D.24434>;
    <D.27559>:
    D.27562 = sig->ret;
    D.27563 = D.27562->type;
    if (D.27563 == 15) goto <D.27560>; else goto <D.27564>;
    <D.27564>:
    D.27562 = sig->ret;
    D.27563 = D.27562->type;
    if (D.27563 == 22) goto <D.27560>; else goto <D.27561>;
    <D.27560>:
    skip = 1;
    <D.27561>:
    D.27562 = sig->ret;
    D.27565 = mono_class_is_open_constructed_type (D.27562);
    if (D.27565 != 0) goto <D.27566>; else goto <D.27567>;
    <D.27566>:
    skip = 1;
    <D.27567>:
    j = 0;
    goto <D.24436>;
    <D.24435>:
    D.27568 = sig->params[j];
    D.27569 = D.27568->type;
    if (D.27569 == 22) goto <D.27570>; else goto <D.27571>;
    <D.27570>:
    skip = 1;
    <D.27571>:
    D.27568 = sig->params[j];
    D.27572 = mono_class_is_open_constructed_type (D.27568);
    if (D.27572 != 0) goto <D.27573>; else goto <D.27574>;
    <D.27573>:
    skip = 1;
    <D.27574>:
    j = j + 1;
    <D.24436>:
    D.27575 = sig->param_count;
    D.27576 = (int) D.27575;
    if (D.27576 > j) goto <D.24435>; else goto <D.24437>;
    <D.24437>:
    if (skip == 0) goto <D.27577>; else goto <D.27578>;
    <D.27577>:
    D.27579 = mono_marshal_get_runtime_invoke (method, 0);
    add_method (acfg, D.27579);
    <D.27578>:
  }
  <D.24434>:
  i = i + 1;
  <D.24439>:
  D.27546 = acfg->image;
  D.27580 = D.27546->tables[6].rows;
  D.27581 = (int) D.27580;
  if (D.27581 > i) goto <D.24438>; else goto <D.24440>;
  <D.24440>:
  D.27546 = acfg->image;
  D.27582 = D.27546->assembly;
  D.27583 = D.27582->aname.name;
  D.27584 = strcmp (D.27583, "mscorlib");
  if (D.27584 == 0) goto <D.27585>; else goto <D.27586>;
  <D.27585>:
  {
    struct MonoMethodDesc * desc;
    struct MonoMethod * orig_method;
    int nallocators;

    D.27587 = mono_defaults.corlib;
    csig = mono_metadata_signature_alloc (D.27587, 0);
    D.27588 = mono_defaults.void_class;
    D.27589 = &D.27588->byval_arg;
    csig->ret = D.27589;
    D.27590 = get_runtime_invoke_sig (csig);
    add_method (acfg, D.27590);
    D.27587 = mono_defaults.corlib;
    csig = mono_metadata_signature_alloc (D.27587, 0);
    csig->hasthis = 1;
    D.27588 = mono_defaults.void_class;
    D.27589 = &D.27588->byval_arg;
    csig->ret = D.27589;
    D.27591 = get_runtime_invoke_sig (csig);
    add_method (acfg, D.27591);
    D.27587 = mono_defaults.corlib;
    csig = mono_metadata_signature_alloc (D.27587, 1);
    csig->hasthis = 1;
    D.27588 = mono_defaults.void_class;
    D.27589 = &D.27588->byval_arg;
    csig->ret = D.27589;
    D.27592 = mono_defaults.string_class;
    D.27593 = &D.27592->byval_arg;
    csig->params[0] = D.27593;
    D.27594 = get_runtime_invoke_sig (csig);
    add_method (acfg, D.27594);
    D.27587 = mono_defaults.corlib;
    csig = mono_metadata_signature_alloc (D.27587, 2);
    csig->hasthis = 1;
    D.27588 = mono_defaults.void_class;
    D.27589 = &D.27588->byval_arg;
    csig->ret = D.27589;
    D.27592 = mono_defaults.string_class;
    D.27593 = &D.27592->byval_arg;
    csig->params[0] = D.27593;
    D.27592 = mono_defaults.string_class;
    D.27593 = &D.27592->byval_arg;
    csig->params[1] = D.27593;
    D.27595 = get_runtime_invoke_sig (csig);
    add_method (acfg, D.27595);
    D.27587 = mono_defaults.corlib;
    csig = mono_metadata_signature_alloc (D.27587, 0);
    csig->hasthis = 1;
    D.27592 = mono_defaults.string_class;
    D.27593 = &D.27592->byval_arg;
    csig->ret = D.27593;
    D.27596 = get_runtime_invoke_sig (csig);
    add_method (acfg, D.27596);
    D.27587 = mono_defaults.corlib;
    csig = mono_metadata_signature_alloc (D.27587, 2);
    csig->hasthis = 1;
    D.27588 = mono_defaults.void_class;
    D.27589 = &D.27588->byval_arg;
    csig->ret = D.27589;
    D.27592 = mono_defaults.string_class;
    D.27593 = &D.27592->byval_arg;
    csig->params[0] = D.27593;
    D.27597 = mono_defaults.exception_class;
    D.27598 = &D.27597->byval_arg;
    csig->params[1] = D.27598;
    D.27599 = get_runtime_invoke_sig (csig);
    add_method (acfg, D.27599);
    D.27587 = mono_defaults.corlib;
    csig = mono_metadata_signature_alloc (D.27587, 2);
    csig->hasthis = 1;
    D.27587 = mono_defaults.corlib;
    D.27600 = mono_class_from_name (D.27587, "System.Reflection", "Assembly");
    D.27601 = &D.27600->byval_arg;
    csig->ret = D.27601;
    D.27592 = mono_defaults.string_class;
    D.27593 = &D.27592->byval_arg;
    csig->params[0] = D.27593;
    D.27602 = mono_defaults.boolean_class;
    D.27603 = &D.27602->byval_arg;
    csig->params[1] = D.27603;
    D.27604 = get_runtime_invoke_sig (csig);
    add_method (acfg, D.27604);
    D.27605 = mono_defaults.object_class;
    D.27606 = mono_class_get_method_from_name_flags (D.27605, "Finalize", 0, 0);
    D.27607 = mono_marshal_get_runtime_invoke (D.27606, 1);
    add_method (acfg, D.27607);
    method = mono_get_context_capture_method ();
    if (method != 0B) goto <D.27608>; else goto <D.27609>;
    <D.27608>:
    D.27610 = mono_marshal_get_runtime_invoke (method, 0);
    add_method (acfg, D.27610);
    <D.27609>:
    D.27611 = mono_marshal_get_stelemref ();
    add_method (acfg, D.27611);
    if (1 != 0) goto <D.27612>; else goto <D.27613>;
    <D.27612>:
    D.27614 = mono_gc_get_managed_allocator_types ();
    nallocators = (int) D.27614;
    i = 0;
    goto <D.24445>;
    <D.24444>:
    m = mono_gc_get_managed_allocator_by_type (i);
    if (m != 0B) goto <D.27615>; else goto <D.27616>;
    <D.27615>:
    add_method (acfg, m);
    <D.27616>:
    i = i + 1;
    <D.24445>:
    if (i < nallocators) goto <D.24444>; else goto <D.24446>;
    <D.24446>:
    desc = mono_method_desc_new ("Monitor:Enter(object,bool&)", 0);
    D.27617 = mono_defaults.monitor_class;
    orig_method = mono_method_desc_search_in_class (desc, D.27617);
    if (orig_method != 0B) goto <D.27618>; else goto <D.27619>;
    <D.27618>:
    method = mono_monitor_get_fast_path (orig_method);
    if (method != 0B) goto <D.27620>; else goto <D.27621>;
    <D.27620>:
    add_method (acfg, method);
    <D.27621>:
    <D.27619>:
    mono_method_desc_free (desc);
    desc = mono_method_desc_new ("Monitor:Exit(object)", 0);
    D.27617 = mono_defaults.monitor_class;
    orig_method = mono_method_desc_search_in_class (desc, D.27617);
    D.27622 = orig_method == 0B;
    D.27623 = (long int) D.27622;
    D.27624 = __builtin_expect (D.27623, 0);
    if (D.27624 != 0) goto <D.27625>; else goto <D.27626>;
    <D.27625>:
    monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "aot-compiler.c", 3370, "orig_method");
    <D.27626>:
    mono_method_desc_free (desc);
    method = mono_monitor_get_fast_path (orig_method);
    if (method != 0B) goto <D.27627>; else goto <D.27628>;
    <D.27627>:
    add_method (acfg, method);
    <D.27628>:
    <D.27613>:
    {
      struct MonoMethod * * wrappers;
      int nwrappers;

      try
        {
          wrappers = mono_marshal_get_virtual_stelemref_wrappers (&nwrappers);
          i = 0;
          goto <D.24450>;
          <D.24449>:
          D.27629 = (long unsigned int) i;
          D.27630 = D.27629 * 8;
          D.27631 = wrappers + D.27630;
          D.27632 = *D.27631;
          add_method (acfg, D.27632);
          i = i + 1;
          <D.24450>:
          nwrappers.57 = nwrappers;
          if (i < nwrappers.57) goto <D.24449>; else goto <D.24451>;
          <D.24451>:
          monoeg_g_free (wrappers);
        }
      finally
        {
          nwrappers = {CLOBBER};
        }
    }
    D.27634 = mono_marshal_get_castclass_with_cache ();
    add_method (acfg, D.27634);
    D.27635 = mono_marshal_get_isinst_with_cache ();
    add_method (acfg, D.27635);
    D.27636 = mono_get_jit_icall_info ();
    monoeg_g_hash_table_foreach (D.27636, add_jit_icall_wrapper, acfg);
  }
  <D.27586>:
  i = 0;
  goto <D.24463>;
  <D.24462>:
  {
    struct MonoClass * klass;
    struct MonoCustomAttrInfo * cattr;

    D.27544 = i + 1;
    D.27637 = D.27544 | 33554432;
    token = (guint32) D.27637;
    D.27546 = acfg->image;
    klass = mono_class_get (D.27546, token);
    if (klass == 0B) goto <D.27638>; else goto <D.27639>;
    <D.27638>:
    mono_loader_clear_error ();
    // predicted unlikely by continue predictor.
    goto <D.24454>;
    <D.27639>:
    D.27642 = BIT_FIELD_REF <*klass, 64, 256>;
    D.27643 = D.27642 & 549755813888;
    if (D.27643 == 0) goto <D.27640>; else goto <D.27644>;
    <D.27644>:
    D.27645 = mono_defaults.delegate_class;
    if (D.27645 == klass) goto <D.27640>; else goto <D.27646>;
    <D.27646>:
    D.27647 = mono_defaults.multicastdelegate_class;
    if (D.27647 == klass) goto <D.27640>; else goto <D.27641>;
    <D.27640>:
    // predicted unlikely by continue predictor.
    goto <D.24454>;
    <D.27641>:
    D.27648 = klass->generic_container;
    if (D.27648 == 0B) goto <D.27649>; else goto <D.27650>;
    <D.27649>:
    method = mono_get_delegate_invoke (klass);
    m = mono_marshal_get_delegate_invoke (method, 0B);
    add_method (acfg, m);
    method = mono_class_get_method_from_name_flags (klass, "BeginInvoke", -1, 0);
    if (method != 0B) goto <D.27651>; else goto <D.27652>;
    <D.27651>:
    D.27653 = mono_marshal_get_delegate_begin_invoke (method);
    add_method (acfg, D.27653);
    <D.27652>:
    method = mono_class_get_method_from_name_flags (klass, "EndInvoke", -1, 0);
    if (method != 0B) goto <D.27654>; else goto <D.27655>;
    <D.27654>:
    D.27656 = mono_marshal_get_delegate_end_invoke (method);
    add_method (acfg, D.27656);
    <D.27655>:
    cattr = mono_custom_attrs_from_class (klass);
    if (cattr != 0B) goto <D.27657>; else goto <D.27658>;
    <D.27657>:
    {
      int j;

      j = 0;
      goto <D.24458>;
      <D.24457>:
      D.27659 = cattr->attrs[j].ctor;
      if (D.27659 != 0B) goto <D.27660>; else goto <D.27661>;
      <D.27660>:
      D.27659 = cattr->attrs[j].ctor;
      D.27662 = D.27659->klass;
      D.27663 = D.27662->name;
      D.27664 = strcmp (D.27663, "MonoNativeFunctionWrapperAttribute");
      if (D.27664 == 0) goto <D.24456>; else goto <D.27665>;
      <D.27665>:
      D.27659 = cattr->attrs[j].ctor;
      D.27662 = D.27659->klass;
      D.27663 = D.27662->name;
      D.27666 = strcmp (D.27663, "UnmanagedFunctionPointerAttribute");
      if (D.27666 == 0) goto <D.24456>; else goto <D.27667>;
      <D.27667>:
      <D.27661>:
      j = j + 1;
      <D.24458>:
      D.27668 = cattr->num_attrs;
      if (D.27668 > j) goto <D.24457>; else goto <D.24456>;
      <D.24456>:
      D.27668 = cattr->num_attrs;
      if (D.27668 > j) goto <D.27669>; else goto <D.27670>;
      <D.27669>:
      D.27671 = mono_marshal_get_native_func_wrapper_aot (klass);
      add_method (acfg, D.27671);
      <D.27670>:
    }
    <D.27658>:
    goto <D.27672>;
    <D.27650>:
    D.27673 = acfg->opts;
    D.27674 = D.27673 & 16777216;
    if (D.27674 != 0) goto <D.27675>; else goto <D.27676>;
    <D.27675>:
    D.27648 = klass->generic_container;
    if (D.27648 != 0B) goto <D.27677>; else goto <D.27678>;
    <D.27677>:
    {
      struct MonoGenericContext ctx;
      struct MonoMethod * inst;
      struct MonoMethod * gshared;

      try
        {
          method = mono_get_delegate_invoke (klass);
          create_gsharedvt_inst (acfg, method, &ctx);
          inst = mono_class_inflate_generic_method (method, &ctx);
          m = mono_marshal_get_delegate_invoke (inst, 0B);
          D.27679 = BIT_FIELD_REF <*m, 64, 256>;
          D.27680 = D.27679 & 2251799813685248;
          D.27681 = D.27680 == 0;
          D.27682 = (long int) D.27681;
          D.27683 = __builtin_expect (D.27682, 0);
          if (D.27683 != 0) goto <D.27684>; else goto <D.27685>;
          <D.27684>:
          monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "aot-compiler.c", 3493, "m->is_inflated");
          <D.27685>:
          gshared = mini_get_shared_method_full (m, 0, 1);
          add_extra_method (acfg, gshared);
          method = mono_get_delegate_begin_invoke (klass);
          create_gsharedvt_inst (acfg, method, &ctx);
          inst = mono_class_inflate_generic_method (method, &ctx);
          m = mono_marshal_get_delegate_begin_invoke (inst);
          D.27679 = BIT_FIELD_REF <*m, 64, 256>;
          D.27680 = D.27679 & 2251799813685248;
          D.27681 = D.27680 == 0;
          D.27682 = (long int) D.27681;
          D.27683 = __builtin_expect (D.27682, 0);
          if (D.27683 != 0) goto <D.27686>; else goto <D.27687>;
          <D.27686>:
          monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "aot-compiler.c", 3505, "m->is_inflated");
          <D.27687>:
          gshared = mini_get_shared_method_full (m, 0, 1);
          add_extra_method (acfg, gshared);
          method = mono_get_delegate_end_invoke (klass);
          create_gsharedvt_inst (acfg, method, &ctx);
          inst = mono_class_inflate_generic_method (method, &ctx);
          m = mono_marshal_get_delegate_end_invoke (inst);
          D.27679 = BIT_FIELD_REF <*m, 64, 256>;
          D.27680 = D.27679 & 2251799813685248;
          D.27681 = D.27680 == 0;
          D.27682 = (long int) D.27681;
          D.27683 = __builtin_expect (D.27682, 0);
          if (D.27683 != 0) goto <D.27688>; else goto <D.27689>;
          <D.27688>:
          monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "aot-compiler.c", 3517, "m->is_inflated");
          <D.27689>:
          gshared = mini_get_shared_method_full (m, 0, 1);
          add_extra_method (acfg, gshared);
        }
      finally
        {
          ctx = {CLOBBER};
        }
    }
    <D.27678>:
    <D.27676>:
    <D.27672>:
  }
  <D.24454>:
  i = i + 1;
  <D.24463>:
  D.27546 = acfg->image;
  D.27690 = D.27546->tables[2].rows;
  D.27691 = (int) D.27690;
  if (D.27691 > i) goto <D.24462>; else goto <D.24464>;
  <D.24464>:
  i = 0;
  goto <D.24470>;
  <D.24469>:
  {
    struct MonoClass * klass;

    D.27544 = i + 1;
    D.27692 = D.27544 | 452984832;
    token = (guint32) D.27692;
    D.27546 = acfg->image;
    klass = mono_class_get (D.27546, token);
    if (klass == 0B) goto <D.27693>; else goto <D.27694>;
    <D.27693>:
    mono_loader_clear_error ();
    // predicted unlikely by continue predictor.
    goto <D.24466>;
    <D.27694>:
    D.27697 = klass->rank;
    if (D.27697 != 0) goto <D.27698>; else goto <D.27699>;
    <D.27698>:
    D.27700 = klass->element_class;
    D.27701 = BIT_FIELD_REF <*D.27700, 64, 1664>;
    D.27702 = D.27701 & 8589934592;
    if (D.27702 == 0) goto <D.27703>; else goto <D.27704>;
    <D.27703>:
    D.27700 = klass->element_class;
    D.27705 = D.27700->byval_arg.type;
    D.27706 = D.27705 + 254;
    if (D.27706 <= 11) goto <D.27695>; else goto <D.27707>;
    <D.27707>:
    D.27700 = klass->element_class;
    D.27705 = D.27700->byval_arg.type;
    D.27708 = D.27705 + 232;
    if (D.27708 <= 1) goto <D.27695>; else goto <D.27696>;
    <D.27695>:
    {
      struct MonoMethod * m;
      struct MonoMethod * wrapper;

      m = mono_class_get_method_from_name (klass, "Get", -1);
      D.27709 = m == 0B;
      D.27710 = (long int) D.27709;
      D.27711 = __builtin_expect (D.27710, 0);
      if (D.27711 != 0) goto <D.27712>; else goto <D.27713>;
      <D.27712>:
      monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "aot-compiler.c", 3543, "m");
      <D.27713>:
      wrapper = mono_marshal_get_array_accessor_wrapper (m);
      add_extra_method (acfg, wrapper);
      D.27714 = mono_marshal_get_runtime_invoke (wrapper, 0);
      add_extra_method (acfg, D.27714);
      m = mono_class_get_method_from_name (klass, "Set", -1);
      D.27709 = m == 0B;
      D.27710 = (long int) D.27709;
      D.27711 = __builtin_expect (D.27710, 0);
      if (D.27711 != 0) goto <D.27715>; else goto <D.27716>;
      <D.27715>:
      monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "aot-compiler.c", 3549, "m");
      <D.27716>:
      wrapper = mono_marshal_get_array_accessor_wrapper (m);
      add_extra_method (acfg, wrapper);
      D.27717 = mono_marshal_get_runtime_invoke (wrapper, 0);
      add_extra_method (acfg, D.27717);
    }
    <D.27696>:
    <D.27704>:
    <D.27699>:
  }
  <D.24466>:
  i = i + 1;
  <D.24470>:
  D.27546 = acfg->image;
  D.27718 = D.27546->tables[27].rows;
  D.27719 = (int) D.27718;
  if (D.27719 > i) goto <D.24469>; else goto <D.24471>;
  <D.24471>:
  i = 0;
  goto <D.24477>;
  <D.24476>:
  D.27544 = i + 1;
  D.27545 = D.27544 | 100663296;
  token = (guint32) D.27545;
  D.27546 = acfg->image;
  method = mono_get_method (D.27546, token, 0B);
  D.27720 = method->iflags;
  D.27721 = (int) D.27720;
  D.27722 = D.27721 & 32;
  if (D.27722 != 0) goto <D.27723>; else goto <D.27724>;
  <D.27723>:
  D.27725 = BIT_FIELD_REF <*method, 64, 256>;
  D.27726 = D.27725 & 4503599627370496;
  if (D.27726 != 0) goto <D.27727>; else goto <D.27728>;
  <D.27727>:
  goto <D.27729>;
  <D.27728>:
  D.27730 = method->klass;
  D.27731 = D.27730->generic_container;
  if (D.27731 != 0B) goto <D.27732>; else goto <D.27733>;
  <D.27732>:
  {
    struct MonoGenericContext ctx;
    struct MonoMethod * inst;
    struct MonoMethod * gshared;
    struct MonoMethod * m;

    try
      {
        create_gsharedvt_inst (acfg, method, &ctx);
        inst = mono_class_inflate_generic_method (method, &ctx);
        m = mono_marshal_get_synchronized_wrapper (inst);
        D.27734 = BIT_FIELD_REF <*m, 64, 256>;
        D.27735 = D.27734 & 2251799813685248;
        D.27736 = D.27735 == 0;
        D.27737 = (long int) D.27736;
        D.27738 = __builtin_expect (D.27737, 0);
        if (D.27738 != 0) goto <D.27739>; else goto <D.27740>;
        <D.27739>:
        monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "aot-compiler.c", 3574, "m->is_inflated");
        <D.27740>:
        gshared = mini_get_shared_method_full (m, 0, 1);
        add_method (acfg, gshared);
      }
    finally
      {
        ctx = {CLOBBER};
      }
  }
  goto <D.27741>;
  <D.27733>:
  D.27742 = mono_marshal_get_synchronized_wrapper (method);
  add_method (acfg, D.27742);
  <D.27741>:
  <D.27729>:
  <D.27724>:
  i = i + 1;
  <D.24477>:
  D.27546 = acfg->image;
  D.27580 = D.27546->tables[6].rows;
  D.27581 = (int) D.27580;
  if (D.27581 > i) goto <D.24476>; else goto <D.24478>;
  <D.24478>:
  i = 0;
  goto <D.24482>;
  <D.24481>:
  {
    struct MonoMethod * method;
    guint32 token;

    D.27544 = i + 1;
    D.27545 = D.27544 | 100663296;
    token = (guint32) D.27545;
    D.27546 = acfg->image;
    method = mono_get_method (D.27546, token, 0B);
    D.27745 = method->flags;
    D.27746 = (int) D.27745;
    D.27747 = D.27746 & 8192;
    if (D.27747 != 0) goto <D.27743>; else goto <D.27748>;
    <D.27748>:
    D.27749 = method->iflags;
    D.27750 = (int) D.27749;
    D.27751 = D.27750 & 4096;
    if (D.27751 != 0) goto <D.27743>; else goto <D.27744>;
    <D.27743>:
    D.27752 = mono_marshal_get_native_wrapper (method, 1, 1);
    add_method (acfg, D.27752);
    <D.27744>:
  }
  i = i + 1;
  <D.24482>:
  D.27546 = acfg->image;
  D.27580 = D.27546->tables[6].rows;
  D.27581 = (int) D.27580;
  if (D.27581 > i) goto <D.24481>; else goto <D.24483>;
  <D.24483>:
  i = 0;
  goto <D.24508>;
  <D.24507>:
  {
    struct MonoMethod * method;
    guint32 token;
    struct MonoCustomAttrInfo * cattr;
    int j;

    D.27544 = i + 1;
    D.27545 = D.27544 | 100663296;
    token = (guint32) D.27545;
    D.27546 = acfg->image;
    method = mono_get_method (D.27546, token, 0B);
    cattr = mono_custom_attrs_from_method (method);
    if (cattr != 0B) goto <D.27753>; else goto <D.27754>;
    <D.27753>:
    j = 0;
    goto <D.24490>;
    <D.24489>:
    D.27755 = cattr->attrs[j].ctor;
    if (D.27755 != 0B) goto <D.27756>; else goto <D.27757>;
    <D.27756>:
    D.27755 = cattr->attrs[j].ctor;
    D.27758 = D.27755->klass;
    D.27759 = D.27758->name;
    D.27760 = strcmp (D.27759, "MonoPInvokeCallbackAttribute");
    if (D.27760 == 0) goto <D.24488>; else goto <D.27761>;
    <D.27761>:
    <D.27757>:
    j = j + 1;
    <D.24490>:
    D.27762 = cattr->num_attrs;
    if (D.27762 > j) goto <D.24489>; else goto <D.24488>;
    <D.24488>:
    D.27762 = cattr->num_attrs;
    if (D.27762 > j) goto <D.27763>; else goto <D.27764>;
    <D.27763>:
    {
      struct MonoCustomAttrEntry * e;
      struct MonoMethodSignature * sig;
      const char * p;
      const char * named;
      int slen;
      int num_named;
      int named_type;
      int data_type;
      char * n;
      struct MonoType * t;
      struct MonoClass * klass;
      char * export_name;
      struct MonoMethod * wrapper;

      try
        {
          e = &cattr->attrs[j];
          D.27765 = e->ctor;
          sig = mono_method_signature (D.27765);
          p.58 = e->data;
          p = p.58;
          export_name = 0B;
          D.27767 = method->flags;
          D.27768 = (int) D.27767;
          D.27769 = D.27768 & 16;
          if (D.27769 == 0) goto <D.27770>; else goto <D.27771>;
          <D.27770>:
          D.27772 = mono_method_full_name (method, 1);
          monoeg_g_log (0B, 16, "AOT restriction: Method \'%s\' must be static since it is decorated with [MonoPInvokeCallback]. See http://ios.xamarin.com/Documentation/Limitations#Reverse_Callbacks", D.27772);
          exit (1);
          <D.27771>:
          D.27773 = sig->param_count;
          D.27774 = D.27773 != 1;
          D.27775 = (long int) D.27774;
          D.27776 = __builtin_expect (D.27775, 0);
          if (D.27776 != 0) goto <D.27777>; else goto <D.27778>;
          <D.27777>:
          monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "aot-compiler.c", 3635, "sig->param_count == 1");
          <D.27778>:
          D.27783 = sig->params[0];
          D.27784 = D.27783->type;
          if (D.27784 != 18) goto <D.27780>; else goto <D.27785>;
          <D.27785>:
          D.27783 = sig->params[0];
          D.27786 = mono_class_from_mono_type (D.27783);
          D.27787 = D.27786->name;
          D.27788 = strcmp (D.27787, "Type");
          if (D.27788 != 0) goto <D.27780>; else goto <D.27781>;
          <D.27780>:
          iftmp.59 = 1;
          goto <D.27782>;
          <D.27781>:
          iftmp.59 = 0;
          <D.27782>:
          D.27789 = iftmp.59 != 0;
          D.27790 = (long int) D.27789;
          D.27791 = __builtin_expect (D.27790, 0);
          if (D.27791 != 0) goto <D.27792>; else goto <D.27793>;
          <D.27792>:
          monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "aot-compiler.c", 3636, "sig->params [0]->type == MONO_TYPE_CLASS && !strcmp (mono_class_from_mono_type (sig->params [0])->name, \"Type\")");
          <D.27793>:
          p.60 = p;
          p.61 = p.60 + 2;
          p = p.61;
          p.60 = p;
          D.27796 = mono_metadata_decode_value (p.60, &p);
          slen = (int) D.27796;
          p.60 = p;
          D.27797 = slen + 1;
          D.27798 = (unsigned int) D.27797;
          n = monoeg_g_memdup (p.60, D.27798);
          D.27799 = (sizetype) slen;
          D.27800 = n + D.27799;
          *D.27800 = 0;
          D.27546 = acfg->image;
          t = mono_reflection_type_from_name (n, D.27546);
          D.27801 = t == 0B;
          D.27802 = (long int) D.27801;
          D.27803 = __builtin_expect (D.27802, 0);
          if (D.27803 != 0) goto <D.27804>; else goto <D.27805>;
          <D.27804>:
          monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "aot-compiler.c", 3651, "t");
          <D.27805>:
          monoeg_g_free (n);
          klass = mono_class_from_mono_type (t);
          D.27806 = klass->parent;
          D.27647 = mono_defaults.multicastdelegate_class;
          D.27807 = D.27806 != D.27647;
          D.27808 = (long int) D.27807;
          D.27809 = __builtin_expect (D.27808, 0);
          if (D.27809 != 0) goto <D.27810>; else goto <D.27811>;
          <D.27810>:
          monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "aot-compiler.c", 3655, "klass->parent == mono_defaults.multicastdelegate_class");
          <D.27811>:
          p.60 = p;
          D.27799 = (sizetype) slen;
          p.62 = p.60 + D.27799;
          p = p.62;
          p.60 = p;
          D.27813 = MEM[(const guint16 *)p.60];
          D.27814 = D.27813 >> 8;
          D.27815 = (int) D.27814;
          p.60 = p;
          D.27813 = MEM[(const guint16 *)p.60];
          D.27816 = (int) D.27813;
          D.27817 = D.27816 << 8;
          D.27818 = D.27817 & 65535;
          num_named = D.27815 | D.27818;
          p.60 = p;
          p.61 = p.60 + 2;
          p = p.61;
          D.27819 = num_named > 1;
          D.27820 = (long int) D.27819;
          D.27821 = __builtin_expect (D.27820, 0);
          if (D.27821 != 0) goto <D.27822>; else goto <D.27823>;
          <D.27822>:
          monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "aot-compiler.c", 3662, "num_named < 2");
          <D.27823>:
          if (num_named == 1) goto <D.27824>; else goto <D.27825>;
          <D.27824>:
          {
            int name_len;
            char * name;
            struct MonoType * prop_type;

            p.60 = p;
            named = p.60;
            named.63 = named;
            D.27827 = *named.63;
            named_type = (int) D.27827;
            named.63 = named;
            named.64 = named.63 + 1;
            named = named.64;
            named.63 = named;
            D.27827 = *named.63;
            data_type = (int) D.27827;
            named.63 = named;
            named.64 = named.63 + 1;
            named = named.64;
            named.63 = named;
            D.27829 = mono_metadata_decode_blob_size (named.63, &named);
            name_len = (int) D.27829;
            D.27830 = name_len + 1;
            D.27831 = (long unsigned int) D.27830;
            name = monoeg_malloc (D.27831);
            named.63 = named;
            D.27832 = (long unsigned int) name_len;
            memcpy (name, named.63, D.27832);
            D.27833 = (sizetype) name_len;
            D.27834 = name + D.27833;
            *D.27834 = 0;
            named.63 = named;
            D.27833 = (sizetype) name_len;
            named.65 = named.63 + D.27833;
            named = named.65;
            D.27836 = named_type != 84;
            D.27837 = (long int) D.27836;
            D.27838 = __builtin_expect (D.27837, 0);
            if (D.27838 != 0) goto <D.27839>; else goto <D.27840>;
            <D.27839>:
            monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "aot-compiler.c", 3681, "named_type == 0x54");
            <D.27840>:
            D.27841 = strcmp (name, "ExportSymbol");
            D.27842 = D.27841 != 0;
            D.27843 = (long int) D.27842;
            D.27844 = __builtin_expect (D.27843, 0);
            if (D.27844 != 0) goto <D.27845>; else goto <D.27846>;
            <D.27845>:
            monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "aot-compiler.c", 3682, "!strcmp (name, \"ExportSymbol\")");
            <D.27846>:
            D.27592 = mono_defaults.string_class;
            prop_type = &D.27592->byval_arg;
            named.63 = named;
            D.27827 = *named.63;
            D.27847 = D.27827 == 255;
            D.27848 = (long int) D.27847;
            D.27849 = __builtin_expect (D.27848, 0);
            if (D.27849 != 0) goto <D.27850>; else goto <D.27851>;
            <D.27850>:
            monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "aot-compiler.c", 3687, "*named != (char)0xff");
            <D.27851>:
            named.63 = named;
            D.27852 = mono_metadata_decode_value (named.63, &named);
            slen = (int) D.27852;
            D.27797 = slen + 1;
            D.27853 = (long unsigned int) D.27797;
            export_name = monoeg_malloc (D.27853);
            named.63 = named;
            D.27854 = (long unsigned int) slen;
            memcpy (export_name, named.63, D.27854);
            D.27799 = (sizetype) slen;
            D.27855 = export_name + D.27799;
            *D.27855 = 0;
            named.63 = named;
            D.27799 = (sizetype) slen;
            named.66 = named.63 + D.27799;
            named = named.66;
          }
          <D.27825>:
          wrapper = mono_marshal_get_managed_wrapper (method, klass, 0);
          add_method (acfg, wrapper);
          if (export_name != 0B) goto <D.27857>; else goto <D.27858>;
          <D.27857>:
          D.27859 = acfg->export_names;
          monoeg_g_hash_table_insert_replace (D.27859, wrapper, export_name, 0);
          <D.27858>:
        }
      finally
        {
          p = {CLOBBER};
          named = {CLOBBER};
        }
    }
    <D.27764>:
    <D.27754>:
    D.27767 = method->flags;
    D.27768 = (int) D.27767;
    D.27862 = D.27768 & 8192;
    if (D.27862 != 0) goto <D.27860>; else goto <D.27863>;
    <D.27863>:
    D.27864 = method->iflags;
    D.27865 = (int) D.27864;
    D.27866 = D.27865 & 4096;
    if (D.27866 != 0) goto <D.27860>; else goto <D.27861>;
    <D.27860>:
    D.27867 = mono_marshal_get_native_wrapper (method, 1, 1);
    add_method (acfg, D.27867);
    <D.27861>:
  }
  i = i + 1;
  <D.24508>:
  D.27546 = acfg->image;
  D.27580 = D.27546->tables[6].rows;
  D.27581 = (int) D.27580;
  if (D.27581 > i) goto <D.24507>; else goto <D.24509>;
  <D.24509>:
  i = 0;
  goto <D.24513>;
  <D.24512>:
  {
    struct MonoClass * klass;

    D.27544 = i + 1;
    D.27637 = D.27544 | 33554432;
    token = (guint32) D.27637;
    D.27546 = acfg->image;
    klass = mono_class_get (D.27546, token);
    if (klass == 0B) goto <D.27868>; else goto <D.27869>;
    <D.27868>:
    mono_loader_clear_error ();
    // predicted unlikely by continue predictor.
    goto <D.24511>;
    <D.27869>:
    D.27872 = BIT_FIELD_REF <*klass, 64, 256>;
    D.27873 = D.27872 & 1152921504606846976;
    if (D.27873 != 0) goto <D.27874>; else goto <D.27875>;
    <D.27874>:
    D.27876 = klass->generic_container;
    if (D.27876 == 0B) goto <D.27877>; else goto <D.27878>;
    <D.27877>:
    D.27879 = can_marshal_struct (klass);
    if (D.27879 != 0) goto <D.27880>; else goto <D.27881>;
    <D.27880>:
    D.27882 = klass->nested_in;
    if (D.27882 == 0B) goto <D.27870>; else goto <D.27883>;
    <D.27883>:
    D.27882 = klass->nested_in;
    D.27884 = D.27882->name;
    D.27885 = strstr (D.27884, "<PrivateImplementationDetails>");
    D.27882 = klass->nested_in;
    D.27884 = D.27882->name;
    if (D.27885 != D.27884) goto <D.27870>; else goto <D.27871>;
    <D.27870>:
    D.27886 = mono_marshal_get_struct_to_ptr (klass);
    add_method (acfg, D.27886);
    D.27887 = mono_marshal_get_ptr_to_struct (klass);
    add_method (acfg, D.27887);
    <D.27871>:
    <D.27881>:
    <D.27878>:
    <D.27875>:
  }
  <D.24511>:
  i = i + 1;
  <D.24513>:
  D.27546 = acfg->image;
  D.27690 = D.27546->tables[2].rows;
  D.27691 = (int) D.27690;
  if (D.27691 > i) goto <D.24512>; else goto <D.24514>;
  <D.24514>:
}


add_jit_icall_wrapper (void * key, void * value, void * user_data)
{
  struct MonoMethodSignature * D.27888;
  const char * D.27891;
  const void * D.27892;
  int check_for_pending_exc.67;
  struct MonoAotCompile * acfg;
  struct MonoJitICallInfo * callinfo;
  struct MonoMethod * wrapper;
  char * name;

  acfg = user_data;
  callinfo = value;
  D.27888 = callinfo->sig;
  if (D.27888 == 0B) goto <D.27889>; else goto <D.27890>;
  <D.27889>:
  return;
  <D.27890>:
  D.27891 = callinfo->name;
  name = monoeg_g_strdup_printf ("__icall_wrapper_%s", D.27891);
  D.27888 = callinfo->sig;
  D.27892 = callinfo->func;
  check_for_pending_exc.67 = check_for_pending_exc;
  wrapper = mono_marshal_get_icall_wrapper (D.27888, name, D.27892, check_for_pending_exc.67);
  monoeg_g_free (name);
  add_method (acfg, wrapper);
}


get_runtime_invoke_sig (struct MonoMethodSignature * sig)
{
  struct MonoClass * D.27895;
  struct MonoMethod * D.27896;
  struct MonoMethodBuilder * mb;
  struct MonoMethod * m;

  D.27895 = mono_defaults.object_class;
  mb = mono_mb_new (D.27895, "FOO", 0);
  m = mono_mb_create_method (mb, sig, 16);
  D.27896 = mono_marshal_get_runtime_invoke (m, 0);
  return D.27896;
}


create_gsharedvt_inst (struct MonoAotCompile * acfg, struct MonoMethod * method, struct MonoGenericContext * ctx)
{
  struct MonoClass * D.27898;
  struct MonoGenericContainer * D.27899;
  <unnamed-unsigned:22> D.27902;
  long unsigned int D.27903;
  long unsigned int D.27904;
  long unsigned int D.27905;
  long unsigned int D.27906;
  struct MonoType * * D.27907;
  struct MonoClass * D.27908;
  struct MonoType * D.27909;
  int D.27910;
  struct MonoGenericInst * D.27911;
  long unsigned int D.27912;
  long unsigned int D.27913;
  struct MonoGenericParamFull * D.27916;
  long unsigned int D.27917;
  struct MonoGenericParamFull * D.27918;
  struct MonoClass * * D.27921;
  struct MonoClass * D.27926;
  struct MonoImage * D.27929;
  struct MonoImage * D.27930;
  const char * D.27932;
  int D.27933;
  struct MonoClass * D.27934;
  struct MonoType * D.27937;
  <unnamed-signed:31> D.27939;
  int D.27940;
  struct MonoGenericInst * D.27941;
  struct MonoGenericContext shared_context;
  struct MonoType * * args;
  struct MonoGenericInst * inst;
  struct MonoGenericContainer * container;
  struct MonoClass * * constraints;
  int i;

  try
    {
      memset (ctx, 0, 16);
      D.27898 = method->klass;
      D.27899 = D.27898->generic_container;
      if (D.27899 != 0B) goto <D.27900>; else goto <D.27901>;
      <D.27900>:
      D.27898 = method->klass;
      D.27899 = D.27898->generic_container;
      shared_context = D.27899->context;
      inst = shared_context.class_inst;
      D.27902 = inst->type_argc;
      D.27903 = (long unsigned int) D.27902;
      D.27904 = D.27903 * 8;
      args = monoeg_malloc0 (D.27904);
      i = 0;
      goto <D.24410>;
      <D.24409>:
      D.27905 = (long unsigned int) i;
      D.27906 = D.27905 * 8;
      D.27907 = args + D.27906;
      D.27908 = mono_defaults.int_class;
      D.27909 = &D.27908->byval_arg;
      *D.27907 = D.27909;
      i = i + 1;
      <D.24410>:
      D.27902 = inst->type_argc;
      D.27910 = (int) D.27902;
      if (D.27910 > i) goto <D.24409>; else goto <D.24411>;
      <D.24411>:
      D.27902 = inst->type_argc;
      D.27910 = (int) D.27902;
      D.27911 = mono_metadata_get_generic_inst (D.27910, args);
      ctx->class_inst = D.27911;
      <D.27901>:
      D.27912 = BIT_FIELD_REF <*method, 64, 256>;
      D.27913 = D.27912 & 4503599627370496;
      if (D.27913 != 0) goto <D.27914>; else goto <D.27915>;
      <D.27914>:
      container = mono_method_get_generic_container (method);
      shared_context = container->context;
      inst = shared_context.method_inst;
      D.27902 = inst->type_argc;
      D.27903 = (long unsigned int) D.27902;
      D.27904 = D.27903 * 8;
      args = monoeg_malloc0 (D.27904);
      i = 0;
      goto <D.24419>;
      <D.24418>:
      {
        struct MonoGenericParamInfo * info;
        gboolean ref_only;

        D.27916 = container->type_params;
        D.27905 = (long unsigned int) i;
        D.27917 = D.27905 * 56;
        D.27918 = D.27916 + D.27917;
        info = &D.27918->info;
        ref_only = 0;
        if (info != 0B) goto <D.27919>; else goto <D.27920>;
        <D.27919>:
        D.27921 = info->constraints;
        if (D.27921 != 0B) goto <D.27922>; else goto <D.27923>;
        <D.27922>:
        constraints = info->constraints;
        goto <D.24416>;
        <D.24415>:
        {
          struct MonoClass * cklass;

          cklass = *constraints;
          D.27926 = mono_defaults.object_class;
          if (D.27926 != cklass) goto <D.27927>; else goto <D.27928>;
          <D.27927>:
          D.27929 = cklass->image;
          D.27930 = mono_defaults.corlib;
          if (D.27929 != D.27930) goto <D.27924>; else goto <D.27931>;
          <D.27931>:
          D.27932 = cklass->name;
          D.27933 = strcmp (D.27932, "ValueType");
          if (D.27933 != 0) goto <D.27924>; else goto <D.27925>;
          <D.27924>:
          ref_only = 1;
          <D.27925>:
          <D.27928>:
          constraints = constraints + 8;
        }
        <D.24416>:
        D.27934 = *constraints;
        if (D.27934 != 0B) goto <D.24415>; else goto <D.24417>;
        <D.24417>:
        <D.27923>:
        <D.27920>:
        if (ref_only != 0) goto <D.27935>; else goto <D.27936>;
        <D.27935>:
        D.27905 = (long unsigned int) i;
        D.27906 = D.27905 * 8;
        D.27907 = args + D.27906;
        D.27926 = mono_defaults.object_class;
        D.27937 = &D.27926->byval_arg;
        *D.27907 = D.27937;
        goto <D.27938>;
        <D.27936>:
        D.27905 = (long unsigned int) i;
        D.27906 = D.27905 * 8;
        D.27907 = args + D.27906;
        D.27908 = mono_defaults.int_class;
        D.27909 = &D.27908->byval_arg;
        *D.27907 = D.27909;
        <D.27938>:
      }
      i = i + 1;
      <D.24419>:
      D.27939 = container->type_argc;
      D.27940 = (int) D.27939;
      if (D.27940 > i) goto <D.24418>; else goto <D.24420>;
      <D.24420>:
      D.27902 = inst->type_argc;
      D.27910 = (int) D.27902;
      D.27941 = mono_metadata_get_generic_inst (D.27910, args);
      ctx->method_inst = D.27941;
      <D.27915>:
    }
  finally
    {
      shared_context = {CLOBBER};
    }
}


can_marshal_struct (struct MonoClass * klass)
{
  unsigned int D.27942;
  unsigned int D.27943;
  gboolean D.27946;
  struct MonoType * D.27947;
  short unsigned int D.27948;
  int D.27949;
  int D.27950;
  unsigned char D.27953;
  int D.27954;
  struct MonoClass * D.27955;
  long unsigned int D.27956;
  long unsigned int D.27957;
  struct MonoClass * D.27960;
  int D.27961;
  struct MonoClassField * D.27966;
  struct MonoMarshalSpec * D.27969;
  unsigned int D.27972;
  unsigned int i.68;
  const char * D.27976;
  int D.27977;
  const char * D.27980;
  int D.27981;
  struct MonoClassField * field;
  gboolean can_marshal;
  void * iter;
  struct MonoMarshalType * info;
  int i;

  try
    {
      can_marshal = 1;
      iter = 0B;
      D.27942 = klass->flags;
      D.27943 = D.27942 & 24;
      if (D.27943 == 0) goto <D.27944>; else goto <D.27945>;
      <D.27944>:
      D.27946 = 0;
      return D.27946;
      <D.27945>:
      info = mono_marshal_load_type_info (klass);
      goto <D.24371>;
      <D.24396>:
      D.27947 = field->type;
      D.27948 = D.27947->attrs;
      D.27949 = (int) D.27948;
      D.27950 = D.27949 & 16;
      if (D.27950 != 0) goto <D.27951>; else goto <D.27952>;
      <D.27951>:
      // predicted unlikely by continue predictor.
      goto <D.24371>;
      <D.27952>:
      D.27947 = field->type;
      D.27953 = D.27947->type;
      D.27954 = (int) D.27953;
      switch (D.27954) <default: <D.24395>, case 2: <D.24376>, case 3: <D.24379>, case 4: <D.24374>, case 5: <D.24375>, case 6: <D.24377>, case 7: <D.24378>, case 8: <D.24372>, case 9: <D.24373>, case 10: <D.24380>, case 11: <D.24381>, case 12: <D.24385>, case 13: <D.24386>, case 14: <D.24387>, case 15: <D.24384>, case 17: <D.24389>, case 24: <D.24382>, case 25: <D.24383>, case 29: <D.24390>>
      <D.24372>:
      <D.24373>:
      <D.24374>:
      <D.24375>:
      <D.24376>:
      <D.24377>:
      <D.24378>:
      <D.24379>:
      <D.24380>:
      <D.24381>:
      <D.24382>:
      <D.24383>:
      <D.24384>:
      <D.24385>:
      <D.24386>:
      <D.24387>:
      goto <D.24388>;
      <D.24389>:
      D.27947 = field->type;
      D.27955 = mono_class_from_mono_type (D.27947);
      D.27956 = BIT_FIELD_REF <*D.27955, 64, 256>;
      D.27957 = D.27956 & 576460752303423488;
      if (D.27957 == 0) goto <D.27958>; else goto <D.27959>;
      <D.27958>:
      D.27947 = field->type;
      D.27960 = mono_class_from_mono_type (D.27947);
      D.27961 = can_marshal_struct (D.27960);
      if (D.27961 == 0) goto <D.27962>; else goto <D.27963>;
      <D.27962>:
      can_marshal = 0;
      <D.27963>:
      <D.27959>:
      goto <D.24388>;
      <D.24390>:
      {
        gboolean has_mspec;

        has_mspec = 0;
        if (info != 0B) goto <D.27964>; else goto <D.27965>;
        <D.27964>:
        i = 0;
        goto <D.24393>;
        <D.24392>:
        D.27966 = info->fields[i].field;
        if (D.27966 == field) goto <D.27967>; else goto <D.27968>;
        <D.27967>:
        D.27969 = info->fields[i].mspec;
        if (D.27969 != 0B) goto <D.27970>; else goto <D.27971>;
        <D.27970>:
        has_mspec = 1;
        <D.27971>:
        <D.27968>:
        i = i + 1;
        <D.24393>:
        D.27972 = info->num_fields;
        i.68 = (unsigned int) i;
        if (D.27972 > i.68) goto <D.24392>; else goto <D.24394>;
        <D.24394>:
        <D.27965>:
        if (has_mspec == 0) goto <D.27974>; else goto <D.27975>;
        <D.27974>:
        can_marshal = 0;
        <D.27975>:
        goto <D.24388>;
      }
      <D.24395>:
      can_marshal = 0;
      goto <D.24388>;
      <D.24388>:
      <D.24371>:
      field = mono_class_get_fields (klass, &iter);
      if (field != 0B) goto <D.24396>; else goto <D.24397>;
      <D.24397>:
      D.27976 = klass->name_space;
      D.27977 = strcmp (D.27976, "System.Net.NetworkInformation.MacOsStructs");
      if (D.27977 == 0) goto <D.27978>; else goto <D.27979>;
      <D.27978>:
      D.27980 = klass->name;
      D.27981 = strcmp (D.27980, "sockaddr_dl");
      if (D.27981 != 0) goto <D.27982>; else goto <D.27983>;
      <D.27982>:
      D.27946 = 1;
      return D.27946;
      <D.27983>:
      <D.27979>:
      D.27946 = can_marshal;
      return D.27946;
    }
  finally
    {
      iter = {CLOBBER};
    }
}


compile_methods (struct MonoAotCompile * acfg)
{
  int D.27987;
  struct GPtrArray * D.27990;
  unsigned int D.27991;
  unsigned int D.27992;
  unsigned int D.27993;
  _Bool D.27994;
  long int D.27995;
  long int D.27996;
  long unsigned int D.27999;
  long unsigned int D.28000;
  long unsigned int D.28001;
  long unsigned int D.28002;
  struct MonoMethod * * D.28003;
  void * * D.28004;
  void * * D.28005;
  void * D.28006;
  struct MonoMethod * D.28009;
  struct MonoDomain * D.28010;
  void * * D.28011;
  void * * D.28012;
  void * * D.28013;
  void * * D.28014;
  void * D.28015;
  unsigned int D.28016;
  unsigned int i.69;
  int i;
  int methods_len;

  D.27987 = acfg->aot_opts.nthreads;
  if (D.27987 > 0) goto <D.27988>; else goto <D.27989>;
  <D.27988>:
  {
    struct GPtrArray * frag;
    int len;
    int j;
    struct GPtrArray * threads;
    void * handle;
    void * * user_data;
    struct MonoMethod * * methods;

    D.27990 = acfg->methods;
    D.27991 = D.27990->len;
    methods_len = (int) D.27991;
    D.27990 = acfg->methods;
    D.27991 = D.27990->len;
    D.27987 = acfg->aot_opts.nthreads;
    D.27992 = (unsigned int) D.27987;
    D.27993 = D.27991 / D.27992;
    len = (int) D.27993;
    D.27994 = len <= 0;
    D.27995 = (long int) D.27994;
    D.27996 = __builtin_expect (D.27995, 0);
    if (D.27996 != 0) goto <D.27997>; else goto <D.27998>;
    <D.27997>:
    monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "aot-compiler.c", 8377, "len > 0");
    <D.27998>:
    threads = monoeg_g_ptr_array_new ();
    D.27999 = (long unsigned int) methods_len;
    D.28000 = D.27999 * 8;
    methods = monoeg_malloc0 (D.28000);
    i = 0;
    goto <D.25750>;
    <D.25749>:
    D.28001 = (long unsigned int) i;
    D.28002 = D.28001 * 8;
    D.28003 = methods + D.28002;
    D.27990 = acfg->methods;
    D.28004 = D.27990->pdata;
    D.28001 = (long unsigned int) i;
    D.28002 = D.28001 * 8;
    D.28005 = D.28004 + D.28002;
    D.28006 = *D.28005;
    *D.28003 = D.28006;
    i = i + 1;
    <D.25750>:
    if (i < methods_len) goto <D.25749>; else goto <D.25751>;
    <D.25751>:
    i = 0;
    goto <D.25756>;
    <D.25755>:
    frag = monoeg_g_ptr_array_new ();
    j = 0;
    goto <D.25753>;
    <D.25752>:
    if (i < methods_len) goto <D.28007>; else goto <D.28008>;
    <D.28007>:
    D.28001 = (long unsigned int) i;
    D.28002 = D.28001 * 8;
    D.28003 = methods + D.28002;
    D.28009 = *D.28003;
    monoeg_g_ptr_array_add (frag, D.28009);
    i = i + 1;
    <D.28008>:
    j = j + 1;
    <D.25753>:
    if (j < len) goto <D.25752>; else goto <D.25754>;
    <D.25754>:
    user_data = monoeg_malloc0 (24);
    D.28010 = mono_domain_get ();
    *user_data = D.28010;
    D.28011 = user_data + 8;
    *D.28011 = acfg;
    D.28012 = user_data + 16;
    *D.28012 = frag;
    handle = mono_threads_create_thread (compile_thread_main, user_data, 0, 0, 0B);
    monoeg_g_ptr_array_add (threads, handle);
    <D.25756>:
    if (i < methods_len) goto <D.25755>; else goto <D.25757>;
    <D.25757>:
    monoeg_g_free (methods);
    i = 0;
    goto <D.25759>;
    <D.25758>:
    D.28013 = threads->pdata;
    D.28001 = (long unsigned int) i;
    D.28002 = D.28001 * 8;
    D.28014 = D.28013 + D.28002;
    D.28015 = *D.28014;
    WaitForSingleObjectEx (D.28015, 4294967295, 0);
    i = i + 1;
    <D.25759>:
    D.28016 = threads->len;
    i.69 = (unsigned int) i;
    if (D.28016 > i.69) goto <D.25758>; else goto <D.25760>;
    <D.25760>:
  }
  goto <D.28018>;
  <D.27989>:
  methods_len = 0;
  <D.28018>:
  i = methods_len;
  goto <D.25762>;
  <D.25761>:
  D.27990 = acfg->methods;
  D.28004 = D.27990->pdata;
  D.28001 = (long unsigned int) i;
  D.28002 = D.28001 * 8;
  D.28005 = D.28004 + D.28002;
  D.28006 = *D.28005;
  compile_method (acfg, D.28006);
  i = i + 1;
  <D.25762>:
  D.27990 = acfg->methods;
  D.27991 = D.27990->len;
  i.69 = (unsigned int) i;
  if (D.27991 > i.69) goto <D.25761>; else goto <D.25763>;
  <D.25763>:
}


compile_thread_main (void * * user_data)
{
  void * * D.28019;
  long unsigned int D.28020;
  long unsigned int D.28021;
  void * * D.28022;
  void * D.28023;
  unsigned int D.28024;
  unsigned int i.70;
  struct MonoDomain * domain;
  struct MonoAotCompile * acfg;
  struct GPtrArray * methods;
  int i;

  domain = *user_data;
  acfg = MEM[(void * *)user_data + 8B];
  methods = MEM[(void * *)user_data + 16B];
  mono_thread_attach (domain);
  i = 0;
  goto <D.25337>;
  <D.25336>:
  D.28019 = methods->pdata;
  D.28020 = (long unsigned int) i;
  D.28021 = D.28020 * 8;
  D.28022 = D.28019 + D.28021;
  D.28023 = *D.28022;
  compile_method (acfg, D.28023);
  i = i + 1;
  <D.25337>:
  D.28024 = methods->len;
  i.70 = (unsigned int) i;
  if (D.28024 > i.70) goto <D.25336>; else goto <D.25338>;
  <D.25338>:
}


compile_method (struct MonoAotCompile * acfg, struct MonoMethod * method)
{
  int D.28026;
  union mono_mutex_t * D.28029;
  _Bool D.28032;
  long int D.28033;
  long int D.28034;
  unsigned int D.28037;
  _Bool D.28040;
  long int D.28041;
  long int D.28042;
  short unsigned int D.28047;
  int D.28048;
  int D.28049;
  short unsigned int D.28051;
  int D.28052;
  int D.28053;
  int D.28055;
  int D.28056;
  short unsigned int D.28061;
  int D.28062;
  int D.28063;
  long unsigned int D.28066;
  long unsigned int D.28067;
  long unsigned int D.28070;
  long unsigned int D.28071;
  int * D.28074;
  unsigned int D.28075;
  struct MonoDomain * D.28076;
  JitFlags iftmp.71;
  int D.28078;
  unsigned int D.28082;
  int D.28085;
  char * D.28088;
  char * D.28089;
  int * D.28090;
  char * D.28095;
  long unsigned int D.28096;
  long unsigned int D.28097;
  char * D.28102;
  int * D.28103;
  unsigned int index.72;
  <unnamed type> D.28105;
  _Bool D.28108;
  long int D.28109;
  long int D.28110;
  struct GHashTable * D.28113;
  _Bool D.28116;
  long int D.28117;
  long int D.28118;
  char * D.28125;
  int * D.28126;
  _Bool D.28129;
  long int D.28130;
  long int D.28131;
  int D.28134;
  char * D.28141;
  int D.28142;
  int D.28143;
  _Bool D.28146;
  long int D.28147;
  long int D.28148;
  struct GHashTable * D.28151;
  void * D.28152;
  long int D.28153;
  int D.28154;
  long unsigned int D.28159;
  long unsigned int D.28160;
  struct MonoClass * D.28165;
  int D.28166;
  int D.28168;
  int D.28169;
  short unsigned int D.28172;
  int D.28173;
  int D.28174;
  struct MonoMethod * D.28179;
  int D.28180;
  int D.28182;
  long unsigned int D.28183;
  const char * D.28186;
  int D.28187;
  struct MonoGenericClass * D.28190;
  int D.28193;
  struct MonoClassField * D.28196;
  struct MonoGenericClass * D.28197;
  struct MonoGenericContext * D.28200;
  int D.28201;
  struct MonoMethod * D.28204;
  struct MonoMethod * D.28207;
  struct MonoImage * D.28208;
  struct MonoImage * D.28209;
  int D.28212;
  long unsigned int D.28215;
  long unsigned int D.28216;
  int * D.28219;
  struct MonoMemPool * D.28220;
  void * D.28224;
  struct GSList * D.28225;
  short unsigned int D.28226;
  int D.28227;
  <unnamed-unsigned:1> D.28228;
  int D.28229;
  int D.28230;
  long unsigned int D.28231;
  unsigned int D.28232;
  unsigned int D.28233;
  long unsigned int D.28234;
  long unsigned int D.28235;
  struct MonoInst * * D.28236;
  void * D.28237;
  struct MonoInst * D.28238;
  struct MonoInst * * D.28239;
  struct MonoInst * * D.28240;
  struct MonoInst * D.28241;
  short unsigned int D.28242;
  unsigned int D.28243;
  unsigned int D.28244;
  struct MonoInst * * D.28245;
  void * D.28246;
  struct MonoInst * D.28247;
  struct MonoInst * * D.28248;
  struct MonoInst * * D.28249;
  struct MonoInst * D.28250;
  int D.28251;
  struct MonoMemPool * D.28252;
  struct MonoInst * * D.28253;
  struct MonoMethodVar * D.28254;
  struct MonoRegState * D.28255;
  int D.28258;
  long unsigned int D.28259;
  long unsigned int D.28260;
  struct MonoCompile * * D.28261;
  long unsigned int D.28262;
  long unsigned int D.28263;
  long unsigned int D.28264;
  long unsigned int D.28265;
  struct MonoCompile * * D.28266;
  struct GHashTable * D.28267;
  struct MonoMethod * D.28268;
  _Bool D.28271;
  long int D.28272;
  long int D.28273;
  int * D.28276;
  struct MonoCompile * cfg;
  struct MonoJumpInfo * patch_info;
  gboolean skip;
  int index;
  int depth;
  struct MonoMethod * wrapped;

  D.28026 = acfg->aot_opts.metadata_only;
  if (D.28026 != 0) goto <D.28027>; else goto <D.28028>;
  <D.28027>:
  return;
  <D.28028>:
  {
    int ret;

    D.28029 = &acfg->mutex.mutex;
    ret = pthread_mutex_lock (D.28029);
    if (ret != 0) goto <D.28030>; else goto <D.28031>;
    <D.28030>:
    monoeg_g_log (0B, 16, "Bad call to mono_mutex_lock result %d", ret);
    <D.28031>:
    D.28032 = ret != 0;
    D.28033 = (long int) D.28032;
    D.28034 = __builtin_expect (D.28033, 0);
    if (D.28034 != 0) goto <D.28035>; else goto <D.28036>;
    <D.28035>:
    monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "aot-compiler.c", 6458, "ret == 0");
    <D.28036>:
  }
  D.28037 = get_method_index (acfg, method);
  index = (int) D.28037;
  {
    int ret;

    D.28029 = &acfg->mutex.mutex;
    ret = pthread_mutex_unlock (D.28029);
    if (ret != 0) goto <D.28038>; else goto <D.28039>;
    <D.28038>:
    monoeg_g_log (0B, 16, "Bad call to mono_mutex_unlock result %d", ret);
    <D.28039>:
    D.28040 = ret != 0;
    D.28041 = (long int) D.28040;
    D.28042 = __builtin_expect (D.28041, 0);
    if (D.28042 != 0) goto <D.28043>; else goto <D.28044>;
    <D.28043>:
    monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "aot-compiler.c", 6460, "ret == 0");
    <D.28044>:
  }
  D.28047 = method->flags;
  D.28048 = (int) D.28047;
  D.28049 = D.28048 & 8192;
  if (D.28049 != 0) goto <D.28045>; else goto <D.28050>;
  <D.28050>:
  D.28051 = method->iflags;
  D.28052 = (int) D.28051;
  D.28053 = D.28052 & 3;
  if (D.28053 != 0) goto <D.28045>; else goto <D.28054>;
  <D.28054>:
  D.28047 = method->flags;
  D.28048 = (int) D.28047;
  D.28055 = D.28048 & 1024;
  if (D.28055 != 0) goto <D.28045>; else goto <D.28046>;
  <D.28045>:
  return;
  <D.28046>:
  D.28051 = method->iflags;
  D.28052 = (int) D.28051;
  D.28056 = D.28052 & 4096;
  if (D.28056 != 0) goto <D.28057>; else goto <D.28058>;
  <D.28057>:
  return;
  <D.28058>:
  wrapped = mono_marshal_method_from_wrapper (method);
  if (wrapped != 0B) goto <D.28059>; else goto <D.28060>;
  <D.28059>:
  D.28061 = wrapped->iflags;
  D.28062 = (int) D.28061;
  D.28063 = D.28062 & 4096;
  if (D.28063 != 0) goto <D.28064>; else goto <D.28065>;
  <D.28064>:
  D.28066 = BIT_FIELD_REF <*wrapped, 64, 256>;
  D.28067 = D.28066 & 4503599627370496;
  if (D.28067 != 0) goto <D.28068>; else goto <D.28069>;
  <D.28068>:
  return;
  <D.28069>:
  <D.28065>:
  <D.28060>:
  D.28070 = BIT_FIELD_REF <*method, 64, 256>;
  D.28071 = D.28070 & 4467570830351532032;
  if (D.28071 == 3891110078048108544) goto <D.28072>; else goto <D.28073>;
  <D.28072>:
  return;
  <D.28073>:
  D.28074 = &acfg->stats.mcount;
  InterlockedIncrement (D.28074);
  D.28075 = acfg->opts;
  D.28076 = mono_get_root_domain ();
  D.28078 = acfg->aot_opts.full_aot;
  if (D.28078 != 0) goto <D.28079>; else goto <D.28080>;
  <D.28079>:
  iftmp.71 = 6;
  goto <D.28081>;
  <D.28080>:
  iftmp.71 = 2;
  <D.28081>:
  cfg = mini_method_compile (method, D.28075, D.28076, iftmp.71, 0);
  mono_loader_clear_error ();
  D.28082 = cfg->exception_type;
  if (D.28082 == 11) goto <D.28083>; else goto <D.28084>;
  <D.28083>:
  D.28085 = acfg->aot_opts.print_skipped_methods;
  if (D.28085 != 0) goto <D.28086>; else goto <D.28087>;
  <D.28086>:
  D.28088 = mono_method_full_name (method, 1);
  D.28089 = cfg->exception_message;
  printf ("Skip (gshared failure): %s (%s)\n", D.28088, D.28089);
  <D.28087>:
  D.28090 = &acfg->stats.genericcount;
  InterlockedIncrement (D.28090);
  return;
  <D.28084>:
  D.28082 = cfg->exception_type;
  if (D.28082 != 0) goto <D.28091>; else goto <D.28092>;
  <D.28091>:
  D.28085 = acfg->aot_opts.print_skipped_methods;
  if (D.28085 != 0) goto <D.28093>; else goto <D.28094>;
  <D.28093>:
  D.28095 = mono_method_full_name (method, 1);
  printf ("Skip (JIT failure): %s\n", D.28095);
  <D.28094>:
  return;
  <D.28092>:
  D.28096 = BIT_FIELD_REF <*cfg, 64, 5568>;
  D.28097 = D.28096 & 2147483648;
  if (D.28097 != 0) goto <D.28098>; else goto <D.28099>;
  <D.28098>:
  D.28085 = acfg->aot_opts.print_skipped_methods;
  if (D.28085 != 0) goto <D.28100>; else goto <D.28101>;
  <D.28100>:
  D.28102 = mono_method_full_name (method, 1);
  printf ("Skip (disabled): %s\n", D.28102);
  <D.28101>:
  D.28103 = &acfg->stats.ocount;
  InterlockedIncrement (D.28103);
  mono_destroy_compile (cfg);
  return;
  <D.28099>:
  index.72 = (unsigned int) index;
  cfg->method_index = index.72;
  patch_info = cfg->patch_info;
  goto <D.25265>;
  <D.25264>:
  D.28105 = patch_info->type;
  switch (D.28105) <default: <D.25263>, case 0: <D.25261>, case 2: <D.25260>>
  <D.25260>:
  <D.25261>:
  patch_info->type = 51;
  goto <D.25262>;
  <D.25263>:
  goto <D.25262>;
  <D.25262>:
  patch_info = patch_info->next;
  <D.25265>:
  if (patch_info != 0B) goto <D.25264>; else goto <D.25266>;
  <D.25266>:
  {
    int ret;

    D.28029 = &acfg->mutex.mutex;
    ret = pthread_mutex_lock (D.28029);
    if (ret != 0) goto <D.28106>; else goto <D.28107>;
    <D.28106>:
    monoeg_g_log (0B, 16, "Bad call to mono_mutex_lock result %d", ret);
    <D.28107>:
    D.28108 = ret != 0;
    D.28109 = (long int) D.28108;
    D.28110 = __builtin_expect (D.28109, 0);
    if (D.28110 != 0) goto <D.28111>; else goto <D.28112>;
    <D.28111>:
    monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "aot-compiler.c", 6536, "ret == 0");
    <D.28112>:
  }
  D.28113 = cfg->token_info_hash;
  monoeg_g_hash_table_foreach (D.28113, add_token_info_hash, acfg);
  {
    int ret;

    D.28029 = &acfg->mutex.mutex;
    ret = pthread_mutex_unlock (D.28029);
    if (ret != 0) goto <D.28114>; else goto <D.28115>;
    <D.28114>:
    monoeg_g_log (0B, 16, "Bad call to mono_mutex_unlock result %d", ret);
    <D.28115>:
    D.28116 = ret != 0;
    D.28117 = (long int) D.28116;
    D.28118 = __builtin_expect (D.28117, 0);
    if (D.28118 != 0) goto <D.28119>; else goto <D.28120>;
    <D.28119>:
    monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "aot-compiler.c", 6538, "ret == 0");
    <D.28120>:
  }
  skip = 0;
  patch_info = cfg->patch_info;
  goto <D.25273>;
  <D.25272>:
  D.28105 = patch_info->type;
  switch (D.28105) <default: <D.25271>, case 1: <D.25269>>
  <D.25269>:
  skip = 1;
  goto <D.25270>;
  <D.25271>:
  goto <D.25270>;
  <D.25270>:
  patch_info = patch_info->next;
  <D.25273>:
  if (patch_info != 0B) goto <D.25272>; else goto <D.25274>;
  <D.25274>:
  if (skip != 0) goto <D.28121>; else goto <D.28122>;
  <D.28121>:
  D.28085 = acfg->aot_opts.print_skipped_methods;
  if (D.28085 != 0) goto <D.28123>; else goto <D.28124>;
  <D.28123>:
  D.28125 = mono_method_full_name (method, 1);
  printf ("Skip (abs call): %s\n", D.28125);
  <D.28124>:
  D.28126 = &acfg->stats.abscount;
  InterlockedIncrement (D.28126);
  mono_destroy_compile (cfg);
  return;
  <D.28122>:
  {
    int ret;

    D.28029 = &acfg->mutex.mutex;
    ret = pthread_mutex_lock (D.28029);
    if (ret != 0) goto <D.28127>; else goto <D.28128>;
    <D.28127>:
    monoeg_g_log (0B, 16, "Bad call to mono_mutex_lock result %d", ret);
    <D.28128>:
    D.28129 = ret != 0;
    D.28130 = (long int) D.28129;
    D.28131 = __builtin_expect (D.28130, 0);
    if (D.28131 != 0) goto <D.28132>; else goto <D.28133>;
    <D.28132>:
    monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "aot-compiler.c", 6564, "ret == 0");
    <D.28133>:
  }
  skip = 0;
  patch_info = cfg->patch_info;
  goto <D.25277>;
  <D.25276>:
  D.28134 = can_encode_patch (acfg, patch_info);
  if (D.28134 == 0) goto <D.28135>; else goto <D.28136>;
  <D.28135>:
  skip = 1;
  <D.28136>:
  patch_info = patch_info->next;
  <D.25277>:
  if (patch_info != 0B) goto <D.25276>; else goto <D.25278>;
  <D.25278>:
  if (skip != 0) goto <D.28137>; else goto <D.28138>;
  <D.28137>:
  D.28085 = acfg->aot_opts.print_skipped_methods;
  if (D.28085 != 0) goto <D.28139>; else goto <D.28140>;
  <D.28139>:
  D.28141 = mono_method_full_name (method, 1);
  printf ("Skip (patches): %s\n", D.28141);
  <D.28140>:
  D.28142 = acfg->stats.ocount;
  D.28143 = D.28142 + 1;
  acfg->stats.ocount = D.28143;
  mono_destroy_compile (cfg);
  {
    int ret;

    D.28029 = &acfg->mutex.mutex;
    ret = pthread_mutex_unlock (D.28029);
    if (ret != 0) goto <D.28144>; else goto <D.28145>;
    <D.28144>:
    monoeg_g_log (0B, 16, "Bad call to mono_mutex_unlock result %d", ret);
    <D.28145>:
    D.28146 = ret != 0;
    D.28147 = (long int) D.28146;
    D.28148 = __builtin_expect (D.28147, 0);
    if (D.28148 != 0) goto <D.28149>; else goto <D.28150>;
    <D.28149>:
    monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "aot-compiler.c", 6580, "ret == 0");
    <D.28150>:
  }
  return;
  <D.28138>:
  D.28151 = acfg->method_depth;
  D.28152 = monoeg_g_hash_table_lookup (D.28151, method);
  D.28153 = (long int) D.28152;
  depth = (int) D.28153;
  D.28154 = acfg->aot_opts.no_instances;
  if (D.28154 == 0) goto <D.28155>; else goto <D.28156>;
  <D.28155>:
  if (depth <= 31) goto <D.28157>; else goto <D.28158>;
  <D.28157>:
  patch_info = cfg->patch_info;
  goto <D.25289>;
  <D.25288>:
  D.28105 = patch_info->type;
  switch (D.28105) <default: <D.25287>, case 3: <D.25280>, case 14: <D.25283>, case 16: <D.25285>>
  <D.25280>:
  {
    struct MonoMethod * m;

    m = patch_info->data.method;
    D.28159 = BIT_FIELD_REF <*m, 64, 256>;
    D.28160 = D.28159 & 2251799813685248;
    if (D.28160 != 0) goto <D.28161>; else goto <D.28162>;
    <D.28161>:
    D.28165 = m->klass;
    D.28166 = mono_class_generic_sharing_enabled (D.28165);
    if (D.28166 == 0) goto <D.28163>; else goto <D.28167>;
    <D.28167>:
    D.28168 = mono_method_is_generic_sharable_full (m, 0, 0, 0);
    if (D.28168 == 0) goto <D.28163>; else goto <D.28164>;
    <D.28163>:
    D.28169 = method_has_type_vars (m);
    if (D.28169 == 0) goto <D.28170>; else goto <D.28171>;
    <D.28170>:
    D.28172 = m->iflags;
    D.28173 = (int) D.28172;
    D.28174 = D.28173 & 4096;
    if (D.28174 != 0) goto <D.28175>; else goto <D.28176>;
    <D.28175>:
    D.28078 = acfg->aot_opts.full_aot;
    if (D.28078 != 0) goto <D.28177>; else goto <D.28178>;
    <D.28177>:
    D.28179 = mono_marshal_get_native_wrapper (m, 1, 1);
    D.28180 = depth + 1;
    add_extra_method_with_depth (acfg, D.28179, D.28180);
    <D.28178>:
    goto <D.28181>;
    <D.28176>:
    D.28180 = depth + 1;
    add_extra_method_with_depth (acfg, m, D.28180);
    add_types_from_method_header (acfg, m);
    <D.28181>:
    <D.28171>:
    <D.28164>:
    D.28165 = m->klass;
    D.28182 = depth + 5;
    add_generic_class_with_depth (acfg, D.28165, D.28182, "method");
    <D.28162>:
    D.28159 = BIT_FIELD_REF <*m, 64, 256>;
    D.28183 = D.28159 & 4467570830351532032;
    if (D.28183 == 1008806316530991104) goto <D.28184>; else goto <D.28185>;
    <D.28184>:
    D.28186 = m->name;
    D.28187 = strcmp (D.28186, "ElementAddr");
    if (D.28187 == 0) goto <D.28188>; else goto <D.28189>;
    <D.28188>:
    D.28180 = depth + 1;
    add_extra_method_with_depth (acfg, m, D.28180);
    <D.28189>:
    <D.28185>:
    goto <D.25282>;
  }
  <D.25283>:
  {
    struct MonoClass * klass;

    klass = patch_info->data.klass;
    D.28190 = klass->generic_class;
    if (D.28190 != 0B) goto <D.28191>; else goto <D.28192>;
    <D.28191>:
    D.28193 = mini_class_is_generic_sharable (klass);
    if (D.28193 == 0) goto <D.28194>; else goto <D.28195>;
    <D.28194>:
    D.28182 = depth + 5;
    add_generic_class_with_depth (acfg, klass, D.28182, "vtable");
    <D.28195>:
    <D.28192>:
    goto <D.25282>;
  }
  <D.25285>:
  {
    struct MonoClass * klass;

    D.28196 = patch_info->data.field;
    klass = D.28196->parent;
    D.28197 = klass->generic_class;
    if (D.28197 != 0B) goto <D.28198>; else goto <D.28199>;
    <D.28198>:
    D.28197 = klass->generic_class;
    D.28200 = &D.28197->context;
    D.28201 = mono_generic_context_is_sharable (D.28200, 0);
    if (D.28201 == 0) goto <D.28202>; else goto <D.28203>;
    <D.28202>:
    D.28204 = mono_class_get_cctor (klass);
    if (D.28204 != 0B) goto <D.28205>; else goto <D.28206>;
    <D.28205>:
    D.28207 = mono_class_get_cctor (klass);
    D.28180 = depth + 1;
    add_extra_method_with_depth (acfg, D.28207, D.28180);
    <D.28206>:
    <D.28203>:
    <D.28199>:
    goto <D.25282>;
  }
  <D.25287>:
  goto <D.25282>;
  <D.25282>:
  patch_info = patch_info->next;
  <D.25289>:
  if (patch_info != 0B) goto <D.25288>; else goto <D.25290>;
  <D.25290>:
  <D.28158>:
  <D.28156>:
  patch_info = cfg->patch_info;
  goto <D.25298>;
  <D.25297>:
  D.28105 = patch_info->type;
  switch (D.28105) <default: <D.25296>, case 12: <D.25295>, case 27: <D.25291>, case 42: <D.25293>, case 51: <D.25292>>
  <D.25291>:
  <D.25292>:
  <D.25293>:
  goto <D.25294>;
  <D.25295>:
  D.28208 = patch_info->data.image;
  D.28209 = acfg->image;
  if (D.28208 != D.28209) goto <D.28210>; else goto <D.28211>;
  <D.28210>:
  cfg->has_got_slots = 1;
  <D.28211>:
  goto <D.25294>;
  <D.25296>:
  D.28212 = is_plt_patch (patch_info);
  if (D.28212 == 0) goto <D.28213>; else goto <D.28214>;
  <D.28213>:
  cfg->has_got_slots = 1;
  <D.28214>:
  goto <D.25294>;
  <D.25294>:
  patch_info = patch_info->next;
  <D.25298>:
  if (patch_info != 0B) goto <D.25297>; else goto <D.25299>;
  <D.25299>:
  D.28215 = BIT_FIELD_REF <*cfg, 64, 5632>;
  D.28216 = D.28215 & 9223372036854775808;
  if (D.28216 == 0) goto <D.28217>; else goto <D.28218>;
  <D.28217>:
  D.28219 = &acfg->stats.methods_without_got_slots;
  InterlockedIncrement (D.28219);
  <D.28218>:
  {
    struct MonoJumpInfo * patches;
    struct MonoJumpInfo * patches_end;

    patches = 0B;
    patches_end = 0B;
    patch_info = cfg->patch_info;
    goto <D.25304>;
    <D.25303>:
    {
      struct MonoJumpInfo * new_patch_info;

      D.28220 = acfg->mempool;
      new_patch_info = mono_patch_info_dup_mp (D.28220, patch_info);
      if (patches == 0B) goto <D.28221>; else goto <D.28222>;
      <D.28221>:
      patches = new_patch_info;
      goto <D.28223>;
      <D.28222>:
      patches_end->next = new_patch_info;
      <D.28223>:
      patches_end = new_patch_info;
    }
    patch_info = patch_info->next;
    <D.25304>:
    if (patch_info != 0B) goto <D.25303>; else goto <D.25305>;
    <D.25305>:
    cfg->patch_info = patches;
  }
  {
    struct GSList * l;
    struct GSList * unwind_ops;
    struct MonoUnwindOp * op;

    unwind_ops = 0B;
    l = cfg->unwind_ops;
    goto <D.25310>;
    <D.25309>:
    D.28220 = acfg->mempool;
    op = mono_mempool_alloc (D.28220, 12);
    D.28224 = l->data;
    memcpy (op, D.28224, 12);
    D.28220 = acfg->mempool;
    unwind_ops = g_slist_prepend_mempool (D.28220, unwind_ops, op);
    l = l->next;
    <D.25310>:
    if (l != 0B) goto <D.25309>; else goto <D.25311>;
    <D.25311>:
    D.28225 = monoeg_g_slist_reverse (unwind_ops);
    cfg->unwind_ops = D.28225;
  }
  {
    struct MonoInst * * args;
    struct MonoInst * * locals;
    struct MonoMethodSignature * sig;
    struct MonoMethodHeader * header;
    int i;

    sig = mono_method_signature (method);
    D.28220 = acfg->mempool;
    D.28226 = sig->param_count;
    D.28227 = (int) D.28226;
    D.28228 = sig->hasthis;
    D.28229 = (int) D.28228;
    D.28230 = D.28227 + D.28229;
    D.28231 = (long unsigned int) D.28230;
    D.28232 = (unsigned int) D.28231;
    D.28233 = D.28232 * 8;
    args = mono_mempool_alloc (D.28220, D.28233);
    i = 0;
    goto <D.25318>;
    <D.25317>:
    D.28234 = (long unsigned int) i;
    D.28235 = D.28234 * 8;
    D.28236 = args + D.28235;
    D.28220 = acfg->mempool;
    D.28237 = mono_mempool_alloc (D.28220, 80);
    *D.28236 = D.28237;
    D.28234 = (long unsigned int) i;
    D.28235 = D.28234 * 8;
    D.28236 = args + D.28235;
    D.28238 = *D.28236;
    D.28239 = cfg->args;
    D.28234 = (long unsigned int) i;
    D.28235 = D.28234 * 8;
    D.28240 = D.28239 + D.28235;
    D.28241 = *D.28240;
    memcpy (D.28238, D.28241, 80);
    i = i + 1;
    <D.25318>:
    D.28226 = sig->param_count;
    D.28227 = (int) D.28226;
    D.28228 = sig->hasthis;
    D.28229 = (int) D.28228;
    D.28230 = D.28227 + D.28229;
    if (D.28230 > i) goto <D.25317>; else goto <D.25319>;
    <D.25319>:
    cfg->args = args;
    header = mono_method_get_header (method);
    D.28220 = acfg->mempool;
    D.28242 = header->num_locals;
    D.28243 = (unsigned int) D.28242;
    D.28244 = D.28243 * 8;
    locals = mono_mempool_alloc (D.28220, D.28244);
    i = 0;
    goto <D.25321>;
    <D.25320>:
    D.28234 = (long unsigned int) i;
    D.28235 = D.28234 * 8;
    D.28245 = locals + D.28235;
    D.28220 = acfg->mempool;
    D.28246 = mono_mempool_alloc (D.28220, 80);
    *D.28245 = D.28246;
    D.28234 = (long unsigned int) i;
    D.28235 = D.28234 * 8;
    D.28245 = locals + D.28235;
    D.28247 = *D.28245;
    D.28248 = cfg->locals;
    D.28234 = (long unsigned int) i;
    D.28235 = D.28234 * 8;
    D.28249 = D.28248 + D.28235;
    D.28250 = *D.28249;
    memcpy (D.28247, D.28250, 80);
    i = i + 1;
    <D.25321>:
    D.28242 = header->num_locals;
    D.28251 = (int) D.28242;
    if (D.28251 > i) goto <D.25320>; else goto <D.25322>;
    <D.25322>:
    cfg->locals = locals;
  }
  D.28252 = cfg->mempool;
  mono_mempool_destroy (D.28252);
  cfg->mempool = 0B;
  D.28253 = cfg->varinfo;
  monoeg_g_free (D.28253);
  cfg->varinfo = 0B;
  D.28254 = cfg->vars;
  monoeg_g_free (D.28254);
  cfg->vars = 0B;
  D.28255 = cfg->rs;
  if (D.28255 != 0B) goto <D.28256>; else goto <D.28257>;
  <D.28256>:
  D.28255 = cfg->rs;
  mono_regstate_free (D.28255);
  cfg->rs = 0B;
  <D.28257>:
  goto <D.25326>;
  <D.25325>:
  {
    struct MonoCompile * * new_cfgs;
    int new_size;

    D.28258 = acfg->cfgs_size;
    new_size = D.28258 * 2;
    D.28259 = (long unsigned int) new_size;
    D.28260 = D.28259 * 8;
    new_cfgs = monoeg_malloc0 (D.28260);
    D.28261 = acfg->cfgs;
    D.28258 = acfg->cfgs_size;
    D.28262 = (long unsigned int) D.28258;
    D.28263 = D.28262 * 8;
    memcpy (new_cfgs, D.28261, D.28263);
    D.28261 = acfg->cfgs;
    monoeg_g_free (D.28261);
    acfg->cfgs = new_cfgs;
    acfg->cfgs_size = new_size;
  }
  <D.25326>:
  D.28258 = acfg->cfgs_size;
  if (D.28258 <= index) goto <D.25325>; else goto <D.25327>;
  <D.25327>:
  D.28261 = acfg->cfgs;
  D.28264 = (long unsigned int) index;
  D.28265 = D.28264 * 8;
  D.28266 = D.28261 + D.28265;
  *D.28266 = cfg;
  D.28267 = acfg->method_to_cfg;
  D.28268 = cfg->orig_method;
  monoeg_g_hash_table_insert_replace (D.28267, D.28268, cfg, 0);
  {
    int ret;

    D.28029 = &acfg->mutex.mutex;
    ret = pthread_mutex_unlock (D.28029);
    if (ret != 0) goto <D.28269>; else goto <D.28270>;
    <D.28269>:
    monoeg_g_log (0B, 16, "Bad call to mono_mutex_unlock result %d", ret);
    <D.28270>:
    D.28271 = ret != 0;
    D.28272 = (long int) D.28271;
    D.28273 = __builtin_expect (D.28272, 0);
    if (D.28273 != 0) goto <D.28274>; else goto <D.28275>;
    <D.28274>:
    monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "aot-compiler.c", 6745, "ret == 0");
    <D.28275>:
  }
  D.28276 = &acfg->stats.ccount;
  InterlockedIncrement (D.28276);
}


add_token_info_hash (void * key, void * value, void * user_data)
{
  struct MonoImage * D.28282;
  unsigned int D.28283;
  struct GHashTable * D.28284;
  struct MonoMethod * method;
  struct MonoJumpInfoToken * ji;
  struct MonoJumpInfoToken * new_ji;
  struct MonoAotCompile * acfg;

  method = key;
  ji = value;
  new_ji = monoeg_malloc0 (32);
  acfg = user_data;
  D.28282 = ji->image;
  new_ji->image = D.28282;
  D.28283 = ji->token;
  new_ji->token = D.28283;
  D.28284 = acfg->token_info_hash;
  monoeg_g_hash_table_insert_replace (D.28284, method, new_ji, 0);
}


method_has_type_vars (struct MonoMethod * method)
{
  struct MonoClass * D.28285;
  int D.28286;
  gboolean D.28289;
  long unsigned int D.28290;
  long unsigned int D.28291;
  struct MonoGenericInst * D.28294;
  struct MonoType * D.28297;
  struct MonoClass * D.28298;
  int D.28299;
  <unnamed-unsigned:22> D.28302;
  int D.28303;

  D.28285 = method->klass;
  D.28286 = has_type_vars (D.28285);
  if (D.28286 != 0) goto <D.28287>; else goto <D.28288>;
  <D.28287>:
  D.28289 = 1;
  return D.28289;
  <D.28288>:
  D.28290 = BIT_FIELD_REF <*method, 64, 256>;
  D.28291 = D.28290 & 2251799813685248;
  if (D.28291 != 0) goto <D.28292>; else goto <D.28293>;
  <D.28292>:
  {
    struct MonoGenericContext * context;

    context = mono_method_get_context (method);
    D.28294 = context->method_inst;
    if (D.28294 != 0B) goto <D.28295>; else goto <D.28296>;
    <D.28295>:
    {
      int i;

      i = 0;
      goto <D.24537>;
      <D.24536>:
      D.28294 = context->method_inst;
      D.28297 = D.28294->type_argv[i];
      D.28298 = mono_class_from_mono_type (D.28297);
      D.28299 = has_type_vars (D.28298);
      if (D.28299 != 0) goto <D.28300>; else goto <D.28301>;
      <D.28300>:
      D.28289 = 1;
      return D.28289;
      <D.28301>:
      i = i + 1;
      <D.24537>:
      D.28294 = context->method_inst;
      D.28302 = D.28294->type_argc;
      D.28303 = (int) D.28302;
      if (D.28303 > i) goto <D.24536>; else goto <D.24538>;
      <D.24538>:
    }
    <D.28296>:
  }
  <D.28293>:
  D.28289 = 0;
  return D.28289;
}


g_slist_prepend_mempool (struct MonoMemPool * mp, struct GSList * list, void * data)
{
  struct GSList * D.28305;
  struct GSList * new_list;

  new_list = mono_mempool_alloc (mp, 16);
  new_list->data = data;
  new_list->next = list;
  D.28305 = new_list;
  return D.28305;
}


InterlockedIncrement (volatile gint32 * val)
{
  gint32 D.28307;
  unsigned int D.28308;

  D.28308 = __sync_add_and_fetch_4 (val, 1);
  D.28307 = (gint32) D.28308;
  return D.28307;
}


emit_section_change (struct MonoAotCompile * acfg, const char * section_name, int subsection_index)
{
  struct MonoImageWriter * D.28310;

  D.28310 = acfg->w;
  img_writer_emit_section_change (D.28310, section_name, subsection_index);
}


emit_alignment (struct MonoAotCompile * acfg, int size)
{
  struct MonoImageWriter * D.28311;

  D.28311 = acfg->w;
  img_writer_emit_alignment (D.28311, size);
}


emit_label (struct MonoAotCompile * acfg, const char * name)
{
  struct MonoImageWriter * D.28312;

  D.28312 = acfg->w;
  img_writer_emit_label (D.28312, name);
}


emit_zero_bytes (struct MonoAotCompile * acfg, int num)
{
  struct MonoImageWriter * D.28313;

  D.28313 = acfg->w;
  img_writer_emit_zero_bytes (D.28313, num);
}


emit_code (struct MonoAotCompile * acfg)
{
  int D.28314;
  struct MonoCompile * * D.28317;
  long unsigned int D.28318;
  long unsigned int D.28319;
  struct MonoCompile * * D.28320;
  struct MonoCompile * D.28321;
  long unsigned int D.28324;
  long unsigned int D.28325;
  char * D.28328;
  gchar * D.28329;
  unsigned int D.28330;
  unsigned int i.73;
  char * D.28332;
  gchar * D.28335;
  struct GPtrArray * D.28336;
  void * * D.28337;
  long unsigned int D.28338;
  long unsigned int D.28339;
  void * * D.28340;
  void * D.28341;
  long int D.28342;
  int D.28345;
  struct MonoMethod * D.28348;
  struct MonoClass * D.28349;
  long unsigned int D.28350;
  long unsigned int D.28351;
  unsigned int D.28354;
  int D.28355;
  long unsigned int D.28358;
  long unsigned int D.28359;
  struct FILE * D.28362;
  char * D.28363;
  int D.28370;
  int D.28371;
  unsigned int D.28373;
  unsigned int oindex.74;
  int D.28377;
  int D.28384;
  unsigned int D.28385;
  unsigned int D.28386;
  unsigned int D.28387;
  int D.28388;
  int D.28392;
  struct MonoMethod * D.28400;
  struct MonoClass * D.28401;
  long unsigned int D.28402;
  long unsigned int D.28403;
  unsigned int D.28406;
  long unsigned int D.28412;
  long unsigned int D.28413;
  _Bool D.28416;
  long int D.28417;
  long int D.28418;
  int oindex;
  int i;
  int prev_index;
  char symbol[256];

  try
    {
      emit_section_change (acfg, ".text", 0);
      emit_alignment (acfg, 8);
      D.28314 = acfg->llvm;
      if (D.28314 != 0) goto <D.28315>; else goto <D.28316>;
      <D.28315>:
      i = 0;
      goto <D.25403>;
      <D.25402>:
      D.28317 = acfg->cfgs;
      D.28318 = (long unsigned int) i;
      D.28319 = D.28318 * 8;
      D.28320 = D.28317 + D.28319;
      D.28321 = *D.28320;
      if (D.28321 != 0B) goto <D.28322>; else goto <D.28323>;
      <D.28322>:
      D.28317 = acfg->cfgs;
      D.28318 = (long unsigned int) i;
      D.28319 = D.28318 * 8;
      D.28320 = D.28317 + D.28319;
      D.28321 = *D.28320;
      D.28324 = BIT_FIELD_REF <*D.28321, 64, 5568>;
      D.28325 = D.28324 & 8388608;
      if (D.28325 != 0) goto <D.28326>; else goto <D.28327>;
      <D.28326>:
      D.28317 = acfg->cfgs;
      D.28318 = (long unsigned int) i;
      D.28319 = D.28318 * 8;
      D.28320 = D.28317 + D.28319;
      D.28321 = *D.28320;
      D.28328 = D.28321->asm_symbol;
      D.28329 = monoeg_strdup (D.28328);
      acfg->methods_symbol = D.28329;
      goto <D.25401>;
      <D.28327>:
      <D.28323>:
      i = i + 1;
      <D.25403>:
      D.28330 = acfg->nmethods;
      i.73 = (unsigned int) i;
      if (D.28330 > i.73) goto <D.25402>; else goto <D.25401>;
      <D.25401>:
      <D.28316>:
      D.28332 = acfg->methods_symbol;
      if (D.28332 == 0B) goto <D.28333>; else goto <D.28334>;
      <D.28333>:
      sprintf (&symbol, "methods");
      emit_label (acfg, &symbol);
      D.28335 = monoeg_strdup (&symbol);
      acfg->methods_symbol = D.28335;
      <D.28334>:
      emit_zero_bytes (acfg, 16);
      oindex = 0;
      goto <D.25408>;
      <D.25407>:
      {
        struct MonoCompile * cfg;
        struct MonoMethod * method;

        D.28336 = acfg->method_order;
        D.28337 = D.28336->pdata;
        D.28338 = (long unsigned int) oindex;
        D.28339 = D.28338 * 8;
        D.28340 = D.28337 + D.28339;
        D.28341 = *D.28340;
        D.28342 = (long int) D.28341;
        i = (int) D.28342;
        D.28317 = acfg->cfgs;
        D.28318 = (long unsigned int) i;
        D.28319 = D.28318 * 8;
        D.28320 = D.28317 + D.28319;
        cfg = *D.28320;
        if (cfg == 0B) goto <D.28343>; else goto <D.28344>;
        <D.28343>:
        // predicted unlikely by continue predictor.
        goto <D.25406>;
        <D.28344>:
        method = cfg->orig_method;
        D.28345 = acfg->aot_opts.full_aot;
        if (D.28345 != 0) goto <D.28346>; else goto <D.28347>;
        <D.28346>:
        D.28348 = cfg->orig_method;
        D.28349 = D.28348->klass;
        D.28350 = BIT_FIELD_REF <*D.28349, 64, 256>;
        D.28351 = D.28350 & 1152921504606846976;
        if (D.28351 != 0) goto <D.28352>; else goto <D.28353>;
        <D.28352>:
        D.28354 = get_method_index (acfg, method);
        sprintf (&symbol, "ut_%d", D.28354);
        emit_section_change (acfg, ".text", 0);
        D.28355 = acfg->thumb_mixed;
        if (D.28355 != 0) goto <D.28356>; else goto <D.28357>;
        <D.28356>:
        D.28358 = BIT_FIELD_REF <*cfg, 64, 5568>;
        D.28359 = D.28358 & 8388608;
        if (D.28359 != 0) goto <D.28360>; else goto <D.28361>;
        <D.28360>:
        emit_set_thumb_mode (acfg);
        D.28362 = acfg->fp;
        fprintf (D.28362, "\n.thumb_func\n");
        <D.28361>:
        <D.28357>:
        emit_label (acfg, &symbol);
        D.28348 = cfg->orig_method;
        D.28363 = cfg->asm_symbol;
        arch_emit_unbox_trampoline (acfg, cfg, D.28348, D.28363);
        D.28355 = acfg->thumb_mixed;
        if (D.28355 != 0) goto <D.28364>; else goto <D.28365>;
        <D.28364>:
        D.28358 = BIT_FIELD_REF <*cfg, 64, 5568>;
        D.28359 = D.28358 & 8388608;
        if (D.28359 != 0) goto <D.28366>; else goto <D.28367>;
        <D.28366>:
        emit_set_arm_mode (acfg);
        <D.28367>:
        <D.28365>:
        <D.28353>:
        <D.28347>:
        D.28358 = BIT_FIELD_REF <*cfg, 64, 5568>;
        D.28359 = D.28358 & 8388608;
        if (D.28359 != 0) goto <D.28368>; else goto <D.28369>;
        <D.28368>:
        D.28370 = acfg->stats.llvm_count;
        D.28371 = D.28370 + 1;
        acfg->stats.llvm_count = D.28371;
        goto <D.28372>;
        <D.28369>:
        emit_method_code (acfg, cfg);
        <D.28372>:
      }
      <D.25406>:
      oindex = oindex + 1;
      <D.25408>:
      D.28336 = acfg->method_order;
      D.28373 = D.28336->len;
      oindex.74 = (unsigned int) oindex;
      if (D.28373 > oindex.74) goto <D.25407>; else goto <D.25409>;
      <D.25409>:
      sprintf (&symbol, "methods_end");
      emit_section_change (acfg, ".text", 0);
      emit_alignment (acfg, 8);
      emit_label (acfg, &symbol);
      emit_int32 (acfg, 0);
      D.28314 = acfg->llvm;
      if (D.28314 != 0) goto <D.28375>; else goto <D.28376>;
      <D.28375>:
      D.28377 = acfg->need_no_dead_strip;
      if (D.28377 != 0) goto <D.28378>; else goto <D.28379>;
      <D.28378>:
      D.28362 = acfg->fp;
      fprintf (D.28362, "\n");
      i = 0;
      goto <D.25411>;
      <D.25410>:
      D.28317 = acfg->cfgs;
      D.28318 = (long unsigned int) i;
      D.28319 = D.28318 * 8;
      D.28320 = D.28317 + D.28319;
      D.28321 = *D.28320;
      if (D.28321 != 0B) goto <D.28380>; else goto <D.28381>;
      <D.28380>:
      D.28317 = acfg->cfgs;
      D.28318 = (long unsigned int) i;
      D.28319 = D.28318 * 8;
      D.28320 = D.28317 + D.28319;
      D.28321 = *D.28320;
      D.28324 = BIT_FIELD_REF <*D.28321, 64, 5568>;
      D.28325 = D.28324 & 8388608;
      if (D.28325 != 0) goto <D.28382>; else goto <D.28383>;
      <D.28382>:
      D.28362 = acfg->fp;
      D.28317 = acfg->cfgs;
      D.28318 = (long unsigned int) i;
      D.28319 = D.28318 * 8;
      D.28320 = D.28317 + D.28319;
      D.28321 = *D.28320;
      D.28328 = D.28321->asm_symbol;
      fprintf (D.28362, ".no_dead_strip %s\n", D.28328);
      <D.28383>:
      <D.28381>:
      i = i + 1;
      <D.25411>:
      D.28330 = acfg->nmethods;
      i.73 = (unsigned int) i;
      if (D.28330 > i.73) goto <D.25410>; else goto <D.25412>;
      <D.25412>:
      <D.28379>:
      <D.28376>:
      sprintf (&symbol, "code_offsets");
      emit_section_change (acfg, ".rodata", 1);
      emit_alignment (acfg, 8);
      emit_label (acfg, &symbol);
      D.28384 = acfg->stats.offsets_size;
      D.28385 = (unsigned int) D.28384;
      D.28330 = acfg->nmethods;
      D.28386 = D.28330 * 4;
      D.28387 = D.28385 + D.28386;
      D.28388 = (int) D.28387;
      acfg->stats.offsets_size = D.28388;
      i = 0;
      goto <D.25414>;
      <D.25413>:
      D.28317 = acfg->cfgs;
      D.28318 = (long unsigned int) i;
      D.28319 = D.28318 * 8;
      D.28320 = D.28317 + D.28319;
      D.28321 = *D.28320;
      if (D.28321 != 0B) goto <D.28389>; else goto <D.28390>;
      <D.28389>:
      D.28317 = acfg->cfgs;
      D.28318 = (long unsigned int) i;
      D.28319 = D.28318 * 8;
      D.28320 = D.28317 + D.28319;
      D.28321 = *D.28320;
      D.28328 = D.28321->asm_symbol;
      D.28332 = acfg->methods_symbol;
      emit_symbol_diff (acfg, D.28328, D.28332, 0);
      goto <D.28391>;
      <D.28390>:
      emit_int32 (acfg, -1);
      <D.28391>:
      i = i + 1;
      <D.25414>:
      D.28330 = acfg->nmethods;
      i.73 = (unsigned int) i;
      if (D.28330 > i.73) goto <D.25413>; else goto <D.25415>;
      <D.25415>:
      emit_line (acfg);
      sprintf (&symbol, "unbox_trampolines");
      D.28392 = acfg->direct_method_addresses;
      if (D.28392 != 0) goto <D.28393>; else goto <D.28394>;
      <D.28393>:
      emit_section_change (acfg, ".text", 0);
      goto <D.28395>;
      <D.28394>:
      emit_section_change (acfg, ".rodata", 0);
      <D.28395>:
      emit_alignment (acfg, 8);
      emit_label (acfg, &symbol);
      prev_index = -1;
      i = 0;
      goto <D.25421>;
      <D.25420>:
      {
        struct MonoCompile * cfg;
        struct MonoMethod * method;
        int index;

        D.28317 = acfg->cfgs;
        D.28318 = (long unsigned int) i;
        D.28319 = D.28318 * 8;
        D.28320 = D.28317 + D.28319;
        cfg = *D.28320;
        if (cfg == 0B) goto <D.28396>; else goto <D.28397>;
        <D.28396>:
        // predicted unlikely by continue predictor.
        goto <D.25419>;
        <D.28397>:
        method = cfg->orig_method;
        D.28345 = acfg->aot_opts.full_aot;
        if (D.28345 != 0) goto <D.28398>; else goto <D.28399>;
        <D.28398>:
        D.28400 = cfg->orig_method;
        D.28401 = D.28400->klass;
        D.28402 = BIT_FIELD_REF <*D.28401, 64, 256>;
        D.28403 = D.28402 & 1152921504606846976;
        if (D.28403 != 0) goto <D.28404>; else goto <D.28405>;
        <D.28404>:
        D.28406 = get_method_index (acfg, method);
        index = (int) D.28406;
        sprintf (&symbol, "ut_%d", index);
        emit_int32 (acfg, index);
        D.28392 = acfg->direct_method_addresses;
        if (D.28392 != 0) goto <D.28407>; else goto <D.28408>;
        <D.28407>:
        emit_unset_mode (acfg);
        D.28355 = acfg->thumb_mixed;
        if (D.28355 != 0) goto <D.28411>; else goto <D.28409>;
        <D.28411>:
        D.28412 = BIT_FIELD_REF <*cfg, 64, 5568>;
        D.28413 = D.28412 & 8388608;
        if (D.28413 != 0) goto <D.28414>; else goto <D.28409>;
        <D.28414>:
        D.28362 = acfg->fp;
        fprintf (D.28362, "\n\tblx %s\n", &symbol);
        goto <D.28410>;
        <D.28409>:
        D.28362 = acfg->fp;
        fprintf (D.28362, "\n\tbl %s\n", &symbol);
        <D.28410>:
        goto <D.28415>;
        <D.28408>:
        D.28332 = acfg->methods_symbol;
        emit_symbol_diff (acfg, &symbol, D.28332, 0);
        <D.28415>:
        D.28416 = index <= prev_index;
        D.28417 = (long int) D.28416;
        D.28418 = __builtin_expect (D.28417, 0);
        if (D.28418 != 0) goto <D.28419>; else goto <D.28420>;
        <D.28419>:
        monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "aot-compiler.c", 7246, "index > prev_index");
        <D.28420>:
        prev_index = index;
        <D.28405>:
        <D.28399>:
      }
      <D.25419>:
      i = i + 1;
      <D.25421>:
      D.28330 = acfg->nmethods;
      i.73 = (unsigned int) i;
      if (D.28330 > i.73) goto <D.25420>; else goto <D.25422>;
      <D.25422>:
      sprintf (&symbol, "unbox_trampolines_end");
      emit_label (acfg, &symbol);
      emit_int32 (acfg, 0);
    }
  finally
    {
      symbol = {CLOBBER};
    }
}


__attribute__((__unused__))
emit_set_thumb_mode (struct MonoAotCompile * acfg)
{
  struct FILE * D.28421;

  emit_unset_mode (acfg);
  D.28421 = acfg->fp;
  fprintf (D.28421, ".code 16\n");
}


arch_emit_unbox_trampoline (struct MonoAotCompile * acfg, struct MonoCompile * cfg, struct MonoMethod * method, const char * call_target)
{
  monoeg_assertion_message ("* Assertion: should not be reached at %s:%d\n", "aot-compiler.c", 1454);
}


__attribute__((__unused__))
emit_set_arm_mode (struct MonoAotCompile * acfg)
{
  struct FILE * D.28422;

  emit_unset_mode (acfg);
  D.28422 = acfg->fp;
  fprintf (D.28422, ".code 32\n");
}


emit_method_code (struct MonoAotCompile * acfg, struct MonoCompile * cfg)
{
  unsigned int D.28423;
  const char * D.28424;
  int D.28425;
  int D.28428;
  struct FILE * D.28431;
  char * D.28432;
  int D.28433;
  struct GHashTable * D.28438;
  struct GHashTable * D.28441;
  unsigned int D.28444;
  char * D.28447;
  int D.28448;
  unsigned int D.28449;
  unsigned int D.28450;
  unsigned int D.28451;
  int D.28452;
  struct MonoCompile * * D.28453;
  long unsigned int D.28454;
  long unsigned int D.28455;
  struct MonoCompile * * D.28456;
  struct MonoCompile * D.28457;
  unsigned int D.28458;
  struct MonoJumpInfo * D.28459;
  struct MonoJitInfo * D.28460;
  struct MonoMethod * D.28461;
  struct MonoDomain * D.28462;
  struct MonoDebugMethodJitInfo * D.28463;
  struct MonoMethod * method;
  int method_index;
  guint8 * code;
  char * debug_sym;
  char * symbol;
  int func_alignment;
  struct MonoMethodHeader * header;
  char * export_name;

  debug_sym = 0B;
  symbol = 0B;
  func_alignment = 16;
  method = cfg->orig_method;
  code = cfg->native_code;
  header = cfg->header;
  D.28423 = get_method_index (acfg, method);
  method_index = (int) D.28423;
  D.28424 = acfg->temp_prefix;
  symbol = monoeg_g_strdup_printf ("%sme_%x", D.28424, method_index);
  emit_section_change (acfg, ".text", 0);
  emit_alignment (acfg, func_alignment);
  D.28425 = acfg->global_symbols;
  if (D.28425 != 0) goto <D.28426>; else goto <D.28427>;
  <D.28426>:
  D.28428 = acfg->need_no_dead_strip;
  if (D.28428 != 0) goto <D.28429>; else goto <D.28430>;
  <D.28429>:
  D.28431 = acfg->fp;
  D.28432 = cfg->asm_symbol;
  fprintf (D.28431, "\t.no_dead_strip %s\n", D.28432);
  <D.28430>:
  <D.28427>:
  D.28432 = cfg->asm_symbol;
  emit_label (acfg, D.28432);
  D.28433 = acfg->aot_opts.write_symbols;
  if (D.28433 != 0) goto <D.28434>; else goto <D.28435>;
  <D.28434>:
  D.28425 = acfg->global_symbols;
  if (D.28425 == 0) goto <D.28436>; else goto <D.28437>;
  <D.28436>:
  D.28438 = acfg->method_label_hash;
  debug_sym = get_debug_sym (method, "", D.28438);
  D.28428 = acfg->need_no_dead_strip;
  if (D.28428 != 0) goto <D.28439>; else goto <D.28440>;
  <D.28439>:
  D.28431 = acfg->fp;
  fprintf (D.28431, "\t.no_dead_strip %s\n", debug_sym);
  <D.28440>:
  emit_local_symbol (acfg, debug_sym, symbol, 1);
  emit_label (acfg, debug_sym);
  <D.28437>:
  <D.28435>:
  D.28441 = acfg->export_names;
  export_name = monoeg_g_hash_table_lookup (D.28441, method);
  if (export_name != 0B) goto <D.28442>; else goto <D.28443>;
  <D.28442>:
  emit_global_inner (acfg, export_name, 1);
  emit_label (acfg, export_name);
  <D.28443>:
  D.28444 = cfg->verbose_level;
  if (D.28444 != 0) goto <D.28445>; else goto <D.28446>;
  <D.28445>:
  D.28447 = mono_method_full_name (method, 1);
  D.28432 = cfg->asm_symbol;
  monoeg_g_print ("Method %s emitted as %s\n", D.28447, D.28432);
  <D.28446>:
  D.28448 = acfg->stats.code_size;
  D.28449 = (unsigned int) D.28448;
  D.28450 = cfg->code_len;
  D.28451 = D.28449 + D.28450;
  D.28452 = (int) D.28451;
  acfg->stats.code_size = D.28452;
  D.28453 = acfg->cfgs;
  D.28454 = (long unsigned int) method_index;
  D.28455 = D.28454 * 8;
  D.28456 = D.28453 + D.28455;
  D.28457 = *D.28456;
  D.28458 = acfg->got_offset;
  D.28457->got_offset = D.28458;
  D.28450 = cfg->code_len;
  D.28459 = cfg->patch_info;
  D.28460 = cfg->jit_info;
  D.28461 = D.28460->d.method;
  D.28462 = mono_domain_get ();
  D.28463 = mono_debug_find_method (D.28461, D.28462);
  emit_and_reloc_code (acfg, method, code, D.28450, D.28459, 0, D.28463);
  emit_line (acfg);
  D.28433 = acfg->aot_opts.write_symbols;
  if (D.28433 != 0) goto <D.28464>; else goto <D.28465>;
  <D.28464>:
  emit_symbol_size (acfg, debug_sym, ".");
  monoeg_g_free (debug_sym);
  <D.28465>:
  emit_label (acfg, symbol);
  monoeg_g_free (symbol);
}


emit_local_symbol (struct MonoAotCompile * acfg, const char * name, const char * end_label, gboolean func)
{
  struct MonoImageWriter * D.28466;

  D.28466 = acfg->w;
  img_writer_emit_local_symbol (D.28466, name, end_label, func);
}


__attribute__((__unused__))
emit_global_inner (struct MonoAotCompile * acfg, const char * name, gboolean func)
{
  struct MonoImageWriter * D.28467;

  D.28467 = acfg->w;
  img_writer_emit_global (D.28467, name, func);
}


emit_and_reloc_code (struct MonoAotCompile * acfg, struct MonoMethod * method, guint8 * code, guint32 code_len, struct MonoJumpInfo * relocs, gboolean got_only, struct MonoDebugMethodJitInfo * debug_info)
{
  unsigned int D.28470;
  int D.28471;
  int code_len.75;
  struct FILE * D.28481;
  void * * D.28482;
  long unsigned int D.28483;
  long unsigned int D.28484;
  void * * D.28485;
  int D.28486;
  unsigned int D.28488;
  unsigned int pindex.76;
  long unsigned int D.28492;
  long unsigned int D.28493;
  struct MonoDebugSourceLocation * * D.28494;
  struct MonoDebugSourceLocation * D.28495;
  char * D.28498;
  unsigned int D.28499;
  long unsigned int D.28509;
  long unsigned int D.28510;
  struct MonoDebugSourceLocation * * D.28511;
  struct MonoDebugSourceLocation * D.28512;
  sizetype D.28514;
  guint8 * D.28515;
  int D.28516;
  unsigned int i.77;
  int i;
  int pindex;
  int start_index;
  int method_index;
  struct GPtrArray * patches;
  struct MonoJumpInfo * patch_info;
  struct MonoMethodHeader * header;
  struct MonoDebugSourceLocation * * locs;
  gboolean skip;

  locs = 0B;
  if (method != 0B) goto <D.28468>; else goto <D.28469>;
  <D.28468>:
  header = mono_method_get_header (method);
  D.28470 = get_method_index (acfg, method);
  method_index = (int) D.28470;
  <D.28469>:
  D.28471 = acfg->gas_line_numbers;
  if (D.28471 != 0) goto <D.28472>; else goto <D.28473>;
  <D.28472>:
  if (method != 0B) goto <D.28474>; else goto <D.28475>;
  <D.28474>:
  if (debug_info != 0B) goto <D.28476>; else goto <D.28477>;
  <D.28476>:
  code_len.75 = (int) code_len;
  locs = compute_line_numbers (method, code_len.75, debug_info);
  if (locs == 0B) goto <D.28479>; else goto <D.28480>;
  <D.28479>:
  {
    int findex;

    findex = get_file_index (acfg, "<unknown>");
    emit_unset_mode (acfg);
    D.28481 = acfg->fp;
    fprintf (D.28481, ".loc %d %d 0\n", findex, 1);
  }
  <D.28480>:
  <D.28477>:
  <D.28475>:
  <D.28473>:
  patches = monoeg_g_ptr_array_new ();
  patch_info = relocs;
  goto <D.24763>;
  <D.24762>:
  monoeg_g_ptr_array_add (patches, patch_info);
  patch_info = patch_info->next;
  <D.24763>:
  if (patch_info != 0B) goto <D.24762>; else goto <D.24764>;
  <D.24764>:
  monoeg_g_ptr_array_sort (patches, compare_patches);
  start_index = 0;
  i = 0;
  goto <D.24778>;
  <D.24777>:
  patch_info = 0B;
  pindex = start_index;
  goto <D.24767>;
  <D.24766>:
  D.28482 = patches->pdata;
  D.28483 = (long unsigned int) pindex;
  D.28484 = D.28483 * 8;
  D.28485 = D.28482 + D.28484;
  patch_info = *D.28485;
  D.28486 = patch_info->ip.i;
  if (D.28486 >= i) goto <D.24765>; else goto <D.28487>;
  <D.28487>:
  pindex = pindex + 1;
  <D.24767>:
  D.28488 = patches->len;
  pindex.76 = (unsigned int) pindex;
  if (D.28488 > pindex.76) goto <D.24766>; else goto <D.24765>;
  <D.24765>:
  if (locs != 0B) goto <D.28490>; else goto <D.28491>;
  <D.28490>:
  D.28492 = (long unsigned int) i;
  D.28493 = D.28492 * 8;
  D.28494 = locs + D.28493;
  D.28495 = *D.28494;
  if (D.28495 != 0B) goto <D.28496>; else goto <D.28497>;
  <D.28496>:
  {
    struct MonoDebugSourceLocation * loc;
    int findex;

    D.28492 = (long unsigned int) i;
    D.28493 = D.28492 * 8;
    D.28494 = locs + D.28493;
    loc = *D.28494;
    D.28498 = loc->source_file;
    findex = get_file_index (acfg, D.28498);
    emit_unset_mode (acfg);
    D.28481 = acfg->fp;
    D.28499 = loc->row;
    fprintf (D.28481, ".loc %d %d 0\n", findex, D.28499);
    mono_debug_symfile_free_location (loc);
  }
  <D.28497>:
  <D.28491>:
  skip = 0;
  if (skip == 0) goto <D.28500>; else goto <D.28501>;
  <D.28500>:
  patch_info = 0B;
  pindex = start_index;
  goto <D.24772>;
  <D.24771>:
  D.28482 = patches->pdata;
  D.28483 = (long unsigned int) pindex;
  D.28484 = D.28483 * 8;
  D.28485 = D.28482 + D.28484;
  patch_info = *D.28485;
  D.28486 = patch_info->ip.i;
  if (D.28486 >= i) goto <D.24770>; else goto <D.28502>;
  <D.28502>:
  pindex = pindex + 1;
  <D.24772>:
  D.28488 = patches->len;
  pindex.76 = (unsigned int) pindex;
  if (D.28488 > pindex.76) goto <D.24771>; else goto <D.24770>;
  <D.24770>:
  D.28488 = patches->len;
  pindex.76 = (unsigned int) pindex;
  if (D.28488 > pindex.76) goto <D.28505>; else goto <D.28503>;
  <D.28505>:
  D.28486 = patch_info->ip.i;
  if (D.28486 > i) goto <D.28506>; else goto <D.28503>;
  <D.28506>:
  {
    int limit;

    limit = i + 1;
    goto <D.24776>;
    <D.24775>:
    if (locs != 0B) goto <D.28507>; else goto <D.28508>;
    <D.28507>:
    D.28509 = (long unsigned int) limit;
    D.28510 = D.28509 * 8;
    D.28511 = locs + D.28510;
    D.28512 = *D.28511;
    if (D.28512 != 0B) goto <D.24774>; else goto <D.28513>;
    <D.28513>:
    <D.28508>:
    limit = limit + 1;
    <D.24776>:
    D.28486 = patch_info->ip.i;
    if (D.28486 > limit) goto <D.24775>; else goto <D.24774>;
    <D.24774>:
    D.28514 = (sizetype) i;
    D.28515 = code + D.28514;
    D.28516 = limit - i;
    emit_bytes (acfg, D.28515, D.28516);
    i = limit + -1;
  }
  goto <D.28504>;
  <D.28503>:
  D.28514 = (sizetype) i;
  D.28515 = code + D.28514;
  emit_bytes (acfg, D.28515, 1);
  <D.28504>:
  <D.28501>:
  i = i + 1;
  <D.24778>:
  i.77 = (unsigned int) i;
  if (i.77 < code_len) goto <D.24777>; else goto <D.24779>;
  <D.24779>:
  monoeg_g_free (locs);
}


compare_patches (const void * a, const void * b)
{
  struct MonoJumpInfo * D.28518;
  struct MonoJumpInfo * D.28519;
  gint D.28522;
  int i;
  int j;

  D.28518 = MEM[(struct MonoJumpInfo * *)a];
  i = D.28518->ip.i;
  D.28519 = MEM[(struct MonoJumpInfo * *)b];
  j = D.28519->ip.i;
  if (i < j) goto <D.28520>; else goto <D.28521>;
  <D.28520>:
  D.28522 = -1;
  return D.28522;
  <D.28521>:
  if (i > j) goto <D.28523>; else goto <D.28524>;
  <D.28523>:
  D.28522 = 1;
  return D.28522;
  <D.28524>:
  D.28522 = 0;
  return D.28522;
}


compute_line_numbers (struct MonoMethod * method, int code_size, struct MonoDebugMethodJitInfo * debug_info)
{
  struct MonoDebugSourceLocation * * D.28528;
  unsigned int D.28529;
  unsigned int code_size.78;
  _Bool D.28533;
  long int D.28534;
  long int D.28535;
  unsigned int D.28538;
  long unsigned int D.28539;
  long unsigned int D.28540;
  struct MonoDebugLineNumberEntry * D.28541;
  long unsigned int D.28542;
  int D.28543;
  long unsigned int D.28544;
  long unsigned int D.28545;
  long unsigned int D.28546;
  long unsigned int D.28547;
  long unsigned int D.28550;
  long unsigned int D.28551;
  int * D.28552;
  unsigned int D.28553;
  unsigned int j.79;
  unsigned int D.28555;
  unsigned int i.80;
  sizetype D.28559;
  sizetype D.28560;
  sizetype D.28561;
  unsigned int D.28562;
  int D.28563;
  unsigned int D.28564;
  long unsigned int D.28566;
  long unsigned int D.28567;
  long unsigned int D.28568;
  int * D.28569;
  unsigned int il_offset.81;
  char * D.28577;
  unsigned int D.28578;
  unsigned int prev_line.82;
  struct MonoDebugSourceLocation * * D.28585;
  struct MonoDebugMethodInfo * minfo;
  struct MonoDebugLineNumberEntry * ln_array;
  struct MonoDebugSourceLocation * loc;
  int i;
  int prev_line;
  int prev_il_offset;
  int * native_to_il_offset;
  struct MonoDebugSourceLocation * * res;
  gboolean first;

  native_to_il_offset = 0B;
  minfo = mono_debug_lookup_method (method);
  if (minfo == 0B) goto <D.28526>; else goto <D.28527>;
  <D.28526>:
  D.28528 = 0B;
  return D.28528;
  <D.28527>:
  D.28529 = debug_info->code_size;
  code_size.78 = (unsigned int) code_size;
  if (D.28529 != code_size.78) goto <D.28531>; else goto <D.28532>;
  <D.28531>:
  D.28528 = 0B;
  return D.28528;
  <D.28532>:
  D.28533 = code_size == 0;
  D.28534 = (long int) D.28533;
  D.28535 = __builtin_expect (D.28534, 0);
  if (D.28535 != 0) goto <D.28536>; else goto <D.28537>;
  <D.28536>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "aot-compiler.c", 4403, "code_size");
  <D.28537>:
  D.28538 = debug_info->num_line_numbers;
  D.28539 = (long unsigned int) D.28538;
  D.28540 = D.28539 * 8;
  ln_array = monoeg_malloc0 (D.28540);
  D.28541 = debug_info->line_numbers;
  D.28538 = debug_info->num_line_numbers;
  D.28539 = (long unsigned int) D.28538;
  D.28540 = D.28539 * 8;
  memcpy (ln_array, D.28541, D.28540);
  D.28538 = debug_info->num_line_numbers;
  D.28542 = (long unsigned int) D.28538;
  qsort (ln_array, D.28542, 8, compare_lne);
  D.28543 = code_size + 1;
  D.28544 = (long unsigned int) D.28543;
  D.28545 = D.28544 * 4;
  native_to_il_offset = monoeg_malloc0 (D.28545);
  i = 0;
  goto <D.24731>;
  <D.24730>:
  {
    int j;
    struct MonoDebugLineNumberEntry * lne;

    D.28546 = (long unsigned int) i;
    D.28547 = D.28546 * 8;
    lne = ln_array + D.28547;
    if (i == 0) goto <D.28548>; else goto <D.28549>;
    <D.28548>:
    j = 0;
    goto <D.24721>;
    <D.24720>:
    D.28550 = (long unsigned int) j;
    D.28551 = D.28550 * 4;
    D.28552 = native_to_il_offset + D.28551;
    *D.28552 = -1;
    j = j + 1;
    <D.24721>:
    D.28553 = lne->native_offset;
    j.79 = (unsigned int) j;
    if (D.28553 > j.79) goto <D.24720>; else goto <D.24722>;
    <D.24722>:
    <D.28549>:
    D.28538 = debug_info->num_line_numbers;
    D.28555 = D.28538 + 4294967295;
    i.80 = (unsigned int) i;
    if (D.28555 > i.80) goto <D.28557>; else goto <D.28558>;
    <D.28557>:
    {
      struct MonoDebugLineNumberEntry * lne_next;

      D.28559 = (sizetype) i;
      D.28560 = D.28559 + 1;
      D.28561 = D.28560 * 8;
      lne_next = ln_array + D.28561;
      D.28553 = lne->native_offset;
      j = (int) D.28553;
      goto <D.24725>;
      <D.24724>:
      D.28550 = (long unsigned int) j;
      D.28551 = D.28550 * 4;
      D.28552 = native_to_il_offset + D.28551;
      D.28562 = lne->il_offset;
      D.28563 = (int) D.28562;
      *D.28552 = D.28563;
      j = j + 1;
      <D.24725>:
      D.28564 = lne_next->native_offset;
      j.79 = (unsigned int) j;
      if (D.28564 > j.79) goto <D.24724>; else goto <D.24726>;
      <D.24726>:
    }
    goto <D.28565>;
    <D.28558>:
    D.28553 = lne->native_offset;
    j = (int) D.28553;
    goto <D.24728>;
    <D.24727>:
    D.28550 = (long unsigned int) j;
    D.28551 = D.28550 * 4;
    D.28552 = native_to_il_offset + D.28551;
    D.28562 = lne->il_offset;
    D.28563 = (int) D.28562;
    *D.28552 = D.28563;
    j = j + 1;
    <D.24728>:
    if (j < code_size) goto <D.24727>; else goto <D.24729>;
    <D.24729>:
    <D.28565>:
  }
  i = i + 1;
  <D.24731>:
  D.28538 = debug_info->num_line_numbers;
  i.80 = (unsigned int) i;
  if (D.28538 > i.80) goto <D.24730>; else goto <D.24732>;
  <D.24732>:
  monoeg_g_free (ln_array);
  D.28566 = (long unsigned int) code_size;
  D.28567 = D.28566 * 8;
  res = monoeg_malloc0 (D.28567);
  prev_il_offset = -1;
  prev_line = -1;
  first = 1;
  i = 0;
  goto <D.24736>;
  <D.24735>:
  {
    int il_offset;

    D.28546 = (long unsigned int) i;
    D.28568 = D.28546 * 4;
    D.28569 = native_to_il_offset + D.28568;
    il_offset = *D.28569;
    if (il_offset == -1) goto <D.28570>; else goto <D.28572>;
    <D.28572>:
    if (il_offset == prev_il_offset) goto <D.28570>; else goto <D.28571>;
    <D.28570>:
    // predicted unlikely by continue predictor.
    goto <D.24734>;
    <D.28571>:
    prev_il_offset = il_offset;
    il_offset.81 = (unsigned int) il_offset;
    loc = mono_debug_symfile_lookup_location (minfo, il_offset.81);
    if (loc == 0B) goto <D.28574>; else goto <D.28576>;
    <D.28576>:
    D.28577 = loc->source_file;
    if (D.28577 == 0B) goto <D.28574>; else goto <D.28575>;
    <D.28574>:
    // predicted unlikely by continue predictor.
    goto <D.24734>;
    <D.28575>:
    D.28578 = loc->row;
    prev_line.82 = (unsigned int) prev_line;
    if (D.28578 == prev_line.82) goto <D.28580>; else goto <D.28581>;
    <D.28580>:
    mono_debug_symfile_free_location (loc);
    // predicted unlikely by continue predictor.
    goto <D.24734>;
    <D.28581>:
    D.28578 = loc->row;
    prev_line = (int) D.28578;
    if (first != 0) goto <D.28582>; else goto <D.28583>;
    <D.28582>:
    *res = loc;
    goto <D.28584>;
    <D.28583>:
    D.28546 = (long unsigned int) i;
    D.28547 = D.28546 * 8;
    D.28585 = res + D.28547;
    *D.28585 = loc;
    <D.28584>:
    first = 0;
  }
  <D.24734>:
  i = i + 1;
  <D.24736>:
  if (i < code_size) goto <D.24735>; else goto <D.24737>;
  <D.24737>:
  D.28528 = res;
  return D.28528;
}


compare_lne (struct MonoDebugLineNumberEntry * a, struct MonoDebugLineNumberEntry * b)
{
  unsigned int D.28587;
  unsigned int D.28588;
  gint D.28591;
  unsigned int D.28592;
  unsigned int D.28593;
  unsigned int D.28594;
  unsigned int D.28595;

  D.28587 = a->native_offset;
  D.28588 = b->native_offset;
  if (D.28587 == D.28588) goto <D.28589>; else goto <D.28590>;
  <D.28589>:
  D.28592 = a->il_offset;
  D.28593 = b->il_offset;
  D.28594 = D.28592 - D.28593;
  D.28591 = (gint) D.28594;
  return D.28591;
  <D.28590>:
  D.28587 = a->native_offset;
  D.28588 = b->native_offset;
  D.28595 = D.28587 - D.28588;
  D.28591 = (gint) D.28595;
  return D.28591;
}


get_file_index (struct MonoAotCompile * acfg, const char * source_file)
{
  struct GHashTable * D.28597;
  struct GHashTable * D.28600;
  void * D.28601;
  long int D.28602;
  unsigned int D.28605;
  unsigned int D.28606;
  gchar * D.28607;
  long int D.28608;
  void * D.28609;
  struct FILE * D.28610;
  char * D.28611;
  int D.28612;
  int findex;

  D.28597 = acfg->dwarf_ln_filenames;
  if (D.28597 == 0B) goto <D.28598>; else goto <D.28599>;
  <D.28598>:
  D.28600 = monoeg_g_hash_table_new (monoeg_g_str_hash, monoeg_g_str_equal);
  acfg->dwarf_ln_filenames = D.28600;
  <D.28599>:
  D.28597 = acfg->dwarf_ln_filenames;
  D.28601 = monoeg_g_hash_table_lookup (D.28597, source_file);
  D.28602 = (long int) D.28601;
  findex = (int) D.28602;
  if (findex == 0) goto <D.28603>; else goto <D.28604>;
  <D.28603>:
  D.28597 = acfg->dwarf_ln_filenames;
  D.28605 = monoeg_g_hash_table_size (D.28597);
  D.28606 = D.28605 + 1;
  findex = (int) D.28606;
  D.28597 = acfg->dwarf_ln_filenames;
  D.28607 = monoeg_strdup (source_file);
  D.28608 = (long int) findex;
  D.28609 = (void *) D.28608;
  monoeg_g_hash_table_insert_replace (D.28597, D.28607, D.28609, 0);
  emit_unset_mode (acfg);
  D.28610 = acfg->fp;
  D.28611 = mono_dwarf_escape_path (source_file);
  fprintf (D.28610, ".file %d \"%s\"\n", findex, D.28611);
  <D.28604>:
  D.28612 = findex;
  return D.28612;
}


emit_bytes (struct MonoAotCompile * acfg, const guint8 * buf, int size)
{
  struct MonoImageWriter * D.28614;

  D.28614 = acfg->w;
  img_writer_emit_bytes (D.28614, buf, size);
}


emit_symbol_size (struct MonoAotCompile * acfg, const char * name, const char * end_label)
{
  struct MonoImageWriter * D.28615;

  D.28615 = acfg->w;
  img_writer_emit_symbol_size (D.28615, name, end_label);
}


emit_line (struct MonoAotCompile * acfg)
{
  struct MonoImageWriter * D.28616;

  D.28616 = acfg->w;
  img_writer_emit_line (D.28616);
}


emit_unset_mode (struct MonoAotCompile * acfg)
{
  struct MonoImageWriter * D.28617;

  D.28617 = acfg->w;
  img_writer_emit_unset_mode (D.28617);
}


emit_symbol_diff (struct MonoAotCompile * acfg, const char * end, const char * start, int offset)
{
  struct MonoImageWriter * D.28618;

  D.28618 = acfg->w;
  img_writer_emit_symbol_diff (D.28618, end, start, offset);
}


emit_int32 (struct MonoAotCompile * acfg, int value)
{
  struct MonoImageWriter * D.28619;

  D.28619 = acfg->w;
  img_writer_emit_int32 (D.28619, value);
}


emit_info (struct MonoAotCompile * acfg)
{
  unsigned int D.28620;
  long unsigned int D.28621;
  long unsigned int D.28622;
  struct GPtrArray * D.28623;
  void * * D.28624;
  long unsigned int D.28625;
  long unsigned int D.28626;
  void * * D.28627;
  void * D.28628;
  long int D.28629;
  struct MonoCompile * * D.28630;
  long unsigned int D.28631;
  long unsigned int D.28632;
  struct MonoCompile * * D.28633;
  struct MonoCompile * D.28634;
  long unsigned int D.28637;
  gint32 * D.28638;
  unsigned int D.28639;
  int D.28640;
  unsigned int D.28642;
  unsigned int oindex.83;
  int D.28644;
  unsigned int D.28645;
  int D.28646;
  unsigned int D.28647;
  unsigned int D.28648;
  int D.28649;
  int oindex;
  int i;
  char symbol[256];
  gint32 * offsets;

  try
    {
      D.28620 = acfg->nmethods;
      D.28621 = (long unsigned int) D.28620;
      D.28622 = D.28621 * 4;
      offsets = monoeg_malloc0 (D.28622);
      oindex = 0;
      goto <D.25431>;
      <D.25430>:
      D.28623 = acfg->method_order;
      D.28624 = D.28623->pdata;
      D.28625 = (long unsigned int) oindex;
      D.28626 = D.28625 * 8;
      D.28627 = D.28624 + D.28626;
      D.28628 = *D.28627;
      D.28629 = (long int) D.28628;
      i = (int) D.28629;
      D.28630 = acfg->cfgs;
      D.28631 = (long unsigned int) i;
      D.28632 = D.28631 * 8;
      D.28633 = D.28630 + D.28632;
      D.28634 = *D.28633;
      if (D.28634 != 0B) goto <D.28635>; else goto <D.28636>;
      <D.28635>:
      D.28630 = acfg->cfgs;
      D.28631 = (long unsigned int) i;
      D.28632 = D.28631 * 8;
      D.28633 = D.28630 + D.28632;
      D.28634 = *D.28633;
      emit_method_info (acfg, D.28634);
      D.28631 = (long unsigned int) i;
      D.28637 = D.28631 * 4;
      D.28638 = offsets + D.28637;
      D.28630 = acfg->cfgs;
      D.28631 = (long unsigned int) i;
      D.28632 = D.28631 * 8;
      D.28633 = D.28630 + D.28632;
      D.28634 = *D.28633;
      D.28639 = D.28634->method_info_offset;
      D.28640 = (int) D.28639;
      *D.28638 = D.28640;
      goto <D.28641>;
      <D.28636>:
      D.28631 = (long unsigned int) i;
      D.28637 = D.28631 * 4;
      D.28638 = offsets + D.28637;
      *D.28638 = 0;
      <D.28641>:
      oindex = oindex + 1;
      <D.25431>:
      D.28623 = acfg->method_order;
      D.28642 = D.28623->len;
      oindex.83 = (unsigned int) oindex;
      if (D.28642 > oindex.83) goto <D.25430>; else goto <D.25432>;
      <D.25432>:
      sprintf (&symbol, "method_info_offsets");
      emit_section_change (acfg, ".rodata", 1);
      emit_alignment (acfg, 8);
      emit_label (acfg, &symbol);
      D.28620 = acfg->nmethods;
      D.28644 = (int) D.28620;
      D.28645 = emit_offset_table (acfg, D.28644, 10, offsets);
      D.28646 = acfg->stats.offsets_size;
      D.28647 = (unsigned int) D.28646;
      D.28648 = D.28647 + D.28645;
      D.28649 = (int) D.28648;
      acfg->stats.offsets_size = D.28649;
      monoeg_g_free (offsets);
    }
  finally
    {
      symbol = {CLOBBER};
    }
}


emit_method_info (struct MonoAotCompile * acfg, struct MonoCompile * cfg)
{
  struct MonoCompile * * D.28650;
  long unsigned int D.28651;
  long unsigned int D.28652;
  struct MonoCompile * * D.28653;
  struct MonoCompile * D.28654;
  int iftmp.84;
  unsigned int D.28656;
  unsigned int D.28659;
  unsigned int D.28660;
  long unsigned int D.28662;
  struct MonoClass * D.28663;
  struct MonoMethod * D.28664;
  guint8 * p.85;
  unsigned int D.28669;
  unsigned int D.28670;
  struct GList * D.28673;
  unsigned int D.28674;
  int D.28675;
  void * D.28676;
  long int D.28677;
  int D.28678;
  _Bool D.28680;
  long int D.28681;
  long int D.28682;
  void * * D.28685;
  long unsigned int D.28686;
  long unsigned int D.28687;
  void * * D.28688;
  <unnamed type> D.28691;
  struct MonoImage * D.28695;
  struct MonoImage * D.28696;
  int D.28701;
  unsigned int pindex.86;
  long unsigned int D.28707;
  signed long D.28708;
  _Bool D.28709;
  long int D.28710;
  long int D.28711;
  int first_got_offset.87;
  int D.28715;
  unsigned int D.28716;
  long int p.88;
  long int buf.89;
  long int D.28719;
  unsigned int D.28720;
  unsigned int D.28721;
  int D.28722;
  long int D.28723;
  _Bool D.28724;
  long int D.28725;
  long int D.28726;
  unsigned int D.28729;
  unsigned int D.28730;
  struct MonoMethod * method;
  struct GList * l;
  int pindex;
  int buf_size;
  int n_patches;
  struct GPtrArray * patches;
  struct MonoJumpInfo * patch_info;
  struct MonoMethodHeader * header;
  guint32 method_index;
  guint8 * p;
  guint8 * buf;
  guint32 first_got_offset;

  try
    {
      method = cfg->orig_method;
      header = mono_method_get_header (method);
      method_index = get_method_index (acfg, method);
      patches = monoeg_g_ptr_array_new ();
      patch_info = cfg->patch_info;
      goto <D.24937>;
      <D.24936>:
      monoeg_g_ptr_array_add (patches, patch_info);
      patch_info = patch_info->next;
      <D.24937>:
      if (patch_info != 0B) goto <D.24936>; else goto <D.24938>;
      <D.24938>:
      monoeg_g_ptr_array_sort (patches, compare_patches);
      D.28650 = acfg->cfgs;
      D.28651 = (long unsigned int) method_index;
      D.28652 = D.28651 * 8;
      D.28653 = D.28650 + D.28652;
      D.28654 = *D.28653;
      first_got_offset = D.28654->got_offset;
      D.28656 = patches->len;
      if (D.28656 > 999) goto <D.28657>; else goto <D.28658>;
      <D.28657>:
      D.28656 = patches->len;
      D.28659 = D.28656 + 640;
      D.28660 = D.28659 * 64;
      iftmp.84 = (int) D.28660;
      goto <D.28661>;
      <D.28658>:
      iftmp.84 = 40960;
      <D.28661>:
      buf_size = iftmp.84;
      D.28662 = (long unsigned int) buf_size;
      buf = monoeg_malloc (D.28662);
      p = buf;
      D.28663 = method->klass;
      D.28664 = mono_class_get_cctor (D.28663);
      if (D.28664 != 0B) goto <D.28665>; else goto <D.28666>;
      <D.28665>:
      D.28663 = method->klass;
      p.85 = p;
      encode_klass_ref (acfg, D.28663, p.85, &p);
      goto <D.28668>;
      <D.28666>:
      p.85 = p;
      encode_value (0, p.85, &p);
      <D.28668>:
      D.28669 = cfg->opt;
      D.28670 = D.28669 & 512;
      if (D.28670 != 0) goto <D.28671>; else goto <D.28672>;
      <D.28671>:
      D.28673 = cfg->ldstr_list;
      D.28674 = monoeg_g_list_length (D.28673);
      D.28675 = (int) D.28674;
      p.85 = p;
      encode_value (D.28675, p.85, &p);
      l = cfg->ldstr_list;
      goto <D.24940>;
      <D.24939>:
      D.28676 = l->data;
      D.28677 = (long int) D.28676;
      D.28678 = (int) D.28677;
      p.85 = p;
      encode_value (D.28678, p.85, &p);
      l = l->next;
      <D.24940>:
      if (l != 0B) goto <D.24939>; else goto <D.24941>;
      <D.24941>:
      goto <D.28679>;
      <D.28672>:
      D.28673 = cfg->ldstr_list;
      D.28680 = D.28673 != 0B;
      D.28681 = (long int) D.28680;
      D.28682 = __builtin_expect (D.28681, 0);
      if (D.28682 != 0) goto <D.28683>; else goto <D.28684>;
      <D.28683>:
      monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "aot-compiler.c", 5129, "!cfg->ldstr_list");
      <D.28684>:
      <D.28679>:
      n_patches = 0;
      pindex = 0;
      goto <D.24944>;
      <D.24943>:
      D.28685 = patches->pdata;
      D.28686 = (long unsigned int) pindex;
      D.28687 = D.28686 * 8;
      D.28688 = D.28685 + D.28687;
      patch_info = *D.28688;
      D.28691 = patch_info->type;
      if (D.28691 == 27) goto <D.28689>; else goto <D.28692>;
      <D.28692>:
      D.28691 = patch_info->type;
      if (D.28691 == 51) goto <D.28689>; else goto <D.28690>;
      <D.28689>:
      patch_info->type = 51;
      // predicted unlikely by continue predictor.
      goto <D.24942>;
      <D.28690>:
      D.28691 = patch_info->type;
      if (D.28691 == 12) goto <D.28693>; else goto <D.28694>;
      <D.28693>:
      D.28695 = patch_info->data.image;
      D.28696 = acfg->image;
      if (D.28695 == D.28696) goto <D.28697>; else goto <D.28698>;
      <D.28697>:
      patch_info->type = 51;
      // predicted unlikely by continue predictor.
      goto <D.24942>;
      <D.28698>:
      <D.28694>:
      D.28691 = patch_info->type;
      if (D.28691 == 42) goto <D.28699>; else goto <D.28700>;
      <D.28699>:
      patch_info->type = 51;
      // predicted unlikely by continue predictor.
      goto <D.24942>;
      <D.28700>:
      D.28701 = is_plt_patch (patch_info);
      if (D.28701 != 0) goto <D.28702>; else goto <D.28703>;
      <D.28702>:
      patch_info->type = 51;
      // predicted unlikely by continue predictor.
      goto <D.24942>;
      <D.28703>:
      n_patches = n_patches + 1;
      <D.24942>:
      pindex = pindex + 1;
      <D.24944>:
      D.28656 = patches->len;
      pindex.86 = (unsigned int) pindex;
      if (D.28656 > pindex.86) goto <D.24943>; else goto <D.24945>;
      <D.24945>:
      if (n_patches != 0) goto <D.28705>; else goto <D.28706>;
      <D.28705>:
      D.28707 = BIT_FIELD_REF <*cfg, 64, 5632>;
      D.28708 = (signed long) D.28707;
      D.28709 = D.28708 >= 0;
      D.28710 = (long int) D.28709;
      D.28711 = __builtin_expect (D.28710, 0);
      if (D.28711 != 0) goto <D.28712>; else goto <D.28713>;
      <D.28712>:
      monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "aot-compiler.c", 5164, "cfg->has_got_slots");
      <D.28713>:
      <D.28706>:
      first_got_offset.87 = (int) first_got_offset;
      p.85 = p;
      encode_patch_list (acfg, patches, n_patches, first_got_offset.87, p.85, &p);
      D.28715 = acfg->stats.info_size;
      D.28716 = (unsigned int) D.28715;
      p.85 = p;
      p.88 = (long int) p.85;
      buf.89 = (long int) buf;
      D.28719 = p.88 - buf.89;
      D.28720 = (unsigned int) D.28719;
      D.28721 = D.28716 + D.28720;
      D.28722 = (int) D.28721;
      acfg->stats.info_size = D.28722;
      p.85 = p;
      p.88 = (long int) p.85;
      buf.89 = (long int) buf;
      D.28719 = p.88 - buf.89;
      D.28723 = (long int) buf_size;
      D.28724 = D.28719 >= D.28723;
      D.28725 = (long int) D.28724;
      D.28726 = __builtin_expect (D.28725, 0);
      if (D.28726 != 0) goto <D.28727>; else goto <D.28728>;
      <D.28727>:
      monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "aot-compiler.c", 5170, "p - buf < buf_size");
      <D.28728>:
      p.85 = p;
      p.88 = (long int) p.85;
      buf.89 = (long int) buf;
      D.28719 = p.88 - buf.89;
      D.28729 = (unsigned int) D.28719;
      D.28730 = add_to_blob (acfg, buf, D.28729);
      cfg->method_info_offset = D.28730;
      monoeg_g_free (buf);
    }
  finally
    {
      p = {CLOBBER};
    }
}


encode_klass_ref (struct MonoAotCompile * acfg, struct MonoClass * klass, guint8 * buf, guint8 * * endbuf)
{
  struct MonoGenericClass * D.28731;
  unsigned int D.28734;
  _Bool D.28735;
  long int D.28736;
  long int D.28737;
  unsigned char D.28745;
  struct GHashTable * D.28749;
  void * D.28750;
  long int D.28751;
  guint8 * p.90;
  long int p.91;
  long int buf2.92;
  long int D.28757;
  _Bool D.28758;
  long int D.28759;
  long int D.28760;
  unsigned int D.28763;
  unsigned int D.28764;
  long unsigned int D.28765;
  void * D.28766;
  int offset.93;
  gboolean shared;

  shared = 0;
  D.28731 = klass->generic_class;
  if (D.28731 != 0B) goto <D.28732>; else goto <D.28733>;
  <D.28732>:
  {
    guint32 token;

    D.28734 = klass->type_token;
    D.28735 = D.28734 == 0;
    D.28736 = (long int) D.28735;
    D.28737 = __builtin_expect (D.28736, 0);
    if (D.28737 != 0) goto <D.28738>; else goto <D.28739>;
    <D.28738>:
    monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "aot-compiler.c", 2354, "klass->type_token");
    <D.28739>:
    token = find_typespec_for_class (acfg, klass);
    if (token == 0) goto <D.28740>; else goto <D.28741>;
    <D.28740>:
    shared = 1;
    <D.28741>:
  }
  goto <D.28742>;
  <D.28733>:
  D.28745 = klass->byval_arg.type;
  if (D.28745 == 19) goto <D.28743>; else goto <D.28746>;
  <D.28746>:
  D.28745 = klass->byval_arg.type;
  if (D.28745 == 30) goto <D.28743>; else goto <D.28744>;
  <D.28743>:
  shared = 1;
  <D.28744>:
  <D.28742>:
  if (shared != 0) goto <D.28747>; else goto <D.28748>;
  <D.28747>:
  {
    guint offset;
    guint8 * buf2;
    guint8 * p;

    try
      {
        D.28749 = acfg->klass_blob_hash;
        D.28750 = monoeg_g_hash_table_lookup (D.28749, klass);
        D.28751 = (long int) D.28750;
        offset = (guint) D.28751;
        if (offset == 0) goto <D.28752>; else goto <D.28753>;
        <D.28752>:
        buf2 = monoeg_malloc (1024);
        p = buf2;
        p.90 = p;
        encode_klass_ref_inner (acfg, klass, p.90, &p);
        p.90 = p;
        p.91 = (long int) p.90;
        buf2.92 = (long int) buf2;
        D.28757 = p.91 - buf2.92;
        D.28758 = D.28757 > 1023;
        D.28759 = (long int) D.28758;
        D.28760 = __builtin_expect (D.28759, 0);
        if (D.28760 != 0) goto <D.28761>; else goto <D.28762>;
        <D.28761>:
        monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "aot-compiler.c", 2373, "p - buf2 < 1024");
        <D.28762>:
        p.90 = p;
        p.91 = (long int) p.90;
        buf2.92 = (long int) buf2;
        D.28757 = p.91 - buf2.92;
        D.28763 = (unsigned int) D.28757;
        offset = add_to_blob (acfg, buf2, D.28763);
        monoeg_g_free (buf2);
        D.28749 = acfg->klass_blob_hash;
        D.28764 = offset + 1;
        D.28765 = (long unsigned int) D.28764;
        D.28766 = (void *) D.28765;
        monoeg_g_hash_table_insert_replace (D.28749, klass, D.28766, 0);
        goto <D.28767>;
        <D.28753>:
        offset = offset + 4294967295;
        <D.28767>:
        p = buf;
        p.90 = p;
        encode_value (7, p.90, &p);
        offset.93 = (int) offset;
        p.90 = p;
        encode_value (offset.93, p.90, &p);
        p.90 = p;
        *endbuf = p.90;
        return;
      }
    finally
      {
        p = {CLOBBER};
      }
  }
  <D.28748>:
  encode_klass_ref_inner (acfg, klass, buf, endbuf);
}


find_typespec_for_class (struct MonoAotCompile * acfg, struct MonoClass * klass)
{
  struct MonoImage * D.28771;
  <unnamed-unsigned:24> D.28772;
  struct MonoClass * * D.28773;
  struct MonoMemPool * D.28776;
  long unsigned int D.28777;
  unsigned int D.28778;
  unsigned int D.28779;
  void * D.28780;
  long unsigned int D.28781;
  long unsigned int D.28782;
  struct MonoClass * * D.28783;
  int D.28784;
  int D.28785;
  unsigned int D.28786;
  struct MonoClass * D.28787;
  struct MonoClass * D.28788;
  guint32 D.28792;
  int i;
  int len;

  D.28771 = acfg->image;
  D.28772 = D.28771->tables[27].rows;
  len = (int) D.28772;
  D.28773 = acfg->typespec_classes;
  if (D.28773 == 0B) goto <D.28774>; else goto <D.28775>;
  <D.28774>:
  D.28776 = acfg->mempool;
  D.28777 = (long unsigned int) len;
  D.28778 = (unsigned int) D.28777;
  D.28779 = D.28778 * 8;
  D.28780 = mono_mempool_alloc0 (D.28776, D.28779);
  acfg->typespec_classes = D.28780;
  i = 0;
  goto <D.24090>;
  <D.24089>:
  D.28773 = acfg->typespec_classes;
  D.28781 = (long unsigned int) i;
  D.28782 = D.28781 * 8;
  D.28783 = D.28773 + D.28782;
  D.28771 = acfg->image;
  D.28784 = i + 1;
  D.28785 = D.28784 | 452984832;
  D.28786 = (unsigned int) D.28785;
  D.28787 = mono_class_get_full (D.28771, D.28786, 0B);
  *D.28783 = D.28787;
  i = i + 1;
  <D.24090>:
  if (i < len) goto <D.24089>; else goto <D.24091>;
  <D.24091>:
  <D.28775>:
  i = 0;
  goto <D.24094>;
  <D.24093>:
  D.28773 = acfg->typespec_classes;
  D.28781 = (long unsigned int) i;
  D.28782 = D.28781 * 8;
  D.28783 = D.28773 + D.28782;
  D.28788 = *D.28783;
  if (D.28788 == klass) goto <D.24092>; else goto <D.28789>;
  <D.28789>:
  i = i + 1;
  <D.24094>:
  if (i < len) goto <D.24093>; else goto <D.24092>;
  <D.24092>:
  if (i < len) goto <D.28790>; else goto <D.28791>;
  <D.28790>:
  D.28784 = i + 1;
  D.28785 = D.28784 | 452984832;
  D.28792 = (guint32) D.28785;
  return D.28792;
  <D.28791>:
  D.28792 = 0;
  return D.28792;
}


encode_klass_ref_inner (struct MonoAotCompile * acfg, struct MonoClass * klass, guint8 * buf, guint8 * * endbuf)
{
  struct MonoGenericClass * D.28794;
  unsigned int D.28797;
  _Bool D.28798;
  long int D.28799;
  long int D.28800;
  guint8 * p.94;
  int token.95;
  long int p.96;
  long int p1.97;
  long int D.28810;
  unsigned int D.28811;
  int count.98;
  unsigned int count.99;
  unsigned int D.28814;
  int count.100;
  struct MonoImage * D.28819;
  unsigned int D.28820;
  unsigned int D.28821;
  _Bool D.28822;
  long int D.28823;
  long int D.28824;
  unsigned int D.28829;
  int D.28830;
  unsigned int D.28832;
  int D.28833;
  unsigned char D.28838;
  struct MonoGenericParam * D.28840;
  int D.28841;
  short unsigned int D.28842;
  int D.28843;
  _Bool D.28844;
  int D.28845;
  <unnamed-signed:1> D.28848;
  int D.28849;
  short unsigned int D.28850;
  _Bool D.28851;
  long int D.28852;
  long int D.28853;
  long unsigned int D.28856;
  long unsigned int D.28857;
  struct MonoMethod * D.28860;
  struct MonoClass * D.28862;
  int D.28864;
  struct MonoType * D.28867;
  unsigned char D.28869;
  _Bool D.28870;
  long int D.28871;
  long int D.28872;
  int D.28875;
  struct MonoClass * D.28876;
  guint8 * p;

  try
    {
      p = buf;
      D.28794 = klass->generic_class;
      if (D.28794 != 0B) goto <D.28795>; else goto <D.28796>;
      <D.28795>:
      {
        guint32 token;

        D.28797 = klass->type_token;
        D.28798 = D.28797 == 0;
        D.28799 = (long int) D.28798;
        D.28800 = __builtin_expect (D.28799, 0);
        if (D.28800 != 0) goto <D.28801>; else goto <D.28802>;
        <D.28801>:
        monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "aot-compiler.c", 2275, "klass->type_token");
        <D.28802>:
        token = find_typespec_for_class (acfg, klass);
        if (token != 0) goto <D.28803>; else goto <D.28804>;
        <D.28803>:
        p.94 = p;
        encode_value (3, p.94, &p);
        token.95 = (int) token;
        p.94 = p;
        encode_value (token.95, p.94, &p);
        goto <D.28807>;
        <D.28804>:
        {
          struct MonoClass * gclass;
          struct MonoGenericInst * inst;
          static int count = 0;
          guint8 * p1;

          D.28794 = klass->generic_class;
          gclass = D.28794->container_class;
          D.28794 = klass->generic_class;
          inst = D.28794->context.class_inst;
          p1 = p;
          p.94 = p;
          encode_value (4, p.94, &p);
          p.94 = p;
          encode_klass_ref (acfg, gclass, p.94, &p);
          p.94 = p;
          encode_ginst (acfg, inst, p.94, &p);
          p.94 = p;
          p.96 = (long int) p.94;
          p1.97 = (long int) p1;
          D.28810 = p.96 - p1.97;
          D.28811 = (unsigned int) D.28810;
          count.98 = count;
          count.99 = (unsigned int) count.98;
          D.28814 = D.28811 + count.99;
          count.100 = (int) D.28814;
          count = count.100;
        }
        <D.28807>:
      }
      goto <D.28816>;
      <D.28796>:
      D.28797 = klass->type_token;
      if (D.28797 != 0) goto <D.28817>; else goto <D.28818>;
      <D.28817>:
      {
        int iindex;

        D.28819 = klass->image;
        D.28820 = get_image_index (acfg, D.28819);
        iindex = (int) D.28820;
        D.28797 = klass->type_token;
        D.28821 = D.28797 & 4278190080;
        D.28822 = D.28821 != 33554432;
        D.28823 = (long int) D.28822;
        D.28824 = __builtin_expect (D.28823, 0);
        if (D.28824 != 0) goto <D.28825>; else goto <D.28826>;
        <D.28825>:
        monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "aot-compiler.c", 2297, "mono_metadata_token_code (klass->type_token) == MONO_TOKEN_TYPE_DEF");
        <D.28826>:
        if (iindex == 0) goto <D.28827>; else goto <D.28828>;
        <D.28827>:
        p.94 = p;
        encode_value (1, p.94, &p);
        D.28797 = klass->type_token;
        D.28829 = D.28797 + 4261412864;
        D.28830 = (int) D.28829;
        p.94 = p;
        encode_value (D.28830, p.94, &p);
        goto <D.28831>;
        <D.28828>:
        p.94 = p;
        encode_value (2, p.94, &p);
        D.28797 = klass->type_token;
        D.28829 = D.28797 + 4261412864;
        D.28830 = (int) D.28829;
        p.94 = p;
        encode_value (D.28830, p.94, &p);
        D.28819 = klass->image;
        D.28832 = get_image_index (acfg, D.28819);
        D.28833 = (int) D.28832;
        p.94 = p;
        encode_value (D.28833, p.94, &p);
        <D.28831>:
      }
      goto <D.28834>;
      <D.28818>:
      D.28838 = klass->byval_arg.type;
      if (D.28838 == 19) goto <D.28835>; else goto <D.28839>;
      <D.28839>:
      D.28838 = klass->byval_arg.type;
      if (D.28838 == 30) goto <D.28835>; else goto <D.28836>;
      <D.28835>:
      {
        struct MonoGenericContainer * container;
        struct MonoGenericParam * par;

        D.28840 = klass->byval_arg.data.generic_param;
        container = D.28840->owner;
        par = klass->byval_arg.data.generic_param;
        p.94 = p;
        encode_value (5, p.94, &p);
        D.28838 = klass->byval_arg.type;
        D.28841 = (int) D.28838;
        p.94 = p;
        encode_value (D.28841, p.94, &p);
        D.28840 = klass->byval_arg.data.generic_param;
        D.28842 = D.28840->num;
        D.28843 = (int) D.28842;
        p.94 = p;
        encode_value (D.28843, p.94, &p);
        D.28844 = container != 0B;
        D.28845 = (int) D.28844;
        p.94 = p;
        encode_value (D.28845, p.94, &p);
        if (container != 0B) goto <D.28846>; else goto <D.28847>;
        <D.28846>:
        D.28848 = container->is_method;
        D.28849 = (int) D.28848;
        p.94 = p;
        encode_value (D.28849, p.94, &p);
        D.28850 = par->serial;
        D.28851 = D.28850 != 0;
        D.28852 = (long int) D.28851;
        D.28853 = __builtin_expect (D.28852, 0);
        if (D.28853 != 0) goto <D.28854>; else goto <D.28855>;
        <D.28854>:
        monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "aot-compiler.c", 2317, "par->serial == 0");
        <D.28855>:
        D.28856 = BIT_FIELD_REF <*container, 64, 256>;
        D.28857 = D.28856 & 4294967296;
        if (D.28857 != 0) goto <D.28858>; else goto <D.28859>;
        <D.28858>:
        D.28860 = container->owner.method;
        p.94 = p;
        encode_method_ref (acfg, D.28860, p.94, &p);
        goto <D.28861>;
        <D.28859>:
        D.28862 = container->owner.klass;
        p.94 = p;
        encode_klass_ref (acfg, D.28862, p.94, &p);
        <D.28861>:
        goto <D.28863>;
        <D.28847>:
        D.28850 = par->serial;
        D.28864 = (int) D.28850;
        p.94 = p;
        encode_value (D.28864, p.94, &p);
        <D.28863>:
      }
      goto <D.28837>;
      <D.28836>:
      D.28838 = klass->byval_arg.type;
      if (D.28838 == 15) goto <D.28865>; else goto <D.28866>;
      <D.28865>:
      p.94 = p;
      encode_value (8, p.94, &p);
      D.28867 = &klass->byval_arg;
      p.94 = p;
      encode_type (acfg, D.28867, p.94, &p);
      goto <D.28868>;
      <D.28866>:
      D.28869 = klass->rank;
      D.28870 = D.28869 == 0;
      D.28871 = (long int) D.28870;
      D.28872 = __builtin_expect (D.28871, 0);
      if (D.28872 != 0) goto <D.28873>; else goto <D.28874>;
      <D.28873>:
      monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "aot-compiler.c", 2330, "klass->rank > 0");
      <D.28874>:
      p.94 = p;
      encode_value (6, p.94, &p);
      D.28869 = klass->rank;
      D.28875 = (int) D.28869;
      p.94 = p;
      encode_value (D.28875, p.94, &p);
      D.28876 = klass->element_class;
      p.94 = p;
      encode_klass_ref (acfg, D.28876, p.94, &p);
      <D.28868>:
      <D.28837>:
      <D.28834>:
      <D.28816>:
      p.94 = p;
      *endbuf = p.94;
    }
  finally
    {
      p = {CLOBBER};
    }
}


encode_ginst (struct MonoAotCompile * acfg, struct MonoGenericInst * inst, guint8 * buf, guint8 * * endbuf)
{
  <unnamed-unsigned:22> D.28877;
  int D.28878;
  guint8 * p.101;
  struct MonoType * D.28880;
  struct MonoClass * D.28881;
  int D.28882;
  guint8 * p;
  int i;

  try
    {
      p = buf;
      D.28877 = inst->type_argc;
      D.28878 = (int) D.28877;
      p.101 = p;
      encode_value (D.28878, p.101, &p);
      i = 0;
      goto <D.24158>;
      <D.24157>:
      D.28880 = inst->type_argv[i];
      D.28881 = mono_class_from_mono_type (D.28880);
      p.101 = p;
      encode_klass_ref (acfg, D.28881, p.101, &p);
      i = i + 1;
      <D.24158>:
      D.28877 = inst->type_argc;
      D.28882 = (int) D.28877;
      if (D.28882 > i) goto <D.24157>; else goto <D.24159>;
      <D.24159>:
      p.101 = p;
      *endbuf = p.101;
    }
  finally
    {
      p = {CLOBBER};
    }
}


get_image_index (struct MonoAotCompile * cfg, struct MonoImage * image)
{
  struct GHashTable * D.28883;
  void * D.28884;
  long int D.28885;
  guint32 D.28888;
  unsigned int D.28889;
  long unsigned int D.28890;
  void * D.28891;
  struct GPtrArray * D.28892;
  guint32 index;

  D.28883 = cfg->image_hash;
  D.28884 = monoeg_g_hash_table_lookup (D.28883, image);
  D.28885 = (long int) D.28884;
  index = (guint32) D.28885;
  if (index != 0) goto <D.28886>; else goto <D.28887>;
  <D.28886>:
  D.28888 = index + 4294967295;
  return D.28888;
  <D.28887>:
  D.28883 = cfg->image_hash;
  index = monoeg_g_hash_table_size (D.28883);
  D.28883 = cfg->image_hash;
  D.28889 = index + 1;
  D.28890 = (long unsigned int) D.28889;
  D.28891 = (void *) D.28890;
  monoeg_g_hash_table_insert_replace (D.28883, image, D.28891, 0);
  D.28892 = cfg->image_table;
  monoeg_g_ptr_array_add (D.28892, image);
  D.28888 = index;
  return D.28888;
}


encode_method_ref (struct MonoAotCompile * acfg, struct MonoMethod * method, guint8 * buf, guint8 * * endbuf)
{
  struct MonoClass * D.28894;
  struct MonoImage * D.28895;
  long unsigned int D.28899;
  long unsigned int D.28900;
  short unsigned int D.28902;
  int D.28903;
  int D.28904;
  short unsigned int D.28905;
  int D.28906;
  int D.28907;
  guint8 * p.102;
  long unsigned int D.28909;
  <unnamed-unsigned:5> D.28912;
  int D.28913;
  int D.28914;
  _Bool D.28915;
  long int D.28916;
  long int D.28917;
  int D.28920;
  _Bool D.28921;
  long int D.28922;
  long int D.28923;
  _Bool D.28926;
  long int D.28927;
  long int D.28928;
  <unnamed type> D.28931;
  int D.28932;
  int D.28935;
  _Bool D.28936;
  long int D.28937;
  long int D.28938;
  <unnamed type> D.28941;
  int D.28942;
  unsigned int D.28943;
  struct MonoMethod * D.28949;
  struct MonoMethod * D.28953;
  _Bool D.28954;
  long int D.28955;
  long int D.28956;
  <unnamed type> D.28959;
  int D.28960;
  const char * D.28963;
  long unsigned int D.28964;
  long unsigned int D.28965;
  guint8 * p.103;
  struct MonoMethod * D.28970;
  _Bool D.28972;
  long int D.28973;
  long int D.28974;
  _Bool D.28977;
  long int D.28978;
  long int D.28979;
  _Bool D.28982;
  long int D.28983;
  long int D.28984;
  _Bool D.28987;
  long int D.28988;
  long int D.28989;
  <unnamed type> D.28992;
  int D.28993;
  unsigned int D.28996;
  int D.28997;
  unsigned int D.28998;
  int D.28999;
  struct MonoMethod * D.29003;
  _Bool D.29005;
  long int D.29006;
  long int D.29007;
  <unnamed type> D.29010;
  int D.29011;
  _Bool D.29012;
  long int D.29013;
  long int D.29014;
  <unnamed type> D.29017;
  int D.29018;
  unsigned int D.29019;
  struct MonoMethod * D.29022;
  struct MonoMethodSignature * D.29026;
  long unsigned int D.29027;
  gint32 iftmp.104;
  <unnamed type> D.29036;
  _Bool D.29038;
  long int D.29039;
  long int D.29040;
  struct MonoMethod * D.29043;
  struct MonoClass * D.29044;
  struct MonoMethodSignature * D.29046;
  long unsigned int D.29047;
  long unsigned int D.29048;
  struct GHashTable * D.29051;
  struct MonoImage * D.29054;
  _Bool D.29055;
  long int D.29056;
  long int D.29057;
  int image_index.105;
  int token.106;
  _Bool D.29063;
  long int D.29064;
  long int D.29065;
  unsigned int D.29070;
  _Bool D.29071;
  long int D.29072;
  long int D.29073;
  unsigned int D.29076;
  _Bool D.29077;
  long int D.29078;
  long int D.29079;
  unsigned char D.29090;
  _Bool D.29091;
  long int D.29092;
  long int D.29093;
  int D.29098;
  struct MonoMethodSignature * D.29100;
  short unsigned int D.29101;
  short unsigned int D.29102;
  int D.29106;
  struct MonoMethodSignature * D.29108;
  short unsigned int D.29109;
  int D.29110;
  int D.29111;
  int D.29112;
  int D.29114;
  int D.29118;
  int D.29122;
  int D.29131;
  unsigned int D.29133;
  unsigned int D.29134;
  unsigned int D.29135;
  int D.29136;
  guint32 image_index;
  guint32 token;
  struct MonoJumpInfoToken * ji;
  guint8 * p;

  try
    {
      D.28894 = method->klass;
      D.28895 = D.28894->image;
      image_index = get_image_index (acfg, D.28895);
      token = method->token;
      p = buf;
      D.28899 = BIT_FIELD_REF <*method, 64, 256>;
      D.28900 = D.28899 & 4503599627370496;
      if (D.28900 != 0) goto <D.28901>; else goto <D.28896>;
      <D.28901>:
      D.28902 = method->flags;
      D.28903 = (int) D.28902;
      D.28904 = D.28903 & 64;
      if (D.28904 != 0) goto <D.28897>; else goto <D.28896>;
      <D.28896>:
      D.28905 = method->iflags;
      D.28906 = (int) D.28905;
      D.28907 = D.28906 & 32;
      if (D.28907 != 0) goto <D.28897>; else goto <D.28898>;
      <D.28897>:
      p.102 = p;
      encode_value (-83886080, p.102, &p);
      <D.28898>:
      D.28899 = BIT_FIELD_REF <*method, 64, 256>;
      D.28909 = D.28899 & 4467570830351532032;
      if (D.28909 != 0) goto <D.28910>; else goto <D.28911>;
      <D.28910>:
      p.102 = p;
      encode_value (-67108864, p.102, &p);
      D.28912 = method->wrapper_type;
      D.28913 = (int) D.28912;
      p.102 = p;
      encode_value (D.28913, p.102, &p);
      D.28912 = method->wrapper_type;
      D.28914 = (int) D.28912;
      switch (D.28914) <default: <D.24272>, case 1: <D.24265>, case 2: <D.24266>, case 3: <D.24267>, case 4: <D.24263>, case 5: <D.24270>, case 6: <D.24255>, case 7: <D.24259>, case 8: <D.24235>, case 9: <D.24236>, case 10: <D.24237>, case 12: <D.24241>, case 13: <D.24243>, case 14: <D.24246>, case 15: <D.24247>, case 16: <D.24257>, case 18: <D.24244>, case 19: <D.24261>, case 20: <D.24240>, case 21: <D.24251>, case 23: <D.24242>, case 24: <D.24250>, case 25: <D.24253>, case 28: <D.24248>>
      <D.24235>:
      <D.24236>:
      <D.24237>:
      {
        struct MonoMethod * m;

        m = mono_marshal_method_from_wrapper (method);
        D.28915 = m == 0B;
        D.28916 = (long int) D.28915;
        D.28917 = __builtin_expect (D.28916, 0);
        if (D.28917 != 0) goto <D.28918>; else goto <D.28919>;
        <D.28918>:
        monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "aot-compiler.c", 2595, "m");
        <D.28919>:
        p.102 = p;
        encode_method_ref (acfg, m, p.102, &p);
        goto <D.24239>;
      }
      <D.24240>:
      <D.24241>:
      <D.24242>:
      <D.24243>:
      <D.24244>:
      {
        struct MonoClass * proxy_class;

        proxy_class = mono_marshal_get_wrapper_info (method);
        p.102 = p;
        encode_klass_ref (acfg, proxy_class, p.102, &p);
        goto <D.24239>;
      }
      <D.24246>:
      <D.24247>:
      goto <D.24239>;
      <D.24248>:
      {
        struct AllocatorWrapperInfo * info;

        info = mono_marshal_get_wrapper_info (method);
        D.28920 = info->alloc_type;
        D.28921 = D.28920 == -1;
        D.28922 = (long int) D.28921;
        D.28923 = __builtin_expect (D.28922, 0);
        if (D.28923 != 0) goto <D.28924>; else goto <D.28925>;
        <D.28924>:
        monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "aot-compiler.c", 2615, "info->alloc_type != -1");
        <D.28925>:
        D.28920 = info->alloc_type;
        p.102 = p;
        encode_value (D.28920, p.102, &p);
        goto <D.24239>;
      }
      <D.24250>:
      goto <D.24239>;
      <D.24251>:
      {
        struct WrapperInfo * info;

        info = mono_marshal_get_wrapper_info (method);
        D.28926 = info == 0B;
        D.28927 = (long int) D.28926;
        D.28928 = __builtin_expect (D.28927, 0);
        if (D.28928 != 0) goto <D.28929>; else goto <D.28930>;
        <D.28929>:
        monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "aot-compiler.c", 2624, "info");
        <D.28930>:
        D.28931 = info->subtype;
        D.28932 = (int) D.28931;
        p.102 = p;
        encode_value (D.28932, p.102, &p);
        D.28931 = info->subtype;
        if (D.28931 == 3) goto <D.28933>; else goto <D.28934>;
        <D.28933>:
        D.28935 = info->d.virtual_stelemref.kind;
        p.102 = p;
        encode_value (D.28935, p.102, &p);
        <D.28934>:
        goto <D.24239>;
      }
      <D.24253>:
      {
        struct WrapperInfo * info;

        info = mono_marshal_get_wrapper_info (method);
        D.28936 = info == 0B;
        D.28937 = (long int) D.28936;
        D.28938 = __builtin_expect (D.28937, 0);
        if (D.28938 != 0) goto <D.28939>; else goto <D.28940>;
        <D.28939>:
        monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "aot-compiler.c", 2633, "info");
        <D.28940>:
        D.28941 = info->subtype;
        D.28942 = (int) D.28941;
        p.102 = p;
        encode_value (D.28942, p.102, &p);
        D.28941 = info->subtype;
        D.28943 = D.28941 + 4294967289;
        if (D.28943 <= 1) goto <D.28944>; else goto <D.28945>;
        <D.28944>:
        D.28894 = method->klass;
        p.102 = p;
        encode_klass_ref (acfg, D.28894, p.102, &p);
        goto <D.28946>;
        <D.28945>:
        D.28941 = info->subtype;
        if (D.28941 == 17) goto <D.28947>; else goto <D.28948>;
        <D.28947>:
        D.28949 = info->d.synchronized_inner.method;
        p.102 = p;
        encode_method_ref (acfg, D.28949, p.102, &p);
        goto <D.28950>;
        <D.28948>:
        D.28941 = info->subtype;
        if (D.28941 == 20) goto <D.28951>; else goto <D.28952>;
        <D.28951>:
        D.28953 = info->d.array_accessor.method;
        p.102 = p;
        encode_method_ref (acfg, D.28953, p.102, &p);
        <D.28952>:
        <D.28950>:
        <D.28946>:
        goto <D.24239>;
      }
      <D.24255>:
      {
        struct WrapperInfo * info;

        info = mono_marshal_get_wrapper_info (method);
        D.28954 = info == 0B;
        D.28955 = (long int) D.28954;
        D.28956 = __builtin_expect (D.28955, 0);
        if (D.28956 != 0) goto <D.28957>; else goto <D.28958>;
        <D.28957>:
        monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "aot-compiler.c", 2647, "info");
        <D.28958>:
        D.28959 = info->subtype;
        D.28960 = (int) D.28959;
        p.102 = p;
        encode_value (D.28960, p.102, &p);
        D.28959 = info->subtype;
        if (D.28959 == 15) goto <D.28961>; else goto <D.28962>;
        <D.28961>:
        p.102 = p;
        D.28963 = method->name;
        strcpy (p.102, D.28963);
        D.28963 = method->name;
        D.28964 = __strlen_g (D.28963);
        D.28965 = D.28964 + 1;
        p.102 = p;
        p.103 = p.102 + D.28965;
        p = p.103;
        goto <D.28967>;
        <D.28962>:
        D.28959 = info->subtype;
        if (D.28959 == 16) goto <D.28968>; else goto <D.28969>;
        <D.28968>:
        D.28970 = info->d.managed_to_native.method;
        p.102 = p;
        encode_method_ref (acfg, D.28970, p.102, &p);
        goto <D.28971>;
        <D.28969>:
        D.28959 = info->subtype;
        D.28972 = D.28959 != 0;
        D.28973 = (long int) D.28972;
        D.28974 = __builtin_expect (D.28973, 0);
        if (D.28974 != 0) goto <D.28975>; else goto <D.28976>;
        <D.28975>:
        monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "aot-compiler.c", 2655, "info->subtype == WRAPPER_SUBTYPE_NONE");
        <D.28976>:
        D.28970 = info->d.managed_to_native.method;
        p.102 = p;
        encode_method_ref (acfg, D.28970, p.102, &p);
        <D.28971>:
        <D.28967>:
        goto <D.24239>;
      }
      <D.24257>:
      {
        struct MonoMethod * m;

        m = mono_marshal_method_from_wrapper (method);
        D.28977 = m == 0B;
        D.28978 = (long int) D.28977;
        D.28979 = __builtin_expect (D.28978, 0);
        if (D.28979 != 0) goto <D.28980>; else goto <D.28981>;
        <D.28980>:
        monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "aot-compiler.c", 2664, "m");
        <D.28981>:
        D.28982 = m == method;
        D.28983 = (long int) D.28982;
        D.28984 = __builtin_expect (D.28983, 0);
        if (D.28984 != 0) goto <D.28985>; else goto <D.28986>;
        <D.28985>:
        monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "aot-compiler.c", 2665, "m != method");
        <D.28986>:
        p.102 = p;
        encode_method_ref (acfg, m, p.102, &p);
        goto <D.24239>;
      }
      <D.24259>:
      {
        struct WrapperInfo * info;

        info = mono_marshal_get_wrapper_info (method);
        D.28987 = info == 0B;
        D.28988 = (long int) D.28987;
        D.28989 = __builtin_expect (D.28988, 0);
        if (D.28989 != 0) goto <D.28990>; else goto <D.28991>;
        <D.28990>:
        monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "aot-compiler.c", 2672, "info");
        <D.28991>:
        D.28992 = info->subtype;
        D.28993 = (int) D.28992;
        p.102 = p;
        encode_value (D.28993, p.102, &p);
        D.28992 = info->subtype;
        if (D.28992 == 1) goto <D.28994>; else goto <D.28995>;
        <D.28994>:
        D.28996 = info->d.element_addr.rank;
        D.28997 = (int) D.28996;
        p.102 = p;
        encode_value (D.28997, p.102, &p);
        D.28998 = info->d.element_addr.elem_size;
        D.28999 = (int) D.28998;
        p.102 = p;
        encode_value (D.28999, p.102, &p);
        goto <D.29000>;
        <D.28995>:
        D.28992 = info->subtype;
        if (D.28992 == 2) goto <D.29001>; else goto <D.29002>;
        <D.29001>:
        D.29003 = info->d.string_ctor.method;
        p.102 = p;
        encode_method_ref (acfg, D.29003, p.102, &p);
        goto <D.29004>;
        <D.29002>:
        monoeg_assertion_message ("* Assertion: should not be reached at %s:%d\n", "aot-compiler.c", 2681);
        <D.29004>:
        <D.29000>:
        goto <D.24239>;
      }
      <D.24261>:
      {
        struct WrapperInfo * info;

        info = mono_marshal_get_wrapper_info (method);
        D.29005 = info == 0B;
        D.29006 = (long int) D.29005;
        D.29007 = __builtin_expect (D.29006, 0);
        if (D.29007 != 0) goto <D.29008>; else goto <D.29009>;
        <D.29008>:
        monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "aot-compiler.c", 2688, "info");
        <D.29009>:
        D.29010 = info->subtype;
        D.29011 = (int) D.29010;
        p.102 = p;
        encode_value (D.29011, p.102, &p);
        goto <D.24239>;
      }
      <D.24263>:
      {
        struct WrapperInfo * info;

        info = mono_marshal_get_wrapper_info (method);
        D.29012 = info == 0B;
        D.29013 = (long int) D.29012;
        D.29014 = __builtin_expect (D.29013, 0);
        if (D.29014 != 0) goto <D.29015>; else goto <D.29016>;
        <D.29015>:
        monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "aot-compiler.c", 2695, "info");
        <D.29016>:
        D.29017 = info->subtype;
        D.29018 = (int) D.29017;
        p.102 = p;
        encode_value (D.29018, p.102, &p);
        D.29017 = info->subtype;
        D.29019 = D.29017 + 4294967283;
        if (D.29019 <= 1) goto <D.29020>; else goto <D.29021>;
        <D.29020>:
        D.29022 = info->d.runtime_invoke.method;
        p.102 = p;
        encode_method_ref (acfg, D.29022, p.102, &p);
        goto <D.29023>;
        <D.29021>:
        D.29017 = info->subtype;
        if (D.29017 == 11) goto <D.29024>; else goto <D.29025>;
        <D.29024>:
        D.29026 = info->d.runtime_invoke.sig;
        p.102 = p;
        encode_signature (acfg, D.29026, p.102, &p);
        <D.29025>:
        <D.29023>:
        goto <D.24239>;
      }
      <D.24265>:
      <D.24266>:
      <D.24267>:
      D.28899 = BIT_FIELD_REF <*method, 64, 256>;
      D.29027 = D.28899 & 2251799813685248;
      if (D.29027 != 0) goto <D.29028>; else goto <D.29029>;
      <D.29028>:
      p.102 = p;
      encode_value (1, p.102, &p);
      D.28894 = method->klass;
      p.102 = p;
      encode_klass_ref (acfg, D.28894, p.102, &p);
      goto <D.29030>;
      <D.29029>:
      {
        struct MonoMethodSignature * sig;
        struct WrapperInfo * info;

        sig = mono_method_signature (method);
        info = mono_marshal_get_wrapper_info (method);
        p.102 = p;
        encode_value (0, p.102, &p);
        D.28899 = BIT_FIELD_REF <*method, 64, 256>;
        D.28909 = D.28899 & 4467570830351532032;
        if (D.28909 == 144115188075855872) goto <D.29031>; else goto <D.29032>;
        <D.29031>:
        if (info != 0B) goto <D.29034>; else goto <D.29035>;
        <D.29034>:
        D.29036 = info->subtype;
        iftmp.104 = (gint32) D.29036;
        goto <D.29037>;
        <D.29035>:
        iftmp.104 = 0;
        <D.29037>:
        p.102 = p;
        encode_value (iftmp.104, p.102, &p);
        <D.29032>:
        p.102 = p;
        encode_signature (acfg, sig, p.102, &p);
      }
      <D.29030>:
      goto <D.24239>;
      <D.24270>:
      {
        struct WrapperInfo * info;

        info = mono_marshal_get_wrapper_info (method);
        D.29038 = info == 0B;
        D.29039 = (long int) D.29038;
        D.29040 = __builtin_expect (D.29039, 0);
        if (D.29040 != 0) goto <D.29041>; else goto <D.29042>;
        <D.29041>:
        monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "aot-compiler.c", 2724, "info");
        <D.29042>:
        D.29043 = info->d.native_to_managed.method;
        p.102 = p;
        encode_method_ref (acfg, D.29043, p.102, &p);
        D.29044 = info->d.native_to_managed.klass;
        p.102 = p;
        encode_klass_ref (acfg, D.29044, p.102, &p);
        goto <D.24239>;
      }
      <D.24272>:
      monoeg_assertion_message ("* Assertion: should not be reached at %s:%d\n", "aot-compiler.c", 2730);
      <D.24239>:
      goto <D.29045>;
      <D.28911>:
      D.29046 = mono_method_signature (method);
      D.29047 = BIT_FIELD_REF <*D.29046, 64, 64>;
      D.29048 = D.29047 & 64;
      if (D.29048 != 0) goto <D.29049>; else goto <D.29050>;
      <D.29049>:
      D.29051 = acfg->token_info_hash;
      ji = monoeg_g_hash_table_lookup (D.29051, method);
      if (ji != 0B) goto <D.29052>; else goto <D.29053>;
      <D.29052>:
      D.29054 = ji->image;
      image_index = get_image_index (acfg, D.29054);
      D.29055 = image_index > 249;
      D.29056 = (long int) D.29055;
      D.29057 = __builtin_expect (D.29056, 0);
      if (D.29057 != 0) goto <D.29058>; else goto <D.29059>;
      <D.29058>:
      monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "aot-compiler.c", 2741, "image_index < MAX_IMAGE_INDEX");
      <D.29059>:
      token = ji->token;
      p.102 = p;
      encode_value (-33554432, p.102, &p);
      image_index.105 = (int) image_index;
      p.102 = p;
      encode_value (image_index.105, p.102, &p);
      token.106 = (int) token;
      p.102 = p;
      encode_value (token.106, p.102, &p);
      goto <D.29062>;
      <D.29053>:
      {
        struct MonoMethod * declaring;
        struct MonoGenericContext * context;

        context = mono_method_get_context (method);
        D.28899 = BIT_FIELD_REF <*method, 64, 256>;
        D.29027 = D.28899 & 2251799813685248;
        D.29063 = D.29027 == 0;
        D.29064 = (long int) D.29063;
        D.29065 = __builtin_expect (D.29064, 0);
        if (D.29065 != 0) goto <D.29066>; else goto <D.29067>;
        <D.29066>:
        monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "aot-compiler.c", 2751, "method->is_inflated");
        <D.29067>:
        declaring = MEM[(struct MonoMethodInflated *)method].declaring;
        p.102 = p;
        encode_value (-50331648, p.102, &p);
        D.28894 = method->klass;
        p.102 = p;
        encode_klass_ref (acfg, D.28894, p.102, &p);
        D.28894 = method->klass;
        D.28895 = D.28894->image;
        image_index = get_image_index (acfg, D.28895);
        D.29055 = image_index > 249;
        D.29056 = (long int) D.29055;
        D.29057 = __builtin_expect (D.29056, 0);
        if (D.29057 != 0) goto <D.29068>; else goto <D.29069>;
        <D.29068>:
        monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "aot-compiler.c", 2764, "image_index < MAX_IMAGE_INDEX");
        <D.29069>:
        D.29070 = declaring->token;
        D.29071 = D.29070 == 0;
        D.29072 = (long int) D.29071;
        D.29073 = __builtin_expect (D.29072, 0);
        if (D.29073 != 0) goto <D.29074>; else goto <D.29075>;
        <D.29074>:
        monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "aot-compiler.c", 2765, "declaring->token");
        <D.29075>:
        token = declaring->token;
        D.29076 = token >> 24;
        D.29077 = D.29076 != 6;
        D.29078 = (long int) D.29077;
        D.29079 = __builtin_expect (D.29078, 0);
        if (D.29079 != 0) goto <D.29080>; else goto <D.29081>;
        <D.29080>:
        monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "aot-compiler.c", 2767, "mono_metadata_token_table (token) == MONO_TABLE_METHOD");
        <D.29081>:
        image_index.105 = (int) image_index;
        p.102 = p;
        encode_value (image_index.105, p.102, &p);
        token.106 = (int) token;
        p.102 = p;
        encode_value (token.106, p.102, &p);
        p.102 = p;
        encode_generic_context (acfg, context, p.102, &p);
      }
      <D.29062>:
      goto <D.29082>;
      <D.29050>:
      if (token == 0) goto <D.29083>; else goto <D.29084>;
      <D.29083>:
      D.29051 = acfg->token_info_hash;
      ji = monoeg_g_hash_table_lookup (D.29051, method);
      if (ji != 0B) goto <D.29085>; else goto <D.29086>;
      <D.29085>:
      D.29054 = ji->image;
      image_index = get_image_index (acfg, D.29054);
      D.29055 = image_index > 249;
      D.29056 = (long int) D.29055;
      D.29057 = __builtin_expect (D.29056, 0);
      if (D.29057 != 0) goto <D.29087>; else goto <D.29088>;
      <D.29087>:
      monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "aot-compiler.c", 2778, "image_index < MAX_IMAGE_INDEX");
      <D.29088>:
      token = ji->token;
      p.102 = p;
      encode_value (-33554432, p.102, &p);
      image_index.105 = (int) image_index;
      p.102 = p;
      encode_value (image_index.105, p.102, &p);
      token.106 = (int) token;
      p.102 = p;
      encode_value (token.106, p.102, &p);
      goto <D.29089>;
      <D.29086>:
      D.28894 = method->klass;
      D.29090 = D.28894->rank;
      D.29091 = D.29090 == 0;
      D.29092 = (long int) D.29091;
      D.29093 = __builtin_expect (D.29092, 0);
      if (D.29093 != 0) goto <D.29094>; else goto <D.29095>;
      <D.29094>:
      monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "aot-compiler.c", 2786, "method->klass->rank");
      <D.29095>:
      p.102 = p;
      encode_value (-100663296, p.102, &p);
      D.28894 = method->klass;
      p.102 = p;
      encode_klass_ref (acfg, D.28894, p.102, &p);
      D.28963 = method->name;
      D.29098 = strcmp (D.28963, ".ctor");
      if (D.29098 == 0) goto <D.29099>; else goto <D.29096>;
      <D.29099>:
      D.29100 = mono_method_signature (method);
      D.29101 = D.29100->param_count;
      D.28894 = method->klass;
      D.29090 = D.28894->rank;
      D.29102 = (short unsigned int) D.29090;
      if (D.29101 == D.29102) goto <D.29103>; else goto <D.29096>;
      <D.29103>:
      p.102 = p;
      encode_value (0, p.102, &p);
      goto <D.29097>;
      <D.29096>:
      D.28963 = method->name;
      D.29106 = strcmp (D.28963, ".ctor");
      if (D.29106 == 0) goto <D.29107>; else goto <D.29104>;
      <D.29107>:
      D.29108 = mono_method_signature (method);
      D.29109 = D.29108->param_count;
      D.29110 = (int) D.29109;
      D.28894 = method->klass;
      D.29090 = D.28894->rank;
      D.29111 = (int) D.29090;
      D.29112 = D.29111 * 2;
      if (D.29110 == D.29112) goto <D.29113>; else goto <D.29104>;
      <D.29113>:
      p.102 = p;
      encode_value (1, p.102, &p);
      goto <D.29105>;
      <D.29104>:
      D.28963 = method->name;
      D.29114 = strcmp (D.28963, "Get");
      if (D.29114 == 0) goto <D.29115>; else goto <D.29116>;
      <D.29115>:
      p.102 = p;
      encode_value (2, p.102, &p);
      goto <D.29117>;
      <D.29116>:
      D.28963 = method->name;
      D.29118 = strcmp (D.28963, "Address");
      if (D.29118 == 0) goto <D.29119>; else goto <D.29120>;
      <D.29119>:
      p.102 = p;
      encode_value (3, p.102, &p);
      goto <D.29121>;
      <D.29120>:
      D.28963 = method->name;
      D.29122 = strcmp (D.28963, "Set");
      if (D.29122 == 0) goto <D.29123>; else goto <D.29124>;
      <D.29123>:
      p.102 = p;
      encode_value (4, p.102, &p);
      goto <D.29125>;
      <D.29124>:
      monoeg_assertion_message ("* Assertion: should not be reached at %s:%d\n", "aot-compiler.c", 2802);
      <D.29125>:
      <D.29121>:
      <D.29117>:
      <D.29105>:
      <D.29097>:
      <D.29089>:
      goto <D.29126>;
      <D.29084>:
      D.29076 = token >> 24;
      D.29077 = D.29076 != 6;
      D.29078 = (long int) D.29077;
      D.29079 = __builtin_expect (D.29078, 0);
      if (D.29079 != 0) goto <D.29127>; else goto <D.29128>;
      <D.29127>:
      monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "aot-compiler.c", 2805, "mono_metadata_token_table (token) == MONO_TABLE_METHOD");
      <D.29128>:
      if (image_index > 239) goto <D.29129>; else goto <D.29130>;
      <D.29129>:
      p.102 = p;
      encode_value (-117440512, p.102, &p);
      image_index.105 = (int) image_index;
      p.102 = p;
      encode_value (image_index.105, p.102, &p);
      token.106 = (int) token;
      D.29131 = token.106 & 16777215;
      p.102 = p;
      encode_value (D.29131, p.102, &p);
      goto <D.29132>;
      <D.29130>:
      D.29133 = image_index << 24;
      D.29134 = token & 16777215;
      D.29135 = D.29133 | D.29134;
      D.29136 = (int) D.29135;
      p.102 = p;
      encode_value (D.29136, p.102, &p);
      <D.29132>:
      <D.29126>:
      <D.29082>:
      <D.29045>:
      p.102 = p;
      *endbuf = p.102;
    }
  finally
    {
      p = {CLOBBER};
    }
}


encode_signature (struct MonoAotCompile * acfg, struct MonoMethodSignature * sig, guint8 * buf, guint8 * * endbuf)
{
  short unsigned int D.29139;
  long unsigned int D.29142;
  long unsigned int D.29143;
  long unsigned int D.29146;
  <unnamed-unsigned:6> D.29149;
  unsigned int D.29150;
  unsigned int D.29151;
  guint8 * p.107;
  unsigned char D.29153;
  guint8 * p.108;
  int D.29157;
  short unsigned int D.29158;
  int D.29159;
  struct MonoType * D.29160;
  short int D.29161;
  int D.29162;
  struct MonoType * D.29165;
  int D.29166;
  guint8 * p;
  guint32 flags;
  int i;

  try
    {
      p = buf;
      flags = 0;
      D.29139 = sig->generic_param_count;
      if (D.29139 != 0) goto <D.29140>; else goto <D.29141>;
      <D.29140>:
      flags = flags | 16;
      <D.29141>:
      D.29142 = BIT_FIELD_REF <*sig, 64, 64>;
      D.29143 = D.29142 & 512;
      if (D.29143 != 0) goto <D.29144>; else goto <D.29145>;
      <D.29144>:
      flags = flags | 32;
      <D.29145>:
      D.29142 = BIT_FIELD_REF <*sig, 64, 64>;
      D.29146 = D.29142 & 256;
      if (D.29146 != 0) goto <D.29147>; else goto <D.29148>;
      <D.29147>:
      flags = flags | 64;
      <D.29148>:
      D.29149 = sig->call_convention;
      D.29150 = (unsigned int) D.29149;
      D.29151 = D.29150 & 15;
      flags = D.29151 | flags;
      p.107 = p;
      D.29153 = (unsigned char) flags;
      *p.107 = D.29153;
      p.107 = p;
      p.108 = p.107 + 1;
      p = p.108;
      D.29139 = sig->generic_param_count;
      if (D.29139 != 0) goto <D.29155>; else goto <D.29156>;
      <D.29155>:
      D.29139 = sig->generic_param_count;
      D.29157 = (int) D.29139;
      p.107 = p;
      encode_value (D.29157, p.107, &p);
      <D.29156>:
      D.29158 = sig->param_count;
      D.29159 = (int) D.29158;
      p.107 = p;
      encode_value (D.29159, p.107, &p);
      D.29160 = sig->ret;
      p.107 = p;
      encode_type (acfg, D.29160, p.107, &p);
      i = 0;
      goto <D.24223>;
      <D.24222>:
      D.29161 = sig->sentinelpos;
      D.29162 = (int) D.29161;
      if (D.29162 == i) goto <D.29163>; else goto <D.29164>;
      <D.29163>:
      p.107 = p;
      *p.107 = 65;
      p.107 = p;
      p.108 = p.107 + 1;
      p = p.108;
      <D.29164>:
      D.29165 = sig->params[i];
      p.107 = p;
      encode_type (acfg, D.29165, p.107, &p);
      i = i + 1;
      <D.24223>:
      D.29158 = sig->param_count;
      D.29166 = (int) D.29158;
      if (D.29166 > i) goto <D.24222>; else goto <D.24224>;
      <D.24224>:
      p.107 = p;
      *endbuf = p.107;
    }
  finally
    {
      p = {CLOBBER};
    }
}


encode_generic_context (struct MonoAotCompile * acfg, struct MonoGenericContext * context, guint8 * buf, guint8 * * endbuf)
{
  long unsigned int D.29169;
  long unsigned int D.29170;
  _Bool D.29171;
  long int D.29172;
  long int D.29173;
  guint8 * p.109;
  guint8 * p;
  struct MonoGenericInst * inst;

  try
    {
      p = buf;
      inst = context->class_inst;
      if (inst != 0B) goto <D.29167>; else goto <D.29168>;
      <D.29167>:
      D.29169 = BIT_FIELD_REF <*inst, 64, 0>;
      D.29170 = D.29169 & 4294966272;
      D.29171 = D.29170 == 0;
      D.29172 = (long int) D.29171;
      D.29173 = __builtin_expect (D.29172, 0);
      if (D.29173 != 0) goto <D.29174>; else goto <D.29175>;
      <D.29174>:
      monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "aot-compiler.c", 2425, "inst->type_argc");
      <D.29175>:
      p.109 = p;
      encode_ginst (acfg, inst, p.109, &p);
      goto <D.29177>;
      <D.29168>:
      p.109 = p;
      encode_value (0, p.109, &p);
      <D.29177>:
      inst = context->method_inst;
      if (inst != 0B) goto <D.29178>; else goto <D.29179>;
      <D.29178>:
      D.29169 = BIT_FIELD_REF <*inst, 64, 0>;
      D.29170 = D.29169 & 4294966272;
      D.29171 = D.29170 == 0;
      D.29172 = (long int) D.29171;
      D.29173 = __builtin_expect (D.29172, 0);
      if (D.29173 != 0) goto <D.29180>; else goto <D.29181>;
      <D.29180>:
      monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "aot-compiler.c", 2432, "inst->type_argc");
      <D.29181>:
      p.109 = p;
      encode_ginst (acfg, inst, p.109, &p);
      goto <D.29182>;
      <D.29179>:
      p.109 = p;
      encode_value (0, p.109, &p);
      <D.29182>:
      p.109 = p;
      *endbuf = p.109;
    }
  finally
    {
      p = {CLOBBER};
    }
}


encode_type (struct MonoAotCompile * acfg, struct MonoType * t, guint8 * buf, guint8 * * endbuf)
{
  long unsigned int D.29183;
  long unsigned int D.29184;
  _Bool D.29185;
  long int D.29186;
  long int D.29187;
  long unsigned int D.29190;
  guint8 * p.110;
  guint8 * p.111;
  long unsigned int D.29195;
  unsigned char D.29198;
  int D.29199;
  struct MonoClass * D.29200;
  struct MonoClass * D.29201;
  struct MonoType * D.29202;
  struct MonoGenericClass * D.29203;
  struct MonoClass * D.29204;
  unsigned char D.29205;
  int D.29206;
  unsigned char D.29207;
  int D.29208;
  int * D.29209;
  long unsigned int D.29210;
  long unsigned int D.29211;
  int * D.29212;
  int D.29213;
  int D.29214;
  unsigned char D.29215;
  int D.29216;
  int * D.29217;
  int * D.29218;
  int D.29219;
  int D.29220;
  struct MonoClass * D.29221;
  guint8 * p;

  try
    {
      p = buf;
      D.29183 = BIT_FIELD_REF <*t, 64, 64>;
      D.29184 = D.29183 & 1082331758592;
      D.29185 = D.29184 != 0;
      D.29186 = (long int) D.29185;
      D.29187 = __builtin_expect (D.29186, 0);
      if (D.29187 != 0) goto <D.29188>; else goto <D.29189>;
      <D.29188>:
      monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "aot-compiler.c", 2445, "t->num_mods == 0");
      <D.29189>:
      D.29183 = BIT_FIELD_REF <*t, 64, 64>;
      D.29190 = D.29183 & 4294967296;
      if (D.29190 != 0) goto <D.29191>; else goto <D.29192>;
      <D.29191>:
      p.110 = p;
      *p.110 = 69;
      p.110 = p;
      p.111 = p.110 + 1;
      p = p.111;
      <D.29192>:
      D.29183 = BIT_FIELD_REF <*t, 64, 64>;
      D.29195 = D.29183 & 8589934592;
      if (D.29195 != 0) goto <D.29196>; else goto <D.29197>;
      <D.29196>:
      p.110 = p;
      *p.110 = 16;
      p.110 = p;
      p.111 = p.110 + 1;
      p = p.111;
      <D.29197>:
      p.110 = p;
      D.29198 = t->type;
      *p.110 = D.29198;
      p.110 = p;
      p.111 = p.110 + 1;
      p = p.111;
      D.29198 = t->type;
      D.29199 = (int) D.29198;
      switch (D.29199) <default: <D.24212>, case 1: <D.24175>, case 2: <D.24176>, case 3: <D.24177>, case 4: <D.24178>, case 5: <D.24179>, case 6: <D.24180>, case 7: <D.24181>, case 8: <D.24182>, case 9: <D.24183>, case 10: <D.24184>, case 11: <D.24185>, case 12: <D.24186>, case 13: <D.24187>, case 14: <D.24190>, case 15: <D.24197>, case 17: <D.24194>, case 18: <D.24195>, case 19: <D.24210>, case 20: <D.24201>, case 21: <D.24198>, case 22: <D.24192>, case 24: <D.24188>, case 25: <D.24189>, case 28: <D.24191>, case 29: <D.24196>, case 30: <D.24211>>
      <D.24175>:
      <D.24176>:
      <D.24177>:
      <D.24178>:
      <D.24179>:
      <D.24180>:
      <D.24181>:
      <D.24182>:
      <D.24183>:
      <D.24184>:
      <D.24185>:
      <D.24186>:
      <D.24187>:
      <D.24188>:
      <D.24189>:
      <D.24190>:
      <D.24191>:
      <D.24192>:
      goto <D.24193>;
      <D.24194>:
      <D.24195>:
      D.29200 = mono_class_from_mono_type (t);
      p.110 = p;
      encode_klass_ref (acfg, D.29200, p.110, &p);
      goto <D.24193>;
      <D.24196>:
      D.29201 = t->data.klass;
      p.110 = p;
      encode_klass_ref (acfg, D.29201, p.110, &p);
      goto <D.24193>;
      <D.24197>:
      D.29202 = t->data.type;
      p.110 = p;
      encode_type (acfg, D.29202, p.110, &p);
      goto <D.24193>;
      <D.24198>:
      {
        struct MonoClass * gclass;
        struct MonoGenericInst * inst;

        D.29203 = t->data.generic_class;
        gclass = D.29203->container_class;
        D.29203 = t->data.generic_class;
        inst = D.29203->context.class_inst;
        p.110 = p;
        encode_klass_ref (acfg, gclass, p.110, &p);
        p.110 = p;
        encode_ginst (acfg, inst, p.110, &p);
        goto <D.24193>;
      }
      <D.24201>:
      {
        struct MonoArrayType * array;
        int i;

        array = t->data.array;
        D.29204 = array->eklass;
        p.110 = p;
        encode_klass_ref (acfg, D.29204, p.110, &p);
        D.29205 = array->rank;
        D.29206 = (int) D.29205;
        p.110 = p;
        encode_value (D.29206, p.110, &p);
        D.29207 = array->numsizes;
        D.29208 = (int) D.29207;
        p.110 = p;
        encode_value (D.29208, p.110, &p);
        i = 0;
        goto <D.24205>;
        <D.24204>:
        D.29209 = array->sizes;
        D.29210 = (long unsigned int) i;
        D.29211 = D.29210 * 4;
        D.29212 = D.29209 + D.29211;
        D.29213 = *D.29212;
        p.110 = p;
        encode_value (D.29213, p.110, &p);
        i = i + 1;
        <D.24205>:
        D.29207 = array->numsizes;
        D.29214 = (int) D.29207;
        if (D.29214 > i) goto <D.24204>; else goto <D.24206>;
        <D.24206>:
        D.29215 = array->numlobounds;
        D.29216 = (int) D.29215;
        p.110 = p;
        encode_value (D.29216, p.110, &p);
        i = 0;
        goto <D.24208>;
        <D.24207>:
        D.29217 = array->lobounds;
        D.29210 = (long unsigned int) i;
        D.29211 = D.29210 * 4;
        D.29218 = D.29217 + D.29211;
        D.29219 = *D.29218;
        p.110 = p;
        encode_value (D.29219, p.110, &p);
        i = i + 1;
        <D.24208>:
        D.29215 = array->numlobounds;
        D.29220 = (int) D.29215;
        if (D.29220 > i) goto <D.24207>; else goto <D.24209>;
        <D.24209>:
        goto <D.24193>;
      }
      <D.24210>:
      <D.24211>:
      D.29221 = mono_class_from_mono_type (t);
      p.110 = p;
      encode_klass_ref (acfg, D.29221, p.110, &p);
      goto <D.24193>;
      <D.24212>:
      monoeg_assertion_message ("* Assertion: should not be reached at %s:%d\n", "aot-compiler.c", 2518);
      <D.24193>:
      p.110 = p;
      *endbuf = p.110;
    }
  finally
    {
      p = {CLOBBER};
    }
}


encode_value (gint32 value, guint8 * buf, guint8 * * endbuf)
{
  unsigned int value.112;
  guint8 * p.113;
  unsigned char D.29227;
  int D.29231;
  signed char D.29232;
  signed char D.29233;
  unsigned char D.29234;
  guint8 * D.29235;
  int D.29239;
  signed char D.29240;
  signed char D.29241;
  unsigned char D.29242;
  int D.29243;
  unsigned char D.29244;
  guint8 * D.29245;
  unsigned char D.29246;
  guint8 * D.29247;
  unsigned int D.29249;
  unsigned char D.29250;
  guint8 * D.29251;
  guint8 * p;

  p = buf;
  value.112 = (unsigned int) value;
  if (value.112 <= 127) goto <D.29224>; else goto <D.29225>;
  <D.29224>:
  p.113 = p;
  p = p.113 + 1;
  D.29227 = (unsigned char) value;
  *p.113 = D.29227;
  goto <D.29228>;
  <D.29225>:
  value.112 = (unsigned int) value;
  if (value.112 <= 16383) goto <D.29229>; else goto <D.29230>;
  <D.29229>:
  D.29231 = value >> 8;
  D.29232 = (signed char) D.29231;
  D.29233 = D.29232 | -128;
  D.29234 = (unsigned char) D.29233;
  *p = D.29234;
  D.29235 = p + 1;
  D.29227 = (unsigned char) value;
  *D.29235 = D.29227;
  p = p + 2;
  goto <D.29236>;
  <D.29230>:
  value.112 = (unsigned int) value;
  if (value.112 <= 536870911) goto <D.29237>; else goto <D.29238>;
  <D.29237>:
  D.29239 = value >> 24;
  D.29240 = (signed char) D.29239;
  D.29241 = D.29240 | -64;
  D.29242 = (unsigned char) D.29241;
  *p = D.29242;
  D.29235 = p + 1;
  D.29243 = value >> 16;
  D.29244 = (unsigned char) D.29243;
  *D.29235 = D.29244;
  D.29245 = p + 2;
  D.29231 = value >> 8;
  D.29246 = (unsigned char) D.29231;
  *D.29245 = D.29246;
  D.29247 = p + 3;
  D.29227 = (unsigned char) value;
  *D.29247 = D.29227;
  p = p + 4;
  goto <D.29248>;
  <D.29238>:
  *p = 255;
  D.29235 = p + 1;
  value.112 = (unsigned int) value;
  D.29249 = value.112 >> 24;
  D.29250 = (unsigned char) D.29249;
  *D.29235 = D.29250;
  D.29245 = p + 2;
  D.29243 = value >> 16;
  D.29244 = (unsigned char) D.29243;
  *D.29245 = D.29244;
  D.29247 = p + 3;
  D.29231 = value >> 8;
  D.29246 = (unsigned char) D.29231;
  *D.29247 = D.29246;
  D.29251 = p + 4;
  D.29227 = (unsigned char) value;
  *D.29251 = D.29227;
  p = p + 5;
  <D.29248>:
  <D.29236>:
  <D.29228>:
  if (endbuf != 0B) goto <D.29252>; else goto <D.29253>;
  <D.29252>:
  *endbuf = p;
  <D.29253>:
}


encode_patch_list (struct MonoAotCompile * acfg, struct GPtrArray * patches, int n_patches, int first_got_offset, guint8 * buf, guint8 * * endbuf)
{
  guint8 * p.114;
  void * * D.29255;
  long unsigned int D.29256;
  long unsigned int D.29257;
  void * * D.29258;
  <unnamed type> D.29261;
  int offset.115;
  unsigned int D.29264;
  guint8 * p;
  guint32 pindex;
  guint32 offset;
  struct MonoJumpInfo * patch_info;

  try
    {
      p = buf;
      p.114 = p;
      encode_value (n_patches, p.114, &p);
      pindex = 0;
      goto <D.24918>;
      <D.24917>:
      D.29255 = patches->pdata;
      D.29256 = (long unsigned int) pindex;
      D.29257 = D.29256 * 8;
      D.29258 = D.29255 + D.29257;
      patch_info = *D.29258;
      D.29261 = patch_info->type;
      if (D.29261 == 51) goto <D.29259>; else goto <D.29262>;
      <D.29262>:
      D.29261 = patch_info->type;
      if (D.29261 == 0) goto <D.29259>; else goto <D.29260>;
      <D.29259>:
      // predicted unlikely by continue predictor.
      goto <D.24916>;
      <D.29260>:
      offset = get_got_offset (acfg, patch_info);
      offset.115 = (int) offset;
      p.114 = p;
      encode_value (offset.115, p.114, &p);
      <D.24916>:
      pindex = pindex + 1;
      <D.24918>:
      D.29264 = patches->len;
      if (D.29264 > pindex) goto <D.24917>; else goto <D.24919>;
      <D.24919>:
      p.114 = p;
      *endbuf = p.114;
    }
  finally
    {
      p = {CLOBBER};
    }
}


add_to_blob (struct MonoAotCompile * acfg, const guint8 * data, guint32 data_len)
{
  unsigned int D.29265;
  struct MonoDynamicStream * D.29268;
  guint32 D.29269;

  D.29265 = acfg->blob.alloc_size;
  if (D.29265 == 0) goto <D.29266>; else goto <D.29267>;
  <D.29266>:
  D.29268 = &acfg->blob;
  stream_init (D.29268);
  <D.29267>:
  D.29268 = &acfg->blob;
  D.29269 = add_stream_data (D.29268, data, data_len);
  return D.29269;
}


stream_init (struct MonoDynamicStream * sh)
{
  void * D.29271;
  char * D.29272;
  unsigned int D.29273;
  unsigned int D.29274;

  sh->index = 0;
  sh->alloc_size = 4096;
  D.29271 = monoeg_malloc (4096);
  sh->data = D.29271;
  D.29272 = sh->data;
  *D.29272 = 0;
  D.29273 = sh->index;
  D.29274 = D.29273 + 1;
  sh->index = D.29274;
}


add_stream_data (struct MonoDynamicStream * stream, const char * data, guint32 len)
{
  unsigned int D.29275;
  unsigned int D.29276;
  int D.29277;
  char * D.29278;
  sizetype D.29279;
  char * D.29280;
  long unsigned int D.29281;
  guint32 D.29282;
  guint32 idx;

  D.29275 = stream->index;
  D.29276 = D.29275 + len;
  D.29277 = (int) D.29276;
  make_room_in_stream (stream, D.29277);
  D.29278 = stream->data;
  D.29275 = stream->index;
  D.29279 = (sizetype) D.29275;
  D.29280 = D.29278 + D.29279;
  D.29281 = (long unsigned int) len;
  memcpy (D.29280, data, D.29281);
  idx = stream->index;
  D.29275 = stream->index;
  D.29276 = D.29275 + len;
  stream->index = D.29276;
  D.29282 = idx;
  return D.29282;
}


make_room_in_stream (struct MonoDynamicStream * stream, int size)
{
  unsigned int D.29284;
  unsigned int size.116;
  unsigned int D.29291;
  char * D.29292;
  long unsigned int D.29293;
  void * D.29294;

  D.29284 = stream->alloc_size;
  size.116 = (unsigned int) size;
  if (D.29284 >= size.116) goto <D.29286>; else goto <D.29287>;
  <D.29286>:
  return;
  <D.29287>:
  goto <D.24037>;
  <D.24036>:
  D.29284 = stream->alloc_size;
  if (D.29284 <= 4095) goto <D.29288>; else goto <D.29289>;
  <D.29288>:
  stream->alloc_size = 4096;
  goto <D.29290>;
  <D.29289>:
  D.29284 = stream->alloc_size;
  D.29291 = D.29284 * 2;
  stream->alloc_size = D.29291;
  <D.29290>:
  <D.24037>:
  D.29284 = stream->alloc_size;
  size.116 = (unsigned int) size;
  if (D.29284 <= size.116) goto <D.24036>; else goto <D.24038>;
  <D.24038>:
  D.29292 = stream->data;
  D.29284 = stream->alloc_size;
  D.29293 = (long unsigned int) D.29284;
  D.29294 = monoeg_realloc (D.29292, D.29293);
  stream->data = D.29294;
}


emit_offset_table (struct MonoAotCompile * acfg, int noffsets, int group_size, gint32 * offsets)
{
  int D.29296;
  int D.29297;
  long unsigned int D.29298;
  long unsigned int D.29299;
  long unsigned int D.29300;
  int D.29301;
  int D.29304;
  long unsigned int D.29305;
  long unsigned int D.29306;
  guint32 * D.29307;
  guint8 * p.117;
  long int p.118;
  long int buf.119;
  long int D.29311;
  unsigned int D.29312;
  long unsigned int D.29313;
  long unsigned int D.29314;
  gint32 * D.29315;
  int D.29316;
  int D.29318;
  sizetype D.29322;
  guint32 * D.29323;
  unsigned int D.29324;
  guint32 * D.29328;
  unsigned int D.29329;
  int D.29330;
  int D.29332;
  guint32 D.29333;
  int D.29334;
  int D.29335;
  gint32 current_offset;
  int i;
  int buf_size;
  int ngroups;
  int index_entry_size;
  guint8 * p;
  guint8 * buf;
  guint32 * index_offsets;

  try
    {
      D.29296 = group_size + -1;
      D.29297 = D.29296 + noffsets;
      ngroups = D.29297 / group_size;
      D.29298 = (long unsigned int) ngroups;
      D.29299 = D.29298 * 4;
      index_offsets = monoeg_malloc0 (D.29299);
      buf_size = noffsets * 4;
      D.29300 = (long unsigned int) buf_size;
      buf = monoeg_malloc0 (D.29300);
      p = buf;
      current_offset = 0;
      i = 0;
      goto <D.24073>;
      <D.24072>:
      D.29301 = i % group_size;
      if (D.29301 == 0) goto <D.29302>; else goto <D.29303>;
      <D.29302>:
      D.29304 = i / group_size;
      D.29305 = (long unsigned int) D.29304;
      D.29306 = D.29305 * 4;
      D.29307 = index_offsets + D.29306;
      p.117 = p;
      p.118 = (long int) p.117;
      buf.119 = (long int) buf;
      D.29311 = p.118 - buf.119;
      D.29312 = (unsigned int) D.29311;
      *D.29307 = D.29312;
      D.29313 = (long unsigned int) i;
      D.29314 = D.29313 * 4;
      D.29315 = offsets + D.29314;
      D.29316 = *D.29315;
      p.117 = p;
      encode_value (D.29316, p.117, &p);
      goto <D.29317>;
      <D.29303>:
      D.29313 = (long unsigned int) i;
      D.29314 = D.29313 * 4;
      D.29315 = offsets + D.29314;
      D.29316 = *D.29315;
      D.29318 = D.29316 - current_offset;
      p.117 = p;
      encode_value (D.29318, p.117, &p);
      <D.29317>:
      D.29313 = (long unsigned int) i;
      D.29314 = D.29313 * 4;
      D.29315 = offsets + D.29314;
      current_offset = *D.29315;
      i = i + 1;
      <D.24073>:
      if (i < noffsets) goto <D.24072>; else goto <D.24074>;
      <D.24074>:
      if (ngroups != 0) goto <D.29321>; else goto <D.29319>;
      <D.29321>:
      D.29298 = (long unsigned int) ngroups;
      D.29299 = D.29298 * 4;
      D.29322 = D.29299 + 18446744073709551612;
      D.29323 = index_offsets + D.29322;
      D.29324 = *D.29323;
      if (D.29324 <= 64999) goto <D.29325>; else goto <D.29319>;
      <D.29325>:
      index_entry_size = 2;
      goto <D.29320>;
      <D.29319>:
      index_entry_size = 4;
      <D.29320>:
      emit_int32 (acfg, noffsets);
      emit_int32 (acfg, group_size);
      emit_int32 (acfg, ngroups);
      emit_int32 (acfg, index_entry_size);
      i = 0;
      goto <D.24076>;
      <D.24075>:
      if (index_entry_size == 2) goto <D.29326>; else goto <D.29327>;
      <D.29326>:
      D.29313 = (long unsigned int) i;
      D.29314 = D.29313 * 4;
      D.29328 = index_offsets + D.29314;
      D.29329 = *D.29328;
      D.29330 = (int) D.29329;
      emit_int16 (acfg, D.29330);
      goto <D.29331>;
      <D.29327>:
      D.29313 = (long unsigned int) i;
      D.29314 = D.29313 * 4;
      D.29328 = index_offsets + D.29314;
      D.29329 = *D.29328;
      D.29330 = (int) D.29329;
      emit_int32 (acfg, D.29330);
      <D.29331>:
      i = i + 1;
      <D.24076>:
      if (i < ngroups) goto <D.24075>; else goto <D.24077>;
      <D.24077>:
      p.117 = p;
      p.118 = (long int) p.117;
      buf.119 = (long int) buf;
      D.29311 = p.118 - buf.119;
      D.29332 = (int) D.29311;
      emit_bytes (acfg, buf, D.29332);
      p.117 = p;
      p.118 = (long int) p.117;
      buf.119 = (long int) buf;
      D.29311 = p.118 - buf.119;
      D.29332 = (int) D.29311;
      D.29334 = ngroups * 4;
      D.29335 = D.29332 + D.29334;
      D.29333 = (guint32) D.29335;
      return D.29333;
    }
  finally
    {
      p = {CLOBBER};
    }
}


emit_int16 (struct MonoAotCompile * acfg, int value)
{
  struct MonoImageWriter * D.29338;

  D.29338 = acfg->w;
  img_writer_emit_int16 (D.29338, value);
}


emit_extra_methods (struct MonoAotCompile * acfg)
{
  struct GPtrArray * D.29339;
  unsigned int D.29340;
  long unsigned int D.29341;
  long unsigned int D.29342;
  void * * D.29343;
  long unsigned int D.29344;
  long unsigned int D.29345;
  void * * D.29346;
  struct GHashTable * D.29347;
  long unsigned int D.29350;
  guint8 * p.120;
  long int p.121;
  long int buf.122;
  long int D.29354;
  long int D.29355;
  _Bool D.29356;
  long int D.29357;
  long int D.29358;
  long unsigned int D.29361;
  guint32 * D.29362;
  unsigned int D.29363;
  unsigned int D.29364;
  unsigned int i.123;
  double D.29366;
  double D.29367;
  int D.29368;
  unsigned int D.29369;
  unsigned int D.29370;
  unsigned int table_size.124;
  long unsigned int D.29372;
  long unsigned int D.29373;
  unsigned int D.29376;
  unsigned int table_size.125;
  long unsigned int D.29378;
  long unsigned int D.29379;
  int * D.29380;
  int D.29381;
  int D.29382;
  struct MonoMemPool * D.29383;
  void * * D.29384;
  long unsigned int D.29385;
  void * * D.29386;
  struct HashEntry * D.29390;
  unsigned int D.29391;
  void * * D.29392;
  unsigned int D.29396;
  int D.29397;
  unsigned int D.29398;
  int D.29399;
  struct HashEntry * D.29400;
  unsigned int D.29403;
  int D.29404;
  int D.29406;
  unsigned int D.29407;
  int D.29408;
  unsigned int D.29409;
  int D.29410;
  int i;
  int table_size;
  int buf_size;
  char symbol[256];
  guint8 * p;
  guint8 * buf;
  guint32 * info_offsets;
  guint32 hash;
  struct GPtrArray * table;
  struct HashEntry * entry;
  struct HashEntry * new_entry;
  int nmethods;
  int max_chain_length;
  int * chain_lengths;

  try
    {
      D.29339 = acfg->extra_methods;
      D.29340 = D.29339->len;
      D.29341 = (long unsigned int) D.29340;
      D.29342 = D.29341 * 4;
      info_offsets = monoeg_malloc0 (D.29342);
      nmethods = 0;
      i = 0;
      goto <D.25512>;
      <D.25511>:
      {
        struct MonoMethod * method;
        struct MonoCompile * cfg;

        D.29339 = acfg->extra_methods;
        D.29343 = D.29339->pdata;
        D.29344 = (long unsigned int) i;
        D.29345 = D.29344 * 8;
        D.29346 = D.29343 + D.29345;
        method = *D.29346;
        D.29347 = acfg->method_to_cfg;
        cfg = monoeg_g_hash_table_lookup (D.29347, method);
        if (cfg == 0B) goto <D.29348>; else goto <D.29349>;
        <D.29348>:
        // predicted unlikely by continue predictor.
        goto <D.25510>;
        <D.29349>:
        buf_size = 10240;
        D.29350 = (long unsigned int) buf_size;
        buf = monoeg_malloc (D.29350);
        p = buf;
        nmethods = nmethods + 1;
        method = cfg->method_to_register;
        p.120 = p;
        encode_method_ref (acfg, method, p.120, &p);
        p.120 = p;
        p.121 = (long int) p.120;
        buf.122 = (long int) buf;
        D.29354 = p.121 - buf.122;
        D.29355 = (long int) buf_size;
        D.29356 = D.29354 >= D.29355;
        D.29357 = (long int) D.29356;
        D.29358 = __builtin_expect (D.29357, 0);
        if (D.29358 != 0) goto <D.29359>; else goto <D.29360>;
        <D.29359>:
        monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "aot-compiler.c", 7508, "(p - buf) < buf_size");
        <D.29360>:
        D.29344 = (long unsigned int) i;
        D.29361 = D.29344 * 4;
        D.29362 = info_offsets + D.29361;
        p.120 = p;
        p.121 = (long int) p.120;
        buf.122 = (long int) buf;
        D.29354 = p.121 - buf.122;
        D.29363 = (unsigned int) D.29354;
        D.29364 = add_to_blob (acfg, buf, D.29363);
        *D.29362 = D.29364;
        monoeg_g_free (buf);
      }
      <D.25510>:
      i = i + 1;
      <D.25512>:
      D.29339 = acfg->extra_methods;
      D.29340 = D.29339->len;
      i.123 = (unsigned int) i;
      if (D.29340 > i.123) goto <D.25511>; else goto <D.25513>;
      <D.25513>:
      D.29366 = (double) nmethods;
      D.29367 = D.29366 * 1.5e+0;
      D.29368 = (int) D.29367;
      D.29369 = (unsigned int) D.29368;
      D.29370 = monoeg_g_spaced_primes_closest (D.29369);
      table_size = (int) D.29370;
      table_size.124 = (unsigned int) table_size;
      table = monoeg_g_ptr_array_sized_new (table_size.124);
      i = 0;
      goto <D.25515>;
      <D.25514>:
      monoeg_g_ptr_array_add (table, 0B);
      i = i + 1;
      <D.25515>:
      if (i < table_size) goto <D.25514>; else goto <D.25516>;
      <D.25516>:
      D.29372 = (long unsigned int) table_size;
      D.29373 = D.29372 * 4;
      chain_lengths = monoeg_malloc0 (D.29373);
      max_chain_length = 0;
      i = 0;
      goto <D.25526>;
      <D.25525>:
      {
        struct MonoMethod * method;
        struct MonoCompile * cfg;
        guint32 key;
        guint32 value;

        D.29339 = acfg->extra_methods;
        D.29343 = D.29339->pdata;
        D.29344 = (long unsigned int) i;
        D.29345 = D.29344 * 8;
        D.29346 = D.29343 + D.29345;
        method = *D.29346;
        D.29347 = acfg->method_to_cfg;
        cfg = monoeg_g_hash_table_lookup (D.29347, method);
        if (cfg == 0B) goto <D.29374>; else goto <D.29375>;
        <D.29374>:
        // predicted unlikely by continue predictor.
        goto <D.25521>;
        <D.29375>:
        D.29344 = (long unsigned int) i;
        D.29361 = D.29344 * 4;
        D.29362 = info_offsets + D.29361;
        key = *D.29362;
        value = get_method_index (acfg, method);
        D.29376 = mono_aot_method_hash (method);
        table_size.125 = (unsigned int) table_size;
        hash = D.29376 % table_size.125;
        D.29378 = (long unsigned int) hash;
        D.29379 = D.29378 * 4;
        D.29380 = chain_lengths + D.29379;
        D.29381 = *D.29380;
        D.29382 = D.29381 + 1;
        *D.29380 = D.29382;
        D.29378 = (long unsigned int) hash;
        D.29379 = D.29378 * 4;
        D.29380 = chain_lengths + D.29379;
        D.29381 = *D.29380;
        max_chain_length = MAX_EXPR <D.29381, max_chain_length>;
        D.29383 = acfg->mempool;
        new_entry = mono_mempool_alloc0 (D.29383, 24);
        new_entry->key = key;
        new_entry->value = value;
        D.29384 = table->pdata;
        D.29378 = (long unsigned int) hash;
        D.29385 = D.29378 * 8;
        D.29386 = D.29384 + D.29385;
        entry = *D.29386;
        if (entry == 0B) goto <D.29387>; else goto <D.29388>;
        <D.29387>:
        new_entry->index = hash;
        D.29384 = table->pdata;
        D.29378 = (long unsigned int) hash;
        D.29385 = D.29378 * 8;
        D.29386 = D.29384 + D.29385;
        *D.29386 = new_entry;
        goto <D.29389>;
        <D.29388>:
        goto <D.25523>;
        <D.25522>:
        entry = entry->next;
        <D.25523>:
        D.29390 = entry->next;
        if (D.29390 != 0B) goto <D.25522>; else goto <D.25524>;
        <D.25524>:
        entry->next = new_entry;
        D.29391 = table->len;
        new_entry->index = D.29391;
        monoeg_g_ptr_array_add (table, new_entry);
        <D.29389>:
      }
      <D.25521>:
      i = i + 1;
      <D.25526>:
      D.29339 = acfg->extra_methods;
      D.29340 = D.29339->len;
      i.123 = (unsigned int) i;
      if (D.29340 > i.123) goto <D.25525>; else goto <D.25527>;
      <D.25527>:
      sprintf (&symbol, "extra_method_table");
      emit_section_change (acfg, ".rodata", 0);
      emit_alignment (acfg, 8);
      emit_label (acfg, &symbol);
      emit_int32 (acfg, table_size);
      i = 0;
      goto <D.25530>;
      <D.25529>:
      {
        struct HashEntry * entry;

        D.29384 = table->pdata;
        D.29344 = (long unsigned int) i;
        D.29345 = D.29344 * 8;
        D.29392 = D.29384 + D.29345;
        entry = *D.29392;
        if (entry == 0B) goto <D.29393>; else goto <D.29394>;
        <D.29393>:
        emit_int32 (acfg, 0);
        emit_int32 (acfg, 0);
        emit_int32 (acfg, 0);
        goto <D.29395>;
        <D.29394>:
        D.29396 = entry->key;
        D.29397 = (int) D.29396;
        emit_int32 (acfg, D.29397);
        D.29398 = entry->value;
        D.29399 = (int) D.29398;
        emit_int32 (acfg, D.29399);
        D.29400 = entry->next;
        if (D.29400 != 0B) goto <D.29401>; else goto <D.29402>;
        <D.29401>:
        D.29400 = entry->next;
        D.29403 = D.29400->index;
        D.29404 = (int) D.29403;
        emit_int32 (acfg, D.29404);
        goto <D.29405>;
        <D.29402>:
        emit_int32 (acfg, 0);
        <D.29405>:
        <D.29395>:
      }
      i = i + 1;
      <D.25530>:
      D.29391 = table->len;
      i.123 = (unsigned int) i;
      if (D.29391 > i.123) goto <D.25529>; else goto <D.25531>;
      <D.25531>:
      sprintf (&symbol, "extra_method_info_offsets");
      emit_section_change (acfg, ".rodata", 0);
      emit_alignment (acfg, 8);
      emit_label (acfg, &symbol);
      D.29339 = acfg->extra_methods;
      D.29340 = D.29339->len;
      D.29406 = (int) D.29340;
      emit_int32 (acfg, D.29406);
      i = 0;
      goto <D.25534>;
      <D.25533>:
      {
        struct MonoMethod * method;

        D.29339 = acfg->extra_methods;
        D.29343 = D.29339->pdata;
        D.29344 = (long unsigned int) i;
        D.29345 = D.29344 * 8;
        D.29346 = D.29343 + D.29345;
        method = *D.29346;
        D.29407 = get_method_index (acfg, method);
        D.29408 = (int) D.29407;
        emit_int32 (acfg, D.29408);
        D.29344 = (long unsigned int) i;
        D.29361 = D.29344 * 4;
        D.29362 = info_offsets + D.29361;
        D.29409 = *D.29362;
        D.29410 = (int) D.29409;
        emit_int32 (acfg, D.29410);
      }
      i = i + 1;
      <D.25534>:
      D.29339 = acfg->extra_methods;
      D.29340 = D.29339->len;
      i.123 = (unsigned int) i;
      if (D.29340 > i.123) goto <D.25533>; else goto <D.25535>;
      <D.25535>:
    }
  finally
    {
      symbol = {CLOBBER};
      p = {CLOBBER};
    }
}


emit_trampolines (struct MonoAotCompile * acfg)
{
  int D.29411;
  struct MonoImage * D.29414;
  struct MonoAssembly * D.29415;
  _Bool D.29416;
  long int D.29417;
  long int D.29418;
  const char * D.29421;
  int D.29422;
  unsigned int D.29425;
  int D.29426;
  unsigned int tramp_got_offset.126;
  unsigned int D.29430;
  int tramp_size.127;
  _Bool D.29434;
  long int D.29435;
  long int D.29436;
  unsigned int tramp_size.128;
  unsigned int D.29440;
  unsigned int i.129;
  unsigned int D.29442;
  unsigned int D.29443;
  unsigned int D.29444;
  char symbol[256];
  char end_symbol[256];
  int i;
  int tramp_got_offset;
  MonoAotTrampoline ntype;

  try
    {
      D.29411 = acfg->aot_opts.full_aot;
      if (D.29411 == 0) goto <D.29412>; else goto <D.29413>;
      <D.29412>:
      return;
      <D.29413>:
      D.29414 = acfg->image;
      D.29415 = D.29414->assembly;
      D.29416 = D.29415 == 0B;
      D.29417 = (long int) D.29416;
      D.29418 = __builtin_expect (D.29417, 0);
      if (D.29418 != 0) goto <D.29419>; else goto <D.29420>;
      <D.29419>:
      monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "aot-compiler.c", 5896, "acfg->image->assembly");
      <D.29420>:
      D.29414 = acfg->image;
      D.29415 = D.29414->assembly;
      D.29421 = D.29415->aname.name;
      D.29422 = strcmp (D.29421, "mscorlib");
      if (D.29422 == 0) goto <D.29423>; else goto <D.29424>;
      <D.29423>:
      emit_section_change (acfg, ".text", 0);
      D.29425 = acfg->got_offset;
      tramp_got_offset = (int) D.29425;
      ntype = 0;
      goto <D.25150>;
      <D.25149>:
      switch (ntype) <default: <D.25138>, case 0: <D.25133>, case 1: <D.25135>, case 2: <D.25136>, case 3: <D.25137>>
      <D.25133>:
      sprintf (&symbol, "specific_trampolines");
      goto <D.25134>;
      <D.25135>:
      sprintf (&symbol, "static_rgctx_trampolines");
      goto <D.25134>;
      <D.25136>:
      sprintf (&symbol, "imt_thunks");
      goto <D.25134>;
      <D.25137>:
      sprintf (&symbol, "gsharedvt_arg_trampolines");
      goto <D.25134>;
      <D.25138>:
      monoeg_assertion_message ("* Assertion: should not be reached at %s:%d\n", "aot-compiler.c", 6053);
      <D.25134>:
      sprintf (&end_symbol, "%s_e", &symbol);
      D.29426 = acfg->aot_opts.write_symbols;
      if (D.29426 != 0) goto <D.29427>; else goto <D.29428>;
      <D.29427>:
      emit_local_symbol (acfg, &symbol, &end_symbol, 1);
      <D.29428>:
      emit_alignment (acfg, 16);
      emit_label (acfg, &symbol);
      tramp_got_offset.126 = (unsigned int) tramp_got_offset;
      acfg->trampoline_got_offset_base[ntype] = tramp_got_offset.126;
      i = 0;
      goto <D.25147>;
      <D.25146>:
      {
        int tramp_size;

        try
          {
            tramp_size = 0;
            switch (ntype) <default: <D.25145>, case 0: <D.25140>, case 1: <D.25142>, case 2: <D.25143>, case 3: <D.25144>>
            <D.25140>:
            arch_emit_specific_trampoline (acfg, tramp_got_offset, &tramp_size);
            tramp_got_offset = tramp_got_offset + 2;
            goto <D.25141>;
            <D.25142>:
            arch_emit_static_rgctx_trampoline (acfg, tramp_got_offset, &tramp_size);
            tramp_got_offset = tramp_got_offset + 2;
            goto <D.25141>;
            <D.25143>:
            arch_emit_imt_thunk (acfg, tramp_got_offset, &tramp_size);
            tramp_got_offset = tramp_got_offset + 1;
            goto <D.25141>;
            <D.25144>:
            arch_emit_gsharedvt_arg_trampoline (acfg, tramp_got_offset, &tramp_size);
            tramp_got_offset = tramp_got_offset + 2;
            goto <D.25141>;
            <D.25145>:
            monoeg_assertion_message ("* Assertion: should not be reached at %s:%d\n", "aot-compiler.c", 6087);
            <D.25141>:
            D.29430 = acfg->trampoline_size[ntype];
            if (D.29430 == 0) goto <D.29431>; else goto <D.29432>;
            <D.29431>:
            tramp_size.127 = tramp_size;
            D.29434 = tramp_size.127 == 0;
            D.29435 = (long int) D.29434;
            D.29436 = __builtin_expect (D.29435, 0);
            if (D.29436 != 0) goto <D.29437>; else goto <D.29438>;
            <D.29437>:
            monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "aot-compiler.c", 6095, "tramp_size");
            <D.29438>:
            tramp_size.127 = tramp_size;
            tramp_size.128 = (unsigned int) tramp_size.127;
            acfg->trampoline_size[ntype] = tramp_size.128;
            <D.29432>:
          }
        finally
          {
            tramp_size = {CLOBBER};
          }
      }
      i = i + 1;
      <D.25147>:
      D.29440 = acfg->num_trampolines[ntype];
      i.129 = (unsigned int) i;
      if (D.29440 > i.129) goto <D.25146>; else goto <D.25148>;
      <D.25148>:
      emit_label (acfg, &end_symbol);
      emit_int32 (acfg, 0);
      ntype = ntype + 1;
      <D.25150>:
      if (ntype <= 3) goto <D.25149>; else goto <D.25151>;
      <D.25151>:
      arch_emit_specific_trampoline_pages (acfg);
      tramp_got_offset.126 = (unsigned int) tramp_got_offset;
      D.29425 = acfg->got_offset;
      D.29442 = tramp_got_offset.126 - D.29425;
      acfg->num_trampoline_got_entries = D.29442;
      <D.29424>:
      D.29425 = acfg->got_offset;
      D.29443 = acfg->num_trampoline_got_entries;
      D.29444 = D.29425 + D.29443;
      acfg->got_offset = D.29444;
    }
  finally
    {
      symbol = {CLOBBER};
      end_symbol = {CLOBBER};
    }
}


arch_emit_specific_trampoline (struct MonoAotCompile * acfg, int offset, int * tramp_size)
{
  monoeg_assertion_message ("* Assertion: should not be reached at %s:%d\n", "aot-compiler.c", 1373);
}


arch_emit_static_rgctx_trampoline (struct MonoAotCompile * acfg, int offset, int * tramp_size)
{
  monoeg_assertion_message ("* Assertion: should not be reached at %s:%d\n", "aot-compiler.c", 1600);
}


arch_emit_imt_thunk (struct MonoAotCompile * acfg, int offset, int * tramp_size)
{
  monoeg_assertion_message ("* Assertion: should not be reached at %s:%d\n", "aot-compiler.c", 1883);
}


arch_emit_gsharedvt_arg_trampoline (struct MonoAotCompile * acfg, int offset, int * tramp_size)
{
  monoeg_assertion_message ("* Assertion: should not be reached at %s:%d\n", "aot-compiler.c", 1951);
}


arch_emit_specific_trampoline_pages (struct MonoAotCompile * acfg)
{

}


emit_class_name_table (struct MonoAotCompile * acfg)
{
  struct MonoImage * D.29448;
  <unnamed-unsigned:24> D.29449;
  int D.29450;
  double D.29451;
  double D.29452;
  int D.29453;
  unsigned int D.29454;
  unsigned int D.29455;
  unsigned int table_size.130;
  int D.29457;
  int D.29458;
  struct MonoType * D.29461;
  unsigned int D.29462;
  void * * D.29463;
  long unsigned int D.29464;
  long unsigned int D.29465;
  void * * D.29466;
  struct ClassNameTableEntry * D.29470;
  unsigned int D.29471;
  _Bool D.29472;
  long int D.29473;
  long int D.29474;
  _Bool D.29477;
  long int D.29478;
  long int D.29479;
  long unsigned int D.29482;
  long unsigned int D.29483;
  void * * D.29484;
  unsigned int D.29488;
  int D.29489;
  int D.29490;
  struct ClassNameTableEntry * D.29491;
  unsigned int D.29494;
  int D.29495;
  unsigned int i.131;
  int i;
  int table_size;
  guint32 token;
  guint32 hash;
  struct MonoClass * klass;
  struct GPtrArray * table;
  char * full_name;
  char symbol[256];
  struct ClassNameTableEntry * entry;
  struct ClassNameTableEntry * new_entry;

  try
    {
      D.29448 = acfg->image;
      D.29449 = D.29448->tables[2].rows;
      D.29450 = (int) D.29449;
      D.29451 = (double) D.29450;
      D.29452 = D.29451 * 1.5e+0;
      D.29453 = (int) D.29452;
      D.29454 = (unsigned int) D.29453;
      D.29455 = monoeg_g_spaced_primes_closest (D.29454);
      table_size = (int) D.29455;
      table_size.130 = (unsigned int) table_size;
      table = monoeg_g_ptr_array_sized_new (table_size.130);
      i = 0;
      goto <D.25586>;
      <D.25585>:
      monoeg_g_ptr_array_add (table, 0B);
      i = i + 1;
      <D.25586>:
      if (i < table_size) goto <D.25585>; else goto <D.25587>;
      <D.25587>:
      i = 0;
      goto <D.25593>;
      <D.25592>:
      D.29457 = i + 1;
      D.29458 = D.29457 | 33554432;
      token = (guint32) D.29458;
      D.29448 = acfg->image;
      klass = mono_class_get (D.29448, token);
      if (klass == 0B) goto <D.29459>; else goto <D.29460>;
      <D.29459>:
      mono_loader_clear_error ();
      // predicted unlikely by continue predictor.
      goto <D.25588>;
      <D.29460>:
      D.29461 = mono_class_get_type (klass);
      full_name = mono_type_get_name_full (D.29461, 2);
      D.29462 = mono_metadata_str_hash (full_name);
      table_size.130 = (unsigned int) table_size;
      hash = D.29462 % table_size.130;
      monoeg_g_free (full_name);
      new_entry = monoeg_malloc0 (16);
      new_entry->token = token;
      D.29463 = table->pdata;
      D.29464 = (long unsigned int) hash;
      D.29465 = D.29464 * 8;
      D.29466 = D.29463 + D.29465;
      entry = *D.29466;
      if (entry == 0B) goto <D.29467>; else goto <D.29468>;
      <D.29467>:
      new_entry->index = hash;
      D.29463 = table->pdata;
      D.29464 = (long unsigned int) hash;
      D.29465 = D.29464 * 8;
      D.29466 = D.29463 + D.29465;
      *D.29466 = new_entry;
      goto <D.29469>;
      <D.29468>:
      goto <D.25590>;
      <D.25589>:
      entry = entry->next;
      <D.25590>:
      D.29470 = entry->next;
      if (D.29470 != 0B) goto <D.25589>; else goto <D.25591>;
      <D.25591>:
      entry->next = new_entry;
      D.29471 = table->len;
      new_entry->index = D.29471;
      monoeg_g_ptr_array_add (table, new_entry);
      <D.29469>:
      <D.25588>:
      i = i + 1;
      <D.25593>:
      D.29448 = acfg->image;
      D.29449 = D.29448->tables[2].rows;
      D.29450 = (int) D.29449;
      if (D.29450 > i) goto <D.25592>; else goto <D.25594>;
      <D.25594>:
      sprintf (&symbol, "class_name_table");
      emit_section_change (acfg, ".rodata", 0);
      emit_alignment (acfg, 8);
      emit_label (acfg, &symbol);
      D.29472 = table_size > 64999;
      D.29473 = (long int) D.29472;
      D.29474 = __builtin_expect (D.29473, 0);
      if (D.29474 != 0) goto <D.29475>; else goto <D.29476>;
      <D.29475>:
      monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "aot-compiler.c", 7744, "table_size < 65000");
      <D.29476>:
      emit_int16 (acfg, table_size);
      D.29471 = table->len;
      D.29477 = D.29471 > 64999;
      D.29478 = (long int) D.29477;
      D.29479 = __builtin_expect (D.29478, 0);
      if (D.29479 != 0) goto <D.29480>; else goto <D.29481>;
      <D.29480>:
      monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "aot-compiler.c", 7746, "table->len < 65000");
      <D.29481>:
      i = 0;
      goto <D.25597>;
      <D.25596>:
      {
        struct ClassNameTableEntry * entry;

        D.29463 = table->pdata;
        D.29482 = (long unsigned int) i;
        D.29483 = D.29482 * 8;
        D.29484 = D.29463 + D.29483;
        entry = *D.29484;
        if (entry == 0B) goto <D.29485>; else goto <D.29486>;
        <D.29485>:
        emit_int16 (acfg, 0);
        emit_int16 (acfg, 0);
        goto <D.29487>;
        <D.29486>:
        D.29488 = entry->token;
        D.29489 = (int) D.29488;
        D.29490 = D.29489 & 16777215;
        emit_int16 (acfg, D.29490);
        D.29491 = entry->next;
        if (D.29491 != 0B) goto <D.29492>; else goto <D.29493>;
        <D.29492>:
        D.29491 = entry->next;
        D.29494 = D.29491->index;
        D.29495 = (int) D.29494;
        emit_int16 (acfg, D.29495);
        goto <D.29496>;
        <D.29493>:
        emit_int16 (acfg, 0);
        <D.29496>:
        <D.29487>:
      }
      i = i + 1;
      <D.25597>:
      D.29471 = table->len;
      i.131 = (unsigned int) i;
      if (D.29471 > i.131) goto <D.25596>; else goto <D.25598>;
      <D.25598>:
    }
  finally
    {
      symbol = {CLOBBER};
    }
}


emit_got_info (struct MonoAotCompile * acfg)
{
  unsigned int D.29498;
  struct GPtrArray * D.29499;
  unsigned int D.29500;
  struct GHashTable * D.29501;
  long unsigned int D.29502;
  const void * D.29503;
  struct MonoJumpInfo * D.29504;
  <unnamed type> D.29505;
  int D.29506;
  int D.29507;
  unsigned int D.29508;
  unsigned int i.132;
  unsigned int D.29510;
  unsigned int D.29511;
  struct MonoMemPool * D.29512;
  unsigned int buf_size.133;
  unsigned int D.29514;
  unsigned int D.29515;
  void * D.29516;
  guint32 * D.29519;
  void * * D.29520;
  long unsigned int D.29521;
  void * * D.29522;
  <unnamed type> D.29523;
  int D.29524;
  guint8 * p.134;
  int D.29526;
  unsigned int D.29527;
  long int p.135;
  long int p2.136;
  long int D.29530;
  unsigned int D.29531;
  unsigned int D.29532;
  int D.29533;
  long int buf.137;
  long int D.29535;
  long int D.29536;
  _Bool D.29537;
  long int D.29538;
  long int D.29539;
  long unsigned int D.29542;
  guint32 * D.29543;
  unsigned int D.29544;
  unsigned int D.29545;
  int D.29548;
  sizetype D.29549;
  sizetype D.29550;
  sizetype D.29551;
  guint32 * D.29552;
  unsigned int D.29553;
  int D.29554;
  unsigned int D.29555;
  unsigned int D.29556;
  unsigned int D.29557;
  int D.29558;
  unsigned int i.138;
  unsigned int D.29560;
  int D.29561;
  unsigned int D.29562;
  unsigned int D.29563;
  int D.29564;
  char symbol[256];
  int i;
  int first_plt_got_patch;
  int buf_size;
  guint8 * p;
  guint8 * buf;
  guint32 * got_info_offsets;

  try
    {
      D.29498 = acfg->got_offset;
      acfg->plt_got_offset_base = D.29498;
      D.29499 = acfg->got_patches;
      D.29500 = D.29499->len;
      first_plt_got_patch = (int) D.29500;
      i = 1;
      goto <D.25621>;
      <D.25620>:
      {
        struct MonoPltEntry * plt_entry;

        D.29501 = acfg->plt_offset_to_entry;
        D.29502 = (long unsigned int) i;
        D.29503 = (const void *) D.29502;
        plt_entry = monoeg_g_hash_table_lookup (D.29501, D.29503);
        D.29499 = acfg->got_patches;
        D.29504 = plt_entry->ji;
        monoeg_g_ptr_array_add (D.29499, D.29504);
        D.29504 = plt_entry->ji;
        D.29505 = D.29504->type;
        D.29506 = acfg->stats.got_slot_types[D.29505];
        D.29507 = D.29506 + 1;
        acfg->stats.got_slot_types[D.29505] = D.29507;
      }
      i = i + 1;
      <D.25621>:
      D.29508 = acfg->plt_offset;
      i.132 = (unsigned int) i;
      if (D.29508 > i.132) goto <D.25620>; else goto <D.25622>;
      <D.25622>:
      D.29498 = acfg->got_offset;
      D.29508 = acfg->plt_offset;
      D.29510 = D.29498 + D.29508;
      acfg->got_offset = D.29510;
      D.29499 = acfg->got_patches;
      D.29500 = D.29499->len;
      D.29511 = D.29500 * 128;
      buf_size = (int) D.29511;
      D.29512 = acfg->mempool;
      buf_size.133 = (unsigned int) buf_size;
      buf = mono_mempool_alloc (D.29512, buf_size.133);
      p = buf;
      D.29512 = acfg->mempool;
      D.29499 = acfg->got_patches;
      D.29500 = D.29499->len;
      D.29514 = D.29500 * 4;
      got_info_offsets = mono_mempool_alloc (D.29512, D.29514);
      D.29512 = acfg->mempool;
      D.29508 = acfg->plt_offset;
      D.29515 = D.29508 * 4;
      D.29516 = mono_mempool_alloc (D.29512, D.29515);
      acfg->plt_got_info_offsets = D.29516;
      D.29508 = acfg->plt_offset;
      if (D.29508 != 0) goto <D.29517>; else goto <D.29518>;
      <D.29517>:
      D.29519 = acfg->plt_got_info_offsets;
      *D.29519 = 0;
      <D.29518>:
      i = 0;
      goto <D.25626>;
      <D.25625>:
      {
        struct MonoJumpInfo * ji;
        guint8 * p2;

        D.29499 = acfg->got_patches;
        D.29520 = D.29499->pdata;
        D.29502 = (long unsigned int) i;
        D.29521 = D.29502 * 8;
        D.29522 = D.29520 + D.29521;
        ji = *D.29522;
        p = buf;
        D.29523 = ji->type;
        D.29524 = (int) D.29523;
        p.134 = p;
        encode_value (D.29524, p.134, &p);
        p2 = p;
        p.134 = p;
        encode_patch (acfg, ji, p.134, &p);
        D.29523 = ji->type;
        D.29523 = ji->type;
        D.29526 = acfg->stats.got_slot_info_sizes[D.29523];
        D.29527 = (unsigned int) D.29526;
        p.134 = p;
        p.135 = (long int) p.134;
        p2.136 = (long int) p2;
        D.29530 = p.135 - p2.136;
        D.29531 = (unsigned int) D.29530;
        D.29532 = D.29527 + D.29531;
        D.29533 = (int) D.29532;
        acfg->stats.got_slot_info_sizes[D.29523] = D.29533;
        p.134 = p;
        p.135 = (long int) p.134;
        buf.137 = (long int) buf;
        D.29535 = p.135 - buf.137;
        D.29536 = (long int) buf_size;
        D.29537 = D.29535 > D.29536;
        D.29538 = (long int) D.29537;
        D.29539 = __builtin_expect (D.29538, 0);
        if (D.29539 != 0) goto <D.29540>; else goto <D.29541>;
        <D.29540>:
        monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "aot-compiler.c", 7851, "p - buf <= buf_size");
        <D.29541>:
        D.29502 = (long unsigned int) i;
        D.29542 = D.29502 * 4;
        D.29543 = got_info_offsets + D.29542;
        p.134 = p;
        p.135 = (long int) p.134;
        buf.137 = (long int) buf;
        D.29535 = p.135 - buf.137;
        D.29544 = (unsigned int) D.29535;
        D.29545 = add_to_blob (acfg, buf, D.29544);
        *D.29543 = D.29545;
        if (i >= first_plt_got_patch) goto <D.29546>; else goto <D.29547>;
        <D.29546>:
        D.29519 = acfg->plt_got_info_offsets;
        D.29548 = i - first_plt_got_patch;
        D.29549 = (sizetype) D.29548;
        D.29550 = D.29549 + 1;
        D.29551 = D.29550 * 4;
        D.29552 = D.29519 + D.29551;
        D.29502 = (long unsigned int) i;
        D.29542 = D.29502 * 4;
        D.29543 = got_info_offsets + D.29542;
        D.29553 = *D.29543;
        *D.29552 = D.29553;
        <D.29547>:
        D.29554 = acfg->stats.got_info_size;
        D.29555 = (unsigned int) D.29554;
        p.134 = p;
        p.135 = (long int) p.134;
        buf.137 = (long int) buf;
        D.29535 = p.135 - buf.137;
        D.29556 = (unsigned int) D.29535;
        D.29557 = D.29555 + D.29556;
        D.29558 = (int) D.29557;
        acfg->stats.got_info_size = D.29558;
      }
      i = i + 1;
      <D.25626>:
      D.29499 = acfg->got_patches;
      D.29500 = D.29499->len;
      i.138 = (unsigned int) i;
      if (D.29500 > i.138) goto <D.25625>; else goto <D.25627>;
      <D.25627>:
      sprintf (&symbol, "got_info_offsets");
      emit_section_change (acfg, ".rodata", 1);
      emit_alignment (acfg, 8);
      emit_label (acfg, &symbol);
      D.29560 = emit_offset_table (acfg, first_plt_got_patch, 10, got_info_offsets);
      D.29561 = acfg->stats.offsets_size;
      D.29562 = (unsigned int) D.29561;
      D.29563 = D.29562 + D.29560;
      D.29564 = (int) D.29563;
      acfg->stats.offsets_size = D.29564;
    }
  finally
    {
      symbol = {CLOBBER};
      p = {CLOBBER};
    }
}


encode_patch (struct MonoAotCompile * acfg, struct MonoJumpInfo * patch_info, guint8 * buf, guint8 * * endbuf)
{
  <unnamed type> D.29565;
  struct MonoImage * D.29566;
  unsigned int D.29567;
  int D.29568;
  guint8 * p.139;
  long int D.29570;
  int D.29571;
  struct MonoJumpInfoBBTable * D.29572;
  int D.29573;
  long unsigned int D.29574;
  long unsigned int D.29575;
  void * * D.29576;
  void * D.29577;
  long int D.29578;
  int D.29579;
  struct MonoMethod * D.29580;
  const char * D.29581;
  long unsigned int D.29582;
  int len.140;
  long unsigned int D.29584;
  sizetype D.29585;
  guint8 * p.141;
  guint8 * p.142;
  guint8 * p.143;
  struct MonoJumpInfoToken * D.29589;
  struct MonoImage * D.29590;
  unsigned int D.29591;
  _Bool D.29592;
  long int D.29593;
  long int D.29594;
  int image_index.144;
  unsigned int D.29598;
  unsigned int D.29599;
  int D.29600;
  unsigned int D.29601;
  int D.29602;
  int D.29603;
  int D.29604;
  struct MonoGenericContext * D.29607;
  struct MonoClass * D.29608;
  struct MonoImage * D.29609;
  const void * D.29610;
  _Bool D.29611;
  long int D.29612;
  long int D.29613;
  unsigned int D.29616;
  int D.29617;
  guint32 * D.29618;
  unsigned int D.29619;
  int D.29620;
  struct MonoClass * D.29621;
  struct MonoClassField * D.29622;
  struct GHashTable * D.29623;
  struct MonoMethod * D.29624;
  void * D.29625;
  long int D.29626;
  guint8 * p2.145;
  long int p2.146;
  long int buf2.147;
  long int D.29632;
  _Bool D.29633;
  long int D.29634;
  long int D.29635;
  unsigned int D.29638;
  unsigned int D.29639;
  long unsigned int D.29640;
  void * D.29641;
  int offset.148;
  <unnamed type> D.29644;
  int D.29645;
  _Bool D.29646;
  long int D.29647;
  long int D.29648;
  struct MonoJumpInfo * D.29651;
  <unnamed type> D.29652;
  _Bool D.29653;
  long int D.29654;
  long int D.29655;
  unsigned int iftmp.149;
  int D.29659;
  unsigned int D.29663;
  unsigned int D.29664;
  unsigned int D.29665;
  unsigned int D.29666;
  int D.29667;
  struct MonoJumpInfoImtTramp * D.29668;
  struct MonoMethod * D.29669;
  int D.29670;
  long int D.29671;
  int D.29672;
  struct MonoJumpInfoGSharedVtCall * D.29673;
  struct MonoMethodSignature * D.29674;
  struct MonoMethod * D.29675;
  struct MonoMethod * D.29676;
  struct GPtrArray * D.29677;
  unsigned int D.29678;
  int D.29679;
  void * * D.29680;
  long unsigned int D.29681;
  long unsigned int D.29682;
  void * * D.29683;
  <unnamed type> D.29684;
  int D.29685;
  <unnamed type> D.29686;
  void * D.29687;
  struct MonoClass * D.29688;
  unsigned int i.150;
  guint8 * p;

  try
    {
      p = buf;
      D.29565 = patch_info->type;
      switch (D.29565) <default: <D.24903>, case 3: <D.24851>, case 4: <D.24852>, case 5: <D.24843>, case 6: <D.24850>, case 7: <D.24856>, case 8: <D.24844>, case 10: <D.24866>, case 11: <D.24871>, case 12: <D.24838>, case 13: <D.24876>, case 14: <D.24870>, case 15: <D.24874>, case 16: <D.24877>, case 17: <D.24859>, case 18: <D.24864>, case 19: <D.24865>, case 20: <D.24868>, case 21: <D.24869>, case 23: <D.24872>, case 24: <D.24873>, case 28: <D.24863>, case 29: <D.24862>, case 30: <D.24875>, case 31: <D.24853>, case 32: <D.24857>, case 33: <D.24878>, case 34: <D.24854>, case 35: <D.24879>, case 36: <D.24884>, case 37: <D.24885>, case 38: <D.24886>, case 39: <D.24839>, case 40: <D.24887>, case 41: <D.24888>, case 42: <D.24841>, case 43: <D.24842>, case 44: <D.24889>, case 45: <D.24891>, case 46: <D.24892>, case 47: <D.24840>, case 48: <D.24890>, case 50: <D.24855>, case 51: <D.24836>>
      <D.24836>:
      goto <D.24837>;
      <D.24838>:
      D.29566 = patch_info->data.image;
      D.29567 = get_image_index (acfg, D.29566);
      D.29568 = (int) D.29567;
      p.139 = p;
      encode_value (D.29568, p.139, &p);
      goto <D.24837>;
      <D.24839>:
      <D.24840>:
      <D.24841>:
      <D.24842>:
      goto <D.24837>;
      <D.24843>:
      D.29570 = patch_info->data.offset;
      D.29571 = (int) D.29570;
      p.139 = p;
      encode_value (D.29571, p.139, &p);
      goto <D.24837>;
      <D.24844>:
      {
        void * * table;
        int k;

        D.29572 = patch_info->data.table;
        table = D.29572->table;
        D.29572 = patch_info->data.table;
        D.29573 = D.29572->table_size;
        p.139 = p;
        encode_value (D.29573, p.139, &p);
        k = 0;
        goto <D.24848>;
        <D.24847>:
        D.29574 = (long unsigned int) k;
        D.29575 = D.29574 * 8;
        D.29576 = table + D.29575;
        D.29577 = *D.29576;
        D.29578 = (long int) D.29577;
        D.29579 = (int) D.29578;
        p.139 = p;
        encode_value (D.29579, p.139, &p);
        k = k + 1;
        <D.24848>:
        D.29572 = patch_info->data.table;
        D.29573 = D.29572->table_size;
        if (D.29573 > k) goto <D.24847>; else goto <D.24849>;
        <D.24849>:
        goto <D.24837>;
      }
      <D.24850>:
      <D.24851>:
      <D.24852>:
      <D.24853>:
      <D.24854>:
      <D.24855>:
      D.29580 = patch_info->data.method;
      p.139 = p;
      encode_method_ref (acfg, D.29580, p.139, &p);
      goto <D.24837>;
      <D.24856>:
      <D.24857>:
      {
        guint32 len;

        D.29581 = patch_info->data.name;
        D.29582 = __strlen_g (D.29581);
        len = (guint32) D.29582;
        len.140 = (int) len;
        p.139 = p;
        encode_value (len.140, p.139, &p);
        p.139 = p;
        D.29581 = patch_info->data.name;
        D.29584 = (long unsigned int) len;
        memcpy (p.139, D.29581, D.29584);
        p.139 = p;
        D.29585 = (sizetype) len;
        p.141 = p.139 + D.29585;
        p = p.141;
        p.139 = p;
        p.142 = p.139;
        p.143 = p.142 + 1;
        p = p.143;
        *p.142 = 0;
        goto <D.24837>;
      }
      <D.24859>:
      {
        guint32 image_index;
        guint32 token;

        D.29589 = patch_info->data.token;
        D.29590 = D.29589->image;
        image_index = get_image_index (acfg, D.29590);
        D.29589 = patch_info->data.token;
        token = D.29589->token;
        D.29591 = token & 4278190080;
        D.29592 = D.29591 != 1879048192;
        D.29593 = (long int) D.29592;
        D.29594 = __builtin_expect (D.29593, 0);
        if (D.29594 != 0) goto <D.29595>; else goto <D.29596>;
        <D.29595>:
        monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "aot-compiler.c", 4927, "mono_metadata_token_code (token) == MONO_TOKEN_STRING");
        <D.29596>:
        image_index.144 = (int) image_index;
        p.139 = p;
        encode_value (image_index.144, p.139, &p);
        D.29589 = patch_info->data.token;
        D.29598 = D.29589->token;
        D.29599 = D.29598 + 2415919104;
        D.29600 = (int) D.29599;
        p.139 = p;
        encode_value (D.29600, p.139, &p);
        goto <D.24837>;
      }
      <D.24862>:
      <D.24863>:
      <D.24864>:
      <D.24865>:
      D.29589 = patch_info->data.token;
      D.29590 = D.29589->image;
      D.29601 = get_image_index (acfg, D.29590);
      D.29602 = (int) D.29601;
      p.139 = p;
      encode_value (D.29602, p.139, &p);
      D.29589 = patch_info->data.token;
      D.29598 = D.29589->token;
      D.29603 = (int) D.29598;
      p.139 = p;
      encode_value (D.29603, p.139, &p);
      D.29589 = patch_info->data.token;
      D.29604 = D.29589->has_context;
      p.139 = p;
      encode_value (D.29604, p.139, &p);
      D.29589 = patch_info->data.token;
      D.29604 = D.29589->has_context;
      if (D.29604 != 0) goto <D.29605>; else goto <D.29606>;
      <D.29605>:
      D.29589 = patch_info->data.token;
      D.29607 = &D.29589->context;
      p.139 = p;
      encode_generic_context (acfg, D.29607, p.139, &p);
      <D.29606>:
      goto <D.24837>;
      <D.24866>:
      {
        struct MonoClass * ex_class;

        D.29608 = mono_defaults.exception_class;
        D.29609 = D.29608->image;
        D.29610 = patch_info->data.target;
        ex_class = mono_class_from_name (D.29609, "System", D.29610);
        D.29611 = ex_class == 0B;
        D.29612 = (long int) D.29611;
        D.29613 = __builtin_expect (D.29612, 0);
        if (D.29613 != 0) goto <D.29614>; else goto <D.29615>;
        <D.29614>:
        monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "aot-compiler.c", 4948, "ex_class");
        <D.29615>:
        p.139 = p;
        encode_klass_ref (acfg, ex_class, p.139, &p);
        goto <D.24837>;
      }
      <D.24868>:
      D.29610 = patch_info->data.target;
      D.29616 = MEM[(guint32 *)D.29610];
      D.29617 = (int) D.29616;
      p.139 = p;
      encode_value (D.29617, p.139, &p);
      goto <D.24837>;
      <D.24869>:
      D.29610 = patch_info->data.target;
      D.29618 = D.29610 + 4;
      D.29619 = *D.29618;
      D.29620 = (int) D.29619;
      p.139 = p;
      encode_value (D.29620, p.139, &p);
      D.29610 = patch_info->data.target;
      D.29616 = MEM[(guint32 *)D.29610];
      D.29617 = (int) D.29616;
      p.139 = p;
      encode_value (D.29617, p.139, &p);
      goto <D.24837>;
      <D.24870>:
      <D.24871>:
      <D.24872>:
      <D.24873>:
      D.29621 = patch_info->data.klass;
      p.139 = p;
      encode_klass_ref (acfg, D.29621, p.139, &p);
      goto <D.24837>;
      <D.24874>:
      <D.24875>:
      D.29621 = patch_info->data.klass;
      p.139 = p;
      encode_klass_ref (acfg, D.29621, p.139, &p);
      goto <D.24837>;
      <D.24876>:
      <D.24877>:
      D.29622 = patch_info->data.field;
      p.139 = p;
      encode_field_info (acfg, D.29622, p.139, &p);
      goto <D.24837>;
      <D.24878>:
      goto <D.24837>;
      <D.24879>:
      {
        struct MonoJumpInfoRgctxEntry * entry;
        guint32 offset;
        guint8 * buf2;
        guint8 * p2;

        try
          {
            entry = patch_info->data.rgctx_entry;
            D.29623 = acfg->method_blob_hash;
            D.29624 = entry->method;
            D.29625 = monoeg_g_hash_table_lookup (D.29623, D.29624);
            D.29626 = (long int) D.29625;
            offset = (guint32) D.29626;
            if (offset == 0) goto <D.29627>; else goto <D.29628>;
            <D.29627>:
            buf2 = monoeg_malloc (1024);
            p2 = buf2;
            D.29624 = entry->method;
            p2.145 = p2;
            encode_method_ref (acfg, D.29624, p2.145, &p2);
            p2.145 = p2;
            p2.146 = (long int) p2.145;
            buf2.147 = (long int) buf2;
            D.29632 = p2.146 - buf2.147;
            D.29633 = D.29632 > 1023;
            D.29634 = (long int) D.29633;
            D.29635 = __builtin_expect (D.29634, 0);
            if (D.29635 != 0) goto <D.29636>; else goto <D.29637>;
            <D.29636>:
            monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "aot-compiler.c", 4990, "p2 - buf2 < 1024");
            <D.29637>:
            p2.145 = p2;
            p2.146 = (long int) p2.145;
            buf2.147 = (long int) buf2;
            D.29632 = p2.146 - buf2.147;
            D.29638 = (unsigned int) D.29632;
            offset = add_to_blob (acfg, buf2, D.29638);
            monoeg_g_free (buf2);
            D.29623 = acfg->method_blob_hash;
            D.29624 = entry->method;
            D.29639 = offset + 1;
            D.29640 = (long unsigned int) D.29639;
            D.29641 = (void *) D.29640;
            monoeg_g_hash_table_insert_replace (D.29623, D.29624, D.29641, 0);
            goto <D.29642>;
            <D.29628>:
            offset = offset + 4294967295;
            <D.29642>:
            offset.148 = (int) offset;
            p.139 = p;
            encode_value (offset.148, p.139, &p);
            D.29644 = entry->info_type;
            D.29645 = (int) D.29644;
            D.29646 = D.29645 > 255;
            D.29647 = (long int) D.29646;
            D.29648 = __builtin_expect (D.29647, 0);
            if (D.29648 != 0) goto <D.29649>; else goto <D.29650>;
            <D.29649>:
            monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "aot-compiler.c", 5001, "(int)entry->info_type < 256");
            <D.29650>:
            D.29651 = entry->data;
            D.29652 = D.29651->type;
            D.29653 = D.29652 > 255;
            D.29654 = (long int) D.29653;
            D.29655 = __builtin_expect (D.29654, 0);
            if (D.29655 != 0) goto <D.29656>; else goto <D.29657>;
            <D.29656>:
            monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "aot-compiler.c", 5002, "entry->data->type < 256");
            <D.29657>:
            D.29659 = entry->in_mrgctx;
            if (D.29659 != 0) goto <D.29660>; else goto <D.29661>;
            <D.29660>:
            iftmp.149 = 1;
            goto <D.29662>;
            <D.29661>:
            iftmp.149 = 0;
            <D.29662>:
            D.29644 = entry->info_type;
            D.29663 = D.29644 << 1;
            D.29664 = iftmp.149 | D.29663;
            D.29651 = entry->data;
            D.29652 = D.29651->type;
            D.29665 = D.29652 << 9;
            D.29666 = D.29664 | D.29665;
            D.29667 = (int) D.29666;
            p.139 = p;
            encode_value (D.29667, p.139, &p);
            D.29651 = entry->data;
            p.139 = p;
            encode_patch (acfg, D.29651, p.139, &p);
            goto <D.24837>;
          }
        finally
          {
            p2 = {CLOBBER};
          }
      }
      <D.24884>:
      <D.24885>:
      <D.24886>:
      <D.24887>:
      goto <D.24837>;
      <D.24888>:
      D.29668 = patch_info->data.imt_tramp;
      D.29669 = D.29668->method;
      p.139 = p;
      encode_method_ref (acfg, D.29669, p.139, &p);
      D.29668 = patch_info->data.imt_tramp;
      D.29670 = D.29668->vt_offset;
      p.139 = p;
      encode_value (D.29670, p.139, &p);
      goto <D.24837>;
      <D.24889>:
      D.29610 = patch_info->data.target;
      p.139 = p;
      encode_signature (acfg, D.29610, p.139, &p);
      goto <D.24837>;
      <D.24890>:
      D.29610 = patch_info->data.target;
      D.29671 = (long int) D.29610;
      D.29672 = (int) D.29671;
      p.139 = p;
      encode_value (D.29672, p.139, &p);
      goto <D.24837>;
      <D.24891>:
      D.29673 = patch_info->data.gsharedvt;
      D.29674 = D.29673->sig;
      p.139 = p;
      encode_signature (acfg, D.29674, p.139, &p);
      D.29673 = patch_info->data.gsharedvt;
      D.29675 = D.29673->method;
      p.139 = p;
      encode_method_ref (acfg, D.29675, p.139, &p);
      goto <D.24837>;
      <D.24892>:
      {
        struct MonoGSharedVtMethodInfo * info;
        int i;

        info = patch_info->data.gsharedvt_method;
        D.29676 = info->method;
        p.139 = p;
        encode_method_ref (acfg, D.29676, p.139, &p);
        D.29677 = info->entries;
        D.29678 = D.29677->len;
        D.29679 = (int) D.29678;
        p.139 = p;
        encode_value (D.29679, p.139, &p);
        i = 0;
        goto <D.24901>;
        <D.24900>:
        {
          struct MonoRuntimeGenericContextInfoTemplate * template;

          D.29677 = info->entries;
          D.29680 = D.29677->pdata;
          D.29681 = (long unsigned int) i;
          D.29682 = D.29681 * 8;
          D.29683 = D.29680 + D.29682;
          template = *D.29683;
          D.29684 = template->info_type;
          D.29685 = (int) D.29684;
          p.139 = p;
          encode_value (D.29685, p.139, &p);
          D.29684 = template->info_type;
          D.29686 = mini_rgctx_info_type_to_patch_info_type (D.29684);
          switch (D.29686) <default: <D.24899>, case 11: <D.24896>, case 13: <D.24898>>
          <D.24896>:
          D.29687 = template->data;
          D.29688 = mono_class_from_mono_type (D.29687);
          p.139 = p;
          encode_klass_ref (acfg, D.29688, p.139, &p);
          goto <D.24897>;
          <D.24898>:
          D.29687 = template->data;
          p.139 = p;
          encode_field_info (acfg, D.29687, p.139, &p);
          goto <D.24897>;
          <D.24899>:
          monoeg_assertion_message ("* Assertion: should not be reached at %s:%d\n", "aot-compiler.c", 5044);
          <D.24897>:
        }
        i = i + 1;
        <D.24901>:
        D.29677 = info->entries;
        D.29678 = D.29677->len;
        i.150 = (unsigned int) i;
        if (D.29678 > i.150) goto <D.24900>; else goto <D.24902>;
        <D.24902>:
        goto <D.24837>;
      }
      <D.24903>:
      D.29565 = patch_info->type;
      monoeg_g_log (0B, 16, "unable to handle jump info %d", D.29565);
      monoeg_assertion_message ("* Assertion: should not be reached at %s:%d\n", "aot-compiler.c", 5052);
      <D.24837>:
      p.139 = p;
      *endbuf = p.139;
    }
  finally
    {
      p = {CLOBBER};
    }
}


encode_field_info (struct MonoAotCompile * cfg, struct MonoClassField * field, guint8 * buf, guint8 * * endbuf)
{
  struct MonoClass * D.29692;
  guint8 * p.151;
  unsigned int D.29694;
  _Bool D.29695;
  long int D.29696;
  long int D.29697;
  unsigned int D.29700;
  int D.29701;
  guint32 token;
  guint8 * p;

  try
    {
      token = mono_get_field_token (field);
      p = buf;
      D.29692 = field->parent;
      p.151 = p;
      encode_klass_ref (cfg, D.29692, p.151, &p);
      D.29694 = token & 4278190080;
      D.29695 = D.29694 != 67108864;
      D.29696 = (long int) D.29695;
      D.29697 = __builtin_expect (D.29696, 0);
      if (D.29697 != 0) goto <D.29698>; else goto <D.29699>;
      <D.29698>:
      monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "aot-compiler.c", 2400, "mono_metadata_token_code (token) == MONO_TOKEN_FIELD_DEF");
      <D.29699>:
      D.29700 = token + 4227858432;
      D.29701 = (int) D.29700;
      p.151 = p;
      encode_value (D.29701, p.151, &p);
      p.151 = p;
      *endbuf = p.151;
    }
  finally
    {
      p = {CLOBBER};
    }
}


mono_get_field_token (struct MonoClassField * field)
{
  struct MonoClassField * D.29702;
  long unsigned int D.29703;
  long unsigned int D.29704;
  struct MonoClassField * D.29705;
  guint32 D.29708;
  unsigned int D.29709;
  unsigned int i.152;
  unsigned int D.29711;
  unsigned int D.29712;
  unsigned int D.29713;
  struct MonoClass * klass;
  int i;

  klass = field->parent;
  i = 0;
  goto <D.24021>;
  <D.24020>:
  D.29702 = klass->fields;
  D.29703 = (long unsigned int) i;
  D.29704 = D.29703 * 32;
  D.29705 = D.29702 + D.29704;
  if (D.29705 == field) goto <D.29706>; else goto <D.29707>;
  <D.29706>:
  D.29709 = klass->field.first;
  i.152 = (unsigned int) i;
  D.29711 = D.29709 + i.152;
  D.29712 = D.29711 + 1;
  D.29708 = D.29712 | 67108864;
  return D.29708;
  <D.29707>:
  i = i + 1;
  <D.24021>:
  D.29713 = klass->field.count;
  i.152 = (unsigned int) i;
  if (D.29713 > i.152) goto <D.24020>; else goto <D.24022>;
  <D.24022>:
  monoeg_assertion_message ("* Assertion: should not be reached at %s:%d\n", "aot-compiler.c", 2035);
  D.29708 = 0;
  return D.29708;
}


emit_exception_info (struct MonoAotCompile * acfg)
{
  unsigned int D.29715;
  long unsigned int D.29716;
  long unsigned int D.29717;
  struct MonoCompile * * D.29718;
  long unsigned int D.29719;
  long unsigned int D.29720;
  struct MonoCompile * * D.29721;
  struct MonoCompile * D.29722;
  long unsigned int D.29725;
  gint32 * D.29726;
  unsigned int D.29727;
  int D.29728;
  unsigned int i.153;
  int D.29731;
  unsigned int D.29732;
  int D.29733;
  unsigned int D.29734;
  unsigned int D.29735;
  int D.29736;
  int i;
  char symbol[256];
  gint32 * offsets;

  try
    {
      D.29715 = acfg->nmethods;
      D.29716 = (long unsigned int) D.29715;
      D.29717 = D.29716 * 4;
      offsets = monoeg_malloc0 (D.29717);
      i = 0;
      goto <D.25543>;
      <D.25542>:
      D.29718 = acfg->cfgs;
      D.29719 = (long unsigned int) i;
      D.29720 = D.29719 * 8;
      D.29721 = D.29718 + D.29720;
      D.29722 = *D.29721;
      if (D.29722 != 0B) goto <D.29723>; else goto <D.29724>;
      <D.29723>:
      D.29718 = acfg->cfgs;
      D.29719 = (long unsigned int) i;
      D.29720 = D.29719 * 8;
      D.29721 = D.29718 + D.29720;
      D.29722 = *D.29721;
      emit_exception_debug_info (acfg, D.29722);
      D.29719 = (long unsigned int) i;
      D.29725 = D.29719 * 4;
      D.29726 = offsets + D.29725;
      D.29718 = acfg->cfgs;
      D.29719 = (long unsigned int) i;
      D.29720 = D.29719 * 8;
      D.29721 = D.29718 + D.29720;
      D.29722 = *D.29721;
      D.29727 = D.29722->ex_info_offset;
      D.29728 = (int) D.29727;
      *D.29726 = D.29728;
      goto <D.29729>;
      <D.29724>:
      D.29719 = (long unsigned int) i;
      D.29725 = D.29719 * 4;
      D.29726 = offsets + D.29725;
      *D.29726 = 0;
      <D.29729>:
      i = i + 1;
      <D.25543>:
      D.29715 = acfg->nmethods;
      i.153 = (unsigned int) i;
      if (D.29715 > i.153) goto <D.25542>; else goto <D.25544>;
      <D.25544>:
      sprintf (&symbol, "ex_info_offsets");
      emit_section_change (acfg, ".rodata", 1);
      emit_alignment (acfg, 8);
      emit_label (acfg, &symbol);
      D.29715 = acfg->nmethods;
      D.29731 = (int) D.29715;
      D.29732 = emit_offset_table (acfg, D.29731, 10, offsets);
      D.29733 = acfg->stats.offsets_size;
      D.29734 = (unsigned int) D.29733;
      D.29735 = D.29734 + D.29732;
      D.29736 = (int) D.29735;
      acfg->stats.offsets_size = D.29736;
      monoeg_g_free (offsets);
    }
  finally
    {
      symbol = {CLOBBER};
    }
}


emit_exception_debug_info (struct MonoAotCompile * acfg, struct MonoCompile * cfg)
{
  unsigned int D.29737;
  int D.29738;
  <unnamed-unsigned:15> D.29742;
  int D.29743;
  int D.29744;
  unsigned int D.29745;
  unsigned int debug_info_size.154;
  unsigned int D.29747;
  guint32 iftmp.155;
  int D.29751;
  int D.29752;
  unsigned int D.29754;
  unsigned int D.29755;
  unsigned int D.29756;
  unsigned int D.29757;
  long unsigned int D.29758;
  struct GSList * D.29759;
  _Bool D.29760;
  long unsigned int D.29761;
  long unsigned int D.29762;
  _Bool D.29763;
  int D.29764;
  int iftmp.156;
  int D.29769;
  int iftmp.157;
  long unsigned int D.29771;
  long unsigned int D.29772;
  int D.29776;
  int iftmp.158;
  int D.29781;
  int iftmp.159;
  long unsigned int D.29783;
  long unsigned int D.29784;
  int D.29788;
  int iftmp.160;
  long unsigned int D.29790;
  int D.29794;
  int iftmp.161;
  guint8 * D.29796;
  int D.29800;
  int iftmp.162;
  long unsigned int D.29802;
  int D.29806;
  int flags.163;
  guint8 * p.164;
  unsigned int encoded_len.165;
  unsigned int D.29812;
  int D.29813;
  unsigned int D.29815;
  int D.29816;
  short unsigned int D.29819;
  int D.29820;
  int D.29825;
  struct MonoExceptionClause * D.29826;
  long unsigned int D.29827;
  long unsigned int D.29828;
  unsigned int D.29829;
  int D.29830;
  struct MonoClass * D.29831;
  long unsigned int D.29835;
  long unsigned int D.29836;
  long unsigned int D.29837;
  long unsigned int D.29838;
  unsigned int D.29841;
  unsigned int D.29842;
  unsigned int D.29845;
  unsigned int D.29846;
  long unsigned int D.29850;
  <unnamed-unsigned:15> D.29853;
  int D.29854;
  unsigned int D.29855;
  int D.29856;
  int D.29857;
  unsigned int D.29858;
  void * D.29861;
  long int D.29862;
  long int code.166;
  long int D.29864;
  int D.29865;
  struct MonoClass * D.29867;
  guint8 * p2.167;
  long int p2.168;
  long int buf2.169;
  long int D.29873;
  _Bool D.29874;
  long int D.29875;
  long int D.29876;
  long unsigned int D.29879;
  sizetype D.29880;
  guint8 * p.170;
  void * D.29883;
  long int D.29884;
  long int D.29885;
  int D.29886;
  void * D.29887;
  long int D.29888;
  long int D.29889;
  int D.29890;
  void * D.29891;
  long int D.29892;
  long int D.29893;
  int D.29894;
  int D.29895;
  short unsigned int D.29898;
  int D.29899;
  short unsigned int D.29900;
  int D.29901;
  unsigned int D.29902;
  int D.29903;
  short unsigned int D.29904;
  int D.29905;
  unsigned int D.29908;
  int D.29909;
  int D.29912;
  struct MonoDwarfLocListEntry * D.29915;
  long unsigned int D.29916;
  long unsigned int D.29917;
  int D.29918;
  _Bool D.29919;
  int D.29920;
  int D.29921;
  int D.29924;
  int D.29927;
  _Bool D.29928;
  long int D.29929;
  long int D.29930;
  int D.29934;
  long unsigned int D.29938;
  long unsigned int D.29939;
  _Bool D.29940;
  int D.29941;
  unsigned char D.29942;
  int D.29943;
  int D.29944;
  struct MonoMethod * D.29945;
  guint8 * p2.171;
  long int p2.172;
  long int buf2.173;
  long int D.29949;
  _Bool D.29950;
  long int D.29951;
  long int D.29952;
  long unsigned int D.29955;
  sizetype D.29956;
  guint8 * p.174;
  gboolean * D.29962;
  gboolean * D.29964;
  long unsigned int D.29965;
  long unsigned int D.29966;
  _Bool D.29967;
  long int D.29968;
  long int D.29969;
  struct MonoGenericInst * D.29972;
  <unnamed-unsigned:22> D.29975;
  int D.29976;
  long unsigned int D.29977;
  gboolean * D.29978;
  int D.29979;
  int D.29980;
  struct MonoGenericInst * D.29982;
  gboolean * D.29985;
  int D.29986;
  int D.29990;
  int D.29991;
  int D.29992;
  int D.29993;
  int * D.29994;
  long unsigned int D.29995;
  long unsigned int D.29996;
  int * D.29997;
  int D.29998;
  unsigned int buf_size.175;
  _Bool D.30000;
  long int D.30001;
  long int D.30002;
  int debug_info_size.176;
  guint8 * debug_info.177;
  long unsigned int D.30009;
  sizetype D.30010;
  guint8 * p.178;
  int D.30014;
  guint8 * p.179;
  long unsigned int p.180;
  long unsigned int D.30017;
  long unsigned int D.30018;
  sizetype D.30019;
  guint8 * p.181;
  int D.30021;
  unsigned int D.30022;
  long int p.182;
  long int buf.183;
  long int D.30025;
  unsigned int D.30026;
  unsigned int D.30027;
  int D.30028;
  long int D.30029;
  _Bool D.30030;
  long int D.30031;
  long int D.30032;
  unsigned int D.30035;
  guint32 iftmp.184;
  unsigned int D.30040;
  struct MonoMethod * method;
  int i;
  int k;
  int buf_size;
  int method_index;
  guint32 debug_info_size;
  guint8 * code;
  struct MonoMethodHeader * header;
  guint8 * p;
  guint8 * buf;
  guint8 * debug_info;
  struct MonoJitInfo * jinfo;
  guint32 flags;
  gboolean use_unwind_ops;
  struct MonoSeqPointInfo * seq_points;

  try
    {
      jinfo = cfg->jit_info;
      use_unwind_ops = 0;
      method = cfg->orig_method;
      code = cfg->native_code;
      header = cfg->header;
      D.29737 = get_method_index (acfg, method);
      method_index = (int) D.29737;
      D.29738 = acfg->aot_opts.nodebug;
      if (D.29738 == 0) goto <D.29739>; else goto <D.29740>;
      <D.29739>:
      mono_debug_serialize_debug_info (cfg, &debug_info, &debug_info_size);
      goto <D.29741>;
      <D.29740>:
      debug_info = 0B;
      debug_info_size = 0;
      <D.29741>:
      seq_points = cfg->seq_point_info;
      D.29742 = header->num_clauses;
      D.29743 = (int) D.29742;
      D.29744 = D.29743 * 256;
      D.29745 = (unsigned int) D.29744;
      debug_info_size.154 = debug_info_size;
      D.29747 = D.29745 + debug_info_size.154;
      if (seq_points != 0B) goto <D.29749>; else goto <D.29750>;
      <D.29749>:
      D.29751 = seq_points->len;
      D.29752 = D.29751 * 128;
      iftmp.155 = (guint32) D.29752;
      goto <D.29753>;
      <D.29750>:
      iftmp.155 = 0;
      <D.29753>:
      D.29754 = D.29747 + iftmp.155;
      D.29755 = cfg->gc_map_size;
      D.29756 = D.29754 + D.29755;
      D.29757 = D.29756 + 2048;
      buf_size = (int) D.29757;
      D.29758 = (long unsigned int) buf_size;
      buf = monoeg_malloc (D.29758);
      p = buf;
      D.29759 = cfg->unwind_ops;
      D.29760 = D.29759 != 0B;
      use_unwind_ops = (gboolean) D.29760;
      D.29761 = BIT_FIELD_REF <*jinfo, 64, 256>;
      D.29762 = D.29761 & 70368744177664;
      D.29763 = D.29762 != 0;
      D.29764 = (int) D.29763;
      if (use_unwind_ops != 0) goto <D.29766>; else goto <D.29767>;
      <D.29766>:
      iftmp.156 = 2;
      goto <D.29768>;
      <D.29767>:
      iftmp.156 = 0;
      <D.29768>:
      D.29769 = D.29764 | iftmp.156;
      D.29771 = BIT_FIELD_REF <*header, 64, 64>;
      D.29772 = D.29771 & 65534;
      if (D.29772 != 0) goto <D.29773>; else goto <D.29774>;
      <D.29773>:
      iftmp.157 = 4;
      goto <D.29775>;
      <D.29774>:
      iftmp.157 = 0;
      <D.29775>:
      D.29776 = D.29769 | iftmp.157;
      if (seq_points != 0B) goto <D.29778>; else goto <D.29779>;
      <D.29778>:
      iftmp.158 = 8;
      goto <D.29780>;
      <D.29779>:
      iftmp.158 = 0;
      <D.29780>:
      D.29781 = D.29776 | iftmp.158;
      D.29783 = BIT_FIELD_REF <*cfg, 64, 5568>;
      D.29784 = D.29783 & 8388608;
      if (D.29784 != 0) goto <D.29785>; else goto <D.29786>;
      <D.29785>:
      iftmp.159 = 16;
      goto <D.29787>;
      <D.29786>:
      iftmp.159 = 0;
      <D.29787>:
      D.29788 = D.29781 | iftmp.159;
      D.29761 = BIT_FIELD_REF <*jinfo, 64, 256>;
      D.29790 = D.29761 & 35184372088832;
      if (D.29790 != 0) goto <D.29791>; else goto <D.29792>;
      <D.29791>:
      iftmp.160 = 32;
      goto <D.29793>;
      <D.29792>:
      iftmp.160 = 0;
      <D.29793>:
      D.29794 = D.29788 | iftmp.160;
      D.29796 = cfg->gc_map;
      if (D.29796 != 0B) goto <D.29797>; else goto <D.29798>;
      <D.29797>:
      iftmp.161 = 64;
      goto <D.29799>;
      <D.29798>:
      iftmp.161 = 0;
      <D.29799>:
      D.29800 = D.29794 | iftmp.161;
      D.29761 = BIT_FIELD_REF <*jinfo, 64, 256>;
      D.29802 = D.29761 & 17592186044416;
      if (D.29802 != 0) goto <D.29803>; else goto <D.29804>;
      <D.29803>:
      iftmp.162 = 128;
      goto <D.29805>;
      <D.29804>:
      iftmp.162 = 0;
      <D.29805>:
      D.29806 = D.29800 | iftmp.162;
      flags = (guint32) D.29806;
      flags.163 = (int) flags;
      p.164 = p;
      encode_value (flags.163, p.164, &p);
      if (use_unwind_ops != 0) goto <D.29809>; else goto <D.29810>;
      <D.29809>:
      {
        guint32 encoded_len;
        guint8 * encoded;

        try
          {
            D.29759 = cfg->unwind_ops;
            encoded = mono_unwind_ops_encode (D.29759, &encoded_len);
            encoded_len.165 = encoded_len;
            D.29812 = get_unwind_info_offset (acfg, encoded, encoded_len.165);
            D.29813 = (int) D.29812;
            p.164 = p;
            encode_value (D.29813, p.164, &p);
            monoeg_g_free (encoded);
          }
        finally
          {
            encoded_len = {CLOBBER};
          }
      }
      goto <D.29814>;
      <D.29810>:
      D.29815 = jinfo->used_regs;
      D.29816 = (int) D.29815;
      p.164 = p;
      encode_value (D.29816, p.164, &p);
      <D.29814>:
      D.29761 = BIT_FIELD_REF <*jinfo, 64, 256>;
      D.29790 = D.29761 & 35184372088832;
      if (D.29790 != 0) goto <D.29817>; else goto <D.29818>;
      <D.29817>:
      {
        struct MonoTryBlockHoleTableJitInfo * table;

        table = mono_jit_info_get_try_block_hole_table_info (jinfo);
        D.29819 = table->num_holes;
        D.29820 = (int) D.29819;
        p.164 = p;
        encode_value (D.29820, p.164, &p);
      }
      <D.29818>:
      D.29783 = BIT_FIELD_REF <*cfg, 64, 5568>;
      D.29784 = D.29783 & 8388608;
      if (D.29784 != 0) goto <D.29821>; else goto <D.29822>;
      <D.29821>:
      D.29771 = BIT_FIELD_REF <*header, 64, 64>;
      D.29772 = D.29771 & 65534;
      if (D.29772 != 0) goto <D.29823>; else goto <D.29824>;
      <D.29823>:
      D.29742 = header->num_clauses;
      D.29825 = (int) D.29742;
      p.164 = p;
      encode_value (D.29825, p.164, &p);
      <D.29824>:
      k = 0;
      goto <D.24986>;
      <D.24985>:
      {
        struct MonoExceptionClause * clause;

        D.29826 = header->clauses;
        D.29827 = (long unsigned int) k;
        D.29828 = D.29827 * 32;
        clause = D.29826 + D.29828;
        D.29829 = clause->flags;
        D.29830 = (int) D.29829;
        p.164 = p;
        encode_value (D.29830, p.164, &p);
        D.29831 = clause->data.catch_class;
        if (D.29831 != 0B) goto <D.29832>; else goto <D.29833>;
        <D.29832>:
        p.164 = p;
        encode_value (1, p.164, &p);
        D.29831 = clause->data.catch_class;
        p.164 = p;
        encode_klass_ref (acfg, D.29831, p.164, &p);
        goto <D.29834>;
        <D.29833>:
        p.164 = p;
        encode_value (0, p.164, &p);
        <D.29834>:
        i = 0;
        goto <D.24983>;
        <D.24982>:
        {
          gint32 cindex1;
          struct MonoExceptionClause * clause1;
          gint32 cindex2;
          struct MonoExceptionClause * clause2;

          cindex1 = k;
          D.29826 = header->clauses;
          D.29835 = (long unsigned int) cindex1;
          D.29836 = D.29835 * 32;
          clause1 = D.29826 + D.29836;
          cindex2 = i;
          D.29826 = header->clauses;
          D.29837 = (long unsigned int) cindex2;
          D.29838 = D.29837 * 32;
          clause2 = D.29826 + D.29838;
          if (cindex1 != cindex2) goto <D.29839>; else goto <D.29840>;
          <D.29839>:
          D.29841 = clause1->try_offset;
          D.29842 = clause2->try_offset;
          if (D.29841 >= D.29842) goto <D.29843>; else goto <D.29844>;
          <D.29843>:
          D.29845 = clause1->handler_offset;
          D.29846 = clause2->handler_offset;
          if (D.29845 <= D.29846) goto <D.29847>; else goto <D.29848>;
          <D.29847>:
          p.164 = p;
          encode_value (i, p.164, &p);
          <D.29848>:
          <D.29844>:
          <D.29840>:
        }
        i = i + 1;
        <D.24983>:
        D.29742 = header->num_clauses;
        D.29743 = (int) D.29742;
        if (D.29743 > i) goto <D.24982>; else goto <D.24984>;
        <D.24984>:
        p.164 = p;
        encode_value (-1, p.164, &p);
      }
      k = k + 1;
      <D.24986>:
      D.29742 = header->num_clauses;
      D.29743 = (int) D.29742;
      if (D.29743 > k) goto <D.24985>; else goto <D.24987>;
      <D.24987>:
      goto <D.29849>;
      <D.29822>:
      D.29761 = BIT_FIELD_REF <*jinfo, 64, 256>;
      D.29850 = D.29761 & 18446181123756130304;
      if (D.29850 != 0) goto <D.29851>; else goto <D.29852>;
      <D.29851>:
      D.29853 = jinfo->num_clauses;
      D.29854 = (int) D.29853;
      p.164 = p;
      encode_value (D.29854, p.164, &p);
      <D.29852>:
      k = 0;
      goto <D.24993>;
      <D.24992>:
      {
        struct MonoJitExceptionInfo * ei;

        ei = &jinfo->clauses[k];
        D.29855 = ei->flags;
        D.29856 = (int) D.29855;
        p.164 = p;
        encode_value (D.29856, p.164, &p);
        D.29857 = ei->exvar_offset;
        p.164 = p;
        encode_value (D.29857, p.164, &p);
        D.29855 = ei->flags;
        D.29858 = D.29855 + 4294967295;
        if (D.29858 <= 1) goto <D.29859>; else goto <D.29860>;
        <D.29859>:
        D.29861 = ei->data.filter;
        D.29862 = (long int) D.29861;
        code.166 = (long int) code;
        D.29864 = D.29862 - code.166;
        D.29865 = (int) D.29864;
        p.164 = p;
        encode_value (D.29865, p.164, &p);
        goto <D.29866>;
        <D.29860>:
        D.29867 = ei->data.catch_class;
        if (D.29867 != 0B) goto <D.29868>; else goto <D.29869>;
        <D.29868>:
        {
          guint8 * buf2;
          guint8 * p2;
          int len;

          try
            {
              buf2 = monoeg_malloc (4096);
              p2 = buf2;
              D.29867 = ei->data.catch_class;
              p2.167 = p2;
              encode_klass_ref (acfg, D.29867, p2.167, &p2);
              p2.167 = p2;
              p2.168 = (long int) p2.167;
              buf2.169 = (long int) buf2;
              D.29873 = p2.168 - buf2.169;
              len = (int) D.29873;
              D.29874 = len > 4095;
              D.29875 = (long int) D.29874;
              D.29876 = __builtin_expect (D.29875, 0);
              if (D.29876 != 0) goto <D.29877>; else goto <D.29878>;
              <D.29877>:
              monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "aot-compiler.c", 5325, "len < 4096");
              <D.29878>:
              p.164 = p;
              encode_value (len, p.164, &p);
              p.164 = p;
              D.29879 = (long unsigned int) len;
              memcpy (p.164, buf2, D.29879);
              p.164 = p;
              p2.167 = p2;
              p2.168 = (long int) p2.167;
              buf2.169 = (long int) buf2;
              D.29873 = p2.168 - buf2.169;
              D.29880 = (sizetype) D.29873;
              p.170 = p.164 + D.29880;
              p = p.170;
              monoeg_g_free (buf2);
            }
          finally
            {
              p2 = {CLOBBER};
            }
        }
        goto <D.29882>;
        <D.29869>:
        p.164 = p;
        encode_value (0, p.164, &p);
        <D.29882>:
        <D.29866>:
        D.29883 = ei->try_start;
        D.29884 = (long int) D.29883;
        code.166 = (long int) code;
        D.29885 = D.29884 - code.166;
        D.29886 = (int) D.29885;
        p.164 = p;
        encode_value (D.29886, p.164, &p);
        D.29887 = ei->try_end;
        D.29888 = (long int) D.29887;
        code.166 = (long int) code;
        D.29889 = D.29888 - code.166;
        D.29890 = (int) D.29889;
        p.164 = p;
        encode_value (D.29890, p.164, &p);
        D.29891 = ei->handler_start;
        D.29892 = (long int) D.29891;
        code.166 = (long int) code;
        D.29893 = D.29892 - code.166;
        D.29894 = (int) D.29893;
        p.164 = p;
        encode_value (D.29894, p.164, &p);
      }
      k = k + 1;
      <D.24993>:
      D.29853 = jinfo->num_clauses;
      D.29895 = (int) D.29853;
      if (D.29895 > k) goto <D.24992>; else goto <D.24994>;
      <D.24994>:
      <D.29849>:
      D.29761 = BIT_FIELD_REF <*jinfo, 64, 256>;
      D.29790 = D.29761 & 35184372088832;
      if (D.29790 != 0) goto <D.29896>; else goto <D.29897>;
      <D.29896>:
      {
        struct MonoTryBlockHoleTableJitInfo * table;

        table = mono_jit_info_get_try_block_hole_table_info (jinfo);
        i = 0;
        goto <D.24998>;
        <D.24997>:
        {
          struct MonoTryBlockHoleJitInfo * hole;

          hole = &table->holes[i];
          D.29898 = hole->clause;
          D.29899 = (int) D.29898;
          p.164 = p;
          encode_value (D.29899, p.164, &p);
          D.29900 = hole->length;
          D.29901 = (int) D.29900;
          p.164 = p;
          encode_value (D.29901, p.164, &p);
          D.29902 = hole->offset;
          D.29903 = (int) D.29902;
          p.164 = p;
          encode_value (D.29903, p.164, &p);
        }
        i = i + 1;
        <D.24998>:
        D.29904 = table->num_holes;
        D.29905 = (int) D.29904;
        if (D.29905 > i) goto <D.24997>; else goto <D.24999>;
        <D.24999>:
      }
      <D.29897>:
      D.29761 = BIT_FIELD_REF <*jinfo, 64, 256>;
      D.29802 = D.29761 & 17592186044416;
      if (D.29802 != 0) goto <D.29906>; else goto <D.29907>;
      <D.29906>:
      {
        struct MonoArchEHJitInfo * eh_info;

        eh_info = mono_jit_info_get_arch_eh_info (jinfo);
        D.29908 = eh_info->stack_size;
        D.29909 = (int) D.29908;
        p.164 = p;
        encode_value (D.29909, p.164, &p);
      }
      <D.29907>:
      D.29761 = BIT_FIELD_REF <*jinfo, 64, 256>;
      D.29762 = D.29761 & 70368744177664;
      if (D.29762 != 0) goto <D.29910>; else goto <D.29911>;
      <D.29910>:
      {
        struct MonoGenericJitInfo * gi;
        struct MonoGenericSharingContext * gsctx;
        guint8 * p1;
        guint8 * buf2;
        guint8 * p2;
        int len;

        try
          {
            gi = mono_jit_info_get_generic_jit_info (jinfo);
            gsctx = gi->generic_sharing_context;
            p1 = p;
            D.29912 = gi->nlocs;
            p.164 = p;
            encode_value (D.29912, p.164, &p);
            D.29912 = gi->nlocs;
            if (D.29912 != 0) goto <D.29913>; else goto <D.29914>;
            <D.29913>:
            i = 0;
            goto <D.25009>;
            <D.25008>:
            {
              struct MonoDwarfLocListEntry * entry;

              D.29915 = gi->locations;
              D.29916 = (long unsigned int) i;
              D.29917 = D.29916 * 20;
              entry = D.29915 + D.29917;
              D.29918 = entry->is_reg;
              D.29919 = D.29918 != 0;
              D.29920 = (int) D.29919;
              p.164 = p;
              encode_value (D.29920, p.164, &p);
              D.29921 = entry->reg;
              p.164 = p;
              encode_value (D.29921, p.164, &p);
              D.29918 = entry->is_reg;
              if (D.29918 == 0) goto <D.29922>; else goto <D.29923>;
              <D.29922>:
              D.29924 = entry->offset;
              p.164 = p;
              encode_value (D.29924, p.164, &p);
              <D.29923>:
              if (i == 0) goto <D.29925>; else goto <D.29926>;
              <D.29925>:
              D.29927 = entry->from;
              D.29928 = D.29927 != 0;
              D.29929 = (long int) D.29928;
              D.29930 = __builtin_expect (D.29929, 0);
              if (D.29930 != 0) goto <D.29931>; else goto <D.29932>;
              <D.29931>:
              monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "aot-compiler.c", 5376, "entry->from == 0");
              <D.29932>:
              goto <D.29933>;
              <D.29926>:
              D.29927 = entry->from;
              p.164 = p;
              encode_value (D.29927, p.164, &p);
              <D.29933>:
              D.29934 = entry->to;
              p.164 = p;
              encode_value (D.29934, p.164, &p);
            }
            i = i + 1;
            <D.25009>:
            D.29912 = gi->nlocs;
            if (D.29912 > i) goto <D.25008>; else goto <D.25010>;
            <D.25010>:
            goto <D.29935>;
            <D.29914>:
            D.29783 = BIT_FIELD_REF <*cfg, 64, 5568>;
            D.29784 = D.29783 & 8388608;
            if (D.29784 == 0) goto <D.29936>; else goto <D.29937>;
            <D.29936>:
            D.29938 = BIT_FIELD_REF <*gi, 64, 192>;
            D.29939 = D.29938 & 8388608;
            D.29940 = D.29939 != 0;
            D.29941 = (int) D.29940;
            p.164 = p;
            encode_value (D.29941, p.164, &p);
            D.29942 = gi->this_reg;
            D.29943 = (int) D.29942;
            p.164 = p;
            encode_value (D.29943, p.164, &p);
            D.29944 = gi->this_offset;
            p.164 = p;
            encode_value (D.29944, p.164, &p);
            <D.29937>:
            <D.29935>:
            buf2 = monoeg_malloc (4096);
            p2 = buf2;
            D.29945 = jinfo->d.method;
            p2.171 = p2;
            encode_method_ref (acfg, D.29945, p2.171, &p2);
            p2.171 = p2;
            p2.172 = (long int) p2.171;
            buf2.173 = (long int) buf2;
            D.29949 = p2.172 - buf2.173;
            len = (int) D.29949;
            D.29950 = len > 4095;
            D.29951 = (long int) D.29950;
            D.29952 = __builtin_expect (D.29951, 0);
            if (D.29952 != 0) goto <D.29953>; else goto <D.29954>;
            <D.29953>:
            monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "aot-compiler.c", 5397, "len < 4096");
            <D.29954>:
            p.164 = p;
            encode_value (len, p.164, &p);
            p.164 = p;
            D.29955 = (long unsigned int) len;
            memcpy (p.164, buf2, D.29955);
            p.164 = p;
            p2.171 = p2;
            p2.172 = (long int) p2.171;
            buf2.173 = (long int) buf2;
            D.29949 = p2.172 - buf2.173;
            D.29956 = (sizetype) D.29949;
            p.174 = p.164 + D.29956;
            p = p.174;
            monoeg_g_free (buf2);
            if (gsctx != 0B) goto <D.29961>; else goto <D.29958>;
            <D.29961>:
            D.29962 = gsctx->var_is_vt;
            if (D.29962 != 0B) goto <D.29959>; else goto <D.29963>;
            <D.29963>:
            D.29964 = gsctx->mvar_is_vt;
            if (D.29964 != 0B) goto <D.29959>; else goto <D.29958>;
            <D.29959>:
            {
              struct MonoMethodInflated * inflated;
              struct MonoGenericContext * context;
              struct MonoGenericInst * inst;

              D.29945 = jinfo->d.method;
              D.29965 = BIT_FIELD_REF <*D.29945, 64, 256>;
              D.29966 = D.29965 & 2251799813685248;
              D.29967 = D.29966 == 0;
              D.29968 = (long int) D.29967;
              D.29969 = __builtin_expect (D.29968, 0);
              if (D.29969 != 0) goto <D.29970>; else goto <D.29971>;
              <D.29970>:
              monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "aot-compiler.c", 5408, "jinfo->d.method->is_inflated");
              <D.29971>:
              inflated = jinfo->d.method;
              context = &inflated->context;
              p.164 = p;
              encode_value (1, p.164, &p);
              D.29972 = context->class_inst;
              if (D.29972 != 0B) goto <D.29973>; else goto <D.29974>;
              <D.29973>:
              inst = context->class_inst;
              D.29975 = inst->type_argc;
              D.29976 = (int) D.29975;
              p.164 = p;
              encode_value (D.29976, p.164, &p);
              i = 0;
              goto <D.25015>;
              <D.25014>:
              D.29962 = gsctx->var_is_vt;
              D.29916 = (long unsigned int) i;
              D.29977 = D.29916 * 4;
              D.29978 = D.29962 + D.29977;
              D.29979 = *D.29978;
              p.164 = p;
              encode_value (D.29979, p.164, &p);
              i = i + 1;
              <D.25015>:
              D.29975 = inst->type_argc;
              D.29980 = (int) D.29975;
              if (D.29980 > i) goto <D.25014>; else goto <D.25016>;
              <D.25016>:
              goto <D.29981>;
              <D.29974>:
              p.164 = p;
              encode_value (0, p.164, &p);
              <D.29981>:
              D.29982 = context->method_inst;
              if (D.29982 != 0B) goto <D.29983>; else goto <D.29984>;
              <D.29983>:
              inst = context->method_inst;
              D.29975 = inst->type_argc;
              D.29976 = (int) D.29975;
              p.164 = p;
              encode_value (D.29976, p.164, &p);
              i = 0;
              goto <D.25018>;
              <D.25017>:
              D.29964 = gsctx->mvar_is_vt;
              D.29916 = (long unsigned int) i;
              D.29977 = D.29916 * 4;
              D.29985 = D.29964 + D.29977;
              D.29986 = *D.29985;
              p.164 = p;
              encode_value (D.29986, p.164, &p);
              i = i + 1;
              <D.25018>:
              D.29975 = inst->type_argc;
              D.29980 = (int) D.29975;
              if (D.29980 > i) goto <D.25017>; else goto <D.25019>;
              <D.25019>:
              goto <D.29987>;
              <D.29984>:
              p.164 = p;
              encode_value (0, p.164, &p);
              <D.29987>:
            }
            goto <D.29960>;
            <D.29958>:
            p.164 = p;
            encode_value (0, p.164, &p);
            <D.29960>:
          }
        finally
          {
            p2 = {CLOBBER};
          }
      }
      <D.29911>:
      if (seq_points != 0B) goto <D.29988>; else goto <D.29989>;
      <D.29988>:
      {
        int il_offset;
        int native_offset;
        int last_il_offset;
        int last_native_offset;
        int j;

        D.29751 = seq_points->len;
        p.164 = p;
        encode_value (D.29751, p.164, &p);
        last_native_offset = 0;
        last_il_offset = last_native_offset;
        i = 0;
        goto <D.25030>;
        <D.25029>:
        {
          struct SeqPoint * sp;

          sp = &seq_points->seq_points[i];
          il_offset = sp->il_offset;
          native_offset = sp->native_offset;
          D.29990 = il_offset - last_il_offset;
          p.164 = p;
          encode_value (D.29990, p.164, &p);
          D.29991 = native_offset - last_native_offset;
          p.164 = p;
          encode_value (D.29991, p.164, &p);
          last_il_offset = il_offset;
          last_native_offset = native_offset;
          D.29992 = sp->flags;
          p.164 = p;
          encode_value (D.29992, p.164, &p);
          D.29993 = sp->next_len;
          p.164 = p;
          encode_value (D.29993, p.164, &p);
          j = 0;
          goto <D.25027>;
          <D.25026>:
          D.29994 = sp->next;
          D.29995 = (long unsigned int) j;
          D.29996 = D.29995 * 4;
          D.29997 = D.29994 + D.29996;
          D.29998 = *D.29997;
          p.164 = p;
          encode_value (D.29998, p.164, &p);
          j = j + 1;
          <D.25027>:
          D.29993 = sp->next_len;
          if (D.29993 > j) goto <D.25026>; else goto <D.25028>;
          <D.25028>:
        }
        i = i + 1;
        <D.25030>:
        D.29751 = seq_points->len;
        if (D.29751 > i) goto <D.25029>; else goto <D.25031>;
        <D.25031>:
      }
      <D.29989>:
      debug_info_size.154 = debug_info_size;
      buf_size.175 = (unsigned int) buf_size;
      D.30000 = debug_info_size.154 >= buf_size.175;
      D.30001 = (long int) D.30000;
      D.30002 = __builtin_expect (D.30001, 0);
      if (D.30002 != 0) goto <D.30003>; else goto <D.30004>;
      <D.30003>:
      monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "aot-compiler.c", 5457, "debug_info_size < buf_size");
      <D.30004>:
      debug_info_size.154 = debug_info_size;
      debug_info_size.176 = (int) debug_info_size.154;
      p.164 = p;
      encode_value (debug_info_size.176, p.164, &p);
      debug_info_size.154 = debug_info_size;
      if (debug_info_size.154 != 0) goto <D.30006>; else goto <D.30007>;
      <D.30006>:
      p.164 = p;
      debug_info.177 = debug_info;
      debug_info_size.154 = debug_info_size;
      D.30009 = (long unsigned int) debug_info_size.154;
      memcpy (p.164, debug_info.177, D.30009);
      p.164 = p;
      debug_info_size.154 = debug_info_size;
      D.30010 = (sizetype) debug_info_size.154;
      p.178 = p.164 + D.30010;
      p = p.178;
      debug_info.177 = debug_info;
      monoeg_g_free (debug_info.177);
      <D.30007>:
      D.29796 = cfg->gc_map;
      if (D.29796 != 0B) goto <D.30012>; else goto <D.30013>;
      <D.30012>:
      D.29755 = cfg->gc_map_size;
      D.30014 = (int) D.29755;
      p.164 = p;
      encode_value (D.30014, p.164, &p);
      goto <D.25033>;
      <D.25032>:
      p.164 = p;
      p.179 = p.164 + 1;
      p = p.179;
      <D.25033>:
      p.164 = p;
      p.180 = (long unsigned int) p.164;
      D.30017 = p.180 & 3;
      if (D.30017 != 0) goto <D.25032>; else goto <D.25034>;
      <D.25034>:
      p.164 = p;
      D.29796 = cfg->gc_map;
      D.29755 = cfg->gc_map_size;
      D.30018 = (long unsigned int) D.29755;
      memcpy (p.164, D.29796, D.30018);
      p.164 = p;
      D.29755 = cfg->gc_map_size;
      D.30019 = (sizetype) D.29755;
      p.181 = p.164 + D.30019;
      p = p.181;
      <D.30013>:
      D.30021 = acfg->stats.ex_info_size;
      D.30022 = (unsigned int) D.30021;
      p.164 = p;
      p.182 = (long int) p.164;
      buf.183 = (long int) buf;
      D.30025 = p.182 - buf.183;
      D.30026 = (unsigned int) D.30025;
      D.30027 = D.30022 + D.30026;
      D.30028 = (int) D.30027;
      acfg->stats.ex_info_size = D.30028;
      p.164 = p;
      p.182 = (long int) p.164;
      buf.183 = (long int) buf;
      D.30025 = p.182 - buf.183;
      D.30029 = (long int) buf_size;
      D.30030 = D.30025 >= D.30029;
      D.30031 = (long int) D.30030;
      D.30032 = __builtin_expect (D.30031, 0);
      if (D.30032 != 0) goto <D.30033>; else goto <D.30034>;
      <D.30033>:
      monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "aot-compiler.c", 5478, "p - buf < buf_size");
      <D.30034>:
      p.164 = p;
      p.182 = (long int) p.164;
      buf.183 = (long int) buf;
      D.30025 = p.182 - buf.183;
      D.30035 = (unsigned int) D.30025;
      D.29796 = cfg->gc_map;
      if (D.29796 != 0B) goto <D.30037>; else goto <D.30038>;
      <D.30037>:
      iftmp.184 = 4;
      goto <D.30039>;
      <D.30038>:
      iftmp.184 = 1;
      <D.30039>:
      D.30040 = add_to_blob_aligned (acfg, buf, D.30035, iftmp.184);
      cfg->ex_info_offset = D.30040;
      monoeg_g_free (buf);
    }
  finally
    {
      debug_info_size = {CLOBBER};
      p = {CLOBBER};
      debug_info = {CLOBBER};
    }
}


get_unwind_info_offset (struct MonoAotCompile * acfg, guint8 * encoded, guint32 encoded_len)
{
  struct GHashTable * D.30041;
  unsigned int D.30042;
  long unsigned int D.30043;
  const void * D.30044;
  void * D.30045;
  long int D.30046;
  guint32 D.30049;
  void * D.30050;
  unsigned int D.30051;
  long unsigned int D.30052;
  void * D.30053;
  struct GPtrArray * D.30054;
  long unsigned int D.30055;
  void * D.30056;
  int encoded_len.185;
  guint8 * p.186;
  unsigned int D.30059;
  long int p.187;
  long int buf.188;
  long int D.30062;
  unsigned int D.30063;
  unsigned int D.30064;
  unsigned int D.30065;
  guint32 cache_index;
  guint32 offset;

  cache_index = mono_cache_unwind_info (encoded, encoded_len);
  D.30041 = acfg->unwind_info_offsets;
  D.30042 = cache_index + 1;
  D.30043 = (long unsigned int) D.30042;
  D.30044 = (const void *) D.30043;
  D.30045 = monoeg_g_hash_table_lookup (D.30041, D.30044);
  D.30046 = (long int) D.30045;
  offset = (guint32) D.30046;
  if (offset != 0) goto <D.30047>; else goto <D.30048>;
  <D.30047>:
  D.30049 = offset + 4294967295;
  return D.30049;
  <D.30048>:
  {
    guint8 buf[16];
    guint8 * p;

    try
      {
        offset = acfg->unwind_info_offset;
        D.30041 = acfg->unwind_info_offsets;
        D.30042 = cache_index + 1;
        D.30043 = (long unsigned int) D.30042;
        D.30050 = (void *) D.30043;
        D.30051 = offset + 1;
        D.30052 = (long unsigned int) D.30051;
        D.30053 = (void *) D.30052;
        monoeg_g_hash_table_insert_replace (D.30041, D.30050, D.30053, 0);
        D.30054 = acfg->unwind_ops;
        D.30055 = (long unsigned int) cache_index;
        D.30056 = (void *) D.30055;
        monoeg_g_ptr_array_add (D.30054, D.30056);
        p = &buf;
        encoded_len.185 = (int) encoded_len;
        p.186 = p;
        encode_value (encoded_len.185, p.186, &p);
        D.30059 = acfg->unwind_info_offset;
        p.186 = p;
        p.187 = (long int) p.186;
        buf.188 = (long int) &buf;
        D.30062 = p.187 - buf.188;
        D.30063 = (unsigned int) D.30062;
        D.30064 = D.30063 + encoded_len;
        D.30065 = D.30059 + D.30064;
        acfg->unwind_info_offset = D.30065;
        D.30049 = offset;
        return D.30049;
      }
    finally
      {
        buf = {CLOBBER};
        p = {CLOBBER};
      }
  }
}


add_to_blob_aligned (struct MonoAotCompile * acfg, const guint8 * data, guint32 data_len, guint32 align)
{
  unsigned int D.30068;
  struct MonoDynamicStream * D.30071;
  unsigned int D.30072;
  unsigned int D.30075;
  guint32 D.30076;
  char buf[4];
  guint32 count;

  try
    {
      buf = {};
      D.30068 = acfg->blob.alloc_size;
      if (D.30068 == 0) goto <D.30069>; else goto <D.30070>;
      <D.30069>:
      D.30071 = &acfg->blob;
      stream_init (D.30071);
      <D.30070>:
      D.30072 = acfg->blob.index;
      count = D.30072 % align;
      if (count != 0) goto <D.30073>; else goto <D.30074>;
      <D.30073>:
      D.30071 = &acfg->blob;
      D.30075 = 4 - count;
      add_stream_data (D.30071, &buf, D.30075);
      <D.30074>:
      D.30071 = &acfg->blob;
      D.30076 = add_stream_data (D.30071, data, data_len);
      return D.30076;
    }
  finally
    {
      buf = {CLOBBER};
    }
}


emit_unwind_info (struct MonoAotCompile * acfg)
{
  struct GPtrArray * D.30079;
  void * * D.30080;
  long unsigned int D.30081;
  long unsigned int D.30082;
  void * * D.30083;
  void * D.30084;
  long int D.30085;
  unsigned int unwind_info_len.189;
  int unwind_info_len.190;
  guint8 * p.191;
  long int p.192;
  long int buf.193;
  long int D.30091;
  int D.30092;
  int unwind_info_len.194;
  int D.30094;
  unsigned int D.30095;
  unsigned int D.30096;
  unsigned int D.30097;
  unsigned int D.30098;
  int D.30099;
  unsigned int D.30100;
  unsigned int i.195;
  int i;
  char symbol[128];

  try
    {
      sprintf (&symbol, "unwind_info");
      emit_section_change (acfg, ".rodata", 1);
      emit_alignment (acfg, 8);
      emit_label (acfg, &symbol);
      i = 0;
      goto <D.25556>;
      <D.25555>:
      {
        guint32 index;
        guint8 * unwind_info;
        guint32 unwind_info_len;
        guint8 buf[16];
        guint8 * p;

        try
          {
            D.30079 = acfg->unwind_ops;
            D.30080 = D.30079->pdata;
            D.30081 = (long unsigned int) i;
            D.30082 = D.30081 * 8;
            D.30083 = D.30080 + D.30082;
            D.30084 = *D.30083;
            D.30085 = (long int) D.30084;
            index = (guint32) D.30085;
            unwind_info = mono_get_cached_unwind_info (index, &unwind_info_len);
            p = &buf;
            unwind_info_len.189 = unwind_info_len;
            unwind_info_len.190 = (int) unwind_info_len.189;
            p.191 = p;
            encode_value (unwind_info_len.190, p.191, &p);
            p.191 = p;
            p.192 = (long int) p.191;
            buf.193 = (long int) &buf;
            D.30091 = p.192 - buf.193;
            D.30092 = (int) D.30091;
            emit_bytes (acfg, &buf, D.30092);
            unwind_info_len.189 = unwind_info_len;
            unwind_info_len.194 = (int) unwind_info_len.189;
            emit_bytes (acfg, unwind_info, unwind_info_len.194);
            D.30094 = acfg->stats.unwind_info_size;
            D.30095 = (unsigned int) D.30094;
            p.191 = p;
            p.192 = (long int) p.191;
            buf.193 = (long int) &buf;
            D.30091 = p.192 - buf.193;
            D.30096 = (unsigned int) D.30091;
            unwind_info_len.189 = unwind_info_len;
            D.30097 = D.30096 + unwind_info_len.189;
            D.30098 = D.30095 + D.30097;
            D.30099 = (int) D.30098;
            acfg->stats.unwind_info_size = D.30099;
          }
        finally
          {
            unwind_info_len = {CLOBBER};
            buf = {CLOBBER};
            p = {CLOBBER};
          }
      }
      i = i + 1;
      <D.25556>:
      D.30079 = acfg->unwind_ops;
      D.30100 = D.30079->len;
      i.195 = (unsigned int) i;
      if (D.30100 > i.195) goto <D.25555>; else goto <D.25557>;
      <D.25557>:
    }
  finally
    {
      symbol = {CLOBBER};
    }
}


emit_class_info (struct MonoAotCompile * acfg)
{
  struct MonoImage * D.30102;
  <unnamed-unsigned:24> D.30103;
  long unsigned int D.30104;
  long unsigned int D.30105;
  long unsigned int D.30106;
  long unsigned int D.30107;
  gint32 * D.30108;
  int D.30109;
  int D.30110;
  unsigned int D.30111;
  unsigned int D.30112;
  int D.30113;
  int D.30114;
  unsigned int D.30115;
  int D.30116;
  unsigned int D.30117;
  unsigned int D.30118;
  int D.30119;
  int i;
  char symbol[256];
  gint32 * offsets;

  try
    {
      D.30102 = acfg->image;
      D.30103 = D.30102->tables[2].rows;
      D.30104 = (long unsigned int) D.30103;
      D.30105 = D.30104 * 4;
      offsets = monoeg_malloc0 (D.30105);
      i = 0;
      goto <D.25565>;
      <D.25564>:
      D.30106 = (long unsigned int) i;
      D.30107 = D.30106 * 4;
      D.30108 = offsets + D.30107;
      D.30109 = i + 1;
      D.30110 = D.30109 | 33554432;
      D.30111 = (unsigned int) D.30110;
      D.30112 = emit_klass_info (acfg, D.30111);
      D.30113 = (int) D.30112;
      *D.30108 = D.30113;
      i = i + 1;
      <D.25565>:
      D.30102 = acfg->image;
      D.30103 = D.30102->tables[2].rows;
      D.30114 = (int) D.30103;
      if (D.30114 > i) goto <D.25564>; else goto <D.25566>;
      <D.25566>:
      sprintf (&symbol, "class_info_offsets");
      emit_section_change (acfg, ".rodata", 1);
      emit_alignment (acfg, 8);
      emit_label (acfg, &symbol);
      D.30102 = acfg->image;
      D.30103 = D.30102->tables[2].rows;
      D.30114 = (int) D.30103;
      D.30115 = emit_offset_table (acfg, D.30114, 10, offsets);
      D.30116 = acfg->stats.offsets_size;
      D.30117 = (unsigned int) D.30116;
      D.30118 = D.30117 + D.30115;
      D.30119 = (int) D.30118;
      acfg->stats.offsets_size = D.30119;
      monoeg_g_free (offsets);
    }
  finally
    {
      symbol = {CLOBBER};
    }
}


emit_klass_info (struct MonoAotCompile * acfg, guint32 token)
{
  struct MonoImage * D.30120;
  long unsigned int D.30123;
  guint8 * p.196;
  long int p.197;
  long int buf.198;
  long int D.30127;
  unsigned int D.30128;
  unsigned int D.30129;
  guint32 D.30130;
  int D.30131;
  int D.30132;
  _Bool D.30133;
  long int D.30134;
  long int D.30135;
  long unsigned int D.30138;
  long unsigned int D.30139;
  _Bool D.30140;
  long int D.30141;
  long int D.30142;
  int D.30145;
  _Bool D.30146;
  struct MonoMethod * * D.30147;
  long unsigned int D.30148;
  long unsigned int D.30149;
  struct MonoMethod * * D.30150;
  struct MonoMethodSignature * D.30153;
  long unsigned int D.30154;
  long unsigned int D.30155;
  struct GHashTable * D.30158;
  void * D.30159;
  struct MonoGenericContainer * D.30164;
  gboolean iftmp.199;
  int D.30170;
  int D.30171;
  <unnamed-unsigned:1> D.30172;
  int D.30173;
  int D.30174;
  int D.30175;
  <unnamed-unsigned:1> D.30176;
  int D.30177;
  int D.30178;
  int D.30179;
  <unnamed-unsigned:1> D.30180;
  int D.30181;
  int D.30182;
  int iftmp.200;
  struct MonoClassExt * D.30186;
  struct GList * D.30188;
  int D.30190;
  int D.30191;
  int D.30192;
  <unnamed-unsigned:1> D.30193;
  int D.30194;
  int D.30195;
  int D.30196;
  <unnamed-unsigned:1> D.30197;
  int D.30198;
  int D.30199;
  int D.30200;
  <unnamed-unsigned:1> D.30201;
  int D.30202;
  int D.30203;
  long unsigned int D.30204;
  struct MonoMethod * D.30207;
  long unsigned int D.30208;
  struct MonoMethod * D.30211;
  int D.30212;
  int D.30213;
  <unnamed-unsigned:4> D.30214;
  int D.30215;
  unsigned char D.30216;
  int D.30217;
  int D.30221;
  unsigned int D.30222;
  unsigned int D.30223;
  unsigned int D.30224;
  int D.30225;
  long int D.30226;
  _Bool D.30227;
  long int D.30228;
  long int D.30229;
  unsigned int D.30232;
  struct MonoClass * klass;
  guint8 * p;
  guint8 * buf;
  int i;
  int buf_size;
  int res;
  gboolean no_special_static;
  gboolean cant_encode;
  void * iter;

  try
    {
      D.30120 = acfg->image;
      klass = mono_class_get (D.30120, token);
      iter = 0B;
      if (klass == 0B) goto <D.30121>; else goto <D.30122>;
      <D.30121>:
      mono_loader_clear_error ();
      buf_size = 16;
      D.30123 = (long unsigned int) buf_size;
      buf = monoeg_malloc (D.30123);
      p = buf;
      p.196 = p;
      encode_value (-1, p.196, &p);
      p.196 = p;
      p.197 = (long int) p.196;
      buf.198 = (long int) buf;
      D.30127 = p.197 - buf.198;
      D.30128 = (unsigned int) D.30127;
      D.30129 = add_to_blob (acfg, buf, D.30128);
      res = (int) D.30129;
      monoeg_g_free (buf);
      D.30130 = (guint32) res;
      return D.30130;
      <D.30122>:
      D.30131 = klass->vtable_size;
      D.30132 = D.30131 + 640;
      buf_size = D.30132 * 16;
      D.30123 = (long unsigned int) buf_size;
      buf = monoeg_malloc (D.30123);
      p = buf;
      D.30133 = klass == 0B;
      D.30134 = (long int) D.30133;
      D.30135 = __builtin_expect (D.30134, 0);
      if (D.30135 != 0) goto <D.30136>; else goto <D.30137>;
      <D.30136>:
      monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "aot-compiler.c", 5514, "klass");
      <D.30137>:
      mono_class_init (klass);
      mono_class_get_nested_types (klass, &iter);
      D.30138 = BIT_FIELD_REF <*klass, 64, 256>;
      D.30139 = D.30138 & 4294967296;
      D.30140 = D.30139 == 0;
      D.30141 = (long int) D.30140;
      D.30142 = __builtin_expect (D.30141, 0);
      if (D.30142 != 0) goto <D.30143>; else goto <D.30144>;
      <D.30143>:
      monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "aot-compiler.c", 5519, "klass->nested_classes_inited");
      <D.30144>:
      mono_class_setup_vtable (klass);
      D.30145 = mono_class_has_special_static_fields (klass);
      D.30146 = D.30145 == 0;
      no_special_static = (gboolean) D.30146;
      cant_encode = 0;
      i = 0;
      goto <D.25050>;
      <D.25049>:
      {
        struct MonoMethod * cm;

        D.30147 = klass->vtable;
        D.30148 = (long unsigned int) i;
        D.30149 = D.30148 * 8;
        D.30150 = D.30147 + D.30149;
        cm = *D.30150;
        if (cm != 0B) goto <D.30151>; else goto <D.30152>;
        <D.30151>:
        D.30153 = mono_method_signature (cm);
        D.30154 = BIT_FIELD_REF <*D.30153, 64, 64>;
        D.30155 = D.30154 & 64;
        if (D.30155 != 0) goto <D.30156>; else goto <D.30157>;
        <D.30156>:
        D.30158 = acfg->token_info_hash;
        D.30159 = monoeg_g_hash_table_lookup (D.30158, cm);
        if (D.30159 == 0B) goto <D.30160>; else goto <D.30161>;
        <D.30160>:
        cant_encode = 1;
        <D.30161>:
        <D.30157>:
        <D.30152>:
      }
      i = i + 1;
      <D.25050>:
      D.30131 = klass->vtable_size;
      if (D.30131 > i) goto <D.25049>; else goto <D.25051>;
      <D.25051>:
      mono_class_has_finalizer (klass);
      D.30164 = klass->generic_container;
      if (D.30164 != 0B) goto <D.30162>; else goto <D.30165>;
      <D.30165>:
      if (cant_encode != 0) goto <D.30162>; else goto <D.30163>;
      <D.30162>:
      p.196 = p;
      encode_value (-1, p.196, &p);
      goto <D.25055>;
      <D.30163>:
      D.30131 = klass->vtable_size;
      p.196 = p;
      encode_value (D.30131, p.196, &p);
      D.30164 = klass->generic_container;
      if (D.30164 != 0B) goto <D.30167>; else goto <D.30168>;
      <D.30167>:
      iftmp.199 = 256;
      goto <D.30169>;
      <D.30168>:
      iftmp.199 = 0;
      <D.30169>:
      D.30170 = no_special_static << 7;
      D.30171 = iftmp.199 | D.30170;
      D.30172 = klass->has_static_refs;
      D.30173 = (int) D.30172;
      D.30174 = D.30173 << 6;
      D.30175 = D.30171 | D.30174;
      D.30176 = klass->has_references;
      D.30177 = (int) D.30176;
      D.30178 = D.30177 << 5;
      D.30179 = D.30175 | D.30178;
      D.30180 = klass->blittable;
      D.30181 = (int) D.30180;
      D.30182 = D.30181 << 4;
      D.30186 = klass->ext;
      if (D.30186 != 0B) goto <D.30187>; else goto <D.30184>;
      <D.30187>:
      D.30186 = klass->ext;
      D.30188 = D.30186->nested_classes;
      if (D.30188 != 0B) goto <D.30189>; else goto <D.30184>;
      <D.30189>:
      iftmp.200 = 1;
      goto <D.30185>;
      <D.30184>:
      iftmp.200 = 0;
      <D.30185>:
      D.30190 = iftmp.200 << 3;
      D.30191 = D.30182 | D.30190;
      D.30192 = D.30179 | D.30191;
      D.30193 = klass->has_cctor;
      D.30194 = (int) D.30193;
      D.30195 = D.30194 << 2;
      D.30196 = D.30192 | D.30195;
      D.30197 = klass->has_finalize;
      D.30198 = (int) D.30197;
      D.30199 = D.30198 << 1;
      D.30200 = D.30196 | D.30199;
      D.30201 = klass->ghcimpl;
      D.30202 = (int) D.30201;
      D.30203 = D.30200 | D.30202;
      p.196 = p;
      encode_value (D.30203, p.196, &p);
      D.30138 = BIT_FIELD_REF <*klass, 64, 256>;
      D.30204 = D.30138 & 137438953472;
      if (D.30204 != 0) goto <D.30205>; else goto <D.30206>;
      <D.30205>:
      D.30207 = mono_class_get_cctor (klass);
      p.196 = p;
      encode_method_ref (acfg, D.30207, p.196, &p);
      <D.30206>:
      D.30138 = BIT_FIELD_REF <*klass, 64, 256>;
      D.30208 = D.30138 & 4398046511104;
      if (D.30208 != 0) goto <D.30209>; else goto <D.30210>;
      <D.30209>:
      D.30211 = mono_class_get_finalizer (klass);
      p.196 = p;
      encode_method_ref (acfg, D.30211, p.196, &p);
      <D.30210>:
      D.30212 = klass->instance_size;
      p.196 = p;
      encode_value (D.30212, p.196, &p);
      D.30213 = mono_class_data_size (klass);
      p.196 = p;
      encode_value (D.30213, p.196, &p);
      D.30214 = klass->packing_size;
      D.30215 = (int) D.30214;
      p.196 = p;
      encode_value (D.30215, p.196, &p);
      D.30216 = klass->min_align;
      D.30217 = (int) D.30216;
      p.196 = p;
      encode_value (D.30217, p.196, &p);
      i = 0;
      goto <D.25054>;
      <D.25053>:
      {
        struct MonoMethod * cm;

        D.30147 = klass->vtable;
        D.30148 = (long unsigned int) i;
        D.30149 = D.30148 * 8;
        D.30150 = D.30147 + D.30149;
        cm = *D.30150;
        if (cm != 0B) goto <D.30218>; else goto <D.30219>;
        <D.30218>:
        p.196 = p;
        encode_method_ref (acfg, cm, p.196, &p);
        goto <D.30220>;
        <D.30219>:
        p.196 = p;
        encode_value (0, p.196, &p);
        <D.30220>:
      }
      i = i + 1;
      <D.25054>:
      D.30131 = klass->vtable_size;
      if (D.30131 > i) goto <D.25053>; else goto <D.25055>;
      <D.25055>:
      D.30221 = acfg->stats.class_info_size;
      D.30222 = (unsigned int) D.30221;
      p.196 = p;
      p.197 = (long int) p.196;
      buf.198 = (long int) buf;
      D.30127 = p.197 - buf.198;
      D.30223 = (unsigned int) D.30127;
      D.30224 = D.30222 + D.30223;
      D.30225 = (int) D.30224;
      acfg->stats.class_info_size = D.30225;
      p.196 = p;
      p.197 = (long int) p.196;
      buf.198 = (long int) buf;
      D.30127 = p.197 - buf.198;
      D.30226 = (long int) buf_size;
      D.30227 = D.30127 >= D.30226;
      D.30228 = (long int) D.30227;
      D.30229 = __builtin_expect (D.30228, 0);
      if (D.30229 != 0) goto <D.30230>; else goto <D.30231>;
      <D.30230>:
      monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "aot-compiler.c", 5569, "p - buf < buf_size");
      <D.30231>:
      p.196 = p;
      p.197 = (long int) p.196;
      buf.198 = (long int) buf;
      D.30127 = p.197 - buf.198;
      D.30128 = (unsigned int) D.30127;
      D.30232 = add_to_blob (acfg, buf, D.30128);
      res = (int) D.30232;
      monoeg_g_free (buf);
      D.30130 = (guint32) res;
      return D.30130;
    }
  finally
    {
      p = {CLOBBER};
      iter = {CLOBBER};
    }
}


emit_plt (struct MonoAotCompile * acfg)
{
  char * D.30235;
  struct GHashTable * D.30238;
  long unsigned int D.30239;
  const void * D.30240;
  int D.30241;
  int D.30246;
  int D.30249;
  struct GHashTable * D.30252;
  struct MonoMethod * D.30253;
  int D.30258;
  long unsigned int D.30260;
  long unsigned int D.30261;
  struct FILE * D.30263;
  char * D.30264;
  char * D.30265;
  int D.30268;
  int D.30277;
  char * D.30280;
  unsigned int D.30283;
  unsigned int i.201;
  int D.30291;
  int D.30296;
  int D.30299;
  char * D.30302;
  char * D.30307;
  char symbol[128];
  int i;

  try
    {
      emit_line (acfg);
      sprintf (&symbol, "plt");
      emit_section_change (acfg, ".text", 0);
      emit_alignment (acfg, 16);
      emit_label (acfg, &symbol);
      D.30235 = acfg->plt_symbol;
      emit_label (acfg, D.30235);
      i = 0;
      goto <D.25084>;
      <D.25083>:
      {
        char * debug_sym;
        struct MonoPltEntry * plt_entry;
        struct MonoJumpInfo * ji;

        debug_sym = 0B;
        plt_entry = 0B;
        if (i == 0) goto <D.30236>; else goto <D.30237>;
        <D.30236>:
        // predicted unlikely by continue predictor.
        goto <D.25081>;
        <D.30237>:
        D.30238 = acfg->plt_offset_to_entry;
        D.30239 = (long unsigned int) i;
        D.30240 = (const void *) D.30239;
        plt_entry = monoeg_g_hash_table_lookup (D.30238, D.30240);
        ji = plt_entry->ji;
        D.30241 = acfg->llvm;
        if (D.30241 != 0) goto <D.30242>; else goto <D.30243>;
        <D.30242>:
        if (ji != 0B) goto <D.30244>; else goto <D.30245>;
        <D.30244>:
        D.30246 = is_direct_callable (acfg, 0B, ji);
        if (D.30246 != 0) goto <D.30247>; else goto <D.30248>;
        <D.30247>:
        D.30249 = acfg->use_bin_writer;
        if (D.30249 == 0) goto <D.30250>; else goto <D.30251>;
        <D.30250>:
        {
          struct MonoCompile * callee_cfg;

          D.30252 = acfg->method_to_cfg;
          D.30253 = ji->data.method;
          callee_cfg = monoeg_g_hash_table_lookup (D.30252, D.30253);
          if (callee_cfg != 0B) goto <D.30254>; else goto <D.30255>;
          <D.30254>:
          D.30258 = acfg->thumb_mixed;
          if (D.30258 != 0) goto <D.30259>; else goto <D.30256>;
          <D.30259>:
          D.30260 = BIT_FIELD_REF <*callee_cfg, 64, 5568>;
          D.30261 = D.30260 & 8388608;
          if (D.30261 == 0) goto <D.30262>; else goto <D.30256>;
          <D.30262>:
          emit_set_thumb_mode (acfg);
          D.30263 = acfg->fp;
          fprintf (D.30263, "\n.thumb_func\n");
          D.30264 = plt_entry->llvm_symbol;
          emit_label (acfg, D.30264);
          D.30263 = acfg->fp;
          fprintf (D.30263, "bx pc\n");
          D.30263 = acfg->fp;
          fprintf (D.30263, "nop\n");
          emit_set_arm_mode (acfg);
          D.30263 = acfg->fp;
          D.30265 = callee_cfg->asm_symbol;
          fprintf (D.30263, "b %s\n", D.30265);
          goto <D.30257>;
          <D.30256>:
          D.30263 = acfg->fp;
          D.30264 = plt_entry->llvm_symbol;
          D.30265 = callee_cfg->asm_symbol;
          fprintf (D.30263, "\n.set %s, %s\n", D.30264, D.30265);
          <D.30257>:
          // predicted unlikely by continue predictor.
          goto <D.25081>;
          <D.30255>:
        }
        <D.30251>:
        <D.30248>:
        <D.30245>:
        <D.30243>:
        debug_sym = plt_entry->debug_sym;
        D.30258 = acfg->thumb_mixed;
        if (D.30258 != 0) goto <D.30266>; else goto <D.30267>;
        <D.30266>:
        D.30268 = plt_entry->jit_used;
        if (D.30268 == 0) goto <D.30269>; else goto <D.30270>;
        <D.30269>:
        // predicted unlikely by continue predictor.
        goto <D.25081>;
        <D.30270>:
        <D.30267>:
        D.30241 = acfg->llvm;
        if (D.30241 != 0) goto <D.30271>; else goto <D.30272>;
        <D.30271>:
        D.30258 = acfg->thumb_mixed;
        if (D.30258 == 0) goto <D.30273>; else goto <D.30274>;
        <D.30273>:
        D.30264 = plt_entry->llvm_symbol;
        emit_label (acfg, D.30264);
        <D.30274>:
        <D.30272>:
        if (debug_sym != 0B) goto <D.30275>; else goto <D.30276>;
        <D.30275>:
        D.30277 = acfg->need_no_dead_strip;
        if (D.30277 != 0) goto <D.30278>; else goto <D.30279>;
        <D.30278>:
        emit_unset_mode (acfg);
        D.30263 = acfg->fp;
        fprintf (D.30263, "\t.no_dead_strip %s\n", debug_sym);
        <D.30279>:
        emit_local_symbol (acfg, debug_sym, 0B, 1);
        emit_label (acfg, debug_sym);
        <D.30276>:
        D.30280 = plt_entry->symbol;
        emit_label (acfg, D.30280);
        arch_emit_plt_entry (acfg, i);
        if (debug_sym != 0B) goto <D.30281>; else goto <D.30282>;
        <D.30281>:
        emit_symbol_size (acfg, debug_sym, ".");
        <D.30282>:
      }
      <D.25081>:
      i = i + 1;
      <D.25084>:
      D.30283 = acfg->plt_offset;
      i.201 = (unsigned int) i;
      if (D.30283 > i.201) goto <D.25083>; else goto <D.25085>;
      <D.25085>:
      D.30258 = acfg->thumb_mixed;
      if (D.30258 != 0) goto <D.30285>; else goto <D.30286>;
      <D.30285>:
      emit_zero_bytes (acfg, 16);
      i = 0;
      goto <D.25091>;
      <D.25090>:
      {
        char * debug_sym;
        struct MonoPltEntry * plt_entry;
        struct MonoJumpInfo * ji;

        debug_sym = 0B;
        plt_entry = 0B;
        if (i == 0) goto <D.30287>; else goto <D.30288>;
        <D.30287>:
        // predicted unlikely by continue predictor.
        goto <D.25089>;
        <D.30288>:
        D.30238 = acfg->plt_offset_to_entry;
        D.30239 = (long unsigned int) i;
        D.30240 = (const void *) D.30239;
        plt_entry = monoeg_g_hash_table_lookup (D.30238, D.30240);
        ji = plt_entry->ji;
        if (ji != 0B) goto <D.30289>; else goto <D.30290>;
        <D.30289>:
        D.30291 = is_direct_callable (acfg, 0B, ji);
        if (D.30291 != 0) goto <D.30292>; else goto <D.30293>;
        <D.30292>:
        D.30249 = acfg->use_bin_writer;
        if (D.30249 == 0) goto <D.30294>; else goto <D.30295>;
        <D.30294>:
        // predicted unlikely by continue predictor.
        goto <D.25089>;
        <D.30295>:
        <D.30293>:
        <D.30290>:
        D.30296 = plt_entry->llvm_used;
        if (D.30296 == 0) goto <D.30297>; else goto <D.30298>;
        <D.30297>:
        // predicted unlikely by continue predictor.
        goto <D.25089>;
        <D.30298>:
        D.30299 = acfg->aot_opts.write_symbols;
        if (D.30299 != 0) goto <D.30300>; else goto <D.30301>;
        <D.30300>:
        D.30302 = plt_entry->debug_sym;
        if (D.30302 != 0B) goto <D.30303>; else goto <D.30304>;
        <D.30303>:
        D.30302 = plt_entry->debug_sym;
        debug_sym = monoeg_g_strdup_printf ("%s_thumb", D.30302);
        <D.30304>:
        <D.30301>:
        if (debug_sym != 0B) goto <D.30305>; else goto <D.30306>;
        <D.30305>:
        emit_local_symbol (acfg, debug_sym, 0B, 1);
        emit_label (acfg, debug_sym);
        <D.30306>:
        D.30263 = acfg->fp;
        fprintf (D.30263, "\n.thumb_func\n");
        D.30307 = plt_entry->llvm_symbol;
        emit_label (acfg, D.30307);
        arch_emit_llvm_plt_entry (acfg, i);
        if (debug_sym != 0B) goto <D.30308>; else goto <D.30309>;
        <D.30308>:
        emit_symbol_size (acfg, debug_sym, ".");
        monoeg_g_free (debug_sym);
        <D.30309>:
      }
      <D.25089>:
      i = i + 1;
      <D.25091>:
      D.30283 = acfg->plt_offset;
      i.201 = (unsigned int) i;
      if (D.30283 > i.201) goto <D.25090>; else goto <D.25092>;
      <D.25092>:
      <D.30286>:
      D.30235 = acfg->plt_symbol;
      emit_symbol_size (acfg, D.30235, ".");
      sprintf (&symbol, "plt_end");
      emit_label (acfg, &symbol);
    }
  finally
    {
      symbol = {CLOBBER};
    }
}


arch_emit_plt_entry (struct MonoAotCompile * acfg, int index)
{
  monoeg_assertion_message ("* Assertion: should not be reached at %s:%d\n", "aot-compiler.c", 969);
}


is_direct_callable (struct MonoAotCompile * acfg, struct MonoMethod * method, struct MonoJumpInfo * patch_info)
{
  <unnamed type> D.30312;
  struct MonoMethod * D.30314;
  struct MonoClass * D.30315;
  struct MonoImage * D.30316;
  struct MonoImage * D.30317;
  struct GHashTable * D.30319;
  long unsigned int D.30326;
  long unsigned int D.30327;
  struct MonoMethod * D.30329;
  struct MonoClass * D.30330;
  unsigned int D.30331;
  unsigned int D.30332;
  short unsigned int D.30335;
  int D.30336;
  int D.30337;
  long unsigned int D.30341;
  long unsigned int D.30342;
  int D.30345;
  int D.30347;
  long unsigned int D.30348;
  long unsigned int D.30349;
  gboolean D.30354;
  short unsigned int D.30358;
  int D.30359;
  int D.30360;
  int D.30362;
  int D.30367;

  D.30312 = patch_info->type;
  if (D.30312 == 3) goto <D.30313>; else goto <D.30310>;
  <D.30313>:
  D.30314 = patch_info->data.method;
  D.30315 = D.30314->klass;
  D.30316 = D.30315->image;
  D.30317 = acfg->image;
  if (D.30316 == D.30317) goto <D.30318>; else goto <D.30310>;
  <D.30318>:
  {
    struct MonoCompile * callee_cfg;

    D.30319 = acfg->method_to_cfg;
    D.30314 = patch_info->data.method;
    callee_cfg = monoeg_g_hash_table_lookup (D.30319, D.30314);
    if (callee_cfg != 0B) goto <D.30320>; else goto <D.30321>;
    <D.30320>:
    {
      gboolean direct_callable;

      direct_callable = 1;
      if (direct_callable != 0) goto <D.30324>; else goto <D.30325>;
      <D.30324>:
      D.30326 = BIT_FIELD_REF <*callee_cfg, 64, 5632>;
      D.30327 = D.30326 & 9223372036854775808;
      if (D.30327 != 0) goto <D.30322>; else goto <D.30328>;
      <D.30328>:
      D.30329 = callee_cfg->method;
      D.30330 = D.30329->klass;
      D.30331 = D.30330->flags;
      D.30332 = D.30331 & 1048576;
      if (D.30332 == 0) goto <D.30322>; else goto <D.30323>;
      <D.30322>:
      direct_callable = 0;
      <D.30323>:
      <D.30325>:
      D.30329 = callee_cfg->method;
      D.30335 = D.30329->iflags;
      D.30336 = (int) D.30335;
      D.30337 = D.30336 & 32;
      if (D.30337 != 0) goto <D.30338>; else goto <D.30339>;
      <D.30338>:
      if (method == 0B) goto <D.30333>; else goto <D.30340>;
      <D.30340>:
      D.30341 = BIT_FIELD_REF <*method, 64, 256>;
      D.30342 = D.30341 & 4467570830351532032;
      if (D.30342 != 2305843009213693952) goto <D.30333>; else goto <D.30334>;
      <D.30333>:
      direct_callable = 0;
      <D.30334>:
      <D.30339>:
      D.30345 = acfg->aot_opts.soft_debug;
      if (D.30345 != 0) goto <D.30343>; else goto <D.30346>;
      <D.30346>:
      D.30347 = acfg->aot_opts.no_direct_calls;
      if (D.30347 != 0) goto <D.30343>; else goto <D.30344>;
      <D.30343>:
      direct_callable = 0;
      <D.30344>:
      D.30329 = callee_cfg->method;
      D.30348 = BIT_FIELD_REF <*D.30329, 64, 256>;
      D.30349 = D.30348 & 4467570830351532032;
      if (D.30349 == 4035225266123964416) goto <D.30350>; else goto <D.30351>;
      <D.30350>:
      direct_callable = 0;
      <D.30351>:
      if (direct_callable != 0) goto <D.30352>; else goto <D.30353>;
      <D.30352>:
      D.30354 = 1;
      return D.30354;
      <D.30353>:
    }
    <D.30321>:
  }
  goto <D.30311>;
  <D.30310>:
  D.30312 = patch_info->type;
  if (D.30312 == 31) goto <D.30357>; else goto <D.30355>;
  <D.30357>:
  D.30314 = patch_info->data.method;
  D.30358 = D.30314->flags;
  D.30359 = (int) D.30358;
  D.30360 = D.30359 & 8192;
  if (D.30360 != 0) goto <D.30361>; else goto <D.30355>;
  <D.30361>:
  D.30362 = acfg->aot_opts.direct_pinvoke;
  if (D.30362 != 0) goto <D.30363>; else goto <D.30364>;
  <D.30363>:
  D.30354 = 1;
  return D.30354;
  <D.30364>:
  goto <D.30356>;
  <D.30355>:
  D.30312 = patch_info->type;
  if (D.30312 == 31) goto <D.30365>; else goto <D.30366>;
  <D.30365>:
  D.30367 = acfg->aot_opts.direct_icalls;
  if (D.30367 != 0) goto <D.30368>; else goto <D.30369>;
  <D.30368>:
  D.30354 = 1;
  return D.30354;
  <D.30369>:
  D.30354 = 0;
  return D.30354;
  <D.30366>:
  <D.30356>:
  <D.30311>:
  D.30354 = 0;
  return D.30354;
}


arch_emit_llvm_plt_entry (struct MonoAotCompile * acfg, int index)
{
  monoeg_assertion_message ("* Assertion: should not be reached at %s:%d\n", "aot-compiler.c", 1006);
}


emit_image_table (struct MonoAotCompile * acfg)
{
  struct GPtrArray * D.30371;
  unsigned int D.30372;
  int D.30373;
  void * * D.30374;
  long unsigned int D.30375;
  long unsigned int D.30376;
  void * * D.30377;
  struct MonoAssembly * D.30378;
  struct MonoImage * D.30379;
  _Bool D.30380;
  long int D.30381;
  long int D.30382;
  const char * D.30385;
  char * D.30386;
  const char * iftmp.202;
  const char * D.30388;
  mono_byte[17] * D.30392;
  unsigned int D.30393;
  int D.30394;
  short unsigned int D.30395;
  int D.30396;
  short unsigned int D.30397;
  int D.30398;
  short unsigned int D.30399;
  int D.30400;
  short unsigned int D.30401;
  int D.30402;
  unsigned int i.203;
  int i;
  char symbol[256];

  try
    {
      sprintf (&symbol, "image_table");
      emit_section_change (acfg, ".rodata", 1);
      emit_alignment (acfg, 8);
      emit_label (acfg, &symbol);
      D.30371 = acfg->image_table;
      D.30372 = D.30371->len;
      D.30373 = (int) D.30372;
      emit_int32 (acfg, D.30373);
      i = 0;
      goto <D.25607>;
      <D.25606>:
      {
        struct MonoImage * image;
        struct MonoAssemblyName * aname;

        D.30371 = acfg->image_table;
        D.30374 = D.30371->pdata;
        D.30375 = (long unsigned int) i;
        D.30376 = D.30375 * 8;
        D.30377 = D.30374 + D.30376;
        image = *D.30377;
        D.30378 = image->assembly;
        aname = &D.30378->aname;
        D.30378 = image->assembly;
        D.30379 = D.30378->image;
        D.30380 = D.30379 != image;
        D.30381 = (long int) D.30380;
        D.30382 = __builtin_expect (D.30381, 0);
        if (D.30382 != 0) goto <D.30383>; else goto <D.30384>;
        <D.30383>:
        monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "aot-compiler.c", 7785, "image->assembly->image == image");
        <D.30384>:
        D.30385 = image->assembly_name;
        emit_string (acfg, D.30385);
        D.30386 = image->guid;
        emit_string (acfg, D.30386);
        D.30388 = aname->culture;
        if (D.30388 != 0B) goto <D.30389>; else goto <D.30390>;
        <D.30389>:
        iftmp.202 = aname->culture;
        goto <D.30391>;
        <D.30390>:
        iftmp.202 = "";
        <D.30391>:
        emit_string (acfg, iftmp.202);
        D.30392 = &aname->public_key_token;
        emit_string (acfg, D.30392);
        emit_alignment (acfg, 8);
        D.30393 = aname->flags;
        D.30394 = (int) D.30393;
        emit_int32 (acfg, D.30394);
        D.30395 = aname->major;
        D.30396 = (int) D.30395;
        emit_int32 (acfg, D.30396);
        D.30397 = aname->minor;
        D.30398 = (int) D.30397;
        emit_int32 (acfg, D.30398);
        D.30399 = aname->build;
        D.30400 = (int) D.30399;
        emit_int32 (acfg, D.30400);
        D.30401 = aname->revision;
        D.30402 = (int) D.30401;
        emit_int32 (acfg, D.30402);
      }
      i = i + 1;
      <D.25607>:
      D.30371 = acfg->image_table;
      D.30372 = D.30371->len;
      i.203 = (unsigned int) i;
      if (D.30372 > i.203) goto <D.25606>; else goto <D.25608>;
      <D.25608>:
    }
  finally
    {
      symbol = {CLOBBER};
    }
}


emit_string (struct MonoAotCompile * acfg, const char * value)
{
  struct MonoImageWriter * D.30404;

  D.30404 = acfg->w;
  img_writer_emit_string (D.30404, value);
}


emit_got (struct MonoAotCompile * acfg)
{
  int D.30405;
  char * D.30408;
  unsigned int D.30409;
  unsigned int D.30412;
  int D.30413;
  char symbol[256];

  try
    {
      D.30405 = acfg->llvm;
      if (D.30405 == 0) goto <D.30406>; else goto <D.30407>;
      <D.30406>:
      D.30408 = acfg->got_symbol;
      sprintf (&symbol, "%s", D.30408);
      emit_section_change (acfg, ".bss", 0);
      emit_alignment (acfg, 8);
      emit_local_symbol (acfg, &symbol, "got_end", 0);
      emit_label (acfg, &symbol);
      D.30409 = acfg->got_offset;
      if (D.30409 != 0) goto <D.30410>; else goto <D.30411>;
      <D.30410>:
      D.30409 = acfg->got_offset;
      D.30412 = D.30409 * 8;
      D.30413 = (int) D.30412;
      emit_zero_bytes (acfg, D.30413);
      <D.30411>:
      sprintf (&symbol, "got_end");
      emit_label (acfg, &symbol);
      <D.30407>:
    }
  finally
    {
      symbol = {CLOBBER};
    }
}


emit_file_info (struct MonoAotCompile * acfg)
{
  struct MonoImage * D.30414;
  char * D.30415;
  int D.30416;
  struct MonoAssembly * D.30420;
  const char * D.30421;
  long unsigned int D.30422;
  unsigned int D.30423;
  unsigned int D.30424;
  unsigned int D.30425;
  const char * D.30426;
  int D.30427;
  char * D.30430;
  char * D.30431;
  int D.30432;
  int D.30436;
  unsigned int D.30440;
  int D.30444;
  unsigned int D.30451;
  int D.30452;
  unsigned int D.30453;
  unsigned int D.30454;
  int D.30455;
  unsigned int D.30456;
  int D.30457;
  unsigned int D.30458;
  int D.30459;
  <unnamed type> D.30460;
  int D.30461;
  unsigned int D.30462;
  int D.30463;
  unsigned int D.30464;
  int D.30465;
  unsigned int D.30466;
  int D.30467;
  unsigned int D.30468;
  int D.30469;
  unsigned int D.30470;
  int D.30471;
  int D.30472;
  unsigned int D.30473;
  int D.30474;
  unsigned int D.30475;
  int D.30476;
  const short unsigned int * * D.30479;
  const short unsigned int * D.30480;
  char D.30481;
  long unsigned int D.30482;
  long unsigned int D.30483;
  const short unsigned int * D.30484;
  short unsigned int D.30485;
  int D.30486;
  int D.30487;
  gchar * D.30492;
  char symbol[256];
  int i;
  int gc_name_offset;
  const char * gc_name;
  char * build_info;

  try
    {
      D.30414 = acfg->image;
      D.30415 = D.30414->guid;
      emit_string_symbol (acfg, "assembly_guid", D.30415);
      D.30416 = acfg->aot_opts.bind_to_runtime_version;
      if (D.30416 != 0) goto <D.30417>; else goto <D.30418>;
      <D.30417>:
      build_info = mono_get_runtime_build_info ();
      emit_string_symbol (acfg, "runtime_version", build_info);
      monoeg_g_free (build_info);
      goto <D.30419>;
      <D.30418>:
      emit_string_symbol (acfg, "runtime_version", "");
      <D.30419>:
      D.30414 = acfg->image;
      D.30420 = D.30414->assembly;
      D.30421 = D.30420->aname.name;
      emit_string_symbol (acfg, "assembly_name", D.30421);
      gc_name = mono_gc_get_gc_name ();
      D.30422 = __strlen_g (gc_name);
      D.30423 = (unsigned int) D.30422;
      D.30424 = D.30423 + 1;
      D.30425 = add_to_blob (acfg, gc_name, D.30424);
      gc_name_offset = (int) D.30425;
      D.30426 = acfg->user_symbol_prefix;
      sprintf (&symbol, "%smono_aot_file_info", D.30426);
      emit_section_change (acfg, ".data", 0);
      emit_alignment (acfg, 8);
      emit_label (acfg, &symbol);
      D.30427 = acfg->aot_opts.static_link;
      if (D.30427 == 0) goto <D.30428>; else goto <D.30429>;
      <D.30428>:
      emit_global (acfg, &symbol, 0);
      <D.30429>:
      emit_int32 (acfg, 97);
      emit_int32 (acfg, 0);
      D.30430 = acfg->got_symbol;
      emit_pointer (acfg, D.30430);
      D.30431 = acfg->methods_symbol;
      emit_pointer (acfg, D.30431);
      D.30432 = acfg->llvm;
      if (D.30432 != 0) goto <D.30433>; else goto <D.30434>;
      <D.30433>:
      emit_pointer (acfg, "mono_eh_frame");
      goto <D.30435>;
      <D.30434>:
      emit_pointer (acfg, 0B);
      <D.30435>:
      emit_pointer (acfg, "blob");
      emit_pointer (acfg, "class_name_table");
      emit_pointer (acfg, "class_info_offsets");
      emit_pointer (acfg, "method_info_offsets");
      emit_pointer (acfg, "ex_info_offsets");
      emit_pointer (acfg, "code_offsets");
      D.30436 = acfg->direct_method_addresses;
      if (D.30436 != 0) goto <D.30437>; else goto <D.30438>;
      <D.30437>:
      emit_pointer (acfg, "method_addresses");
      goto <D.30439>;
      <D.30438>:
      emit_pointer (acfg, 0B);
      <D.30439>:
      emit_pointer (acfg, "extra_method_info_offsets");
      emit_pointer (acfg, "extra_method_table");
      emit_pointer (acfg, "got_info_offsets");
      emit_pointer (acfg, "methods_end");
      emit_pointer (acfg, "unwind_info");
      emit_pointer (acfg, "mem_end");
      emit_pointer (acfg, "image_table");
      emit_pointer (acfg, "plt");
      emit_pointer (acfg, "plt_end");
      emit_pointer (acfg, "assembly_guid");
      emit_pointer (acfg, "runtime_version");
      D.30440 = acfg->num_trampoline_got_entries;
      if (D.30440 != 0) goto <D.30441>; else goto <D.30442>;
      <D.30441>:
      emit_pointer (acfg, "specific_trampolines");
      emit_pointer (acfg, "static_rgctx_trampolines");
      emit_pointer (acfg, "imt_thunks");
      emit_pointer (acfg, "gsharedvt_arg_trampolines");
      goto <D.30443>;
      <D.30442>:
      emit_pointer (acfg, 0B);
      emit_pointer (acfg, 0B);
      emit_pointer (acfg, 0B);
      emit_pointer (acfg, 0B);
      <D.30443>:
      D.30444 = acfg->thumb_mixed;
      if (D.30444 != 0) goto <D.30445>; else goto <D.30446>;
      <D.30445>:
      emit_pointer (acfg, "thumb_end");
      goto <D.30447>;
      <D.30446>:
      emit_pointer (acfg, 0B);
      <D.30447>:
      D.30427 = acfg->aot_opts.static_link;
      if (D.30427 != 0) goto <D.30448>; else goto <D.30449>;
      <D.30448>:
      emit_pointer (acfg, "globals");
      goto <D.30450>;
      <D.30449>:
      emit_pointer (acfg, 0B);
      <D.30450>:
      emit_pointer (acfg, "assembly_name");
      emit_pointer (acfg, "unbox_trampolines");
      emit_pointer (acfg, "unbox_trampolines_end");
      D.30451 = acfg->plt_got_offset_base;
      D.30452 = (int) D.30451;
      emit_int32 (acfg, D.30452);
      D.30453 = acfg->got_offset;
      D.30454 = D.30453 * 8;
      D.30455 = (int) D.30454;
      emit_int32 (acfg, D.30455);
      D.30456 = acfg->plt_offset;
      D.30457 = (int) D.30456;
      emit_int32 (acfg, D.30457);
      D.30458 = acfg->nmethods;
      D.30459 = (int) D.30458;
      emit_int32 (acfg, D.30459);
      D.30460 = acfg->flags;
      D.30461 = (int) D.30460;
      emit_int32 (acfg, D.30461);
      D.30462 = acfg->opts;
      D.30463 = (int) D.30462;
      emit_int32 (acfg, D.30463);
      D.30464 = acfg->simd_opts;
      D.30465 = (int) D.30464;
      emit_int32 (acfg, D.30465);
      emit_int32 (acfg, gc_name_offset);
      i = 0;
      goto <D.25686>;
      <D.25685>:
      D.30466 = acfg->num_trampolines[i];
      D.30467 = (int) D.30466;
      emit_int32 (acfg, D.30467);
      i = i + 1;
      <D.25686>:
      if (i <= 3) goto <D.25685>; else goto <D.25687>;
      <D.25687>:
      i = 0;
      goto <D.25689>;
      <D.25688>:
      D.30468 = acfg->trampoline_got_offset_base[i];
      D.30469 = (int) D.30468;
      emit_int32 (acfg, D.30469);
      i = i + 1;
      <D.25689>:
      if (i <= 3) goto <D.25688>; else goto <D.25690>;
      <D.25690>:
      i = 0;
      goto <D.25692>;
      <D.25691>:
      D.30470 = acfg->trampoline_size[i];
      D.30471 = (int) D.30470;
      emit_int32 (acfg, D.30471);
      i = i + 1;
      <D.25692>:
      if (i <= 3) goto <D.25691>; else goto <D.25693>;
      <D.25693>:
      D.30472 = acfg->aot_opts.nrgctx_fetch_trampolines;
      emit_int32 (acfg, D.30472);
      emit_int32 (acfg, 8);
      emit_int32 (acfg, 8);
      emit_int32 (acfg, 14);
      D.30473 = acfg->tramp_page_size;
      D.30474 = (int) D.30473;
      emit_int32 (acfg, D.30474);
      i = 0;
      goto <D.25695>;
      <D.25694>:
      D.30475 = acfg->tramp_page_code_offsets[i];
      D.30476 = (int) D.30475;
      emit_int32 (acfg, D.30476);
      i = i + 1;
      <D.25695>:
      if (i <= 3) goto <D.25694>; else goto <D.25696>;
      <D.25696>:
      D.30427 = acfg->aot_opts.static_link;
      if (D.30427 != 0) goto <D.30477>; else goto <D.30478>;
      <D.30477>:
      {
        char * p;

        D.30426 = acfg->user_symbol_prefix;
        D.30414 = acfg->image;
        D.30420 = D.30414->assembly;
        D.30421 = D.30420->aname.name;
        sprintf (&symbol, "%smono_aot_module_%s_info", D.30426, D.30421);
        p = &symbol;
        p = &symbol;
        goto <D.25699>;
        <D.25698>:
        D.30479 = __ctype_b_loc ();
        D.30480 = *D.30479;
        D.30481 = *p;
        D.30482 = (long unsigned int) D.30481;
        D.30483 = D.30482 * 2;
        D.30484 = D.30480 + D.30483;
        D.30485 = *D.30484;
        D.30486 = (int) D.30485;
        D.30487 = D.30486 & 2048;
        if (D.30487 == 0) goto <D.30488>; else goto <D.30489>;
        <D.30488>:
        D.30481 = *p;
        if (D.30481 != 95) goto <D.30490>; else goto <D.30491>;
        <D.30490>:
        *p = 95;
        <D.30491>:
        <D.30489>:
        p = p + 1;
        <D.25699>:
        D.30481 = *p;
        if (D.30481 != 0) goto <D.25698>; else goto <D.25700>;
        <D.25700>:
        D.30492 = monoeg_strdup (&symbol);
        acfg->static_linking_symbol = D.30492;
        emit_global_inner (acfg, &symbol, 0);
        emit_alignment (acfg, 8);
        emit_label (acfg, &symbol);
        D.30426 = acfg->user_symbol_prefix;
        emit_pointer_2 (acfg, D.30426, "mono_aot_file_info");
      }
      <D.30478>:
    }
  finally
    {
      symbol = {CLOBBER};
    }
}


emit_string_symbol (struct MonoAotCompile * acfg, const char * name, const char * value)
{
  struct MonoImageWriter * D.30493;

  D.30493 = acfg->w;
  img_writer_emit_section_change (D.30493, ".rodata", 1);
  D.30493 = acfg->w;
  img_writer_emit_label (D.30493, name);
  D.30493 = acfg->w;
  img_writer_emit_string (D.30493, value);
}


emit_global (struct MonoAotCompile * acfg, const char * name, gboolean func)
{
  int D.30494;
  struct GPtrArray * D.30497;
  gchar * D.30498;
  struct MonoImageWriter * D.30499;

  D.30494 = acfg->aot_opts.no_dlsym;
  if (D.30494 != 0) goto <D.30495>; else goto <D.30496>;
  <D.30495>:
  D.30497 = acfg->globals;
  D.30498 = monoeg_strdup (name);
  monoeg_g_ptr_array_add (D.30497, D.30498);
  D.30499 = acfg->w;
  img_writer_emit_local_symbol (D.30499, name, 0B, func);
  goto <D.30500>;
  <D.30496>:
  D.30499 = acfg->w;
  img_writer_emit_global (D.30499, name, func);
  <D.30500>:
}


emit_pointer (struct MonoAotCompile * acfg, const char * target)
{
  struct MonoImageWriter * D.30501;

  D.30501 = acfg->w;
  img_writer_emit_pointer (D.30501, target);
}


emit_pointer_2 (struct MonoAotCompile * acfg, const char * prefix, const char * target)
{
  char D.30502;
  struct MonoImageWriter * D.30505;

  D.30502 = *prefix;
  if (D.30502 != 0) goto <D.30503>; else goto <D.30504>;
  <D.30503>:
  {
    char * s;

    s = monoeg_g_strdup_printf ("%s%s", prefix, target);
    D.30505 = acfg->w;
    img_writer_emit_pointer (D.30505, s);
    monoeg_g_free (s);
  }
  goto <D.30506>;
  <D.30504>:
  D.30505 = acfg->w;
  img_writer_emit_pointer (D.30505, target);
  <D.30506>:
}


emit_blob (struct MonoAotCompile * acfg)
{
  char * D.30507;
  unsigned int D.30508;
  int D.30509;
  char symbol[128];

  try
    {
      sprintf (&symbol, "blob");
      emit_section_change (acfg, ".rodata", 1);
      emit_alignment (acfg, 8);
      emit_label (acfg, &symbol);
      D.30507 = acfg->blob.data;
      D.30508 = acfg->blob.index;
      D.30509 = (int) D.30508;
      emit_bytes (acfg, D.30507, D.30509);
    }
  finally
    {
      symbol = {CLOBBER};
    }
}


emit_objc_selectors (struct MonoAotCompile * acfg)
{
  struct GPtrArray * D.30512;
  unsigned int D.30514;
  struct MonoImageWriter * D.30515;
  struct FILE * D.30516;
  _Bool D.30517;
  long int D.30518;
  long int D.30519;
  unsigned int i.204;
  void * * D.30523;
  long unsigned int D.30524;
  long unsigned int D.30525;
  void * * D.30526;
  void * D.30527;
  int i;

  D.30512 = acfg->objc_selectors;
  if (D.30512 == 0B) goto <D.30510>; else goto <D.30513>;
  <D.30513>:
  D.30512 = acfg->objc_selectors;
  D.30514 = D.30512->len;
  if (D.30514 == 0) goto <D.30510>; else goto <D.30511>;
  <D.30510>:
  return;
  <D.30511>:
  D.30515 = acfg->w;
  img_writer_emit_unset_mode (D.30515);
  D.30516 = acfg->fp;
  D.30517 = D.30516 == 0B;
  D.30518 = (long int) D.30517;
  D.30519 = __builtin_expect (D.30518, 0);
  if (D.30519 != 0) goto <D.30520>; else goto <D.30521>;
  <D.30520>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "aot-compiler.c", 8235, "acfg->fp");
  <D.30521>:
  D.30516 = acfg->fp;
  fprintf (D.30516, ".section\t__DATA,__objc_selrefs,literal_pointers,no_dead_strip\n");
  D.30516 = acfg->fp;
  fprintf (D.30516, ".align\t2\n");
  i = 0;
  goto <D.25710>;
  <D.25709>:
  D.30516 = acfg->fp;
  fprintf (D.30516, "L_OBJC_SELECTOR_REFERENCES_%d:\n", i);
  D.30516 = acfg->fp;
  fprintf (D.30516, ".long\tL_OBJC_METH_VAR_NAME_%d\n", i);
  i = i + 1;
  <D.25710>:
  D.30512 = acfg->objc_selectors;
  D.30514 = D.30512->len;
  i.204 = (unsigned int) i;
  if (D.30514 > i.204) goto <D.25709>; else goto <D.25711>;
  <D.25711>:
  D.30516 = acfg->fp;
  fprintf (D.30516, ".section\t__TEXT,__cstring,cstring_literals\n");
  i = 0;
  goto <D.25713>;
  <D.25712>:
  D.30516 = acfg->fp;
  fprintf (D.30516, "L_OBJC_METH_VAR_NAME_%d:\n", i);
  D.30516 = acfg->fp;
  D.30512 = acfg->objc_selectors;
  D.30523 = D.30512->pdata;
  D.30524 = (long unsigned int) i;
  D.30525 = D.30524 * 8;
  D.30526 = D.30523 + D.30525;
  D.30527 = *D.30526;
  fprintf (D.30516, ".asciz \"%s\"\n", D.30527);
  i = i + 1;
  <D.25713>:
  D.30512 = acfg->objc_selectors;
  D.30514 = D.30512->len;
  i.204 = (unsigned int) i;
  if (D.30514 > i.204) goto <D.25712>; else goto <D.25714>;
  <D.25714>:
  D.30516 = acfg->fp;
  fprintf (D.30516, ".section\t__DATA,__objc_imageinfo,regular,no_dead_strip\n");
  D.30516 = acfg->fp;
  fprintf (D.30516, ".align\t2\n");
  D.30516 = acfg->fp;
  fprintf (D.30516, "L_OBJC_IMAGE_INFO:\n");
  D.30516 = acfg->fp;
  fprintf (D.30516, ".long\t0\n");
  D.30516 = acfg->fp;
  fprintf (D.30516, ".long\t16\n");
}


emit_globals (struct MonoAotCompile * acfg)
{
  int D.30529;
  struct GPtrArray * D.30532;
  unsigned int D.30533;
  double D.30534;
  double D.30535;
  int D.30536;
  unsigned int D.30537;
  unsigned int D.30538;
  unsigned int table_size.205;
  void * * D.30540;
  long unsigned int D.30541;
  long unsigned int D.30542;
  void * * D.30543;
  unsigned int D.30544;
  unsigned int i.206;
  void * * D.30546;
  long unsigned int D.30547;
  long unsigned int D.30548;
  void * * D.30549;
  struct GlobalsTableEntry * D.30553;
  unsigned int D.30554;
  unsigned int i.207;
  _Bool D.30556;
  long int D.30557;
  long int D.30558;
  void * * D.30561;
  unsigned int D.30565;
  unsigned int D.30566;
  int D.30567;
  struct GlobalsTableEntry * D.30568;
  unsigned int D.30571;
  int D.30572;
  const char * D.30574;
  int i;
  int table_size;
  guint32 hash;
  struct GPtrArray * table;
  char symbol[256];
  struct GlobalsTableEntry * entry;
  struct GlobalsTableEntry * new_entry;

  try
    {
      D.30529 = acfg->aot_opts.static_link;
      if (D.30529 == 0) goto <D.30530>; else goto <D.30531>;
      <D.30530>:
      return;
      <D.30531>:
      D.30532 = acfg->globals;
      D.30533 = D.30532->len;
      D.30534 = (double) D.30533;
      D.30535 = D.30534 * 1.5e+0;
      D.30536 = (int) D.30535;
      D.30537 = (unsigned int) D.30536;
      D.30538 = monoeg_g_spaced_primes_closest (D.30537);
      table_size = (int) D.30538;
      table_size.205 = (unsigned int) table_size;
      table = monoeg_g_ptr_array_sized_new (table_size.205);
      i = 0;
      goto <D.25648>;
      <D.25647>:
      monoeg_g_ptr_array_add (table, 0B);
      i = i + 1;
      <D.25648>:
      if (i < table_size) goto <D.25647>; else goto <D.25649>;
      <D.25649>:
      i = 0;
      goto <D.25655>;
      <D.25654>:
      {
        char * name;

        D.30532 = acfg->globals;
        D.30540 = D.30532->pdata;
        D.30541 = (long unsigned int) i;
        D.30542 = D.30541 * 8;
        D.30543 = D.30540 + D.30542;
        name = *D.30543;
        D.30544 = mono_metadata_str_hash (name);
        table_size.205 = (unsigned int) table_size;
        hash = D.30544 % table_size.205;
        new_entry = monoeg_malloc0 (16);
        i.206 = (unsigned int) i;
        new_entry->value = i.206;
        D.30546 = table->pdata;
        D.30547 = (long unsigned int) hash;
        D.30548 = D.30547 * 8;
        D.30549 = D.30546 + D.30548;
        entry = *D.30549;
        if (entry == 0B) goto <D.30550>; else goto <D.30551>;
        <D.30550>:
        new_entry->index = hash;
        D.30546 = table->pdata;
        D.30547 = (long unsigned int) hash;
        D.30548 = D.30547 * 8;
        D.30549 = D.30546 + D.30548;
        *D.30549 = new_entry;
        goto <D.30552>;
        <D.30551>:
        goto <D.25652>;
        <D.25651>:
        entry = entry->next;
        <D.25652>:
        D.30553 = entry->next;
        if (D.30553 != 0B) goto <D.25651>; else goto <D.25653>;
        <D.25653>:
        entry->next = new_entry;
        D.30554 = table->len;
        new_entry->index = D.30554;
        monoeg_g_ptr_array_add (table, new_entry);
        <D.30552>:
      }
      i = i + 1;
      <D.25655>:
      D.30532 = acfg->globals;
      D.30533 = D.30532->len;
      i.207 = (unsigned int) i;
      if (D.30533 > i.207) goto <D.25654>; else goto <D.25656>;
      <D.25656>:
      sprintf (&symbol, ".Lglobals_hash");
      emit_section_change (acfg, ".rodata", 0);
      emit_alignment (acfg, 8);
      emit_label (acfg, &symbol);
      D.30556 = table_size > 64999;
      D.30557 = (long int) D.30556;
      D.30558 = __builtin_expect (D.30557, 0);
      if (D.30558 != 0) goto <D.30559>; else goto <D.30560>;
      <D.30559>:
      monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "aot-compiler.c", 7948, "table_size < 65000");
      <D.30560>:
      emit_int16 (acfg, table_size);
      i = 0;
      goto <D.25659>;
      <D.25658>:
      {
        struct GlobalsTableEntry * entry;

        D.30546 = table->pdata;
        D.30541 = (long unsigned int) i;
        D.30542 = D.30541 * 8;
        D.30561 = D.30546 + D.30542;
        entry = *D.30561;
        if (entry == 0B) goto <D.30562>; else goto <D.30563>;
        <D.30562>:
        emit_int16 (acfg, 0);
        emit_int16 (acfg, 0);
        goto <D.30564>;
        <D.30563>:
        D.30565 = entry->value;
        D.30566 = D.30565 + 1;
        D.30567 = (int) D.30566;
        emit_int16 (acfg, D.30567);
        D.30568 = entry->next;
        if (D.30568 != 0B) goto <D.30569>; else goto <D.30570>;
        <D.30569>:
        D.30568 = entry->next;
        D.30571 = D.30568->index;
        D.30572 = (int) D.30571;
        emit_int16 (acfg, D.30572);
        goto <D.30573>;
        <D.30570>:
        emit_int16 (acfg, 0);
        <D.30573>:
        <D.30564>:
      }
      i = i + 1;
      <D.25659>:
      D.30554 = table->len;
      i.207 = (unsigned int) i;
      if (D.30554 > i.207) goto <D.25658>; else goto <D.25660>;
      <D.25660>:
      i = 0;
      goto <D.25663>;
      <D.25662>:
      {
        char * name;

        D.30532 = acfg->globals;
        D.30540 = D.30532->pdata;
        D.30541 = (long unsigned int) i;
        D.30542 = D.30541 * 8;
        D.30543 = D.30540 + D.30542;
        name = *D.30543;
        sprintf (&symbol, "name_%d", i);
        emit_section_change (acfg, ".rodata", 1);
        emit_label (acfg, &symbol);
        emit_string (acfg, name);
      }
      i = i + 1;
      <D.25663>:
      D.30532 = acfg->globals;
      D.30533 = D.30532->len;
      i.207 = (unsigned int) i;
      if (D.30533 > i.207) goto <D.25662>; else goto <D.25664>;
      <D.25664>:
      sprintf (&symbol, "globals");
      emit_section_change (acfg, ".data", 0);
      emit_alignment (acfg, 8);
      emit_label (acfg, &symbol);
      D.30574 = acfg->temp_prefix;
      sprintf (&symbol, "%sglobals_hash", D.30574);
      emit_pointer (acfg, &symbol);
      i = 0;
      goto <D.25667>;
      <D.25666>:
      {
        char * name;

        D.30532 = acfg->globals;
        D.30540 = D.30532->pdata;
        D.30541 = (long unsigned int) i;
        D.30542 = D.30541 * 8;
        D.30543 = D.30540 + D.30542;
        name = *D.30543;
        sprintf (&symbol, "name_%d", i);
        emit_pointer (acfg, &symbol);
        sprintf (&symbol, "%s", name);
        emit_pointer (acfg, &symbol);
      }
      i = i + 1;
      <D.25667>:
      D.30532 = acfg->globals;
      D.30533 = D.30532->len;
      i.207 = (unsigned int) i;
      if (D.30533 > i.207) goto <D.25666>; else goto <D.25668>;
      <D.25668>:
      emit_int32 (acfg, 0);
      emit_int32 (acfg, 0);
    }
  finally
    {
      symbol = {CLOBBER};
    }
}


emit_autoreg (struct MonoAotCompile * acfg)
{
  int D.30580;
  int D.30582;
  int D.30584;
  char * D.30585;
  char * symbol;

  D.30580 = acfg->use_bin_writer;
  if (D.30580 != 0) goto <D.30578>; else goto <D.30581>;
  <D.30581>:
  D.30582 = acfg->aot_opts.static_link;
  if (D.30582 == 0) goto <D.30578>; else goto <D.30583>;
  <D.30583>:
  D.30584 = acfg->aot_opts.autoreg;
  if (D.30584 == 0) goto <D.30578>; else goto <D.30579>;
  <D.30578>:
  return;
  <D.30579>:
  D.30585 = acfg->static_linking_symbol;
  symbol = monoeg_g_strdup_printf ("_%s_autoreg", D.30585);
  arch_emit_autoreg (acfg, symbol);
  monoeg_g_free (symbol);
}


arch_emit_autoreg (struct MonoAotCompile * acfg, char * symbol)
{

}


emit_dwarf_info (struct MonoAotCompile * acfg)
{

}


emit_mem_end (struct MonoAotCompile * acfg)
{
  char symbol[128];

  try
    {
      sprintf (&symbol, "mem_end");
      emit_section_change (acfg, ".text", 1);
      emit_alignment (acfg, 8);
      emit_label (acfg, &symbol);
    }
  finally
    {
      symbol = {CLOBBER};
    }
}


__attribute__((__artificial__, __gnu_inline__, __always_inline__))
fprintf (struct FILE * restrict __stream, const char * restrict __fmt)
{
  int D.30587;

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


__attribute__((__artificial__, __gnu_inline__, __always_inline__, __nothrow__, __leaf__))
strcpy (char * restrict __dest, const char * restrict __src)
{
  char * D.30589;
  long unsigned int D.30590;

  D.30590 = __builtin_object_size (__dest, 1);
  D.30589 = __builtin___strcpy_chk (__dest, __src, D.30590);
  return D.30589;
}


compile_asm (struct MonoAotCompile * acfg)
{
  const char * iftmp.208;
  char * D.30593;
  int D.30597;
  char * D.30600;
  int D.30601;
  char * D.30604;
  int D.30605;
  char * D.30608;
  struct MonoImage * D.30612;
  char * D.30613;
  const char * iftmp.209;
  struct GString * D.30616;
  int D.30620;
  int D.30628;
  int D.30631;
  char * command;
  char * objfile;
  char * outfile_name;
  char * tmp_outfile_name;
  const char * tool_prefix;

  D.30593 = acfg->aot_opts.tool_prefix;
  if (D.30593 != 0B) goto <D.30594>; else goto <D.30595>;
  <D.30594>:
  iftmp.208 = acfg->aot_opts.tool_prefix;
  goto <D.30596>;
  <D.30595>:
  iftmp.208 = "";
  <D.30596>:
  tool_prefix = iftmp.208;
  D.30597 = acfg->aot_opts.asm_only;
  if (D.30597 != 0) goto <D.30598>; else goto <D.30599>;
  <D.30598>:
  D.30600 = acfg->tmpfname;
  printf ("Output file: \'%s\'.\n", D.30600);
  D.30601 = acfg->aot_opts.static_link;
  if (D.30601 != 0) goto <D.30602>; else goto <D.30603>;
  <D.30602>:
  D.30604 = acfg->static_linking_symbol;
  printf ("Linking symbol: \'%s\'.\n", D.30604);
  <D.30603>:
  D.30605 = 0;
  return D.30605;
  <D.30599>:
  D.30601 = acfg->aot_opts.static_link;
  if (D.30601 != 0) goto <D.30606>; else goto <D.30607>;
  <D.30606>:
  D.30608 = acfg->aot_opts.outfile;
  if (D.30608 != 0B) goto <D.30609>; else goto <D.30610>;
  <D.30609>:
  D.30608 = acfg->aot_opts.outfile;
  objfile = monoeg_g_strdup_printf ("%s", D.30608);
  goto <D.30611>;
  <D.30610>:
  D.30612 = acfg->image;
  D.30613 = D.30612->name;
  objfile = monoeg_g_strdup_printf ("%s.o", D.30613);
  <D.30611>:
  goto <D.30614>;
  <D.30607>:
  D.30600 = acfg->tmpfname;
  objfile = monoeg_g_strdup_printf ("%s.o", D.30600);
  <D.30614>:
  D.30616 = acfg->as_args;
  if (D.30616 != 0B) goto <D.30617>; else goto <D.30618>;
  <D.30617>:
  D.30616 = acfg->as_args;
  iftmp.209 = D.30616->str;
  goto <D.30619>;
  <D.30618>:
  iftmp.209 = "";
  <D.30619>:
  D.30600 = acfg->tmpfname;
  command = monoeg_g_strdup_printf ("%s%s %s %s -o %s %s", tool_prefix, "as", "", iftmp.209, objfile, D.30600);
  printf ("Executing the native assembler: %s\n", command);
  D.30620 = system (command);
  if (D.30620 != 0) goto <D.30621>; else goto <D.30622>;
  <D.30621>:
  monoeg_g_free (command);
  monoeg_g_free (objfile);
  D.30605 = 1;
  return D.30605;
  <D.30622>:
  monoeg_g_free (command);
  D.30601 = acfg->aot_opts.static_link;
  if (D.30601 != 0) goto <D.30623>; else goto <D.30624>;
  <D.30623>:
  printf ("Output file: \'%s\'.\n", objfile);
  D.30604 = acfg->static_linking_symbol;
  printf ("Linking symbol: \'%s\'.\n", D.30604);
  monoeg_g_free (objfile);
  D.30605 = 0;
  return D.30605;
  <D.30624>:
  D.30608 = acfg->aot_opts.outfile;
  if (D.30608 != 0B) goto <D.30625>; else goto <D.30626>;
  <D.30625>:
  D.30608 = acfg->aot_opts.outfile;
  outfile_name = monoeg_g_strdup_printf ("%s", D.30608);
  goto <D.30627>;
  <D.30626>:
  D.30612 = acfg->image;
  D.30613 = D.30612->name;
  outfile_name = monoeg_g_strdup_printf ("%s%s", D.30613, ".so");
  <D.30627>:
  tmp_outfile_name = monoeg_g_strdup_printf ("%s.tmp", outfile_name);
  D.30600 = acfg->tmpfname;
  command = monoeg_g_strdup_printf ("%sld %s -shared -o %s %s.o", tool_prefix, "", tmp_outfile_name, D.30600);
  printf ("Executing the native linker: %s\n", command);
  D.30628 = system (command);
  if (D.30628 != 0) goto <D.30629>; else goto <D.30630>;
  <D.30629>:
  monoeg_g_free (tmp_outfile_name);
  monoeg_g_free (outfile_name);
  monoeg_g_free (command);
  monoeg_g_free (objfile);
  D.30605 = 1;
  return D.30605;
  <D.30630>:
  monoeg_g_free (command);
  rename (tmp_outfile_name, outfile_name);
  D.30631 = acfg->aot_opts.save_temps;
  if (D.30631 == 0) goto <D.30632>; else goto <D.30633>;
  <D.30632>:
  unlink (objfile);
  <D.30633>:
  monoeg_g_free (tmp_outfile_name);
  monoeg_g_free (outfile_name);
  monoeg_g_free (objfile);
  D.30631 = acfg->aot_opts.save_temps;
  if (D.30631 != 0) goto <D.30634>; else goto <D.30635>;
  <D.30634>:
  printf ("Retained input file.\n");
  goto <D.30636>;
  <D.30635>:
  D.30600 = acfg->tmpfname;
  unlink (D.30600);
  <D.30636>:
  D.30605 = 0;
  return D.30605;
}


__attribute__((__unused__))
get_patch_name (int info)
{
  const char * D.30638;
  short int D.30639;
  sizetype D.30640;

  D.30639 = opidx[info];
  D.30640 = (sizetype) D.30639;
  D.30638 = &opstr + D.30640;
  return D.30638;
}


__attribute__((__artificial__, __gnu_inline__, __always_inline__))
printf (const char * restrict __fmt)
{
  int D.30642;

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


acfg_free (struct MonoAotCompile * acfg)
{
  struct MonoImageWriter * D.30644;
  struct MonoCompile * * D.30645;
  long unsigned int D.30646;
  long unsigned int D.30647;
  struct MonoCompile * * D.30648;
  struct MonoCompile * D.30649;
  unsigned int D.30652;
  unsigned int i.210;
  char * D.30654;
  char * D.30655;
  char * D.30656;
  struct GPtrArray * D.30657;
  struct GPtrArray * D.30658;
  struct GPtrArray * D.30659;
  struct GPtrArray * D.30660;
  struct GPtrArray * D.30661;
  struct GHashTable * D.30662;
  struct GHashTable * D.30663;
  struct GHashTable * D.30664;
  struct GHashTable * * D.30665;
  struct GHashTable * * D.30666;
  struct GHashTable * D.30667;
  struct GHashTable * D.30670;
  struct GHashTable * D.30671;
  struct GHashTable * D.30672;
  struct GHashTable * D.30673;
  struct GHashTable * D.30674;
  struct GHashTable * D.30675;
  struct GHashTable * D.30676;
  struct GHashTable * D.30677;
  struct GHashTable * D.30678;
  struct GHashTable * D.30679;
  struct GHashTable * D.30680;
  struct GHashTable * * D.30681;
  struct GHashTable * * D.30682;
  struct GHashTable * D.30683;
  struct MonoMemPool * D.30684;
  int i;

  D.30644 = acfg->w;
  img_writer_destroy (D.30644);
  i = 0;
  goto <D.25787>;
  <D.25786>:
  D.30645 = acfg->cfgs;
  D.30646 = (long unsigned int) i;
  D.30647 = D.30646 * 8;
  D.30648 = D.30645 + D.30647;
  D.30649 = *D.30648;
  if (D.30649 != 0B) goto <D.30650>; else goto <D.30651>;
  <D.30650>:
  D.30645 = acfg->cfgs;
  D.30646 = (long unsigned int) i;
  D.30647 = D.30646 * 8;
  D.30648 = D.30645 + D.30647;
  D.30649 = *D.30648;
  monoeg_g_free (D.30649);
  <D.30651>:
  i = i + 1;
  <D.25787>:
  D.30652 = acfg->nmethods;
  i.210 = (unsigned int) i;
  if (D.30652 > i.210) goto <D.25786>; else goto <D.25788>;
  <D.25788>:
  D.30645 = acfg->cfgs;
  monoeg_g_free (D.30645);
  D.30654 = acfg->static_linking_symbol;
  monoeg_g_free (D.30654);
  D.30655 = acfg->got_symbol;
  monoeg_g_free (D.30655);
  D.30656 = acfg->plt_symbol;
  monoeg_g_free (D.30656);
  D.30657 = acfg->methods;
  monoeg_g_ptr_array_free (D.30657, 1);
  D.30658 = acfg->got_patches;
  monoeg_g_ptr_array_free (D.30658, 1);
  D.30659 = acfg->image_table;
  monoeg_g_ptr_array_free (D.30659, 1);
  D.30660 = acfg->globals;
  monoeg_g_ptr_array_free (D.30660, 1);
  D.30661 = acfg->unwind_ops;
  monoeg_g_ptr_array_free (D.30661, 1);
  D.30662 = acfg->method_indexes;
  monoeg_g_hash_table_destroy (D.30662);
  D.30663 = acfg->method_depth;
  monoeg_g_hash_table_destroy (D.30663);
  D.30664 = acfg->plt_offset_to_entry;
  monoeg_g_hash_table_destroy (D.30664);
  i = 0;
  goto <D.25790>;
  <D.25789>:
  D.30665 = acfg->patch_to_plt_entry;
  D.30646 = (long unsigned int) i;
  D.30647 = D.30646 * 8;
  D.30666 = D.30665 + D.30647;
  D.30667 = *D.30666;
  if (D.30667 != 0B) goto <D.30668>; else goto <D.30669>;
  <D.30668>:
  D.30665 = acfg->patch_to_plt_entry;
  D.30646 = (long unsigned int) i;
  D.30647 = D.30646 * 8;
  D.30666 = D.30665 + D.30647;
  D.30667 = *D.30666;
  monoeg_g_hash_table_destroy (D.30667);
  <D.30669>:
  i = i + 1;
  <D.25790>:
  if (i <= 51) goto <D.25789>; else goto <D.25791>;
  <D.25791>:
  D.30665 = acfg->patch_to_plt_entry;
  monoeg_g_free (D.30665);
  D.30670 = acfg->patch_to_got_offset;
  monoeg_g_hash_table_destroy (D.30670);
  D.30671 = acfg->method_to_cfg;
  monoeg_g_hash_table_destroy (D.30671);
  D.30672 = acfg->token_info_hash;
  monoeg_g_hash_table_destroy (D.30672);
  D.30673 = acfg->method_to_pinvoke_import;
  monoeg_g_hash_table_destroy (D.30673);
  D.30674 = acfg->image_hash;
  monoeg_g_hash_table_destroy (D.30674);
  D.30675 = acfg->unwind_info_offsets;
  monoeg_g_hash_table_destroy (D.30675);
  D.30676 = acfg->method_label_hash;
  monoeg_g_hash_table_destroy (D.30676);
  D.30677 = acfg->export_names;
  monoeg_g_hash_table_destroy (D.30677);
  D.30678 = acfg->plt_entry_debug_sym_cache;
  monoeg_g_hash_table_destroy (D.30678);
  D.30679 = acfg->klass_blob_hash;
  monoeg_g_hash_table_destroy (D.30679);
  D.30680 = acfg->method_blob_hash;
  monoeg_g_hash_table_destroy (D.30680);
  i = 0;
  goto <D.25793>;
  <D.25792>:
  D.30681 = acfg->patch_to_got_offset_by_type;
  D.30646 = (long unsigned int) i;
  D.30647 = D.30646 * 8;
  D.30682 = D.30681 + D.30647;
  D.30683 = *D.30682;
  monoeg_g_hash_table_destroy (D.30683);
  i = i + 1;
  <D.25793>:
  if (i <= 51) goto <D.25792>; else goto <D.25794>;
  <D.25794>:
  D.30681 = acfg->patch_to_got_offset_by_type;
  monoeg_g_free (D.30681);
  D.30684 = acfg->mempool;
  mono_mempool_destroy (D.30684);
  monoeg_g_free (acfg);
}