mono_aot_readonly_field_override (struct MonoClassField * field)
{
  struct MonoClass * D.28614;
  const char * D.28615;
  unsigned int D.28616;
  unsigned int len.0;
  int D.28618;
  sizetype len.1;
  char * p.2;
  char D.28623;
  const char * D.28626;
  unsigned int D.28627;
  int D.28628;
  char * p.3;
  char D.28632;
  int D.27880;
  const char * D.28635;
  int D.28638;
  void * D.28639;
  struct ReadOnlyValue * rdv;

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

    p = rdv->name;
    D.28614 = field->parent;
    D.28615 = D.28614->name_space;
    D.28616 = strlen (D.28615);
    len = (int) D.28616;
    D.28614 = field->parent;
    D.28615 = D.28614->name_space;
    len.0 = (unsigned int) len;
    D.28618 = strncmp (p, D.28615, len.0);
    if (D.28618 != 0) goto <D.28619>; else goto <D.28620>;
    <D.28619>:
    // predicted unlikely by continue predictor.
    goto <D.27862>;
    <D.28620>:
    len.1 = (sizetype) len;
    p = p + len.1;
    p.2 = p;
    p = p.2 + 1;
    D.28623 = *p.2;
    if (D.28623 != 46) goto <D.28624>; else goto <D.28625>;
    <D.28624>:
    // predicted unlikely by continue predictor.
    goto <D.27862>;
    <D.28625>:
    D.28614 = field->parent;
    D.28626 = D.28614->name;
    D.28627 = strlen (D.28626);
    len = (int) D.28627;
    D.28614 = field->parent;
    D.28626 = D.28614->name;
    len.0 = (unsigned int) len;
    D.28628 = strncmp (p, D.28626, len.0);
    if (D.28628 != 0) goto <D.28629>; else goto <D.28630>;
    <D.28629>:
    // predicted unlikely by continue predictor.
    goto <D.27862>;
    <D.28630>:
    len.1 = (sizetype) len;
    p = p + len.1;
    p.3 = p;
    p = p.3 + 1;
    D.28632 = *p.3;
    if (D.28632 != 46) goto <D.28633>; else goto <D.28634>;
    <D.28633>:
    // predicted unlikely by continue predictor.
    goto <D.27862>;
    <D.28634>:
    {
      size_t __s1_len;
      size_t __s2_len;

      D.28635 = field->name;
      D.27880 = __builtin_strcmp (p, D.28635);
    }
    if (D.27880 != 0) goto <D.28636>; else goto <D.28637>;
    <D.28636>:
    // predicted unlikely by continue predictor.
    goto <D.27862>;
    <D.28637>:
    D.28638 = rdv->type;
    switch (D.28638) <default: <D.27884>, case 4: <D.27881>, case 6: <D.27882>, case 8: <D.27883>>
    <D.27881>:
    D.28639 = &rdv->value.i1;
    return D.28639;
    <D.27882>:
    D.28639 = &rdv->value.i2;
    return D.28639;
    <D.27883>:
    D.28639 = &rdv->value.i4;
    return D.28639;
    <D.27884>:
    goto <D.27885>;
    <D.27885>:
  }
  <D.27862>:
  rdv = rdv->next;
  <D.27887>:
  if (rdv != 0B) goto <D.27886>; else goto <D.27888>;
  <D.27888>:
  D.28639 = 0B;
  return D.28639;
}


mono_aot_get_got_offset (struct MonoJumpInfo * ji)
{
  guint32 D.28642;
  struct MonoAotCompile * llvm_acfg.4;

  llvm_acfg.4 = llvm_acfg;
  D.28642 = get_got_offset (llvm_acfg.4, ji);
  return D.28642;
}


get_got_offset (struct MonoAotCompile * acfg, struct MonoJumpInfo * ji)
{
  struct GHashTable * * D.28645;
  <unnamed type> D.28646;
  unsigned int D.28647;
  struct GHashTable * * D.28648;
  struct GHashTable * D.28649;
  void * D.28650;
  guint32 D.28653;
  unsigned int D.28654;
  unsigned int D.28655;
  unsigned int D.28656;
  _Bool D.28659;
  long int D.28660;
  long int D.28661;
  int D.28664;
  int D.28665;
  int D.28666;
  int D.28667;
  struct GHashTable * D.28668;
  unsigned int D.28669;
  void * D.28670;
  struct GPtrArray * D.28671;
  guint32 got_offset;

  D.28645 = acfg->patch_to_got_offset_by_type;
  D.28646 = ji->type;
  D.28647 = D.28646 * 4;
  D.28648 = D.28645 + D.28647;
  D.28649 = *D.28648;
  D.28650 = monoeg_g_hash_table_lookup (D.28649, ji);
  got_offset = (guint32) D.28650;
  if (got_offset != 0) goto <D.28651>; else goto <D.28652>;
  <D.28651>:
  D.28653 = got_offset + 4294967295;
  return D.28653;
  <D.28652>:
  got_offset = acfg->got_offset;
  D.28654 = acfg->got_offset;
  D.28655 = D.28654 + 1;
  acfg->got_offset = D.28655;
  D.28656 = acfg->final_got_size;
  if (D.28656 != 0) goto <D.28657>; else goto <D.28658>;
  <D.28657>:
  D.28656 = acfg->final_got_size;
  D.28659 = D.28656 <= got_offset;
  D.28660 = (long int) D.28659;
  D.28661 = __builtin_expect (D.28660, 0);
  if (D.28661 != 0) goto <D.28662>; else goto <D.28663>;
  <D.28662>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "aot-compiler.c", 2978, "got_offset < acfg->final_got_size");
  <D.28663>:
  <D.28658>:
  D.28664 = acfg->stats.got_slots;
  D.28665 = D.28664 + 1;
  acfg->stats.got_slots = D.28665;
  D.28646 = ji->type;
  D.28666 = acfg->stats.got_slot_types[D.28646];
  D.28667 = D.28666 + 1;
  acfg->stats.got_slot_types[D.28646] = D.28667;
  D.28668 = acfg->patch_to_got_offset;
  D.28669 = got_offset + 1;
  D.28670 = (void *) D.28669;
  monoeg_g_hash_table_insert_replace (D.28668, ji, D.28670, 0);
  D.28645 = acfg->patch_to_got_offset_by_type;
  D.28646 = ji->type;
  D.28647 = D.28646 * 4;
  D.28648 = D.28645 + D.28647;
  D.28649 = *D.28648;
  D.28669 = got_offset + 1;
  D.28670 = (void *) D.28669;
  monoeg_g_hash_table_insert_replace (D.28649, ji, D.28670, 0);
  D.28671 = acfg->got_patches;
  monoeg_g_ptr_array_add (D.28671, ji);
  D.28653 = got_offset;
  return D.28653;
}


mono_aot_get_method_name (struct MonoCompile * cfg)
{
  struct MonoAotCompile * llvm_acfg.5;
  int D.28674;
  char * D.28677;
  char * D.28678;
  struct MonoMethod * D.28679;
  struct GHashTable * D.28680;
  char * D.28681;

  llvm_acfg.5 = llvm_acfg;
  D.28674 = llvm_acfg.5->aot_opts.static_link;
  if (D.28674 != 0) goto <D.28675>; else goto <D.28676>;
  <D.28675>:
  llvm_acfg.5 = llvm_acfg;
  D.28678 = llvm_acfg.5->assembly_name_sym;
  D.28679 = cfg->orig_method;
  llvm_acfg.5 = llvm_acfg;
  D.28680 = llvm_acfg.5->method_label_hash;
  D.28681 = get_debug_sym (D.28679, "", D.28680);
  D.28677 = monoeg_g_strdup_printf ("%s_%s", D.28678, D.28681);
  return D.28677;
  <D.28676>:
  D.28679 = cfg->orig_method;
  llvm_acfg.5 = llvm_acfg;
  D.28680 = llvm_acfg.5->method_label_hash;
  D.28677 = get_debug_sym (D.28679, "", D.28680);
  return D.28677;
}


get_debug_sym (struct MonoMethod * method, const char * prefix, struct GHashTable * cache)
{
  unsigned int D.28683;
  unsigned int D.28684;
  unsigned int len.6;
  unsigned int D.28686;
  unsigned int D.28687;
  unsigned int D.28688;
  unsigned int D.28689;
  const short unsigned int * * D.28690;
  const short unsigned int * D.28691;
  sizetype i.7;
  char * D.28693;
  char D.28694;
  unsigned int D.28695;
  unsigned int D.28696;
  const short unsigned int * D.28697;
  short unsigned int D.28698;
  int D.28699;
  int D.28700;
  int j.8;
  sizetype j.9;
  char * D.28705;
  sizetype D.28710;
  char * D.28711;
  char D.28712;
  sizetype D.28714;
  char * D.28715;
  char D.28716;
  int j.10;
  sizetype j.11;
  char * D.28724;
  char D.28725;
  char D.28726;
  _Bool D.28727;
  _Bool D.28728;
  _Bool D.28729;
  int j.12;
  sizetype j.13;
  char * D.28735;
  sizetype j.14;
  char * D.28737;
  void * D.28738;
  char * D.28739;
  char * name1;
  char * name2;
  char * cached;
  int i;
  int j;
  int len;
  int count;

  name1 = mono_method_full_name (method, 1);
  D.28683 = strlen (name1);
  len = (int) D.28683;
  D.28684 = strlen (prefix);
  len.6 = (unsigned int) len;
  D.28686 = D.28684 + len.6;
  D.28687 = D.28686 + 16;
  name2 = malloc (D.28687);
  D.28688 = strlen (prefix);
  memcpy (name2, prefix, D.28688);
  D.28689 = strlen (prefix);
  j = (int) D.28689;
  i = 0;
  goto <D.27464>;
  <D.27463>:
  D.28690 = __ctype_b_loc ();
  D.28691 = *D.28690;
  i.7 = (sizetype) i;
  D.28693 = name1 + i.7;
  D.28694 = *D.28693;
  D.28695 = (unsigned int) D.28694;
  D.28696 = D.28695 * 2;
  D.28697 = D.28691 + D.28696;
  D.28698 = *D.28697;
  D.28699 = (int) D.28698;
  D.28700 = D.28699 & 8;
  if (D.28700 != 0) goto <D.28701>; else goto <D.28702>;
  <D.28701>:
  j.8 = j;
  j = j.8 + 1;
  j.9 = (sizetype) j.8;
  D.28705 = name2 + j.9;
  i.7 = (sizetype) i;
  D.28693 = name1 + i.7;
  D.28694 = *D.28693;
  *D.28705 = D.28694;
  goto <D.28706>;
  <D.28702>:
  i.7 = (sizetype) i;
  D.28693 = name1 + i.7;
  D.28694 = *D.28693;
  if (D.28694 == 32) goto <D.28709>; else goto <D.28707>;
  <D.28709>:
  i.7 = (sizetype) i;
  D.28710 = i.7 + 1;
  D.28711 = name1 + D.28710;
  D.28712 = *D.28711;
  if (D.28712 == 40) goto <D.28713>; else goto <D.28707>;
  <D.28713>:
  i.7 = (sizetype) i;
  D.28714 = i.7 + 2;
  D.28715 = name1 + D.28714;
  D.28716 = *D.28715;
  if (D.28716 == 41) goto <D.28717>; else goto <D.28707>;
  <D.28717>:
  i = i + 2;
  goto <D.28708>;
  <D.28707>:
  i.7 = (sizetype) i;
  D.28693 = name1 + i.7;
  D.28694 = *D.28693;
  if (D.28694 == 44) goto <D.28720>; else goto <D.28718>;
  <D.28720>:
  i.7 = (sizetype) i;
  D.28710 = i.7 + 1;
  D.28711 = name1 + D.28710;
  D.28712 = *D.28711;
  if (D.28712 == 32) goto <D.28721>; else goto <D.28718>;
  <D.28721>:
  j.10 = j;
  j = j.10 + 1;
  j.11 = (sizetype) j.10;
  D.28724 = name2 + j.11;
  *D.28724 = 95;
  i = i + 1;
  goto <D.28719>;
  <D.28718>:
  i.7 = (sizetype) i;
  D.28693 = name1 + i.7;
  D.28725 = *D.28693;
  D.28726 = D.28725 + 216;
  D.28727 = D.28726 <= 1;
  D.28728 = D.28725 == 62;
  D.28729 = D.28727 | D.28728;
  if (D.28729 != 0) goto <D.28730>; else goto <D.28731>;
  <D.28730>:
  goto <D.28732>;
  <D.28731>:
  j.12 = j;
  j = j.12 + 1;
  j.13 = (sizetype) j.12;
  D.28735 = name2 + j.13;
  *D.28735 = 95;
  <D.28732>:
  <D.28719>:
  <D.28708>:
  <D.28706>:
  i = i + 1;
  <D.27464>:
  if (i < len) goto <D.27463>; else goto <D.27465>;
  <D.27465>:
  j.14 = (sizetype) j;
  D.28737 = name2 + j.14;
  *D.28737 = 0;
  monoeg_g_free (name1);
  count = 0;
  goto <D.27467>;
  <D.27466>:
  j.14 = (sizetype) j;
  D.28737 = name2 + j.14;
  sprintf (D.28737, "_%d", count);
  count = count + 1;
  <D.27467>:
  D.28738 = monoeg_g_hash_table_lookup (cache, name2);
  if (D.28738 != 0B) goto <D.27466>; else goto <D.27468>;
  <D.27468>:
  cached = monoeg_strdup (name2);
  monoeg_g_hash_table_insert_replace (cache, cached, cached, 0);
  D.28739 = name2;
  return D.28739;
}


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

  D.28742 = __builtin_object_size (__dest, 0);
  D.28741 = __builtin___memcpy_chk (__dest, __src, __len, D.28742);
  return D.28741;
}


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

  D.28745 = __builtin_object_size (__s, 1);
  D.28744 = __builtin___sprintf_chk (__s, 1, D.28745, __fmt, __builtin_va_arg_pack ());
  return D.28744;
}


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

  if (str != 0B) goto <D.28747>; else goto <D.28748>;
  <D.28747>:
  D.28749 = __strdup (str);
  return D.28749;
  <D.28748>:
  D.28749 = 0B;
  return D.28749;
}


mono_aot_get_plt_symbol (MonoJumpInfoType type, const void * data)
{
  struct MonoAotCompile * llvm_acfg.15;
  struct MonoMemPool * D.28752;
  int D.28753;
  char * D.28756;
  char * D.28757;
  struct MonoJumpInfo * ji;
  struct MonoPltEntry * plt_entry;

  llvm_acfg.15 = llvm_acfg;
  D.28752 = llvm_acfg.15->mempool;
  ji = mono_mempool_alloc (D.28752, 20);
  ji->type = type;
  ji->data.target = data;
  llvm_acfg.15 = llvm_acfg;
  D.28753 = can_encode_patch (llvm_acfg.15, ji);
  if (D.28753 == 0) goto <D.28754>; else goto <D.28755>;
  <D.28754>:
  D.28756 = 0B;
  return D.28756;
  <D.28755>:
  llvm_acfg.15 = llvm_acfg;
  plt_entry = get_plt_entry (llvm_acfg.15, ji);
  plt_entry->llvm_used = 1;
  D.28757 = plt_entry->llvm_symbol;
  D.28756 = monoeg_g_strdup_printf (D.28757);
  return D.28756;
}


can_encode_patch (struct MonoAotCompile * acfg, struct MonoJumpInfo * patch_info)
{
  <unnamed type> D.28759;
  gboolean D.28760;
  struct MonoClass * D.28761;
  int D.28762;
  struct MonoMethod * D.28765;
  int D.28766;
  struct MonoJumpInfo * D.28769;
  int D.28770;

  D.28759 = patch_info->type;
  switch (D.28759) <default: <D.27991>, case 3: <D.27978>, case 6: <D.27979>, case 11: <D.27985>, case 14: <D.27982>, case 15: <D.27983>, case 23: <D.27986>, case 24: <D.27987>, case 30: <D.27984>, case 35: <D.27989>, case 50: <D.27980>>
  <D.27978>:
  <D.27979>:
  <D.27980>:
  {
    struct MonoMethod * method;

    method = patch_info->data.method;
    D.28760 = can_encode_method (acfg, method);
    return D.28760;
  }
  <D.27982>:
  <D.27983>:
  <D.27984>:
  <D.27985>:
  <D.27986>:
  <D.27987>:
  D.28761 = patch_info->data.klass;
  D.28762 = can_encode_class (acfg, D.28761);
  if (D.28762 == 0) goto <D.28763>; else goto <D.28764>;
  <D.28763>:
  D.28760 = 0;
  return D.28760;
  <D.28764>:
  goto <D.27988>;
  <D.27989>:
  {
    struct MonoJumpInfoRgctxEntry * entry;

    entry = patch_info->data.rgctx_entry;
    D.28765 = entry->method;
    D.28766 = can_encode_method (acfg, D.28765);
    if (D.28766 == 0) goto <D.28767>; else goto <D.28768>;
    <D.28767>:
    D.28760 = 0;
    return D.28760;
    <D.28768>:
    D.28769 = entry->data;
    D.28770 = can_encode_patch (acfg, D.28769);
    if (D.28770 == 0) goto <D.28771>; else goto <D.28772>;
    <D.28771>:
    D.28760 = 0;
    return D.28760;
    <D.28772>:
    goto <D.27988>;
  }
  <D.27991>:
  goto <D.27988>;
  <D.27988>:
  D.28760 = 1;
  return D.28760;
}


can_encode_class (struct MonoAotCompile * acfg, struct MonoClass * klass)
{
  unsigned int D.28775;
  gboolean D.28778;
  unsigned char D.28781;
  _Bool D.28782;
  _Bool D.28783;
  _Bool D.28784;
  unsigned char D.28786;
  unsigned char D.28787;
  struct MonoClass * D.28790;

  D.28775 = klass->type_token;
  if (D.28775 != 0) goto <D.28776>; else goto <D.28777>;
  <D.28776>:
  D.28778 = 1;
  return D.28778;
  <D.28777>:
  D.28781 = klass->byval_arg.type;
  D.28782 = D.28781 == 19;
  D.28783 = D.28781 == 30;
  D.28784 = D.28782 | D.28783;
  if (D.28784 != 0) goto <D.28779>; else goto <D.28785>;
  <D.28785>:
  D.28786 = klass->byval_arg.type;
  if (D.28786 == 15) goto <D.28779>; else goto <D.28780>;
  <D.28779>:
  D.28778 = 1;
  return D.28778;
  <D.28780>:
  D.28787 = klass->rank;
  if (D.28787 != 0) goto <D.28788>; else goto <D.28789>;
  <D.28788>:
  D.28790 = klass->element_class;
  D.28778 = can_encode_class (acfg, D.28790);
  return D.28778;
  <D.28789>:
  D.28778 = 0;
  return D.28778;
}


can_encode_method (struct MonoAotCompile * acfg, struct MonoMethod * method)
{
  unsigned char D.28792;
  unsigned char D.28793;
  <unnamed-unsigned:5> D.28796;
  int D.28797;
  gboolean D.28800;
  unsigned int D.28802;
  struct GHashTable * D.28805;
  void * D.28806;
  struct MonoClass * D.28809;
  unsigned char D.28810;

  D.28792 = BIT_FIELD_REF <*method, 8, 160>;
  D.28793 = D.28792 & 124;
  if (D.28793 != 0) goto <D.28794>; else goto <D.28795>;
  <D.28794>:
  D.28796 = method->wrapper_type;
  D.28797 = (int) D.28796;
  switch (D.28797) <default: <D.27973>, case 0: <D.27950>, case 1: <D.27965>, case 2: <D.27966>, case 3: <D.27967>, case 7: <D.27970>, case 8: <D.27962>, case 9: <D.27951>, case 10: <D.27952>, case 12: <D.27954>, case 13: <D.27953>, case 14: <D.27956>, case 15: <D.27957>, case 16: <D.27968>, case 18: <D.27959>, case 19: <D.27971>, case 20: <D.27960>, case 21: <D.27958>, case 23: <D.27955>, case 24: <D.27964>, case 25: <D.27963>, case 28: <D.27961>>
  <D.27950>:
  <D.27951>:
  <D.27952>:
  <D.27953>:
  <D.27954>:
  <D.27955>:
  <D.27956>:
  <D.27957>:
  <D.27958>:
  <D.27959>:
  <D.27960>:
  <D.27961>:
  <D.27962>:
  <D.27963>:
  <D.27964>:
  <D.27965>:
  <D.27966>:
  <D.27967>:
  <D.27968>:
  goto <D.27969>;
  <D.27970>:
  <D.27971>:
  {
    struct WrapperInfo * info;

    info = mono_marshal_get_wrapper_info (method);
    if (info != 0B) goto <D.28798>; else goto <D.28799>;
    <D.28798>:
    D.28800 = 1;
    return D.28800;
    <D.28799>:
    D.28800 = 0;
    return D.28800;
  }
  <D.27973>:
  D.28800 = 0;
  return D.28800;
  <D.27969>:
  goto <D.28801>;
  <D.28795>:
  D.28802 = method->token;
  if (D.28802 == 0) goto <D.28803>; else goto <D.28804>;
  <D.28803>:
  D.28805 = acfg->token_info_hash;
  D.28806 = monoeg_g_hash_table_lookup (D.28805, method);
  if (D.28806 == 0B) goto <D.28807>; else goto <D.28808>;
  <D.28807>:
  D.28809 = method->klass;
  D.28810 = D.28809->rank;
  if (D.28810 != 0) goto <D.28811>; else goto <D.28812>;
  <D.28811>:
  D.28800 = 1;
  return D.28800;
  <D.28812>:
  D.28800 = 0;
  return D.28800;
  <D.28808>:
  <D.28804>:
  <D.28801>:
  D.28800 = 1;
  return D.28800;
}


get_plt_entry (struct MonoAotCompile * acfg, struct MonoJumpInfo * patch_info)
{
  int D.28816;
  struct MonoPltEntry * D.28819;
  struct GHashTable * * D.28820;
  <unnamed type> D.28821;
  unsigned int D.28822;
  struct GHashTable * * D.28823;
  struct GHashTable * D.28824;
  struct GHashTable * D.28827;
  int D.28828;
  struct MonoMethod * D.28833;
  short unsigned int D.28834;
  int D.28835;
  int D.28836;
  unsigned int D.28841;
  _Bool D.28842;
  long int D.28843;
  long int D.28844;
  struct MonoMemPool * D.28847;
  unsigned int D.28848;
  int D.28849;
  int D.28850;
  char * D.28851;
  int D.28852;
  struct MonoJumpInfo * D.28855;
  struct GHashTable * D.28856;
  char * D.28857;
  char * D.28858;
  char * D.28861;
  gchar * D.28862;
  gchar * D.28864;
  <unnamed type> D.28865;
  unsigned int D.28866;
  struct GHashTable * * D.28867;
  struct GHashTable * D.28868;
  struct GHashTable * D.28869;
  void * D.28870;
  unsigned int D.28871;
  struct MonoPltEntry * res;

  D.28816 = is_plt_patch (patch_info);
  if (D.28816 == 0) goto <D.28817>; else goto <D.28818>;
  <D.28817>:
  D.28819 = 0B;
  return D.28819;
  <D.28818>:
  D.28820 = acfg->patch_to_plt_entry;
  D.28821 = patch_info->type;
  D.28822 = D.28821 * 4;
  D.28823 = D.28820 + D.28822;
  D.28824 = *D.28823;
  if (D.28824 == 0B) goto <D.28825>; else goto <D.28826>;
  <D.28825>:
  D.28820 = acfg->patch_to_plt_entry;
  D.28821 = patch_info->type;
  D.28822 = D.28821 * 4;
  D.28823 = D.28820 + D.28822;
  D.28827 = monoeg_g_hash_table_new (mono_patch_info_hash, mono_patch_info_equal);
  *D.28823 = D.28827;
  <D.28826>:
  D.28820 = acfg->patch_to_plt_entry;
  D.28821 = patch_info->type;
  D.28822 = D.28821 * 4;
  D.28823 = D.28820 + D.28822;
  D.28824 = *D.28823;
  res = monoeg_g_hash_table_lookup (D.28824, patch_info);
  D.28828 = acfg->llvm;
  if (D.28828 == 0) goto <D.28829>; else goto <D.28830>;
  <D.28829>:
  D.28821 = patch_info->type;
  if (D.28821 == 3) goto <D.28831>; else goto <D.28832>;
  <D.28831>:
  D.28833 = patch_info->data.method;
  D.28834 = D.28833->iflags;
  D.28835 = (int) D.28834;
  D.28836 = D.28835 & 32;
  if (D.28836 != 0) goto <D.28837>; else goto <D.28838>;
  <D.28837>:
  res = 0B;
  <D.28838>:
  <D.28832>:
  <D.28830>:
  if (res == 0B) goto <D.28839>; else goto <D.28840>;
  <D.28839>:
  {
    struct MonoJumpInfo * new_ji;

    D.28841 = acfg->final_got_size;
    D.28842 = D.28841 != 0;
    D.28843 = (long int) D.28842;
    D.28844 = __builtin_expect (D.28843, 0);
    if (D.28844 != 0) goto <D.28845>; else goto <D.28846>;
    <D.28845>:
    monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "aot-compiler.c", 2930, "!acfg->final_got_size");
    <D.28846>:
    D.28847 = acfg->mempool;
    new_ji = mono_patch_info_dup_mp (D.28847, patch_info);
    D.28847 = acfg->mempool;
    res = mono_mempool_alloc0 (D.28847, 28);
    D.28848 = acfg->plt_offset;
    D.28849 = (int) D.28848;
    res->plt_offset = D.28849;
    res->ji = new_ji;
    D.28850 = res->plt_offset;
    D.28851 = get_plt_symbol (acfg, D.28850, patch_info);
    res->symbol = D.28851;
    D.28852 = acfg->aot_opts.write_symbols;
    if (D.28852 != 0) goto <D.28853>; else goto <D.28854>;
    <D.28853>:
    D.28855 = res->ji;
    D.28856 = acfg->plt_entry_debug_sym_cache;
    D.28857 = get_plt_entry_debug_sym (acfg, D.28855, D.28856);
    res->debug_sym = D.28857;
    <D.28854>:
    D.28858 = res->debug_sym;
    if (D.28858 != 0B) goto <D.28859>; else goto <D.28860>;
    <D.28859>:
    D.28861 = res->symbol;
    D.28858 = res->debug_sym;
    D.28862 = monoeg_g_strdup_printf ("%s_%s_llvm", D.28861, D.28858);
    res->llvm_symbol = D.28862;
    goto <D.28863>;
    <D.28860>:
    D.28861 = res->symbol;
    D.28864 = monoeg_g_strdup_printf ("%s_llvm", D.28861);
    res->llvm_symbol = D.28864;
    <D.28863>:
    D.28820 = acfg->patch_to_plt_entry;
    D.28865 = new_ji->type;
    D.28866 = D.28865 * 4;
    D.28867 = D.28820 + D.28866;
    D.28868 = *D.28867;
    monoeg_g_hash_table_insert_replace (D.28868, new_ji, res, 0);
    D.28869 = acfg->plt_offset_to_entry;
    D.28850 = res->plt_offset;
    D.28870 = (void *) D.28850;
    monoeg_g_hash_table_insert_replace (D.28869, D.28870, res, 0);
    D.28848 = acfg->plt_offset;
    D.28871 = D.28848 + 1;
    acfg->plt_offset = D.28871;
  }
  <D.28840>:
  D.28819 = res;
  return D.28819;
}


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

  D.28873 = patch_info->type;
  switch (D.28873) <default: <D.26655>, case 3: <D.26645>, case 7: <D.26646>, case 15: <D.26649>, case 31: <D.26648>, case 32: <D.26647>, case 35: <D.26650>, case 36: <D.26651>, case 37: <D.26652>, case 38: <D.26653>, case 41: <D.26654>>
  <D.26645>:
  <D.26646>:
  <D.26647>:
  <D.26648>:
  <D.26649>:
  <D.26650>:
  <D.26651>:
  <D.26652>:
  <D.26653>:
  <D.26654>:
  D.28874 = 1;
  return D.28874;
  <D.26655>:
  D.28874 = 0;
  return D.28874;
}


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

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


get_plt_entry_debug_sym (struct MonoAotCompile * acfg, struct MonoJumpInfo * ji, struct GHashTable * cache)
{
  <unnamed type> D.28879;
  struct MonoMethod * D.28880;
  const char * D.28881;
  struct MonoClass * D.28882;
  struct MonoType * D.28883;
  unsigned int D.28884;
  unsigned int D.28885;
  unsigned int D.28886;
  char * D.28887;
  char * debug_sym;
  char * s;

  debug_sym = 0B;
  D.28879 = ji->type;
  switch (D.28879) <default: <D.27724>, case 3: <D.27715>, case 7: <D.27717>, case 15: <D.27718>, case 31: <D.27720>, case 32: <D.27722>, case 35: <D.27719>, case 36: <D.27723>>
  <D.27715>:
  D.28880 = ji->data.method;
  debug_sym = get_debug_sym (D.28880, "plt_", cache);
  goto <D.27716>;
  <D.27717>:
  D.28881 = ji->data.name;
  debug_sym = monoeg_g_strdup_printf ("plt__jit_icall_%s", D.28881);
  goto <D.27716>;
  <D.27718>:
  D.28882 = ji->data.klass;
  D.28883 = &D.28882->byval_arg;
  s = mono_type_get_name (D.28883);
  debug_sym = monoeg_g_strdup_printf ("plt__class_init_%s", s);
  monoeg_g_free (s);
  goto <D.27716>;
  <D.27719>:
  D.28884 = acfg->label_generator;
  D.28885 = D.28884;
  D.28886 = D.28885 + 1;
  acfg->label_generator = D.28886;
  debug_sym = monoeg_g_strdup_printf ("plt__rgctx_fetch_%d", D.28885);
  goto <D.27716>;
  <D.27720>:
  {
    char * s;

    D.28880 = ji->data.method;
    s = get_debug_sym (D.28880, "", cache);
    debug_sym = monoeg_g_strdup_printf ("plt__icall_native_%s", s);
    monoeg_g_free (s);
    goto <D.27716>;
  }
  <D.27722>:
  D.28881 = ji->data.name;
  debug_sym = monoeg_g_strdup_printf ("plt__jit_icall_native_%s", D.28881);
  goto <D.27716>;
  <D.27723>:
  debug_sym = monoeg_g_strdup_printf ("plt__generic_class_init");
  goto <D.27716>;
  <D.27724>:
  goto <D.27716>;
  <D.27716>:
  D.28887 = sanitize_symbol (acfg, debug_sym);
  return D.28887;
}


sanitize_symbol (struct MonoAotCompile * acfg, char * s)
{
  char * D.28892;
  unsigned int D.28893;
  sizetype i.16;
  char * D.28897;
  char D.28898;
  signed char D.28899;
  const short unsigned int * * D.28901;
  const short unsigned int * D.28902;
  unsigned int D.28903;
  unsigned int D.28904;
  const short unsigned int * D.28905;
  short unsigned int D.28906;
  int D.28907;
  int D.28908;
  unsigned int len.17;
  signed char c.18;
  unsigned int D.28918;
  unsigned int D.28919;
  const short unsigned int * D.28920;
  short unsigned int D.28921;
  int D.28922;
  int D.28923;
  int D.28927;
  unsigned char D.28928;
  struct MonoMemPool * D.28930;
  char * D.28931;
  gboolean process;
  int i;
  int len;
  struct GString * gs;
  char * res;

  process = 0;
  if (s == 0B) goto <D.28890>; else goto <D.28891>;
  <D.28890>:
  D.28892 = s;
  return D.28892;
  <D.28891>:
  D.28893 = strlen (s);
  len = (int) D.28893;
  i = 0;
  goto <D.27442>;
  <D.27441>:
  i.16 = (sizetype) i;
  D.28897 = s + i.16;
  D.28898 = *D.28897;
  D.28899 = (signed char) D.28898;
  if (D.28899 < 0) goto <D.28894>; else goto <D.28900>;
  <D.28900>:
  D.28901 = __ctype_b_loc ();
  D.28902 = *D.28901;
  i.16 = (sizetype) i;
  D.28897 = s + i.16;
  D.28898 = *D.28897;
  D.28903 = (unsigned int) D.28898;
  D.28904 = D.28903 * 2;
  D.28905 = D.28902 + D.28904;
  D.28906 = *D.28905;
  D.28907 = (int) D.28906;
  D.28908 = D.28907 & 8;
  if (D.28908 == 0) goto <D.28909>; else goto <D.28895>;
  <D.28909>:
  i.16 = (sizetype) i;
  D.28897 = s + i.16;
  D.28898 = *D.28897;
  if (D.28898 != 95) goto <D.28894>; else goto <D.28895>;
  <D.28894>:
  process = 1;
  <D.28895>:
  i = i + 1;
  <D.27442>:
  if (i < len) goto <D.27441>; else goto <D.27443>;
  <D.27443>:
  if (process == 0) goto <D.28910>; else goto <D.28911>;
  <D.28910>:
  D.28892 = s;
  return D.28892;
  <D.28911>:
  len.17 = (unsigned int) len;
  gs = monoeg_g_string_sized_new (len.17);
  i = 0;
  goto <D.27449>;
  <D.27448>:
  {
    guint8 c;

    i.16 = (sizetype) i;
    D.28897 = s + i.16;
    c = *D.28897;
    c.18 = (signed char) c;
    if (c.18 >= 0) goto <D.28917>; else goto <D.28913>;
    <D.28917>:
    D.28901 = __ctype_b_loc ();
    D.28902 = *D.28901;
    D.28918 = (unsigned int) c;
    D.28919 = D.28918 * 2;
    D.28920 = D.28902 + D.28919;
    D.28921 = *D.28920;
    D.28922 = (int) D.28921;
    D.28923 = D.28922 & 8;
    if (D.28923 != 0) goto <D.28914>; else goto <D.28924>;
    <D.28924>:
    if (c == 95) goto <D.28914>; else goto <D.28913>;
    <D.28914>:
    monoeg_g_string_append_c (gs, c);
    goto <D.28915>;
    <D.28913>:
    c.18 = (signed char) c;
    if (c.18 < 0) goto <D.28925>; else goto <D.28926>;
    <D.28925>:
    D.28927 = (int) c;
    monoeg_g_string_append_printf (gs, "_0x%x", D.28927);
    i = i + 1;
    i.16 = (sizetype) i;
    D.28897 = s + i.16;
    c = *D.28897;
    goto <D.27446>;
    <D.27445>:
    D.28927 = (int) c;
    monoeg_g_string_append_printf (gs, "%x", D.28927);
    i = i + 1;
    i.16 = (sizetype) i;
    D.28897 = s + i.16;
    c = *D.28897;
    <D.27446>:
    D.28928 = c >> 6;
    if (D.28928 == 2) goto <D.27445>; else goto <D.27447>;
    <D.27447>:
    monoeg_g_string_append_printf (gs, "_");
    i = i + -1;
    goto <D.28929>;
    <D.28926>:
    monoeg_g_string_append_c (gs, 95);
    <D.28929>:
    <D.28915>:
  }
  i = i + 1;
  <D.27449>:
  if (i < len) goto <D.27448>; else goto <D.27450>;
  <D.27450>:
  D.28930 = acfg->mempool;
  D.28931 = gs->str;
  res = mono_mempool_strdup (D.28930, D.28931);
  monoeg_g_string_free (gs, 1);
  D.28892 = res;
  return D.28892;
}


mono_aot_get_method_index (struct MonoMethod * method)
{
  struct MonoAotCompile * llvm_acfg.19;
  _Bool D.28934;
  long int D.28935;
  long int D.28936;
  int D.28939;
  unsigned int D.28940;

  llvm_acfg.19 = llvm_acfg;
  D.28934 = llvm_acfg.19 == 0B;
  D.28935 = (long int) D.28934;
  D.28936 = __builtin_expect (D.28935, 0);
  if (D.28936 != 0) goto <D.28937>; else goto <D.28938>;
  <D.28937>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "aot-compiler.c", 6895, "llvm_acfg");
  <D.28938>:
  llvm_acfg.19 = llvm_acfg;
  D.28940 = get_method_index (llvm_acfg.19, method);
  D.28939 = (int) D.28940;
  return D.28939;
}


get_method_index (struct MonoAotCompile * acfg, struct MonoMethod * method)
{
  struct GHashTable * D.28942;
  void * D.28943;
  _Bool D.28944;
  long int D.28945;
  long int D.28946;
  guint32 D.28949;
  int D.28950;
  int index;

  D.28942 = acfg->method_indexes;
  D.28943 = monoeg_g_hash_table_lookup (D.28942, method);
  index = (int) D.28943;
  D.28944 = index == 0;
  D.28945 = (long int) D.28944;
  D.28946 = __builtin_expect (D.28945, 0);
  if (D.28946 != 0) goto <D.28947>; else goto <D.28948>;
  <D.28947>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "aot-compiler.c", 3010, "index");
  <D.28948>:
  D.28950 = index + -1;
  D.28949 = (guint32) D.28950;
  return D.28949;
}


mono_aot_patch_info_dup (struct MonoJumpInfo * ji)
{
  struct MonoAotCompile * llvm_acfg.20;
  union mono_mutex_t * D.28953;
  _Bool D.28956;
  long int D.28957;
  long int D.28958;
  struct MonoMemPool * D.28961;
  _Bool D.28964;
  long int D.28965;
  long int D.28966;
  struct MonoJumpInfo * D.28969;
  struct MonoJumpInfo * res;

  {
    int ret;

    llvm_acfg.20 = llvm_acfg;
    D.28953 = &llvm_acfg.20->mutex.mutex;
    ret = pthread_mutex_lock (D.28953);
    if (ret != 0) goto <D.28954>; else goto <D.28955>;
    <D.28954>:
    monoeg_g_log (0B, 16, "Bad call to mono_mutex_lock result %d", ret);
    <D.28955>:
    D.28956 = ret != 0;
    D.28957 = (long int) D.28956;
    D.28958 = __builtin_expect (D.28957, 0);
    if (D.28958 != 0) goto <D.28959>; else goto <D.28960>;
    <D.28959>:
    monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "aot-compiler.c", 6904, "ret == 0");
    <D.28960>:
  }
  llvm_acfg.20 = llvm_acfg;
  D.28961 = llvm_acfg.20->mempool;
  res = mono_patch_info_dup_mp (D.28961, ji);
  {
    int ret;

    llvm_acfg.20 = llvm_acfg;
    D.28953 = &llvm_acfg.20->mutex.mutex;
    ret = pthread_mutex_unlock (D.28953);
    if (ret != 0) goto <D.28962>; else goto <D.28963>;
    <D.28962>:
    monoeg_g_log (0B, 16, "Bad call to mono_mutex_unlock result %d", ret);
    <D.28963>:
    D.28964 = ret != 0;
    D.28965 = (long int) D.28964;
    D.28966 = __builtin_expect (D.28965, 0);
    if (D.28966 != 0) goto <D.28967>; else goto <D.28968>;
    <D.28967>:
    monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "aot-compiler.c", 6906, "ret == 0");
    <D.28968>:
  }
  D.28969 = res;
  return D.28969;
}


mono_aot_method_hash (struct MonoMethod * method)
{
  unsigned char D.28971;
  unsigned char D.28972;
  short unsigned int D.28975;
  int D.28976;
  int D.28977;
  int iftmp.21;
  <unnamed-unsigned:22> D.28981;
  unsigned int hashes_count.22;
  unsigned int D.28984;
  unsigned char D.28985;
  unsigned char D.28986;
  _Bool D.28987;
  _Bool D.28988;
  _Bool D.28989;
  unsigned char D.28993;
  struct MonoType * D.28996;
  unsigned int D.28997;
  guint32 * D.28998;
  const char * D.29000;
  unsigned int D.29001;
  const char * D.29002;
  unsigned int D.29003;
  unsigned char D.29007;
  _Bool D.29008;
  _Bool D.29009;
  _Bool D.29010;
  guint32 * D.29012;
  const char * D.29013;
  unsigned int D.29014;
  guint32 * D.29015;
  <unnamed-unsigned:5> D.29016;
  unsigned int D.29017;
  guint32 * D.29018;
  struct MonoType * D.29019;
  unsigned int D.29020;
  int hindex.23;
  unsigned int hindex.24;
  unsigned int D.29023;
  guint32 * D.29024;
  struct MonoType * D.29025;
  unsigned int D.29026;
  int hindex.25;
  unsigned int hindex.26;
  unsigned int D.29031;
  guint32 * D.29032;
  struct MonoType * D.29033;
  unsigned int D.29034;
  int D.29035;
  _Bool D.29036;
  long int D.29037;
  long int D.29038;
  unsigned int D.29041;
  unsigned int D.29042;
  unsigned int D.29043;
  unsigned int D.29044;
  unsigned int D.29045;
  unsigned int D.29046;
  unsigned int D.29047;
  unsigned int D.29048;
  unsigned int D.29049;
  unsigned int D.29050;
  unsigned int D.29051;
  unsigned int D.29052;
  unsigned int D.29053;
  unsigned int D.29054;
  unsigned int D.29055;
  unsigned int D.29056;
  guint32 D.29058;
  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.28971 = BIT_FIELD_REF <*method, 8, 168>;
  D.28972 = D.28971 & 16;
  if (D.28972 != 0) goto <D.28973>; else goto <D.28974>;
  <D.28973>:
  ginst = MEM[(struct MonoMethodInflated *)method].context.method_inst;
  <D.28974>:
  D.28975 = sig->param_count;
  D.28976 = (int) D.28975;
  D.28977 = D.28976 + 5;
  if (ginst != 0B) goto <D.28979>; else goto <D.28980>;
  <D.28979>:
  D.28981 = ginst->type_argc;
  iftmp.21 = (int) D.28981;
  goto <D.28982>;
  <D.28980>:
  iftmp.21 = 0;
  <D.28982>:
  hashes_count = D.28977 + iftmp.21;
  hashes_count.22 = (unsigned int) hashes_count;
  D.28984 = hashes_count.22 * 4;
  hashes_start = monoeg_malloc0 (D.28984);
  hashes = hashes_start;
  D.28985 = BIT_FIELD_REF <*method, 8, 160>;
  D.28986 = D.28985 & 124;
  D.28987 = D.28986 == 0;
  D.28988 = D.28986 == 36;
  D.28989 = D.28987 | D.28988;
  if (D.28989 != 0) goto <D.28990>; else goto <D.28991>;
  <D.28990>:
  klass = method->klass;
  goto <D.28992>;
  <D.28991>:
  klass = mono_defaults.object_class;
  <D.28992>:
  D.28985 = BIT_FIELD_REF <*method, 8, 160>;
  D.28993 = D.28985 & 124;
  if (D.28993 == 0) goto <D.28994>; else goto <D.28995>;
  <D.28994>:
  {
    char * full_name;

    D.28996 = &klass->byval_arg;
    full_name = mono_type_full_name (D.28996);
    D.28997 = mono_metadata_str_hash (full_name);
    *hashes = D.28997;
    D.28998 = hashes + 4;
    *D.28998 = 0;
    monoeg_g_free (full_name);
  }
  goto <D.28999>;
  <D.28995>:
  D.29000 = klass->name;
  D.29001 = mono_metadata_str_hash (D.29000);
  *hashes = D.29001;
  D.28998 = hashes + 4;
  D.29002 = klass->name_space;
  D.29003 = mono_metadata_str_hash (D.29002);
  *D.28998 = D.29003;
  <D.28999>:
  D.28985 = BIT_FIELD_REF <*method, 8, 160>;
  D.29007 = D.28985 & 124;
  D.29008 = D.29007 == 52;
  D.29009 = D.29007 == 48;
  D.29010 = D.29008 | D.29009;
  if (D.29010 != 0) goto <D.29004>; else goto <D.29011>;
  <D.29011>:
  D.28985 = BIT_FIELD_REF <*method, 8, 160>;
  D.28993 = D.28985 & 124;
  if (D.28993 == 92) goto <D.29004>; else goto <D.29005>;
  <D.29004>:
  D.29012 = hashes + 8;
  *D.29012 = 0;
  goto <D.29006>;
  <D.29005>:
  D.29012 = hashes + 8;
  D.29013 = method->name;
  D.29014 = mono_metadata_str_hash (D.29013);
  *D.29012 = D.29014;
  <D.29006>:
  D.29015 = hashes + 12;
  D.29016 = method->wrapper_type;
  D.29017 = (unsigned int) D.29016;
  *D.29015 = D.29017;
  D.29018 = hashes + 16;
  D.29019 = sig->ret;
  D.29020 = mono_aot_type_hash (D.29019);
  *D.29018 = D.29020;
  hindex = 5;
  i = 0;
  goto <D.28222>;
  <D.28221>:
  hindex.23 = hindex;
  hindex = hindex.23 + 1;
  hindex.24 = (unsigned int) hindex.23;
  D.29023 = hindex.24 * 4;
  D.29024 = hashes + D.29023;
  D.29025 = sig->params[i];
  D.29026 = mono_aot_type_hash (D.29025);
  *D.29024 = D.29026;
  i = i + 1;
  <D.28222>:
  D.28975 = sig->param_count;
  D.28976 = (int) D.28975;
  if (D.28976 > i) goto <D.28221>; else goto <D.28223>;
  <D.28223>:
  if (ginst != 0B) goto <D.29027>; else goto <D.29028>;
  <D.29027>:
  i = 0;
  goto <D.28225>;
  <D.28224>:
  hindex.25 = hindex;
  hindex = hindex.25 + 1;
  hindex.26 = (unsigned int) hindex.25;
  D.29031 = hindex.26 * 4;
  D.29032 = hashes + D.29031;
  D.29033 = ginst->type_argv[i];
  D.29034 = mono_aot_type_hash (D.29033);
  *D.29032 = D.29034;
  i = i + 1;
  <D.28225>:
  D.28981 = ginst->type_argc;
  D.29035 = (int) D.28981;
  if (D.29035 > i) goto <D.28224>; else goto <D.28226>;
  <D.28226>:
  <D.29028>:
  D.29036 = hindex != hashes_count;
  D.29037 = (long int) D.29036;
  D.29038 = __builtin_expect (D.29037, 0);
  if (D.29038 != 0) goto <D.29039>; else goto <D.29040>;
  <D.29039>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "aot-compiler.c", 7387, "hindex == hashes_count");
  <D.29040>:
  hashes_count.22 = (unsigned int) hashes_count;
  D.29041 = hashes_count.22 << 2;
  c = D.29041 + 3735928559;
  b = c;
  a = b;
  goto <D.28228>;
  <D.28227>:
  D.29042 = *hashes;
  a = D.29042 + a;
  D.28998 = hashes + 4;
  D.29043 = *D.28998;
  b = D.29043 + b;
  D.29012 = hashes + 8;
  D.29044 = *D.29012;
  c = D.29044 + c;
  a = a - c;
  D.29045 = c r>> 28;
  a = D.29045 ^ a;
  c = c + b;
  b = b - a;
  D.29046 = a r>> 26;
  b = D.29046 ^ b;
  a = a + c;
  c = c - b;
  D.29047 = b r>> 24;
  c = D.29047 ^ c;
  b = b + a;
  a = a - c;
  D.29048 = c r>> 16;
  a = D.29048 ^ a;
  c = c + b;
  b = b - a;
  D.29049 = a r>> 13;
  b = D.29049 ^ b;
  a = a + c;
  c = c - b;
  D.29050 = b r>> 28;
  c = D.29050 ^ c;
  b = b + a;
  hashes_count = hashes_count + -3;
  hashes = hashes + 12;
  <D.28228>:
  if (hashes_count > 3) goto <D.28227>; else goto <D.28229>;
  <D.28229>:
  switch (hashes_count) <default: <D.29057>, case 0: <D.28233>, case 1: <D.28232>, case 2: <D.28231>, case 3: <D.28230>>
  <D.28230>:
  D.29012 = hashes + 8;
  D.29044 = *D.29012;
  c = D.29044 + c;
  <D.28231>:
  D.28998 = hashes + 4;
  D.29043 = *D.28998;
  b = D.29043 + b;
  <D.28232>:
  D.29042 = *hashes;
  a = D.29042 + a;
  c = c ^ b;
  D.29051 = b r>> 18;
  c = c - D.29051;
  a = a ^ c;
  D.29052 = c r>> 21;
  a = a - D.29052;
  b = b ^ a;
  D.29053 = a r>> 7;
  b = b - D.29053;
  c = c ^ b;
  D.29054 = b r>> 16;
  c = c - D.29054;
  a = a ^ c;
  D.29045 = c r>> 28;
  a = a - D.29045;
  b = b ^ a;
  D.29055 = a r>> 18;
  b = b - D.29055;
  c = c ^ b;
  D.29056 = b r>> 8;
  c = c - D.29056;
  <D.28233>:
  goto <D.28234>;
  <D.29057>:
  <D.28234>:
  free (hashes_start);
  D.29058 = c;
  return D.29058;
}


mono_aot_type_hash (struct MonoType * t1)
{
  unsigned char D.29060;
  <unnamed-unsigned:1> D.29061;
  int D.29062;
  int D.29063;
  unsigned int D.29064;
  int D.29065;
  guint D.29066;
  unsigned int D.29067;
  unsigned int D.29068;
  struct MonoClass * D.29069;
  const char * D.29070;
  unsigned int D.29071;
  struct MonoType * D.29072;
  unsigned int D.29073;
  struct MonoArrayType * D.29074;
  struct MonoClass * D.29075;
  struct MonoType * D.29076;
  unsigned int D.29077;
  guint hash;

  D.29060 = t1->type;
  hash = (guint) D.29060;
  D.29061 = t1->byref;
  D.29062 = (int) D.29061;
  D.29063 = D.29062 << 6;
  D.29064 = (unsigned int) D.29063;
  hash = D.29064 | hash;
  D.29060 = t1->type;
  D.29065 = (int) D.29060;
  switch (D.29065) <default: <D.28205>, case 15: <D.28202>, case 17: <D.28199>, case 18: <D.28200>, case 20: <D.28203>, case 21: <D.28204>, case 29: <D.28201>>
  <D.28199>:
  <D.28200>:
  <D.28201>:
  D.29067 = hash << 5;
  D.29068 = D.29067 - hash;
  D.29069 = t1->data.klass;
  D.29070 = D.29069->name;
  D.29071 = mono_metadata_str_hash (D.29070);
  D.29066 = D.29068 ^ D.29071;
  return D.29066;
  <D.28202>:
  D.29067 = hash << 5;
  D.29068 = D.29067 - hash;
  D.29072 = t1->data.type;
  D.29073 = mono_metadata_type_hash (D.29072);
  D.29066 = D.29068 ^ D.29073;
  return D.29066;
  <D.28203>:
  D.29067 = hash << 5;
  D.29068 = D.29067 - hash;
  D.29074 = t1->data.array;
  D.29075 = D.29074->eklass;
  D.29076 = &D.29075->byval_arg;
  D.29077 = mono_metadata_type_hash (D.29076);
  D.29066 = D.29068 ^ D.29077;
  return D.29066;
  <D.28204>:
  D.29067 = hash << 5;
  D.29066 = D.29067 - hash;
  return D.29066;
  <D.28205>:
  D.29066 = hash;
  return D.29066;
}


mono_aot_get_array_helper_from_wrapper (struct MonoMethod * method)
{
  const char * D.29079;
  unsigned int D.29080;
  sizetype D.29081;
  const char * D.29082;
  _Bool D.29083;
  long int D.29084;
  long int D.29085;
  int D.28255;
  int iftmp.27;
  int D.28254;
  const char[6] * D.29091;
  unsigned char D.29092;
  int D.29093;
  unsigned char D.29094;
  int D.29095;
  _Bool D.29096;
  _Bool D.29097;
  _Bool D.29098;
  const unsigned char * D.29101;
  unsigned char D.29102;
  int D.29103;
  const unsigned char * D.29104;
  unsigned char D.29105;
  int D.29106;
  _Bool D.29107;
  _Bool D.29108;
  const unsigned char * D.29111;
  unsigned char D.29112;
  int D.29113;
  const unsigned char * D.29114;
  unsigned char D.29115;
  int D.29116;
  _Bool D.29117;
  _Bool D.29118;
  const unsigned char * D.29121;
  unsigned char D.29122;
  int D.29123;
  const unsigned char * D.29124;
  unsigned char D.29125;
  int D.29126;
  struct MonoClass * D.29131;
  struct MonoMethodSignature * D.29132;
  short unsigned int D.29133;
  int D.29134;
  _Bool D.29135;
  long int D.29136;
  long int D.29137;
  unsigned char D.29140;
  unsigned char D.29141;
  struct MonoClass * D.29144;
  struct MonoClass * D.29145;
  struct MonoType * D.29146;
  struct MonoGenericInst * D.29147;
  struct MonoMethod * D.29148;
  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.29079 = method->name;
      D.29080 = strlen (prefix);
      D.29081 = D.29080 + 1;
      D.29082 = D.29079 + D.29081;
      s = monoeg_g_strdup_printf ("%s", D.29082);
      s2 = strstr (s, "`1.");
      D.29083 = s2 == 0B;
      D.29084 = (long int) D.29083;
      D.29085 = __builtin_expect (D.29084, 0);
      if (D.29085 != 0) goto <D.29086>; else goto <D.29087>;
      <D.29086>:
      monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "aot-compiler.c", 7437, "s2");
      <D.29087>:
      *s2 = 0;
      iname = s;
      mname = s2 + 3;
      {
        size_t __s1_len;
        size_t __s2_len;

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

          __s2 = iname;
          D.29091 = "IList";
          D.29092 = MEM[(const unsigned char *)D.29091];
          D.29093 = (int) D.29092;
          D.29094 = *__s2;
          D.29095 = (int) D.29094;
          __result = D.29093 - D.29095;
          {
            D.29096 = __s2_len != 0;
            D.29097 = __result == 0;
            D.29098 = D.29096 & D.29097;
            if (D.29098 != 0) goto <D.29099>; else goto <D.29100>;
            <D.29099>:
            D.29101 = &MEM[(void *)"IList" + 1B];
            D.29102 = *D.29101;
            D.29103 = (int) D.29102;
            D.29104 = __s2 + 1;
            D.29105 = *D.29104;
            D.29106 = (int) D.29105;
            __result = D.29103 - D.29106;
            D.29107 = __s2_len > 1;
            D.29097 = __result == 0;
            D.29108 = D.29107 & D.29097;
            if (D.29108 != 0) goto <D.29109>; else goto <D.29110>;
            <D.29109>:
            D.29111 = &MEM[(void *)"IList" + 2B];
            D.29112 = *D.29111;
            D.29113 = (int) D.29112;
            D.29114 = __s2 + 2;
            D.29115 = *D.29114;
            D.29116 = (int) D.29115;
            __result = D.29113 - D.29116;
            D.29117 = __s2_len > 2;
            D.29097 = __result == 0;
            D.29118 = D.29117 & D.29097;
            if (D.29118 != 0) goto <D.29119>; else goto <D.29120>;
            <D.29119>:
            D.29121 = &MEM[(void *)"IList" + 3B];
            D.29122 = *D.29121;
            D.29123 = (int) D.29122;
            D.29124 = __s2 + 3;
            D.29125 = *D.29124;
            D.29126 = (int) D.29125;
            __result = D.29123 - D.29126;
            <D.29120>:
            <D.29110>:
            <D.29100>:
          }
          D.28254 = __result;
        }
        iftmp.27 = -D.28254;
        goto <D.29127>;
        <D.29090>:
        iftmp.27 = __builtin_strcmp (iname, "IList");
        <D.29127>:
        D.28255 = iftmp.27;
      }
      if (D.28255 == 0) goto <D.29128>; else goto <D.29129>;
      <D.29128>:
      helper_name = monoeg_g_strdup_printf ("InternalArray__%s", mname);
      goto <D.29130>;
      <D.29129>:
      helper_name = monoeg_g_strdup_printf ("InternalArray__%s_%s", iname, mname);
      <D.29130>:
      D.29131 = mono_defaults.array_class;
      D.29132 = mono_method_signature (method);
      D.29133 = D.29132->param_count;
      D.29134 = (int) D.29133;
      m = mono_class_get_method_from_name (D.29131, helper_name, D.29134);
      D.29135 = m == 0B;
      D.29136 = (long int) D.29135;
      D.29137 = __builtin_expect (D.29136, 0);
      if (D.29137 != 0) goto <D.29138>; else goto <D.29139>;
      <D.29138>:
      monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "aot-compiler.c", 7449, "m");
      <D.29139>:
      monoeg_g_free (helper_name);
      monoeg_g_free (s);
      D.29140 = BIT_FIELD_REF <*m, 8, 168>;
      D.29141 = D.29140 & 8;
      if (D.29141 != 0) goto <D.29142>; else goto <D.29143>;
      <D.29142>:
      memset (&ctx, 0, 8);
      D.29144 = method->klass;
      D.29145 = D.29144->element_class;
      D.29146 = &D.29145->byval_arg;
      args[0] = D.29146;
      D.29147 = mono_metadata_get_generic_inst (1, &args);
      ctx.method_inst = D.29147;
      m = mono_class_inflate_generic_method (m, &ctx);
      <D.29143>:
      D.29148 = m;
      return D.29148;
    }
  finally
    {
      ctx = {CLOBBER};
      args = {CLOBBER};
    }
}


memset (void * __dest, int __ch, size_t __len)
{
  int D.29153;
  int D.29158;
  void * D.29160;
  unsigned int D.29161;

  D.29153 = __builtin_constant_p (__len);
  if (D.29153 != 0) goto <D.29154>; else goto <D.29155>;
  <D.29154>:
  if (__len == 0) goto <D.29156>; else goto <D.29157>;
  <D.29156>:
  D.29158 = __builtin_constant_p (__ch);
  if (D.29158 == 0) goto <D.29151>; else goto <D.29159>;
  <D.29159>:
  if (__ch != 0) goto <D.29151>; else goto <D.29152>;
  <D.29151>:
  __warn_memset_zero_len ();
  D.29160 = __dest;
  return D.29160;
  <D.29152>:
  <D.29157>:
  <D.29155>:
  D.29161 = __builtin_object_size (__dest, 0);
  D.29160 = __builtin___memset_chk (__dest, __ch, __len, D.29161);
  return D.29160;
}


mono_compile_assembly (struct MonoAssembly * ass, guint32 opts, const char * aot_options)
{
  unsigned int D.29163;
  struct _IO_FILE * stderr.28;
  char * D.29167;
  struct MonoAotOptions * D.29168;
  gchar * D.29169;
  int D.29170;
  int D.29173;
  int D.29180;
  int D.29183;
  int D.29186;
  <unnamed type> D.29187;
  unsigned int D.29188;
  int mono_use_llvm.29;
  unsigned int D.29192;
  int D.29195;
  unsigned int D.29198;
  guint32 iftmp.30;
  int D.29202;
  guint32 iftmp.31;
  int D.29207;
  guint32 iftmp.32;
  int D.29212;
  unsigned int D.29214;
  unsigned int D.29215;
  guint32 iftmp.33;
  int D.29221;
  const char * D.29223;
  struct MonoImage * D.29224;
  struct MonoAssembly * D.29225;
  const char * D.29226;
  gchar * D.29227;
  const char * D.29228;
  gchar * D.29229;
  gchar * D.29230;
  const short unsigned int * * D.29231;
  const short unsigned int * D.29232;
  char D.29233;
  unsigned int D.29234;
  unsigned int D.29235;
  const short unsigned int * D.29236;
  short unsigned int D.29237;
  int D.29238;
  int D.29239;
  struct GPtrArray * D.29252;
  unsigned int D.29253;
  unsigned int D.29254;
  int D.29255;
  int D.29256;
  unsigned int D.29257;
  unsigned int D.29258;
  void * D.29259;
  struct MonoMemPool * D.29260;
  long long int D.29261;
  long long int D.29262;
  int D.29263;
  int D.29266;
  int D.29268;
  int D.29270;
  char * D.29272;
  char * D.29276;
  struct FILE * D.29277;
  struct FILE * D.29278;
  int * D.29281;
  int D.29282;
  char * D.29283;
  struct MonoImageWriter * D.29284;
  int D.29285;
  char * D.29288;
  struct FILE * D.29289;
  gchar * D.29295;
  gchar * D.29297;
  struct FILE * D.29298;
  char * * D.29300;
  struct FILE * D.29301;
  char * D.29304;
  struct MonoImageWriter * D.29305;
  char * D.29306;
  gchar * D.29307;
  struct MonoCompile * * D.29308;
  unsigned int i.34;
  unsigned int D.29310;
  struct MonoCompile * * D.29311;
  struct MonoCompile * D.29312;
  struct MonoMethod * D.29315;
  unsigned int D.29316;
  char * D.29319;
  gchar * D.29320;
  int D.29322;
  struct MonoMethod * D.29325;
  struct GHashTable * D.29326;
  char * D.29327;
  const char * D.29329;
  gchar * D.29330;
  unsigned int i.35;
  unsigned int D.29332;
  int D.29333;
  int D.29338;
  int D.29343;
  int D.29347;
  struct MonoImageWriter * D.29350;
  int D.29351;
  _Bool D.29352;
  int D.29353;
  struct MonoDwarfWriter * D.29354;
  struct MonoDwarfWriter * D.29355;
  gchar * D.29358;
  struct GSList * D.29359;
  int D.29360;
  int D.29365;
  int D.29368;
  unsigned int D.29373;
  unsigned int D.29374;
  _Bool D.29375;
  long int D.29376;
  long int D.29377;
  int D.29382;
  int iftmp.36;
  int D.29384;
  int D.29387;
  int D.29390;
  int D.29391;
  int D.29392;
  int D.29393;
  int D.29394;
  unsigned int D.29395;
  int D.29396;
  unsigned int D.29397;
  int D.29398;
  int D.29399;
  int D.29400;
  int iftmp.37;
  int D.29404;
  int D.29406;
  int iftmp.38;
  int D.29410;
  int D.29412;
  int iftmp.39;
  int D.29414;
  int D.29417;
  int D.29419;
  int iftmp.40;
  int D.29425;
  int D.29427;
  int iftmp.41;
  int D.29433;
  int D.29435;
  int iftmp.42;
  int D.29441;
  int D.29443;
  int iftmp.43;
  int D.29449;
  char * D.29457;
  int D.29461;
  int D.29464;
  const char * D.29467;
  int D.29468;
  int D.29469;
  int D.29470;
  int D.29471;
  int D.29472;
  int D.29473;
  int D.29474;
  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.29163 = opts & 16777216;
      if (D.29163 != 0) goto <D.29164>; else goto <D.29165>;
      <D.29164>:
      stderr.28 = stderr;
      fprintf (stderr.28, "-O=gsharedvt not supported on this platform.\n");
      exit (1);
      <D.29165>:
      D.29167 = image->name;
      printf ("Mono Ahead of Time compiler - compiling assembly %s\n", D.29167);
      acfg = acfg_create (ass, opts);
      D.29168 = &acfg->aot_opts;
      memset (D.29168, 0, 128);
      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.29169 = monoeg_strdup ("");
      acfg->aot_opts.llvm_path = D.29169;
      D.29168 = &acfg->aot_opts;
      mono_aot_parse_options (aot_options, D.29168);
      D.29170 = acfg->aot_opts.static_link;
      if (D.29170 != 0) goto <D.29171>; else goto <D.29172>;
      <D.29171>:
      acfg->aot_opts.autoreg = 1;
      <D.29172>:
      D.29173 = acfg->aot_opts.direct_pinvoke;
      if (D.29173 != 0) goto <D.29174>; else goto <D.29175>;
      <D.29174>:
      D.29170 = acfg->aot_opts.static_link;
      if (D.29170 == 0) goto <D.29176>; else goto <D.29177>;
      <D.29176>:
      stderr.28 = stderr;
      fprintf (stderr.28, "The \'direct-pinvoke\' AOT option also requires the \'static\' AOT option.\n");
      exit (1);
      <D.29177>:
      <D.29175>:
      D.29170 = acfg->aot_opts.static_link;
      if (D.29170 != 0) goto <D.29178>; else goto <D.29179>;
      <D.29178>:
      acfg->aot_opts.asm_writer = 1;
      <D.29179>:
      D.29180 = acfg->aot_opts.soft_debug;
      if (D.29180 != 0) goto <D.29181>; else goto <D.29182>;
      <D.29181>:
      {
        struct MonoDebugOptions * opt;

        opt = mini_get_debug_options ();
        opt->mdb_optimizations = 1;
        opt->gen_seq_points = 1;
        D.29183 = mono_debug_enabled ();
        if (D.29183 == 0) goto <D.29184>; else goto <D.29185>;
        <D.29184>:
        stderr.28 = stderr;
        fprintf (stderr.28, "The soft-debug AOT option requires the --debug option.\n");
        D.29186 = 1;
        return D.29186;
        <D.29185>:
        D.29187 = acfg->flags;
        D.29188 = D.29187 | 4;
        acfg->flags = D.29188;
      }
      <D.29182>:
      mono_use_llvm.29 = mono_use_llvm;
      if (mono_use_llvm.29 != 0) goto <D.29190>; else goto <D.29191>;
      <D.29190>:
      acfg->llvm = 1;
      acfg->aot_opts.asm_writer = 1;
      D.29187 = acfg->flags;
      D.29192 = D.29187 | 1;
      acfg->flags = D.29192;
      D.29180 = acfg->aot_opts.soft_debug;
      if (D.29180 != 0) goto <D.29193>; else goto <D.29194>;
      <D.29193>:
      stderr.28 = stderr;
      fprintf (stderr.28, "The \'soft-debug\' option is not supported when compiling with LLVM.\n");
      exit (1);
      <D.29194>:
      <D.29191>:
      D.29195 = acfg->aot_opts.full_aot;
      if (D.29195 != 0) goto <D.29196>; else goto <D.29197>;
      <D.29196>:
      D.29187 = acfg->flags;
      D.29198 = D.29187 | 2;
      acfg->flags = D.29198;
      <D.29197>:
      load_profile_files (acfg);
      D.29195 = acfg->aot_opts.full_aot;
      if (D.29195 != 0) goto <D.29200>; else goto <D.29201>;
      <D.29200>:
      D.29202 = acfg->aot_opts.ntrampolines;
      iftmp.30 = (guint32) D.29202;
      goto <D.29203>;
      <D.29201>:
      iftmp.30 = 0;
      <D.29203>:
      acfg->num_trampolines[0] = iftmp.30;
      D.29195 = acfg->aot_opts.full_aot;
      if (D.29195 != 0) goto <D.29205>; else goto <D.29206>;
      <D.29205>:
      D.29207 = acfg->aot_opts.nrgctx_trampolines;
      iftmp.31 = (guint32) D.29207;
      goto <D.29208>;
      <D.29206>:
      iftmp.31 = 0;
      <D.29208>:
      acfg->num_trampolines[1] = iftmp.31;
      D.29195 = acfg->aot_opts.full_aot;
      if (D.29195 != 0) goto <D.29210>; else goto <D.29211>;
      <D.29210>:
      D.29212 = acfg->aot_opts.nimt_trampolines;
      iftmp.32 = (guint32) D.29212;
      goto <D.29213>;
      <D.29211>:
      iftmp.32 = 0;
      <D.29213>:
      acfg->num_trampolines[2] = iftmp.32;
      D.29214 = acfg->opts;
      D.29215 = D.29214 & 16777216;
      if (D.29215 != 0) goto <D.29216>; else goto <D.29217>;
      <D.29216>:
      D.29195 = acfg->aot_opts.full_aot;
      if (D.29195 != 0) goto <D.29219>; else goto <D.29220>;
      <D.29219>:
      D.29221 = acfg->aot_opts.ngsharedvt_arg_trampolines;
      iftmp.33 = (guint32) D.29221;
      goto <D.29222>;
      <D.29220>:
      iftmp.33 = 0;
      <D.29222>:
      acfg->num_trampolines[3] = iftmp.33;
      <D.29217>:
      D.29223 = img_writer_get_temp_label_prefix (0B);
      acfg->temp_prefix = D.29223;
      arch_init (acfg);
      D.29224 = acfg->image;
      D.29225 = D.29224->assembly;
      D.29226 = D.29225->aname.name;
      D.29227 = monoeg_g_strdup_printf ("mono_aot_%s_got", D.29226);
      acfg->got_symbol_base = D.29227;
      D.29228 = acfg->llvm_label_prefix;
      D.29224 = acfg->image;
      D.29225 = D.29224->assembly;
      D.29226 = D.29225->aname.name;
      D.29229 = monoeg_g_strdup_printf ("%smono_aot_%s_plt", D.29228, D.29226);
      acfg->plt_symbol = D.29229;
      D.29224 = acfg->image;
      D.29225 = D.29224->assembly;
      D.29226 = D.29225->aname.name;
      D.29230 = monoeg_strdup (D.29226);
      acfg->assembly_name_sym = D.29230;
      p = acfg->got_symbol_base;
      goto <D.28590>;
      <D.28589>:
      D.29231 = __ctype_b_loc ();
      D.29232 = *D.29231;
      D.29233 = *p;
      D.29234 = (unsigned int) D.29233;
      D.29235 = D.29234 * 2;
      D.29236 = D.29232 + D.29235;
      D.29237 = *D.29236;
      D.29238 = (int) D.29237;
      D.29239 = D.29238 & 8;
      if (D.29239 == 0) goto <D.29240>; else goto <D.29241>;
      <D.29240>:
      D.29233 = *p;
      if (D.29233 != 95) goto <D.29242>; else goto <D.29243>;
      <D.29242>:
      *p = 95;
      <D.29243>:
      <D.29241>:
      p = p + 1;
      <D.28590>:
      D.29233 = *p;
      if (D.29233 != 0) goto <D.28589>; else goto <D.28591>;
      <D.28591>:
      p = acfg->plt_symbol;
      goto <D.28593>;
      <D.28592>:
      D.29231 = __ctype_b_loc ();
      D.29232 = *D.29231;
      D.29233 = *p;
      D.29234 = (unsigned int) D.29233;
      D.29235 = D.29234 * 2;
      D.29236 = D.29232 + D.29235;
      D.29237 = *D.29236;
      D.29238 = (int) D.29237;
      D.29239 = D.29238 & 8;
      if (D.29239 == 0) goto <D.29244>; else goto <D.29245>;
      <D.29244>:
      D.29233 = *p;
      if (D.29233 != 95) goto <D.29246>; else goto <D.29247>;
      <D.29246>:
      *p = 95;
      <D.29247>:
      <D.29245>:
      p = p + 1;
      <D.28593>:
      D.29233 = *p;
      if (D.29233 != 0) goto <D.28592>; else goto <D.28594>;
      <D.28594>:
      p = acfg->assembly_name_sym;
      goto <D.28596>;
      <D.28595>:
      D.29231 = __ctype_b_loc ();
      D.29232 = *D.29231;
      D.29233 = *p;
      D.29234 = (unsigned int) D.29233;
      D.29235 = D.29234 * 2;
      D.29236 = D.29232 + D.29235;
      D.29237 = *D.29236;
      D.29238 = (int) D.29237;
      D.29239 = D.29238 & 8;
      if (D.29239 == 0) goto <D.29248>; else goto <D.29249>;
      <D.29248>:
      D.29233 = *p;
      if (D.29233 != 95) goto <D.29250>; else goto <D.29251>;
      <D.29250>:
      *p = 95;
      <D.29251>:
      <D.29249>:
      p = p + 1;
      <D.28596>:
      D.29233 = *p;
      if (D.29233 != 0) goto <D.28595>; else goto <D.28597>;
      <D.28597>:
      acfg->method_index = 1;
      collect_methods (acfg);
      D.29252 = acfg->methods;
      D.29253 = D.29252->len;
      D.29254 = D.29253 + 32;
      D.29255 = (int) D.29254;
      acfg->cfgs_size = D.29255;
      D.29256 = acfg->cfgs_size;
      D.29257 = (unsigned int) D.29256;
      D.29258 = D.29257 * 4;
      D.29259 = monoeg_malloc0 (D.29258);
      acfg->cfgs = D.29259;
      acfg->plt_offset = 1;
      {
        struct MonoJumpInfo * ji;

        D.29260 = acfg->mempool;
        ji = mono_mempool_alloc0 (D.29260, 1032);
        ji->type = 12;
        D.29224 = acfg->image;
        ji->data.image = D.29224;
        get_got_offset (acfg, ji);
        D.29260 = acfg->mempool;
        ji = mono_mempool_alloc0 (D.29260, 1032);
        ji->type = 39;
        get_got_offset (acfg, ji);
        D.29260 = acfg->mempool;
        ji = mono_mempool_alloc0 (D.29260, 1032);
        ji->type = 42;
        get_got_offset (acfg, ji);
        D.29260 = acfg->mempool;
        ji = mono_mempool_alloc0 (D.29260, 1032);
        ji->type = 47;
        get_got_offset (acfg, ji);
      }
      atv = mono_100ns_ticks ();
      compile_methods (acfg);
      btv = mono_100ns_ticks ();
      D.29261 = btv - atv;
      D.29262 = D.29261 / 10;
      D.29263 = (int) D.29262;
      acfg->stats.jit_time = D.29263;
      atv = mono_100ns_ticks ();
      D.29266 = acfg->aot_opts.asm_only;
      if (D.29266 == 0) goto <D.29267>; else goto <D.29264>;
      <D.29267>:
      D.29268 = acfg->aot_opts.asm_writer;
      if (D.29268 == 0) goto <D.29269>; else goto <D.29264>;
      <D.29269>:
      D.29270 = bin_writer_supported ();
      if (D.29270 != 0) goto <D.29271>; else goto <D.29264>;
      <D.29271>:
      D.29272 = acfg->aot_opts.outfile;
      if (D.29272 != 0B) goto <D.29273>; else goto <D.29274>;
      <D.29273>:
      D.29272 = acfg->aot_opts.outfile;
      outfile_name = monoeg_g_strdup_printf ("%s", D.29272);
      goto <D.29275>;
      <D.29274>:
      D.29224 = acfg->image;
      D.29276 = D.29224->name;
      outfile_name = monoeg_g_strdup_printf ("%s%s", D.29276, ".so");
      <D.29275>:
      tmp_outfile_name = monoeg_g_strdup_printf ("%s.tmp", outfile_name);
      D.29277 = fopen (tmp_outfile_name, "w");
      acfg->fp = D.29277;
      D.29278 = acfg->fp;
      if (D.29278 == 0B) goto <D.29279>; else goto <D.29280>;
      <D.29279>:
      D.29281 = __errno_location ();
      D.29282 = *D.29281;
      D.29283 = strerror (D.29282);
      printf ("Unable to create temporary file \'%s\': %s\n", tmp_outfile_name, D.29283);
      D.29186 = 1;
      return D.29186;
      <D.29280>:
      D.29278 = acfg->fp;
      D.29284 = img_writer_create (D.29278, 1);
      acfg->w = D.29284;
      acfg->use_bin_writer = 1;
      goto <D.29265>;
      <D.29264>:
      D.29285 = acfg->llvm;
      if (D.29285 != 0) goto <D.29286>; else goto <D.29287>;
      <D.29286>:
      D.29288 = acfg->tmpfname;
      D.29289 = fopen (D.29288, "a+");
      acfg->fp = D.29289;
      goto <D.29290>;
      <D.29287>:
      D.29266 = acfg->aot_opts.asm_only;
      if (D.29266 != 0) goto <D.29291>; else goto <D.29292>;
      <D.29291>:
      D.29272 = acfg->aot_opts.outfile;
      if (D.29272 != 0B) goto <D.29293>; else goto <D.29294>;
      <D.29293>:
      D.29272 = acfg->aot_opts.outfile;
      D.29295 = monoeg_g_strdup_printf ("%s", D.29272);
      acfg->tmpfname = D.29295;
      goto <D.29296>;
      <D.29294>:
      D.29224 = acfg->image;
      D.29276 = D.29224->name;
      D.29297 = monoeg_g_strdup_printf ("%s.s", D.29276);
      acfg->tmpfname = D.29297;
      <D.29296>:
      D.29288 = acfg->tmpfname;
      D.29298 = fopen (D.29288, "w+");
      acfg->fp = D.29298;
      goto <D.29299>;
      <D.29292>:
      {
        int i;

        D.29300 = &acfg->tmpfname;
        i = monoeg_g_file_open_tmp ("mono_aot_XXXXXX", D.29300, 0B);
        D.29301 = fdopen (i, "w+");
        acfg->fp = D.29301;
      }
      <D.29299>:
      <D.29290>:
      D.29278 = acfg->fp;
      if (D.29278 == 0B) goto <D.29302>; else goto <D.29303>;
      <D.29302>:
      stderr.28 = stderr;
      D.29288 = acfg->tmpfname;
      D.29281 = __errno_location ();
      D.29282 = *D.29281;
      D.29304 = strerror (D.29282);
      fprintf (stderr.28, "Unable to open file \'%s\': %s\n", D.29288, D.29304);
      D.29186 = 1;
      return D.29186;
      <D.29303>:
      D.29278 = acfg->fp;
      D.29305 = img_writer_create (D.29278, 0);
      acfg->w = D.29305;
      tmp_outfile_name = 0B;
      outfile_name = 0B;
      <D.29265>:
      D.29228 = acfg->llvm_label_prefix;
      D.29306 = acfg->got_symbol_base;
      D.29307 = monoeg_g_strdup_printf ("%s%s", D.29228, D.29306);
      acfg->got_symbol = D.29307;
      i = 0;
      goto <D.28603>;
      <D.28602>:
      D.29308 = acfg->cfgs;
      i.34 = (unsigned int) i;
      D.29310 = i.34 * 4;
      D.29311 = D.29308 + D.29310;
      D.29312 = *D.29311;
      if (D.29312 != 0B) goto <D.29313>; else goto <D.29314>;
      <D.29313>:
      {
        struct MonoCompile * cfg;
        int method_index;

        D.29308 = acfg->cfgs;
        i.34 = (unsigned int) i;
        D.29310 = i.34 * 4;
        D.29311 = D.29308 + D.29310;
        cfg = *D.29311;
        D.29315 = cfg->orig_method;
        D.29316 = get_method_index (acfg, D.29315);
        method_index = (int) D.29316;
        if (0 != 0) goto <D.29317>; else goto <D.29318>;
        <D.29317>:
        D.29228 = acfg->llvm_label_prefix;
        D.29319 = cfg->llvm_method_name;
        D.29320 = monoeg_g_strdup_printf ("%s%s", D.29228, D.29319);
        cfg->asm_symbol = D.29320;
        goto <D.29321>;
        <D.29318>:
        D.29322 = acfg->global_symbols;
        if (D.29322 != 0) goto <D.29323>; else goto <D.29324>;
        <D.29323>:
        D.29325 = cfg->method;
        D.29326 = acfg->method_label_hash;
        D.29327 = get_debug_sym (D.29325, "", D.29326);
        cfg->asm_symbol = D.29327;
        goto <D.29328>;
        <D.29324>:
        D.29329 = acfg->temp_prefix;
        D.29228 = acfg->llvm_label_prefix;
        D.29330 = monoeg_g_strdup_printf ("%s%sm_%x", D.29329, D.29228, method_index);
        cfg->asm_symbol = D.29330;
        <D.29328>:
        <D.29321>:
      }
      <D.29314>:
      i = i + 1;
      <D.28603>:
      i.35 = (unsigned int) i;
      D.29332 = acfg->nmethods;
      if (i.35 < D.29332) goto <D.28602>; else goto <D.28604>;
      <D.28604>:
      D.29333 = acfg->aot_opts.dwarf_debug;
      if (D.29333 != 0) goto <D.29334>; else goto <D.29335>;
      <D.29334>:
      D.29266 = acfg->aot_opts.asm_only;
      if (D.29266 != 0) goto <D.29336>; else goto <D.29337>;
      <D.29336>:
      D.29338 = acfg->aot_opts.gnu_asm;
      if (D.29338 != 0) goto <D.29339>; else goto <D.29340>;
      <D.29339>:
      acfg->gas_line_numbers = 1;
      <D.29340>:
      <D.29337>:
      <D.29335>:
      D.29343 = acfg->aot_opts.nodebug;
      if (D.29343 == 0) goto <D.29341>; else goto <D.29344>;
      <D.29344>:
      D.29333 = acfg->aot_opts.dwarf_debug;
      if (D.29333 != 0) goto <D.29341>; else goto <D.29342>;
      <D.29341>:
      D.29333 = acfg->aot_opts.dwarf_debug;
      if (D.29333 != 0) goto <D.29345>; else goto <D.29346>;
      <D.29345>:
      D.29347 = mono_debug_enabled ();
      if (D.29347 == 0) goto <D.29348>; else goto <D.29349>;
      <D.29348>:
      stderr.28 = stderr;
      fprintf (stderr.28, "The dwarf AOT option requires the --debug option.\n");
      D.29186 = 1;
      return D.29186;
      <D.29349>:
      <D.29346>:
      D.29350 = acfg->w;
      D.29351 = acfg->gas_line_numbers;
      D.29352 = D.29351 == 0;
      D.29353 = (int) D.29352;
      D.29354 = mono_dwarf_writer_create (D.29350, 0B, 0, 0, D.29353);
      acfg->dwarf = D.29354;
      <D.29342>:
      D.29350 = acfg->w;
      img_writer_emit_start (D.29350);
      D.29355 = acfg->dwarf;
      if (D.29355 != 0B) goto <D.29356>; else goto <D.29357>;
      <D.29356>:
      D.29355 = acfg->dwarf;
      D.29224 = acfg->image;
      D.29276 = D.29224->name;
      D.29358 = monoeg_g_path_get_basename (D.29276);
      D.29359 = mono_unwind_get_cie_program ();
      mono_dwarf_writer_emit_base_info (D.29355, D.29358, D.29359);
      <D.29357>:
      D.29360 = acfg->thumb_mixed;
      if (D.29360 != 0) goto <D.29361>; else goto <D.29362>;
      <D.29361>:
      {
        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.29278 = acfg->fp;
            fprintf (D.29278, ".arm\n");
          }
        finally
          {
            symbol = {CLOBBER};
          }
      }
      <D.29362>:
      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.29355 = acfg->dwarf;
      if (D.29355 != 0B) goto <D.29363>; else goto <D.29364>;
      <D.29363>:
      emit_dwarf_info (acfg);
      D.29355 = acfg->dwarf;
      mono_dwarf_writer_close (D.29355);
      <D.29364>:
      emit_mem_end (acfg);
      D.29365 = acfg->need_pt_gnu_stack;
      if (D.29365 != 0) goto <D.29366>; else goto <D.29367>;
      <D.29366>:
      D.29368 = acfg->use_bin_writer;
      if (D.29368 == 0) goto <D.29369>; else goto <D.29370>;
      <D.29369>:
      D.29278 = acfg->fp;
      fprintf (D.29278, "\n.section\t.note.GNU-stack,\"\",@progbits\n");
      <D.29370>:
      <D.29367>:
      btv = mono_100ns_ticks ();
      D.29261 = btv - atv;
      D.29262 = D.29261 / 10;
      D.29263 = (int) D.29262;
      acfg->stats.gen_time = D.29263;
      D.29285 = acfg->llvm;
      if (D.29285 != 0) goto <D.29371>; else goto <D.29372>;
      <D.29371>:
      D.29373 = acfg->got_offset;
      D.29374 = acfg->final_got_size;
      D.29375 = D.29373 > D.29374;
      D.29376 = (long int) D.29375;
      D.29377 = __builtin_expect (D.29376, 0);
      if (D.29377 != 0) goto <D.29378>; else goto <D.29379>;
      <D.29378>:
      monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "aot-compiler.c", 9004, "acfg->got_offset <= acfg->final_got_size");
      <D.29379>:
      <D.29372>:
      D.29285 = acfg->llvm;
      if (D.29285 != 0) goto <D.29380>; else goto <D.29381>;
      <D.29380>:
      D.29382 = acfg->stats.llvm_count;
      D.29384 = acfg->stats.mcount;
      if (D.29384 != 0) goto <D.29385>; else goto <D.29386>;
      <D.29385>:
      D.29382 = acfg->stats.llvm_count;
      D.29387 = D.29382 * 100;
      D.29384 = acfg->stats.mcount;
      iftmp.36 = D.29387 / D.29384;
      goto <D.29388>;
      <D.29386>:
      iftmp.36 = 100;
      <D.29388>:
      sprintf (&llvm_stats_msg, ", LLVM: %d (%d%%)", D.29382, iftmp.36);
      goto <D.29389>;
      <D.29381>:
      strcpy (&llvm_stats_msg, "");
      <D.29389>:
      D.29390 = acfg->stats.code_size;
      D.29391 = acfg->stats.info_size;
      D.29392 = acfg->stats.ex_info_size;
      D.29393 = acfg->stats.unwind_info_size;
      D.29394 = acfg->stats.class_info_size;
      D.29395 = acfg->plt_offset;
      D.29396 = acfg->stats.got_info_size;
      D.29373 = acfg->got_offset;
      D.29397 = D.29373 * 4;
      D.29398 = (int) D.29397;
      D.29399 = 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.29390, D.29391, D.29392, D.29393, D.29394, D.29395, D.29396, D.29398, D.29399);
      D.29400 = acfg->stats.ccount;
      D.29384 = acfg->stats.mcount;
      D.29384 = acfg->stats.mcount;
      if (D.29384 != 0) goto <D.29402>; else goto <D.29403>;
      <D.29402>:
      D.29400 = acfg->stats.ccount;
      D.29404 = D.29400 * 100;
      D.29384 = acfg->stats.mcount;
      iftmp.37 = D.29404 / D.29384;
      goto <D.29405>;
      <D.29403>:
      iftmp.37 = 100;
      <D.29405>:
      D.29406 = acfg->stats.methods_without_got_slots;
      D.29384 = acfg->stats.mcount;
      if (D.29384 != 0) goto <D.29408>; else goto <D.29409>;
      <D.29408>:
      D.29406 = acfg->stats.methods_without_got_slots;
      D.29410 = D.29406 * 100;
      D.29384 = acfg->stats.mcount;
      iftmp.38 = D.29410 / D.29384;
      goto <D.29411>;
      <D.29409>:
      iftmp.38 = 100;
      <D.29411>:
      D.29412 = acfg->stats.direct_calls;
      D.29414 = acfg->stats.all_calls;
      if (D.29414 != 0) goto <D.29415>; else goto <D.29416>;
      <D.29415>:
      D.29412 = acfg->stats.direct_calls;
      D.29417 = D.29412 * 100;
      D.29414 = acfg->stats.all_calls;
      iftmp.39 = D.29417 / D.29414;
      goto <D.29418>;
      <D.29416>:
      iftmp.39 = 100;
      <D.29418>:
      printf ("Compiled: %d/%d (%d%%)%s, No GOT slots: %d (%d%%), Direct calls: %d (%d%%)\n", D.29400, D.29384, iftmp.37, &llvm_stats_msg, D.29406, iftmp.38, D.29412, iftmp.39);
      D.29419 = acfg->stats.genericcount;
      if (D.29419 != 0) goto <D.29420>; else goto <D.29421>;
      <D.29420>:
      D.29419 = acfg->stats.genericcount;
      D.29384 = acfg->stats.mcount;
      if (D.29384 != 0) goto <D.29423>; else goto <D.29424>;
      <D.29423>:
      D.29419 = acfg->stats.genericcount;
      D.29425 = D.29419 * 100;
      D.29384 = acfg->stats.mcount;
      iftmp.40 = D.29425 / D.29384;
      goto <D.29426>;
      <D.29424>:
      iftmp.40 = 100;
      <D.29426>:
      printf ("%d methods are generic (%d%%)\n", D.29419, iftmp.40);
      <D.29421>:
      D.29427 = acfg->stats.abscount;
      if (D.29427 != 0) goto <D.29428>; else goto <D.29429>;
      <D.29428>:
      D.29427 = acfg->stats.abscount;
      D.29384 = acfg->stats.mcount;
      if (D.29384 != 0) goto <D.29431>; else goto <D.29432>;
      <D.29431>:
      D.29427 = acfg->stats.abscount;
      D.29433 = D.29427 * 100;
      D.29384 = acfg->stats.mcount;
      iftmp.41 = D.29433 / D.29384;
      goto <D.29434>;
      <D.29432>:
      iftmp.41 = 100;
      <D.29434>:
      printf ("%d methods contain absolute addresses (%d%%)\n", D.29427, iftmp.41);
      <D.29429>:
      D.29435 = acfg->stats.lmfcount;
      if (D.29435 != 0) goto <D.29436>; else goto <D.29437>;
      <D.29436>:
      D.29435 = acfg->stats.lmfcount;
      D.29384 = acfg->stats.mcount;
      if (D.29384 != 0) goto <D.29439>; else goto <D.29440>;
      <D.29439>:
      D.29435 = acfg->stats.lmfcount;
      D.29441 = D.29435 * 100;
      D.29384 = acfg->stats.mcount;
      iftmp.42 = D.29441 / D.29384;
      goto <D.29442>;
      <D.29440>:
      iftmp.42 = 100;
      <D.29442>:
      printf ("%d methods contain lmf pointers (%d%%)\n", D.29435, iftmp.42);
      <D.29437>:
      D.29443 = acfg->stats.ocount;
      if (D.29443 != 0) goto <D.29444>; else goto <D.29445>;
      <D.29444>:
      D.29443 = acfg->stats.ocount;
      D.29384 = acfg->stats.mcount;
      if (D.29384 != 0) goto <D.29447>; else goto <D.29448>;
      <D.29447>:
      D.29443 = acfg->stats.ocount;
      D.29449 = D.29443 * 100;
      D.29384 = acfg->stats.mcount;
      iftmp.43 = D.29449 / D.29384;
      goto <D.29450>;
      <D.29448>:
      iftmp.43 = 100;
      <D.29450>:
      printf ("%d methods have other problems (%d%%)\n", D.29443, iftmp.43);
      <D.29445>:
      atv = mono_100ns_ticks ();
      D.29350 = acfg->w;
      res = img_writer_emit_writeout (D.29350);
      if (res != 0) goto <D.29451>; else goto <D.29452>;
      <D.29451>:
      acfg_free (acfg);
      D.29186 = res;
      return D.29186;
      <D.29452>:
      D.29368 = acfg->use_bin_writer;
      if (D.29368 != 0) goto <D.29453>; else goto <D.29454>;
      <D.29453>:
      {
        int err;

        err = rename (tmp_outfile_name, outfile_name);
        if (err != 0) goto <D.29455>; else goto <D.29456>;
        <D.29455>:
        D.29281 = __errno_location ();
        D.29282 = *D.29281;
        D.29457 = strerror (D.29282);
        printf ("Unable to rename \'%s\' to \'%s\': %s\n", tmp_outfile_name, outfile_name, D.29457);
        D.29186 = 1;
        return D.29186;
        <D.29456>:
      }
      goto <D.29458>;
      <D.29454>:
      res = compile_asm (acfg);
      if (res != 0) goto <D.29459>; else goto <D.29460>;
      <D.29459>:
      acfg_free (acfg);
      D.29186 = res;
      return D.29186;
      <D.29460>:
      <D.29458>:
      btv = mono_100ns_ticks ();
      D.29261 = btv - atv;
      D.29262 = D.29261 / 10;
      D.29263 = (int) D.29262;
      acfg->stats.link_time = D.29263;
      D.29461 = acfg->aot_opts.stats;
      if (D.29461 != 0) goto <D.29462>; else goto <D.29463>;
      <D.29462>:
      {
        int i;

        printf ("GOT slot distribution:\n");
        i = 0;
        goto <D.28609>;
        <D.28608>:
        D.29464 = acfg->stats.got_slot_types[i];
        if (D.29464 != 0) goto <D.29465>; else goto <D.29466>;
        <D.29465>:
        D.29467 = get_patch_name (i);
        D.29464 = acfg->stats.got_slot_types[i];
        D.29468 = acfg->stats.got_slot_info_sizes[i];
        printf ("\t%s: %d (%d)\n", D.29467, D.29464, D.29468);
        <D.29466>:
        i = i + 1;
        <D.28609>:
        if (i <= 50) goto <D.28608>; else goto <D.28610>;
        <D.28610>:
      }
      <D.29463>:
      D.29469 = acfg->stats.jit_time;
      D.29470 = D.29469 / 1000;
      D.29471 = acfg->stats.gen_time;
      D.29472 = D.29471 / 1000;
      D.29473 = acfg->stats.link_time;
      D.29474 = D.29473 / 1000;
      printf ("JIT time: %d ms, Generation time: %d ms, Assembly+Link time: %d ms.\n", D.29470, D.29472, D.29474);
      acfg_free (acfg);
      D.29186 = 0;
      return D.29186;
    }
  finally
    {
      llvm_stats_msg = {CLOBBER};
    }
}


acfg_create (struct MonoAssembly * ass, guint32 opts)
{
  struct GPtrArray * D.29477;
  struct GHashTable * D.29478;
  struct GHashTable * D.29479;
  struct GHashTable * D.29480;
  void * D.29481;
  struct GHashTable * D.29482;
  void * D.29483;
  struct GHashTable * * D.29484;
  unsigned int i.44;
  unsigned int D.29486;
  struct GHashTable * * D.29487;
  struct GHashTable * D.29488;
  struct GPtrArray * D.29489;
  struct GHashTable * D.29490;
  struct GHashTable * D.29491;
  struct GHashTable * D.29492;
  struct GHashTable * D.29493;
  struct GPtrArray * D.29494;
  struct GPtrArray * D.29495;
  unsigned int D.29496;
  struct MonoMemPool * D.29497;
  struct GPtrArray * D.29498;
  struct GHashTable * D.29499;
  struct GPtrArray * D.29500;
  struct GHashTable * D.29501;
  struct GPtrArray * D.29502;
  struct GHashTable * D.29503;
  struct GHashTable * D.29504;
  struct GHashTable * D.29505;
  struct GHashTable * D.29506;
  struct CRITICAL_SECTION * D.29507;
  struct MonoAotCompile * D.29508;
  struct MonoImage * image;
  struct MonoAotCompile * acfg;
  int i;

  image = ass->image;
  acfg = monoeg_malloc0 (1032);
  D.29477 = monoeg_g_ptr_array_new ();
  acfg->methods = D.29477;
  D.29478 = monoeg_g_hash_table_new (0B, 0B);
  acfg->method_indexes = D.29478;
  D.29479 = monoeg_g_hash_table_new (0B, 0B);
  acfg->method_depth = D.29479;
  D.29480 = monoeg_g_hash_table_new (0B, 0B);
  acfg->plt_offset_to_entry = D.29480;
  D.29481 = monoeg_malloc0 (208);
  acfg->patch_to_plt_entry = D.29481;
  D.29482 = monoeg_g_hash_table_new (mono_patch_info_hash, mono_patch_info_equal);
  acfg->patch_to_got_offset = D.29482;
  D.29483 = monoeg_malloc0 (208);
  acfg->patch_to_got_offset_by_type = D.29483;
  i = 0;
  goto <D.28558>;
  <D.28557>:
  D.29484 = acfg->patch_to_got_offset_by_type;
  i.44 = (unsigned int) i;
  D.29486 = i.44 * 4;
  D.29487 = D.29484 + D.29486;
  D.29488 = monoeg_g_hash_table_new (mono_patch_info_hash, mono_patch_info_equal);
  *D.29487 = D.29488;
  i = i + 1;
  <D.28558>:
  if (i <= 51) goto <D.28557>; else goto <D.28559>;
  <D.28559>:
  D.29489 = monoeg_g_ptr_array_new ();
  acfg->got_patches = D.29489;
  D.29490 = monoeg_g_hash_table_new (0B, 0B);
  acfg->method_to_cfg = D.29490;
  D.29491 = monoeg_g_hash_table_new_full (0B, 0B, 0B, monoeg_g_free);
  acfg->token_info_hash = D.29491;
  D.29492 = monoeg_g_hash_table_new_full (0B, 0B, 0B, monoeg_g_free);
  acfg->method_to_pinvoke_import = D.29492;
  D.29493 = monoeg_g_hash_table_new (0B, 0B);
  acfg->image_hash = D.29493;
  D.29494 = monoeg_g_ptr_array_new ();
  acfg->image_table = D.29494;
  D.29495 = monoeg_g_ptr_array_new ();
  acfg->globals = D.29495;
  acfg->image = image;
  acfg->opts = opts;
  D.29496 = mono_arch_cpu_enumerate_simd_versions ();
  acfg->simd_opts = D.29496;
  D.29497 = mono_mempool_new ();
  acfg->mempool = D.29497;
  D.29498 = monoeg_g_ptr_array_new ();
  acfg->extra_methods = D.29498;
  D.29499 = monoeg_g_hash_table_new (0B, 0B);
  acfg->unwind_info_offsets = D.29499;
  D.29500 = monoeg_g_ptr_array_new ();
  acfg->unwind_ops = D.29500;
  D.29501 = monoeg_g_hash_table_new_full (monoeg_g_str_hash, monoeg_g_str_equal, monoeg_g_free, 0B);
  acfg->method_label_hash = D.29501;
  D.29502 = monoeg_g_ptr_array_new ();
  acfg->method_order = D.29502;
  D.29503 = monoeg_g_hash_table_new (0B, 0B);
  acfg->export_names = D.29503;
  D.29504 = monoeg_g_hash_table_new (0B, 0B);
  acfg->klass_blob_hash = D.29504;
  D.29505 = monoeg_g_hash_table_new (0B, 0B);
  acfg->method_blob_hash = D.29505;
  D.29506 = monoeg_g_hash_table_new (monoeg_g_str_hash, monoeg_g_str_equal);
  acfg->plt_entry_debug_sym_cache = D.29506;
  D.29507 = &acfg->mutex;
  InitializeCriticalSection (D.29507);
  D.29508 = acfg;
  return D.29508;
}


mono_aot_parse_options (const char * aot_options, struct MonoAotOptions * opts)
{
  const gchar * iftmp.45;
  int D.29514;
  const gchar * D.29517;
  gchar * D.29518;
  int D.29520;
  int D.29524;
  int D.29528;
  int D.29532;
  int D.29536;
  int D.29540;
  int D.29544;
  int D.29548;
  const char * D.29551;
  int D.29552;
  int D.29554;
  int D.29558;
  int D.29562;
  int D.29566;
  int D.29570;
  int D.29574;
  int D.29578;
  const char * D.29581;
  int D.29582;
  int D.29584;
  const char * D.29587;
  int D.29588;
  int D.29590;
  const char * D.29593;
  int D.29594;
  int D.29596;
  const char * D.29599;
  int D.29600;
  int D.29602;
  int D.29606;
  const gchar * D.29609;
  gchar * D.29610;
  int D.29612;
  int D.29616;
  int D.29620;
  int D.29624;
  int D.29628;
  int D.29632;
  int D.29636;
  int D.29640;
  int D.29644;
  int D.29648;
  gchar * D.29651;
  int D.29653;
  const gchar * D.29656;
  gchar * D.29657;
  int D.29659;
  const char * D.29662;
  int D.29664;
  int D.29667;
  int D.29673;
  int D.29675;
  struct _IO_FILE * stderr.46;
  gchar * D.29678;
  int D.29679;
  gchar * * args;
  gchar * * ptr;

  if (aot_options != 0B) goto <D.29511>; else goto <D.29512>;
  <D.29511>:
  iftmp.45 = aot_options;
  goto <D.29513>;
  <D.29512>:
  iftmp.45 = "";
  <D.29513>:
  args = monoeg_g_strsplit (iftmp.45, ",", -1);
  ptr = args;
  goto <D.27931>;
  <D.27930>:
  {
    const char * arg;

    arg = *ptr;
    D.29514 = str_begins_with (arg, "outfile=");
    if (D.29514 != 0) goto <D.29515>; else goto <D.29516>;
    <D.29515>:
    D.29517 = arg + 8;
    D.29518 = monoeg_strdup (D.29517);
    opts->outfile = D.29518;
    goto <D.29519>;
    <D.29516>:
    D.29520 = str_begins_with (arg, "save-temps");
    if (D.29520 != 0) goto <D.29521>; else goto <D.29522>;
    <D.29521>:
    opts->save_temps = 1;
    goto <D.29523>;
    <D.29522>:
    D.29524 = str_begins_with (arg, "keep-temps");
    if (D.29524 != 0) goto <D.29525>; else goto <D.29526>;
    <D.29525>:
    opts->save_temps = 1;
    goto <D.29527>;
    <D.29526>:
    D.29528 = str_begins_with (arg, "write-symbols");
    if (D.29528 != 0) goto <D.29529>; else goto <D.29530>;
    <D.29529>:
    opts->write_symbols = 1;
    goto <D.29531>;
    <D.29530>:
    D.29532 = str_begins_with (arg, "no-write-symbols");
    if (D.29532 != 0) goto <D.29533>; else goto <D.29534>;
    <D.29533>:
    opts->write_symbols = 0;
    goto <D.29535>;
    <D.29534>:
    D.29536 = str_begins_with (arg, "metadata-only");
    if (D.29536 != 0) goto <D.29537>; else goto <D.29538>;
    <D.29537>:
    opts->metadata_only = 1;
    goto <D.29539>;
    <D.29538>:
    D.29540 = str_begins_with (arg, "bind-to-runtime-version");
    if (D.29540 != 0) goto <D.29541>; else goto <D.29542>;
    <D.29541>:
    opts->bind_to_runtime_version = 1;
    goto <D.29543>;
    <D.29542>:
    D.29544 = str_begins_with (arg, "full");
    if (D.29544 != 0) goto <D.29545>; else goto <D.29546>;
    <D.29545>:
    opts->full_aot = 1;
    goto <D.29547>;
    <D.29546>:
    D.29548 = str_begins_with (arg, "threads=");
    if (D.29548 != 0) goto <D.29549>; else goto <D.29550>;
    <D.29549>:
    D.29551 = arg + 8;
    D.29552 = atoi (D.29551);
    opts->nthreads = D.29552;
    goto <D.29553>;
    <D.29550>:
    D.29554 = str_begins_with (arg, "static");
    if (D.29554 != 0) goto <D.29555>; else goto <D.29556>;
    <D.29555>:
    opts->static_link = 1;
    opts->no_dlsym = 1;
    goto <D.29557>;
    <D.29556>:
    D.29558 = str_begins_with (arg, "asmonly");
    if (D.29558 != 0) goto <D.29559>; else goto <D.29560>;
    <D.29559>:
    opts->asm_only = 1;
    goto <D.29561>;
    <D.29560>:
    D.29562 = str_begins_with (arg, "asmwriter");
    if (D.29562 != 0) goto <D.29563>; else goto <D.29564>;
    <D.29563>:
    opts->asm_writer = 1;
    goto <D.29565>;
    <D.29564>:
    D.29566 = str_begins_with (arg, "nodebug");
    if (D.29566 != 0) goto <D.29567>; else goto <D.29568>;
    <D.29567>:
    opts->nodebug = 1;
    goto <D.29569>;
    <D.29568>:
    D.29570 = str_begins_with (arg, "dwarfdebug");
    if (D.29570 != 0) goto <D.29571>; else goto <D.29572>;
    <D.29571>:
    opts->dwarf_debug = 1;
    goto <D.29573>;
    <D.29572>:
    D.29574 = str_begins_with (arg, "nopagetrampolines");
    if (D.29574 != 0) goto <D.29575>; else goto <D.29576>;
    <D.29575>:
    opts->use_trampolines_page = 0;
    goto <D.29577>;
    <D.29576>:
    D.29578 = str_begins_with (arg, "ntrampolines=");
    if (D.29578 != 0) goto <D.29579>; else goto <D.29580>;
    <D.29579>:
    D.29581 = arg + 13;
    D.29582 = atoi (D.29581);
    opts->ntrampolines = D.29582;
    goto <D.29583>;
    <D.29580>:
    D.29584 = str_begins_with (arg, "nrgctx-trampolines=");
    if (D.29584 != 0) goto <D.29585>; else goto <D.29586>;
    <D.29585>:
    D.29587 = arg + 19;
    D.29588 = atoi (D.29587);
    opts->nrgctx_trampolines = D.29588;
    goto <D.29589>;
    <D.29586>:
    D.29590 = str_begins_with (arg, "nimt-trampolines=");
    if (D.29590 != 0) goto <D.29591>; else goto <D.29592>;
    <D.29591>:
    D.29593 = arg + 17;
    D.29594 = atoi (D.29593);
    opts->nimt_trampolines = D.29594;
    goto <D.29595>;
    <D.29592>:
    D.29596 = str_begins_with (arg, "ngsharedvt-trampolines=");
    if (D.29596 != 0) goto <D.29597>; else goto <D.29598>;
    <D.29597>:
    D.29599 = arg + 23;
    D.29600 = atoi (D.29599);
    opts->ngsharedvt_arg_trampolines = D.29600;
    goto <D.29601>;
    <D.29598>:
    D.29602 = str_begins_with (arg, "autoreg");
    if (D.29602 != 0) goto <D.29603>; else goto <D.29604>;
    <D.29603>:
    opts->autoreg = 1;
    goto <D.29605>;
    <D.29604>:
    D.29606 = str_begins_with (arg, "tool-prefix=");
    if (D.29606 != 0) goto <D.29607>; else goto <D.29608>;
    <D.29607>:
    D.29609 = arg + 12;
    D.29610 = monoeg_strdup (D.29609);
    opts->tool_prefix = D.29610;
    goto <D.29611>;
    <D.29608>:
    D.29612 = str_begins_with (arg, "soft-debug");
    if (D.29612 != 0) goto <D.29613>; else goto <D.29614>;
    <D.29613>:
    opts->soft_debug = 1;
    goto <D.29615>;
    <D.29614>:
    D.29616 = str_begins_with (arg, "direct-pinvoke");
    if (D.29616 != 0) goto <D.29617>; else goto <D.29618>;
    <D.29617>:
    opts->direct_pinvoke = 1;
    goto <D.29619>;
    <D.29618>:
    D.29620 = str_begins_with (arg, "direct-icalls");
    if (D.29620 != 0) goto <D.29621>; else goto <D.29622>;
    <D.29621>:
    opts->direct_icalls = 1;
    goto <D.29623>;
    <D.29622>:
    D.29624 = str_begins_with (arg, "iphone-abi");
    if (D.29624 != 0) goto <D.29625>; else goto <D.29626>;
    <D.29625>:
    goto <D.29627>;
    <D.29626>:
    D.29628 = str_begins_with (arg, "no-direct-calls");
    if (D.29628 != 0) goto <D.29629>; else goto <D.29630>;
    <D.29629>:
    opts->no_direct_calls = 1;
    goto <D.29631>;
    <D.29630>:
    D.29632 = str_begins_with (arg, "print-skipped");
    if (D.29632 != 0) goto <D.29633>; else goto <D.29634>;
    <D.29633>:
    opts->print_skipped_methods = 1;
    goto <D.29635>;
    <D.29634>:
    D.29636 = str_begins_with (arg, "stats");
    if (D.29636 != 0) goto <D.29637>; else goto <D.29638>;
    <D.29637>:
    opts->stats = 1;
    goto <D.29639>;
    <D.29638>:
    D.29640 = str_begins_with (arg, "no-instances");
    if (D.29640 != 0) goto <D.29641>; else goto <D.29642>;
    <D.29641>:
    opts->no_instances = 1;
    goto <D.29643>;
    <D.29642>:
    D.29644 = str_begins_with (arg, "log-generics");
    if (D.29644 != 0) goto <D.29645>; else goto <D.29646>;
    <D.29645>:
    opts->log_generics = 1;
    goto <D.29647>;
    <D.29646>:
    D.29648 = str_begins_with (arg, "mtriple=");
    if (D.29648 != 0) goto <D.29649>; else goto <D.29650>;
    <D.29649>:
    D.29517 = arg + 8;
    D.29651 = monoeg_strdup (D.29517);
    opts->mtriple = D.29651;
    goto <D.29652>;
    <D.29650>:
    D.29653 = str_begins_with (arg, "llvm-path=");
    if (D.29653 != 0) goto <D.29654>; else goto <D.29655>;
    <D.29654>:
    D.29656 = arg + 10;
    D.29657 = monoeg_strdup (D.29656);
    opts->llvm_path = D.29657;
    goto <D.29658>;
    <D.29655>:
    D.29659 = str_begins_with (arg, "readonly-value=");
    if (D.29659 != 0) goto <D.29660>; else goto <D.29661>;
    <D.29660>:
    D.29662 = arg + 15;
    add_readonly_value (opts, D.29662);
    goto <D.29663>;
    <D.29661>:
    D.29664 = str_begins_with (arg, "info");
    if (D.29664 != 0) goto <D.29665>; else goto <D.29666>;
    <D.29665>:
    printf ("AOT target setup: %s.\n", "ARM (!MACH)");
    exit (0);
    <D.29666>:
    D.29667 = str_begins_with (arg, "gc-maps");
    if (D.29667 != 0) goto <D.29668>; else goto <D.29669>;
    <D.29668>:
    mini_gc_enable_gc_maps_for_aot ();
    goto <D.29670>;
    <D.29669>:
    D.29673 = str_begins_with (arg, "help");
    if (D.29673 != 0) goto <D.29671>; else goto <D.29674>;
    <D.29674>:
    D.29675 = str_begins_with (arg, "?");
    if (D.29675 != 0) goto <D.29671>; else goto <D.29672>;
    <D.29671>:
    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.29672>:
    stderr.46 = stderr;
    fprintf (stderr.46, "AOT : Unknown argument \'%s\'.\n", arg);
    exit (1);
    <D.29670>:
    <D.29663>:
    <D.29658>:
    <D.29652>:
    <D.29647>:
    <D.29643>:
    <D.29639>:
    <D.29635>:
    <D.29631>:
    <D.29627>:
    <D.29623>:
    <D.29619>:
    <D.29615>:
    <D.29611>:
    <D.29605>:
    <D.29601>:
    <D.29595>:
    <D.29589>:
    <D.29583>:
    <D.29577>:
    <D.29573>:
    <D.29569>:
    <D.29565>:
    <D.29561>:
    <D.29557>:
    <D.29553>:
    <D.29547>:
    <D.29543>:
    <D.29539>:
    <D.29535>:
    <D.29531>:
    <D.29527>:
    <D.29523>:
    <D.29519>:
  }
  ptr = ptr + 4;
  <D.27931>:
  if (ptr != 0B) goto <D.29677>; else goto <D.27932>;
  <D.29677>:
  D.29678 = *ptr;
  if (D.29678 != 0B) goto <D.27930>; else goto <D.27932>;
  <D.27932>:
  D.29679 = opts->use_trampolines_page;
  if (D.29679 != 0) goto <D.29680>; else goto <D.29681>;
  <D.29680>:
  opts->ntrampolines = 0;
  opts->nrgctx_trampolines = 0;
  opts->nimt_trampolines = 0;
  opts->ngsharedvt_arg_trampolines = 0;
  <D.29681>:
  monoeg_g_strfreev (args);
}


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

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


add_readonly_value (struct MonoAotOptions * opts, const char * val)
{
  struct _IO_FILE * stderr.47;
  int tval.48;
  int val.49;
  int D.29691;
  int D.29692;
  unsigned int D.29693;
  void * D.29694;
  char * D.29695;
  unsigned int D.29696;
  int D.29697;
  int D.29700;
  unsigned char D.29701;
  int D.29703;
  int D.29706;
  short unsigned int D.29707;
  int D.29709;
  int D.29712;
  unsigned int D.29713;
  struct ReadOnlyValue * readonly_values.50;
  struct ReadOnlyValue * rdv;
  const char * fval;
  const char * tval;

  fval = strrchr (val, 47);
  if (fval == 0B) goto <D.29684>; else goto <D.29685>;
  <D.29684>:
  stderr.47 = stderr;
  fprintf (stderr.47, "AOT : invalid format for readonly field \'%s\', missing /.\n", val);
  exit (1);
  <D.29685>:
  tval = strrchr (val, 61);
  if (tval == 0B) goto <D.29687>; else goto <D.29688>;
  <D.29687>:
  stderr.47 = stderr;
  fprintf (stderr.47, "AOT : invalid format for readonly field \'%s\', missing =.\n", val);
  exit (1);
  <D.29688>:
  rdv = monoeg_malloc0 (24);
  tval.48 = (int) tval;
  val.49 = (int) val;
  D.29691 = tval.48 - val.49;
  D.29692 = D.29691 + 1;
  D.29693 = (unsigned int) D.29692;
  D.29694 = monoeg_malloc0 (D.29693);
  rdv->name = D.29694;
  D.29695 = rdv->name;
  tval.48 = (int) tval;
  val.49 = (int) val;
  D.29691 = tval.48 - val.49;
  D.29696 = (unsigned int) D.29691;
  memcpy (D.29695, val, D.29696);
  tval = tval + 1;
  fval = fval + 1;
  D.29697 = strncmp (tval, "i1", 2);
  if (D.29697 == 0) goto <D.29698>; else goto <D.29699>;
  <D.29698>:
  D.29700 = atoi (fval);
  D.29701 = (unsigned char) D.29700;
  rdv->value.i1 = D.29701;
  rdv->type = 4;
  goto <D.29702>;
  <D.29699>:
  D.29703 = strncmp (tval, "i2", 2);
  if (D.29703 == 0) goto <D.29704>; else goto <D.29705>;
  <D.29704>:
  D.29706 = atoi (fval);
  D.29707 = (short unsigned int) D.29706;
  rdv->value.i2 = D.29707;
  rdv->type = 6;
  goto <D.29708>;
  <D.29705>:
  D.29709 = strncmp (tval, "i4", 2);
  if (D.29709 == 0) goto <D.29710>; else goto <D.29711>;
  <D.29710>:
  D.29712 = atoi (fval);
  D.29713 = (unsigned int) D.29712;
  rdv->value.i4 = D.29713;
  rdv->type = 8;
  goto <D.29714>;
  <D.29711>:
  stderr.47 = stderr;
  fprintf (stderr.47, "AOT : unsupported type for readonly field \'%s\'.\n", tval);
  exit (1);
  <D.29714>:
  <D.29708>:
  <D.29702>:
  readonly_values.50 = readonly_values;
  rdv->next = readonly_values.50;
  readonly_values = rdv;
}


str_begins_with (const char * str1, const char * str2)
{
  unsigned int D.29716;
  gboolean D.29717;
  unsigned int len.51;
  int D.29719;
  _Bool D.29720;
  int len;

  D.29716 = strlen (str2);
  len = (int) D.29716;
  len.51 = (unsigned int) len;
  D.29719 = strncmp (str1, str2, len.51);
  D.29720 = D.29719 == 0;
  D.29717 = (gboolean) D.29720;
  return D.29717;
}


load_profile_files (struct MonoAotCompile * acfg)
{
  const gchar * D.29722;
  struct MonoImage * D.29723;
  const char * D.29724;
  int D.29725;
  _Bool D.29728;
  long int D.29729;
  long int D.29730;
  int D.28115;
  int iftmp.52;
  int D.28114;
  const char[7] * D.29739;
  unsigned char D.29740;
  int D.29741;
  unsigned char D.29742;
  int D.29743;
  _Bool D.29744;
  _Bool D.29745;
  _Bool D.29746;
  const unsigned char * D.29749;
  unsigned char D.29750;
  int D.29751;
  const unsigned char * D.29752;
  unsigned char D.29753;
  int D.29754;
  _Bool D.29755;
  _Bool D.29756;
  const unsigned char * D.29759;
  unsigned char D.29760;
  int D.29761;
  const unsigned char * D.29762;
  unsigned char D.29763;
  int D.29764;
  _Bool D.29765;
  _Bool D.29766;
  const unsigned char * D.29769;
  unsigned char D.29770;
  int D.29771;
  const unsigned char * D.29772;
  unsigned char D.29773;
  int D.29774;
  char * D.29776;
  char[1024] * name.53;
  char D.29779;
  unsigned int D.29782;
  unsigned int D.29783;
  unsigned int D.29786;
  unsigned int D.29789;
  unsigned int D.29790;
  struct GPtrArray * D.29791;
  void * * D.29792;
  unsigned int i.54;
  unsigned int D.29794;
  void * * D.29795;
  void * D.29796;
  void * method_index.55;
  unsigned int i.56;
  unsigned int D.29801;
  <unnamed-unsigned:24> D.29809;
  int D.29810;
  void * D.29811;
  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.28125>:
      D.29722 = monoeg_g_get_home_dir ();
      D.29723 = acfg->image;
      D.29724 = D.29723->assembly_name;
      tmp = monoeg_g_strdup_printf ("%s/.mono/aot-profile-data/%s-%d", D.29722, D.29724, file_index);
      D.29725 = monoeg_g_file_test (tmp, 1);
      if (D.29725 == 0) goto <D.29726>; else goto <D.29727>;
      <D.29726>:
      monoeg_g_free (tmp);
      goto <D.28106>;
      <D.29727>:
      infile = fopen (tmp, "r");
      D.29728 = infile == 0B;
      D.29729 = (long int) D.29728;
      D.29730 = __builtin_expect (D.29729, 0);
      if (D.29730 != 0) goto <D.29731>; else goto <D.29732>;
      <D.29731>:
      monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "aot-compiler.c", 6785, "infile");
      <D.29732>:
      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.29733>; else goto <D.29735>;
      <D.29735>:
      {
        size_t __s1_len;
        size_t __s2_len;

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

          __s2 = &ver;
          D.29739 = "#VER:2";
          D.29740 = MEM[(const unsigned char *)D.29739];
          D.29741 = (int) D.29740;
          D.29742 = *__s2;
          D.29743 = (int) D.29742;
          __result = D.29741 - D.29743;
          {
            D.29744 = __s2_len != 0;
            D.29745 = __result == 0;
            D.29746 = D.29744 & D.29745;
            if (D.29746 != 0) goto <D.29747>; else goto <D.29748>;
            <D.29747>:
            D.29749 = &MEM[(void *)"#VER:2" + 1B];
            D.29750 = *D.29749;
            D.29751 = (int) D.29750;
            D.29752 = __s2 + 1;
            D.29753 = *D.29752;
            D.29754 = (int) D.29753;
            __result = D.29751 - D.29754;
            D.29755 = __s2_len > 1;
            D.29745 = __result == 0;
            D.29756 = D.29755 & D.29745;
            if (D.29756 != 0) goto <D.29757>; else goto <D.29758>;
            <D.29757>:
            D.29759 = &MEM[(void *)"#VER:2" + 2B];
            D.29760 = *D.29759;
            D.29761 = (int) D.29760;
            D.29762 = __s2 + 2;
            D.29763 = *D.29762;
            D.29764 = (int) D.29763;
            __result = D.29761 - D.29764;
            D.29765 = __s2_len > 2;
            D.29745 = __result == 0;
            D.29766 = D.29765 & D.29745;
            if (D.29766 != 0) goto <D.29767>; else goto <D.29768>;
            <D.29767>:
            D.29769 = &MEM[(void *)"#VER:2" + 3B];
            D.29770 = *D.29769;
            D.29771 = (int) D.29770;
            D.29772 = __s2 + 3;
            D.29773 = *D.29772;
            D.29774 = (int) D.29773;
            __result = D.29771 - D.29774;
            <D.29768>:
            <D.29758>:
            <D.29748>:
          }
          D.28114 = __result;
        }
        iftmp.52 = -D.28114;
        goto <D.29775>;
        <D.29738>:
        iftmp.52 = __builtin_strcmp (&ver, "#VER:2");
        <D.29775>:
        D.28115 = iftmp.52;
      }
      if (D.28115 != 0) goto <D.29733>; else goto <D.29734>;
      <D.29733>:
      printf ("Profile file has wrong version or invalid.\n");
      fclose (infile);
      // predicted unlikely by continue predictor.
      goto <D.28116>;
      <D.29734>:
      <D.28124>:
      {
        char name[1024];
        struct MonoMethodDesc * desc;
        struct MonoMethod * method;

        try
          {
            D.29776 = fgets (&name, 1023, infile);
            if (D.29776 == 0B) goto <D.28120>; else goto <D.29777>;
            <D.29777>:
            name.53 = &name;
            D.29779 = MEM[(const char *)name.53];
            if (D.29779 != 0) goto <D.29780>; else goto <D.29781>;
            <D.29780>:
            D.29782 = strlen (&name);
            D.29783 = D.29782 + 4294967295;
            name[D.29783] = 0;
            <D.29781>:
            desc = mono_method_desc_new (&name, 1);
            D.29723 = acfg->image;
            method = mono_method_desc_search_in_image (desc, D.29723);
            if (method != 0B) goto <D.29784>; else goto <D.29785>;
            <D.29784>:
            D.29786 = mono_method_get_token (method);
            if (D.29786 != 0) goto <D.29787>; else goto <D.29788>;
            <D.29787>:
            token = mono_method_get_token (method);
            D.29789 = token & 16777215;
            D.29790 = D.29789 + 4294967295;
            method_index = (int) D.29790;
            found = 0;
            i = 0;
            goto <D.28123>;
            <D.28122>:
            D.29791 = acfg->method_order;
            D.29792 = D.29791->pdata;
            i.54 = (unsigned int) i;
            D.29794 = i.54 * 4;
            D.29795 = D.29792 + D.29794;
            D.29796 = *D.29795;
            method_index.55 = (void *) method_index;
            if (D.29796 == method_index.55) goto <D.29798>; else goto <D.29799>;
            <D.29798>:
            found = 1;
            goto <D.28121>;
            <D.29799>:
            i = i + 1;
            <D.28123>:
            i.56 = (unsigned int) i;
            D.29791 = acfg->method_order;
            D.29801 = D.29791->len;
            if (i.56 < D.29801) goto <D.28122>; else goto <D.28121>;
            <D.28121>:
            if (found == 0) goto <D.29802>; else goto <D.29803>;
            <D.29802>:
            D.29791 = acfg->method_order;
            method_index.55 = (void *) method_index;
            monoeg_g_ptr_array_add (D.29791, method_index.55);
            <D.29803>:
            goto <D.29804>;
            <D.29788>:
            <D.29804>:
            <D.29785>:
          }
        finally
          {
            name = {CLOBBER};
          }
      }
      goto <D.28124>;
      <D.28120>:
      fclose (infile);
      <D.28116>:
      goto <D.28125>;
      <D.28106>:
      unordered = 0B;
      method_index = 0;
      goto <D.28130>;
      <D.28129>:
      found = 0;
      i = 0;
      goto <D.28128>;
      <D.28127>:
      D.29791 = acfg->method_order;
      D.29792 = D.29791->pdata;
      i.54 = (unsigned int) i;
      D.29794 = i.54 * 4;
      D.29795 = D.29792 + D.29794;
      D.29796 = *D.29795;
      method_index.55 = (void *) method_index;
      if (D.29796 == method_index.55) goto <D.29805>; else goto <D.29806>;
      <D.29805>:
      found = 1;
      goto <D.28126>;
      <D.29806>:
      i = i + 1;
      <D.28128>:
      i.56 = (unsigned int) i;
      D.29791 = acfg->method_order;
      D.29801 = D.29791->len;
      if (i.56 < D.29801) goto <D.28127>; else goto <D.28126>;
      <D.28126>:
      if (found == 0) goto <D.29807>; else goto <D.29808>;
      <D.29807>:
      method_index.55 = (void *) method_index;
      unordered = monoeg_g_list_prepend (unordered, method_index.55);
      <D.29808>:
      method_index = method_index + 1;
      <D.28130>:
      D.29723 = acfg->image;
      D.29809 = D.29723->tables[6].rows;
      D.29810 = (int) D.29809;
      if (D.29810 > method_index) goto <D.28129>; else goto <D.28131>;
      <D.28131>:
      unordered = monoeg_g_list_reverse (unordered);
      l = unordered;
      goto <D.28133>;
      <D.28132>:
      D.29791 = acfg->method_order;
      D.29811 = l->data;
      monoeg_g_ptr_array_add (D.29791, D.29811);
      l = l->next;
      <D.28133>:
      if (l != 0B) goto <D.28132>; else goto <D.28134>;
      <D.28134>:
    }
  finally
    {
      ver = {CLOBBER};
    }
}


fgets (char * restrict __s, int __n, struct FILE * restrict __stream)
{
  unsigned int D.29814;
  int D.29819;
  char * D.29821;
  unsigned int D.29822;
  unsigned int __n.57;
  unsigned int D.29824;
  unsigned int D.29827;

  D.29814 = __builtin_object_size (__s, 1);
  if (D.29814 != 4294967295) goto <D.29815>; else goto <D.29816>;
  <D.29815>:
  D.29819 = __builtin_constant_p (__n);
  if (D.29819 == 0) goto <D.29817>; else goto <D.29820>;
  <D.29820>:
  if (__n <= 0) goto <D.29817>; else goto <D.29818>;
  <D.29817>:
  D.29822 = __builtin_object_size (__s, 1);
  D.29821 = __fgets_chk (__s, D.29822, __n, __stream);
  return D.29821;
  <D.29818>:
  __n.57 = (unsigned int) __n;
  D.29824 = __builtin_object_size (__s, 1);
  if (__n.57 > D.29824) goto <D.29825>; else goto <D.29826>;
  <D.29825>:
  D.29827 = __builtin_object_size (__s, 1);
  D.29821 = __fgets_chk_warn (__s, D.29827, __n, __stream);
  return D.29821;
  <D.29826>:
  <D.29816>:
  D.29821 = __fgets_alias (__s, __n, __stream);
  return D.29821;
}


arch_init (struct MonoAotCompile * acfg)
{
  struct GString * D.29829;
  struct GString * D.29830;
  char * D.29833;
  char * D.29835;
  struct GString * D.29837;
  char * D.29840;

  D.29829 = monoeg_g_string_new ("");
  acfg->llc_args = D.29829;
  D.29830 = monoeg_g_string_new ("");
  acfg->as_args = D.29830;
  acfg->llvm_label_prefix = "";
  acfg->user_symbol_prefix = "";
  D.29833 = acfg->aot_opts.mtriple;
  if (D.29833 != 0B) goto <D.29834>; else goto <D.29831>;
  <D.29834>:
  D.29833 = acfg->aot_opts.mtriple;
  D.29835 = strstr (D.29833, "darwin");
  if (D.29835 != 0B) goto <D.29836>; else goto <D.29831>;
  <D.29836>:
  D.29837 = acfg->llc_args;
  monoeg_g_string_append (D.29837, "-mattr=+v6");
  goto <D.29832>;
  <D.29831>:
  D.29837 = acfg->llc_args;
  monoeg_g_string_append (D.29837, " -soft-float");
  <D.29832>:
  D.29833 = acfg->aot_opts.mtriple;
  if (D.29833 != 0B) goto <D.29838>; else goto <D.29839>;
  <D.29838>:
  D.29833 = acfg->aot_opts.mtriple;
  D.29840 = strstr (D.29833, "thumb");
  if (D.29840 != 0B) goto <D.29841>; else goto <D.29842>;
  <D.29841>:
  acfg->thumb_mixed = 1;
  <D.29842>:
  <D.29839>:
  D.29833 = acfg->aot_opts.mtriple;
  if (D.29833 != 0B) goto <D.29843>; else goto <D.29844>;
  <D.29843>:
  D.29833 = acfg->aot_opts.mtriple;
  mono_arch_set_target (D.29833);
  <D.29844>:
}


collect_methods (struct MonoAotCompile * acfg)
{
  int D.29845;
  int D.29846;
  struct MonoImage * D.29847;
  char * D.29850;
  struct MonoClass * D.29851;
  int D.29852;
  short unsigned int D.29855;
  int D.29856;
  int D.29857;
  int check_for_pending_exc.58;
  int D.29861;
  int D.29862;
  <unnamed-unsigned:24> D.29863;
  int D.29864;
  int D.29865;
  int D.29866;
  unsigned int D.29867;
  unsigned int D.29868;
  unsigned char D.29875;
  unsigned char D.29876;
  struct MonoClass * D.29878;
  struct MonoGenericContainer * D.29879;
  int mindex;
  int i;
  struct MonoImage * image;

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

    D.29845 = i + 1;
    D.29846 = D.29845 | 100663296;
    token = (guint32) D.29846;
    D.29847 = acfg->image;
    method = mono_get_method (D.29847, token, 0B);
    if (method == 0B) goto <D.29848>; else goto <D.29849>;
    <D.29848>:
    D.29850 = image->name;
    printf ("Failed to load method 0x%x from \'%s\'.\n", token, D.29850);
    exit (1);
    <D.29849>:
    D.29851 = method->klass;
    mono_class_setup_methods (D.29851);
    D.29852 = acfg->aot_opts.full_aot;
    if (D.29852 != 0) goto <D.29853>; else goto <D.29854>;
    <D.29853>:
    D.29855 = method->iflags;
    D.29856 = (int) D.29855;
    D.29857 = D.29856 & 4096;
    if (D.29857 != 0) goto <D.29858>; else goto <D.29859>;
    <D.29858>:
    {
      struct MonoMethod * wrapper;

      check_for_pending_exc.58 = check_for_pending_exc;
      wrapper = mono_marshal_get_native_wrapper (method, check_for_pending_exc.58, 1);
      method = wrapper;
    }
    <D.29859>:
    <D.29854>:
    add_method_with_index (acfg, method, i, 0);
    D.29861 = acfg->method_index;
    D.29862 = D.29861 + 1;
    acfg->method_index = D.29862;
  }
  i = i + 1;
  <D.28506>:
  D.29863 = image->tables[6].rows;
  D.29864 = (int) D.29863;
  if (D.29864 > i) goto <D.28505>; else goto <D.28507>;
  <D.28507>:
  mindex = 0;
  goto <D.28513>;
  <D.28512>:
  {
    struct MonoMethod * method;
    guint32 token;

    D.29865 = mindex + 1;
    D.29866 = D.29865 | 100663296;
    token = (guint32) D.29866;
    D.29867 = acfg->opts;
    D.29868 = D.29867 & 16777216;
    if (D.29868 == 0) goto <D.29869>; else goto <D.29870>;
    <D.29869>:
    // predicted unlikely by continue predictor.
    goto <D.28510>;
    <D.29870>:
    D.29847 = acfg->image;
    method = mono_get_method (D.29847, token, 0B);
    if (method == 0B) goto <D.29871>; else goto <D.29872>;
    <D.29871>:
    // predicted unlikely by continue predictor.
    goto <D.28510>;
    <D.29872>:
    D.29875 = BIT_FIELD_REF <*method, 8, 168>;
    D.29876 = D.29875 & 8;
    if (D.29876 != 0) goto <D.29873>; else goto <D.29877>;
    <D.29877>:
    D.29878 = method->klass;
    D.29879 = D.29878->generic_container;
    if (D.29879 != 0B) goto <D.29873>; else goto <D.29874>;
    <D.29873>:
    {
      struct MonoMethod * gshared;

      gshared = mini_get_shared_method_full (method, 1, 1);
      add_extra_method (acfg, gshared);
    }
    <D.29874>:
  }
  <D.28510>:
  mindex = mindex + 1;
  <D.28513>:
  D.29863 = image->tables[6].rows;
  D.29864 = (int) D.29863;
  if (D.29864 > mindex) goto <D.28512>; else goto <D.28514>;
  <D.28514>:
  add_generic_instances (acfg);
  D.29852 = acfg->aot_opts.full_aot;
  if (D.29852 != 0) goto <D.29880>; else goto <D.29881>;
  <D.29880>:
  add_wrappers (acfg);
  <D.29881>:
}


add_method_with_index (struct MonoAotCompile * acfg, struct MonoMethod * method, int index, gboolean extra)
{
  _Bool D.29882;
  long int D.29883;
  long int D.29884;
  struct GHashTable * D.29887;
  void * D.29888;
  struct GPtrArray * D.29891;
  int D.29892;
  void * D.29893;
  unsigned int D.29894;
  unsigned int D.29895;
  unsigned char D.29898;
  unsigned char D.29899;
  struct GPtrArray * D.29901;

  D.29882 = method == 0B;
  D.29883 = (long int) D.29882;
  D.29884 = __builtin_expect (D.29883, 0);
  if (D.29884 != 0) goto <D.29885>; else goto <D.29886>;
  <D.29885>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "aot-compiler.c", 2994, "method");
  <D.29886>:
  D.29887 = acfg->method_indexes;
  D.29888 = monoeg_g_hash_table_lookup (D.29887, method);
  if (D.29888 == 0B) goto <D.29889>; else goto <D.29890>;
  <D.29889>:
  D.29891 = acfg->methods;
  monoeg_g_ptr_array_add (D.29891, method);
  D.29887 = acfg->method_indexes;
  D.29892 = index + 1;
  D.29893 = (void *) D.29892;
  monoeg_g_hash_table_insert_replace (D.29887, method, D.29893, 0);
  D.29891 = acfg->methods;
  D.29894 = D.29891->len;
  D.29895 = D.29894 + 1;
  acfg->nmethods = D.29895;
  <D.29890>:
  D.29898 = BIT_FIELD_REF <*method, 8, 160>;
  D.29899 = D.29898 & 124;
  if (D.29899 != 0) goto <D.29896>; else goto <D.29900>;
  <D.29900>:
  if (extra != 0) goto <D.29896>; else goto <D.29897>;
  <D.29896>:
  D.29901 = acfg->extra_methods;
  monoeg_g_ptr_array_add (D.29901, method);
  <D.29897>:
}


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.29902;
  int D.29905;
  char * D.29908;

  D.29902 = mono_method_is_generic_sharable_full (method, 0, 1, 0);
  if (D.29902 != 0) goto <D.29903>; else goto <D.29904>;
  <D.29903>:
  method = mini_get_shared_method (method);
  <D.29904>:
  D.29905 = acfg->aot_opts.log_generics;
  if (D.29905 != 0) goto <D.29906>; else goto <D.29907>;
  <D.29906>:
  D.29908 = mono_method_full_name (method, 1);
  printf ("%*sAdding method %s.\n", depth, "", D.29908);
  <D.29907>:
  add_method_full (acfg, method, 1, depth);
}


add_method_full (struct MonoAotCompile * acfg, struct MonoMethod * method, gboolean extra, int depth)
{
  struct GHashTable * D.29909;
  void * D.29910;
  int D.29913;
  struct GPtrArray * D.29914;
  void * index.59;
  struct GHashTable * D.29916;
  void * depth.60;
  int D.29918;
  int D.29919;
  int index;

  D.29909 = acfg->method_indexes;
  D.29910 = monoeg_g_hash_table_lookup (D.29909, method);
  index = (int) D.29910;
  if (index != 0) goto <D.29911>; else goto <D.29912>;
  <D.29911>:
  D.29913 = index + -1;
  return D.29913;
  <D.29912>:
  index = acfg->method_index;
  add_method_with_index (acfg, method, index, extra);
  D.29914 = acfg->method_order;
  index.59 = (void *) index;
  monoeg_g_ptr_array_add (D.29914, index.59);
  D.29916 = acfg->method_depth;
  depth.60 = (void *) depth;
  monoeg_g_hash_table_insert_replace (D.29916, method, depth.60, 0);
  D.29918 = acfg->method_index;
  D.29919 = D.29918 + 1;
  acfg->method_index = D.29919;
  D.29913 = index;
  return D.29913;
}


add_generic_instances (struct MonoAotCompile * acfg)
{
  int D.29921;
  int D.29924;
  int D.29925;
  struct MonoImage * D.29926;
  struct MonoClass * D.29929;
  struct MonoImage * D.29930;
  struct MonoGenericInst * D.29935;
  unsigned char D.29938;
  unsigned char D.29939;
  struct MonoGenericInst * D.29944;
  unsigned char D.29947;
  unsigned char D.29948;
  struct MonoType * D.29955;
  int D.29956;
  unsigned char D.29958;
  int D.29960;
  <unnamed-unsigned:22> D.29963;
  int D.29964;
  int D.29969;
  int D.29972;
  unsigned int D.29979;
  unsigned int D.29980;
  int D.29984;
  unsigned int i.61;
  unsigned int D.29988;
  struct MonoType * * D.29989;
  struct MonoClass * D.29990;
  struct MonoType * D.29991;
  struct MonoGenericInst * D.29992;
  int D.29998;
  struct MonoGenericInst * D.30001;
  unsigned char D.30005;
  unsigned char D.30006;
  struct MonoGenericContainer * D.30008;
  int D.30009;
  <unnamed-unsigned:24> D.30012;
  int D.30013;
  int D.30014;
  unsigned char D.30018;
  <unnamed-unsigned:24> D.30019;
  int D.30020;
  struct GPtrArray * D.30021;
  void * * D.30022;
  unsigned int i.62;
  unsigned int D.30024;
  void * * D.30025;
  unsigned int i.63;
  unsigned int D.30027;
  struct MonoImage * D.30028;
  int ninsts.64;
  struct MonoClass * D.30032;
  struct MonoType * D.30033;
  int ninsts.65;
  struct MonoClass * D.30035;
  struct MonoType * D.30036;
  int ninsts.66;
  struct MonoClass * D.30038;
  struct MonoType * D.30039;
  int ninsts.67;
  struct MonoClass * D.30041;
  struct MonoType * D.30042;
  int ninsts.68;
  struct MonoClass * D.30044;
  struct MonoType * D.30045;
  int ninsts.69;
  struct MonoClass * D.30047;
  struct MonoType * D.30048;
  int ninsts.70;
  struct MonoClass * D.30050;
  struct MonoType * D.30051;
  int ninsts.71;
  struct MonoClass * D.30053;
  struct MonoType * D.30054;
  int ninsts.72;
  struct MonoClass * D.30056;
  struct MonoType * D.30057;
  int ninsts.73;
  struct MonoClass * D.30059;
  struct MonoType * D.30060;
  int ninsts.74;
  struct MonoClass * D.30062;
  struct MonoType * D.30063;
  int ninsts.75;
  struct MonoClass * D.30065;
  struct MonoType * D.30066;
  struct MonoClass * D.30077;
  struct MonoGenericInst * D.30080;
  struct MonoMethod * D.30081;
  struct MonoMethod * D.30082;
  int D.27274;
  int iftmp.76;
  int D.27273;
  const char[16] * D.30088;
  unsigned char D.30089;
  int D.30090;
  unsigned char D.30091;
  int D.30092;
  _Bool D.30093;
  _Bool D.30094;
  _Bool D.30095;
  const unsigned char * D.30098;
  unsigned char D.30099;
  int D.30100;
  const unsigned char * D.30101;
  unsigned char D.30102;
  int D.30103;
  _Bool D.30104;
  _Bool D.30105;
  const unsigned char * D.30108;
  unsigned char D.30109;
  int D.30110;
  const unsigned char * D.30111;
  unsigned char D.30112;
  int D.30113;
  _Bool D.30114;
  _Bool D.30115;
  const unsigned char * D.30118;
  unsigned char D.30119;
  int D.30120;
  const unsigned char * D.30121;
  unsigned char D.30122;
  int D.30123;
  const char * D.30125;
  int D.27283;
  int iftmp.77;
  int D.27282;
  const char[9] * D.30130;
  unsigned char D.30131;
  int D.30132;
  unsigned char D.30133;
  int D.30134;
  _Bool D.30135;
  _Bool D.30136;
  _Bool D.30137;
  const unsigned char * D.30140;
  unsigned char D.30141;
  int D.30142;
  const unsigned char * D.30143;
  unsigned char D.30144;
  int D.30145;
  _Bool D.30146;
  _Bool D.30147;
  const unsigned char * D.30150;
  unsigned char D.30151;
  int D.30152;
  const unsigned char * D.30153;
  unsigned char D.30154;
  int D.30155;
  _Bool D.30156;
  _Bool D.30157;
  const unsigned char * D.30160;
  unsigned char D.30161;
  int D.30162;
  const unsigned char * D.30163;
  unsigned char D.30164;
  int D.30165;
  unsigned char D.30167;
  unsigned char D.30168;
  struct MonoGenericInst * D.30171;
  struct MonoMethod * D.30172;
  struct MonoMethod * D.30173;
  int D.27300;
  int iftmp.78;
  int D.27299;
  const char[5] * D.30181;
  unsigned char D.30182;
  int D.30183;
  unsigned char D.30184;
  int D.30185;
  _Bool D.30186;
  _Bool D.30187;
  _Bool D.30188;
  const unsigned char * D.30191;
  unsigned char D.30192;
  int D.30193;
  const unsigned char * D.30194;
  unsigned char D.30195;
  int D.30196;
  _Bool D.30197;
  _Bool D.30198;
  const unsigned char * D.30201;
  unsigned char D.30202;
  int D.30203;
  const unsigned char * D.30204;
  unsigned char D.30205;
  int D.30206;
  _Bool D.30207;
  _Bool D.30208;
  const unsigned char * D.30211;
  unsigned char D.30212;
  int D.30213;
  const unsigned char * D.30214;
  unsigned char D.30215;
  int D.30216;
  const char * D.30218;
  int D.27309;
  int iftmp.79;
  int D.27308;
  const char[6] * D.30223;
  unsigned char D.30224;
  int D.30225;
  unsigned char D.30226;
  int D.30227;
  _Bool D.30228;
  _Bool D.30229;
  _Bool D.30230;
  const unsigned char * D.30233;
  unsigned char D.30234;
  int D.30235;
  const unsigned char * D.30236;
  unsigned char D.30237;
  int D.30238;
  _Bool D.30239;
  _Bool D.30240;
  const unsigned char * D.30243;
  unsigned char D.30244;
  int D.30245;
  const unsigned char * D.30246;
  unsigned char D.30247;
  int D.30248;
  _Bool D.30249;
  _Bool D.30250;
  const unsigned char * D.30253;
  unsigned char D.30254;
  int D.30255;
  const unsigned char * D.30256;
  unsigned char D.30257;
  int D.30258;
  unsigned char D.30260;
  unsigned char D.30261;
  struct MonoGenericInst * D.30264;
  struct MonoMethod * D.30265;
  struct MonoMethod * D.30266;
  int i;
  guint32 token;
  struct MonoMethod * method;
  struct MonoGenericContext * context;

  D.29921 = acfg->aot_opts.no_instances;
  if (D.29921 != 0) goto <D.29922>; else goto <D.29923>;
  <D.29922>:
  return;
  <D.29923>:
  i = 0;
  goto <D.27244>;
  <D.27243>:
  D.29924 = i + 1;
  D.29925 = D.29924 | 721420288;
  token = (guint32) D.29925;
  D.29926 = acfg->image;
  method = mono_get_method (D.29926, token, 0B);
  if (method == 0B) goto <D.29927>; else goto <D.29928>;
  <D.29927>:
  // predicted unlikely by continue predictor.
  goto <D.27222>;
  <D.29928>:
  D.29929 = method->klass;
  D.29930 = D.29929->image;
  D.29926 = acfg->image;
  if (D.29930 != D.29926) goto <D.29931>; else goto <D.29932>;
  <D.29931>:
  // predicted unlikely by continue predictor.
  goto <D.27222>;
  <D.29932>:
  context = mono_method_get_context (method);
  if (context != 0B) goto <D.29933>; else goto <D.29934>;
  <D.29933>:
  D.29935 = context->class_inst;
  if (D.29935 != 0B) goto <D.29936>; else goto <D.29937>;
  <D.29936>:
  D.29935 = context->class_inst;
  D.29938 = BIT_FIELD_REF <*D.29935, 8, 48>;
  D.29939 = D.29938 & 64;
  if (D.29939 != 0) goto <D.29940>; else goto <D.29941>;
  <D.29940>:
  // predicted unlikely by continue predictor.
  goto <D.27222>;
  <D.29941>:
  <D.29937>:
  <D.29934>:
  if (context != 0B) goto <D.29942>; else goto <D.29943>;
  <D.29942>:
  D.29944 = context->method_inst;
  if (D.29944 != 0B) goto <D.29945>; else goto <D.29946>;
  <D.29945>:
  D.29944 = context->method_inst;
  D.29947 = BIT_FIELD_REF <*D.29944, 8, 48>;
  D.29948 = D.29947 & 64;
  if (D.29948 != 0) goto <D.29949>; else goto <D.29950>;
  <D.29949>:
  {
    struct MonoGenericContext shared_context;
    struct MonoGenericInst * inst;
    struct MonoType * * type_argv;
    int i;
    struct MonoMethod * declaring_method;
    gboolean supported;

    try
      {
        supported = 1;
        D.29935 = context->class_inst;
        if (D.29935 != 0B) goto <D.29951>; else goto <D.29952>;
        <D.29951>:
        inst = context->class_inst;
        i = 0;
        goto <D.27231>;
        <D.27230>:
        D.29955 = inst->type_argv[i];
        D.29956 = mono_type_is_reference (D.29955);
        if (D.29956 != 0) goto <D.29953>; else goto <D.29957>;
        <D.29957>:
        D.29955 = inst->type_argv[i];
        D.29958 = D.29955->type;
        if (D.29958 == 19) goto <D.29953>; else goto <D.29959>;
        <D.29959>:
        D.29955 = inst->type_argv[i];
        D.29958 = D.29955->type;
        if (D.29958 == 30) goto <D.29953>; else goto <D.29954>;
        <D.29953>:
        // predicted unlikely by continue predictor.
        goto <D.27229>;
        <D.29954>:
        D.29955 = inst->type_argv[i];
        D.29960 = mono_class_is_open_constructed_type (D.29955);
        if (D.29960 != 0) goto <D.29961>; else goto <D.29962>;
        <D.29961>:
        supported = 0;
        <D.29962>:
        <D.27229>:
        i = i + 1;
        <D.27231>:
        D.29963 = inst->type_argc;
        D.29964 = (int) D.29963;
        if (D.29964 > i) goto <D.27230>; else goto <D.27232>;
        <D.27232>:
        <D.29952>:
        D.29944 = context->method_inst;
        if (D.29944 != 0B) goto <D.29965>; else goto <D.29966>;
        <D.29965>:
        inst = context->method_inst;
        i = 0;
        goto <D.27235>;
        <D.27234>:
        D.29955 = inst->type_argv[i];
        D.29969 = mono_type_is_reference (D.29955);
        if (D.29969 != 0) goto <D.29967>; else goto <D.29970>;
        <D.29970>:
        D.29955 = inst->type_argv[i];
        D.29958 = D.29955->type;
        if (D.29958 == 19) goto <D.29967>; else goto <D.29971>;
        <D.29971>:
        D.29955 = inst->type_argv[i];
        D.29958 = D.29955->type;
        if (D.29958 == 30) goto <D.29967>; else goto <D.29968>;
        <D.29967>:
        // predicted unlikely by continue predictor.
        goto <D.27233>;
        <D.29968>:
        D.29955 = inst->type_argv[i];
        D.29972 = mono_class_is_open_constructed_type (D.29955);
        if (D.29972 != 0) goto <D.29973>; else goto <D.29974>;
        <D.29973>:
        supported = 0;
        <D.29974>:
        <D.27233>:
        i = i + 1;
        <D.27235>:
        D.29963 = inst->type_argc;
        D.29964 = (int) D.29963;
        if (D.29964 > i) goto <D.27234>; else goto <D.27236>;
        <D.27236>:
        <D.29966>:
        if (supported == 0) goto <D.29975>; else goto <D.29976>;
        <D.29975>:
        // predicted unlikely by continue predictor.
        goto <D.27222>;
        <D.29976>:
        memset (&shared_context, 0, 8);
        inst = context->class_inst;
        if (inst != 0B) goto <D.29977>; else goto <D.29978>;
        <D.29977>:
        D.29963 = inst->type_argc;
        D.29979 = (unsigned int) D.29963;
        D.29980 = D.29979 * 4;
        type_argv = monoeg_malloc0 (D.29980);
        i = 0;
        goto <D.27238>;
        <D.27237>:
        D.29955 = inst->type_argv[i];
        D.29984 = mono_type_is_reference (D.29955);
        if (D.29984 != 0) goto <D.29981>; else goto <D.29985>;
        <D.29985>:
        D.29955 = inst->type_argv[i];
        D.29958 = D.29955->type;
        if (D.29958 == 19) goto <D.29981>; else goto <D.29986>;
        <D.29986>:
        D.29955 = inst->type_argv[i];
        D.29958 = D.29955->type;
        if (D.29958 == 30) goto <D.29981>; else goto <D.29982>;
        <D.29981>:
        i.61 = (unsigned int) i;
        D.29988 = i.61 * 4;
        D.29989 = type_argv + D.29988;
        D.29990 = mono_defaults.object_class;
        D.29991 = &D.29990->byval_arg;
        *D.29989 = D.29991;
        goto <D.29983>;
        <D.29982>:
        i.61 = (unsigned int) i;
        D.29988 = i.61 * 4;
        D.29989 = type_argv + D.29988;
        D.29955 = inst->type_argv[i];
        *D.29989 = D.29955;
        <D.29983>:
        i = i + 1;
        <D.27238>:
        D.29963 = inst->type_argc;
        D.29964 = (int) D.29963;
        if (D.29964 > i) goto <D.27237>; else goto <D.27239>;
        <D.27239>:
        D.29963 = inst->type_argc;
        D.29964 = (int) D.29963;
        D.29992 = mono_metadata_get_generic_inst (D.29964, type_argv);
        shared_context.class_inst = D.29992;
        monoeg_g_free (type_argv);
        <D.29978>:
        inst = context->method_inst;
        if (inst != 0B) goto <D.29993>; else goto <D.29994>;
        <D.29993>:
        D.29963 = inst->type_argc;
        D.29979 = (unsigned int) D.29963;
        D.29980 = D.29979 * 4;
        type_argv = monoeg_malloc0 (D.29980);
        i = 0;
        goto <D.27241>;
        <D.27240>:
        D.29955 = inst->type_argv[i];
        D.29998 = mono_type_is_reference (D.29955);
        if (D.29998 != 0) goto <D.29995>; else goto <D.29999>;
        <D.29999>:
        D.29955 = inst->type_argv[i];
        D.29958 = D.29955->type;
        if (D.29958 == 19) goto <D.29995>; else goto <D.30000>;
        <D.30000>:
        D.29955 = inst->type_argv[i];
        D.29958 = D.29955->type;
        if (D.29958 == 30) goto <D.29995>; else goto <D.29996>;
        <D.29995>:
        i.61 = (unsigned int) i;
        D.29988 = i.61 * 4;
        D.29989 = type_argv + D.29988;
        D.29990 = mono_defaults.object_class;
        D.29991 = &D.29990->byval_arg;
        *D.29989 = D.29991;
        goto <D.29997>;
        <D.29996>:
        i.61 = (unsigned int) i;
        D.29988 = i.61 * 4;
        D.29989 = type_argv + D.29988;
        D.29955 = inst->type_argv[i];
        *D.29989 = D.29955;
        <D.29997>:
        i = i + 1;
        <D.27241>:
        D.29963 = inst->type_argc;
        D.29964 = (int) D.29963;
        if (D.29964 > i) goto <D.27240>; else goto <D.27242>;
        <D.27242>:
        D.29963 = inst->type_argc;
        D.29964 = (int) D.29963;
        D.30001 = mono_metadata_get_generic_inst (D.29964, type_argv);
        shared_context.method_inst = D.30001;
        monoeg_g_free (type_argv);
        <D.29994>:
        D.30005 = BIT_FIELD_REF <*method, 8, 168>;
        D.30006 = D.30005 & 8;
        if (D.30006 != 0) goto <D.30002>; else goto <D.30007>;
        <D.30007>:
        D.29929 = method->klass;
        D.30008 = D.29929->generic_container;
        if (D.30008 != 0B) goto <D.30002>; else goto <D.30003>;
        <D.30002>:
        declaring_method = method;
        goto <D.30004>;
        <D.30003>:
        declaring_method = mono_method_get_declaring_generic_method (method);
        <D.30004>:
        method = mono_class_inflate_generic_method (declaring_method, &shared_context);
      }
    finally
      {
        shared_context = {CLOBBER};
      }
  }
  <D.29950>:
  <D.29946>:
  <D.29943>:
  D.30009 = mono_method_is_generic_sharable_full (method, 0, 0, 0);
  if (D.30009 != 0) goto <D.30010>; else goto <D.30011>;
  <D.30010>:
  // predicted unlikely by continue predictor.
  goto <D.27222>;
  <D.30011>:
  add_extra_method (acfg, method);
  <D.27222>:
  i = i + 1;
  <D.27244>:
  D.29926 = acfg->image;
  D.30012 = D.29926->tables[43].rows;
  D.30013 = (int) D.30012;
  if (D.30013 > i) goto <D.27243>; else goto <D.27245>;
  <D.27245>:
  i = 0;
  goto <D.27249>;
  <D.27248>:
  {
    struct MonoClass * klass;

    D.29924 = i + 1;
    D.30014 = D.29924 | 452984832;
    token = (guint32) D.30014;
    D.29926 = acfg->image;
    klass = mono_class_get (D.29926, token);
    if (klass == 0B) goto <D.30015>; else goto <D.30017>;
    <D.30017>:
    D.30018 = klass->rank;
    if (D.30018 != 0) goto <D.30015>; else goto <D.30016>;
    <D.30015>:
    mono_loader_clear_error ();
    // predicted unlikely by continue predictor.
    goto <D.27247>;
    <D.30016>:
    add_generic_class (acfg, klass, 0, "typespec");
  }
  <D.27247>:
  i = i + 1;
  <D.27249>:
  D.29926 = acfg->image;
  D.30019 = D.29926->tables[27].rows;
  D.30020 = (int) D.30019;
  if (D.30020 > i) goto <D.27248>; else goto <D.27250>;
  <D.27250>:
  i = 0;
  goto <D.27252>;
  <D.27251>:
  D.30021 = acfg->methods;
  D.30022 = D.30021->pdata;
  i.62 = (unsigned int) i;
  D.30024 = i.62 * 4;
  D.30025 = D.30022 + D.30024;
  method = *D.30025;
  add_types_from_method_header (acfg, method);
  i = i + 1;
  <D.27252>:
  i.63 = (unsigned int) i;
  D.30021 = acfg->methods;
  D.30027 = D.30021->len;
  if (i.63 < D.30027) goto <D.27251>; else goto <D.27253>;
  <D.27253>:
  D.29926 = acfg->image;
  D.30028 = mono_defaults.corlib;
  if (D.29926 == D.30028) goto <D.30029>; else goto <D.30030>;
  <D.30029>:
  {
    struct MonoClass * klass;
    struct MonoType * insts[256];
    int ninsts;

    try
      {
        ninsts = 0;
        ninsts.64 = ninsts;
        ninsts = ninsts.64 + 1;
        D.30032 = mono_defaults.byte_class;
        D.30033 = &D.30032->byval_arg;
        insts[ninsts.64] = D.30033;
        ninsts.65 = ninsts;
        ninsts = ninsts.65 + 1;
        D.30035 = mono_defaults.sbyte_class;
        D.30036 = &D.30035->byval_arg;
        insts[ninsts.65] = D.30036;
        ninsts.66 = ninsts;
        ninsts = ninsts.66 + 1;
        D.30038 = mono_defaults.int16_class;
        D.30039 = &D.30038->byval_arg;
        insts[ninsts.66] = D.30039;
        ninsts.67 = ninsts;
        ninsts = ninsts.67 + 1;
        D.30041 = mono_defaults.uint16_class;
        D.30042 = &D.30041->byval_arg;
        insts[ninsts.67] = D.30042;
        ninsts.68 = ninsts;
        ninsts = ninsts.68 + 1;
        D.30044 = mono_defaults.int32_class;
        D.30045 = &D.30044->byval_arg;
        insts[ninsts.68] = D.30045;
        ninsts.69 = ninsts;
        ninsts = ninsts.69 + 1;
        D.30047 = mono_defaults.uint32_class;
        D.30048 = &D.30047->byval_arg;
        insts[ninsts.69] = D.30048;
        ninsts.70 = ninsts;
        ninsts = ninsts.70 + 1;
        D.30050 = mono_defaults.int64_class;
        D.30051 = &D.30050->byval_arg;
        insts[ninsts.70] = D.30051;
        ninsts.71 = ninsts;
        ninsts = ninsts.71 + 1;
        D.30053 = mono_defaults.uint64_class;
        D.30054 = &D.30053->byval_arg;
        insts[ninsts.71] = D.30054;
        ninsts.72 = ninsts;
        ninsts = ninsts.72 + 1;
        D.30056 = mono_defaults.single_class;
        D.30057 = &D.30056->byval_arg;
        insts[ninsts.72] = D.30057;
        ninsts.73 = ninsts;
        ninsts = ninsts.73 + 1;
        D.30059 = mono_defaults.double_class;
        D.30060 = &D.30059->byval_arg;
        insts[ninsts.73] = D.30060;
        ninsts.74 = ninsts;
        ninsts = ninsts.74 + 1;
        D.30062 = mono_defaults.char_class;
        D.30063 = &D.30062->byval_arg;
        insts[ninsts.74] = D.30063;
        ninsts.75 = ninsts;
        ninsts = ninsts.75 + 1;
        D.30065 = mono_defaults.boolean_class;
        D.30066 = &D.30065->byval_arg;
        insts[ninsts.75] = D.30066;
        D.29926 = acfg->image;
        klass = mono_class_from_name (D.29926, "System.Collections.Generic", "GenericComparer`1");
        if (klass != 0B) goto <D.30067>; else goto <D.30068>;
        <D.30067>:
        add_instances_of (acfg, klass, &insts, ninsts, 1);
        <D.30068>:
        D.29926 = acfg->image;
        klass = mono_class_from_name (D.29926, "System.Collections.Generic", "GenericEqualityComparer`1");
        if (klass != 0B) goto <D.30069>; else goto <D.30070>;
        <D.30069>:
        add_instances_of (acfg, klass, &insts, ninsts, 1);
        <D.30070>:
        D.29926 = acfg->image;
        klass = mono_class_from_name (D.29926, "System.Collections.Generic", "ICollection`1");
        if (klass != 0B) goto <D.30071>; else goto <D.30072>;
        <D.30071>:
        add_instances_of (acfg, klass, &insts, ninsts, 1);
        <D.30072>:
        D.29926 = acfg->image;
        klass = mono_class_from_name (D.29926, "System.Collections.Generic", "IList`1");
        if (klass != 0B) goto <D.30073>; else goto <D.30074>;
        <D.30073>:
        add_instances_of (acfg, klass, &insts, ninsts, 1);
        <D.30074>:
        D.29926 = acfg->image;
        klass = mono_class_from_name (D.29926, "System.Collections.Generic", "IEnumerable`1");
        if (klass != 0B) goto <D.30075>; else goto <D.30076>;
        <D.30075>:
        add_instances_of (acfg, klass, &insts, ninsts, 1);
        <D.30076>:
        {
          struct MonoGenericContext ctx;
          struct MonoType * args[16];
          struct MonoMethod * get_method;
          struct MonoClass * array_klass;

          try
            {
              D.29990 = mono_defaults.object_class;
              D.30077 = mono_array_class_get (D.29990, 1);
              array_klass = D.30077->parent;
              get_method = mono_class_get_method_from_name (array_klass, "GetGenericValueImpl", 2);
              if (get_method != 0B) goto <D.30078>; else goto <D.30079>;
              <D.30078>:
              memset (&ctx, 0, 8);
              D.29990 = mono_defaults.object_class;
              D.29991 = &D.29990->byval_arg;
              args[0] = D.29991;
              D.30080 = mono_metadata_get_generic_inst (1, &args);
              ctx.method_inst = D.30080;
              D.30081 = mono_class_inflate_generic_method (get_method, &ctx);
              D.30082 = mono_marshal_get_native_wrapper (D.30081, 1, 1);
              add_extra_method (acfg, D.30082);
              <D.30079>:
            }
          finally
            {
              ctx = {CLOBBER};
              args = {CLOBBER};
            }
        }
        {
          struct MonoGenericContext ctx;
          struct MonoType * args[16];
          struct MonoMethod * m;
          struct MonoClass * interlocked_klass;
          void * iter;

          try
            {
              D.30028 = mono_defaults.corlib;
              interlocked_klass = mono_class_from_name (D.30028, "System.Threading", "Interlocked");
              iter = 0B;
              goto <D.27285>;
              <D.27284>:
              {
                size_t __s1_len;
                size_t __s2_len;

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

                  __s2 = m->name;
                  D.30088 = "CompareExchange";
                  D.30089 = MEM[(const unsigned char *)D.30088];
                  D.30090 = (int) D.30089;
                  D.30091 = *__s2;
                  D.30092 = (int) D.30091;
                  __result = D.30090 - D.30092;
                  {
                    D.30093 = __s2_len != 0;
                    D.30094 = __result == 0;
                    D.30095 = D.30093 & D.30094;
                    if (D.30095 != 0) goto <D.30096>; else goto <D.30097>;
                    <D.30096>:
                    D.30098 = &MEM[(void *)"CompareExchange" + 1B];
                    D.30099 = *D.30098;
                    D.30100 = (int) D.30099;
                    D.30101 = __s2 + 1;
                    D.30102 = *D.30101;
                    D.30103 = (int) D.30102;
                    __result = D.30100 - D.30103;
                    D.30104 = __s2_len > 1;
                    D.30094 = __result == 0;
                    D.30105 = D.30104 & D.30094;
                    if (D.30105 != 0) goto <D.30106>; else goto <D.30107>;
                    <D.30106>:
                    D.30108 = &MEM[(void *)"CompareExchange" + 2B];
                    D.30109 = *D.30108;
                    D.30110 = (int) D.30109;
                    D.30111 = __s2 + 2;
                    D.30112 = *D.30111;
                    D.30113 = (int) D.30112;
                    __result = D.30110 - D.30113;
                    D.30114 = __s2_len > 2;
                    D.30094 = __result == 0;
                    D.30115 = D.30114 & D.30094;
                    if (D.30115 != 0) goto <D.30116>; else goto <D.30117>;
                    <D.30116>:
                    D.30118 = &MEM[(void *)"CompareExchange" + 3B];
                    D.30119 = *D.30118;
                    D.30120 = (int) D.30119;
                    D.30121 = __s2 + 3;
                    D.30122 = *D.30121;
                    D.30123 = (int) D.30122;
                    __result = D.30120 - D.30123;
                    <D.30117>:
                    <D.30107>:
                    <D.30097>:
                  }
                  D.27273 = __result;
                }
                iftmp.76 = -D.27273;
                goto <D.30124>;
                <D.30087>:
                D.30125 = m->name;
                iftmp.76 = __builtin_strcmp (D.30125, "CompareExchange");
                <D.30124>:
                D.27274 = iftmp.76;
              }
              if (D.27274 == 0) goto <D.30083>; else goto <D.30126>;
              <D.30126>:
              {
                size_t __s1_len;
                size_t __s2_len;

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

                  __s2 = m->name;
                  D.30130 = "Exchange";
                  D.30131 = MEM[(const unsigned char *)D.30130];
                  D.30132 = (int) D.30131;
                  D.30133 = *__s2;
                  D.30134 = (int) D.30133;
                  __result = D.30132 - D.30134;
                  {
                    D.30135 = __s2_len != 0;
                    D.30136 = __result == 0;
                    D.30137 = D.30135 & D.30136;
                    if (D.30137 != 0) goto <D.30138>; else goto <D.30139>;
                    <D.30138>:
                    D.30140 = &MEM[(void *)"Exchange" + 1B];
                    D.30141 = *D.30140;
                    D.30142 = (int) D.30141;
                    D.30143 = __s2 + 1;
                    D.30144 = *D.30143;
                    D.30145 = (int) D.30144;
                    __result = D.30142 - D.30145;
                    D.30146 = __s2_len > 1;
                    D.30136 = __result == 0;
                    D.30147 = D.30146 & D.30136;
                    if (D.30147 != 0) goto <D.30148>; else goto <D.30149>;
                    <D.30148>:
                    D.30150 = &MEM[(void *)"Exchange" + 2B];
                    D.30151 = *D.30150;
                    D.30152 = (int) D.30151;
                    D.30153 = __s2 + 2;
                    D.30154 = *D.30153;
                    D.30155 = (int) D.30154;
                    __result = D.30152 - D.30155;
                    D.30156 = __s2_len > 2;
                    D.30136 = __result == 0;
                    D.30157 = D.30156 & D.30136;
                    if (D.30157 != 0) goto <D.30158>; else goto <D.30159>;
                    <D.30158>:
                    D.30160 = &MEM[(void *)"Exchange" + 3B];
                    D.30161 = *D.30160;
                    D.30162 = (int) D.30161;
                    D.30163 = __s2 + 3;
                    D.30164 = *D.30163;
                    D.30165 = (int) D.30164;
                    __result = D.30162 - D.30165;
                    <D.30159>:
                    <D.30149>:
                    <D.30139>:
                  }
                  D.27282 = __result;
                }
                iftmp.77 = -D.27282;
                goto <D.30166>;
                <D.30129>:
                D.30125 = m->name;
                iftmp.77 = __builtin_strcmp (D.30125, "Exchange");
                <D.30166>:
                D.27283 = iftmp.77;
              }
              if (D.27283 == 0) goto <D.30083>; else goto <D.30084>;
              <D.30083>:
              D.30167 = BIT_FIELD_REF <*m, 8, 168>;
              D.30168 = D.30167 & 8;
              if (D.30168 != 0) goto <D.30169>; else goto <D.30170>;
              <D.30169>:
              memset (&ctx, 0, 8);
              D.29990 = mono_defaults.object_class;
              D.29991 = &D.29990->byval_arg;
              args[0] = D.29991;
              D.30171 = mono_metadata_get_generic_inst (1, &args);
              ctx.method_inst = D.30171;
              D.30172 = mono_class_inflate_generic_method (m, &ctx);
              D.30173 = mono_marshal_get_native_wrapper (D.30172, 1, 1);
              add_extra_method (acfg, D.30173);
              <D.30170>:
              <D.30084>:
              <D.27285>:
              m = mono_class_get_methods (interlocked_klass, &iter);
              if (m != 0B) goto <D.27284>; else goto <D.27286>;
              <D.27286>:
            }
          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.30028 = mono_defaults.corlib;
              volatile_klass = mono_class_from_name (D.30028, "System.Threading", "Volatile");
              iter = 0B;
              if (volatile_klass != 0B) goto <D.30174>; else goto <D.30175>;
              <D.30174>:
              goto <D.27311>;
              <D.27310>:
              {
                size_t __s1_len;
                size_t __s2_len;

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

                  __s2 = m->name;
                  D.30181 = "Read";
                  D.30182 = MEM[(const unsigned char *)D.30181];
                  D.30183 = (int) D.30182;
                  D.30184 = *__s2;
                  D.30185 = (int) D.30184;
                  __result = D.30183 - D.30185;
                  {
                    D.30186 = __s2_len != 0;
                    D.30187 = __result == 0;
                    D.30188 = D.30186 & D.30187;
                    if (D.30188 != 0) goto <D.30189>; else goto <D.30190>;
                    <D.30189>:
                    D.30191 = &MEM[(void *)"Read" + 1B];
                    D.30192 = *D.30191;
                    D.30193 = (int) D.30192;
                    D.30194 = __s2 + 1;
                    D.30195 = *D.30194;
                    D.30196 = (int) D.30195;
                    __result = D.30193 - D.30196;
                    D.30197 = __s2_len > 1;
                    D.30187 = __result == 0;
                    D.30198 = D.30197 & D.30187;
                    if (D.30198 != 0) goto <D.30199>; else goto <D.30200>;
                    <D.30199>:
                    D.30201 = &MEM[(void *)"Read" + 2B];
                    D.30202 = *D.30201;
                    D.30203 = (int) D.30202;
                    D.30204 = __s2 + 2;
                    D.30205 = *D.30204;
                    D.30206 = (int) D.30205;
                    __result = D.30203 - D.30206;
                    D.30207 = __s2_len > 2;
                    D.30187 = __result == 0;
                    D.30208 = D.30207 & D.30187;
                    if (D.30208 != 0) goto <D.30209>; else goto <D.30210>;
                    <D.30209>:
                    D.30211 = &MEM[(void *)"Read" + 3B];
                    D.30212 = *D.30211;
                    D.30213 = (int) D.30212;
                    D.30214 = __s2 + 3;
                    D.30215 = *D.30214;
                    D.30216 = (int) D.30215;
                    __result = D.30213 - D.30216;
                    <D.30210>:
                    <D.30200>:
                    <D.30190>:
                  }
                  D.27299 = __result;
                }
                iftmp.78 = -D.27299;
                goto <D.30217>;
                <D.30180>:
                D.30218 = m->name;
                iftmp.78 = __builtin_strcmp (D.30218, "Read");
                <D.30217>:
                D.27300 = iftmp.78;
              }
              if (D.27300 == 0) goto <D.30176>; else goto <D.30219>;
              <D.30219>:
              {
                size_t __s1_len;
                size_t __s2_len;

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

                  __s2 = m->name;
                  D.30223 = "Write";
                  D.30224 = MEM[(const unsigned char *)D.30223];
                  D.30225 = (int) D.30224;
                  D.30226 = *__s2;
                  D.30227 = (int) D.30226;
                  __result = D.30225 - D.30227;
                  {
                    D.30228 = __s2_len != 0;
                    D.30229 = __result == 0;
                    D.30230 = D.30228 & D.30229;
                    if (D.30230 != 0) goto <D.30231>; else goto <D.30232>;
                    <D.30231>:
                    D.30233 = &MEM[(void *)"Write" + 1B];
                    D.30234 = *D.30233;
                    D.30235 = (int) D.30234;
                    D.30236 = __s2 + 1;
                    D.30237 = *D.30236;
                    D.30238 = (int) D.30237;
                    __result = D.30235 - D.30238;
                    D.30239 = __s2_len > 1;
                    D.30229 = __result == 0;
                    D.30240 = D.30239 & D.30229;
                    if (D.30240 != 0) goto <D.30241>; else goto <D.30242>;
                    <D.30241>:
                    D.30243 = &MEM[(void *)"Write" + 2B];
                    D.30244 = *D.30243;
                    D.30245 = (int) D.30244;
                    D.30246 = __s2 + 2;
                    D.30247 = *D.30246;
                    D.30248 = (int) D.30247;
                    __result = D.30245 - D.30248;
                    D.30249 = __s2_len > 2;
                    D.30229 = __result == 0;
                    D.30250 = D.30249 & D.30229;
                    if (D.30250 != 0) goto <D.30251>; else goto <D.30252>;
                    <D.30251>:
                    D.30253 = &MEM[(void *)"Write" + 3B];
                    D.30254 = *D.30253;
                    D.30255 = (int) D.30254;
                    D.30256 = __s2 + 3;
                    D.30257 = *D.30256;
                    D.30258 = (int) D.30257;
                    __result = D.30255 - D.30258;
                    <D.30252>:
                    <D.30242>:
                    <D.30232>:
                  }
                  D.27308 = __result;
                }
                iftmp.79 = -D.27308;
                goto <D.30259>;
                <D.30222>:
                D.30218 = m->name;
                iftmp.79 = __builtin_strcmp (D.30218, "Write");
                <D.30259>:
                D.27309 = iftmp.79;
              }
              if (D.27309 == 0) goto <D.30176>; else goto <D.30177>;
              <D.30176>:
              D.30260 = BIT_FIELD_REF <*m, 8, 168>;
              D.30261 = D.30260 & 8;
              if (D.30261 != 0) goto <D.30262>; else goto <D.30263>;
              <D.30262>:
              memset (&ctx, 0, 8);
              D.29990 = mono_defaults.object_class;
              D.29991 = &D.29990->byval_arg;
              args[0] = D.29991;
              D.30264 = mono_metadata_get_generic_inst (1, &args);
              ctx.method_inst = D.30264;
              D.30265 = mono_class_inflate_generic_method (m, &ctx);
              D.30266 = mono_marshal_get_native_wrapper (D.30265, 1, 1);
              add_extra_method (acfg, D.30266);
              <D.30263>:
              <D.30177>:
              <D.27311>:
              m = mono_class_get_methods (volatile_klass, &iter);
              if (m != 0B) goto <D.27310>; else goto <D.27312>;
              <D.27312>:
              <D.30175>:
            }
          finally
            {
              ctx = {CLOBBER};
              args = {CLOBBER};
              iter = {CLOBBER};
            }
        }
      }
    finally
      {
        insts = {CLOBBER};
      }
  }
  <D.30030>:
}


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

  D.30270 = acfg->aot_opts.full_aot;
  D.30271 = D.30270 | force;
  if (D.30271 == 0) goto <D.30272>; else goto <D.30273>;
  <D.30272>:
  return;
  <D.30273>:
  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.30275;
  struct GHashTable * D.30278;
  struct MonoGenericClass * D.30279;
  struct MonoGenericInst * D.30282;
  unsigned char D.30283;
  unsigned char D.30284;
  int D.30287;
  unsigned char D.30292;
  unsigned char D.30295;
  struct GHashTable * D.30300;
  void * D.30301;
  struct MonoType * D.30304;
  int D.30305;
  int D.30308;
  char * D.30311;
  unsigned int D.30314;
  unsigned int D.30315;
  struct MonoImage * D.30318;
  struct MonoImage * D.30319;
  int D.30326;
  int D.27024;
  int iftmp.80;
  int D.27023;
  const char[13] * D.30332;
  unsigned char D.30333;
  int D.30334;
  unsigned char D.30335;
  int D.30336;
  _Bool D.30337;
  _Bool D.30338;
  _Bool D.30339;
  const unsigned char * D.30342;
  unsigned char D.30343;
  int D.30344;
  const unsigned char * D.30345;
  unsigned char D.30346;
  int D.30347;
  _Bool D.30348;
  _Bool D.30349;
  const unsigned char * D.30352;
  unsigned char D.30353;
  int D.30354;
  const unsigned char * D.30355;
  unsigned char D.30356;
  int D.30357;
  _Bool D.30358;
  _Bool D.30359;
  const unsigned char * D.30362;
  unsigned char D.30363;
  int D.30364;
  const unsigned char * D.30365;
  unsigned char D.30366;
  int D.30367;
  const char * D.30369;
  int D.27033;
  int iftmp.81;
  int D.27032;
  const char[7] * D.30374;
  unsigned char D.30375;
  int D.30376;
  unsigned char D.30377;
  int D.30378;
  _Bool D.30379;
  _Bool D.30380;
  _Bool D.30381;
  const unsigned char * D.30384;
  unsigned char D.30385;
  int D.30386;
  const unsigned char * D.30387;
  unsigned char D.30388;
  int D.30389;
  _Bool D.30390;
  _Bool D.30391;
  const unsigned char * D.30394;
  unsigned char D.30395;
  int D.30396;
  const unsigned char * D.30397;
  unsigned char D.30398;
  int D.30399;
  _Bool D.30400;
  _Bool D.30401;
  const unsigned char * D.30404;
  unsigned char D.30405;
  int D.30406;
  const unsigned char * D.30407;
  unsigned char D.30408;
  int D.30409;
  unsigned char D.30413;
  unsigned char D.30414;
  struct MonoGenericContext * D.30417;
  struct MonoGenericInst * D.30418;
  int D.30421;
  unsigned char D.30424;
  int D.30427;
  struct MonoType * D.30428;
  unsigned char D.30429;
  struct MonoClass * D.30432;
  unsigned char D.30433;
  unsigned char D.30434;
  char * D.30439;
  struct MonoClass * D.30440;
  int D.27048;
  int iftmp.82;
  int D.27047;
  const char[27] * D.30450;
  unsigned char D.30451;
  int D.30452;
  unsigned char D.30453;
  int D.30454;
  _Bool D.30455;
  _Bool D.30456;
  _Bool D.30457;
  const unsigned char * D.30460;
  unsigned char D.30461;
  int D.30462;
  const unsigned char * D.30463;
  unsigned char D.30464;
  int D.30465;
  _Bool D.30466;
  _Bool D.30467;
  const unsigned char * D.30470;
  unsigned char D.30471;
  int D.30472;
  const unsigned char * D.30473;
  unsigned char D.30474;
  int D.30475;
  _Bool D.30476;
  _Bool D.30477;
  const unsigned char * D.30480;
  unsigned char D.30481;
  int D.30482;
  const unsigned char * D.30483;
  unsigned char D.30484;
  int D.30485;
  const char * D.30487;
  int D.27057;
  int iftmp.83;
  int D.27056;
  const char[14] * D.30493;
  unsigned char D.30494;
  int D.30495;
  unsigned char D.30496;
  int D.30497;
  _Bool D.30498;
  _Bool D.30499;
  _Bool D.30500;
  const unsigned char * D.30503;
  unsigned char D.30504;
  int D.30505;
  const unsigned char * D.30506;
  unsigned char D.30507;
  int D.30508;
  _Bool D.30509;
  _Bool D.30510;
  const unsigned char * D.30513;
  unsigned char D.30514;
  int D.30515;
  const unsigned char * D.30516;
  unsigned char D.30517;
  int D.30518;
  _Bool D.30519;
  _Bool D.30520;
  const unsigned char * D.30523;
  unsigned char D.30524;
  int D.30525;
  const unsigned char * D.30526;
  unsigned char D.30527;
  int D.30528;
  int D.27066;
  int iftmp.84;
  int D.27065;
  const char[14] * D.30534;
  unsigned char D.30535;
  int D.30536;
  unsigned char D.30537;
  int D.30538;
  _Bool D.30539;
  _Bool D.30540;
  _Bool D.30541;
  const unsigned char * D.30544;
  unsigned char D.30545;
  int D.30546;
  const unsigned char * D.30547;
  unsigned char D.30548;
  int D.30549;
  _Bool D.30550;
  _Bool D.30551;
  const unsigned char * D.30554;
  unsigned char D.30555;
  int D.30556;
  const unsigned char * D.30557;
  unsigned char D.30558;
  int D.30559;
  _Bool D.30560;
  _Bool D.30561;
  const unsigned char * D.30564;
  unsigned char D.30565;
  int D.30566;
  const unsigned char * D.30567;
  unsigned char D.30568;
  int D.30569;
  int D.27075;
  int iftmp.85;
  int D.27074;
  const char[8] * D.30575;
  unsigned char D.30576;
  int D.30577;
  unsigned char D.30578;
  int D.30579;
  _Bool D.30580;
  _Bool D.30581;
  _Bool D.30582;
  const unsigned char * D.30585;
  unsigned char D.30586;
  int D.30587;
  const unsigned char * D.30588;
  unsigned char D.30589;
  int D.30590;
  _Bool D.30591;
  _Bool D.30592;
  const unsigned char * D.30595;
  unsigned char D.30596;
  int D.30597;
  const unsigned char * D.30598;
  unsigned char D.30599;
  int D.30600;
  _Bool D.30601;
  _Bool D.30602;
  const unsigned char * D.30605;
  unsigned char D.30606;
  int D.30607;
  const unsigned char * D.30608;
  unsigned char D.30609;
  int D.30610;
  int D.27084;
  int iftmp.86;
  int D.27083;
  const char[14] * D.30616;
  unsigned char D.30617;
  int D.30618;
  unsigned char D.30619;
  int D.30620;
  _Bool D.30621;
  _Bool D.30622;
  _Bool D.30623;
  const unsigned char * D.30626;
  unsigned char D.30627;
  int D.30628;
  const unsigned char * D.30629;
  unsigned char D.30630;
  int D.30631;
  _Bool D.30632;
  _Bool D.30633;
  const unsigned char * D.30636;
  unsigned char D.30637;
  int D.30638;
  const unsigned char * D.30639;
  unsigned char D.30640;
  int D.30641;
  _Bool D.30642;
  _Bool D.30643;
  const unsigned char * D.30646;
  unsigned char D.30647;
  int D.30648;
  const unsigned char * D.30649;
  unsigned char D.30650;
  int D.30651;
  int D.27093;
  int iftmp.87;
  int D.27092;
  const char[16] * D.30657;
  unsigned char D.30658;
  int D.30659;
  unsigned char D.30660;
  int D.30661;
  _Bool D.30662;
  _Bool D.30663;
  _Bool D.30664;
  const unsigned char * D.30667;
  unsigned char D.30668;
  int D.30669;
  const unsigned char * D.30670;
  unsigned char D.30671;
  int D.30672;
  _Bool D.30673;
  _Bool D.30674;
  const unsigned char * D.30677;
  unsigned char D.30678;
  int D.30679;
  const unsigned char * D.30680;
  unsigned char D.30681;
  int D.30682;
  _Bool D.30683;
  _Bool D.30684;
  const unsigned char * D.30687;
  unsigned char D.30688;
  int D.30689;
  const unsigned char * D.30690;
  unsigned char D.30691;
  int D.30692;
  struct MonoType * D.30694;
  int D.27106;
  int iftmp.88;
  int D.27105;
  unsigned char D.30698;
  int D.30699;
  _Bool D.30700;
  _Bool D.30701;
  _Bool D.30702;
  const unsigned char * D.30705;
  unsigned char D.30706;
  int D.30707;
  _Bool D.30708;
  _Bool D.30709;
  const unsigned char * D.30712;
  unsigned char D.30713;
  int D.30714;
  _Bool D.30715;
  _Bool D.30716;
  const unsigned char * D.30719;
  unsigned char D.30720;
  int D.30721;
  int D.27115;
  int iftmp.89;
  int D.27114;
  unsigned char D.30731;
  int D.30732;
  _Bool D.30733;
  _Bool D.30734;
  _Bool D.30735;
  const unsigned char * D.30738;
  unsigned char D.30739;
  int D.30740;
  _Bool D.30741;
  _Bool D.30742;
  const unsigned char * D.30745;
  unsigned char D.30746;
  int D.30747;
  _Bool D.30748;
  _Bool D.30749;
  const unsigned char * D.30752;
  unsigned char D.30753;
  int D.30754;
  int D.27124;
  int iftmp.90;
  int D.27123;
  unsigned char D.30760;
  int D.30761;
  _Bool D.30762;
  _Bool D.30763;
  _Bool D.30764;
  const unsigned char * D.30767;
  unsigned char D.30768;
  int D.30769;
  _Bool D.30770;
  _Bool D.30771;
  const unsigned char * D.30774;
  unsigned char D.30775;
  int D.30776;
  _Bool D.30777;
  _Bool D.30778;
  const unsigned char * D.30781;
  unsigned char D.30782;
  int D.30783;
  int D.27134;
  int iftmp.91;
  int D.27133;
  const char[21] * D.30788;
  unsigned char D.30789;
  int D.30790;
  unsigned char D.30791;
  int D.30792;
  _Bool D.30793;
  _Bool D.30794;
  _Bool D.30795;
  const unsigned char * D.30798;
  unsigned char D.30799;
  int D.30800;
  const unsigned char * D.30801;
  unsigned char D.30802;
  int D.30803;
  _Bool D.30804;
  _Bool D.30805;
  const unsigned char * D.30808;
  unsigned char D.30809;
  int D.30810;
  const unsigned char * D.30811;
  unsigned char D.30812;
  int D.30813;
  _Bool D.30814;
  _Bool D.30815;
  const unsigned char * D.30818;
  unsigned char D.30819;
  int D.30820;
  const unsigned char * D.30821;
  unsigned char D.30822;
  int D.30823;
  const char * D.30825;
  struct MonoClass * D.30827;
  _Bool D.30828;
  long int D.30829;
  long int D.30830;
  struct MonoGenericContext * D.30833;
  const char * D.30834;
  char * D.30835;
  int D.27150;
  int iftmp.92;
  int D.27149;
  unsigned char D.30843;
  int D.30844;
  _Bool D.30845;
  _Bool D.30846;
  _Bool D.30847;
  const unsigned char * D.30850;
  unsigned char D.30851;
  int D.30852;
  _Bool D.30853;
  _Bool D.30854;
  const unsigned char * D.30857;
  unsigned char D.30858;
  int D.30859;
  _Bool D.30860;
  _Bool D.30861;
  const unsigned char * D.30864;
  unsigned char D.30865;
  int D.30866;
  int D.27159;
  int iftmp.93;
  int D.27158;
  const char[11] * D.30873;
  unsigned char D.30874;
  int D.30875;
  unsigned char D.30876;
  int D.30877;
  _Bool D.30878;
  _Bool D.30879;
  _Bool D.30880;
  const unsigned char * D.30883;
  unsigned char D.30884;
  int D.30885;
  const unsigned char * D.30886;
  unsigned char D.30887;
  int D.30888;
  _Bool D.30889;
  _Bool D.30890;
  const unsigned char * D.30893;
  unsigned char D.30894;
  int D.30895;
  const unsigned char * D.30896;
  unsigned char D.30897;
  int D.30898;
  _Bool D.30899;
  _Bool D.30900;
  const unsigned char * D.30903;
  unsigned char D.30904;
  int D.30905;
  const unsigned char * D.30906;
  unsigned char D.30907;
  int D.30908;
  _Bool D.30912;
  long int D.30913;
  long int D.30914;
  struct MonoType * D.30917;
  struct MonoGenericInst * D.30918;
  struct MonoClass * D.30919;
  int D.30920;
  _Bool D.30923;
  long int D.30924;
  long int D.30925;
  struct MonoClass * D.30928;
  int D.27173;
  int iftmp.94;
  int D.27172;
  unsigned char D.30934;
  int D.30935;
  _Bool D.30936;
  _Bool D.30937;
  _Bool D.30938;
  const unsigned char * D.30941;
  unsigned char D.30942;
  int D.30943;
  _Bool D.30944;
  _Bool D.30945;
  const unsigned char * D.30948;
  unsigned char D.30949;
  int D.30950;
  _Bool D.30951;
  _Bool D.30952;
  const unsigned char * D.30955;
  unsigned char D.30956;
  int D.30957;
  int D.27182;
  int iftmp.95;
  int D.27181;
  const char[19] * D.30964;
  unsigned char D.30965;
  int D.30966;
  unsigned char D.30967;
  int D.30968;
  _Bool D.30969;
  _Bool D.30970;
  _Bool D.30971;
  const unsigned char * D.30974;
  unsigned char D.30975;
  int D.30976;
  const unsigned char * D.30977;
  unsigned char D.30978;
  int D.30979;
  _Bool D.30980;
  _Bool D.30981;
  const unsigned char * D.30984;
  unsigned char D.30985;
  int D.30986;
  const unsigned char * D.30987;
  unsigned char D.30988;
  int D.30989;
  _Bool D.30990;
  _Bool D.30991;
  const unsigned char * D.30994;
  unsigned char D.30995;
  int D.30996;
  const unsigned char * D.30997;
  unsigned char D.30998;
  int D.30999;
  _Bool D.31003;
  long int D.31004;
  long int D.31005;
  struct MonoType * D.31008;
  struct MonoGenericInst * D.31009;
  struct MonoClass * D.31010;
  int D.31011;
  _Bool D.31014;
  long int D.31015;
  long int D.31016;
  struct MonoClass * D.31019;
  struct MonoMethod * method;
  struct MonoClassField * field;
  void * iter;
  gboolean use_gsharedvt;

  try
    {
      use_gsharedvt = 0;
      D.30275 = acfg->ginst_hash;
      if (D.30275 == 0B) goto <D.30276>; else goto <D.30277>;
      <D.30276>:
      D.30278 = monoeg_g_hash_table_new (0B, 0B);
      acfg->ginst_hash = D.30278;
      <D.30277>:
      mono_class_init (klass);
      D.30279 = klass->generic_class;
      if (D.30279 != 0B) goto <D.30280>; else goto <D.30281>;
      <D.30280>:
      D.30279 = klass->generic_class;
      D.30282 = D.30279->context.class_inst;
      D.30283 = BIT_FIELD_REF <*D.30282, 8, 48>;
      D.30284 = D.30283 & 64;
      if (D.30284 != 0) goto <D.30285>; else goto <D.30286>;
      <D.30285>:
      return;
      <D.30286>:
      <D.30281>:
      D.30287 = has_type_vars (klass);
      if (D.30287 != 0) goto <D.30288>; else goto <D.30289>;
      <D.30288>:
      return;
      <D.30289>:
      D.30279 = klass->generic_class;
      if (D.30279 == 0B) goto <D.30290>; else goto <D.30291>;
      <D.30290>:
      D.30292 = klass->rank;
      if (D.30292 == 0) goto <D.30293>; else goto <D.30294>;
      <D.30293>:
      return;
      <D.30294>:
      <D.30291>:
      D.30295 = klass->exception_type;
      if (D.30295 != 0) goto <D.30296>; else goto <D.30297>;
      <D.30296>:
      return;
      <D.30297>:
      D.30275 = acfg->ginst_hash;
      if (D.30275 == 0B) goto <D.30298>; else goto <D.30299>;
      <D.30298>:
      D.30300 = monoeg_g_hash_table_new (0B, 0B);
      acfg->ginst_hash = D.30300;
      <D.30299>:
      D.30275 = acfg->ginst_hash;
      D.30301 = monoeg_g_hash_table_lookup (D.30275, klass);
      if (D.30301 != 0B) goto <D.30302>; else goto <D.30303>;
      <D.30302>:
      return;
      <D.30303>:
      D.30304 = &klass->byval_arg;
      D.30305 = check_type_depth (D.30304, 0);
      if (D.30305 != 0) goto <D.30306>; else goto <D.30307>;
      <D.30306>:
      return;
      <D.30307>:
      D.30308 = acfg->aot_opts.log_generics;
      if (D.30308 != 0) goto <D.30309>; else goto <D.30310>;
      <D.30309>:
      D.30304 = &klass->byval_arg;
      D.30311 = mono_type_full_name (D.30304);
      printf ("%*sAdding generic instance %s [%s].\n", depth, "", D.30311, ref);
      <D.30310>:
      D.30275 = acfg->ginst_hash;
      monoeg_g_hash_table_insert_replace (D.30275, klass, klass, 0);
      D.30314 = acfg->opts;
      D.30315 = D.30314 & 16777216;
      if (D.30315 != 0) goto <D.30316>; else goto <D.30317>;
      <D.30316>:
      D.30318 = klass->image;
      D.30319 = mono_defaults.corlib;
      if (D.30318 == D.30319) goto <D.30320>; else goto <D.30321>;
      <D.30320>:
      D.30279 = klass->generic_class;
      if (D.30279 != 0B) goto <D.30322>; else goto <D.30323>;
      <D.30322>:
      D.30279 = klass->generic_class;
      D.30282 = D.30279->context.class_inst;
      if (D.30282 != 0B) goto <D.30324>; else goto <D.30325>;
      <D.30324>:
      D.30279 = klass->generic_class;
      D.30282 = D.30279->context.class_inst;
      D.30326 = is_vt_inst (D.30282);
      if (D.30326 != 0) goto <D.30327>; else goto <D.30328>;
      <D.30327>:
      {
        size_t __s1_len;
        size_t __s2_len;

        __s2_len = 12;
        if (__s2_len <= 3) goto <D.30330>; else goto <D.30331>;
        <D.30330>:
        {
          const unsigned char * __s2;
          int __result;

          __s2 = klass->name;
          D.30332 = "Dictionary`2";
          D.30333 = MEM[(const unsigned char *)D.30332];
          D.30334 = (int) D.30333;
          D.30335 = *__s2;
          D.30336 = (int) D.30335;
          __result = D.30334 - D.30336;
          {
            D.30337 = __s2_len != 0;
            D.30338 = __result == 0;
            D.30339 = D.30337 & D.30338;
            if (D.30339 != 0) goto <D.30340>; else goto <D.30341>;
            <D.30340>:
            D.30342 = &MEM[(void *)"Dictionary`2" + 1B];
            D.30343 = *D.30342;
            D.30344 = (int) D.30343;
            D.30345 = __s2 + 1;
            D.30346 = *D.30345;
            D.30347 = (int) D.30346;
            __result = D.30344 - D.30347;
            D.30348 = __s2_len > 1;
            D.30338 = __result == 0;
            D.30349 = D.30348 & D.30338;
            if (D.30349 != 0) goto <D.30350>; else goto <D.30351>;
            <D.30350>:
            D.30352 = &MEM[(void *)"Dictionary`2" + 2B];
            D.30353 = *D.30352;
            D.30354 = (int) D.30353;
            D.30355 = __s2 + 2;
            D.30356 = *D.30355;
            D.30357 = (int) D.30356;
            __result = D.30354 - D.30357;
            D.30358 = __s2_len > 2;
            D.30338 = __result == 0;
            D.30359 = D.30358 & D.30338;
            if (D.30359 != 0) goto <D.30360>; else goto <D.30361>;
            <D.30360>:
            D.30362 = &MEM[(void *)"Dictionary`2" + 3B];
            D.30363 = *D.30362;
            D.30364 = (int) D.30363;
            D.30365 = __s2 + 3;
            D.30366 = *D.30365;
            D.30367 = (int) D.30366;
            __result = D.30364 - D.30367;
            <D.30361>:
            <D.30351>:
            <D.30341>:
          }
          D.27023 = __result;
        }
        iftmp.80 = -D.27023;
        goto <D.30368>;
        <D.30331>:
        D.30369 = klass->name;
        iftmp.80 = __builtin_strcmp (D.30369, "Dictionary`2");
        <D.30368>:
        D.27024 = iftmp.80;
      }
      if (D.27024 == 0) goto <D.30312>; else goto <D.30370>;
      <D.30370>:
      {
        size_t __s1_len;
        size_t __s2_len;

        __s2_len = 6;
        if (__s2_len <= 3) goto <D.30372>; else goto <D.30373>;
        <D.30372>:
        {
          const unsigned char * __s2;
          int __result;

          __s2 = klass->name;
          D.30374 = "List`1";
          D.30375 = MEM[(const unsigned char *)D.30374];
          D.30376 = (int) D.30375;
          D.30377 = *__s2;
          D.30378 = (int) D.30377;
          __result = D.30376 - D.30378;
          {
            D.30379 = __s2_len != 0;
            D.30380 = __result == 0;
            D.30381 = D.30379 & D.30380;
            if (D.30381 != 0) goto <D.30382>; else goto <D.30383>;
            <D.30382>:
            D.30384 = &MEM[(void *)"List`1" + 1B];
            D.30385 = *D.30384;
            D.30386 = (int) D.30385;
            D.30387 = __s2 + 1;
            D.30388 = *D.30387;
            D.30389 = (int) D.30388;
            __result = D.30386 - D.30389;
            D.30390 = __s2_len > 1;
            D.30380 = __result == 0;
            D.30391 = D.30390 & D.30380;
            if (D.30391 != 0) goto <D.30392>; else goto <D.30393>;
            <D.30392>:
            D.30394 = &MEM[(void *)"List`1" + 2B];
            D.30395 = *D.30394;
            D.30396 = (int) D.30395;
            D.30397 = __s2 + 2;
            D.30398 = *D.30397;
            D.30399 = (int) D.30398;
            __result = D.30396 - D.30399;
            D.30400 = __s2_len > 2;
            D.30380 = __result == 0;
            D.30401 = D.30400 & D.30380;
            if (D.30401 != 0) goto <D.30402>; else goto <D.30403>;
            <D.30402>:
            D.30404 = &MEM[(void *)"List`1" + 3B];
            D.30405 = *D.30404;
            D.30406 = (int) D.30405;
            D.30407 = __s2 + 3;
            D.30408 = *D.30407;
            D.30409 = (int) D.30408;
            __result = D.30406 - D.30409;
            <D.30403>:
            <D.30393>:
            <D.30383>:
          }
          D.27032 = __result;
        }
        iftmp.81 = -D.27032;
        goto <D.30410>;
        <D.30373>:
        D.30369 = klass->name;
        iftmp.81 = __builtin_strcmp (D.30369, "List`1");
        <D.30410>:
        D.27033 = iftmp.81;
      }
      if (D.27033 == 0) goto <D.30312>; else goto <D.30313>;
      <D.30312>:
      use_gsharedvt = 1;
      <D.30313>:
      <D.30328>:
      <D.30325>:
      <D.30323>:
      <D.30321>:
      <D.30317>:
      iter = 0B;
      goto <D.27034>;
      <D.27035>:
      D.30314 = acfg->opts;
      D.30315 = D.30314 & 16777216;
      if (D.30315 != 0) goto <D.30411>; else goto <D.30412>;
      <D.30411>:
      D.30413 = BIT_FIELD_REF <*method, 8, 168>;
      D.30414 = D.30413 & 16;
      if (D.30414 != 0) goto <D.30415>; else goto <D.30416>;
      <D.30415>:
      D.30417 = mono_method_get_context (method);
      D.30418 = D.30417->method_inst;
      if (D.30418 != 0B) goto <D.30419>; else goto <D.30420>;
      <D.30419>:
      // predicted unlikely by continue predictor.
      goto <D.27034>;
      <D.30420>:
      <D.30416>:
      <D.30412>:
      D.30421 = mono_method_is_generic_sharable_full (method, 0, 0, use_gsharedvt);
      if (D.30421 != 0) goto <D.30422>; else goto <D.30423>;
      <D.30422>:
      add_types_from_method_header (acfg, method);
      // predicted unlikely by continue predictor.
      goto <D.27034>;
      <D.30423>:
      D.30413 = BIT_FIELD_REF <*method, 8, 168>;
      D.30424 = D.30413 & 8;
      if (D.30424 != 0) goto <D.30425>; else goto <D.30426>;
      <D.30425>:
      // predicted unlikely by continue predictor.
      goto <D.27034>;
      <D.30426>:
      D.30427 = depth + 1;
      add_extra_method_with_depth (acfg, method, D.30427);
      <D.27034>:
      method = mono_class_get_methods (klass, &iter);
      if (method != 0B) goto <D.27035>; else goto <D.27036>;
      <D.27036>:
      iter = 0B;
      goto <D.27038>;
      <D.27037>:
      D.30428 = field->type;
      D.30429 = D.30428->type;
      if (D.30429 == 21) goto <D.30430>; else goto <D.30431>;
      <D.30430>:
      D.30428 = field->type;
      D.30432 = mono_class_from_mono_type (D.30428);
      D.30427 = depth + 1;
      add_generic_class_with_depth (acfg, D.30432, D.30427, "field");
      <D.30431>:
      <D.27038>:
      field = mono_class_get_fields (klass, &iter);
      if (field != 0B) goto <D.27037>; else goto <D.27039>;
      <D.27039>:
      D.30433 = BIT_FIELD_REF <*klass, 8, 184>;
      D.30434 = D.30433 & 1;
      if (D.30434 != 0) goto <D.30435>; else goto <D.30436>;
      <D.30435>:
      method = mono_get_delegate_invoke (klass);
      method = mono_marshal_get_delegate_invoke (method, 0B);
      D.30308 = acfg->aot_opts.log_generics;
      if (D.30308 != 0) goto <D.30437>; else goto <D.30438>;
      <D.30437>:
      D.30439 = mono_method_full_name (method, 1);
      printf ("%*sAdding method %s.\n", depth, "", D.30439);
      <D.30438>:
      add_method (acfg, method);
      <D.30436>:
      D.30440 = klass->parent;
      if (D.30440 != 0B) goto <D.30441>; else goto <D.30442>;
      <D.30441>:
      D.30440 = klass->parent;
      add_generic_class_with_depth (acfg, D.30440, depth, "parent");
      <D.30442>:
      D.30318 = klass->image;
      D.30319 = mono_defaults.corlib;
      if (D.30318 == D.30319) goto <D.30445>; else goto <D.30446>;
      <D.30445>:
      {
        size_t __s1_len;
        size_t __s2_len;

        __s2_len = 26;
        if (__s2_len <= 3) goto <D.30448>; else goto <D.30449>;
        <D.30448>:
        {
          const unsigned char * __s2;
          int __result;

          __s2 = klass->name_space;
          D.30450 = "System.Collections.Generic";
          D.30451 = MEM[(const unsigned char *)D.30450];
          D.30452 = (int) D.30451;
          D.30453 = *__s2;
          D.30454 = (int) D.30453;
          __result = D.30452 - D.30454;
          {
            D.30455 = __s2_len != 0;
            D.30456 = __result == 0;
            D.30457 = D.30455 & D.30456;
            if (D.30457 != 0) goto <D.30458>; else goto <D.30459>;
            <D.30458>:
            D.30460 = &MEM[(void *)"System.Collections.Generic" + 1B];
            D.30461 = *D.30460;
            D.30462 = (int) D.30461;
            D.30463 = __s2 + 1;
            D.30464 = *D.30463;
            D.30465 = (int) D.30464;
            __result = D.30462 - D.30465;
            D.30466 = __s2_len > 1;
            D.30456 = __result == 0;
            D.30467 = D.30466 & D.30456;
            if (D.30467 != 0) goto <D.30468>; else goto <D.30469>;
            <D.30468>:
            D.30470 = &MEM[(void *)"System.Collections.Generic" + 2B];
            D.30471 = *D.30470;
            D.30472 = (int) D.30471;
            D.30473 = __s2 + 2;
            D.30474 = *D.30473;
            D.30475 = (int) D.30474;
            __result = D.30472 - D.30475;
            D.30476 = __s2_len > 2;
            D.30456 = __result == 0;
            D.30477 = D.30476 & D.30456;
            if (D.30477 != 0) goto <D.30478>; else goto <D.30479>;
            <D.30478>:
            D.30480 = &MEM[(void *)"System.Collections.Generic" + 3B];
            D.30481 = *D.30480;
            D.30482 = (int) D.30481;
            D.30483 = __s2 + 3;
            D.30484 = *D.30483;
            D.30485 = (int) D.30484;
            __result = D.30482 - D.30485;
            <D.30479>:
            <D.30469>:
            <D.30459>:
          }
          D.27047 = __result;
        }
        iftmp.82 = -D.27047;
        goto <D.30486>;
        <D.30449>:
        D.30487 = klass->name_space;
        iftmp.82 = __builtin_strcmp (D.30487, "System.Collections.Generic");
        <D.30486>:
        D.27048 = iftmp.82;
      }
      if (D.27048 == 0) goto <D.30488>; else goto <D.30489>;
      <D.30488>:
      {
        size_t __s1_len;
        size_t __s2_len;

        __s2_len = 13;
        if (__s2_len <= 3) goto <D.30491>; else goto <D.30492>;
        <D.30491>:
        {
          const unsigned char * __s2;
          int __result;

          __s2 = klass->name;
          D.30493 = "ICollection`1";
          D.30494 = MEM[(const unsigned char *)D.30493];
          D.30495 = (int) D.30494;
          D.30496 = *__s2;
          D.30497 = (int) D.30496;
          __result = D.30495 - D.30497;
          {
            D.30498 = __s2_len != 0;
            D.30499 = __result == 0;
            D.30500 = D.30498 & D.30499;
            if (D.30500 != 0) goto <D.30501>; else goto <D.30502>;
            <D.30501>:
            D.30503 = &MEM[(void *)"ICollection`1" + 1B];
            D.30504 = *D.30503;
            D.30505 = (int) D.30504;
            D.30506 = __s2 + 1;
            D.30507 = *D.30506;
            D.30508 = (int) D.30507;
            __result = D.30505 - D.30508;
            D.30509 = __s2_len > 1;
            D.30499 = __result == 0;
            D.30510 = D.30509 & D.30499;
            if (D.30510 != 0) goto <D.30511>; else goto <D.30512>;
            <D.30511>:
            D.30513 = &MEM[(void *)"ICollection`1" + 2B];
            D.30514 = *D.30513;
            D.30515 = (int) D.30514;
            D.30516 = __s2 + 2;
            D.30517 = *D.30516;
            D.30518 = (int) D.30517;
            __result = D.30515 - D.30518;
            D.30519 = __s2_len > 2;
            D.30499 = __result == 0;
            D.30520 = D.30519 & D.30499;
            if (D.30520 != 0) goto <D.30521>; else goto <D.30522>;
            <D.30521>:
            D.30523 = &MEM[(void *)"ICollection`1" + 3B];
            D.30524 = *D.30523;
            D.30525 = (int) D.30524;
            D.30526 = __s2 + 3;
            D.30527 = *D.30526;
            D.30528 = (int) D.30527;
            __result = D.30525 - D.30528;
            <D.30522>:
            <D.30512>:
            <D.30502>:
          }
          D.27056 = __result;
        }
        iftmp.83 = -D.27056;
        goto <D.30529>;
        <D.30492>:
        D.30369 = klass->name;
        iftmp.83 = __builtin_strcmp (D.30369, "ICollection`1");
        <D.30529>:
        D.27057 = iftmp.83;
      }
      if (D.27057 == 0) goto <D.30443>; else goto <D.30530>;
      <D.30530>:
      {
        size_t __s1_len;
        size_t __s2_len;

        __s2_len = 13;
        if (__s2_len <= 3) goto <D.30532>; else goto <D.30533>;
        <D.30532>:
        {
          const unsigned char * __s2;
          int __result;

          __s2 = klass->name;
          D.30534 = "IEnumerable`1";
          D.30535 = MEM[(const unsigned char *)D.30534];
          D.30536 = (int) D.30535;
          D.30537 = *__s2;
          D.30538 = (int) D.30537;
          __result = D.30536 - D.30538;
          {
            D.30539 = __s2_len != 0;
            D.30540 = __result == 0;
            D.30541 = D.30539 & D.30540;
            if (D.30541 != 0) goto <D.30542>; else goto <D.30543>;
            <D.30542>:
            D.30544 = &MEM[(void *)"IEnumerable`1" + 1B];
            D.30545 = *D.30544;
            D.30546 = (int) D.30545;
            D.30547 = __s2 + 1;
            D.30548 = *D.30547;
            D.30549 = (int) D.30548;
            __result = D.30546 - D.30549;
            D.30550 = __s2_len > 1;
            D.30540 = __result == 0;
            D.30551 = D.30550 & D.30540;
            if (D.30551 != 0) goto <D.30552>; else goto <D.30553>;
            <D.30552>:
            D.30554 = &MEM[(void *)"IEnumerable`1" + 2B];
            D.30555 = *D.30554;
            D.30556 = (int) D.30555;
            D.30557 = __s2 + 2;
            D.30558 = *D.30557;
            D.30559 = (int) D.30558;
            __result = D.30556 - D.30559;
            D.30560 = __s2_len > 2;
            D.30540 = __result == 0;
            D.30561 = D.30560 & D.30540;
            if (D.30561 != 0) goto <D.30562>; else goto <D.30563>;
            <D.30562>:
            D.30564 = &MEM[(void *)"IEnumerable`1" + 3B];
            D.30565 = *D.30564;
            D.30566 = (int) D.30565;
            D.30567 = __s2 + 3;
            D.30568 = *D.30567;
            D.30569 = (int) D.30568;
            __result = D.30566 - D.30569;
            <D.30563>:
            <D.30553>:
            <D.30543>:
          }
          D.27065 = __result;
        }
        iftmp.84 = -D.27065;
        goto <D.30570>;
        <D.30533>:
        D.30369 = klass->name;
        iftmp.84 = __builtin_strcmp (D.30369, "IEnumerable`1");
        <D.30570>:
        D.27066 = iftmp.84;
      }
      if (D.27066 == 0) goto <D.30443>; else goto <D.30571>;
      <D.30571>:
      {
        size_t __s1_len;
        size_t __s2_len;

        __s2_len = 7;
        if (__s2_len <= 3) goto <D.30573>; else goto <D.30574>;
        <D.30573>:
        {
          const unsigned char * __s2;
          int __result;

          __s2 = klass->name;
          D.30575 = "IList`1";
          D.30576 = MEM[(const unsigned char *)D.30575];
          D.30577 = (int) D.30576;
          D.30578 = *__s2;
          D.30579 = (int) D.30578;
          __result = D.30577 - D.30579;
          {
            D.30580 = __s2_len != 0;
            D.30581 = __result == 0;
            D.30582 = D.30580 & D.30581;
            if (D.30582 != 0) goto <D.30583>; else goto <D.30584>;
            <D.30583>:
            D.30585 = &MEM[(void *)"IList`1" + 1B];
            D.30586 = *D.30585;
            D.30587 = (int) D.30586;
            D.30588 = __s2 + 1;
            D.30589 = *D.30588;
            D.30590 = (int) D.30589;
            __result = D.30587 - D.30590;
            D.30591 = __s2_len > 1;
            D.30581 = __result == 0;
            D.30592 = D.30591 & D.30581;
            if (D.30592 != 0) goto <D.30593>; else goto <D.30594>;
            <D.30593>:
            D.30595 = &MEM[(void *)"IList`1" + 2B];
            D.30596 = *D.30595;
            D.30597 = (int) D.30596;
            D.30598 = __s2 + 2;
            D.30599 = *D.30598;
            D.30600 = (int) D.30599;
            __result = D.30597 - D.30600;
            D.30601 = __s2_len > 2;
            D.30581 = __result == 0;
            D.30602 = D.30601 & D.30581;
            if (D.30602 != 0) goto <D.30603>; else goto <D.30604>;
            <D.30603>:
            D.30605 = &MEM[(void *)"IList`1" + 3B];
            D.30606 = *D.30605;
            D.30607 = (int) D.30606;
            D.30608 = __s2 + 3;
            D.30609 = *D.30608;
            D.30610 = (int) D.30609;
            __result = D.30607 - D.30610;
            <D.30604>:
            <D.30594>:
            <D.30584>:
          }
          D.27074 = __result;
        }
        iftmp.85 = -D.27074;
        goto <D.30611>;
        <D.30574>:
        D.30369 = klass->name;
        iftmp.85 = __builtin_strcmp (D.30369, "IList`1");
        <D.30611>:
        D.27075 = iftmp.85;
      }
      if (D.27075 == 0) goto <D.30443>; else goto <D.30612>;
      <D.30612>:
      {
        size_t __s1_len;
        size_t __s2_len;

        __s2_len = 13;
        if (__s2_len <= 3) goto <D.30614>; else goto <D.30615>;
        <D.30614>:
        {
          const unsigned char * __s2;
          int __result;

          __s2 = klass->name;
          D.30616 = "IEnumerator`1";
          D.30617 = MEM[(const unsigned char *)D.30616];
          D.30618 = (int) D.30617;
          D.30619 = *__s2;
          D.30620 = (int) D.30619;
          __result = D.30618 - D.30620;
          {
            D.30621 = __s2_len != 0;
            D.30622 = __result == 0;
            D.30623 = D.30621 & D.30622;
            if (D.30623 != 0) goto <D.30624>; else goto <D.30625>;
            <D.30624>:
            D.30626 = &MEM[(void *)"IEnumerator`1" + 1B];
            D.30627 = *D.30626;
            D.30628 = (int) D.30627;
            D.30629 = __s2 + 1;
            D.30630 = *D.30629;
            D.30631 = (int) D.30630;
            __result = D.30628 - D.30631;
            D.30632 = __s2_len > 1;
            D.30622 = __result == 0;
            D.30633 = D.30632 & D.30622;
            if (D.30633 != 0) goto <D.30634>; else goto <D.30635>;
            <D.30634>:
            D.30636 = &MEM[(void *)"IEnumerator`1" + 2B];
            D.30637 = *D.30636;
            D.30638 = (int) D.30637;
            D.30639 = __s2 + 2;
            D.30640 = *D.30639;
            D.30641 = (int) D.30640;
            __result = D.30638 - D.30641;
            D.30642 = __s2_len > 2;
            D.30622 = __result == 0;
            D.30643 = D.30642 & D.30622;
            if (D.30643 != 0) goto <D.30644>; else goto <D.30645>;
            <D.30644>:
            D.30646 = &MEM[(void *)"IEnumerator`1" + 3B];
            D.30647 = *D.30646;
            D.30648 = (int) D.30647;
            D.30649 = __s2 + 3;
            D.30650 = *D.30649;
            D.30651 = (int) D.30650;
            __result = D.30648 - D.30651;
            <D.30645>:
            <D.30635>:
            <D.30625>:
          }
          D.27083 = __result;
        }
        iftmp.86 = -D.27083;
        goto <D.30652>;
        <D.30615>:
        D.30369 = klass->name;
        iftmp.86 = __builtin_strcmp (D.30369, "IEnumerator`1");
        <D.30652>:
        D.27084 = iftmp.86;
      }
      if (D.27084 == 0) goto <D.30443>; else goto <D.30653>;
      <D.30653>:
      {
        size_t __s1_len;
        size_t __s2_len;

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

          __s2 = klass->name;
          D.30657 = "IReadOnlyList`1";
          D.30658 = MEM[(const unsigned char *)D.30657];
          D.30659 = (int) D.30658;
          D.30660 = *__s2;
          D.30661 = (int) D.30660;
          __result = D.30659 - D.30661;
          {
            D.30662 = __s2_len != 0;
            D.30663 = __result == 0;
            D.30664 = D.30662 & D.30663;
            if (D.30664 != 0) goto <D.30665>; else goto <D.30666>;
            <D.30665>:
            D.30667 = &MEM[(void *)"IReadOnlyList`1" + 1B];
            D.30668 = *D.30667;
            D.30669 = (int) D.30668;
            D.30670 = __s2 + 1;
            D.30671 = *D.30670;
            D.30672 = (int) D.30671;
            __result = D.30669 - D.30672;
            D.30673 = __s2_len > 1;
            D.30663 = __result == 0;
            D.30674 = D.30673 & D.30663;
            if (D.30674 != 0) goto <D.30675>; else goto <D.30676>;
            <D.30675>:
            D.30677 = &MEM[(void *)"IReadOnlyList`1" + 2B];
            D.30678 = *D.30677;
            D.30679 = (int) D.30678;
            D.30680 = __s2 + 2;
            D.30681 = *D.30680;
            D.30682 = (int) D.30681;
            __result = D.30679 - D.30682;
            D.30683 = __s2_len > 2;
            D.30663 = __result == 0;
            D.30684 = D.30683 & D.30663;
            if (D.30684 != 0) goto <D.30685>; else goto <D.30686>;
            <D.30685>:
            D.30687 = &MEM[(void *)"IReadOnlyList`1" + 3B];
            D.30688 = *D.30687;
            D.30689 = (int) D.30688;
            D.30690 = __s2 + 3;
            D.30691 = *D.30690;
            D.30692 = (int) D.30691;
            __result = D.30689 - D.30692;
            <D.30686>:
            <D.30676>:
            <D.30666>:
          }
          D.27092 = __result;
        }
        iftmp.87 = -D.27092;
        goto <D.30693>;
        <D.30656>:
        D.30369 = klass->name;
        iftmp.87 = __builtin_strcmp (D.30369, "IReadOnlyList`1");
        <D.30693>:
        D.27093 = iftmp.87;
      }
      if (D.27093 == 0) goto <D.30443>; else goto <D.30444>;
      <D.30443>:
      {
        struct MonoClass * tclass;
        struct MonoClass * array_class;
        void * iter;
        char * name_prefix;

        try
          {
            D.30279 = klass->generic_class;
            D.30282 = D.30279->context.class_inst;
            D.30694 = D.30282->type_argv[0];
            tclass = mono_class_from_mono_type (D.30694);
            array_class = mono_bounded_array_class_get (tclass, 1, 0);
            {
              size_t __s1_len;
              size_t __s2_len;

              __s2_len = 13;
              if (__s2_len <= 3) goto <D.30696>; else goto <D.30697>;
              <D.30696>:
              {
                const unsigned char * __s2;
                int __result;

                __s2 = klass->name;
                D.30616 = "IEnumerator`1";
                D.30617 = MEM[(const unsigned char *)D.30616];
                D.30618 = (int) D.30617;
                D.30698 = *__s2;
                D.30699 = (int) D.30698;
                __result = D.30618 - D.30699;
                {
                  D.30700 = __s2_len != 0;
                  D.30701 = __result == 0;
                  D.30702 = D.30700 & D.30701;
                  if (D.30702 != 0) goto <D.30703>; else goto <D.30704>;
                  <D.30703>:
                  D.30626 = &MEM[(void *)"IEnumerator`1" + 1B];
                  D.30627 = *D.30626;
                  D.30628 = (int) D.30627;
                  D.30705 = __s2 + 1;
                  D.30706 = *D.30705;
                  D.30707 = (int) D.30706;
                  __result = D.30628 - D.30707;
                  D.30708 = __s2_len > 1;
                  D.30701 = __result == 0;
                  D.30709 = D.30708 & D.30701;
                  if (D.30709 != 0) goto <D.30710>; else goto <D.30711>;
                  <D.30710>:
                  D.30636 = &MEM[(void *)"IEnumerator`1" + 2B];
                  D.30637 = *D.30636;
                  D.30638 = (int) D.30637;
                  D.30712 = __s2 + 2;
                  D.30713 = *D.30712;
                  D.30714 = (int) D.30713;
                  __result = D.30638 - D.30714;
                  D.30715 = __s2_len > 2;
                  D.30701 = __result == 0;
                  D.30716 = D.30715 & D.30701;
                  if (D.30716 != 0) goto <D.30717>; else goto <D.30718>;
                  <D.30717>:
                  D.30646 = &MEM[(void *)"IEnumerator`1" + 3B];
                  D.30647 = *D.30646;
                  D.30648 = (int) D.30647;
                  D.30719 = __s2 + 3;
                  D.30720 = *D.30719;
                  D.30721 = (int) D.30720;
                  __result = D.30648 - D.30721;
                  <D.30718>:
                  <D.30711>:
                  <D.30704>:
                }
                D.27105 = __result;
              }
              iftmp.88 = -D.27105;
              goto <D.30722>;
              <D.30697>:
              D.30369 = klass->name;
              iftmp.88 = __builtin_strcmp (D.30369, "IEnumerator`1");
              <D.30722>:
              D.27106 = iftmp.88;
            }
            if (D.27106 == 0) goto <D.30723>; else goto <D.30724>;
            <D.30723>:
            D.30487 = klass->name_space;
            name_prefix = monoeg_g_strdup_printf ("%s.%s", D.30487, "IEnumerable`1");
            goto <D.30725>;
            <D.30724>:
            D.30487 = klass->name_space;
            D.30369 = klass->name;
            name_prefix = monoeg_g_strdup_printf ("%s.%s", D.30487, D.30369);
            <D.30725>:
            {
              size_t __s1_len;
              size_t __s2_len;

              __s2_len = 13;
              if (__s2_len <= 3) goto <D.30729>; else goto <D.30730>;
              <D.30729>:
              {
                const unsigned char * __s2;
                int __result;

                __s2 = klass->name;
                D.30534 = "IEnumerable`1";
                D.30535 = MEM[(const unsigned char *)D.30534];
                D.30536 = (int) D.30535;
                D.30731 = *__s2;
                D.30732 = (int) D.30731;
                __result = D.30536 - D.30732;
                {
                  D.30733 = __s2_len != 0;
                  D.30734 = __result == 0;
                  D.30735 = D.30733 & D.30734;
                  if (D.30735 != 0) goto <D.30736>; else goto <D.30737>;
                  <D.30736>:
                  D.30544 = &MEM[(void *)"IEnumerable`1" + 1B];
                  D.30545 = *D.30544;
                  D.30546 = (int) D.30545;
                  D.30738 = __s2 + 1;
                  D.30739 = *D.30738;
                  D.30740 = (int) D.30739;
                  __result = D.30546 - D.30740;
                  D.30741 = __s2_len > 1;
                  D.30734 = __result == 0;
                  D.30742 = D.30741 & D.30734;
                  if (D.30742 != 0) goto <D.30743>; else goto <D.30744>;
                  <D.30743>:
                  D.30554 = &MEM[(void *)"IEnumerable`1" + 2B];
                  D.30555 = *D.30554;
                  D.30556 = (int) D.30555;
                  D.30745 = __s2 + 2;
                  D.30746 = *D.30745;
                  D.30747 = (int) D.30746;
                  __result = D.30556 - D.30747;
                  D.30748 = __s2_len > 2;
                  D.30734 = __result == 0;
                  D.30749 = D.30748 & D.30734;
                  if (D.30749 != 0) goto <D.30750>; else goto <D.30751>;
                  <D.30750>:
                  D.30564 = &MEM[(void *)"IEnumerable`1" + 3B];
                  D.30565 = *D.30564;
                  D.30566 = (int) D.30565;
                  D.30752 = __s2 + 3;
                  D.30753 = *D.30752;
                  D.30754 = (int) D.30753;
                  __result = D.30566 - D.30754;
                  <D.30751>:
                  <D.30744>:
                  <D.30737>:
                }
                D.27114 = __result;
              }
              iftmp.89 = -D.27114;
              goto <D.30755>;
              <D.30730>:
              D.30369 = klass->name;
              iftmp.89 = __builtin_strcmp (D.30369, "IEnumerable`1");
              <D.30755>:
              D.27115 = iftmp.89;
            }
            if (D.27115 == 0) goto <D.30726>; else goto <D.30756>;
            <D.30756>:
            {
              size_t __s1_len;
              size_t __s2_len;

              __s2_len = 13;
              if (__s2_len <= 3) goto <D.30758>; else goto <D.30759>;
              <D.30758>:
              {
                const unsigned char * __s2;
                int __result;

                __s2 = klass->name;
                D.30616 = "IEnumerator`1";
                D.30617 = MEM[(const unsigned char *)D.30616];
                D.30618 = (int) D.30617;
                D.30760 = *__s2;
                D.30761 = (int) D.30760;
                __result = D.30618 - D.30761;
                {
                  D.30762 = __s2_len != 0;
                  D.30763 = __result == 0;
                  D.30764 = D.30762 & D.30763;
                  if (D.30764 != 0) goto <D.30765>; else goto <D.30766>;
                  <D.30765>:
                  D.30626 = &MEM[(void *)"IEnumerator`1" + 1B];
                  D.30627 = *D.30626;
                  D.30628 = (int) D.30627;
                  D.30767 = __s2 + 1;
                  D.30768 = *D.30767;
                  D.30769 = (int) D.30768;
                  __result = D.30628 - D.30769;
                  D.30770 = __s2_len > 1;
                  D.30763 = __result == 0;
                  D.30771 = D.30770 & D.30763;
                  if (D.30771 != 0) goto <D.30772>; else goto <D.30773>;
                  <D.30772>:
                  D.30636 = &MEM[(void *)"IEnumerator`1" + 2B];
                  D.30637 = *D.30636;
                  D.30638 = (int) D.30637;
                  D.30774 = __s2 + 2;
                  D.30775 = *D.30774;
                  D.30776 = (int) D.30775;
                  __result = D.30638 - D.30776;
                  D.30777 = __s2_len > 2;
                  D.30763 = __result == 0;
                  D.30778 = D.30777 & D.30763;
                  if (D.30778 != 0) goto <D.30779>; else goto <D.30780>;
                  <D.30779>:
                  D.30646 = &MEM[(void *)"IEnumerator`1" + 3B];
                  D.30647 = *D.30646;
                  D.30648 = (int) D.30647;
                  D.30781 = __s2 + 3;
                  D.30782 = *D.30781;
                  D.30783 = (int) D.30782;
                  __result = D.30648 - D.30783;
                  <D.30780>:
                  <D.30773>:
                  <D.30766>:
                }
                D.27123 = __result;
              }
              iftmp.90 = -D.27123;
              goto <D.30784>;
              <D.30759>:
              D.30369 = klass->name;
              iftmp.90 = __builtin_strcmp (D.30369, "IEnumerator`1");
              <D.30784>:
              D.27124 = iftmp.90;
            }
            if (D.27124 == 0) goto <D.30726>; else goto <D.30727>;
            <D.30726>:
            {
              struct MonoClass * nclass;

              iter = 0B;
              goto <D.27137>;
              <D.27136>:
              {
                size_t __s1_len;
                size_t __s2_len;

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

                  __s2 = nclass->name;
                  D.30788 = "InternalEnumerator`1";
                  D.30789 = MEM[(const unsigned char *)D.30788];
                  D.30790 = (int) D.30789;
                  D.30791 = *__s2;
                  D.30792 = (int) D.30791;
                  __result = D.30790 - D.30792;
                  {
                    D.30793 = __s2_len != 0;
                    D.30794 = __result == 0;
                    D.30795 = D.30793 & D.30794;
                    if (D.30795 != 0) goto <D.30796>; else goto <D.30797>;
                    <D.30796>:
                    D.30798 = &MEM[(void *)"InternalEnumerator`1" + 1B];
                    D.30799 = *D.30798;
                    D.30800 = (int) D.30799;
                    D.30801 = __s2 + 1;
                    D.30802 = *D.30801;
                    D.30803 = (int) D.30802;
                    __result = D.30800 - D.30803;
                    D.30804 = __s2_len > 1;
                    D.30794 = __result == 0;
                    D.30805 = D.30804 & D.30794;
                    if (D.30805 != 0) goto <D.30806>; else goto <D.30807>;
                    <D.30806>:
                    D.30808 = &MEM[(void *)"InternalEnumerator`1" + 2B];
                    D.30809 = *D.30808;
                    D.30810 = (int) D.30809;
                    D.30811 = __s2 + 2;
                    D.30812 = *D.30811;
                    D.30813 = (int) D.30812;
                    __result = D.30810 - D.30813;
                    D.30814 = __s2_len > 2;
                    D.30794 = __result == 0;
                    D.30815 = D.30814 & D.30794;
                    if (D.30815 != 0) goto <D.30816>; else goto <D.30817>;
                    <D.30816>:
                    D.30818 = &MEM[(void *)"InternalEnumerator`1" + 3B];
                    D.30819 = *D.30818;
                    D.30820 = (int) D.30819;
                    D.30821 = __s2 + 3;
                    D.30822 = *D.30821;
                    D.30823 = (int) D.30822;
                    __result = D.30820 - D.30823;
                    <D.30817>:
                    <D.30807>:
                    <D.30797>:
                  }
                  D.27133 = __result;
                }
                iftmp.91 = -D.27133;
                goto <D.30824>;
                <D.30787>:
                D.30825 = nclass->name;
                iftmp.91 = __builtin_strcmp (D.30825, "InternalEnumerator`1");
                <D.30824>:
                D.27134 = iftmp.91;
              }
              if (D.27134 == 0) goto <D.27135>; else goto <D.30826>;
              <D.30826>:
              <D.27137>:
              D.30827 = array_class->parent;
              nclass = mono_class_get_nested_types (D.30827, &iter);
              if (nclass != 0B) goto <D.27136>; else goto <D.27135>;
              <D.27135>:
              D.30828 = nclass == 0B;
              D.30829 = (long int) D.30828;
              D.30830 = __builtin_expect (D.30829, 0);
              if (D.30830 != 0) goto <D.30831>; else goto <D.30832>;
              <D.30831>:
              monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "aot-compiler.c", 3948, "nclass");
              <D.30832>:
              D.30279 = klass->generic_class;
              D.30833 = mono_generic_class_get_context (D.30279);
              nclass = mono_class_inflate_generic_class (nclass, D.30833);
              add_generic_class (acfg, nclass, 0, "ICollection<T>");
            }
            <D.30727>:
            iter = 0B;
            goto <D.27140>;
            <D.27139>:
            D.30834 = method->name;
            D.30835 = strstr (D.30834, name_prefix);
            if (D.30835 != 0B) goto <D.30836>; else goto <D.30837>;
            <D.30836>:
            {
              struct MonoMethod * m;

              m = mono_aot_get_array_helper_from_wrapper (method);
              add_extra_method_with_depth (acfg, m, depth);
            }
            <D.30837>:
            <D.27140>:
            method = mono_class_get_methods (array_class, &iter);
            if (method != 0B) goto <D.27139>; else goto <D.27141>;
            <D.27141>:
            monoeg_g_free (name_prefix);
          }
        finally
          {
            iter = {CLOBBER};
          }
      }
      <D.30444>:
      <D.30489>:
      <D.30446>:
      D.30318 = klass->image;
      D.30319 = mono_defaults.corlib;
      if (D.30318 == D.30319) goto <D.30838>; else goto <D.30839>;
      <D.30838>:
      {
        size_t __s1_len;
        size_t __s2_len;

        __s2_len = 26;
        if (__s2_len <= 3) goto <D.30841>; else goto <D.30842>;
        <D.30841>:
        {
          const unsigned char * __s2;
          int __result;

          __s2 = klass->name_space;
          D.30450 = "System.Collections.Generic";
          D.30451 = MEM[(const unsigned char *)D.30450];
          D.30452 = (int) D.30451;
          D.30843 = *__s2;
          D.30844 = (int) D.30843;
          __result = D.30452 - D.30844;
          {
            D.30845 = __s2_len != 0;
            D.30846 = __result == 0;
            D.30847 = D.30845 & D.30846;
            if (D.30847 != 0) goto <D.30848>; else goto <D.30849>;
            <D.30848>:
            D.30460 = &MEM[(void *)"System.Collections.Generic" + 1B];
            D.30461 = *D.30460;
            D.30462 = (int) D.30461;
            D.30850 = __s2 + 1;
            D.30851 = *D.30850;
            D.30852 = (int) D.30851;
            __result = D.30462 - D.30852;
            D.30853 = __s2_len > 1;
            D.30846 = __result == 0;
            D.30854 = D.30853 & D.30846;
            if (D.30854 != 0) goto <D.30855>; else goto <D.30856>;
            <D.30855>:
            D.30470 = &MEM[(void *)"System.Collections.Generic" + 2B];
            D.30471 = *D.30470;
            D.30472 = (int) D.30471;
            D.30857 = __s2 + 2;
            D.30858 = *D.30857;
            D.30859 = (int) D.30858;
            __result = D.30472 - D.30859;
            D.30860 = __s2_len > 2;
            D.30846 = __result == 0;
            D.30861 = D.30860 & D.30846;
            if (D.30861 != 0) goto <D.30862>; else goto <D.30863>;
            <D.30862>:
            D.30480 = &MEM[(void *)"System.Collections.Generic" + 3B];
            D.30481 = *D.30480;
            D.30482 = (int) D.30481;
            D.30864 = __s2 + 3;
            D.30865 = *D.30864;
            D.30866 = (int) D.30865;
            __result = D.30482 - D.30866;
            <D.30863>:
            <D.30856>:
            <D.30849>:
          }
          D.27149 = __result;
        }
        iftmp.92 = -D.27149;
        goto <D.30867>;
        <D.30842>:
        D.30487 = klass->name_space;
        iftmp.92 = __builtin_strcmp (D.30487, "System.Collections.Generic");
        <D.30867>:
        D.27150 = iftmp.92;
      }
      if (D.27150 == 0) goto <D.30868>; else goto <D.30869>;
      <D.30868>:
      {
        size_t __s1_len;
        size_t __s2_len;

        __s2_len = 10;
        if (__s2_len <= 3) goto <D.30871>; else goto <D.30872>;
        <D.30871>:
        {
          const unsigned char * __s2;
          int __result;

          __s2 = klass->name;
          D.30873 = "Comparer`1";
          D.30874 = MEM[(const unsigned char *)D.30873];
          D.30875 = (int) D.30874;
          D.30876 = *__s2;
          D.30877 = (int) D.30876;
          __result = D.30875 - D.30877;
          {
            D.30878 = __s2_len != 0;
            D.30879 = __result == 0;
            D.30880 = D.30878 & D.30879;
            if (D.30880 != 0) goto <D.30881>; else goto <D.30882>;
            <D.30881>:
            D.30883 = &MEM[(void *)"Comparer`1" + 1B];
            D.30884 = *D.30883;
            D.30885 = (int) D.30884;
            D.30886 = __s2 + 1;
            D.30887 = *D.30886;
            D.30888 = (int) D.30887;
            __result = D.30885 - D.30888;
            D.30889 = __s2_len > 1;
            D.30879 = __result == 0;
            D.30890 = D.30889 & D.30879;
            if (D.30890 != 0) goto <D.30891>; else goto <D.30892>;
            <D.30891>:
            D.30893 = &MEM[(void *)"Comparer`1" + 2B];
            D.30894 = *D.30893;
            D.30895 = (int) D.30894;
            D.30896 = __s2 + 2;
            D.30897 = *D.30896;
            D.30898 = (int) D.30897;
            __result = D.30895 - D.30898;
            D.30899 = __s2_len > 2;
            D.30879 = __result == 0;
            D.30900 = D.30899 & D.30879;
            if (D.30900 != 0) goto <D.30901>; else goto <D.30902>;
            <D.30901>:
            D.30903 = &MEM[(void *)"Comparer`1" + 3B];
            D.30904 = *D.30903;
            D.30905 = (int) D.30904;
            D.30906 = __s2 + 3;
            D.30907 = *D.30906;
            D.30908 = (int) D.30907;
            __result = D.30905 - D.30908;
            <D.30902>:
            <D.30892>:
            <D.30882>:
          }
          D.27158 = __result;
        }
        iftmp.93 = -D.27158;
        goto <D.30909>;
        <D.30872>:
        D.30369 = klass->name;
        iftmp.93 = __builtin_strcmp (D.30369, "Comparer`1");
        <D.30909>:
        D.27159 = iftmp.93;
      }
      if (D.27159 == 0) goto <D.30910>; else goto <D.30911>;
      <D.30910>:
      {
        struct MonoClass * tclass;
        struct MonoClass * icomparable;
        struct MonoClass * gcomparer;
        struct MonoGenericContext ctx;
        struct MonoType * args[16];

        try
          {
            D.30279 = klass->generic_class;
            D.30282 = D.30279->context.class_inst;
            D.30694 = D.30282->type_argv[0];
            tclass = mono_class_from_mono_type (D.30694);
            memset (&ctx, 0, 8);
            D.30319 = mono_defaults.corlib;
            icomparable = mono_class_from_name (D.30319, "System", "IComparable`1");
            D.30912 = icomparable == 0B;
            D.30913 = (long int) D.30912;
            D.30914 = __builtin_expect (D.30913, 0);
            if (D.30914 != 0) goto <D.30915>; else goto <D.30916>;
            <D.30915>:
            monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "aot-compiler.c", 3975, "icomparable");
            <D.30916>:
            D.30917 = &tclass->byval_arg;
            args[0] = D.30917;
            D.30918 = mono_metadata_get_generic_inst (1, &args);
            ctx.class_inst = D.30918;
            D.30919 = mono_class_inflate_generic_class (icomparable, &ctx);
            D.30920 = mono_class_is_assignable_from (D.30919, tclass);
            if (D.30920 != 0) goto <D.30921>; else goto <D.30922>;
            <D.30921>:
            D.30319 = mono_defaults.corlib;
            gcomparer = mono_class_from_name (D.30319, "System.Collections.Generic", "GenericComparer`1");
            D.30923 = gcomparer == 0B;
            D.30924 = (long int) D.30923;
            D.30925 = __builtin_expect (D.30924, 0);
            if (D.30925 != 0) goto <D.30926>; else goto <D.30927>;
            <D.30926>:
            monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "aot-compiler.c", 3981, "gcomparer");
            <D.30927>:
            D.30928 = mono_class_inflate_generic_class (gcomparer, &ctx);
            add_generic_class (acfg, D.30928, 0, "Comparer<T>");
            <D.30922>:
          }
        finally
          {
            ctx = {CLOBBER};
            args = {CLOBBER};
          }
      }
      <D.30911>:
      <D.30869>:
      <D.30839>:
      D.30318 = klass->image;
      D.30319 = mono_defaults.corlib;
      if (D.30318 == D.30319) goto <D.30929>; else goto <D.30930>;
      <D.30929>:
      {
        size_t __s1_len;
        size_t __s2_len;

        __s2_len = 26;
        if (__s2_len <= 3) goto <D.30932>; else goto <D.30933>;
        <D.30932>:
        {
          const unsigned char * __s2;
          int __result;

          __s2 = klass->name_space;
          D.30450 = "System.Collections.Generic";
          D.30451 = MEM[(const unsigned char *)D.30450];
          D.30452 = (int) D.30451;
          D.30934 = *__s2;
          D.30935 = (int) D.30934;
          __result = D.30452 - D.30935;
          {
            D.30936 = __s2_len != 0;
            D.30937 = __result == 0;
            D.30938 = D.30936 & D.30937;
            if (D.30938 != 0) goto <D.30939>; else goto <D.30940>;
            <D.30939>:
            D.30460 = &MEM[(void *)"System.Collections.Generic" + 1B];
            D.30461 = *D.30460;
            D.30462 = (int) D.30461;
            D.30941 = __s2 + 1;
            D.30942 = *D.30941;
            D.30943 = (int) D.30942;
            __result = D.30462 - D.30943;
            D.30944 = __s2_len > 1;
            D.30937 = __result == 0;
            D.30945 = D.30944 & D.30937;
            if (D.30945 != 0) goto <D.30946>; else goto <D.30947>;
            <D.30946>:
            D.30470 = &MEM[(void *)"System.Collections.Generic" + 2B];
            D.30471 = *D.30470;
            D.30472 = (int) D.30471;
            D.30948 = __s2 + 2;
            D.30949 = *D.30948;
            D.30950 = (int) D.30949;
            __result = D.30472 - D.30950;
            D.30951 = __s2_len > 2;
            D.30937 = __result == 0;
            D.30952 = D.30951 & D.30937;
            if (D.30952 != 0) goto <D.30953>; else goto <D.30954>;
            <D.30953>:
            D.30480 = &MEM[(void *)"System.Collections.Generic" + 3B];
            D.30481 = *D.30480;
            D.30482 = (int) D.30481;
            D.30955 = __s2 + 3;
            D.30956 = *D.30955;
            D.30957 = (int) D.30956;
            __result = D.30482 - D.30957;
            <D.30954>:
            <D.30947>:
            <D.30940>:
          }
          D.27172 = __result;
        }
        iftmp.94 = -D.27172;
        goto <D.30958>;
        <D.30933>:
        D.30487 = klass->name_space;
        iftmp.94 = __builtin_strcmp (D.30487, "System.Collections.Generic");
        <D.30958>:
        D.27173 = iftmp.94;
      }
      if (D.27173 == 0) goto <D.30959>; else goto <D.30960>;
      <D.30959>:
      {
        size_t __s1_len;
        size_t __s2_len;

        __s2_len = 18;
        if (__s2_len <= 3) goto <D.30962>; else goto <D.30963>;
        <D.30962>:
        {
          const unsigned char * __s2;
          int __result;

          __s2 = klass->name;
          D.30964 = "EqualityComparer`1";
          D.30965 = MEM[(const unsigned char *)D.30964];
          D.30966 = (int) D.30965;
          D.30967 = *__s2;
          D.30968 = (int) D.30967;
          __result = D.30966 - D.30968;
          {
            D.30969 = __s2_len != 0;
            D.30970 = __result == 0;
            D.30971 = D.30969 & D.30970;
            if (D.30971 != 0) goto <D.30972>; else goto <D.30973>;
            <D.30972>:
            D.30974 = &MEM[(void *)"EqualityComparer`1" + 1B];
            D.30975 = *D.30974;
            D.30976 = (int) D.30975;
            D.30977 = __s2 + 1;
            D.30978 = *D.30977;
            D.30979 = (int) D.30978;
            __result = D.30976 - D.30979;
            D.30980 = __s2_len > 1;
            D.30970 = __result == 0;
            D.30981 = D.30980 & D.30970;
            if (D.30981 != 0) goto <D.30982>; else goto <D.30983>;
            <D.30982>:
            D.30984 = &MEM[(void *)"EqualityComparer`1" + 2B];
            D.30985 = *D.30984;
            D.30986 = (int) D.30985;
            D.30987 = __s2 + 2;
            D.30988 = *D.30987;
            D.30989 = (int) D.30988;
            __result = D.30986 - D.30989;
            D.30990 = __s2_len > 2;
            D.30970 = __result == 0;
            D.30991 = D.30990 & D.30970;
            if (D.30991 != 0) goto <D.30992>; else goto <D.30993>;
            <D.30992>:
            D.30994 = &MEM[(void *)"EqualityComparer`1" + 3B];
            D.30995 = *D.30994;
            D.30996 = (int) D.30995;
            D.30997 = __s2 + 3;
            D.30998 = *D.30997;
            D.30999 = (int) D.30998;
            __result = D.30996 - D.30999;
            <D.30993>:
            <D.30983>:
            <D.30973>:
          }
          D.27181 = __result;
        }
        iftmp.95 = -D.27181;
        goto <D.31000>;
        <D.30963>:
        D.30369 = klass->name;
        iftmp.95 = __builtin_strcmp (D.30369, "EqualityComparer`1");
        <D.31000>:
        D.27182 = iftmp.95;
      }
      if (D.27182 == 0) goto <D.31001>; else goto <D.31002>;
      <D.31001>:
      {
        struct MonoClass * tclass;
        struct MonoClass * iface;
        struct MonoClass * gcomparer;
        struct MonoGenericContext ctx;
        struct MonoType * args[16];

        try
          {
            D.30279 = klass->generic_class;
            D.30282 = D.30279->context.class_inst;
            D.30694 = D.30282->type_argv[0];
            tclass = mono_class_from_mono_type (D.30694);
            memset (&ctx, 0, 8);
            D.30319 = mono_defaults.corlib;
            iface = mono_class_from_name (D.30319, "System", "IEquatable`1");
            D.31003 = iface == 0B;
            D.31004 = (long int) D.31003;
            D.31005 = __builtin_expect (D.31004, 0);
            if (D.31005 != 0) goto <D.31006>; else goto <D.31007>;
            <D.31006>:
            monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "aot-compiler.c", 3996, "iface");
            <D.31007>:
            D.31008 = &tclass->byval_arg;
            args[0] = D.31008;
            D.31009 = mono_metadata_get_generic_inst (1, &args);
            ctx.class_inst = D.31009;
            D.31010 = mono_class_inflate_generic_class (iface, &ctx);
            D.31011 = mono_class_is_assignable_from (D.31010, tclass);
            if (D.31011 != 0) goto <D.31012>; else goto <D.31013>;
            <D.31012>:
            D.30319 = mono_defaults.corlib;
            gcomparer = mono_class_from_name (D.30319, "System.Collections.Generic", "GenericEqualityComparer`1");
            D.31014 = gcomparer == 0B;
            D.31015 = (long int) D.31014;
            D.31016 = __builtin_expect (D.31015, 0);
            if (D.31016 != 0) goto <D.31017>; else goto <D.31018>;
            <D.31017>:
            monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "aot-compiler.c", 4002, "gcomparer");
            <D.31018>:
            D.31019 = mono_class_inflate_generic_class (gcomparer, &ctx);
            add_generic_class (acfg, D.31019, 0, "EqualityComparer<T>");
            <D.31013>:
          }
        finally
          {
            ctx = {CLOBBER};
            args = {CLOBBER};
          }
      }
      <D.31002>:
      <D.30960>:
      <D.30930>:
    }
  finally
    {
      iter = {CLOBBER};
    }
}


has_type_vars (struct MonoClass * klass)
{
  unsigned char D.31023;
  _Bool D.31024;
  _Bool D.31025;
  _Bool D.31026;
  gboolean D.31029;
  unsigned char D.31030;
  struct MonoClass * D.31033;
  struct MonoGenericClass * D.31034;
  struct MonoGenericInst * D.31037;
  struct MonoType * D.31040;
  struct MonoClass * D.31041;
  int D.31042;
  <unnamed-unsigned:22> D.31045;
  int D.31046;
  struct MonoGenericContainer * D.31047;

  D.31023 = klass->byval_arg.type;
  D.31024 = D.31023 == 19;
  D.31025 = D.31023 == 30;
  D.31026 = D.31024 | D.31025;
  if (D.31026 != 0) goto <D.31027>; else goto <D.31028>;
  <D.31027>:
  D.31029 = 1;
  return D.31029;
  <D.31028>:
  D.31030 = klass->rank;
  if (D.31030 != 0) goto <D.31031>; else goto <D.31032>;
  <D.31031>:
  D.31033 = klass->element_class;
  D.31029 = has_type_vars (D.31033);
  return D.31029;
  <D.31032>:
  D.31034 = klass->generic_class;
  if (D.31034 != 0B) goto <D.31035>; else goto <D.31036>;
  <D.31035>:
  {
    struct MonoGenericContext * context;

    D.31034 = klass->generic_class;
    context = &D.31034->context;
    D.31037 = context->class_inst;
    if (D.31037 != 0B) goto <D.31038>; else goto <D.31039>;
    <D.31038>:
    {
      int i;

      i = 0;
      goto <D.26961>;
      <D.26960>:
      D.31037 = context->class_inst;
      D.31040 = D.31037->type_argv[i];
      D.31041 = mono_class_from_mono_type (D.31040);
      D.31042 = has_type_vars (D.31041);
      if (D.31042 != 0) goto <D.31043>; else goto <D.31044>;
      <D.31043>:
      D.31029 = 1;
      return D.31029;
      <D.31044>:
      i = i + 1;
      <D.26961>:
      D.31037 = context->class_inst;
      D.31045 = D.31037->type_argc;
      D.31046 = (int) D.31045;
      if (D.31046 > i) goto <D.26960>; else goto <D.26962>;
      <D.26962>:
    }
    <D.31039>:
  }
  <D.31036>:
  D.31047 = klass->generic_container;
  if (D.31047 != 0B) goto <D.31048>; else goto <D.31049>;
  <D.31048>:
  D.31029 = 1;
  return D.31029;
  <D.31049>:
  D.31029 = 0;
  return D.31029;
}


check_type_depth (struct MonoType * t, int depth)
{
  gboolean D.31053;
  unsigned char D.31054;
  int D.31055;
  struct MonoType * D.31058;
  int D.31059;
  int D.31060;
  <unnamed-unsigned:22> D.31063;
  int D.31064;
  int i;

  if (depth > 8) goto <D.31051>; else goto <D.31052>;
  <D.31051>:
  D.31053 = 1;
  return D.31053;
  <D.31052>:
  D.31054 = t->type;
  D.31055 = (int) D.31054;
  switch (D.31055) <default: <D.27002>, case 21: <D.26995>>
  <D.26995>:
  {
    struct MonoGenericClass * gklass;
    struct MonoGenericInst * ginst;

    gklass = t->data.generic_class;
    ginst = gklass->context.class_inst;
    if (ginst != 0B) goto <D.31056>; else goto <D.31057>;
    <D.31056>:
    i = 0;
    goto <D.26999>;
    <D.26998>:
    D.31058 = ginst->type_argv[i];
    D.31059 = depth + 1;
    D.31060 = check_type_depth (D.31058, D.31059);
    if (D.31060 != 0) goto <D.31061>; else goto <D.31062>;
    <D.31061>:
    D.31053 = 1;
    return D.31053;
    <D.31062>:
    i = i + 1;
    <D.26999>:
    D.31063 = ginst->type_argc;
    D.31064 = (int) D.31063;
    if (D.31064 > i) goto <D.26998>; else goto <D.27000>;
    <D.27000>:
    <D.31057>:
    goto <D.27001>;
  }
  <D.27002>:
  goto <D.27001>;
  <D.27001>:
  D.31053 = 0;
  return D.31053;
}


is_vt_inst (struct MonoGenericInst * inst)
{
  unsigned char D.31067;
  gboolean D.31070;
  <unnamed-unsigned:22> D.31071;
  int D.31072;
  int i;

  i = 0;
  goto <D.26969>;
  <D.26968>:
  {
    struct MonoType * t;

    t = inst->type_argv[i];
    D.31067 = t->type;
    if (D.31067 == 17) goto <D.31068>; else goto <D.31069>;
    <D.31068>:
    D.31070 = 1;
    return D.31070;
    <D.31069>:
  }
  i = i + 1;
  <D.26969>:
  D.31071 = inst->type_argc;
  D.31072 = (int) D.31071;
  if (D.31072 > i) goto <D.26968>; else goto <D.26970>;
  <D.26970>:
  D.31070 = 0;
  return D.31070;
}


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

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


add_types_from_method_header (struct MonoAotCompile * acfg, struct MonoMethod * method)
{
  struct GHashTable * D.31076;
  void * D.31077;
  struct MonoType * D.31080;
  unsigned char D.31081;
  struct MonoClass * D.31084;
  int D.31085;
  short unsigned int D.31086;
  int D.31087;
  struct MonoType * D.31090;
  unsigned char D.31091;
  struct MonoClass * D.31094;
  short unsigned int D.31095;
  int D.31096;
  struct MonoMethodHeader * header;
  struct MonoMethodSignature * sig;
  int j;
  int depth;

  D.31076 = acfg->method_depth;
  D.31077 = monoeg_g_hash_table_lookup (D.31076, method);
  depth = (int) D.31077;
  sig = mono_method_signature (method);
  if (sig != 0B) goto <D.31078>; else goto <D.31079>;
  <D.31078>:
  j = 0;
  goto <D.27210>;
  <D.27209>:
  D.31080 = sig->params[j];
  D.31081 = D.31080->type;
  if (D.31081 == 21) goto <D.31082>; else goto <D.31083>;
  <D.31082>:
  D.31080 = sig->params[j];
  D.31084 = mono_class_from_mono_type (D.31080);
  D.31085 = depth + 1;
  add_generic_class_with_depth (acfg, D.31084, D.31085, "arg");
  <D.31083>:
  j = j + 1;
  <D.27210>:
  D.31086 = sig->param_count;
  D.31087 = (int) D.31086;
  if (D.31087 > j) goto <D.27209>; else goto <D.27211>;
  <D.27211>:
  <D.31079>:
  header = mono_method_get_header (method);
  if (header != 0B) goto <D.31088>; else goto <D.31089>;
  <D.31088>:
  j = 0;
  goto <D.27213>;
  <D.27212>:
  D.31090 = header->locals[j];
  D.31091 = D.31090->type;
  if (D.31091 == 21) goto <D.31092>; else goto <D.31093>;
  <D.31092>:
  D.31090 = header->locals[j];
  D.31094 = mono_class_from_mono_type (D.31090);
  D.31085 = depth + 1;
  add_generic_class_with_depth (acfg, D.31094, D.31085, "local");
  <D.31093>:
  j = j + 1;
  <D.27213>:
  D.31095 = header->num_locals;
  D.31096 = (int) D.31095;
  if (D.31096 > j) goto <D.27212>; else goto <D.27214>;
  <D.27214>:
  goto <D.31097>;
  <D.31089>:
  mono_loader_clear_error ();
  <D.31097>:
}


add_instances_of (struct MonoAotCompile * acfg, struct MonoClass * klass, struct MonoType * * insts, int ninsts, gboolean force)
{
  int D.31098;
  unsigned int i.96;
  unsigned int D.31102;
  struct MonoType * * D.31103;
  struct MonoType * D.31104;
  struct MonoGenericInst * D.31105;
  struct MonoClass * D.31106;
  int i;
  struct MonoGenericContext ctx;
  struct MonoType * args[16];

  try
    {
      D.31098 = acfg->aot_opts.no_instances;
      if (D.31098 != 0) goto <D.31099>; else goto <D.31100>;
      <D.31099>:
      return;
      <D.31100>:
      memset (&ctx, 0, 8);
      i = 0;
      goto <D.27199>;
      <D.27198>:
      i.96 = (unsigned int) i;
      D.31102 = i.96 * 4;
      D.31103 = insts + D.31102;
      D.31104 = *D.31103;
      args[0] = D.31104;
      D.31105 = mono_metadata_get_generic_inst (1, &args);
      ctx.class_inst = D.31105;
      D.31106 = mono_class_inflate_generic_class (klass, &ctx);
      add_generic_class (acfg, D.31106, force, "");
      i = i + 1;
      <D.27199>:
      if (i < ninsts) goto <D.27198>; else goto <D.27200>;
      <D.27200>:
    }
  finally
    {
      ctx = {CLOBBER};
      args = {CLOBBER};
    }
}


add_wrappers (struct MonoAotCompile * acfg)
{
  int D.31110;
  int D.31111;
  struct MonoImage * D.31112;
  short unsigned int D.31115;
  int D.31116;
  int D.31117;
  short unsigned int D.31119;
  int D.31120;
  int D.31121;
  int D.31123;
  struct MonoType * D.31126;
  unsigned char D.31127;
  _Bool D.31128;
  _Bool D.31129;
  _Bool D.31130;
  int D.31133;
  struct MonoType * D.31136;
  unsigned char D.31137;
  int D.31140;
  short unsigned int D.31143;
  int D.31144;
  struct MonoClass * D.31145;
  unsigned char D.31146;
  unsigned char D.31147;
  struct MonoClass * D.31152;
  int D.31153;
  _Bool D.31156;
  _Bool D.31157;
  _Bool D.31158;
  struct MonoMethod * D.31163;
  <unnamed-unsigned:24> D.31164;
  int D.31165;
  int D.26835;
  int iftmp.97;
  int D.26834;
  struct MonoAssembly * D.31169;
  const char[9] * D.31170;
  unsigned char D.31171;
  int D.31172;
  unsigned char D.31173;
  int D.31174;
  _Bool D.31175;
  _Bool D.31176;
  _Bool D.31177;
  const unsigned char * D.31180;
  unsigned char D.31181;
  int D.31182;
  const unsigned char * D.31183;
  unsigned char D.31184;
  int D.31185;
  _Bool D.31186;
  _Bool D.31187;
  const unsigned char * D.31190;
  unsigned char D.31191;
  int D.31192;
  const unsigned char * D.31193;
  unsigned char D.31194;
  int D.31195;
  _Bool D.31196;
  _Bool D.31197;
  const unsigned char * D.31200;
  unsigned char D.31201;
  int D.31202;
  const unsigned char * D.31203;
  unsigned char D.31204;
  int D.31205;
  const char * D.31207;
  struct MonoImage * D.31210;
  struct MonoClass * D.31211;
  struct MonoType * D.31212;
  struct MonoMethod * D.31213;
  struct MonoMethod * D.31214;
  struct MonoClass * D.31215;
  struct MonoType * D.31216;
  struct MonoMethod * D.31217;
  struct MonoMethod * D.31218;
  struct MonoMethod * D.31219;
  struct MonoClass * D.31220;
  struct MonoType * D.31221;
  struct MonoMethod * D.31222;
  struct MonoClass * D.31223;
  struct MonoType * D.31224;
  struct MonoClass * D.31225;
  struct MonoType * D.31226;
  struct MonoMethod * D.31227;
  struct MonoClass * D.31228;
  struct MonoMethod * D.31229;
  struct MonoMethod * D.31230;
  struct MonoMethod * D.31233;
  struct MonoMethod * D.31234;
  struct MonoMethod * D.31235;
  unsigned int D.31238;
  struct MonoClass * D.31241;
  _Bool D.31246;
  long int D.31247;
  long int D.31248;
  unsigned int i.98;
  unsigned int D.31254;
  struct MonoMethod * * D.31255;
  struct MonoMethod * D.31256;
  int nwrappers.99;
  struct MonoMethod * D.31258;
  struct MonoMethod * D.31259;
  struct GHashTable * D.31260;
  int D.31261;
  unsigned char D.31266;
  unsigned char D.31267;
  struct MonoClass * D.31269;
  struct MonoClass * D.31271;
  struct MonoGenericContainer * D.31272;
  struct MonoMethod * D.31277;
  struct MonoMethod * D.31280;
  struct MonoMethod * D.31283;
  int D.26859;
  int iftmp.100;
  int D.26858;
  struct MonoClass * D.31289;
  const char[35] * D.31290;
  unsigned char D.31291;
  int D.31292;
  unsigned char D.31293;
  int D.31294;
  _Bool D.31295;
  _Bool D.31296;
  _Bool D.31297;
  const unsigned char * D.31300;
  unsigned char D.31301;
  int D.31302;
  const unsigned char * D.31303;
  unsigned char D.31304;
  int D.31305;
  _Bool D.31306;
  _Bool D.31307;
  const unsigned char * D.31310;
  unsigned char D.31311;
  int D.31312;
  const unsigned char * D.31313;
  unsigned char D.31314;
  int D.31315;
  _Bool D.31316;
  _Bool D.31317;
  const unsigned char * D.31320;
  unsigned char D.31321;
  int D.31322;
  const unsigned char * D.31323;
  unsigned char D.31324;
  int D.31325;
  const char * D.31327;
  int D.26868;
  int iftmp.101;
  int D.26867;
  const char[34] * D.31332;
  unsigned char D.31333;
  int D.31334;
  unsigned char D.31335;
  int D.31336;
  _Bool D.31337;
  _Bool D.31338;
  _Bool D.31339;
  const unsigned char * D.31342;
  unsigned char D.31343;
  int D.31344;
  const unsigned char * D.31345;
  unsigned char D.31346;
  int D.31347;
  _Bool D.31348;
  _Bool D.31349;
  const unsigned char * D.31352;
  unsigned char D.31353;
  int D.31354;
  const unsigned char * D.31355;
  unsigned char D.31356;
  int D.31357;
  _Bool D.31358;
  _Bool D.31359;
  const unsigned char * D.31362;
  unsigned char D.31363;
  int D.31364;
  const unsigned char * D.31365;
  unsigned char D.31366;
  int D.31367;
  int D.31370;
  struct MonoMethod * D.31373;
  unsigned int D.31375;
  unsigned int D.31376;
  unsigned char D.31381;
  unsigned char D.31382;
  _Bool D.31383;
  long int D.31384;
  long int D.31385;
  <unnamed-unsigned:24> D.31392;
  int D.31393;
  int D.31394;
  unsigned char D.31397;
  struct MonoClass * D.31400;
  unsigned char D.31401;
  unsigned char D.31402;
  unsigned char D.31405;
  unsigned char D.31406;
  _Bool D.31407;
  unsigned char D.31408;
  _Bool D.31409;
  _Bool D.31410;
  _Bool D.31413;
  long int D.31414;
  long int D.31415;
  struct MonoMethod * D.31418;
  struct MonoMethod * D.31421;
  <unnamed-unsigned:24> D.31422;
  int D.31423;
  short unsigned int D.31424;
  int D.31425;
  int D.31426;
  unsigned char D.31429;
  unsigned char D.31430;
  struct MonoClass * D.31434;
  struct MonoGenericContainer * D.31435;
  unsigned char D.31438;
  unsigned char D.31439;
  _Bool D.31440;
  long int D.31441;
  long int D.31442;
  struct MonoMethod * D.31446;
  short unsigned int D.31449;
  int D.31450;
  int D.31451;
  short unsigned int D.31453;
  int D.31454;
  int D.31455;
  struct MonoMethod * D.31456;
  struct MonoMethod * D.31459;
  int D.26909;
  int iftmp.102;
  int D.26908;
  struct MonoClass * D.31465;
  const char[29] * D.31466;
  unsigned char D.31467;
  int D.31468;
  unsigned char D.31469;
  int D.31470;
  _Bool D.31471;
  _Bool D.31472;
  _Bool D.31473;
  const unsigned char * D.31476;
  unsigned char D.31477;
  int D.31478;
  const unsigned char * D.31479;
  unsigned char D.31480;
  int D.31481;
  _Bool D.31482;
  _Bool D.31483;
  const unsigned char * D.31486;
  unsigned char D.31487;
  int D.31488;
  const unsigned char * D.31489;
  unsigned char D.31490;
  int D.31491;
  _Bool D.31492;
  _Bool D.31493;
  const unsigned char * D.31496;
  unsigned char D.31497;
  int D.31498;
  const unsigned char * D.31499;
  unsigned char D.31500;
  int D.31501;
  const char * D.31503;
  int D.31505;
  struct MonoMethod * D.31508;
  const mono_byte * p.103;
  short unsigned int D.31510;
  int D.31511;
  int D.31512;
  char * D.31515;
  short unsigned int D.31516;
  _Bool D.31517;
  long int D.31518;
  long int D.31519;
  int iftmp.104;
  struct MonoType * D.31526;
  unsigned char D.31527;
  int D.26934;
  int iftmp.105;
  int D.26933;
  struct MonoClass * D.31532;
  const char[5] * D.31533;
  unsigned char D.31534;
  int D.31535;
  unsigned char D.31536;
  int D.31537;
  _Bool D.31538;
  _Bool D.31539;
  _Bool D.31540;
  const unsigned char * D.31543;
  unsigned char D.31544;
  int D.31545;
  const unsigned char * D.31546;
  unsigned char D.31547;
  int D.31548;
  _Bool D.31549;
  _Bool D.31550;
  const unsigned char * D.31553;
  unsigned char D.31554;
  int D.31555;
  const unsigned char * D.31556;
  unsigned char D.31557;
  int D.31558;
  _Bool D.31559;
  _Bool D.31560;
  const unsigned char * D.31563;
  unsigned char D.31564;
  int D.31565;
  const unsigned char * D.31566;
  unsigned char D.31567;
  int D.31568;
  struct MonoClass * D.31570;
  const char * D.31571;
  _Bool D.31572;
  long int D.31573;
  long int D.31574;
  const char * p.106;
  const char * p.107;
  unsigned int D.31579;
  int D.31580;
  unsigned int D.31581;
  sizetype slen.108;
  char * D.31583;
  _Bool D.31584;
  long int D.31585;
  long int D.31586;
  struct MonoClass * D.31589;
  _Bool D.31590;
  long int D.31591;
  long int D.31592;
  const char * p.109;
  short unsigned int D.31596;
  _Bool D.31597;
  long int D.31598;
  long int D.31599;
  const char * named.110;
  char D.31605;
  const char * named.111;
  unsigned int D.31607;
  int D.31608;
  unsigned int D.31609;
  unsigned int name_len.112;
  sizetype name_len.113;
  char * D.31612;
  const char * named.114;
  _Bool D.31614;
  long int D.31615;
  long int D.31616;
  int D.26946;
  int iftmp.115;
  int D.26945;
  const char[13] * D.31622;
  unsigned char D.31623;
  int D.31624;
  unsigned char D.31625;
  int D.31626;
  _Bool D.31627;
  _Bool D.31628;
  _Bool D.31629;
  const unsigned char * D.31632;
  unsigned char D.31633;
  int D.31634;
  const unsigned char * D.31635;
  unsigned char D.31636;
  int D.31637;
  _Bool D.31638;
  _Bool D.31639;
  const unsigned char * D.31642;
  unsigned char D.31643;
  int D.31644;
  const unsigned char * D.31645;
  unsigned char D.31646;
  int D.31647;
  _Bool D.31648;
  _Bool D.31649;
  const unsigned char * D.31652;
  unsigned char D.31653;
  int D.31654;
  const unsigned char * D.31655;
  unsigned char D.31656;
  int D.31657;
  _Bool D.31659;
  long int D.31660;
  long int D.31661;
  _Bool D.31664;
  long int D.31665;
  long int D.31666;
  unsigned int D.31669;
  unsigned int D.31670;
  unsigned int slen.116;
  char * D.31672;
  const char * named.117;
  struct GHashTable * D.31676;
  int D.31679;
  short unsigned int D.31681;
  int D.31682;
  int D.31683;
  struct MonoMethod * D.31684;
  unsigned char D.31689;
  unsigned char D.31690;
  struct MonoGenericContainer * D.31693;
  int D.31696;
  struct MonoClass * D.31699;
  const char * D.31701;
  char * D.31702;
  struct MonoMethod * D.31703;
  struct MonoMethod * D.31704;
  struct MonoMethod * method;
  struct MonoMethod * m;
  int i;
  int j;
  struct MonoMethodSignature * sig;
  struct MonoMethodSignature * csig;
  guint32 token;

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

    D.31110 = i + 1;
    D.31111 = D.31110 | 100663296;
    token = (guint32) D.31111;
    skip = 0;
    D.31112 = acfg->image;
    method = mono_get_method (D.31112, token, 0B);
    D.31115 = method->flags;
    D.31116 = (int) D.31115;
    D.31117 = D.31116 & 8192;
    if (D.31117 != 0) goto <D.31113>; else goto <D.31118>;
    <D.31118>:
    D.31119 = method->iflags;
    D.31120 = (int) D.31119;
    D.31121 = D.31120 & 3;
    if (D.31121 != 0) goto <D.31113>; else goto <D.31122>;
    <D.31122>:
    D.31115 = method->flags;
    D.31116 = (int) D.31115;
    D.31123 = D.31116 & 1024;
    if (D.31123 != 0) goto <D.31113>; else goto <D.31114>;
    <D.31113>:
    skip = 1;
    <D.31114>:
    sig = mono_method_signature (method);
    if (sig == 0B) goto <D.31124>; else goto <D.31125>;
    <D.31124>:
    // predicted unlikely by continue predictor.
    goto <D.26815>;
    <D.31125>:
    D.31126 = sig->ret;
    D.31127 = D.31126->type;
    D.31128 = D.31127 == 15;
    D.31129 = D.31127 == 22;
    D.31130 = D.31128 | D.31129;
    if (D.31130 != 0) goto <D.31131>; else goto <D.31132>;
    <D.31131>:
    skip = 1;
    <D.31132>:
    D.31126 = sig->ret;
    D.31133 = mono_class_is_open_constructed_type (D.31126);
    if (D.31133 != 0) goto <D.31134>; else goto <D.31135>;
    <D.31134>:
    skip = 1;
    <D.31135>:
    j = 0;
    goto <D.26817>;
    <D.26816>:
    D.31136 = sig->params[j];
    D.31137 = D.31136->type;
    if (D.31137 == 22) goto <D.31138>; else goto <D.31139>;
    <D.31138>:
    skip = 1;
    <D.31139>:
    D.31136 = sig->params[j];
    D.31140 = mono_class_is_open_constructed_type (D.31136);
    if (D.31140 != 0) goto <D.31141>; else goto <D.31142>;
    <D.31141>:
    skip = 1;
    <D.31142>:
    j = j + 1;
    <D.26817>:
    D.31143 = sig->param_count;
    D.31144 = (int) D.31143;
    if (D.31144 > j) goto <D.26816>; else goto <D.26818>;
    <D.26818>:
    D.31145 = method->klass;
    D.31146 = BIT_FIELD_REF <*D.31145, 8, 176>;
    D.31147 = D.31146 & 128;
    if (D.31147 == 0) goto <D.31148>; else goto <D.31149>;
    <D.31148>:
    {
      struct MonoDynCallInfo * info;
      gboolean has_nullable;

      info = mono_arch_dyn_call_prepare (sig);
      has_nullable = 0;
      j = 0;
      goto <D.26822>;
      <D.26821>:
      D.31136 = sig->params[j];
      D.31137 = D.31136->type;
      if (D.31137 == 21) goto <D.31150>; else goto <D.31151>;
      <D.31150>:
      D.31136 = sig->params[j];
      D.31152 = mono_class_from_mono_type (D.31136);
      D.31153 = mono_class_is_nullable (D.31152);
      if (D.31153 != 0) goto <D.31154>; else goto <D.31155>;
      <D.31154>:
      has_nullable = 1;
      <D.31155>:
      <D.31151>:
      j = j + 1;
      <D.26822>:
      D.31143 = sig->param_count;
      D.31144 = (int) D.31143;
      if (D.31144 > j) goto <D.26821>; else goto <D.26823>;
      <D.26823>:
      D.31156 = info != 0B;
      D.31157 = has_nullable == 0;
      D.31158 = D.31156 & D.31157;
      if (D.31158 != 0) goto <D.31159>; else goto <D.31160>;
      <D.31159>:
      skip = 1;
      monoeg_g_free (info);
      <D.31160>:
    }
    <D.31149>:
    if (skip == 0) goto <D.31161>; else goto <D.31162>;
    <D.31161>:
    D.31163 = mono_marshal_get_runtime_invoke (method, 0);
    add_method (acfg, D.31163);
    <D.31162>:
  }
  <D.26815>:
  i = i + 1;
  <D.26825>:
  D.31112 = acfg->image;
  D.31164 = D.31112->tables[6].rows;
  D.31165 = (int) D.31164;
  if (D.31165 > i) goto <D.26824>; else goto <D.26826>;
  <D.26826>:
  {
    size_t __s1_len;
    size_t __s2_len;

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

      D.31112 = acfg->image;
      D.31169 = D.31112->assembly;
      __s2 = D.31169->aname.name;
      D.31170 = "mscorlib";
      D.31171 = MEM[(const unsigned char *)D.31170];
      D.31172 = (int) D.31171;
      D.31173 = *__s2;
      D.31174 = (int) D.31173;
      __result = D.31172 - D.31174;
      {
        D.31175 = __s2_len != 0;
        D.31176 = __result == 0;
        D.31177 = D.31175 & D.31176;
        if (D.31177 != 0) goto <D.31178>; else goto <D.31179>;
        <D.31178>:
        D.31180 = &MEM[(void *)"mscorlib" + 1B];
        D.31181 = *D.31180;
        D.31182 = (int) D.31181;
        D.31183 = __s2 + 1;
        D.31184 = *D.31183;
        D.31185 = (int) D.31184;
        __result = D.31182 - D.31185;
        D.31186 = __s2_len > 1;
        D.31176 = __result == 0;
        D.31187 = D.31186 & D.31176;
        if (D.31187 != 0) goto <D.31188>; else goto <D.31189>;
        <D.31188>:
        D.31190 = &MEM[(void *)"mscorlib" + 2B];
        D.31191 = *D.31190;
        D.31192 = (int) D.31191;
        D.31193 = __s2 + 2;
        D.31194 = *D.31193;
        D.31195 = (int) D.31194;
        __result = D.31192 - D.31195;
        D.31196 = __s2_len > 2;
        D.31176 = __result == 0;
        D.31197 = D.31196 & D.31176;
        if (D.31197 != 0) goto <D.31198>; else goto <D.31199>;
        <D.31198>:
        D.31200 = &MEM[(void *)"mscorlib" + 3B];
        D.31201 = *D.31200;
        D.31202 = (int) D.31201;
        D.31203 = __s2 + 3;
        D.31204 = *D.31203;
        D.31205 = (int) D.31204;
        __result = D.31202 - D.31205;
        <D.31199>:
        <D.31189>:
        <D.31179>:
      }
      D.26834 = __result;
    }
    iftmp.97 = -D.26834;
    goto <D.31206>;
    <D.31168>:
    D.31112 = acfg->image;
    D.31169 = D.31112->assembly;
    D.31207 = D.31169->aname.name;
    iftmp.97 = __builtin_strcmp (D.31207, "mscorlib");
    <D.31206>:
    D.26835 = iftmp.97;
  }
  if (D.26835 == 0) goto <D.31208>; else goto <D.31209>;
  <D.31208>:
  {
    struct MonoMethodDesc * desc;
    struct MonoMethod * orig_method;
    int nallocators;

    D.31210 = mono_defaults.corlib;
    csig = mono_metadata_signature_alloc (D.31210, 0);
    D.31211 = mono_defaults.void_class;
    D.31212 = &D.31211->byval_arg;
    csig->ret = D.31212;
    D.31213 = get_runtime_invoke_sig (csig);
    add_method (acfg, D.31213);
    D.31210 = mono_defaults.corlib;
    csig = mono_metadata_signature_alloc (D.31210, 0);
    csig->hasthis = 1;
    D.31211 = mono_defaults.void_class;
    D.31212 = &D.31211->byval_arg;
    csig->ret = D.31212;
    D.31214 = get_runtime_invoke_sig (csig);
    add_method (acfg, D.31214);
    D.31210 = mono_defaults.corlib;
    csig = mono_metadata_signature_alloc (D.31210, 1);
    csig->hasthis = 1;
    D.31211 = mono_defaults.void_class;
    D.31212 = &D.31211->byval_arg;
    csig->ret = D.31212;
    D.31215 = mono_defaults.string_class;
    D.31216 = &D.31215->byval_arg;
    csig->params[0] = D.31216;
    D.31217 = get_runtime_invoke_sig (csig);
    add_method (acfg, D.31217);
    D.31210 = mono_defaults.corlib;
    csig = mono_metadata_signature_alloc (D.31210, 2);
    csig->hasthis = 1;
    D.31211 = mono_defaults.void_class;
    D.31212 = &D.31211->byval_arg;
    csig->ret = D.31212;
    D.31215 = mono_defaults.string_class;
    D.31216 = &D.31215->byval_arg;
    csig->params[0] = D.31216;
    D.31215 = mono_defaults.string_class;
    D.31216 = &D.31215->byval_arg;
    csig->params[1] = D.31216;
    D.31218 = get_runtime_invoke_sig (csig);
    add_method (acfg, D.31218);
    D.31210 = mono_defaults.corlib;
    csig = mono_metadata_signature_alloc (D.31210, 0);
    csig->hasthis = 1;
    D.31215 = mono_defaults.string_class;
    D.31216 = &D.31215->byval_arg;
    csig->ret = D.31216;
    D.31219 = get_runtime_invoke_sig (csig);
    add_method (acfg, D.31219);
    D.31210 = mono_defaults.corlib;
    csig = mono_metadata_signature_alloc (D.31210, 2);
    csig->hasthis = 1;
    D.31211 = mono_defaults.void_class;
    D.31212 = &D.31211->byval_arg;
    csig->ret = D.31212;
    D.31215 = mono_defaults.string_class;
    D.31216 = &D.31215->byval_arg;
    csig->params[0] = D.31216;
    D.31220 = mono_defaults.exception_class;
    D.31221 = &D.31220->byval_arg;
    csig->params[1] = D.31221;
    D.31222 = get_runtime_invoke_sig (csig);
    add_method (acfg, D.31222);
    D.31210 = mono_defaults.corlib;
    csig = mono_metadata_signature_alloc (D.31210, 2);
    csig->hasthis = 1;
    D.31210 = mono_defaults.corlib;
    D.31223 = mono_class_from_name (D.31210, "System.Reflection", "Assembly");
    D.31224 = &D.31223->byval_arg;
    csig->ret = D.31224;
    D.31215 = mono_defaults.string_class;
    D.31216 = &D.31215->byval_arg;
    csig->params[0] = D.31216;
    D.31225 = mono_defaults.boolean_class;
    D.31226 = &D.31225->byval_arg;
    csig->params[1] = D.31226;
    D.31227 = get_runtime_invoke_sig (csig);
    add_method (acfg, D.31227);
    D.31228 = mono_defaults.object_class;
    D.31229 = mono_class_get_method_from_name_flags (D.31228, "Finalize", 0, 0);
    D.31230 = mono_marshal_get_runtime_invoke (D.31229, 1);
    add_method (acfg, D.31230);
    method = mono_get_context_capture_method ();
    if (method != 0B) goto <D.31231>; else goto <D.31232>;
    <D.31231>:
    D.31233 = mono_marshal_get_runtime_invoke (method, 0);
    add_method (acfg, D.31233);
    <D.31232>:
    D.31234 = mono_marshal_get_runtime_invoke_dynamic ();
    add_method (acfg, D.31234);
    D.31235 = mono_marshal_get_stelemref ();
    add_method (acfg, D.31235);
    if (1 != 0) goto <D.31236>; else goto <D.31237>;
    <D.31236>:
    D.31238 = mono_gc_get_managed_allocator_types ();
    nallocators = (int) D.31238;
    i = 0;
    goto <D.26840>;
    <D.26839>:
    m = mono_gc_get_managed_allocator_by_type (i);
    if (m != 0B) goto <D.31239>; else goto <D.31240>;
    <D.31239>:
    add_method (acfg, m);
    <D.31240>:
    i = i + 1;
    <D.26840>:
    if (i < nallocators) goto <D.26839>; else goto <D.26841>;
    <D.26841>:
    desc = mono_method_desc_new ("Monitor:Enter(object,bool&)", 0);
    D.31241 = mono_defaults.monitor_class;
    orig_method = mono_method_desc_search_in_class (desc, D.31241);
    if (orig_method != 0B) goto <D.31242>; else goto <D.31243>;
    <D.31242>:
    method = mono_monitor_get_fast_path (orig_method);
    if (method != 0B) goto <D.31244>; else goto <D.31245>;
    <D.31244>:
    add_method (acfg, method);
    <D.31245>:
    <D.31243>:
    mono_method_desc_free (desc);
    desc = mono_method_desc_new ("Monitor:Exit(object)", 0);
    D.31241 = mono_defaults.monitor_class;
    orig_method = mono_method_desc_search_in_class (desc, D.31241);
    D.31246 = orig_method == 0B;
    D.31247 = (long int) D.31246;
    D.31248 = __builtin_expect (D.31247, 0);
    if (D.31248 != 0) goto <D.31249>; else goto <D.31250>;
    <D.31249>:
    monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "aot-compiler.c", 3370, "orig_method");
    <D.31250>:
    mono_method_desc_free (desc);
    method = mono_monitor_get_fast_path (orig_method);
    if (method != 0B) goto <D.31251>; else goto <D.31252>;
    <D.31251>:
    add_method (acfg, method);
    <D.31252>:
    <D.31237>:
    {
      struct MonoMethod * * wrappers;
      int nwrappers;

      try
        {
          wrappers = mono_marshal_get_virtual_stelemref_wrappers (&nwrappers);
          i = 0;
          goto <D.26845>;
          <D.26844>:
          i.98 = (unsigned int) i;
          D.31254 = i.98 * 4;
          D.31255 = wrappers + D.31254;
          D.31256 = *D.31255;
          add_method (acfg, D.31256);
          i = i + 1;
          <D.26845>:
          nwrappers.99 = nwrappers;
          if (i < nwrappers.99) goto <D.26844>; else goto <D.26846>;
          <D.26846>:
          monoeg_g_free (wrappers);
        }
      finally
        {
          nwrappers = {CLOBBER};
        }
    }
    D.31258 = mono_marshal_get_castclass_with_cache ();
    add_method (acfg, D.31258);
    D.31259 = mono_marshal_get_isinst_with_cache ();
    add_method (acfg, D.31259);
    D.31260 = mono_get_jit_icall_info ();
    monoeg_g_hash_table_foreach (D.31260, add_jit_icall_wrapper, acfg);
  }
  <D.31209>:
  i = 0;
  goto <D.26876>;
  <D.26875>:
  {
    struct MonoClass * klass;
    struct MonoCustomAttrInfo * cattr;

    D.31110 = i + 1;
    D.31261 = D.31110 | 33554432;
    token = (guint32) D.31261;
    D.31112 = acfg->image;
    klass = mono_class_get (D.31112, token);
    if (klass == 0B) goto <D.31262>; else goto <D.31263>;
    <D.31262>:
    mono_loader_clear_error ();
    // predicted unlikely by continue predictor.
    goto <D.26849>;
    <D.31263>:
    D.31266 = BIT_FIELD_REF <*klass, 8, 184>;
    D.31267 = D.31266 & 1;
    if (D.31267 == 0) goto <D.31264>; else goto <D.31268>;
    <D.31268>:
    D.31269 = mono_defaults.delegate_class;
    if (D.31269 == klass) goto <D.31264>; else goto <D.31270>;
    <D.31270>:
    D.31271 = mono_defaults.multicastdelegate_class;
    if (D.31271 == klass) goto <D.31264>; else goto <D.31265>;
    <D.31264>:
    // predicted unlikely by continue predictor.
    goto <D.26849>;
    <D.31265>:
    D.31272 = klass->generic_container;
    if (D.31272 == 0B) goto <D.31273>; else goto <D.31274>;
    <D.31273>:
    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.31275>; else goto <D.31276>;
    <D.31275>:
    D.31277 = mono_marshal_get_delegate_begin_invoke (method);
    add_method (acfg, D.31277);
    <D.31276>:
    method = mono_class_get_method_from_name_flags (klass, "EndInvoke", -1, 0);
    if (method != 0B) goto <D.31278>; else goto <D.31279>;
    <D.31278>:
    D.31280 = mono_marshal_get_delegate_end_invoke (method);
    add_method (acfg, D.31280);
    <D.31279>:
    cattr = mono_custom_attrs_from_class (klass);
    if (cattr != 0B) goto <D.31281>; else goto <D.31282>;
    <D.31281>:
    {
      int j;

      j = 0;
      goto <D.26871>;
      <D.26870>:
      D.31283 = cattr->attrs[j].ctor;
      if (D.31283 != 0B) goto <D.31284>; else goto <D.31285>;
      <D.31284>:
      {
        size_t __s1_len;
        size_t __s2_len;

        __s2_len = 34;
        if (__s2_len <= 3) goto <D.31287>; else goto <D.31288>;
        <D.31287>:
        {
          const unsigned char * __s2;
          int __result;

          D.31283 = cattr->attrs[j].ctor;
          D.31289 = D.31283->klass;
          __s2 = D.31289->name;
          D.31290 = "MonoNativeFunctionWrapperAttribute";
          D.31291 = MEM[(const unsigned char *)D.31290];
          D.31292 = (int) D.31291;
          D.31293 = *__s2;
          D.31294 = (int) D.31293;
          __result = D.31292 - D.31294;
          {
            D.31295 = __s2_len != 0;
            D.31296 = __result == 0;
            D.31297 = D.31295 & D.31296;
            if (D.31297 != 0) goto <D.31298>; else goto <D.31299>;
            <D.31298>:
            D.31300 = &MEM[(void *)"MonoNativeFunctionWrapperAttribute" + 1B];
            D.31301 = *D.31300;
            D.31302 = (int) D.31301;
            D.31303 = __s2 + 1;
            D.31304 = *D.31303;
            D.31305 = (int) D.31304;
            __result = D.31302 - D.31305;
            D.31306 = __s2_len > 1;
            D.31296 = __result == 0;
            D.31307 = D.31306 & D.31296;
            if (D.31307 != 0) goto <D.31308>; else goto <D.31309>;
            <D.31308>:
            D.31310 = &MEM[(void *)"MonoNativeFunctionWrapperAttribute" + 2B];
            D.31311 = *D.31310;
            D.31312 = (int) D.31311;
            D.31313 = __s2 + 2;
            D.31314 = *D.31313;
            D.31315 = (int) D.31314;
            __result = D.31312 - D.31315;
            D.31316 = __s2_len > 2;
            D.31296 = __result == 0;
            D.31317 = D.31316 & D.31296;
            if (D.31317 != 0) goto <D.31318>; else goto <D.31319>;
            <D.31318>:
            D.31320 = &MEM[(void *)"MonoNativeFunctionWrapperAttribute" + 3B];
            D.31321 = *D.31320;
            D.31322 = (int) D.31321;
            D.31323 = __s2 + 3;
            D.31324 = *D.31323;
            D.31325 = (int) D.31324;
            __result = D.31322 - D.31325;
            <D.31319>:
            <D.31309>:
            <D.31299>:
          }
          D.26858 = __result;
        }
        iftmp.100 = -D.26858;
        goto <D.31326>;
        <D.31288>:
        D.31283 = cattr->attrs[j].ctor;
        D.31289 = D.31283->klass;
        D.31327 = D.31289->name;
        iftmp.100 = __builtin_strcmp (D.31327, "MonoNativeFunctionWrapperAttribute");
        <D.31326>:
        D.26859 = iftmp.100;
      }
      if (D.26859 == 0) goto <D.26869>; else goto <D.31328>;
      <D.31328>:
      {
        size_t __s1_len;
        size_t __s2_len;

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

          D.31283 = cattr->attrs[j].ctor;
          D.31289 = D.31283->klass;
          __s2 = D.31289->name;
          D.31332 = "UnmanagedFunctionPointerAttribute";
          D.31333 = MEM[(const unsigned char *)D.31332];
          D.31334 = (int) D.31333;
          D.31335 = *__s2;
          D.31336 = (int) D.31335;
          __result = D.31334 - D.31336;
          {
            D.31337 = __s2_len != 0;
            D.31338 = __result == 0;
            D.31339 = D.31337 & D.31338;
            if (D.31339 != 0) goto <D.31340>; else goto <D.31341>;
            <D.31340>:
            D.31342 = &MEM[(void *)"UnmanagedFunctionPointerAttribute" + 1B];
            D.31343 = *D.31342;
            D.31344 = (int) D.31343;
            D.31345 = __s2 + 1;
            D.31346 = *D.31345;
            D.31347 = (int) D.31346;
            __result = D.31344 - D.31347;
            D.31348 = __s2_len > 1;
            D.31338 = __result == 0;
            D.31349 = D.31348 & D.31338;
            if (D.31349 != 0) goto <D.31350>; else goto <D.31351>;
            <D.31350>:
            D.31352 = &MEM[(void *)"UnmanagedFunctionPointerAttribute" + 2B];
            D.31353 = *D.31352;
            D.31354 = (int) D.31353;
            D.31355 = __s2 + 2;
            D.31356 = *D.31355;
            D.31357 = (int) D.31356;
            __result = D.31354 - D.31357;
            D.31358 = __s2_len > 2;
            D.31338 = __result == 0;
            D.31359 = D.31358 & D.31338;
            if (D.31359 != 0) goto <D.31360>; else goto <D.31361>;
            <D.31360>:
            D.31362 = &MEM[(void *)"UnmanagedFunctionPointerAttribute" + 3B];
            D.31363 = *D.31362;
            D.31364 = (int) D.31363;
            D.31365 = __s2 + 3;
            D.31366 = *D.31365;
            D.31367 = (int) D.31366;
            __result = D.31364 - D.31367;
            <D.31361>:
            <D.31351>:
            <D.31341>:
          }
          D.26867 = __result;
        }
        iftmp.101 = -D.26867;
        goto <D.31368>;
        <D.31331>:
        D.31283 = cattr->attrs[j].ctor;
        D.31289 = D.31283->klass;
        D.31327 = D.31289->name;
        iftmp.101 = __builtin_strcmp (D.31327, "UnmanagedFunctionPointerAttribute");
        <D.31368>:
        D.26868 = iftmp.101;
      }
      if (D.26868 == 0) goto <D.26869>; else goto <D.31369>;
      <D.31369>:
      <D.31285>:
      j = j + 1;
      <D.26871>:
      D.31370 = cattr->num_attrs;
      if (D.31370 > j) goto <D.26870>; else goto <D.26869>;
      <D.26869>:
      D.31370 = cattr->num_attrs;
      if (D.31370 > j) goto <D.31371>; else goto <D.31372>;
      <D.31371>:
      D.31373 = mono_marshal_get_native_func_wrapper_aot (klass);
      add_method (acfg, D.31373);
      <D.31372>:
    }
    <D.31282>:
    goto <D.31374>;
    <D.31274>:
    D.31375 = acfg->opts;
    D.31376 = D.31375 & 16777216;
    if (D.31376 != 0) goto <D.31377>; else goto <D.31378>;
    <D.31377>:
    D.31272 = klass->generic_container;
    if (D.31272 != 0B) goto <D.31379>; else goto <D.31380>;
    <D.31379>:
    {
      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.31381 = BIT_FIELD_REF <*m, 8, 168>;
          D.31382 = D.31381 & 16;
          D.31383 = D.31382 == 0;
          D.31384 = (long int) D.31383;
          D.31385 = __builtin_expect (D.31384, 0);
          if (D.31385 != 0) goto <D.31386>; else goto <D.31387>;
          <D.31386>:
          monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "aot-compiler.c", 3493, "m->is_inflated");
          <D.31387>:
          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.31381 = BIT_FIELD_REF <*m, 8, 168>;
          D.31382 = D.31381 & 16;
          D.31383 = D.31382 == 0;
          D.31384 = (long int) D.31383;
          D.31385 = __builtin_expect (D.31384, 0);
          if (D.31385 != 0) goto <D.31388>; else goto <D.31389>;
          <D.31388>:
          monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "aot-compiler.c", 3505, "m->is_inflated");
          <D.31389>:
          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.31381 = BIT_FIELD_REF <*m, 8, 168>;
          D.31382 = D.31381 & 16;
          D.31383 = D.31382 == 0;
          D.31384 = (long int) D.31383;
          D.31385 = __builtin_expect (D.31384, 0);
          if (D.31385 != 0) goto <D.31390>; else goto <D.31391>;
          <D.31390>:
          monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "aot-compiler.c", 3517, "m->is_inflated");
          <D.31391>:
          gshared = mini_get_shared_method_full (m, 0, 1);
          add_extra_method (acfg, gshared);
        }
      finally
        {
          ctx = {CLOBBER};
        }
    }
    <D.31380>:
    <D.31378>:
    <D.31374>:
  }
  <D.26849>:
  i = i + 1;
  <D.26876>:
  D.31112 = acfg->image;
  D.31392 = D.31112->tables[2].rows;
  D.31393 = (int) D.31392;
  if (D.31393 > i) goto <D.26875>; else goto <D.26877>;
  <D.26877>:
  i = 0;
  goto <D.26883>;
  <D.26882>:
  {
    struct MonoClass * klass;

    D.31110 = i + 1;
    D.31394 = D.31110 | 452984832;
    token = (guint32) D.31394;
    D.31112 = acfg->image;
    klass = mono_class_get (D.31112, token);
    if (klass == 0B) goto <D.31395>; else goto <D.31396>;
    <D.31395>:
    mono_loader_clear_error ();
    // predicted unlikely by continue predictor.
    goto <D.26879>;
    <D.31396>:
    D.31397 = klass->rank;
    if (D.31397 != 0) goto <D.31398>; else goto <D.31399>;
    <D.31398>:
    D.31400 = klass->element_class;
    D.31401 = BIT_FIELD_REF <*D.31400, 8, 1080>;
    D.31402 = D.31401 & 64;
    if (D.31402 == 0) goto <D.31403>; else goto <D.31404>;
    <D.31403>:
    D.31400 = klass->element_class;
    D.31405 = D.31400->byval_arg.type;
    D.31406 = D.31405 + 254;
    D.31407 = D.31406 <= 11;
    D.31408 = D.31405 + 232;
    D.31409 = D.31408 <= 1;
    D.31410 = D.31407 | D.31409;
    if (D.31410 != 0) goto <D.31411>; else goto <D.31412>;
    <D.31411>:
    {
      struct MonoMethod * m;
      struct MonoMethod * wrapper;

      m = mono_class_get_method_from_name (klass, "Get", -1);
      D.31413 = m == 0B;
      D.31414 = (long int) D.31413;
      D.31415 = __builtin_expect (D.31414, 0);
      if (D.31415 != 0) goto <D.31416>; else goto <D.31417>;
      <D.31416>:
      monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "aot-compiler.c", 3543, "m");
      <D.31417>:
      wrapper = mono_marshal_get_array_accessor_wrapper (m);
      add_extra_method (acfg, wrapper);
      D.31418 = mono_marshal_get_runtime_invoke (wrapper, 0);
      add_extra_method (acfg, D.31418);
      m = mono_class_get_method_from_name (klass, "Set", -1);
      D.31413 = m == 0B;
      D.31414 = (long int) D.31413;
      D.31415 = __builtin_expect (D.31414, 0);
      if (D.31415 != 0) goto <D.31419>; else goto <D.31420>;
      <D.31419>:
      monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "aot-compiler.c", 3549, "m");
      <D.31420>:
      wrapper = mono_marshal_get_array_accessor_wrapper (m);
      add_extra_method (acfg, wrapper);
      D.31421 = mono_marshal_get_runtime_invoke (wrapper, 0);
      add_extra_method (acfg, D.31421);
    }
    <D.31412>:
    <D.31404>:
    <D.31399>:
  }
  <D.26879>:
  i = i + 1;
  <D.26883>:
  D.31112 = acfg->image;
  D.31422 = D.31112->tables[27].rows;
  D.31423 = (int) D.31422;
  if (D.31423 > i) goto <D.26882>; else goto <D.26884>;
  <D.26884>:
  i = 0;
  goto <D.26890>;
  <D.26889>:
  D.31110 = i + 1;
  D.31111 = D.31110 | 100663296;
  token = (guint32) D.31111;
  D.31112 = acfg->image;
  method = mono_get_method (D.31112, token, 0B);
  D.31424 = method->iflags;
  D.31425 = (int) D.31424;
  D.31426 = D.31425 & 32;
  if (D.31426 != 0) goto <D.31427>; else goto <D.31428>;
  <D.31427>:
  D.31429 = BIT_FIELD_REF <*method, 8, 168>;
  D.31430 = D.31429 & 8;
  if (D.31430 != 0) goto <D.31431>; else goto <D.31432>;
  <D.31431>:
  goto <D.31433>;
  <D.31432>:
  D.31434 = method->klass;
  D.31435 = D.31434->generic_container;
  if (D.31435 != 0B) goto <D.31436>; else goto <D.31437>;
  <D.31436>:
  {
    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.31438 = BIT_FIELD_REF <*m, 8, 168>;
        D.31439 = D.31438 & 16;
        D.31440 = D.31439 == 0;
        D.31441 = (long int) D.31440;
        D.31442 = __builtin_expect (D.31441, 0);
        if (D.31442 != 0) goto <D.31443>; else goto <D.31444>;
        <D.31443>:
        monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "aot-compiler.c", 3574, "m->is_inflated");
        <D.31444>:
        gshared = mini_get_shared_method_full (m, 0, 1);
        add_method (acfg, gshared);
      }
    finally
      {
        ctx = {CLOBBER};
      }
  }
  goto <D.31445>;
  <D.31437>:
  D.31446 = mono_marshal_get_synchronized_wrapper (method);
  add_method (acfg, D.31446);
  <D.31445>:
  <D.31433>:
  <D.31428>:
  i = i + 1;
  <D.26890>:
  D.31112 = acfg->image;
  D.31164 = D.31112->tables[6].rows;
  D.31165 = (int) D.31164;
  if (D.31165 > i) goto <D.26889>; else goto <D.26891>;
  <D.26891>:
  i = 0;
  goto <D.26895>;
  <D.26894>:
  {
    struct MonoMethod * method;
    guint32 token;

    D.31110 = i + 1;
    D.31111 = D.31110 | 100663296;
    token = (guint32) D.31111;
    D.31112 = acfg->image;
    method = mono_get_method (D.31112, token, 0B);
    D.31449 = method->flags;
    D.31450 = (int) D.31449;
    D.31451 = D.31450 & 8192;
    if (D.31451 != 0) goto <D.31447>; else goto <D.31452>;
    <D.31452>:
    D.31453 = method->iflags;
    D.31454 = (int) D.31453;
    D.31455 = D.31454 & 4096;
    if (D.31455 != 0) goto <D.31447>; else goto <D.31448>;
    <D.31447>:
    D.31456 = mono_marshal_get_native_wrapper (method, 1, 1);
    add_method (acfg, D.31456);
    <D.31448>:
  }
  i = i + 1;
  <D.26895>:
  D.31112 = acfg->image;
  D.31164 = D.31112->tables[6].rows;
  D.31165 = (int) D.31164;
  if (D.31165 > i) goto <D.26894>; else goto <D.26896>;
  <D.26896>:
  i = 0;
  goto <D.26948>;
  <D.26947>:
  {
    struct MonoMethod * method;
    guint32 token;
    struct MonoCustomAttrInfo * cattr;
    int j;

    D.31110 = i + 1;
    D.31111 = D.31110 | 100663296;
    token = (guint32) D.31111;
    D.31112 = acfg->image;
    method = mono_get_method (D.31112, token, 0B);
    cattr = mono_custom_attrs_from_method (method);
    if (cattr != 0B) goto <D.31457>; else goto <D.31458>;
    <D.31457>:
    j = 0;
    goto <D.26912>;
    <D.26911>:
    D.31459 = cattr->attrs[j].ctor;
    if (D.31459 != 0B) goto <D.31460>; else goto <D.31461>;
    <D.31460>:
    {
      size_t __s1_len;
      size_t __s2_len;

      __s2_len = 28;
      if (__s2_len <= 3) goto <D.31463>; else goto <D.31464>;
      <D.31463>:
      {
        const unsigned char * __s2;
        int __result;

        D.31459 = cattr->attrs[j].ctor;
        D.31465 = D.31459->klass;
        __s2 = D.31465->name;
        D.31466 = "MonoPInvokeCallbackAttribute";
        D.31467 = MEM[(const unsigned char *)D.31466];
        D.31468 = (int) D.31467;
        D.31469 = *__s2;
        D.31470 = (int) D.31469;
        __result = D.31468 - D.31470;
        {
          D.31471 = __s2_len != 0;
          D.31472 = __result == 0;
          D.31473 = D.31471 & D.31472;
          if (D.31473 != 0) goto <D.31474>; else goto <D.31475>;
          <D.31474>:
          D.31476 = &MEM[(void *)"MonoPInvokeCallbackAttribute" + 1B];
          D.31477 = *D.31476;
          D.31478 = (int) D.31477;
          D.31479 = __s2 + 1;
          D.31480 = *D.31479;
          D.31481 = (int) D.31480;
          __result = D.31478 - D.31481;
          D.31482 = __s2_len > 1;
          D.31472 = __result == 0;
          D.31483 = D.31482 & D.31472;
          if (D.31483 != 0) goto <D.31484>; else goto <D.31485>;
          <D.31484>:
          D.31486 = &MEM[(void *)"MonoPInvokeCallbackAttribute" + 2B];
          D.31487 = *D.31486;
          D.31488 = (int) D.31487;
          D.31489 = __s2 + 2;
          D.31490 = *D.31489;
          D.31491 = (int) D.31490;
          __result = D.31488 - D.31491;
          D.31492 = __s2_len > 2;
          D.31472 = __result == 0;
          D.31493 = D.31492 & D.31472;
          if (D.31493 != 0) goto <D.31494>; else goto <D.31495>;
          <D.31494>:
          D.31496 = &MEM[(void *)"MonoPInvokeCallbackAttribute" + 3B];
          D.31497 = *D.31496;
          D.31498 = (int) D.31497;
          D.31499 = __s2 + 3;
          D.31500 = *D.31499;
          D.31501 = (int) D.31500;
          __result = D.31498 - D.31501;
          <D.31495>:
          <D.31485>:
          <D.31475>:
        }
        D.26908 = __result;
      }
      iftmp.102 = -D.26908;
      goto <D.31502>;
      <D.31464>:
      D.31459 = cattr->attrs[j].ctor;
      D.31465 = D.31459->klass;
      D.31503 = D.31465->name;
      iftmp.102 = __builtin_strcmp (D.31503, "MonoPInvokeCallbackAttribute");
      <D.31502>:
      D.26909 = iftmp.102;
    }
    if (D.26909 == 0) goto <D.26910>; else goto <D.31504>;
    <D.31504>:
    <D.31461>:
    j = j + 1;
    <D.26912>:
    D.31505 = cattr->num_attrs;
    if (D.31505 > j) goto <D.26911>; else goto <D.26910>;
    <D.26910>:
    D.31505 = cattr->num_attrs;
    if (D.31505 > j) goto <D.31506>; else goto <D.31507>;
    <D.31506>:
    {
      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.31508 = e->ctor;
          sig = mono_method_signature (D.31508);
          p.103 = e->data;
          p = p.103;
          export_name = 0B;
          D.31510 = method->flags;
          D.31511 = (int) D.31510;
          D.31512 = D.31511 & 16;
          if (D.31512 == 0) goto <D.31513>; else goto <D.31514>;
          <D.31513>:
          D.31515 = 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.31515);
          exit (1);
          <D.31514>:
          D.31516 = sig->param_count;
          D.31517 = D.31516 != 1;
          D.31518 = (long int) D.31517;
          D.31519 = __builtin_expect (D.31518, 0);
          if (D.31519 != 0) goto <D.31520>; else goto <D.31521>;
          <D.31520>:
          monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "aot-compiler.c", 3635, "sig->param_count == 1");
          <D.31521>:
          D.31526 = sig->params[0];
          D.31527 = D.31526->type;
          if (D.31527 != 18) goto <D.31523>; else goto <D.31528>;
          <D.31528>:
          {
            size_t __s1_len;
            size_t __s2_len;

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

              D.31526 = sig->params[0];
              D.31532 = mono_class_from_mono_type (D.31526);
              __s2 = D.31532->name;
              D.31533 = "Type";
              D.31534 = MEM[(const unsigned char *)D.31533];
              D.31535 = (int) D.31534;
              D.31536 = *__s2;
              D.31537 = (int) D.31536;
              __result = D.31535 - D.31537;
              {
                D.31538 = __s2_len != 0;
                D.31539 = __result == 0;
                D.31540 = D.31538 & D.31539;
                if (D.31540 != 0) goto <D.31541>; else goto <D.31542>;
                <D.31541>:
                D.31543 = &MEM[(void *)"Type" + 1B];
                D.31544 = *D.31543;
                D.31545 = (int) D.31544;
                D.31546 = __s2 + 1;
                D.31547 = *D.31546;
                D.31548 = (int) D.31547;
                __result = D.31545 - D.31548;
                D.31549 = __s2_len > 1;
                D.31539 = __result == 0;
                D.31550 = D.31549 & D.31539;
                if (D.31550 != 0) goto <D.31551>; else goto <D.31552>;
                <D.31551>:
                D.31553 = &MEM[(void *)"Type" + 2B];
                D.31554 = *D.31553;
                D.31555 = (int) D.31554;
                D.31556 = __s2 + 2;
                D.31557 = *D.31556;
                D.31558 = (int) D.31557;
                __result = D.31555 - D.31558;
                D.31559 = __s2_len > 2;
                D.31539 = __result == 0;
                D.31560 = D.31559 & D.31539;
                if (D.31560 != 0) goto <D.31561>; else goto <D.31562>;
                <D.31561>:
                D.31563 = &MEM[(void *)"Type" + 3B];
                D.31564 = *D.31563;
                D.31565 = (int) D.31564;
                D.31566 = __s2 + 3;
                D.31567 = *D.31566;
                D.31568 = (int) D.31567;
                __result = D.31565 - D.31568;
                <D.31562>:
                <D.31552>:
                <D.31542>:
              }
              D.26933 = __result;
            }
            iftmp.105 = -D.26933;
            goto <D.31569>;
            <D.31531>:
            D.31526 = sig->params[0];
            D.31570 = mono_class_from_mono_type (D.31526);
            D.31571 = D.31570->name;
            iftmp.105 = __builtin_strcmp (D.31571, "Type");
            <D.31569>:
            D.26934 = iftmp.105;
          }
          if (D.26934 != 0) goto <D.31523>; else goto <D.31524>;
          <D.31523>:
          iftmp.104 = 1;
          goto <D.31525>;
          <D.31524>:
          iftmp.104 = 0;
          <D.31525>:
          D.31572 = iftmp.104 != 0;
          D.31573 = (long int) D.31572;
          D.31574 = __builtin_expect (D.31573, 0);
          if (D.31574 != 0) goto <D.31575>; else goto <D.31576>;
          <D.31575>:
          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.31576>:
          p.106 = p;
          p.107 = p.106 + 2;
          p = p.107;
          p.106 = p;
          D.31579 = mono_metadata_decode_value (p.106, &p);
          slen = (int) D.31579;
          p.106 = p;
          D.31580 = slen + 1;
          D.31581 = (unsigned int) D.31580;
          n = monoeg_g_memdup (p.106, D.31581);
          slen.108 = (sizetype) slen;
          D.31583 = n + slen.108;
          *D.31583 = 0;
          D.31112 = acfg->image;
          t = mono_reflection_type_from_name (n, D.31112);
          D.31584 = t == 0B;
          D.31585 = (long int) D.31584;
          D.31586 = __builtin_expect (D.31585, 0);
          if (D.31586 != 0) goto <D.31587>; else goto <D.31588>;
          <D.31587>:
          monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "aot-compiler.c", 3651, "t");
          <D.31588>:
          monoeg_g_free (n);
          klass = mono_class_from_mono_type (t);
          D.31589 = klass->parent;
          D.31271 = mono_defaults.multicastdelegate_class;
          D.31590 = D.31589 != D.31271;
          D.31591 = (long int) D.31590;
          D.31592 = __builtin_expect (D.31591, 0);
          if (D.31592 != 0) goto <D.31593>; else goto <D.31594>;
          <D.31593>:
          monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "aot-compiler.c", 3655, "klass->parent == mono_defaults.multicastdelegate_class");
          <D.31594>:
          p.106 = p;
          slen.108 = (sizetype) slen;
          p.109 = p.106 + slen.108;
          p = p.109;
          p.106 = p;
          D.31596 = mono_read16 (p.106);
          num_named = (int) D.31596;
          p.106 = p;
          p.107 = p.106 + 2;
          p = p.107;
          D.31597 = num_named > 1;
          D.31598 = (long int) D.31597;
          D.31599 = __builtin_expect (D.31598, 0);
          if (D.31599 != 0) goto <D.31600>; else goto <D.31601>;
          <D.31600>:
          monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "aot-compiler.c", 3662, "num_named < 2");
          <D.31601>:
          if (num_named == 1) goto <D.31602>; else goto <D.31603>;
          <D.31602>:
          {
            int name_len;
            char * name;
            struct MonoType * prop_type;

            p.106 = p;
            named = p.106;
            named.110 = named;
            D.31605 = *named.110;
            named_type = (int) D.31605;
            named.110 = named;
            named.111 = named.110 + 1;
            named = named.111;
            named.110 = named;
            D.31605 = *named.110;
            data_type = (int) D.31605;
            named.110 = named;
            named.111 = named.110 + 1;
            named = named.111;
            named.110 = named;
            D.31607 = mono_metadata_decode_blob_size (named.110, &named);
            name_len = (int) D.31607;
            D.31608 = name_len + 1;
            D.31609 = (unsigned int) D.31608;
            name = monoeg_malloc (D.31609);
            named.110 = named;
            name_len.112 = (unsigned int) name_len;
            memcpy (name, named.110, name_len.112);
            name_len.113 = (sizetype) name_len;
            D.31612 = name + name_len.113;
            *D.31612 = 0;
            named.110 = named;
            name_len.113 = (sizetype) name_len;
            named.114 = named.110 + name_len.113;
            named = named.114;
            D.31614 = named_type != 84;
            D.31615 = (long int) D.31614;
            D.31616 = __builtin_expect (D.31615, 0);
            if (D.31616 != 0) goto <D.31617>; else goto <D.31618>;
            <D.31617>:
            monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "aot-compiler.c", 3681, "named_type == 0x54");
            <D.31618>:
            {
              size_t __s1_len;
              size_t __s2_len;

              __s2_len = 12;
              if (__s2_len <= 3) goto <D.31620>; else goto <D.31621>;
              <D.31620>:
              {
                const unsigned char * __s2;
                int __result;

                __s2 = name;
                D.31622 = "ExportSymbol";
                D.31623 = MEM[(const unsigned char *)D.31622];
                D.31624 = (int) D.31623;
                D.31625 = *__s2;
                D.31626 = (int) D.31625;
                __result = D.31624 - D.31626;
                {
                  D.31627 = __s2_len != 0;
                  D.31628 = __result == 0;
                  D.31629 = D.31627 & D.31628;
                  if (D.31629 != 0) goto <D.31630>; else goto <D.31631>;
                  <D.31630>:
                  D.31632 = &MEM[(void *)"ExportSymbol" + 1B];
                  D.31633 = *D.31632;
                  D.31634 = (int) D.31633;
                  D.31635 = __s2 + 1;
                  D.31636 = *D.31635;
                  D.31637 = (int) D.31636;
                  __result = D.31634 - D.31637;
                  D.31638 = __s2_len > 1;
                  D.31628 = __result == 0;
                  D.31639 = D.31638 & D.31628;
                  if (D.31639 != 0) goto <D.31640>; else goto <D.31641>;
                  <D.31640>:
                  D.31642 = &MEM[(void *)"ExportSymbol" + 2B];
                  D.31643 = *D.31642;
                  D.31644 = (int) D.31643;
                  D.31645 = __s2 + 2;
                  D.31646 = *D.31645;
                  D.31647 = (int) D.31646;
                  __result = D.31644 - D.31647;
                  D.31648 = __s2_len > 2;
                  D.31628 = __result == 0;
                  D.31649 = D.31648 & D.31628;
                  if (D.31649 != 0) goto <D.31650>; else goto <D.31651>;
                  <D.31650>:
                  D.31652 = &MEM[(void *)"ExportSymbol" + 3B];
                  D.31653 = *D.31652;
                  D.31654 = (int) D.31653;
                  D.31655 = __s2 + 3;
                  D.31656 = *D.31655;
                  D.31657 = (int) D.31656;
                  __result = D.31654 - D.31657;
                  <D.31651>:
                  <D.31641>:
                  <D.31631>:
                }
                D.26945 = __result;
              }
              iftmp.115 = -D.26945;
              goto <D.31658>;
              <D.31621>:
              iftmp.115 = __builtin_strcmp (name, "ExportSymbol");
              <D.31658>:
              D.26946 = iftmp.115;
            }
            D.31659 = D.26946 != 0;
            D.31660 = (long int) D.31659;
            D.31661 = __builtin_expect (D.31660, 0);
            if (D.31661 != 0) goto <D.31662>; else goto <D.31663>;
            <D.31662>:
            monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "aot-compiler.c", 3682, "!strcmp (name, \"ExportSymbol\")");
            <D.31663>:
            D.31215 = mono_defaults.string_class;
            prop_type = &D.31215->byval_arg;
            named.110 = named;
            D.31605 = *named.110;
            D.31664 = D.31605 == 255;
            D.31665 = (long int) D.31664;
            D.31666 = __builtin_expect (D.31665, 0);
            if (D.31666 != 0) goto <D.31667>; else goto <D.31668>;
            <D.31667>:
            monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "aot-compiler.c", 3687, "*named != (char)0xff");
            <D.31668>:
            named.110 = named;
            D.31669 = mono_metadata_decode_value (named.110, &named);
            slen = (int) D.31669;
            D.31580 = slen + 1;
            D.31670 = (unsigned int) D.31580;
            export_name = monoeg_malloc (D.31670);
            named.110 = named;
            slen.116 = (unsigned int) slen;
            memcpy (export_name, named.110, slen.116);
            slen.108 = (sizetype) slen;
            D.31672 = export_name + slen.108;
            *D.31672 = 0;
            named.110 = named;
            slen.108 = (sizetype) slen;
            named.117 = named.110 + slen.108;
            named = named.117;
          }
          <D.31603>:
          wrapper = mono_marshal_get_managed_wrapper (method, klass, 0);
          add_method (acfg, wrapper);
          if (export_name != 0B) goto <D.31674>; else goto <D.31675>;
          <D.31674>:
          D.31676 = acfg->export_names;
          monoeg_g_hash_table_insert_replace (D.31676, wrapper, export_name, 0);
          <D.31675>:
        }
      finally
        {
          p = {CLOBBER};
          named = {CLOBBER};
        }
    }
    <D.31507>:
    <D.31458>:
    D.31510 = method->flags;
    D.31511 = (int) D.31510;
    D.31679 = D.31511 & 8192;
    if (D.31679 != 0) goto <D.31677>; else goto <D.31680>;
    <D.31680>:
    D.31681 = method->iflags;
    D.31682 = (int) D.31681;
    D.31683 = D.31682 & 4096;
    if (D.31683 != 0) goto <D.31677>; else goto <D.31678>;
    <D.31677>:
    D.31684 = mono_marshal_get_native_wrapper (method, 1, 1);
    add_method (acfg, D.31684);
    <D.31678>:
  }
  i = i + 1;
  <D.26948>:
  D.31112 = acfg->image;
  D.31164 = D.31112->tables[6].rows;
  D.31165 = (int) D.31164;
  if (D.31165 > i) goto <D.26947>; else goto <D.26949>;
  <D.26949>:
  i = 0;
  goto <D.26953>;
  <D.26952>:
  {
    struct MonoClass * klass;

    D.31110 = i + 1;
    D.31261 = D.31110 | 33554432;
    token = (guint32) D.31261;
    D.31112 = acfg->image;
    klass = mono_class_get (D.31112, token);
    if (klass == 0B) goto <D.31685>; else goto <D.31686>;
    <D.31685>:
    mono_loader_clear_error ();
    // predicted unlikely by continue predictor.
    goto <D.26951>;
    <D.31686>:
    D.31689 = BIT_FIELD_REF <*klass, 8, 160>;
    D.31690 = D.31689 & 8;
    if (D.31690 != 0) goto <D.31691>; else goto <D.31692>;
    <D.31691>:
    D.31693 = klass->generic_container;
    if (D.31693 == 0B) goto <D.31694>; else goto <D.31695>;
    <D.31694>:
    D.31696 = can_marshal_struct (klass);
    if (D.31696 != 0) goto <D.31697>; else goto <D.31698>;
    <D.31697>:
    D.31699 = klass->nested_in;
    if (D.31699 == 0B) goto <D.31687>; else goto <D.31700>;
    <D.31700>:
    D.31699 = klass->nested_in;
    D.31701 = D.31699->name;
    D.31702 = strstr (D.31701, "<PrivateImplementationDetails>");
    D.31699 = klass->nested_in;
    D.31701 = D.31699->name;
    if (D.31702 != D.31701) goto <D.31687>; else goto <D.31688>;
    <D.31687>:
    D.31703 = mono_marshal_get_struct_to_ptr (klass);
    add_method (acfg, D.31703);
    D.31704 = mono_marshal_get_ptr_to_struct (klass);
    add_method (acfg, D.31704);
    <D.31688>:
    <D.31698>:
    <D.31695>:
    <D.31692>:
  }
  <D.26951>:
  i = i + 1;
  <D.26953>:
  D.31112 = acfg->image;
  D.31392 = D.31112->tables[2].rows;
  D.31393 = (int) D.31392;
  if (D.31393 > i) goto <D.26952>; else goto <D.26954>;
  <D.26954>:
}


add_jit_icall_wrapper (void * key, void * value, void * user_data)
{
  struct MonoMethodSignature * D.31705;
  const char * D.31708;
  const void * D.31709;
  int check_for_pending_exc.118;
  struct MonoAotCompile * acfg;
  struct MonoJitICallInfo * callinfo;
  struct MonoMethod * wrapper;
  char * name;

  acfg = user_data;
  callinfo = value;
  D.31705 = callinfo->sig;
  if (D.31705 == 0B) goto <D.31706>; else goto <D.31707>;
  <D.31706>:
  return;
  <D.31707>:
  D.31708 = callinfo->name;
  name = monoeg_g_strdup_printf ("__icall_wrapper_%s", D.31708);
  D.31705 = callinfo->sig;
  D.31709 = callinfo->func;
  check_for_pending_exc.118 = check_for_pending_exc;
  wrapper = mono_marshal_get_icall_wrapper (D.31705, name, D.31709, check_for_pending_exc.118);
  monoeg_g_free (name);
  add_method (acfg, wrapper);
}


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

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


create_gsharedvt_inst (struct MonoAotCompile * acfg, struct MonoMethod * method, struct MonoGenericContext * ctx)
{
  struct MonoClass * D.31715;
  struct MonoGenericContainer * D.31716;
  <unnamed-unsigned:22> D.31719;
  unsigned int D.31720;
  unsigned int D.31721;
  unsigned int i.119;
  unsigned int D.31723;
  struct MonoType * * D.31724;
  struct MonoClass * D.31725;
  struct MonoType * D.31726;
  int D.31727;
  struct MonoGenericInst * D.31728;
  unsigned char D.31729;
  unsigned char D.31730;
  struct MonoGenericParamFull * D.31733;
  unsigned int D.31734;
  struct MonoGenericParamFull * D.31735;
  struct MonoClass * * D.31738;
  struct MonoClass * D.31743;
  struct MonoImage * D.31746;
  struct MonoImage * D.31747;
  int D.26795;
  int iftmp.120;
  int D.26794;
  const char[10] * D.31752;
  unsigned char D.31753;
  int D.31754;
  unsigned char D.31755;
  int D.31756;
  _Bool D.31757;
  _Bool D.31758;
  _Bool D.31759;
  const unsigned char * D.31762;
  unsigned char D.31763;
  int D.31764;
  const unsigned char * D.31765;
  unsigned char D.31766;
  int D.31767;
  _Bool D.31768;
  _Bool D.31769;
  const unsigned char * D.31772;
  unsigned char D.31773;
  int D.31774;
  const unsigned char * D.31775;
  unsigned char D.31776;
  int D.31777;
  _Bool D.31778;
  _Bool D.31779;
  const unsigned char * D.31782;
  unsigned char D.31783;
  int D.31784;
  const unsigned char * D.31785;
  unsigned char D.31786;
  int D.31787;
  const char * D.31789;
  struct MonoClass * D.31790;
  struct MonoType * D.31793;
  <unnamed-signed:31> D.31795;
  int D.31796;
  struct MonoGenericInst * D.31797;
  struct MonoGenericContext shared_context;
  struct MonoType * * args;
  struct MonoGenericInst * inst;
  struct MonoGenericContainer * container;
  struct MonoClass * * constraints;
  int i;

  try
    {
      memset (ctx, 0, 8);
      D.31715 = method->klass;
      D.31716 = D.31715->generic_container;
      if (D.31716 != 0B) goto <D.31717>; else goto <D.31718>;
      <D.31717>:
      D.31715 = method->klass;
      D.31716 = D.31715->generic_container;
      shared_context = D.31716->context;
      inst = shared_context.class_inst;
      D.31719 = inst->type_argc;
      D.31720 = (unsigned int) D.31719;
      D.31721 = D.31720 * 4;
      args = monoeg_malloc0 (D.31721);
      i = 0;
      goto <D.26782>;
      <D.26781>:
      i.119 = (unsigned int) i;
      D.31723 = i.119 * 4;
      D.31724 = args + D.31723;
      D.31725 = mono_defaults.int_class;
      D.31726 = &D.31725->byval_arg;
      *D.31724 = D.31726;
      i = i + 1;
      <D.26782>:
      D.31719 = inst->type_argc;
      D.31727 = (int) D.31719;
      if (D.31727 > i) goto <D.26781>; else goto <D.26783>;
      <D.26783>:
      D.31719 = inst->type_argc;
      D.31727 = (int) D.31719;
      D.31728 = mono_metadata_get_generic_inst (D.31727, args);
      ctx->class_inst = D.31728;
      <D.31718>:
      D.31729 = BIT_FIELD_REF <*method, 8, 168>;
      D.31730 = D.31729 & 8;
      if (D.31730 != 0) goto <D.31731>; else goto <D.31732>;
      <D.31731>:
      container = mono_method_get_generic_container (method);
      shared_context = container->context;
      inst = shared_context.method_inst;
      D.31719 = inst->type_argc;
      D.31720 = (unsigned int) D.31719;
      D.31721 = D.31720 * 4;
      args = monoeg_malloc0 (D.31721);
      i = 0;
      goto <D.26800>;
      <D.26799>:
      {
        struct MonoGenericParamInfo * info;
        gboolean ref_only;

        D.31733 = container->type_params;
        i.119 = (unsigned int) i;
        D.31734 = i.119 * 32;
        D.31735 = D.31733 + D.31734;
        info = &D.31735->info;
        ref_only = 0;
        if (info != 0B) goto <D.31736>; else goto <D.31737>;
        <D.31736>:
        D.31738 = info->constraints;
        if (D.31738 != 0B) goto <D.31739>; else goto <D.31740>;
        <D.31739>:
        constraints = info->constraints;
        goto <D.26797>;
        <D.26796>:
        {
          struct MonoClass * cklass;

          cklass = *constraints;
          D.31743 = mono_defaults.object_class;
          if (D.31743 != cklass) goto <D.31744>; else goto <D.31745>;
          <D.31744>:
          D.31746 = cklass->image;
          D.31747 = mono_defaults.corlib;
          if (D.31746 != D.31747) goto <D.31741>; else goto <D.31748>;
          <D.31748>:
          {
            size_t __s1_len;
            size_t __s2_len;

            __s2_len = 9;
            if (__s2_len <= 3) goto <D.31750>; else goto <D.31751>;
            <D.31750>:
            {
              const unsigned char * __s2;
              int __result;

              __s2 = cklass->name;
              D.31752 = "ValueType";
              D.31753 = MEM[(const unsigned char *)D.31752];
              D.31754 = (int) D.31753;
              D.31755 = *__s2;
              D.31756 = (int) D.31755;
              __result = D.31754 - D.31756;
              {
                D.31757 = __s2_len != 0;
                D.31758 = __result == 0;
                D.31759 = D.31757 & D.31758;
                if (D.31759 != 0) goto <D.31760>; else goto <D.31761>;
                <D.31760>:
                D.31762 = &MEM[(void *)"ValueType" + 1B];
                D.31763 = *D.31762;
                D.31764 = (int) D.31763;
                D.31765 = __s2 + 1;
                D.31766 = *D.31765;
                D.31767 = (int) D.31766;
                __result = D.31764 - D.31767;
                D.31768 = __s2_len > 1;
                D.31758 = __result == 0;
                D.31769 = D.31768 & D.31758;
                if (D.31769 != 0) goto <D.31770>; else goto <D.31771>;
                <D.31770>:
                D.31772 = &MEM[(void *)"ValueType" + 2B];
                D.31773 = *D.31772;
                D.31774 = (int) D.31773;
                D.31775 = __s2 + 2;
                D.31776 = *D.31775;
                D.31777 = (int) D.31776;
                __result = D.31774 - D.31777;
                D.31778 = __s2_len > 2;
                D.31758 = __result == 0;
                D.31779 = D.31778 & D.31758;
                if (D.31779 != 0) goto <D.31780>; else goto <D.31781>;
                <D.31780>:
                D.31782 = &MEM[(void *)"ValueType" + 3B];
                D.31783 = *D.31782;
                D.31784 = (int) D.31783;
                D.31785 = __s2 + 3;
                D.31786 = *D.31785;
                D.31787 = (int) D.31786;
                __result = D.31784 - D.31787;
                <D.31781>:
                <D.31771>:
                <D.31761>:
              }
              D.26794 = __result;
            }
            iftmp.120 = -D.26794;
            goto <D.31788>;
            <D.31751>:
            D.31789 = cklass->name;
            iftmp.120 = __builtin_strcmp (D.31789, "ValueType");
            <D.31788>:
            D.26795 = iftmp.120;
          }
          if (D.26795 != 0) goto <D.31741>; else goto <D.31742>;
          <D.31741>:
          ref_only = 1;
          <D.31742>:
          <D.31745>:
          constraints = constraints + 4;
        }
        <D.26797>:
        D.31790 = *constraints;
        if (D.31790 != 0B) goto <D.26796>; else goto <D.26798>;
        <D.26798>:
        <D.31740>:
        <D.31737>:
        if (ref_only != 0) goto <D.31791>; else goto <D.31792>;
        <D.31791>:
        i.119 = (unsigned int) i;
        D.31723 = i.119 * 4;
        D.31724 = args + D.31723;
        D.31743 = mono_defaults.object_class;
        D.31793 = &D.31743->byval_arg;
        *D.31724 = D.31793;
        goto <D.31794>;
        <D.31792>:
        i.119 = (unsigned int) i;
        D.31723 = i.119 * 4;
        D.31724 = args + D.31723;
        D.31725 = mono_defaults.int_class;
        D.31726 = &D.31725->byval_arg;
        *D.31724 = D.31726;
        <D.31794>:
      }
      i = i + 1;
      <D.26800>:
      D.31795 = container->type_argc;
      D.31796 = (int) D.31795;
      if (D.31796 > i) goto <D.26799>; else goto <D.26801>;
      <D.26801>:
      D.31719 = inst->type_argc;
      D.31727 = (int) D.31719;
      D.31797 = mono_metadata_get_generic_inst (D.31727, args);
      ctx->method_inst = D.31797;
      <D.31732>:
    }
  finally
    {
      shared_context = {CLOBBER};
    }
}


can_marshal_struct (struct MonoClass * klass)
{
  unsigned int D.31798;
  unsigned int D.31799;
  gboolean D.31802;
  struct MonoType * D.31803;
  short unsigned int D.31804;
  int D.31805;
  int D.31806;
  unsigned char D.31809;
  int D.31810;
  struct MonoClass * D.31811;
  unsigned char D.31812;
  unsigned char D.31813;
  struct MonoClass * D.31816;
  int D.31817;
  struct MonoClassField * D.31822;
  struct MonoMarshalSpec * D.31825;
  unsigned int i.121;
  unsigned int D.31829;
  int D.26760;
  int iftmp.122;
  int D.26759;
  const char[43] * D.31835;
  unsigned char D.31836;
  int D.31837;
  unsigned char D.31838;
  int D.31839;
  _Bool D.31840;
  _Bool D.31841;
  _Bool D.31842;
  const unsigned char * D.31845;
  unsigned char D.31846;
  int D.31847;
  const unsigned char * D.31848;
  unsigned char D.31849;
  int D.31850;
  _Bool D.31851;
  _Bool D.31852;
  const unsigned char * D.31855;
  unsigned char D.31856;
  int D.31857;
  const unsigned char * D.31858;
  unsigned char D.31859;
  int D.31860;
  _Bool D.31861;
  _Bool D.31862;
  const unsigned char * D.31865;
  unsigned char D.31866;
  int D.31867;
  const unsigned char * D.31868;
  unsigned char D.31869;
  int D.31870;
  const char * D.31872;
  int D.26769;
  int iftmp.123;
  int D.26768;
  const char[12] * D.31878;
  unsigned char D.31879;
  int D.31880;
  unsigned char D.31881;
  int D.31882;
  _Bool D.31883;
  _Bool D.31884;
  _Bool D.31885;
  const unsigned char * D.31888;
  unsigned char D.31889;
  int D.31890;
  const unsigned char * D.31891;
  unsigned char D.31892;
  int D.31893;
  _Bool D.31894;
  _Bool D.31895;
  const unsigned char * D.31898;
  unsigned char D.31899;
  int D.31900;
  const unsigned char * D.31901;
  unsigned char D.31902;
  int D.31903;
  _Bool D.31904;
  _Bool D.31905;
  const unsigned char * D.31908;
  unsigned char D.31909;
  int D.31910;
  const unsigned char * D.31911;
  unsigned char D.31912;
  int D.31913;
  const char * D.31915;
  struct MonoClassField * field;
  gboolean can_marshal;
  void * iter;
  struct MonoMarshalType * info;
  int i;

  try
    {
      can_marshal = 1;
      iter = 0B;
      D.31798 = klass->flags;
      D.31799 = D.31798 & 24;
      if (D.31799 == 0) goto <D.31800>; else goto <D.31801>;
      <D.31800>:
      D.31802 = 0;
      return D.31802;
      <D.31801>:
      info = mono_marshal_load_type_info (klass);
      goto <D.26725>;
      <D.26750>:
      D.31803 = field->type;
      D.31804 = D.31803->attrs;
      D.31805 = (int) D.31804;
      D.31806 = D.31805 & 16;
      if (D.31806 != 0) goto <D.31807>; else goto <D.31808>;
      <D.31807>:
      // predicted unlikely by continue predictor.
      goto <D.26725>;
      <D.31808>:
      D.31803 = field->type;
      D.31809 = D.31803->type;
      D.31810 = (int) D.31809;
      switch (D.31810) <default: <D.26749>, case 2: <D.26730>, case 3: <D.26733>, case 4: <D.26728>, case 5: <D.26729>, case 6: <D.26731>, case 7: <D.26732>, case 8: <D.26726>, case 9: <D.26727>, case 10: <D.26734>, case 11: <D.26735>, case 12: <D.26739>, case 13: <D.26740>, case 14: <D.26741>, case 15: <D.26738>, case 17: <D.26743>, case 24: <D.26736>, case 25: <D.26737>, case 29: <D.26744>>
      <D.26726>:
      <D.26727>:
      <D.26728>:
      <D.26729>:
      <D.26730>:
      <D.26731>:
      <D.26732>:
      <D.26733>:
      <D.26734>:
      <D.26735>:
      <D.26736>:
      <D.26737>:
      <D.26738>:
      <D.26739>:
      <D.26740>:
      <D.26741>:
      goto <D.26742>;
      <D.26743>:
      D.31803 = field->type;
      D.31811 = mono_class_from_mono_type (D.31803);
      D.31812 = BIT_FIELD_REF <*D.31811, 8, 160>;
      D.31813 = D.31812 & 16;
      if (D.31813 == 0) goto <D.31814>; else goto <D.31815>;
      <D.31814>:
      D.31803 = field->type;
      D.31816 = mono_class_from_mono_type (D.31803);
      D.31817 = can_marshal_struct (D.31816);
      if (D.31817 == 0) goto <D.31818>; else goto <D.31819>;
      <D.31818>:
      can_marshal = 0;
      <D.31819>:
      <D.31815>:
      goto <D.26742>;
      <D.26744>:
      {
        gboolean has_mspec;

        has_mspec = 0;
        if (info != 0B) goto <D.31820>; else goto <D.31821>;
        <D.31820>:
        i = 0;
        goto <D.26747>;
        <D.26746>:
        D.31822 = info->fields[i].field;
        if (D.31822 == field) goto <D.31823>; else goto <D.31824>;
        <D.31823>:
        D.31825 = info->fields[i].mspec;
        if (D.31825 != 0B) goto <D.31826>; else goto <D.31827>;
        <D.31826>:
        has_mspec = 1;
        <D.31827>:
        <D.31824>:
        i = i + 1;
        <D.26747>:
        i.121 = (unsigned int) i;
        D.31829 = info->num_fields;
        if (i.121 < D.31829) goto <D.26746>; else goto <D.26748>;
        <D.26748>:
        <D.31821>:
        if (has_mspec == 0) goto <D.31830>; else goto <D.31831>;
        <D.31830>:
        can_marshal = 0;
        <D.31831>:
        goto <D.26742>;
      }
      <D.26749>:
      can_marshal = 0;
      goto <D.26742>;
      <D.26742>:
      <D.26725>:
      field = mono_class_get_fields (klass, &iter);
      if (field != 0B) goto <D.26750>; else goto <D.26751>;
      <D.26751>:
      {
        size_t __s1_len;
        size_t __s2_len;

        __s2_len = 42;
        if (__s2_len <= 3) goto <D.31833>; else goto <D.31834>;
        <D.31833>:
        {
          const unsigned char * __s2;
          int __result;

          __s2 = klass->name_space;
          D.31835 = "System.Net.NetworkInformation.MacOsStructs";
          D.31836 = MEM[(const unsigned char *)D.31835];
          D.31837 = (int) D.31836;
          D.31838 = *__s2;
          D.31839 = (int) D.31838;
          __result = D.31837 - D.31839;
          {
            D.31840 = __s2_len != 0;
            D.31841 = __result == 0;
            D.31842 = D.31840 & D.31841;
            if (D.31842 != 0) goto <D.31843>; else goto <D.31844>;
            <D.31843>:
            D.31845 = &MEM[(void *)"System.Net.NetworkInformation.MacOsStructs" + 1B];
            D.31846 = *D.31845;
            D.31847 = (int) D.31846;
            D.31848 = __s2 + 1;
            D.31849 = *D.31848;
            D.31850 = (int) D.31849;
            __result = D.31847 - D.31850;
            D.31851 = __s2_len > 1;
            D.31841 = __result == 0;
            D.31852 = D.31851 & D.31841;
            if (D.31852 != 0) goto <D.31853>; else goto <D.31854>;
            <D.31853>:
            D.31855 = &MEM[(void *)"System.Net.NetworkInformation.MacOsStructs" + 2B];
            D.31856 = *D.31855;
            D.31857 = (int) D.31856;
            D.31858 = __s2 + 2;
            D.31859 = *D.31858;
            D.31860 = (int) D.31859;
            __result = D.31857 - D.31860;
            D.31861 = __s2_len > 2;
            D.31841 = __result == 0;
            D.31862 = D.31861 & D.31841;
            if (D.31862 != 0) goto <D.31863>; else goto <D.31864>;
            <D.31863>:
            D.31865 = &MEM[(void *)"System.Net.NetworkInformation.MacOsStructs" + 3B];
            D.31866 = *D.31865;
            D.31867 = (int) D.31866;
            D.31868 = __s2 + 3;
            D.31869 = *D.31868;
            D.31870 = (int) D.31869;
            __result = D.31867 - D.31870;
            <D.31864>:
            <D.31854>:
            <D.31844>:
          }
          D.26759 = __result;
        }
        iftmp.122 = -D.26759;
        goto <D.31871>;
        <D.31834>:
        D.31872 = klass->name_space;
        iftmp.122 = __builtin_strcmp (D.31872, "System.Net.NetworkInformation.MacOsStructs");
        <D.31871>:
        D.26760 = iftmp.122;
      }
      if (D.26760 == 0) goto <D.31873>; else goto <D.31874>;
      <D.31873>:
      {
        size_t __s1_len;
        size_t __s2_len;

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

          __s2 = klass->name;
          D.31878 = "sockaddr_dl";
          D.31879 = MEM[(const unsigned char *)D.31878];
          D.31880 = (int) D.31879;
          D.31881 = *__s2;
          D.31882 = (int) D.31881;
          __result = D.31880 - D.31882;
          {
            D.31883 = __s2_len != 0;
            D.31884 = __result == 0;
            D.31885 = D.31883 & D.31884;
            if (D.31885 != 0) goto <D.31886>; else goto <D.31887>;
            <D.31886>:
            D.31888 = &MEM[(void *)"sockaddr_dl" + 1B];
            D.31889 = *D.31888;
            D.31890 = (int) D.31889;
            D.31891 = __s2 + 1;
            D.31892 = *D.31891;
            D.31893 = (int) D.31892;
            __result = D.31890 - D.31893;
            D.31894 = __s2_len > 1;
            D.31884 = __result == 0;
            D.31895 = D.31894 & D.31884;
            if (D.31895 != 0) goto <D.31896>; else goto <D.31897>;
            <D.31896>:
            D.31898 = &MEM[(void *)"sockaddr_dl" + 2B];
            D.31899 = *D.31898;
            D.31900 = (int) D.31899;
            D.31901 = __s2 + 2;
            D.31902 = *D.31901;
            D.31903 = (int) D.31902;
            __result = D.31900 - D.31903;
            D.31904 = __s2_len > 2;
            D.31884 = __result == 0;
            D.31905 = D.31904 & D.31884;
            if (D.31905 != 0) goto <D.31906>; else goto <D.31907>;
            <D.31906>:
            D.31908 = &MEM[(void *)"sockaddr_dl" + 3B];
            D.31909 = *D.31908;
            D.31910 = (int) D.31909;
            D.31911 = __s2 + 3;
            D.31912 = *D.31911;
            D.31913 = (int) D.31912;
            __result = D.31910 - D.31913;
            <D.31907>:
            <D.31897>:
            <D.31887>:
          }
          D.26768 = __result;
        }
        iftmp.123 = -D.26768;
        goto <D.31914>;
        <D.31877>:
        D.31915 = klass->name;
        iftmp.123 = __builtin_strcmp (D.31915, "sockaddr_dl");
        <D.31914>:
        D.26769 = iftmp.123;
      }
      if (D.26769 != 0) goto <D.31916>; else goto <D.31917>;
      <D.31916>:
      D.31802 = 1;
      return D.31802;
      <D.31917>:
      <D.31874>:
      D.31802 = can_marshal;
      return D.31802;
    }
  finally
    {
      iter = {CLOBBER};
    }
}


compile_methods (struct MonoAotCompile * acfg)
{
  int D.31921;
  struct GPtrArray * D.31924;
  unsigned int D.31925;
  unsigned int D.31926;
  unsigned int D.31927;
  _Bool D.31928;
  long int D.31929;
  long int D.31930;
  unsigned int methods_len.124;
  unsigned int D.31934;
  unsigned int i.125;
  unsigned int D.31936;
  struct MonoMethod * * D.31937;
  void * * D.31938;
  void * * D.31939;
  void * D.31940;
  struct MonoMethod * D.31943;
  struct MonoDomain * D.31944;
  void * * D.31945;
  void * * D.31946;
  void * * D.31947;
  void * * D.31948;
  void * D.31949;
  unsigned int i.126;
  unsigned int D.31951;
  int i;
  int methods_len;

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

    D.31924 = acfg->methods;
    D.31925 = D.31924->len;
    methods_len = (int) D.31925;
    D.31924 = acfg->methods;
    D.31925 = D.31924->len;
    D.31921 = acfg->aot_opts.nthreads;
    D.31926 = (unsigned int) D.31921;
    D.31927 = D.31925 / D.31926;
    len = (int) D.31927;
    D.31928 = len <= 0;
    D.31929 = (long int) D.31928;
    D.31930 = __builtin_expect (D.31929, 0);
    if (D.31930 != 0) goto <D.31931>; else goto <D.31932>;
    <D.31931>:
    monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "aot-compiler.c", 8377, "len > 0");
    <D.31932>:
    threads = monoeg_g_ptr_array_new ();
    methods_len.124 = (unsigned int) methods_len;
    D.31934 = methods_len.124 * 4;
    methods = monoeg_malloc0 (D.31934);
    i = 0;
    goto <D.28528>;
    <D.28527>:
    i.125 = (unsigned int) i;
    D.31936 = i.125 * 4;
    D.31937 = methods + D.31936;
    D.31924 = acfg->methods;
    D.31938 = D.31924->pdata;
    i.125 = (unsigned int) i;
    D.31936 = i.125 * 4;
    D.31939 = D.31938 + D.31936;
    D.31940 = *D.31939;
    *D.31937 = D.31940;
    i = i + 1;
    <D.28528>:
    if (i < methods_len) goto <D.28527>; else goto <D.28529>;
    <D.28529>:
    i = 0;
    goto <D.28534>;
    <D.28533>:
    frag = monoeg_g_ptr_array_new ();
    j = 0;
    goto <D.28531>;
    <D.28530>:
    if (i < methods_len) goto <D.31941>; else goto <D.31942>;
    <D.31941>:
    i.125 = (unsigned int) i;
    D.31936 = i.125 * 4;
    D.31937 = methods + D.31936;
    D.31943 = *D.31937;
    monoeg_g_ptr_array_add (frag, D.31943);
    i = i + 1;
    <D.31942>:
    j = j + 1;
    <D.28531>:
    if (j < len) goto <D.28530>; else goto <D.28532>;
    <D.28532>:
    user_data = monoeg_malloc0 (12);
    D.31944 = mono_domain_get ();
    *user_data = D.31944;
    D.31945 = user_data + 4;
    *D.31945 = acfg;
    D.31946 = user_data + 8;
    *D.31946 = frag;
    handle = mono_threads_create_thread (compile_thread_main, user_data, 0, 0, 0B);
    monoeg_g_ptr_array_add (threads, handle);
    <D.28534>:
    if (i < methods_len) goto <D.28533>; else goto <D.28535>;
    <D.28535>:
    monoeg_g_free (methods);
    i = 0;
    goto <D.28537>;
    <D.28536>:
    D.31947 = threads->pdata;
    i.125 = (unsigned int) i;
    D.31936 = i.125 * 4;
    D.31948 = D.31947 + D.31936;
    D.31949 = *D.31948;
    WaitForSingleObjectEx (D.31949, 4294967295, 0);
    i = i + 1;
    <D.28537>:
    i.126 = (unsigned int) i;
    D.31951 = threads->len;
    if (i.126 < D.31951) goto <D.28536>; else goto <D.28538>;
    <D.28538>:
  }
  goto <D.31952>;
  <D.31923>:
  methods_len = 0;
  <D.31952>:
  i = methods_len;
  goto <D.28540>;
  <D.28539>:
  D.31924 = acfg->methods;
  D.31938 = D.31924->pdata;
  i.125 = (unsigned int) i;
  D.31936 = i.125 * 4;
  D.31939 = D.31938 + D.31936;
  D.31940 = *D.31939;
  compile_method (acfg, D.31940);
  i = i + 1;
  <D.28540>:
  i.126 = (unsigned int) i;
  D.31924 = acfg->methods;
  D.31925 = D.31924->len;
  if (i.126 < D.31925) goto <D.28539>; else goto <D.28541>;
  <D.28541>:
}


compile_thread_main (void * * user_data)
{
  void * * D.31953;
  unsigned int i.127;
  unsigned int D.31955;
  void * * D.31956;
  void * D.31957;
  unsigned int i.128;
  unsigned int D.31959;
  struct MonoDomain * domain;
  struct MonoAotCompile * acfg;
  struct GPtrArray * methods;
  int i;

  domain = *user_data;
  acfg = MEM[(void * *)user_data + 4B];
  methods = MEM[(void * *)user_data + 8B];
  mono_thread_attach (domain);
  i = 0;
  goto <D.28090>;
  <D.28089>:
  D.31953 = methods->pdata;
  i.127 = (unsigned int) i;
  D.31955 = i.127 * 4;
  D.31956 = D.31953 + D.31955;
  D.31957 = *D.31956;
  compile_method (acfg, D.31957);
  i = i + 1;
  <D.28090>:
  i.128 = (unsigned int) i;
  D.31959 = methods->len;
  if (i.128 < D.31959) goto <D.28089>; else goto <D.28091>;
  <D.28091>:
}


compile_method (struct MonoAotCompile * acfg, struct MonoMethod * method)
{
  int D.31960;
  union mono_mutex_t * D.31963;
  _Bool D.31966;
  long int D.31967;
  long int D.31968;
  unsigned int D.31971;
  _Bool D.31974;
  long int D.31975;
  long int D.31976;
  short unsigned int D.31981;
  int D.31982;
  int D.31983;
  short unsigned int D.31985;
  int D.31986;
  int D.31987;
  int D.31989;
  int D.31990;
  short unsigned int D.31995;
  int D.31996;
  int D.31997;
  unsigned char D.32000;
  unsigned char D.32001;
  unsigned char D.32004;
  unsigned char D.32005;
  int * D.32008;
  unsigned int D.32009;
  struct MonoDomain * D.32010;
  JitFlags iftmp.129;
  int D.32012;
  unsigned int D.32016;
  int D.32019;
  char * D.32022;
  char * D.32023;
  int * D.32024;
  char * D.32029;
  unsigned char D.32030;
  unsigned char D.32031;
  char * D.32036;
  int * D.32037;
  unsigned int index.130;
  <unnamed type> D.32039;
  _Bool D.32042;
  long int D.32043;
  long int D.32044;
  struct GHashTable * D.32047;
  _Bool D.32050;
  long int D.32051;
  long int D.32052;
  char * D.32059;
  int * D.32060;
  _Bool D.32063;
  long int D.32064;
  long int D.32065;
  int D.32068;
  char * D.32075;
  int D.32076;
  int D.32077;
  _Bool D.32080;
  long int D.32081;
  long int D.32082;
  struct GHashTable * D.32085;
  void * D.32086;
  int D.32087;
  unsigned char D.32092;
  unsigned char D.32093;
  struct MonoClass * D.32098;
  int D.32099;
  int D.32101;
  int D.32102;
  short unsigned int D.32105;
  int D.32106;
  int D.32107;
  struct MonoMethod * D.32112;
  int D.32113;
  int D.32115;
  unsigned char D.32116;
  unsigned char D.32117;
  int D.28034;
  int iftmp.131;
  int D.28033;
  const char[12] * D.32123;
  unsigned char D.32124;
  int D.32125;
  unsigned char D.32126;
  int D.32127;
  _Bool D.32128;
  _Bool D.32129;
  _Bool D.32130;
  const unsigned char * D.32133;
  unsigned char D.32134;
  int D.32135;
  const unsigned char * D.32136;
  unsigned char D.32137;
  int D.32138;
  _Bool D.32139;
  _Bool D.32140;
  const unsigned char * D.32143;
  unsigned char D.32144;
  int D.32145;
  const unsigned char * D.32146;
  unsigned char D.32147;
  int D.32148;
  _Bool D.32149;
  _Bool D.32150;
  const unsigned char * D.32153;
  unsigned char D.32154;
  int D.32155;
  const unsigned char * D.32156;
  unsigned char D.32157;
  int D.32158;
  const char * D.32160;
  struct MonoGenericClass * D.32163;
  int D.32166;
  struct MonoClassField * D.32169;
  struct MonoGenericClass * D.32170;
  struct MonoGenericContext * D.32173;
  int D.32174;
  struct MonoMethod * D.32177;
  struct MonoMethod * D.32180;
  struct MonoImage * D.32181;
  struct MonoImage * D.32182;
  int D.32185;
  unsigned char D.32188;
  unsigned char D.32189;
  int * D.32192;
  struct MonoMemPool * D.32193;
  void * D.32197;
  struct GSList * D.32198;
  short unsigned int D.32199;
  int D.32200;
  <unnamed-unsigned:1> D.32201;
  int D.32202;
  int D.32203;
  unsigned int D.32204;
  unsigned int D.32205;
  unsigned int i.132;
  unsigned int D.32207;
  struct MonoInst * * D.32208;
  void * D.32209;
  struct MonoInst * D.32210;
  struct MonoInst * * D.32211;
  struct MonoInst * * D.32212;
  struct MonoInst * D.32213;
  short unsigned int D.32214;
  unsigned int D.32215;
  unsigned int D.32216;
  struct MonoInst * * D.32217;
  void * D.32218;
  struct MonoInst * D.32219;
  struct MonoInst * * D.32220;
  struct MonoInst * * D.32221;
  struct MonoInst * D.32222;
  int D.32223;
  struct MonoMemPool * D.32224;
  struct MonoInst * * D.32225;
  struct MonoMethodVar * D.32226;
  struct MonoRegState * D.32227;
  int D.32230;
  unsigned int new_size.133;
  unsigned int D.32232;
  struct MonoCompile * * D.32233;
  unsigned int D.32234;
  unsigned int D.32235;
  unsigned int index.134;
  unsigned int D.32237;
  struct MonoCompile * * D.32238;
  struct GHashTable * D.32239;
  struct MonoMethod * D.32240;
  _Bool D.32243;
  long int D.32244;
  long int D.32245;
  int * D.32248;
  struct MonoCompile * cfg;
  struct MonoJumpInfo * patch_info;
  gboolean skip;
  int index;
  int depth;
  struct MonoMethod * wrapped;

  D.31960 = acfg->aot_opts.metadata_only;
  if (D.31960 != 0) goto <D.31961>; else goto <D.31962>;
  <D.31961>:
  return;
  <D.31962>:
  {
    int ret;

    D.31963 = &acfg->mutex.mutex;
    ret = pthread_mutex_lock (D.31963);
    if (ret != 0) goto <D.31964>; else goto <D.31965>;
    <D.31964>:
    monoeg_g_log (0B, 16, "Bad call to mono_mutex_lock result %d", ret);
    <D.31965>:
    D.31966 = ret != 0;
    D.31967 = (long int) D.31966;
    D.31968 = __builtin_expect (D.31967, 0);
    if (D.31968 != 0) goto <D.31969>; else goto <D.31970>;
    <D.31969>:
    monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "aot-compiler.c", 6458, "ret == 0");
    <D.31970>:
  }
  D.31971 = get_method_index (acfg, method);
  index = (int) D.31971;
  {
    int ret;

    D.31963 = &acfg->mutex.mutex;
    ret = pthread_mutex_unlock (D.31963);
    if (ret != 0) goto <D.31972>; else goto <D.31973>;
    <D.31972>:
    monoeg_g_log (0B, 16, "Bad call to mono_mutex_unlock result %d", ret);
    <D.31973>:
    D.31974 = ret != 0;
    D.31975 = (long int) D.31974;
    D.31976 = __builtin_expect (D.31975, 0);
    if (D.31976 != 0) goto <D.31977>; else goto <D.31978>;
    <D.31977>:
    monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "aot-compiler.c", 6460, "ret == 0");
    <D.31978>:
  }
  D.31981 = method->flags;
  D.31982 = (int) D.31981;
  D.31983 = D.31982 & 8192;
  if (D.31983 != 0) goto <D.31979>; else goto <D.31984>;
  <D.31984>:
  D.31985 = method->iflags;
  D.31986 = (int) D.31985;
  D.31987 = D.31986 & 3;
  if (D.31987 != 0) goto <D.31979>; else goto <D.31988>;
  <D.31988>:
  D.31981 = method->flags;
  D.31982 = (int) D.31981;
  D.31989 = D.31982 & 1024;
  if (D.31989 != 0) goto <D.31979>; else goto <D.31980>;
  <D.31979>:
  return;
  <D.31980>:
  D.31985 = method->iflags;
  D.31986 = (int) D.31985;
  D.31990 = D.31986 & 4096;
  if (D.31990 != 0) goto <D.31991>; else goto <D.31992>;
  <D.31991>:
  return;
  <D.31992>:
  wrapped = mono_marshal_method_from_wrapper (method);
  if (wrapped != 0B) goto <D.31993>; else goto <D.31994>;
  <D.31993>:
  D.31995 = wrapped->iflags;
  D.31996 = (int) D.31995;
  D.31997 = D.31996 & 4096;
  if (D.31997 != 0) goto <D.31998>; else goto <D.31999>;
  <D.31998>:
  D.32000 = BIT_FIELD_REF <*wrapped, 8, 168>;
  D.32001 = D.32000 & 8;
  if (D.32001 != 0) goto <D.32002>; else goto <D.32003>;
  <D.32002>:
  return;
  <D.32003>:
  <D.31999>:
  <D.31994>:
  D.32004 = BIT_FIELD_REF <*method, 8, 160>;
  D.32005 = D.32004 & 124;
  if (D.32005 == 108) goto <D.32006>; else goto <D.32007>;
  <D.32006>:
  return;
  <D.32007>:
  D.32008 = &acfg->stats.mcount;
  InterlockedIncrement (D.32008);
  D.32009 = acfg->opts;
  D.32010 = mono_get_root_domain ();
  D.32012 = acfg->aot_opts.full_aot;
  if (D.32012 != 0) goto <D.32013>; else goto <D.32014>;
  <D.32013>:
  iftmp.129 = 6;
  goto <D.32015>;
  <D.32014>:
  iftmp.129 = 2;
  <D.32015>:
  cfg = mini_method_compile (method, D.32009, D.32010, iftmp.129, 0);
  mono_loader_clear_error ();
  D.32016 = cfg->exception_type;
  if (D.32016 == 11) goto <D.32017>; else goto <D.32018>;
  <D.32017>:
  D.32019 = acfg->aot_opts.print_skipped_methods;
  if (D.32019 != 0) goto <D.32020>; else goto <D.32021>;
  <D.32020>:
  D.32022 = mono_method_full_name (method, 1);
  D.32023 = cfg->exception_message;
  printf ("Skip (gshared failure): %s (%s)\n", D.32022, D.32023);
  <D.32021>:
  D.32024 = &acfg->stats.genericcount;
  InterlockedIncrement (D.32024);
  return;
  <D.32018>:
  D.32016 = cfg->exception_type;
  if (D.32016 != 0) goto <D.32025>; else goto <D.32026>;
  <D.32025>:
  D.32019 = acfg->aot_opts.print_skipped_methods;
  if (D.32019 != 0) goto <D.32027>; else goto <D.32028>;
  <D.32027>:
  D.32029 = mono_method_full_name (method, 1);
  printf ("Skip (JIT failure): %s\n", D.32029);
  <D.32028>:
  return;
  <D.32026>:
  D.32030 = BIT_FIELD_REF <*cfg, 8, 3392>;
  D.32031 = D.32030 & 1;
  if (D.32031 != 0) goto <D.32032>; else goto <D.32033>;
  <D.32032>:
  D.32019 = acfg->aot_opts.print_skipped_methods;
  if (D.32019 != 0) goto <D.32034>; else goto <D.32035>;
  <D.32034>:
  D.32036 = mono_method_full_name (method, 1);
  printf ("Skip (disabled): %s\n", D.32036);
  <D.32035>:
  D.32037 = &acfg->stats.ocount;
  InterlockedIncrement (D.32037);
  mono_destroy_compile (cfg);
  return;
  <D.32033>:
  index.130 = (unsigned int) index;
  cfg->method_index = index.130;
  patch_info = cfg->patch_info;
  goto <D.28009>;
  <D.28008>:
  D.32039 = patch_info->type;
  switch (D.32039) <default: <D.28007>, case 0: <D.28005>, case 2: <D.28004>>
  <D.28004>:
  <D.28005>:
  patch_info->type = 51;
  goto <D.28006>;
  <D.28007>:
  goto <D.28006>;
  <D.28006>:
  patch_info = patch_info->next;
  <D.28009>:
  if (patch_info != 0B) goto <D.28008>; else goto <D.28010>;
  <D.28010>:
  {
    int ret;

    D.31963 = &acfg->mutex.mutex;
    ret = pthread_mutex_lock (D.31963);
    if (ret != 0) goto <D.32040>; else goto <D.32041>;
    <D.32040>:
    monoeg_g_log (0B, 16, "Bad call to mono_mutex_lock result %d", ret);
    <D.32041>:
    D.32042 = ret != 0;
    D.32043 = (long int) D.32042;
    D.32044 = __builtin_expect (D.32043, 0);
    if (D.32044 != 0) goto <D.32045>; else goto <D.32046>;
    <D.32045>:
    monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "aot-compiler.c", 6536, "ret == 0");
    <D.32046>:
  }
  D.32047 = cfg->token_info_hash;
  monoeg_g_hash_table_foreach (D.32047, add_token_info_hash, acfg);
  {
    int ret;

    D.31963 = &acfg->mutex.mutex;
    ret = pthread_mutex_unlock (D.31963);
    if (ret != 0) goto <D.32048>; else goto <D.32049>;
    <D.32048>:
    monoeg_g_log (0B, 16, "Bad call to mono_mutex_unlock result %d", ret);
    <D.32049>:
    D.32050 = ret != 0;
    D.32051 = (long int) D.32050;
    D.32052 = __builtin_expect (D.32051, 0);
    if (D.32052 != 0) goto <D.32053>; else goto <D.32054>;
    <D.32053>:
    monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "aot-compiler.c", 6538, "ret == 0");
    <D.32054>:
  }
  skip = 0;
  patch_info = cfg->patch_info;
  goto <D.28017>;
  <D.28016>:
  D.32039 = patch_info->type;
  switch (D.32039) <default: <D.28015>, case 1: <D.28013>>
  <D.28013>:
  skip = 1;
  goto <D.28014>;
  <D.28015>:
  goto <D.28014>;
  <D.28014>:
  patch_info = patch_info->next;
  <D.28017>:
  if (patch_info != 0B) goto <D.28016>; else goto <D.28018>;
  <D.28018>:
  if (skip != 0) goto <D.32055>; else goto <D.32056>;
  <D.32055>:
  D.32019 = acfg->aot_opts.print_skipped_methods;
  if (D.32019 != 0) goto <D.32057>; else goto <D.32058>;
  <D.32057>:
  D.32059 = mono_method_full_name (method, 1);
  printf ("Skip (abs call): %s\n", D.32059);
  <D.32058>:
  D.32060 = &acfg->stats.abscount;
  InterlockedIncrement (D.32060);
  mono_destroy_compile (cfg);
  return;
  <D.32056>:
  {
    int ret;

    D.31963 = &acfg->mutex.mutex;
    ret = pthread_mutex_lock (D.31963);
    if (ret != 0) goto <D.32061>; else goto <D.32062>;
    <D.32061>:
    monoeg_g_log (0B, 16, "Bad call to mono_mutex_lock result %d", ret);
    <D.32062>:
    D.32063 = ret != 0;
    D.32064 = (long int) D.32063;
    D.32065 = __builtin_expect (D.32064, 0);
    if (D.32065 != 0) goto <D.32066>; else goto <D.32067>;
    <D.32066>:
    monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "aot-compiler.c", 6564, "ret == 0");
    <D.32067>:
  }
  skip = 0;
  patch_info = cfg->patch_info;
  goto <D.28021>;
  <D.28020>:
  D.32068 = can_encode_patch (acfg, patch_info);
  if (D.32068 == 0) goto <D.32069>; else goto <D.32070>;
  <D.32069>:
  skip = 1;
  <D.32070>:
  patch_info = patch_info->next;
  <D.28021>:
  if (patch_info != 0B) goto <D.28020>; else goto <D.28022>;
  <D.28022>:
  if (skip != 0) goto <D.32071>; else goto <D.32072>;
  <D.32071>:
  D.32019 = acfg->aot_opts.print_skipped_methods;
  if (D.32019 != 0) goto <D.32073>; else goto <D.32074>;
  <D.32073>:
  D.32075 = mono_method_full_name (method, 1);
  printf ("Skip (patches): %s\n", D.32075);
  <D.32074>:
  D.32076 = acfg->stats.ocount;
  D.32077 = D.32076 + 1;
  acfg->stats.ocount = D.32077;
  mono_destroy_compile (cfg);
  {
    int ret;

    D.31963 = &acfg->mutex.mutex;
    ret = pthread_mutex_unlock (D.31963);
    if (ret != 0) goto <D.32078>; else goto <D.32079>;
    <D.32078>:
    monoeg_g_log (0B, 16, "Bad call to mono_mutex_unlock result %d", ret);
    <D.32079>:
    D.32080 = ret != 0;
    D.32081 = (long int) D.32080;
    D.32082 = __builtin_expect (D.32081, 0);
    if (D.32082 != 0) goto <D.32083>; else goto <D.32084>;
    <D.32083>:
    monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "aot-compiler.c", 6580, "ret == 0");
    <D.32084>:
  }
  return;
  <D.32072>:
  D.32085 = acfg->method_depth;
  D.32086 = monoeg_g_hash_table_lookup (D.32085, method);
  depth = (int) D.32086;
  D.32087 = acfg->aot_opts.no_instances;
  if (D.32087 == 0) goto <D.32088>; else goto <D.32089>;
  <D.32088>:
  if (depth <= 31) goto <D.32090>; else goto <D.32091>;
  <D.32090>:
  patch_info = cfg->patch_info;
  goto <D.28042>;
  <D.28041>:
  D.32039 = patch_info->type;
  switch (D.32039) <default: <D.28040>, case 3: <D.28024>, case 14: <D.28036>, case 16: <D.28038>>
  <D.28024>:
  {
    struct MonoMethod * m;

    m = patch_info->data.method;
    D.32092 = BIT_FIELD_REF <*m, 8, 168>;
    D.32093 = D.32092 & 16;
    if (D.32093 != 0) goto <D.32094>; else goto <D.32095>;
    <D.32094>:
    D.32098 = m->klass;
    D.32099 = mono_class_generic_sharing_enabled (D.32098);
    if (D.32099 == 0) goto <D.32096>; else goto <D.32100>;
    <D.32100>:
    D.32101 = mono_method_is_generic_sharable_full (m, 0, 0, 0);
    if (D.32101 == 0) goto <D.32096>; else goto <D.32097>;
    <D.32096>:
    D.32102 = method_has_type_vars (m);
    if (D.32102 == 0) goto <D.32103>; else goto <D.32104>;
    <D.32103>:
    D.32105 = m->iflags;
    D.32106 = (int) D.32105;
    D.32107 = D.32106 & 4096;
    if (D.32107 != 0) goto <D.32108>; else goto <D.32109>;
    <D.32108>:
    D.32012 = acfg->aot_opts.full_aot;
    if (D.32012 != 0) goto <D.32110>; else goto <D.32111>;
    <D.32110>:
    D.32112 = mono_marshal_get_native_wrapper (m, 1, 1);
    D.32113 = depth + 1;
    add_extra_method_with_depth (acfg, D.32112, D.32113);
    <D.32111>:
    goto <D.32114>;
    <D.32109>:
    D.32113 = depth + 1;
    add_extra_method_with_depth (acfg, m, D.32113);
    add_types_from_method_header (acfg, m);
    <D.32114>:
    <D.32104>:
    <D.32097>:
    D.32098 = m->klass;
    D.32115 = depth + 5;
    add_generic_class_with_depth (acfg, D.32098, D.32115, "method");
    <D.32095>:
    D.32116 = BIT_FIELD_REF <*m, 8, 160>;
    D.32117 = D.32116 & 124;
    if (D.32117 == 28) goto <D.32118>; else goto <D.32119>;
    <D.32118>:
    {
      size_t __s1_len;
      size_t __s2_len;

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

        __s2 = m->name;
        D.32123 = "ElementAddr";
        D.32124 = MEM[(const unsigned char *)D.32123];
        D.32125 = (int) D.32124;
        D.32126 = *__s2;
        D.32127 = (int) D.32126;
        __result = D.32125 - D.32127;
        {
          D.32128 = __s2_len != 0;
          D.32129 = __result == 0;
          D.32130 = D.32128 & D.32129;
          if (D.32130 != 0) goto <D.32131>; else goto <D.32132>;
          <D.32131>:
          D.32133 = &MEM[(void *)"ElementAddr" + 1B];
          D.32134 = *D.32133;
          D.32135 = (int) D.32134;
          D.32136 = __s2 + 1;
          D.32137 = *D.32136;
          D.32138 = (int) D.32137;
          __result = D.32135 - D.32138;
          D.32139 = __s2_len > 1;
          D.32129 = __result == 0;
          D.32140 = D.32139 & D.32129;
          if (D.32140 != 0) goto <D.32141>; else goto <D.32142>;
          <D.32141>:
          D.32143 = &MEM[(void *)"ElementAddr" + 2B];
          D.32144 = *D.32143;
          D.32145 = (int) D.32144;
          D.32146 = __s2 + 2;
          D.32147 = *D.32146;
          D.32148 = (int) D.32147;
          __result = D.32145 - D.32148;
          D.32149 = __s2_len > 2;
          D.32129 = __result == 0;
          D.32150 = D.32149 & D.32129;
          if (D.32150 != 0) goto <D.32151>; else goto <D.32152>;
          <D.32151>:
          D.32153 = &MEM[(void *)"ElementAddr" + 3B];
          D.32154 = *D.32153;
          D.32155 = (int) D.32154;
          D.32156 = __s2 + 3;
          D.32157 = *D.32156;
          D.32158 = (int) D.32157;
          __result = D.32155 - D.32158;
          <D.32152>:
          <D.32142>:
          <D.32132>:
        }
        D.28033 = __result;
      }
      iftmp.131 = -D.28033;
      goto <D.32159>;
      <D.32122>:
      D.32160 = m->name;
      iftmp.131 = __builtin_strcmp (D.32160, "ElementAddr");
      <D.32159>:
      D.28034 = iftmp.131;
    }
    if (D.28034 == 0) goto <D.32161>; else goto <D.32162>;
    <D.32161>:
    D.32113 = depth + 1;
    add_extra_method_with_depth (acfg, m, D.32113);
    <D.32162>:
    <D.32119>:
    goto <D.28035>;
  }
  <D.28036>:
  {
    struct MonoClass * klass;

    klass = patch_info->data.klass;
    D.32163 = klass->generic_class;
    if (D.32163 != 0B) goto <D.32164>; else goto <D.32165>;
    <D.32164>:
    D.32166 = mini_class_is_generic_sharable (klass);
    if (D.32166 == 0) goto <D.32167>; else goto <D.32168>;
    <D.32167>:
    D.32115 = depth + 5;
    add_generic_class_with_depth (acfg, klass, D.32115, "vtable");
    <D.32168>:
    <D.32165>:
    goto <D.28035>;
  }
  <D.28038>:
  {
    struct MonoClass * klass;

    D.32169 = patch_info->data.field;
    klass = D.32169->parent;
    D.32170 = klass->generic_class;
    if (D.32170 != 0B) goto <D.32171>; else goto <D.32172>;
    <D.32171>:
    D.32170 = klass->generic_class;
    D.32173 = &D.32170->context;
    D.32174 = mono_generic_context_is_sharable (D.32173, 0);
    if (D.32174 == 0) goto <D.32175>; else goto <D.32176>;
    <D.32175>:
    D.32177 = mono_class_get_cctor (klass);
    if (D.32177 != 0B) goto <D.32178>; else goto <D.32179>;
    <D.32178>:
    D.32180 = mono_class_get_cctor (klass);
    D.32113 = depth + 1;
    add_extra_method_with_depth (acfg, D.32180, D.32113);
    <D.32179>:
    <D.32176>:
    <D.32172>:
    goto <D.28035>;
  }
  <D.28040>:
  goto <D.28035>;
  <D.28035>:
  patch_info = patch_info->next;
  <D.28042>:
  if (patch_info != 0B) goto <D.28041>; else goto <D.28043>;
  <D.28043>:
  <D.32091>:
  <D.32089>:
  patch_info = cfg->patch_info;
  goto <D.28051>;
  <D.28050>:
  D.32039 = patch_info->type;
  switch (D.32039) <default: <D.28049>, case 12: <D.28048>, case 27: <D.28044>, case 42: <D.28046>, case 51: <D.28045>>
  <D.28044>:
  <D.28045>:
  <D.28046>:
  goto <D.28047>;
  <D.28048>:
  D.32181 = patch_info->data.image;
  D.32182 = acfg->image;
  if (D.32181 != D.32182) goto <D.32183>; else goto <D.32184>;
  <D.32183>:
  cfg->has_got_slots = 1;
  <D.32184>:
  goto <D.28047>;
  <D.28049>:
  D.32185 = is_plt_patch (patch_info);
  if (D.32185 == 0) goto <D.32186>; else goto <D.32187>;
  <D.32186>:
  cfg->has_got_slots = 1;
  <D.32187>:
  goto <D.28047>;
  <D.28047>:
  patch_info = patch_info->next;
  <D.28051>:
  if (patch_info != 0B) goto <D.28050>; else goto <D.28052>;
  <D.28052>:
  D.32188 = BIT_FIELD_REF <*cfg, 8, 3424>;
  D.32189 = D.32188 & 1;
  if (D.32189 == 0) goto <D.32190>; else goto <D.32191>;
  <D.32190>:
  D.32192 = &acfg->stats.methods_without_got_slots;
  InterlockedIncrement (D.32192);
  <D.32191>:
  {
    struct MonoJumpInfo * patches;
    struct MonoJumpInfo * patches_end;

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

      D.32193 = acfg->mempool;
      new_patch_info = mono_patch_info_dup_mp (D.32193, patch_info);
      if (patches == 0B) goto <D.32194>; else goto <D.32195>;
      <D.32194>:
      patches = new_patch_info;
      goto <D.32196>;
      <D.32195>:
      patches_end->next = new_patch_info;
      <D.32196>:
      patches_end = new_patch_info;
    }
    patch_info = patch_info->next;
    <D.28057>:
    if (patch_info != 0B) goto <D.28056>; else goto <D.28058>;
    <D.28058>:
    cfg->patch_info = patches;
  }
  {
    struct GSList * l;
    struct GSList * unwind_ops;
    struct MonoUnwindOp * op;

    unwind_ops = 0B;
    l = cfg->unwind_ops;
    goto <D.28063>;
    <D.28062>:
    D.32193 = acfg->mempool;
    op = mono_mempool_alloc (D.32193, 12);
    D.32197 = l->data;
    memcpy (op, D.32197, 12);
    D.32193 = acfg->mempool;
    unwind_ops = g_slist_prepend_mempool (D.32193, unwind_ops, op);
    l = l->next;
    <D.28063>:
    if (l != 0B) goto <D.28062>; else goto <D.28064>;
    <D.28064>:
    D.32198 = monoeg_g_slist_reverse (unwind_ops);
    cfg->unwind_ops = D.32198;
  }
  {
    struct MonoInst * * args;
    struct MonoInst * * locals;
    struct MonoMethodSignature * sig;
    struct MonoMethodHeader * header;
    int i;

    sig = mono_method_signature (method);
    D.32193 = acfg->mempool;
    D.32199 = sig->param_count;
    D.32200 = (int) D.32199;
    D.32201 = sig->hasthis;
    D.32202 = (int) D.32201;
    D.32203 = D.32200 + D.32202;
    D.32204 = (unsigned int) D.32203;
    D.32205 = D.32204 * 4;
    args = mono_mempool_alloc (D.32193, D.32205);
    i = 0;
    goto <D.28071>;
    <D.28070>:
    i.132 = (unsigned int) i;
    D.32207 = i.132 * 4;
    D.32208 = args + D.32207;
    D.32193 = acfg->mempool;
    D.32209 = mono_mempool_alloc (D.32193, 56);
    *D.32208 = D.32209;
    i.132 = (unsigned int) i;
    D.32207 = i.132 * 4;
    D.32208 = args + D.32207;
    D.32210 = *D.32208;
    D.32211 = cfg->args;
    i.132 = (unsigned int) i;
    D.32207 = i.132 * 4;
    D.32212 = D.32211 + D.32207;
    D.32213 = *D.32212;
    memcpy (D.32210, D.32213, 56);
    i = i + 1;
    <D.28071>:
    D.32199 = sig->param_count;
    D.32200 = (int) D.32199;
    D.32201 = sig->hasthis;
    D.32202 = (int) D.32201;
    D.32203 = D.32200 + D.32202;
    if (D.32203 > i) goto <D.28070>; else goto <D.28072>;
    <D.28072>:
    cfg->args = args;
    header = mono_method_get_header (method);
    D.32193 = acfg->mempool;
    D.32214 = header->num_locals;
    D.32215 = (unsigned int) D.32214;
    D.32216 = D.32215 * 4;
    locals = mono_mempool_alloc (D.32193, D.32216);
    i = 0;
    goto <D.28074>;
    <D.28073>:
    i.132 = (unsigned int) i;
    D.32207 = i.132 * 4;
    D.32217 = locals + D.32207;
    D.32193 = acfg->mempool;
    D.32218 = mono_mempool_alloc (D.32193, 56);
    *D.32217 = D.32218;
    i.132 = (unsigned int) i;
    D.32207 = i.132 * 4;
    D.32217 = locals + D.32207;
    D.32219 = *D.32217;
    D.32220 = cfg->locals;
    i.132 = (unsigned int) i;
    D.32207 = i.132 * 4;
    D.32221 = D.32220 + D.32207;
    D.32222 = *D.32221;
    memcpy (D.32219, D.32222, 56);
    i = i + 1;
    <D.28074>:
    D.32214 = header->num_locals;
    D.32223 = (int) D.32214;
    if (D.32223 > i) goto <D.28073>; else goto <D.28075>;
    <D.28075>:
    cfg->locals = locals;
  }
  D.32224 = cfg->mempool;
  mono_mempool_destroy (D.32224);
  cfg->mempool = 0B;
  D.32225 = cfg->varinfo;
  monoeg_g_free (D.32225);
  cfg->varinfo = 0B;
  D.32226 = cfg->vars;
  monoeg_g_free (D.32226);
  cfg->vars = 0B;
  D.32227 = cfg->rs;
  if (D.32227 != 0B) goto <D.32228>; else goto <D.32229>;
  <D.32228>:
  D.32227 = cfg->rs;
  mono_regstate_free (D.32227);
  cfg->rs = 0B;
  <D.32229>:
  goto <D.28079>;
  <D.28078>:
  {
    struct MonoCompile * * new_cfgs;
    int new_size;

    D.32230 = acfg->cfgs_size;
    new_size = D.32230 * 2;
    new_size.133 = (unsigned int) new_size;
    D.32232 = new_size.133 * 4;
    new_cfgs = monoeg_malloc0 (D.32232);
    D.32233 = acfg->cfgs;
    D.32230 = acfg->cfgs_size;
    D.32234 = (unsigned int) D.32230;
    D.32235 = D.32234 * 4;
    memcpy (new_cfgs, D.32233, D.32235);
    D.32233 = acfg->cfgs;
    monoeg_g_free (D.32233);
    acfg->cfgs = new_cfgs;
    acfg->cfgs_size = new_size;
  }
  <D.28079>:
  D.32230 = acfg->cfgs_size;
  if (D.32230 <= index) goto <D.28078>; else goto <D.28080>;
  <D.28080>:
  D.32233 = acfg->cfgs;
  index.134 = (unsigned int) index;
  D.32237 = index.134 * 4;
  D.32238 = D.32233 + D.32237;
  *D.32238 = cfg;
  D.32239 = acfg->method_to_cfg;
  D.32240 = cfg->orig_method;
  monoeg_g_hash_table_insert_replace (D.32239, D.32240, cfg, 0);
  {
    int ret;

    D.31963 = &acfg->mutex.mutex;
    ret = pthread_mutex_unlock (D.31963);
    if (ret != 0) goto <D.32241>; else goto <D.32242>;
    <D.32241>:
    monoeg_g_log (0B, 16, "Bad call to mono_mutex_unlock result %d", ret);
    <D.32242>:
    D.32243 = ret != 0;
    D.32244 = (long int) D.32243;
    D.32245 = __builtin_expect (D.32244, 0);
    if (D.32245 != 0) goto <D.32246>; else goto <D.32247>;
    <D.32246>:
    monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "aot-compiler.c", 6745, "ret == 0");
    <D.32247>:
  }
  D.32248 = &acfg->stats.ccount;
  InterlockedIncrement (D.32248);
}


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

  method = key;
  ji = value;
  new_ji = monoeg_malloc0 (20);
  acfg = user_data;
  D.32254 = ji->image;
  new_ji->image = D.32254;
  D.32255 = ji->token;
  new_ji->token = D.32255;
  D.32256 = acfg->token_info_hash;
  monoeg_g_hash_table_insert_replace (D.32256, method, new_ji, 0);
}


method_has_type_vars (struct MonoMethod * method)
{
  struct MonoClass * D.32257;
  int D.32258;
  gboolean D.32261;
  unsigned char D.32262;
  unsigned char D.32263;
  struct MonoGenericInst * D.32266;
  struct MonoType * D.32269;
  struct MonoClass * D.32270;
  int D.32271;
  <unnamed-unsigned:22> D.32274;
  int D.32275;

  D.32257 = method->klass;
  D.32258 = has_type_vars (D.32257);
  if (D.32258 != 0) goto <D.32259>; else goto <D.32260>;
  <D.32259>:
  D.32261 = 1;
  return D.32261;
  <D.32260>:
  D.32262 = BIT_FIELD_REF <*method, 8, 168>;
  D.32263 = D.32262 & 16;
  if (D.32263 != 0) goto <D.32264>; else goto <D.32265>;
  <D.32264>:
  {
    struct MonoGenericContext * context;

    context = mono_method_get_context (method);
    D.32266 = context->method_inst;
    if (D.32266 != 0B) goto <D.32267>; else goto <D.32268>;
    <D.32267>:
    {
      int i;

      i = 0;
      goto <D.26977>;
      <D.26976>:
      D.32266 = context->method_inst;
      D.32269 = D.32266->type_argv[i];
      D.32270 = mono_class_from_mono_type (D.32269);
      D.32271 = has_type_vars (D.32270);
      if (D.32271 != 0) goto <D.32272>; else goto <D.32273>;
      <D.32272>:
      D.32261 = 1;
      return D.32261;
      <D.32273>:
      i = i + 1;
      <D.26977>:
      D.32266 = context->method_inst;
      D.32274 = D.32266->type_argc;
      D.32275 = (int) D.32274;
      if (D.32275 > i) goto <D.26976>; else goto <D.26978>;
      <D.26978>:
    }
    <D.32268>:
  }
  <D.32265>:
  D.32261 = 0;
  return D.32261;
}


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

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


InterlockedIncrement (volatile gint32 * val)
{
  gint32 D.32279;
  unsigned int D.32280;

  D.32280 = __sync_add_and_fetch_4 (val, 1);
  D.32279 = (gint32) D.32280;
  return D.32279;
}


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

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


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

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


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

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


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

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


emit_code (struct MonoAotCompile * acfg)
{
  int D.32286;
  struct MonoCompile * * D.32289;
  unsigned int i.135;
  unsigned int D.32291;
  struct MonoCompile * * D.32292;
  struct MonoCompile * D.32293;
  unsigned char D.32296;
  unsigned char D.32297;
  char * D.32300;
  gchar * D.32301;
  unsigned int i.136;
  unsigned int D.32303;
  char * D.32304;
  gchar * D.32307;
  struct GPtrArray * D.32308;
  void * * D.32309;
  unsigned int oindex.137;
  unsigned int D.32311;
  void * * D.32312;
  void * D.32313;
  int D.32316;
  struct MonoMethod * D.32319;
  struct MonoClass * D.32320;
  unsigned char D.32321;
  unsigned char D.32322;
  unsigned int D.32325;
  int D.32326;
  unsigned char D.32329;
  unsigned char D.32330;
  struct FILE * D.32333;
  char * D.32334;
  int D.32341;
  int D.32342;
  unsigned int oindex.138;
  unsigned int D.32345;
  int D.32348;
  int D.32355;
  unsigned int D.32356;
  unsigned int D.32357;
  unsigned int D.32358;
  int D.32359;
  int D.32363;
  struct MonoMethod * D.32371;
  struct MonoClass * D.32372;
  unsigned char D.32373;
  unsigned char D.32374;
  unsigned int D.32377;
  unsigned char D.32383;
  unsigned char D.32384;
  _Bool D.32387;
  long int D.32388;
  long int D.32389;
  int oindex;
  int i;
  int prev_index;
  char symbol[256];

  try
    {
      emit_section_change (acfg, ".text", 0);
      emit_alignment (acfg, 8);
      D.32286 = acfg->llvm;
      if (D.32286 != 0) goto <D.32287>; else goto <D.32288>;
      <D.32287>:
      i = 0;
      goto <D.28165>;
      <D.28164>:
      D.32289 = acfg->cfgs;
      i.135 = (unsigned int) i;
      D.32291 = i.135 * 4;
      D.32292 = D.32289 + D.32291;
      D.32293 = *D.32292;
      if (D.32293 != 0B) goto <D.32294>; else goto <D.32295>;
      <D.32294>:
      D.32289 = acfg->cfgs;
      i.135 = (unsigned int) i;
      D.32291 = i.135 * 4;
      D.32292 = D.32289 + D.32291;
      D.32293 = *D.32292;
      D.32296 = BIT_FIELD_REF <*D.32293, 8, 3400>;
      D.32297 = D.32296 & 1;
      if (D.32297 != 0) goto <D.32298>; else goto <D.32299>;
      <D.32298>:
      D.32289 = acfg->cfgs;
      i.135 = (unsigned int) i;
      D.32291 = i.135 * 4;
      D.32292 = D.32289 + D.32291;
      D.32293 = *D.32292;
      D.32300 = D.32293->asm_symbol;
      D.32301 = monoeg_strdup (D.32300);
      acfg->methods_symbol = D.32301;
      goto <D.28163>;
      <D.32299>:
      <D.32295>:
      i = i + 1;
      <D.28165>:
      i.136 = (unsigned int) i;
      D.32303 = acfg->nmethods;
      if (i.136 < D.32303) goto <D.28164>; else goto <D.28163>;
      <D.28163>:
      <D.32288>:
      D.32304 = acfg->methods_symbol;
      if (D.32304 == 0B) goto <D.32305>; else goto <D.32306>;
      <D.32305>:
      sprintf (&symbol, "methods");
      emit_label (acfg, &symbol);
      D.32307 = monoeg_strdup (&symbol);
      acfg->methods_symbol = D.32307;
      <D.32306>:
      emit_zero_bytes (acfg, 16);
      oindex = 0;
      goto <D.28170>;
      <D.28169>:
      {
        struct MonoCompile * cfg;
        struct MonoMethod * method;

        D.32308 = acfg->method_order;
        D.32309 = D.32308->pdata;
        oindex.137 = (unsigned int) oindex;
        D.32311 = oindex.137 * 4;
        D.32312 = D.32309 + D.32311;
        D.32313 = *D.32312;
        i = (int) D.32313;
        D.32289 = acfg->cfgs;
        i.135 = (unsigned int) i;
        D.32291 = i.135 * 4;
        D.32292 = D.32289 + D.32291;
        cfg = *D.32292;
        if (cfg == 0B) goto <D.32314>; else goto <D.32315>;
        <D.32314>:
        // predicted unlikely by continue predictor.
        goto <D.28168>;
        <D.32315>:
        method = cfg->orig_method;
        D.32316 = acfg->aot_opts.full_aot;
        if (D.32316 != 0) goto <D.32317>; else goto <D.32318>;
        <D.32317>:
        D.32319 = cfg->orig_method;
        D.32320 = D.32319->klass;
        D.32321 = BIT_FIELD_REF <*D.32320, 8, 160>;
        D.32322 = D.32321 & 8;
        if (D.32322 != 0) goto <D.32323>; else goto <D.32324>;
        <D.32323>:
        D.32325 = get_method_index (acfg, method);
        sprintf (&symbol, "ut_%d", D.32325);
        emit_section_change (acfg, ".text", 0);
        D.32326 = acfg->thumb_mixed;
        if (D.32326 != 0) goto <D.32327>; else goto <D.32328>;
        <D.32327>:
        D.32329 = BIT_FIELD_REF <*cfg, 8, 3400>;
        D.32330 = D.32329 & 1;
        if (D.32330 != 0) goto <D.32331>; else goto <D.32332>;
        <D.32331>:
        emit_set_thumb_mode (acfg);
        D.32333 = acfg->fp;
        fprintf (D.32333, "\n.thumb_func\n");
        <D.32332>:
        <D.32328>:
        emit_label (acfg, &symbol);
        D.32319 = cfg->orig_method;
        D.32334 = cfg->asm_symbol;
        arch_emit_unbox_trampoline (acfg, cfg, D.32319, D.32334);
        D.32326 = acfg->thumb_mixed;
        if (D.32326 != 0) goto <D.32335>; else goto <D.32336>;
        <D.32335>:
        D.32329 = BIT_FIELD_REF <*cfg, 8, 3400>;
        D.32330 = D.32329 & 1;
        if (D.32330 != 0) goto <D.32337>; else goto <D.32338>;
        <D.32337>:
        emit_set_arm_mode (acfg);
        <D.32338>:
        <D.32336>:
        <D.32324>:
        <D.32318>:
        D.32329 = BIT_FIELD_REF <*cfg, 8, 3400>;
        D.32330 = D.32329 & 1;
        if (D.32330 != 0) goto <D.32339>; else goto <D.32340>;
        <D.32339>:
        D.32341 = acfg->stats.llvm_count;
        D.32342 = D.32341 + 1;
        acfg->stats.llvm_count = D.32342;
        goto <D.32343>;
        <D.32340>:
        emit_method_code (acfg, cfg);
        <D.32343>:
      }
      <D.28168>:
      oindex = oindex + 1;
      <D.28170>:
      oindex.138 = (unsigned int) oindex;
      D.32308 = acfg->method_order;
      D.32345 = D.32308->len;
      if (oindex.138 < D.32345) goto <D.28169>; else goto <D.28171>;
      <D.28171>:
      sprintf (&symbol, "methods_end");
      emit_section_change (acfg, ".text", 0);
      emit_alignment (acfg, 8);
      emit_label (acfg, &symbol);
      emit_int32 (acfg, 0);
      D.32286 = acfg->llvm;
      if (D.32286 != 0) goto <D.32346>; else goto <D.32347>;
      <D.32346>:
      D.32348 = acfg->need_no_dead_strip;
      if (D.32348 != 0) goto <D.32349>; else goto <D.32350>;
      <D.32349>:
      D.32333 = acfg->fp;
      fprintf (D.32333, "\n");
      i = 0;
      goto <D.28173>;
      <D.28172>:
      D.32289 = acfg->cfgs;
      i.135 = (unsigned int) i;
      D.32291 = i.135 * 4;
      D.32292 = D.32289 + D.32291;
      D.32293 = *D.32292;
      if (D.32293 != 0B) goto <D.32351>; else goto <D.32352>;
      <D.32351>:
      D.32289 = acfg->cfgs;
      i.135 = (unsigned int) i;
      D.32291 = i.135 * 4;
      D.32292 = D.32289 + D.32291;
      D.32293 = *D.32292;
      D.32296 = BIT_FIELD_REF <*D.32293, 8, 3400>;
      D.32297 = D.32296 & 1;
      if (D.32297 != 0) goto <D.32353>; else goto <D.32354>;
      <D.32353>:
      D.32333 = acfg->fp;
      D.32289 = acfg->cfgs;
      i.135 = (unsigned int) i;
      D.32291 = i.135 * 4;
      D.32292 = D.32289 + D.32291;
      D.32293 = *D.32292;
      D.32300 = D.32293->asm_symbol;
      fprintf (D.32333, ".no_dead_strip %s\n", D.32300);
      <D.32354>:
      <D.32352>:
      i = i + 1;
      <D.28173>:
      i.136 = (unsigned int) i;
      D.32303 = acfg->nmethods;
      if (i.136 < D.32303) goto <D.28172>; else goto <D.28174>;
      <D.28174>:
      <D.32350>:
      <D.32347>:
      sprintf (&symbol, "code_offsets");
      emit_section_change (acfg, ".rodata", 1);
      emit_alignment (acfg, 8);
      emit_label (acfg, &symbol);
      D.32355 = acfg->stats.offsets_size;
      D.32356 = (unsigned int) D.32355;
      D.32303 = acfg->nmethods;
      D.32357 = D.32303 * 4;
      D.32358 = D.32356 + D.32357;
      D.32359 = (int) D.32358;
      acfg->stats.offsets_size = D.32359;
      i = 0;
      goto <D.28176>;
      <D.28175>:
      D.32289 = acfg->cfgs;
      i.135 = (unsigned int) i;
      D.32291 = i.135 * 4;
      D.32292 = D.32289 + D.32291;
      D.32293 = *D.32292;
      if (D.32293 != 0B) goto <D.32360>; else goto <D.32361>;
      <D.32360>:
      D.32289 = acfg->cfgs;
      i.135 = (unsigned int) i;
      D.32291 = i.135 * 4;
      D.32292 = D.32289 + D.32291;
      D.32293 = *D.32292;
      D.32300 = D.32293->asm_symbol;
      D.32304 = acfg->methods_symbol;
      emit_symbol_diff (acfg, D.32300, D.32304, 0);
      goto <D.32362>;
      <D.32361>:
      emit_int32 (acfg, -1);
      <D.32362>:
      i = i + 1;
      <D.28176>:
      i.136 = (unsigned int) i;
      D.32303 = acfg->nmethods;
      if (i.136 < D.32303) goto <D.28175>; else goto <D.28177>;
      <D.28177>:
      emit_line (acfg);
      sprintf (&symbol, "unbox_trampolines");
      D.32363 = acfg->direct_method_addresses;
      if (D.32363 != 0) goto <D.32364>; else goto <D.32365>;
      <D.32364>:
      emit_section_change (acfg, ".text", 0);
      goto <D.32366>;
      <D.32365>:
      emit_section_change (acfg, ".rodata", 0);
      <D.32366>:
      emit_alignment (acfg, 8);
      emit_label (acfg, &symbol);
      prev_index = -1;
      i = 0;
      goto <D.28183>;
      <D.28182>:
      {
        struct MonoCompile * cfg;
        struct MonoMethod * method;
        int index;

        D.32289 = acfg->cfgs;
        i.135 = (unsigned int) i;
        D.32291 = i.135 * 4;
        D.32292 = D.32289 + D.32291;
        cfg = *D.32292;
        if (cfg == 0B) goto <D.32367>; else goto <D.32368>;
        <D.32367>:
        // predicted unlikely by continue predictor.
        goto <D.28181>;
        <D.32368>:
        method = cfg->orig_method;
        D.32316 = acfg->aot_opts.full_aot;
        if (D.32316 != 0) goto <D.32369>; else goto <D.32370>;
        <D.32369>:
        D.32371 = cfg->orig_method;
        D.32372 = D.32371->klass;
        D.32373 = BIT_FIELD_REF <*D.32372, 8, 160>;
        D.32374 = D.32373 & 8;
        if (D.32374 != 0) goto <D.32375>; else goto <D.32376>;
        <D.32375>:
        D.32377 = get_method_index (acfg, method);
        index = (int) D.32377;
        sprintf (&symbol, "ut_%d", index);
        emit_int32 (acfg, index);
        D.32363 = acfg->direct_method_addresses;
        if (D.32363 != 0) goto <D.32378>; else goto <D.32379>;
        <D.32378>:
        emit_unset_mode (acfg);
        D.32326 = acfg->thumb_mixed;
        if (D.32326 != 0) goto <D.32382>; else goto <D.32380>;
        <D.32382>:
        D.32383 = BIT_FIELD_REF <*cfg, 8, 3400>;
        D.32384 = D.32383 & 1;
        if (D.32384 != 0) goto <D.32385>; else goto <D.32380>;
        <D.32385>:
        D.32333 = acfg->fp;
        fprintf (D.32333, "\n\tblx %s\n", &symbol);
        goto <D.32381>;
        <D.32380>:
        D.32333 = acfg->fp;
        fprintf (D.32333, "\n\tbl %s\n", &symbol);
        <D.32381>:
        goto <D.32386>;
        <D.32379>:
        D.32304 = acfg->methods_symbol;
        emit_symbol_diff (acfg, &symbol, D.32304, 0);
        <D.32386>:
        D.32387 = index <= prev_index;
        D.32388 = (long int) D.32387;
        D.32389 = __builtin_expect (D.32388, 0);
        if (D.32389 != 0) goto <D.32390>; else goto <D.32391>;
        <D.32390>:
        monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "aot-compiler.c", 7246, "index > prev_index");
        <D.32391>:
        prev_index = index;
        <D.32376>:
        <D.32370>:
      }
      <D.28181>:
      i = i + 1;
      <D.28183>:
      i.136 = (unsigned int) i;
      D.32303 = acfg->nmethods;
      if (i.136 < D.32303) goto <D.28182>; else goto <D.28184>;
      <D.28184>:
      sprintf (&symbol, "unbox_trampolines_end");
      emit_label (acfg, &symbol);
      emit_int32 (acfg, 0);
    }
  finally
    {
      symbol = {CLOBBER};
    }
}


emit_set_thumb_mode (struct MonoAotCompile * acfg)
{
  struct FILE * D.32392;

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


arch_emit_unbox_trampoline (struct MonoAotCompile * acfg, struct MonoCompile * cfg, struct MonoMethod * method, const char * call_target)
{
  int D.32393;
  unsigned char D.32396;
  unsigned char D.32397;
  struct FILE * D.32400;
  int code.139;
  int buf.140;
  int D.32403;
  int D.32404;
  struct MonoImageWriter * D.32407;
  guint8 buf[128];
  guint8 * code;

  try
    {
      D.32393 = acfg->thumb_mixed;
      if (D.32393 != 0) goto <D.32394>; else goto <D.32395>;
      <D.32394>:
      D.32396 = BIT_FIELD_REF <*cfg, 8, 3400>;
      D.32397 = D.32396 & 1;
      if (D.32397 != 0) goto <D.32398>; else goto <D.32399>;
      <D.32398>:
      D.32400 = acfg->fp;
      fprintf (D.32400, "add r0, r0, #%d\n", 8);
      D.32400 = acfg->fp;
      fprintf (D.32400, "b %s\n", call_target);
      D.32400 = acfg->fp;
      fprintf (D.32400, ".arm\n");
      D.32400 = acfg->fp;
      fprintf (D.32400, ".align 2\n");
      return;
      <D.32399>:
      <D.32395>:
      code = &buf;
      {
        arminstr_t * __ainstrp;

        __ainstrp = code;
        *__ainstrp = 3800039432;
        code = __ainstrp + 4;
      }
      code.139 = (int) code;
      buf.140 = (int) &buf;
      D.32403 = code.139 - buf.140;
      emit_bytes (acfg, &buf, D.32403);
      D.32404 = acfg->use_bin_writer;
      if (D.32404 != 0) goto <D.32405>; else goto <D.32406>;
      <D.32405>:
      {
        guint8 buf[4];
        guint8 * code;

        try
          {
            code = &buf;
            {
              arminstr_t * __ainstrp;

              __ainstrp = code;
              *__ainstrp = 3925868544;
              code = __ainstrp + 4;
            }
            D.32407 = acfg->w;
            img_writer_emit_reloc (D.32407, 29, call_target, -8);
            emit_bytes (acfg, &buf, 4);
          }
        finally
          {
            buf = {CLOBBER};
          }
      }
      goto <D.32408>;
      <D.32406>:
      D.32393 = acfg->thumb_mixed;
      if (D.32393 != 0) goto <D.32411>; else goto <D.32409>;
      <D.32411>:
      D.32396 = BIT_FIELD_REF <*cfg, 8, 3400>;
      D.32397 = D.32396 & 1;
      if (D.32397 != 0) goto <D.32412>; else goto <D.32409>;
      <D.32412>:
      D.32400 = acfg->fp;
      fprintf (D.32400, "\n\tbx %s\n", call_target);
      goto <D.32410>;
      <D.32409>:
      D.32400 = acfg->fp;
      fprintf (D.32400, "\n\tb %s\n", call_target);
      <D.32410>:
      <D.32408>:
    }
  finally
    {
      buf = {CLOBBER};
    }
}


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

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


emit_set_arm_mode (struct MonoAotCompile * acfg)
{
  struct FILE * D.32417;

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


emit_method_code (struct MonoAotCompile * acfg, struct MonoCompile * cfg)
{
  unsigned int D.32418;
  const char * D.32419;
  int D.32420;
  int D.32423;
  struct FILE * D.32426;
  char * D.32427;
  int D.32428;
  struct GHashTable * D.32433;
  struct GHashTable * D.32436;
  unsigned int D.32439;
  char * D.32442;
  int D.32443;
  unsigned int D.32444;
  unsigned int D.32445;
  unsigned int D.32446;
  int D.32447;
  struct MonoCompile * * D.32448;
  unsigned int method_index.141;
  unsigned int D.32450;
  struct MonoCompile * * D.32451;
  struct MonoCompile * D.32452;
  unsigned int D.32453;
  struct MonoJumpInfo * D.32454;
  struct MonoJitInfo * D.32455;
  struct MonoMethod * D.32456;
  struct MonoDomain * D.32457;
  struct MonoDebugMethodJitInfo * D.32458;
  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 = 4;
  method = cfg->orig_method;
  code = cfg->native_code;
  header = cfg->header;
  D.32418 = get_method_index (acfg, method);
  method_index = (int) D.32418;
  D.32419 = acfg->temp_prefix;
  symbol = monoeg_g_strdup_printf ("%sme_%x", D.32419, method_index);
  emit_section_change (acfg, ".text", 0);
  emit_alignment (acfg, func_alignment);
  D.32420 = acfg->global_symbols;
  if (D.32420 != 0) goto <D.32421>; else goto <D.32422>;
  <D.32421>:
  D.32423 = acfg->need_no_dead_strip;
  if (D.32423 != 0) goto <D.32424>; else goto <D.32425>;
  <D.32424>:
  D.32426 = acfg->fp;
  D.32427 = cfg->asm_symbol;
  fprintf (D.32426, "\t.no_dead_strip %s\n", D.32427);
  <D.32425>:
  <D.32422>:
  D.32427 = cfg->asm_symbol;
  emit_label (acfg, D.32427);
  D.32428 = acfg->aot_opts.write_symbols;
  if (D.32428 != 0) goto <D.32429>; else goto <D.32430>;
  <D.32429>:
  D.32420 = acfg->global_symbols;
  if (D.32420 == 0) goto <D.32431>; else goto <D.32432>;
  <D.32431>:
  D.32433 = acfg->method_label_hash;
  debug_sym = get_debug_sym (method, "", D.32433);
  D.32423 = acfg->need_no_dead_strip;
  if (D.32423 != 0) goto <D.32434>; else goto <D.32435>;
  <D.32434>:
  D.32426 = acfg->fp;
  fprintf (D.32426, "\t.no_dead_strip %s\n", debug_sym);
  <D.32435>:
  emit_local_symbol (acfg, debug_sym, symbol, 1);
  emit_label (acfg, debug_sym);
  <D.32432>:
  <D.32430>:
  D.32436 = acfg->export_names;
  export_name = monoeg_g_hash_table_lookup (D.32436, method);
  if (export_name != 0B) goto <D.32437>; else goto <D.32438>;
  <D.32437>:
  emit_global_inner (acfg, export_name, 1);
  emit_label (acfg, export_name);
  <D.32438>:
  D.32439 = cfg->verbose_level;
  if (D.32439 != 0) goto <D.32440>; else goto <D.32441>;
  <D.32440>:
  D.32442 = mono_method_full_name (method, 1);
  D.32427 = cfg->asm_symbol;
  monoeg_g_print ("Method %s emitted as %s\n", D.32442, D.32427);
  <D.32441>:
  D.32443 = acfg->stats.code_size;
  D.32444 = (unsigned int) D.32443;
  D.32445 = cfg->code_len;
  D.32446 = D.32444 + D.32445;
  D.32447 = (int) D.32446;
  acfg->stats.code_size = D.32447;
  D.32448 = acfg->cfgs;
  method_index.141 = (unsigned int) method_index;
  D.32450 = method_index.141 * 4;
  D.32451 = D.32448 + D.32450;
  D.32452 = *D.32451;
  D.32453 = acfg->got_offset;
  D.32452->got_offset = D.32453;
  D.32445 = cfg->code_len;
  D.32454 = cfg->patch_info;
  D.32455 = cfg->jit_info;
  D.32456 = D.32455->d.method;
  D.32457 = mono_domain_get ();
  D.32458 = mono_debug_find_method (D.32456, D.32457);
  emit_and_reloc_code (acfg, method, code, D.32445, D.32454, 0, D.32458);
  emit_line (acfg);
  D.32428 = acfg->aot_opts.write_symbols;
  if (D.32428 != 0) goto <D.32459>; else goto <D.32460>;
  <D.32459>:
  emit_symbol_size (acfg, debug_sym, ".");
  monoeg_g_free (debug_sym);
  <D.32460>:
  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.32461;

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


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

  D.32462 = acfg->w;
  img_writer_emit_global (D.32462, 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.32465;
  int D.32466;
  _Bool D.32469;
  _Bool D.32470;
  _Bool D.32471;
  int code_len.142;
  struct FILE * D.32477;
  void * * D.32478;
  unsigned int pindex.143;
  unsigned int D.32480;
  void * * D.32481;
  int D.32482;
  unsigned int pindex.144;
  unsigned int D.32485;
  unsigned int i.145;
  unsigned int D.32489;
  struct MonoDebugSourceLocation * * D.32490;
  struct MonoDebugSourceLocation * D.32491;
  char * D.32494;
  unsigned int D.32495;
  <unnamed type> D.32502;
  sizetype i.146;
  guint8 * D.32504;
  int code_size.147;
  int D.32506;
  struct GHashTable * D.32507;
  struct GHashTable * D.32510;
  struct GPtrArray * D.32511;
  struct GPtrArray * D.32514;
  void * D.32515;
  const void * D.32519;
  int D.32520;
  void * D.32521;
  int D.32522;
  int D.32523;
  int code_size.148;
  int D.32525;
  struct MonoMethod * D.32529;
  struct MonoClass * D.32530;
  struct MonoImage * D.32531;
  struct MonoImage * D.32532;
  int D.32536;
  struct GHashTable * D.32539;
  int D.32540;
  int D.32541;
  int D.32542;
  int D.32543;
  int D.32548;
  short unsigned int D.32551;
  int D.32552;
  int D.32553;
  unsigned int D.32559;
  _Bool D.32560;
  long int D.32561;
  long int D.32562;
  const char * D.32565;
  const char * D.32569;
  _Bool D.32570;
  _Bool D.32571;
  _Bool D.32572;
  int D.32575;
  unsigned int D.32578;
  _Bool D.32579;
  long int D.32580;
  long int D.32581;
  _Bool D.32587;
  _Bool D.32588;
  const void * D.32593;
  const void * D.32594;
  unsigned int D.32597;
  _Bool D.32598;
  long int D.32599;
  long int D.32600;
  int D.32605;
  int call_size.149;
  int D.32613;
  int got_slot.150;
  int code_size.151;
  int D.32617;
  unsigned int limit.152;
  unsigned int D.32628;
  struct MonoDebugSourceLocation * * D.32629;
  struct MonoDebugSourceLocation * D.32630;
  const guint8 * D.32632;
  int D.32633;
  unsigned int i.153;
  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;
  gboolean direct_call;
  gboolean external_call;
  guint32 got_slot;
  const char * direct_call_target;
  const char * direct_pinvoke;

  locs = 0B;
  direct_call_target = 0B;
  if (method != 0B) goto <D.32463>; else goto <D.32464>;
  <D.32463>:
  header = mono_method_get_header (method);
  D.32465 = get_method_index (acfg, method);
  method_index = (int) D.32465;
  <D.32464>:
  D.32466 = acfg->gas_line_numbers;
  if (D.32466 != 0) goto <D.32467>; else goto <D.32468>;
  <D.32467>:
  D.32469 = method != 0B;
  D.32470 = debug_info != 0B;
  D.32471 = D.32469 & D.32470;
  if (D.32471 != 0) goto <D.32472>; else goto <D.32473>;
  <D.32472>:
  code_len.142 = (int) code_len;
  locs = compute_line_numbers (method, code_len.142, debug_info);
  if (locs == 0B) goto <D.32475>; else goto <D.32476>;
  <D.32475>:
  {
    int findex;

    findex = get_file_index (acfg, "<unknown>");
    emit_unset_mode (acfg);
    D.32477 = acfg->fp;
    fprintf (D.32477, ".loc %d %d 0\n", findex, 1);
  }
  <D.32476>:
  <D.32473>:
  <D.32468>:
  patches = monoeg_g_ptr_array_new ();
  patch_info = relocs;
  goto <D.27399>;
  <D.27398>:
  monoeg_g_ptr_array_add (patches, patch_info);
  patch_info = patch_info->next;
  <D.27399>:
  if (patch_info != 0B) goto <D.27398>; else goto <D.27400>;
  <D.27400>:
  monoeg_g_ptr_array_sort (patches, compare_patches);
  start_index = 0;
  i = 0;
  goto <D.27430>;
  <D.27429>:
  patch_info = 0B;
  pindex = start_index;
  goto <D.27403>;
  <D.27402>:
  D.32478 = patches->pdata;
  pindex.143 = (unsigned int) pindex;
  D.32480 = pindex.143 * 4;
  D.32481 = D.32478 + D.32480;
  patch_info = *D.32481;
  D.32482 = patch_info->ip.i;
  if (D.32482 >= i) goto <D.27401>; else goto <D.32483>;
  <D.32483>:
  pindex = pindex + 1;
  <D.27403>:
  pindex.144 = (unsigned int) pindex;
  D.32485 = patches->len;
  if (pindex.144 < D.32485) goto <D.27402>; else goto <D.27401>;
  <D.27401>:
  if (locs != 0B) goto <D.32486>; else goto <D.32487>;
  <D.32486>:
  i.145 = (unsigned int) i;
  D.32489 = i.145 * 4;
  D.32490 = locs + D.32489;
  D.32491 = *D.32490;
  if (D.32491 != 0B) goto <D.32492>; else goto <D.32493>;
  <D.32492>:
  {
    struct MonoDebugSourceLocation * loc;
    int findex;

    i.145 = (unsigned int) i;
    D.32489 = i.145 * 4;
    D.32490 = locs + D.32489;
    loc = *D.32490;
    D.32494 = loc->source_file;
    findex = get_file_index (acfg, D.32494);
    emit_unset_mode (acfg);
    D.32477 = acfg->fp;
    D.32495 = loc->row;
    fprintf (D.32477, ".loc %d %d 0\n", findex, D.32495);
    mono_debug_symfile_free_location (loc);
  }
  <D.32493>:
  <D.32487>:
  skip = 0;
  if (patch_info != 0B) goto <D.32496>; else goto <D.32497>;
  <D.32496>:
  D.32482 = patch_info->ip.i;
  if (D.32482 == i) goto <D.32498>; else goto <D.32499>;
  <D.32498>:
  pindex.144 = (unsigned int) pindex;
  D.32485 = patches->len;
  if (pindex.144 < D.32485) goto <D.32500>; else goto <D.32501>;
  <D.32500>:
  start_index = pindex;
  D.32502 = patch_info->type;
  switch (D.32502) <default: <D.27414>, case 27: <D.27408>, case 49: <D.27410>, case 51: <D.27406>>
  <D.27406>:
  goto <D.27407>;
  <D.27408>:
  {
    int code_size;

    try
      {
        i.146 = (sizetype) i;
        D.32504 = code + i.146;
        arch_emit_got_offset (acfg, D.32504, &code_size);
        code_size.147 = code_size;
        D.32506 = code_size.147 + -1;
        i = D.32506 + i;
        skip = 1;
        patch_info->type = 51;
        goto <D.27407>;
      }
    finally
      {
        code_size = {CLOBBER};
      }
  }
  <D.27410>:
  {
    int code_size;
    int index;
    char * selector;

    try
      {
        selector = patch_info->data.target;
        D.32507 = acfg->objc_selector_to_index;
        if (D.32507 == 0B) goto <D.32508>; else goto <D.32509>;
        <D.32508>:
        D.32510 = monoeg_g_hash_table_new (monoeg_g_str_hash, monoeg_g_str_equal);
        acfg->objc_selector_to_index = D.32510;
        <D.32509>:
        D.32511 = acfg->objc_selectors;
        if (D.32511 == 0B) goto <D.32512>; else goto <D.32513>;
        <D.32512>:
        D.32514 = monoeg_g_ptr_array_new ();
        acfg->objc_selectors = D.32514;
        <D.32513>:
        D.32507 = acfg->objc_selector_to_index;
        D.32515 = monoeg_g_hash_table_lookup (D.32507, selector);
        index = (int) D.32515;
        if (index != 0) goto <D.32516>; else goto <D.32517>;
        <D.32516>:
        index = index + -1;
        goto <D.32518>;
        <D.32517>:
        index = acfg->objc_selector_index;
        D.32511 = acfg->objc_selectors;
        D.32519 = patch_info->data.target;
        monoeg_g_ptr_array_add (D.32511, D.32519);
        D.32507 = acfg->objc_selector_to_index;
        D.32520 = index + 1;
        D.32521 = (void *) D.32520;
        monoeg_g_hash_table_insert_replace (D.32507, selector, D.32521, 0);
        D.32522 = acfg->objc_selector_index;
        D.32523 = D.32522 + 1;
        acfg->objc_selector_index = D.32523;
        <D.32518>:
        i.146 = (sizetype) i;
        D.32504 = code + i.146;
        arch_emit_objc_selector_ref (acfg, D.32504, index, &code_size);
        code_size.148 = code_size;
        D.32525 = code_size.148 + -1;
        i = D.32525 + i;
        skip = 1;
        patch_info->type = 51;
        goto <D.27407>;
      }
    finally
      {
        code_size = {CLOBBER};
      }
  }
  <D.27414>:
  direct_call = 0;
  external_call = 0;
  D.32502 = patch_info->type;
  if (D.32502 == 3) goto <D.32528>; else goto <D.32526>;
  <D.32528>:
  D.32529 = patch_info->data.method;
  D.32530 = D.32529->klass;
  D.32531 = D.32530->image;
  D.32532 = acfg->image;
  if (D.32531 == D.32532) goto <D.32533>; else goto <D.32526>;
  <D.32533>:
  if (got_only == 0) goto <D.32534>; else goto <D.32535>;
  <D.32534>:
  D.32536 = is_direct_callable (acfg, method, patch_info);
  if (D.32536 != 0) goto <D.32537>; else goto <D.32538>;
  <D.32537>:
  {
    struct MonoCompile * callee_cfg;

    D.32539 = acfg->method_to_cfg;
    D.32529 = patch_info->data.method;
    callee_cfg = monoeg_g_hash_table_lookup (D.32539, D.32529);
    direct_call = 1;
    direct_call_target = callee_cfg->asm_symbol;
    patch_info->type = 51;
    D.32540 = acfg->stats.direct_calls;
    D.32541 = D.32540 + 1;
    acfg->stats.direct_calls = D.32541;
  }
  <D.32538>:
  <D.32535>:
  D.32542 = acfg->stats.all_calls;
  D.32543 = D.32542 + 1;
  acfg->stats.all_calls = D.32543;
  goto <D.32527>;
  <D.32526>:
  D.32502 = patch_info->type;
  if (D.32502 == 31) goto <D.32544>; else goto <D.32545>;
  <D.32544>:
  if (got_only == 0) goto <D.32546>; else goto <D.32547>;
  <D.32546>:
  D.32548 = is_direct_callable (acfg, method, patch_info);
  if (D.32548 != 0) goto <D.32549>; else goto <D.32550>;
  <D.32549>:
  D.32529 = patch_info->data.method;
  D.32551 = D.32529->flags;
  D.32552 = (int) D.32551;
  D.32553 = D.32552 & 8192;
  if (D.32553 == 0) goto <D.32554>; else goto <D.32555>;
  <D.32554>:
  D.32529 = patch_info->data.method;
  direct_pinvoke = mono_lookup_icall_symbol (D.32529);
  goto <D.32556>;
  <D.32555>:
  D.32529 = patch_info->data.method;
  direct_pinvoke = get_pinvoke_import (acfg, D.32529);
  <D.32556>:
  if (direct_pinvoke != 0B) goto <D.32557>; else goto <D.32558>;
  <D.32557>:
  direct_call = 1;
  D.32559 = strlen (direct_pinvoke);
  D.32560 = D.32559 > 999;
  D.32561 = (long int) D.32560;
  D.32562 = __builtin_expect (D.32561, 0);
  if (D.32562 != 0) goto <D.32563>; else goto <D.32564>;
  <D.32563>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "aot-compiler.c", 4615, "strlen (direct_pinvoke) < 1000");
  <D.32564>:
  D.32565 = acfg->user_symbol_prefix;
  direct_call_target = monoeg_g_strdup_printf ("%s%s", D.32565, direct_pinvoke);
  <D.32558>:
  <D.32550>:
  <D.32547>:
  goto <D.32566>;
  <D.32545>:
  D.32502 = patch_info->type;
  if (D.32502 == 32) goto <D.32567>; else goto <D.32568>;
  <D.32567>:
  {
    const char * sym;

    D.32569 = patch_info->data.name;
    sym = mono_lookup_jit_icall_symbol (D.32569);
    D.32570 = got_only == 0;
    D.32571 = sym != 0B;
    D.32572 = D.32570 & D.32571;
    if (D.32572 != 0) goto <D.32573>; else goto <D.32574>;
    <D.32573>:
    D.32575 = acfg->aot_opts.direct_icalls;
    if (D.32575 != 0) goto <D.32576>; else goto <D.32577>;
    <D.32576>:
    direct_call = 1;
    external_call = 1;
    D.32578 = strlen (sym);
    D.32579 = D.32578 > 999;
    D.32580 = (long int) D.32579;
    D.32581 = __builtin_expect (D.32580, 0);
    if (D.32581 != 0) goto <D.32582>; else goto <D.32583>;
    <D.32582>:
    monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "aot-compiler.c", 4625, "strlen (sym) < 1000");
    <D.32583>:
    D.32565 = acfg->user_symbol_prefix;
    direct_call_target = monoeg_g_strdup_printf ("%s%s", D.32565, sym);
    <D.32577>:
    <D.32574>:
  }
  goto <D.32584>;
  <D.32568>:
  D.32502 = patch_info->type;
  if (D.32502 == 7) goto <D.32585>; else goto <D.32586>;
  <D.32585>:
  {
    struct MonoJitICallInfo * info;
    const char * sym;

    D.32569 = patch_info->data.name;
    info = mono_find_jit_icall_by_name (D.32569);
    D.32569 = patch_info->data.name;
    sym = mono_lookup_jit_icall_symbol (D.32569);
    D.32570 = got_only == 0;
    D.32587 = sym != 0B;
    D.32588 = D.32570 & D.32587;
    if (D.32588 != 0) goto <D.32589>; else goto <D.32590>;
    <D.32589>:
    D.32575 = acfg->aot_opts.direct_icalls;
    if (D.32575 != 0) goto <D.32591>; else goto <D.32592>;
    <D.32591>:
    D.32593 = info->func;
    D.32594 = info->wrapper;
    if (D.32593 == D.32594) goto <D.32595>; else goto <D.32596>;
    <D.32595>:
    direct_call = 1;
    external_call = 1;
    D.32597 = strlen (sym);
    D.32598 = D.32597 > 999;
    D.32599 = (long int) D.32598;
    D.32600 = __builtin_expect (D.32599, 0);
    if (D.32600 != 0) goto <D.32601>; else goto <D.32602>;
    <D.32601>:
    monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "aot-compiler.c", 4635, "strlen (sym) < 1000");
    <D.32602>:
    D.32565 = acfg->user_symbol_prefix;
    direct_call_target = monoeg_g_strdup_printf ("%s%s", D.32565, sym);
    <D.32596>:
    <D.32592>:
    <D.32590>:
  }
  <D.32586>:
  <D.32584>:
  <D.32566>:
  <D.32527>:
  if (direct_call != 0) goto <D.32603>; else goto <D.32604>;
  <D.32603>:
  patch_info->type = 51;
  D.32540 = acfg->stats.direct_calls;
  D.32541 = D.32540 + 1;
  acfg->stats.direct_calls = D.32541;
  <D.32604>:
  D.32605 = got_only | direct_call;
  if (D.32605 == 0) goto <D.32606>; else goto <D.32607>;
  <D.32606>:
  {
    struct MonoPltEntry * plt_entry;

    plt_entry = get_plt_entry (acfg, patch_info);
    if (plt_entry != 0B) goto <D.32608>; else goto <D.32609>;
    <D.32608>:
    direct_call = 1;
    direct_call_target = plt_entry->symbol;
    patch_info->type = 51;
    plt_entry->jit_used = 1;
    <D.32609>:
  }
  <D.32607>:
  if (direct_call != 0) goto <D.32610>; else goto <D.32611>;
  <D.32610>:
  {
    int call_size;

    try
      {
        arch_emit_direct_call (acfg, direct_call_target, external_call, patch_info, &call_size);
        call_size.149 = call_size;
        D.32613 = call_size.149 + -1;
        i = D.32613 + i;
      }
    finally
      {
        call_size = {CLOBBER};
      }
  }
  goto <D.32614>;
  <D.32611>:
  {
    int code_size;

    try
      {
        got_slot = get_got_offset (acfg, patch_info);
        i.146 = (sizetype) i;
        D.32504 = code + i.146;
        got_slot.150 = (int) got_slot;
        arch_emit_got_access (acfg, D.32504, got_slot.150, &code_size);
        code_size.151 = code_size;
        D.32617 = code_size.151 + -1;
        i = D.32617 + i;
      }
    finally
      {
        code_size = {CLOBBER};
      }
  }
  <D.32614>:
  skip = 1;
  <D.27407>:
  <D.32501>:
  <D.32499>:
  <D.32497>:
  if (skip == 0) goto <D.32618>; else goto <D.32619>;
  <D.32618>:
  patch_info = 0B;
  pindex = start_index;
  goto <D.27424>;
  <D.27423>:
  D.32478 = patches->pdata;
  pindex.143 = (unsigned int) pindex;
  D.32480 = pindex.143 * 4;
  D.32481 = D.32478 + D.32480;
  patch_info = *D.32481;
  D.32482 = patch_info->ip.i;
  if (D.32482 >= i) goto <D.27422>; else goto <D.32620>;
  <D.32620>:
  pindex = pindex + 1;
  <D.27424>:
  pindex.144 = (unsigned int) pindex;
  D.32485 = patches->len;
  if (pindex.144 < D.32485) goto <D.27423>; else goto <D.27422>;
  <D.27422>:
  pindex.144 = (unsigned int) pindex;
  D.32485 = patches->len;
  if (pindex.144 < D.32485) goto <D.32623>; else goto <D.32621>;
  <D.32623>:
  D.32482 = patch_info->ip.i;
  if (D.32482 > i) goto <D.32624>; else goto <D.32621>;
  <D.32624>:
  {
    int limit;

    limit = i + 1;
    goto <D.27428>;
    <D.27427>:
    if (locs != 0B) goto <D.32625>; else goto <D.32626>;
    <D.32625>:
    limit.152 = (unsigned int) limit;
    D.32628 = limit.152 * 4;
    D.32629 = locs + D.32628;
    D.32630 = *D.32629;
    if (D.32630 != 0B) goto <D.27426>; else goto <D.32631>;
    <D.32631>:
    <D.32626>:
    limit = limit + 1;
    <D.27428>:
    D.32482 = patch_info->ip.i;
    if (D.32482 > limit) goto <D.27427>; else goto <D.27426>;
    <D.27426>:
    i.146 = (sizetype) i;
    D.32632 = code + i.146;
    D.32633 = limit - i;
    emit_bytes (acfg, D.32632, D.32633);
    i = limit + -1;
  }
  goto <D.32622>;
  <D.32621>:
  i.146 = (sizetype) i;
  D.32632 = code + i.146;
  emit_bytes (acfg, D.32632, 1);
  <D.32622>:
  <D.32619>:
  i = i + 1;
  <D.27430>:
  i.153 = (unsigned int) i;
  if (i.153 < code_len) goto <D.27429>; else goto <D.27431>;
  <D.27431>:
  monoeg_g_free (locs);
}


compare_patches (const void * a, const void * b)
{
  struct MonoJumpInfo * D.32638;
  struct MonoJumpInfo * D.32639;
  gint D.32642;
  int i;
  int j;

  D.32638 = MEM[(struct MonoJumpInfo * *)a];
  i = D.32638->ip.i;
  D.32639 = MEM[(struct MonoJumpInfo * *)b];
  j = D.32639->ip.i;
  if (i < j) goto <D.32640>; else goto <D.32641>;
  <D.32640>:
  D.32642 = -1;
  return D.32642;
  <D.32641>:
  if (i > j) goto <D.32643>; else goto <D.32644>;
  <D.32643>:
  D.32642 = 1;
  return D.32642;
  <D.32644>:
  D.32642 = 0;
  return D.32642;
}


compute_line_numbers (struct MonoMethod * method, int code_size, struct MonoDebugMethodJitInfo * debug_info)
{
  struct MonoDebugSourceLocation * * D.32648;
  unsigned int D.32649;
  unsigned int code_size.154;
  _Bool D.32653;
  long int D.32654;
  long int D.32655;
  unsigned int D.32658;
  unsigned int D.32659;
  struct MonoDebugLineNumberEntry * D.32660;
  unsigned int D.32661;
  int D.32662;
  unsigned int D.32663;
  unsigned int D.32664;
  unsigned int i.155;
  unsigned int D.32666;
  unsigned int j.156;
  unsigned int D.32670;
  int * D.32671;
  unsigned int j.157;
  unsigned int D.32673;
  unsigned int i.158;
  unsigned int D.32675;
  sizetype i.159;
  sizetype D.32679;
  sizetype D.32680;
  unsigned int D.32681;
  int D.32682;
  unsigned int D.32683;
  unsigned int code_size.160;
  unsigned int D.32686;
  unsigned int D.32687;
  int * D.32688;
  _Bool D.32689;
  _Bool D.32690;
  _Bool D.32691;
  unsigned int il_offset.161;
  char * D.32698;
  unsigned int D.32699;
  unsigned int prev_line.162;
  struct MonoDebugSourceLocation * * D.32706;
  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.32646>; else goto <D.32647>;
  <D.32646>:
  D.32648 = 0B;
  return D.32648;
  <D.32647>:
  D.32649 = debug_info->code_size;
  code_size.154 = (unsigned int) code_size;
  if (D.32649 != code_size.154) goto <D.32651>; else goto <D.32652>;
  <D.32651>:
  D.32648 = 0B;
  return D.32648;
  <D.32652>:
  D.32653 = code_size == 0;
  D.32654 = (long int) D.32653;
  D.32655 = __builtin_expect (D.32654, 0);
  if (D.32655 != 0) goto <D.32656>; else goto <D.32657>;
  <D.32656>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "aot-compiler.c", 4403, "code_size");
  <D.32657>:
  D.32658 = debug_info->num_line_numbers;
  D.32659 = D.32658 * 8;
  ln_array = monoeg_malloc0 (D.32659);
  D.32660 = debug_info->line_numbers;
  D.32658 = debug_info->num_line_numbers;
  D.32661 = D.32658 * 8;
  memcpy (ln_array, D.32660, D.32661);
  D.32658 = debug_info->num_line_numbers;
  qsort (ln_array, D.32658, 8, compare_lne);
  D.32662 = code_size + 1;
  D.32663 = (unsigned int) D.32662;
  D.32664 = D.32663 * 4;
  native_to_il_offset = monoeg_malloc0 (D.32664);
  i = 0;
  goto <D.27362>;
  <D.27361>:
  {
    int j;
    struct MonoDebugLineNumberEntry * lne;

    i.155 = (unsigned int) i;
    D.32666 = i.155 * 8;
    lne = ln_array + D.32666;
    if (i == 0) goto <D.32667>; else goto <D.32668>;
    <D.32667>:
    j = 0;
    goto <D.27352>;
    <D.27351>:
    j.156 = (unsigned int) j;
    D.32670 = j.156 * 4;
    D.32671 = native_to_il_offset + D.32670;
    *D.32671 = -1;
    j = j + 1;
    <D.27352>:
    j.157 = (unsigned int) j;
    D.32673 = lne->native_offset;
    if (j.157 < D.32673) goto <D.27351>; else goto <D.27353>;
    <D.27353>:
    <D.32668>:
    i.158 = (unsigned int) i;
    D.32658 = debug_info->num_line_numbers;
    D.32675 = D.32658 + 4294967295;
    if (i.158 < D.32675) goto <D.32676>; else goto <D.32677>;
    <D.32676>:
    {
      struct MonoDebugLineNumberEntry * lne_next;

      i.159 = (sizetype) i;
      D.32679 = i.159 + 1;
      D.32680 = D.32679 * 8;
      lne_next = ln_array + D.32680;
      D.32673 = lne->native_offset;
      j = (int) D.32673;
      goto <D.27356>;
      <D.27355>:
      j.156 = (unsigned int) j;
      D.32670 = j.156 * 4;
      D.32671 = native_to_il_offset + D.32670;
      D.32681 = lne->il_offset;
      D.32682 = (int) D.32681;
      *D.32671 = D.32682;
      j = j + 1;
      <D.27356>:
      j.157 = (unsigned int) j;
      D.32683 = lne_next->native_offset;
      if (j.157 < D.32683) goto <D.27355>; else goto <D.27357>;
      <D.27357>:
    }
    goto <D.32684>;
    <D.32677>:
    D.32673 = lne->native_offset;
    j = (int) D.32673;
    goto <D.27359>;
    <D.27358>:
    j.156 = (unsigned int) j;
    D.32670 = j.156 * 4;
    D.32671 = native_to_il_offset + D.32670;
    D.32681 = lne->il_offset;
    D.32682 = (int) D.32681;
    *D.32671 = D.32682;
    j = j + 1;
    <D.27359>:
    if (j < code_size) goto <D.27358>; else goto <D.27360>;
    <D.27360>:
    <D.32684>:
  }
  i = i + 1;
  <D.27362>:
  i.158 = (unsigned int) i;
  D.32658 = debug_info->num_line_numbers;
  if (i.158 < D.32658) goto <D.27361>; else goto <D.27363>;
  <D.27363>:
  monoeg_g_free (ln_array);
  code_size.160 = (unsigned int) code_size;
  D.32686 = code_size.160 * 4;
  res = monoeg_malloc0 (D.32686);
  prev_il_offset = -1;
  prev_line = -1;
  first = 1;
  i = 0;
  goto <D.27367>;
  <D.27366>:
  {
    int il_offset;

    i.155 = (unsigned int) i;
    D.32687 = i.155 * 4;
    D.32688 = native_to_il_offset + D.32687;
    il_offset = *D.32688;
    D.32689 = il_offset == -1;
    D.32690 = il_offset == prev_il_offset;
    D.32691 = D.32689 | D.32690;
    if (D.32691 != 0) goto <D.32692>; else goto <D.32693>;
    <D.32692>:
    // predicted unlikely by continue predictor.
    goto <D.27365>;
    <D.32693>:
    prev_il_offset = il_offset;
    il_offset.161 = (unsigned int) il_offset;
    loc = mono_debug_symfile_lookup_location (minfo, il_offset.161);
    if (loc == 0B) goto <D.32695>; else goto <D.32697>;
    <D.32697>:
    D.32698 = loc->source_file;
    if (D.32698 == 0B) goto <D.32695>; else goto <D.32696>;
    <D.32695>:
    // predicted unlikely by continue predictor.
    goto <D.27365>;
    <D.32696>:
    D.32699 = loc->row;
    prev_line.162 = (unsigned int) prev_line;
    if (D.32699 == prev_line.162) goto <D.32701>; else goto <D.32702>;
    <D.32701>:
    mono_debug_symfile_free_location (loc);
    // predicted unlikely by continue predictor.
    goto <D.27365>;
    <D.32702>:
    D.32699 = loc->row;
    prev_line = (int) D.32699;
    if (first != 0) goto <D.32703>; else goto <D.32704>;
    <D.32703>:
    *res = loc;
    goto <D.32705>;
    <D.32704>:
    i.155 = (unsigned int) i;
    D.32687 = i.155 * 4;
    D.32706 = res + D.32687;
    *D.32706 = loc;
    <D.32705>:
    first = 0;
  }
  <D.27365>:
  i = i + 1;
  <D.27367>:
  if (i < code_size) goto <D.27366>; else goto <D.27368>;
  <D.27368>:
  D.32648 = res;
  return D.32648;
}


compare_lne (struct MonoDebugLineNumberEntry * a, struct MonoDebugLineNumberEntry * b)
{
  unsigned int D.32708;
  unsigned int D.32709;
  gint D.32712;
  unsigned int D.32713;
  unsigned int D.32714;
  unsigned int D.32715;
  unsigned int D.32716;

  D.32708 = a->native_offset;
  D.32709 = b->native_offset;
  if (D.32708 == D.32709) goto <D.32710>; else goto <D.32711>;
  <D.32710>:
  D.32713 = a->il_offset;
  D.32714 = b->il_offset;
  D.32715 = D.32713 - D.32714;
  D.32712 = (gint) D.32715;
  return D.32712;
  <D.32711>:
  D.32708 = a->native_offset;
  D.32709 = b->native_offset;
  D.32716 = D.32708 - D.32709;
  D.32712 = (gint) D.32716;
  return D.32712;
}


get_file_index (struct MonoAotCompile * acfg, const char * source_file)
{
  struct GHashTable * D.32718;
  struct GHashTable * D.32721;
  void * D.32722;
  unsigned int D.32725;
  unsigned int D.32726;
  gchar * D.32727;
  void * findex.163;
  struct FILE * D.32729;
  char * D.32730;
  int D.32731;
  int findex;

  D.32718 = acfg->dwarf_ln_filenames;
  if (D.32718 == 0B) goto <D.32719>; else goto <D.32720>;
  <D.32719>:
  D.32721 = monoeg_g_hash_table_new (monoeg_g_str_hash, monoeg_g_str_equal);
  acfg->dwarf_ln_filenames = D.32721;
  <D.32720>:
  D.32718 = acfg->dwarf_ln_filenames;
  D.32722 = monoeg_g_hash_table_lookup (D.32718, source_file);
  findex = (int) D.32722;
  if (findex == 0) goto <D.32723>; else goto <D.32724>;
  <D.32723>:
  D.32718 = acfg->dwarf_ln_filenames;
  D.32725 = monoeg_g_hash_table_size (D.32718);
  D.32726 = D.32725 + 1;
  findex = (int) D.32726;
  D.32718 = acfg->dwarf_ln_filenames;
  D.32727 = monoeg_strdup (source_file);
  findex.163 = (void *) findex;
  monoeg_g_hash_table_insert_replace (D.32718, D.32727, findex.163, 0);
  emit_unset_mode (acfg);
  D.32729 = acfg->fp;
  D.32730 = mono_dwarf_escape_path (source_file);
  fprintf (D.32729, ".file %d \"%s\"\n", findex, D.32730);
  <D.32724>:
  D.32731 = findex;
  return D.32731;
}


arch_emit_got_offset (struct MonoAotCompile * acfg, guint8 * code, int * code_size)
{
  int offset.164;
  char * D.32734;
  unsigned int D.32735;
  int D.32736;
  guint32 offset;

  offset = mono_arch_get_patch_offset (code);
  offset.164 = (int) offset;
  emit_bytes (acfg, code, offset.164);
  D.32734 = acfg->got_symbol;
  offset.164 = (int) offset;
  emit_symbol_diff (acfg, D.32734, ".", offset.164);
  D.32735 = offset + 4;
  D.32736 = (int) D.32735;
  *code_size = D.32736;
}


arch_emit_objc_selector_ref (struct MonoAotCompile * acfg, guint8 * code, int index, int * code_size)
{
  int D.32737;
  int lindex.165;
  int D.32739;
  struct MonoImageWriter * D.32740;
  struct FILE * D.32741;
  char symbol1[256];
  char symbol2[256];
  int lindex;

  try
    {
      D.32737 = acfg->objc_selector_index_2;
      lindex.165 = D.32737;
      D.32739 = lindex.165 + 1;
      acfg->objc_selector_index_2 = D.32739;
      lindex = lindex.165;
      emit_bytes (acfg, code, 8);
      sprintf (&symbol1, "L_OBJC_SELECTOR_%d", lindex);
      sprintf (&symbol2, "L_OBJC_SELECTOR_REFERENCES_%d", index);
      emit_label (acfg, &symbol1);
      D.32740 = acfg->w;
      img_writer_emit_unset_mode (D.32740);
      D.32741 = acfg->fp;
      fprintf (D.32741, ".long %s-(%s+12)", &symbol2, &symbol1);
      *code_size = 12;
    }
  finally
    {
      symbol1 = {CLOBBER};
      symbol2 = {CLOBBER};
    }
}


is_direct_callable (struct MonoAotCompile * acfg, struct MonoMethod * method, struct MonoJumpInfo * patch_info)
{
  <unnamed type> D.32744;
  struct MonoMethod * D.32746;
  struct MonoClass * D.32747;
  struct MonoImage * D.32748;
  struct MonoImage * D.32749;
  struct GHashTable * D.32751;
  unsigned char D.32758;
  unsigned char D.32759;
  struct MonoMethod * D.32761;
  struct MonoClass * D.32762;
  unsigned int D.32763;
  unsigned int D.32764;
  short unsigned int D.32767;
  int D.32768;
  int D.32769;
  unsigned char D.32773;
  unsigned char D.32774;
  int D.32777;
  int D.32779;
  unsigned char D.32780;
  unsigned char D.32781;
  gboolean D.32786;
  short unsigned int D.32790;
  int D.32791;
  int D.32792;
  int D.32794;
  int D.32799;

  D.32744 = patch_info->type;
  if (D.32744 == 3) goto <D.32745>; else goto <D.32742>;
  <D.32745>:
  D.32746 = patch_info->data.method;
  D.32747 = D.32746->klass;
  D.32748 = D.32747->image;
  D.32749 = acfg->image;
  if (D.32748 == D.32749) goto <D.32750>; else goto <D.32742>;
  <D.32750>:
  {
    struct MonoCompile * callee_cfg;

    D.32751 = acfg->method_to_cfg;
    D.32746 = patch_info->data.method;
    callee_cfg = monoeg_g_hash_table_lookup (D.32751, D.32746);
    if (callee_cfg != 0B) goto <D.32752>; else goto <D.32753>;
    <D.32752>:
    {
      gboolean direct_callable;

      direct_callable = 1;
      if (direct_callable != 0) goto <D.32756>; else goto <D.32757>;
      <D.32756>:
      D.32758 = BIT_FIELD_REF <*callee_cfg, 8, 3424>;
      D.32759 = D.32758 & 1;
      if (D.32759 != 0) goto <D.32754>; else goto <D.32760>;
      <D.32760>:
      D.32761 = callee_cfg->method;
      D.32762 = D.32761->klass;
      D.32763 = D.32762->flags;
      D.32764 = D.32763 & 1048576;
      if (D.32764 == 0) goto <D.32754>; else goto <D.32755>;
      <D.32754>:
      direct_callable = 0;
      <D.32755>:
      <D.32757>:
      D.32761 = callee_cfg->method;
      D.32767 = D.32761->iflags;
      D.32768 = (int) D.32767;
      D.32769 = D.32768 & 32;
      if (D.32769 != 0) goto <D.32770>; else goto <D.32771>;
      <D.32770>:
      if (method == 0B) goto <D.32765>; else goto <D.32772>;
      <D.32772>:
      D.32773 = BIT_FIELD_REF <*method, 8, 160>;
      D.32774 = D.32773 & 124;
      if (D.32774 != 64) goto <D.32765>; else goto <D.32766>;
      <D.32765>:
      direct_callable = 0;
      <D.32766>:
      <D.32771>:
      D.32777 = acfg->aot_opts.soft_debug;
      if (D.32777 != 0) goto <D.32775>; else goto <D.32778>;
      <D.32778>:
      D.32779 = acfg->aot_opts.no_direct_calls;
      if (D.32779 != 0) goto <D.32775>; else goto <D.32776>;
      <D.32775>:
      direct_callable = 0;
      <D.32776>:
      D.32761 = callee_cfg->method;
      D.32780 = BIT_FIELD_REF <*D.32761, 8, 160>;
      D.32781 = D.32780 & 124;
      if (D.32781 == 112) goto <D.32782>; else goto <D.32783>;
      <D.32782>:
      direct_callable = 0;
      <D.32783>:
      if (direct_callable != 0) goto <D.32784>; else goto <D.32785>;
      <D.32784>:
      D.32786 = 1;
      return D.32786;
      <D.32785>:
    }
    <D.32753>:
  }
  goto <D.32743>;
  <D.32742>:
  D.32744 = patch_info->type;
  if (D.32744 == 31) goto <D.32789>; else goto <D.32787>;
  <D.32789>:
  D.32746 = patch_info->data.method;
  D.32790 = D.32746->flags;
  D.32791 = (int) D.32790;
  D.32792 = D.32791 & 8192;
  if (D.32792 != 0) goto <D.32793>; else goto <D.32787>;
  <D.32793>:
  D.32794 = acfg->aot_opts.direct_pinvoke;
  if (D.32794 != 0) goto <D.32795>; else goto <D.32796>;
  <D.32795>:
  D.32786 = 1;
  return D.32786;
  <D.32796>:
  goto <D.32788>;
  <D.32787>:
  D.32744 = patch_info->type;
  if (D.32744 == 31) goto <D.32797>; else goto <D.32798>;
  <D.32797>:
  D.32799 = acfg->aot_opts.direct_icalls;
  if (D.32799 != 0) goto <D.32800>; else goto <D.32801>;
  <D.32800>:
  D.32786 = 1;
  return D.32786;
  <D.32801>:
  D.32786 = 0;
  return D.32786;
  <D.32798>:
  <D.32788>:
  <D.32743>:
  D.32786 = 0;
  return D.32786;
}


get_pinvoke_import (struct MonoAotCompile * acfg, struct MonoMethod * method)
{
  struct MonoClass * D.32803;
  struct GHashTable * D.32804;
  const char * D.32807;
  short unsigned int D.32810;
  int D.32812;
  <unnamed-unsigned:24> D.32813;
  int D.32814;
  int D.32815;
  unsigned int D.32818;
  <unnamed-unsigned:24> D.32820;
  unsigned int D.32821;
  unsigned int D.32822;
  const char * D.32823;
  struct MonoImage * image;
  struct MonoMethodPInvoke * piinfo;
  struct MonoTableInfo * tables;
  struct MonoTableInfo * im;
  struct MonoTableInfo * mr;
  guint32 im_cols[4];
  char * import;

  try
    {
      D.32803 = method->klass;
      image = D.32803->image;
      piinfo = method;
      tables = &image->tables;
      im = tables + 336;
      mr = tables + 312;
      D.32804 = acfg->method_to_pinvoke_import;
      import = monoeg_g_hash_table_lookup (D.32804, method);
      if (import != 0B) goto <D.32805>; else goto <D.32806>;
      <D.32805>:
      D.32807 = import;
      return D.32807;
      <D.32806>:
      D.32810 = piinfo->implmap_idx;
      if (D.32810 == 0) goto <D.32808>; else goto <D.32811>;
      <D.32811>:
      D.32810 = piinfo->implmap_idx;
      D.32812 = (int) D.32810;
      D.32813 = im->rows;
      D.32814 = (int) D.32813;
      if (D.32812 > D.32814) goto <D.32808>; else goto <D.32809>;
      <D.32808>:
      D.32807 = 0B;
      return D.32807;
      <D.32809>:
      D.32810 = piinfo->implmap_idx;
      D.32812 = (int) D.32810;
      D.32815 = D.32812 + -1;
      mono_metadata_decode_row (im, D.32815, &im_cols, 4);
      D.32818 = im_cols[3];
      if (D.32818 == 0) goto <D.32816>; else goto <D.32819>;
      <D.32819>:
      D.32818 = im_cols[3];
      D.32820 = mr->rows;
      D.32821 = (unsigned int) D.32820;
      if (D.32818 > D.32821) goto <D.32816>; else goto <D.32817>;
      <D.32816>:
      D.32807 = 0B;
      return D.32807;
      <D.32817>:
      D.32822 = im_cols[2];
      D.32823 = mono_metadata_string_heap (image, D.32822);
      import = monoeg_g_strdup_printf ("%s", D.32823);
      D.32804 = acfg->method_to_pinvoke_import;
      monoeg_g_hash_table_insert_replace (D.32804, method, import, 0);
      D.32807 = import;
      return D.32807;
    }
  finally
    {
      im_cols = {CLOBBER};
    }
}


arch_emit_direct_call (struct MonoAotCompile * acfg, const char * target, gboolean external, struct MonoJumpInfo * ji, int * call_size)
{
  int D.32826;
  struct MonoImageWriter * D.32829;
  struct FILE * D.32831;

  D.32826 = acfg->use_bin_writer;
  if (D.32826 != 0) goto <D.32827>; else goto <D.32828>;
  <D.32827>:
  {
    guint8 buf[4];
    guint8 * code;

    try
      {
        code = &buf;
        {
          arminstr_t * __ainstrp;

          __ainstrp = code;
          *__ainstrp = 3942645760;
          code = __ainstrp + 4;
        }
        D.32829 = acfg->w;
        img_writer_emit_reloc (D.32829, 28, target, -8);
        emit_bytes (acfg, &buf, 4);
      }
    finally
      {
        buf = {CLOBBER};
      }
  }
  goto <D.32830>;
  <D.32828>:
  emit_unset_mode (acfg);
  D.32831 = acfg->fp;
  fprintf (D.32831, "bl %s\n", target);
  <D.32830>:
  *call_size = 4;
}


arch_emit_got_access (struct MonoAotCompile * acfg, guint8 * code, int got_slot, int * code_size)
{
  unsigned int D.32832;
  int D.32833;
  char * D.32834;
  unsigned int got_slot.166;
  unsigned int D.32836;
  unsigned int D.32837;
  int D.32838;
  unsigned int D.32839;
  unsigned int D.32840;
  int D.32841;

  D.32832 = mono_arch_get_patch_offset (code);
  D.32833 = (int) D.32832;
  emit_bytes (acfg, code, D.32833);
  D.32834 = acfg->got_symbol;
  got_slot.166 = (unsigned int) got_slot;
  D.32836 = got_slot.166 + 1073741821;
  D.32837 = D.32836 * 4;
  D.32838 = (int) D.32837;
  emit_symbol_diff (acfg, D.32834, ".", D.32838);
  D.32839 = mono_arch_get_patch_offset (code);
  D.32840 = D.32839 + 4;
  D.32841 = (int) D.32840;
  *code_size = D.32841;
}


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

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


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

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


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

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


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

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


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

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


emit_info (struct MonoAotCompile * acfg)
{
  unsigned int D.32847;
  unsigned int D.32848;
  struct GPtrArray * D.32849;
  void * * D.32850;
  unsigned int oindex.167;
  unsigned int D.32852;
  void * * D.32853;
  void * D.32854;
  struct MonoCompile * * D.32855;
  unsigned int i.168;
  unsigned int D.32857;
  struct MonoCompile * * D.32858;
  struct MonoCompile * D.32859;
  gint32 * D.32862;
  unsigned int D.32863;
  int D.32864;
  unsigned int oindex.169;
  unsigned int D.32867;
  int D.32868;
  unsigned int D.32869;
  int D.32870;
  unsigned int D.32871;
  unsigned int D.32872;
  int D.32873;
  int oindex;
  int i;
  char symbol[256];
  gint32 * offsets;

  try
    {
      D.32847 = acfg->nmethods;
      D.32848 = D.32847 * 4;
      offsets = monoeg_malloc0 (D.32848);
      oindex = 0;
      goto <D.28193>;
      <D.28192>:
      D.32849 = acfg->method_order;
      D.32850 = D.32849->pdata;
      oindex.167 = (unsigned int) oindex;
      D.32852 = oindex.167 * 4;
      D.32853 = D.32850 + D.32852;
      D.32854 = *D.32853;
      i = (int) D.32854;
      D.32855 = acfg->cfgs;
      i.168 = (unsigned int) i;
      D.32857 = i.168 * 4;
      D.32858 = D.32855 + D.32857;
      D.32859 = *D.32858;
      if (D.32859 != 0B) goto <D.32860>; else goto <D.32861>;
      <D.32860>:
      D.32855 = acfg->cfgs;
      i.168 = (unsigned int) i;
      D.32857 = i.168 * 4;
      D.32858 = D.32855 + D.32857;
      D.32859 = *D.32858;
      emit_method_info (acfg, D.32859);
      i.168 = (unsigned int) i;
      D.32857 = i.168 * 4;
      D.32862 = offsets + D.32857;
      D.32855 = acfg->cfgs;
      i.168 = (unsigned int) i;
      D.32857 = i.168 * 4;
      D.32858 = D.32855 + D.32857;
      D.32859 = *D.32858;
      D.32863 = D.32859->method_info_offset;
      D.32864 = (int) D.32863;
      *D.32862 = D.32864;
      goto <D.32865>;
      <D.32861>:
      i.168 = (unsigned int) i;
      D.32857 = i.168 * 4;
      D.32862 = offsets + D.32857;
      *D.32862 = 0;
      <D.32865>:
      oindex = oindex + 1;
      <D.28193>:
      oindex.169 = (unsigned int) oindex;
      D.32849 = acfg->method_order;
      D.32867 = D.32849->len;
      if (oindex.169 < D.32867) goto <D.28192>; else goto <D.28194>;
      <D.28194>:
      sprintf (&symbol, "method_info_offsets");
      emit_section_change (acfg, ".rodata", 1);
      emit_alignment (acfg, 8);
      emit_label (acfg, &symbol);
      D.32847 = acfg->nmethods;
      D.32868 = (int) D.32847;
      D.32869 = emit_offset_table (acfg, D.32868, 10, offsets);
      D.32870 = acfg->stats.offsets_size;
      D.32871 = (unsigned int) D.32870;
      D.32872 = D.32871 + D.32869;
      D.32873 = (int) D.32872;
      acfg->stats.offsets_size = D.32873;
      monoeg_g_free (offsets);
    }
  finally
    {
      symbol = {CLOBBER};
    }
}


emit_method_info (struct MonoAotCompile * acfg, struct MonoCompile * cfg)
{
  struct MonoCompile * * D.32874;
  unsigned int D.32875;
  struct MonoCompile * * D.32876;
  struct MonoCompile * D.32877;
  int iftmp.170;
  unsigned int D.32879;
  unsigned int D.32882;
  unsigned int D.32883;
  unsigned int buf_size.171;
  struct MonoClass * D.32886;
  struct MonoMethod * D.32887;
  guint8 * p.172;
  unsigned int D.32892;
  unsigned int D.32893;
  struct GList * D.32896;
  unsigned int D.32897;
  int D.32898;
  void * D.32899;
  int D.32900;
  _Bool D.32902;
  long int D.32903;
  long int D.32904;
  void * * D.32907;
  unsigned int pindex.173;
  unsigned int D.32909;
  void * * D.32910;
  <unnamed type> D.32911;
  _Bool D.32912;
  _Bool D.32913;
  _Bool D.32914;
  <unnamed type> D.32917;
  struct MonoImage * D.32920;
  struct MonoImage * D.32921;
  int D.32926;
  unsigned int pindex.174;
  unsigned char D.32932;
  unsigned char D.32933;
  _Bool D.32934;
  long int D.32935;
  long int D.32936;
  int first_got_offset.175;
  int D.32940;
  int p.176;
  int buf.177;
  int D.32943;
  int D.32944;
  _Bool D.32945;
  long int D.32946;
  long int D.32947;
  unsigned int D.32950;
  unsigned int D.32951;
  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.27589>;
      <D.27588>:
      monoeg_g_ptr_array_add (patches, patch_info);
      patch_info = patch_info->next;
      <D.27589>:
      if (patch_info != 0B) goto <D.27588>; else goto <D.27590>;
      <D.27590>:
      monoeg_g_ptr_array_sort (patches, compare_patches);
      D.32874 = acfg->cfgs;
      D.32875 = method_index * 4;
      D.32876 = D.32874 + D.32875;
      D.32877 = *D.32876;
      first_got_offset = D.32877->got_offset;
      D.32879 = patches->len;
      if (D.32879 > 999) goto <D.32880>; else goto <D.32881>;
      <D.32880>:
      D.32879 = patches->len;
      D.32882 = D.32879 + 640;
      D.32883 = D.32882 * 64;
      iftmp.170 = (int) D.32883;
      goto <D.32884>;
      <D.32881>:
      iftmp.170 = 40960;
      <D.32884>:
      buf_size = iftmp.170;
      buf_size.171 = (unsigned int) buf_size;
      buf = monoeg_malloc (buf_size.171);
      p = buf;
      D.32886 = method->klass;
      D.32887 = mono_class_get_cctor (D.32886);
      if (D.32887 != 0B) goto <D.32888>; else goto <D.32889>;
      <D.32888>:
      D.32886 = method->klass;
      p.172 = p;
      encode_klass_ref (acfg, D.32886, p.172, &p);
      goto <D.32891>;
      <D.32889>:
      p.172 = p;
      encode_value (0, p.172, &p);
      <D.32891>:
      D.32892 = cfg->opt;
      D.32893 = D.32892 & 512;
      if (D.32893 != 0) goto <D.32894>; else goto <D.32895>;
      <D.32894>:
      D.32896 = cfg->ldstr_list;
      D.32897 = monoeg_g_list_length (D.32896);
      D.32898 = (int) D.32897;
      p.172 = p;
      encode_value (D.32898, p.172, &p);
      l = cfg->ldstr_list;
      goto <D.27592>;
      <D.27591>:
      D.32899 = l->data;
      D.32900 = (int) D.32899;
      p.172 = p;
      encode_value (D.32900, p.172, &p);
      l = l->next;
      <D.27592>:
      if (l != 0B) goto <D.27591>; else goto <D.27593>;
      <D.27593>:
      goto <D.32901>;
      <D.32895>:
      D.32896 = cfg->ldstr_list;
      D.32902 = D.32896 != 0B;
      D.32903 = (long int) D.32902;
      D.32904 = __builtin_expect (D.32903, 0);
      if (D.32904 != 0) goto <D.32905>; else goto <D.32906>;
      <D.32905>:
      monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "aot-compiler.c", 5129, "!cfg->ldstr_list");
      <D.32906>:
      <D.32901>:
      n_patches = 0;
      pindex = 0;
      goto <D.27596>;
      <D.27595>:
      D.32907 = patches->pdata;
      pindex.173 = (unsigned int) pindex;
      D.32909 = pindex.173 * 4;
      D.32910 = D.32907 + D.32909;
      patch_info = *D.32910;
      D.32911 = patch_info->type;
      D.32912 = D.32911 == 27;
      D.32913 = D.32911 == 51;
      D.32914 = D.32912 | D.32913;
      if (D.32914 != 0) goto <D.32915>; else goto <D.32916>;
      <D.32915>:
      patch_info->type = 51;
      // predicted unlikely by continue predictor.
      goto <D.27594>;
      <D.32916>:
      D.32917 = patch_info->type;
      if (D.32917 == 12) goto <D.32918>; else goto <D.32919>;
      <D.32918>:
      D.32920 = patch_info->data.image;
      D.32921 = acfg->image;
      if (D.32920 == D.32921) goto <D.32922>; else goto <D.32923>;
      <D.32922>:
      patch_info->type = 51;
      // predicted unlikely by continue predictor.
      goto <D.27594>;
      <D.32923>:
      <D.32919>:
      D.32917 = patch_info->type;
      if (D.32917 == 42) goto <D.32924>; else goto <D.32925>;
      <D.32924>:
      patch_info->type = 51;
      // predicted unlikely by continue predictor.
      goto <D.27594>;
      <D.32925>:
      D.32926 = is_plt_patch (patch_info);
      if (D.32926 != 0) goto <D.32927>; else goto <D.32928>;
      <D.32927>:
      patch_info->type = 51;
      // predicted unlikely by continue predictor.
      goto <D.27594>;
      <D.32928>:
      n_patches = n_patches + 1;
      <D.27594>:
      pindex = pindex + 1;
      <D.27596>:
      pindex.174 = (unsigned int) pindex;
      D.32879 = patches->len;
      if (pindex.174 < D.32879) goto <D.27595>; else goto <D.27597>;
      <D.27597>:
      if (n_patches != 0) goto <D.32930>; else goto <D.32931>;
      <D.32930>:
      D.32932 = BIT_FIELD_REF <*cfg, 8, 3424>;
      D.32933 = D.32932 & 1;
      D.32934 = D.32933 == 0;
      D.32935 = (long int) D.32934;
      D.32936 = __builtin_expect (D.32935, 0);
      if (D.32936 != 0) goto <D.32937>; else goto <D.32938>;
      <D.32937>:
      monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "aot-compiler.c", 5164, "cfg->has_got_slots");
      <D.32938>:
      <D.32931>:
      first_got_offset.175 = (int) first_got_offset;
      p.172 = p;
      encode_patch_list (acfg, patches, n_patches, first_got_offset.175, p.172, &p);
      D.32940 = acfg->stats.info_size;
      p.172 = p;
      p.176 = (int) p.172;
      buf.177 = (int) buf;
      D.32943 = p.176 - buf.177;
      D.32944 = D.32940 + D.32943;
      acfg->stats.info_size = D.32944;
      p.172 = p;
      p.176 = (int) p.172;
      buf.177 = (int) buf;
      D.32943 = p.176 - buf.177;
      D.32945 = D.32943 >= buf_size;
      D.32946 = (long int) D.32945;
      D.32947 = __builtin_expect (D.32946, 0);
      if (D.32947 != 0) goto <D.32948>; else goto <D.32949>;
      <D.32948>:
      monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "aot-compiler.c", 5170, "p - buf < buf_size");
      <D.32949>:
      p.172 = p;
      p.176 = (int) p.172;
      buf.177 = (int) buf;
      D.32943 = p.176 - buf.177;
      D.32950 = (unsigned int) D.32943;
      D.32951 = add_to_blob (acfg, buf, D.32950);
      cfg->method_info_offset = D.32951;
      monoeg_g_free (buf);
    }
  finally
    {
      p = {CLOBBER};
    }
}


encode_klass_ref (struct MonoAotCompile * acfg, struct MonoClass * klass, guint8 * buf, guint8 * * endbuf)
{
  struct MonoGenericClass * D.32952;
  unsigned int D.32955;
  _Bool D.32956;
  long int D.32957;
  long int D.32958;
  unsigned char D.32964;
  _Bool D.32965;
  _Bool D.32966;
  _Bool D.32967;
  struct GHashTable * D.32972;
  void * D.32973;
  guint8 * p.178;
  int p.179;
  int buf2.180;
  int D.32979;
  _Bool D.32980;
  long int D.32981;
  long int D.32982;
  unsigned int D.32985;
  unsigned int D.32986;
  void * D.32987;
  int offset.181;
  gboolean shared;

  shared = 0;
  D.32952 = klass->generic_class;
  if (D.32952 != 0B) goto <D.32953>; else goto <D.32954>;
  <D.32953>:
  {
    guint32 token;

    D.32955 = klass->type_token;
    D.32956 = D.32955 == 0;
    D.32957 = (long int) D.32956;
    D.32958 = __builtin_expect (D.32957, 0);
    if (D.32958 != 0) goto <D.32959>; else goto <D.32960>;
    <D.32959>:
    monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "aot-compiler.c", 2354, "klass->type_token");
    <D.32960>:
    token = find_typespec_for_class (acfg, klass);
    if (token == 0) goto <D.32961>; else goto <D.32962>;
    <D.32961>:
    shared = 1;
    <D.32962>:
  }
  goto <D.32963>;
  <D.32954>:
  D.32964 = klass->byval_arg.type;
  D.32965 = D.32964 == 19;
  D.32966 = D.32964 == 30;
  D.32967 = D.32965 | D.32966;
  if (D.32967 != 0) goto <D.32968>; else goto <D.32969>;
  <D.32968>:
  shared = 1;
  <D.32969>:
  <D.32963>:
  if (shared != 0) goto <D.32970>; else goto <D.32971>;
  <D.32970>:
  {
    guint offset;
    guint8 * buf2;
    guint8 * p;

    try
      {
        D.32972 = acfg->klass_blob_hash;
        D.32973 = monoeg_g_hash_table_lookup (D.32972, klass);
        offset = (guint) D.32973;
        if (offset == 0) goto <D.32974>; else goto <D.32975>;
        <D.32974>:
        buf2 = monoeg_malloc (1024);
        p = buf2;
        p.178 = p;
        encode_klass_ref_inner (acfg, klass, p.178, &p);
        p.178 = p;
        p.179 = (int) p.178;
        buf2.180 = (int) buf2;
        D.32979 = p.179 - buf2.180;
        D.32980 = D.32979 > 1023;
        D.32981 = (long int) D.32980;
        D.32982 = __builtin_expect (D.32981, 0);
        if (D.32982 != 0) goto <D.32983>; else goto <D.32984>;
        <D.32983>:
        monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "aot-compiler.c", 2373, "p - buf2 < 1024");
        <D.32984>:
        p.178 = p;
        p.179 = (int) p.178;
        buf2.180 = (int) buf2;
        D.32979 = p.179 - buf2.180;
        D.32985 = (unsigned int) D.32979;
        offset = add_to_blob (acfg, buf2, D.32985);
        monoeg_g_free (buf2);
        D.32972 = acfg->klass_blob_hash;
        D.32986 = offset + 1;
        D.32987 = (void *) D.32986;
        monoeg_g_hash_table_insert_replace (D.32972, klass, D.32987, 0);
        goto <D.32988>;
        <D.32975>:
        offset = offset + 4294967295;
        <D.32988>:
        p = buf;
        p.178 = p;
        encode_value (7, p.178, &p);
        offset.181 = (int) offset;
        p.178 = p;
        encode_value (offset.181, p.178, &p);
        p.178 = p;
        *endbuf = p.178;
        return;
      }
    finally
      {
        p = {CLOBBER};
      }
  }
  <D.32971>:
  encode_klass_ref_inner (acfg, klass, buf, endbuf);
}


find_typespec_for_class (struct MonoAotCompile * acfg, struct MonoClass * klass)
{
  struct MonoImage * D.32992;
  <unnamed-unsigned:24> D.32993;
  struct MonoClass * * D.32994;
  struct MonoMemPool * D.32997;
  unsigned int len.182;
  unsigned int D.32999;
  void * D.33000;
  unsigned int i.183;
  unsigned int D.33002;
  struct MonoClass * * D.33003;
  int D.33004;
  int D.33005;
  unsigned int D.33006;
  struct MonoClass * D.33007;
  struct MonoClass * D.33008;
  guint32 D.33012;
  int i;
  int len;

  D.32992 = acfg->image;
  D.32993 = D.32992->tables[27].rows;
  len = (int) D.32993;
  D.32994 = acfg->typespec_classes;
  if (D.32994 == 0B) goto <D.32995>; else goto <D.32996>;
  <D.32995>:
  D.32997 = acfg->mempool;
  len.182 = (unsigned int) len;
  D.32999 = len.182 * 4;
  D.33000 = mono_mempool_alloc0 (D.32997, D.32999);
  acfg->typespec_classes = D.33000;
  i = 0;
  goto <D.26399>;
  <D.26398>:
  D.32994 = acfg->typespec_classes;
  i.183 = (unsigned int) i;
  D.33002 = i.183 * 4;
  D.33003 = D.32994 + D.33002;
  D.32992 = acfg->image;
  D.33004 = i + 1;
  D.33005 = D.33004 | 452984832;
  D.33006 = (unsigned int) D.33005;
  D.33007 = mono_class_get_full (D.32992, D.33006, 0B);
  *D.33003 = D.33007;
  i = i + 1;
  <D.26399>:
  if (i < len) goto <D.26398>; else goto <D.26400>;
  <D.26400>:
  <D.32996>:
  i = 0;
  goto <D.26403>;
  <D.26402>:
  D.32994 = acfg->typespec_classes;
  i.183 = (unsigned int) i;
  D.33002 = i.183 * 4;
  D.33003 = D.32994 + D.33002;
  D.33008 = *D.33003;
  if (D.33008 == klass) goto <D.26401>; else goto <D.33009>;
  <D.33009>:
  i = i + 1;
  <D.26403>:
  if (i < len) goto <D.26402>; else goto <D.26401>;
  <D.26401>:
  if (i < len) goto <D.33010>; else goto <D.33011>;
  <D.33010>:
  D.33004 = i + 1;
  D.33005 = D.33004 | 452984832;
  D.33012 = (guint32) D.33005;
  return D.33012;
  <D.33011>:
  D.33012 = 0;
  return D.33012;
}


encode_klass_ref_inner (struct MonoAotCompile * acfg, struct MonoClass * klass, guint8 * buf, guint8 * * endbuf)
{
  struct MonoGenericClass * D.33014;
  unsigned int D.33017;
  _Bool D.33018;
  long int D.33019;
  long int D.33020;
  guint8 * p.184;
  int token.185;
  int p.186;
  int p1.187;
  int D.33030;
  int count.188;
  int count.189;
  struct MonoImage * D.33036;
  unsigned int D.33037;
  unsigned int D.33038;
  _Bool D.33039;
  long int D.33040;
  long int D.33041;
  unsigned int D.33046;
  int D.33047;
  unsigned int D.33049;
  int D.33050;
  unsigned char D.33052;
  _Bool D.33053;
  _Bool D.33054;
  _Bool D.33055;
  struct MonoGenericParam * D.33058;
  unsigned char D.33059;
  int D.33060;
  short unsigned int D.33061;
  int D.33062;
  _Bool D.33063;
  int D.33064;
  <unnamed-signed:1> D.33067;
  int D.33068;
  short unsigned int D.33069;
  _Bool D.33070;
  long int D.33071;
  long int D.33072;
  unsigned char D.33075;
  unsigned char D.33076;
  struct MonoMethod * D.33079;
  struct MonoClass * D.33081;
  int D.33083;
  struct MonoType * D.33087;
  unsigned char D.33089;
  _Bool D.33090;
  long int D.33091;
  long int D.33092;
  int D.33095;
  struct MonoClass * D.33096;
  guint8 * p;

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

        D.33017 = klass->type_token;
        D.33018 = D.33017 == 0;
        D.33019 = (long int) D.33018;
        D.33020 = __builtin_expect (D.33019, 0);
        if (D.33020 != 0) goto <D.33021>; else goto <D.33022>;
        <D.33021>:
        monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "aot-compiler.c", 2275, "klass->type_token");
        <D.33022>:
        token = find_typespec_for_class (acfg, klass);
        if (token != 0) goto <D.33023>; else goto <D.33024>;
        <D.33023>:
        p.184 = p;
        encode_value (3, p.184, &p);
        token.185 = (int) token;
        p.184 = p;
        encode_value (token.185, p.184, &p);
        goto <D.33027>;
        <D.33024>:
        {
          struct MonoClass * gclass;
          struct MonoGenericInst * inst;
          static int count = 0;
          guint8 * p1;

          D.33014 = klass->generic_class;
          gclass = D.33014->container_class;
          D.33014 = klass->generic_class;
          inst = D.33014->context.class_inst;
          p1 = p;
          p.184 = p;
          encode_value (4, p.184, &p);
          p.184 = p;
          encode_klass_ref (acfg, gclass, p.184, &p);
          p.184 = p;
          encode_ginst (acfg, inst, p.184, &p);
          p.184 = p;
          p.186 = (int) p.184;
          p1.187 = (int) p1;
          D.33030 = p.186 - p1.187;
          count.188 = count;
          count.189 = D.33030 + count.188;
          count = count.189;
        }
        <D.33027>:
      }
      goto <D.33033>;
      <D.33016>:
      D.33017 = klass->type_token;
      if (D.33017 != 0) goto <D.33034>; else goto <D.33035>;
      <D.33034>:
      {
        int iindex;

        D.33036 = klass->image;
        D.33037 = get_image_index (acfg, D.33036);
        iindex = (int) D.33037;
        D.33017 = klass->type_token;
        D.33038 = D.33017 & 4278190080;
        D.33039 = D.33038 != 33554432;
        D.33040 = (long int) D.33039;
        D.33041 = __builtin_expect (D.33040, 0);
        if (D.33041 != 0) goto <D.33042>; else goto <D.33043>;
        <D.33042>:
        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.33043>:
        if (iindex == 0) goto <D.33044>; else goto <D.33045>;
        <D.33044>:
        p.184 = p;
        encode_value (1, p.184, &p);
        D.33017 = klass->type_token;
        D.33046 = D.33017 + 4261412864;
        D.33047 = (int) D.33046;
        p.184 = p;
        encode_value (D.33047, p.184, &p);
        goto <D.33048>;
        <D.33045>:
        p.184 = p;
        encode_value (2, p.184, &p);
        D.33017 = klass->type_token;
        D.33046 = D.33017 + 4261412864;
        D.33047 = (int) D.33046;
        p.184 = p;
        encode_value (D.33047, p.184, &p);
        D.33036 = klass->image;
        D.33049 = get_image_index (acfg, D.33036);
        D.33050 = (int) D.33049;
        p.184 = p;
        encode_value (D.33050, p.184, &p);
        <D.33048>:
      }
      goto <D.33051>;
      <D.33035>:
      D.33052 = klass->byval_arg.type;
      D.33053 = D.33052 == 19;
      D.33054 = D.33052 == 30;
      D.33055 = D.33053 | D.33054;
      if (D.33055 != 0) goto <D.33056>; else goto <D.33057>;
      <D.33056>:
      {
        struct MonoGenericContainer * container;
        struct MonoGenericParam * par;

        D.33058 = klass->byval_arg.data.generic_param;
        container = D.33058->owner;
        par = klass->byval_arg.data.generic_param;
        p.184 = p;
        encode_value (5, p.184, &p);
        D.33059 = klass->byval_arg.type;
        D.33060 = (int) D.33059;
        p.184 = p;
        encode_value (D.33060, p.184, &p);
        D.33058 = klass->byval_arg.data.generic_param;
        D.33061 = D.33058->num;
        D.33062 = (int) D.33061;
        p.184 = p;
        encode_value (D.33062, p.184, &p);
        D.33063 = container != 0B;
        D.33064 = (int) D.33063;
        p.184 = p;
        encode_value (D.33064, p.184, &p);
        if (container != 0B) goto <D.33065>; else goto <D.33066>;
        <D.33065>:
        D.33067 = container->is_method;
        D.33068 = (int) D.33067;
        p.184 = p;
        encode_value (D.33068, p.184, &p);
        D.33069 = par->serial;
        D.33070 = D.33069 != 0;
        D.33071 = (long int) D.33070;
        D.33072 = __builtin_expect (D.33071, 0);
        if (D.33072 != 0) goto <D.33073>; else goto <D.33074>;
        <D.33073>:
        monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "aot-compiler.c", 2317, "par->serial == 0");
        <D.33074>:
        D.33075 = BIT_FIELD_REF <*container, 8, 152>;
        D.33076 = D.33075 & 128;
        if (D.33076 != 0) goto <D.33077>; else goto <D.33078>;
        <D.33077>:
        D.33079 = container->owner.method;
        p.184 = p;
        encode_method_ref (acfg, D.33079, p.184, &p);
        goto <D.33080>;
        <D.33078>:
        D.33081 = container->owner.klass;
        p.184 = p;
        encode_klass_ref (acfg, D.33081, p.184, &p);
        <D.33080>:
        goto <D.33082>;
        <D.33066>:
        D.33069 = par->serial;
        D.33083 = (int) D.33069;
        p.184 = p;
        encode_value (D.33083, p.184, &p);
        <D.33082>:
      }
      goto <D.33084>;
      <D.33057>:
      D.33059 = klass->byval_arg.type;
      if (D.33059 == 15) goto <D.33085>; else goto <D.33086>;
      <D.33085>:
      p.184 = p;
      encode_value (8, p.184, &p);
      D.33087 = &klass->byval_arg;
      p.184 = p;
      encode_type (acfg, D.33087, p.184, &p);
      goto <D.33088>;
      <D.33086>:
      D.33089 = klass->rank;
      D.33090 = D.33089 == 0;
      D.33091 = (long int) D.33090;
      D.33092 = __builtin_expect (D.33091, 0);
      if (D.33092 != 0) goto <D.33093>; else goto <D.33094>;
      <D.33093>:
      monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "aot-compiler.c", 2330, "klass->rank > 0");
      <D.33094>:
      p.184 = p;
      encode_value (6, p.184, &p);
      D.33089 = klass->rank;
      D.33095 = (int) D.33089;
      p.184 = p;
      encode_value (D.33095, p.184, &p);
      D.33096 = klass->element_class;
      p.184 = p;
      encode_klass_ref (acfg, D.33096, p.184, &p);
      <D.33088>:
      <D.33084>:
      <D.33051>:
      <D.33033>:
      p.184 = p;
      *endbuf = p.184;
    }
  finally
    {
      p = {CLOBBER};
    }
}


encode_ginst (struct MonoAotCompile * acfg, struct MonoGenericInst * inst, guint8 * buf, guint8 * * endbuf)
{
  <unnamed-unsigned:22> D.33097;
  int D.33098;
  guint8 * p.190;
  struct MonoType * D.33100;
  struct MonoClass * D.33101;
  int D.33102;
  guint8 * p;
  int i;

  try
    {
      p = buf;
      D.33097 = inst->type_argc;
      D.33098 = (int) D.33097;
      p.190 = p;
      encode_value (D.33098, p.190, &p);
      i = 0;
      goto <D.26467>;
      <D.26466>:
      D.33100 = inst->type_argv[i];
      D.33101 = mono_class_from_mono_type (D.33100);
      p.190 = p;
      encode_klass_ref (acfg, D.33101, p.190, &p);
      i = i + 1;
      <D.26467>:
      D.33097 = inst->type_argc;
      D.33102 = (int) D.33097;
      if (D.33102 > i) goto <D.26466>; else goto <D.26468>;
      <D.26468>:
      p.190 = p;
      *endbuf = p.190;
    }
  finally
    {
      p = {CLOBBER};
    }
}


get_image_index (struct MonoAotCompile * cfg, struct MonoImage * image)
{
  struct GHashTable * D.33103;
  void * D.33104;
  guint32 D.33107;
  unsigned int D.33108;
  void * D.33109;
  struct GPtrArray * D.33110;
  guint32 index;

  D.33103 = cfg->image_hash;
  D.33104 = monoeg_g_hash_table_lookup (D.33103, image);
  index = (guint32) D.33104;
  if (index != 0) goto <D.33105>; else goto <D.33106>;
  <D.33105>:
  D.33107 = index + 4294967295;
  return D.33107;
  <D.33106>:
  D.33103 = cfg->image_hash;
  index = monoeg_g_hash_table_size (D.33103);
  D.33103 = cfg->image_hash;
  D.33108 = index + 1;
  D.33109 = (void *) D.33108;
  monoeg_g_hash_table_insert_replace (D.33103, image, D.33109, 0);
  D.33110 = cfg->image_table;
  monoeg_g_ptr_array_add (D.33110, image);
  D.33107 = index;
  return D.33107;
}


encode_method_ref (struct MonoAotCompile * acfg, struct MonoMethod * method, guint8 * buf, guint8 * * endbuf)
{
  struct MonoClass * D.33112;
  struct MonoImage * D.33113;
  unsigned char D.33117;
  unsigned char D.33118;
  short unsigned int D.33120;
  int D.33121;
  int D.33122;
  short unsigned int D.33123;
  int D.33124;
  int D.33125;
  guint8 * p.191;
  unsigned char D.33127;
  unsigned char D.33128;
  <unnamed-unsigned:5> D.33131;
  int D.33132;
  int D.33133;
  _Bool D.33134;
  long int D.33135;
  long int D.33136;
  int D.33139;
  _Bool D.33140;
  long int D.33141;
  long int D.33142;
  _Bool D.33145;
  long int D.33146;
  long int D.33147;
  <unnamed type> D.33150;
  int D.33151;
  int D.33154;
  _Bool D.33155;
  long int D.33156;
  long int D.33157;
  <unnamed type> D.33160;
  int D.33161;
  unsigned int D.33162;
  struct MonoMethod * D.33168;
  struct MonoMethod * D.33172;
  _Bool D.33173;
  long int D.33174;
  long int D.33175;
  <unnamed type> D.33178;
  int D.33179;
  const char * D.33182;
  unsigned int D.33183;
  sizetype D.33184;
  guint8 * p.192;
  struct MonoMethod * D.33189;
  _Bool D.33191;
  long int D.33192;
  long int D.33193;
  _Bool D.33196;
  long int D.33197;
  long int D.33198;
  _Bool D.33201;
  long int D.33202;
  long int D.33203;
  _Bool D.33206;
  long int D.33207;
  long int D.33208;
  <unnamed type> D.33211;
  int D.33212;
  unsigned int D.33215;
  int D.33216;
  unsigned int D.33217;
  int D.33218;
  struct MonoMethod * D.33222;
  _Bool D.33224;
  long int D.33225;
  long int D.33226;
  <unnamed type> D.33229;
  int D.33230;
  _Bool D.33231;
  long int D.33232;
  long int D.33233;
  <unnamed type> D.33236;
  int D.33237;
  unsigned int D.33238;
  struct MonoMethod * D.33241;
  struct MonoMethodSignature * D.33245;
  unsigned char D.33246;
  gint32 iftmp.193;
  <unnamed type> D.33255;
  _Bool D.33257;
  long int D.33258;
  long int D.33259;
  struct MonoMethod * D.33262;
  struct MonoClass * D.33263;
  struct MonoMethodSignature * D.33265;
  unsigned char D.33266;
  unsigned char D.33267;
  struct GHashTable * D.33270;
  struct MonoImage * D.33273;
  _Bool D.33274;
  long int D.33275;
  long int D.33276;
  int image_index.194;
  int token.195;
  _Bool D.33282;
  long int D.33283;
  long int D.33284;
  unsigned int D.33289;
  _Bool D.33290;
  long int D.33291;
  long int D.33292;
  unsigned int D.33295;
  _Bool D.33296;
  long int D.33297;
  long int D.33298;
  unsigned char D.33309;
  _Bool D.33310;
  long int D.33311;
  long int D.33312;
  int D.26592;
  int iftmp.196;
  int D.26591;
  const char[6] * D.33320;
  unsigned char D.33321;
  int D.33322;
  unsigned char D.33323;
  int D.33324;
  _Bool D.33325;
  _Bool D.33326;
  _Bool D.33327;
  const unsigned char * D.33330;
  unsigned char D.33331;
  int D.33332;
  const unsigned char * D.33333;
  unsigned char D.33334;
  int D.33335;
  _Bool D.33336;
  _Bool D.33337;
  const unsigned char * D.33340;
  unsigned char D.33341;
  int D.33342;
  const unsigned char * D.33343;
  unsigned char D.33344;
  int D.33345;
  _Bool D.33346;
  _Bool D.33347;
  const unsigned char * D.33350;
  unsigned char D.33351;
  int D.33352;
  const unsigned char * D.33353;
  unsigned char D.33354;
  int D.33355;
  struct MonoMethodSignature * D.33358;
  short unsigned int D.33359;
  short unsigned int D.33360;
  int D.26601;
  int iftmp.197;
  int D.26600;
  unsigned char D.33367;
  int D.33368;
  _Bool D.33369;
  _Bool D.33370;
  _Bool D.33371;
  const unsigned char * D.33374;
  unsigned char D.33375;
  int D.33376;
  _Bool D.33377;
  _Bool D.33378;
  const unsigned char * D.33381;
  unsigned char D.33382;
  int D.33383;
  _Bool D.33384;
  _Bool D.33385;
  const unsigned char * D.33388;
  unsigned char D.33389;
  int D.33390;
  struct MonoMethodSignature * D.33393;
  short unsigned int D.33394;
  int D.33395;
  int D.33396;
  int D.33397;
  int D.26610;
  int iftmp.198;
  int D.26609;
  const char[4] * D.33402;
  unsigned char D.33403;
  int D.33404;
  unsigned char D.33405;
  int D.33406;
  _Bool D.33407;
  _Bool D.33408;
  _Bool D.33409;
  const unsigned char * D.33412;
  unsigned char D.33413;
  int D.33414;
  const unsigned char * D.33415;
  unsigned char D.33416;
  int D.33417;
  _Bool D.33418;
  _Bool D.33419;
  const unsigned char * D.33422;
  unsigned char D.33423;
  int D.33424;
  const unsigned char * D.33425;
  unsigned char D.33426;
  int D.33427;
  _Bool D.33428;
  _Bool D.33429;
  const unsigned char * D.33432;
  unsigned char D.33433;
  int D.33434;
  const unsigned char * D.33435;
  unsigned char D.33436;
  int D.33437;
  int D.26619;
  int iftmp.199;
  int D.26618;
  const char[8] * D.33445;
  unsigned char D.33446;
  int D.33447;
  unsigned char D.33448;
  int D.33449;
  _Bool D.33450;
  _Bool D.33451;
  _Bool D.33452;
  const unsigned char * D.33455;
  unsigned char D.33456;
  int D.33457;
  const unsigned char * D.33458;
  unsigned char D.33459;
  int D.33460;
  _Bool D.33461;
  _Bool D.33462;
  const unsigned char * D.33465;
  unsigned char D.33466;
  int D.33467;
  const unsigned char * D.33468;
  unsigned char D.33469;
  int D.33470;
  _Bool D.33471;
  _Bool D.33472;
  const unsigned char * D.33475;
  unsigned char D.33476;
  int D.33477;
  const unsigned char * D.33478;
  unsigned char D.33479;
  int D.33480;
  int D.26628;
  int iftmp.200;
  int D.26627;
  const char[4] * D.33488;
  unsigned char D.33489;
  int D.33490;
  unsigned char D.33491;
  int D.33492;
  _Bool D.33493;
  _Bool D.33494;
  _Bool D.33495;
  const unsigned char * D.33498;
  unsigned char D.33499;
  int D.33500;
  const unsigned char * D.33501;
  unsigned char D.33502;
  int D.33503;
  _Bool D.33504;
  _Bool D.33505;
  const unsigned char * D.33508;
  unsigned char D.33509;
  int D.33510;
  const unsigned char * D.33511;
  unsigned char D.33512;
  int D.33513;
  _Bool D.33514;
  _Bool D.33515;
  const unsigned char * D.33518;
  unsigned char D.33519;
  int D.33520;
  const unsigned char * D.33521;
  unsigned char D.33522;
  int D.33523;
  int D.33533;
  unsigned int D.33535;
  unsigned int D.33536;
  unsigned int D.33537;
  int D.33538;
  guint32 image_index;
  guint32 token;
  struct MonoJumpInfoToken * ji;
  guint8 * p;

  try
    {
      D.33112 = method->klass;
      D.33113 = D.33112->image;
      image_index = get_image_index (acfg, D.33113);
      token = method->token;
      p = buf;
      D.33117 = BIT_FIELD_REF <*method, 8, 168>;
      D.33118 = D.33117 & 8;
      if (D.33118 != 0) goto <D.33119>; else goto <D.33114>;
      <D.33119>:
      D.33120 = method->flags;
      D.33121 = (int) D.33120;
      D.33122 = D.33121 & 64;
      if (D.33122 != 0) goto <D.33115>; else goto <D.33114>;
      <D.33114>:
      D.33123 = method->iflags;
      D.33124 = (int) D.33123;
      D.33125 = D.33124 & 32;
      if (D.33125 != 0) goto <D.33115>; else goto <D.33116>;
      <D.33115>:
      p.191 = p;
      encode_value (-83886080, p.191, &p);
      <D.33116>:
      D.33127 = BIT_FIELD_REF <*method, 8, 160>;
      D.33128 = D.33127 & 124;
      if (D.33128 != 0) goto <D.33129>; else goto <D.33130>;
      <D.33129>:
      p.191 = p;
      encode_value (-67108864, p.191, &p);
      D.33131 = method->wrapper_type;
      D.33132 = (int) D.33131;
      p.191 = p;
      encode_value (D.33132, p.191, &p);
      D.33131 = method->wrapper_type;
      D.33133 = (int) D.33131;
      switch (D.33133) <default: <D.26581>, case 1: <D.26574>, case 2: <D.26575>, case 3: <D.26576>, case 4: <D.26572>, case 5: <D.26579>, case 6: <D.26564>, case 7: <D.26568>, case 8: <D.26544>, case 9: <D.26545>, case 10: <D.26546>, case 12: <D.26550>, case 13: <D.26552>, case 14: <D.26555>, case 15: <D.26556>, case 16: <D.26566>, case 18: <D.26553>, case 19: <D.26570>, case 20: <D.26549>, case 21: <D.26560>, case 23: <D.26551>, case 24: <D.26559>, case 25: <D.26562>, case 28: <D.26557>>
      <D.26544>:
      <D.26545>:
      <D.26546>:
      {
        struct MonoMethod * m;

        m = mono_marshal_method_from_wrapper (method);
        D.33134 = m == 0B;
        D.33135 = (long int) D.33134;
        D.33136 = __builtin_expect (D.33135, 0);
        if (D.33136 != 0) goto <D.33137>; else goto <D.33138>;
        <D.33137>:
        monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "aot-compiler.c", 2595, "m");
        <D.33138>:
        p.191 = p;
        encode_method_ref (acfg, m, p.191, &p);
        goto <D.26548>;
      }
      <D.26549>:
      <D.26550>:
      <D.26551>:
      <D.26552>:
      <D.26553>:
      {
        struct MonoClass * proxy_class;

        proxy_class = mono_marshal_get_wrapper_info (method);
        p.191 = p;
        encode_klass_ref (acfg, proxy_class, p.191, &p);
        goto <D.26548>;
      }
      <D.26555>:
      <D.26556>:
      goto <D.26548>;
      <D.26557>:
      {
        struct AllocatorWrapperInfo * info;

        info = mono_marshal_get_wrapper_info (method);
        D.33139 = info->alloc_type;
        D.33140 = D.33139 == -1;
        D.33141 = (long int) D.33140;
        D.33142 = __builtin_expect (D.33141, 0);
        if (D.33142 != 0) goto <D.33143>; else goto <D.33144>;
        <D.33143>:
        monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "aot-compiler.c", 2615, "info->alloc_type != -1");
        <D.33144>:
        D.33139 = info->alloc_type;
        p.191 = p;
        encode_value (D.33139, p.191, &p);
        goto <D.26548>;
      }
      <D.26559>:
      goto <D.26548>;
      <D.26560>:
      {
        struct WrapperInfo * info;

        info = mono_marshal_get_wrapper_info (method);
        D.33145 = info == 0B;
        D.33146 = (long int) D.33145;
        D.33147 = __builtin_expect (D.33146, 0);
        if (D.33147 != 0) goto <D.33148>; else goto <D.33149>;
        <D.33148>:
        monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "aot-compiler.c", 2624, "info");
        <D.33149>:
        D.33150 = info->subtype;
        D.33151 = (int) D.33150;
        p.191 = p;
        encode_value (D.33151, p.191, &p);
        D.33150 = info->subtype;
        if (D.33150 == 3) goto <D.33152>; else goto <D.33153>;
        <D.33152>:
        D.33154 = info->d.virtual_stelemref.kind;
        p.191 = p;
        encode_value (D.33154, p.191, &p);
        <D.33153>:
        goto <D.26548>;
      }
      <D.26562>:
      {
        struct WrapperInfo * info;

        info = mono_marshal_get_wrapper_info (method);
        D.33155 = info == 0B;
        D.33156 = (long int) D.33155;
        D.33157 = __builtin_expect (D.33156, 0);
        if (D.33157 != 0) goto <D.33158>; else goto <D.33159>;
        <D.33158>:
        monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "aot-compiler.c", 2633, "info");
        <D.33159>:
        D.33160 = info->subtype;
        D.33161 = (int) D.33160;
        p.191 = p;
        encode_value (D.33161, p.191, &p);
        D.33160 = info->subtype;
        D.33162 = D.33160 + 4294967289;
        if (D.33162 <= 1) goto <D.33163>; else goto <D.33164>;
        <D.33163>:
        D.33112 = method->klass;
        p.191 = p;
        encode_klass_ref (acfg, D.33112, p.191, &p);
        goto <D.33165>;
        <D.33164>:
        D.33160 = info->subtype;
        if (D.33160 == 17) goto <D.33166>; else goto <D.33167>;
        <D.33166>:
        D.33168 = info->d.synchronized_inner.method;
        p.191 = p;
        encode_method_ref (acfg, D.33168, p.191, &p);
        goto <D.33169>;
        <D.33167>:
        D.33160 = info->subtype;
        if (D.33160 == 20) goto <D.33170>; else goto <D.33171>;
        <D.33170>:
        D.33172 = info->d.array_accessor.method;
        p.191 = p;
        encode_method_ref (acfg, D.33172, p.191, &p);
        <D.33171>:
        <D.33169>:
        <D.33165>:
        goto <D.26548>;
      }
      <D.26564>:
      {
        struct WrapperInfo * info;

        info = mono_marshal_get_wrapper_info (method);
        D.33173 = info == 0B;
        D.33174 = (long int) D.33173;
        D.33175 = __builtin_expect (D.33174, 0);
        if (D.33175 != 0) goto <D.33176>; else goto <D.33177>;
        <D.33176>:
        monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "aot-compiler.c", 2647, "info");
        <D.33177>:
        D.33178 = info->subtype;
        D.33179 = (int) D.33178;
        p.191 = p;
        encode_value (D.33179, p.191, &p);
        D.33178 = info->subtype;
        if (D.33178 == 15) goto <D.33180>; else goto <D.33181>;
        <D.33180>:
        p.191 = p;
        D.33182 = method->name;
        strcpy (p.191, D.33182);
        p.191 = p;
        D.33182 = method->name;
        D.33183 = strlen (D.33182);
        D.33184 = D.33183 + 1;
        p.192 = p.191 + D.33184;
        p = p.192;
        goto <D.33186>;
        <D.33181>:
        D.33178 = info->subtype;
        if (D.33178 == 16) goto <D.33187>; else goto <D.33188>;
        <D.33187>:
        D.33189 = info->d.managed_to_native.method;
        p.191 = p;
        encode_method_ref (acfg, D.33189, p.191, &p);
        goto <D.33190>;
        <D.33188>:
        D.33178 = info->subtype;
        D.33191 = D.33178 != 0;
        D.33192 = (long int) D.33191;
        D.33193 = __builtin_expect (D.33192, 0);
        if (D.33193 != 0) goto <D.33194>; else goto <D.33195>;
        <D.33194>:
        monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "aot-compiler.c", 2655, "info->subtype == WRAPPER_SUBTYPE_NONE");
        <D.33195>:
        D.33189 = info->d.managed_to_native.method;
        p.191 = p;
        encode_method_ref (acfg, D.33189, p.191, &p);
        <D.33190>:
        <D.33186>:
        goto <D.26548>;
      }
      <D.26566>:
      {
        struct MonoMethod * m;

        m = mono_marshal_method_from_wrapper (method);
        D.33196 = m == 0B;
        D.33197 = (long int) D.33196;
        D.33198 = __builtin_expect (D.33197, 0);
        if (D.33198 != 0) goto <D.33199>; else goto <D.33200>;
        <D.33199>:
        monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "aot-compiler.c", 2664, "m");
        <D.33200>:
        D.33201 = m == method;
        D.33202 = (long int) D.33201;
        D.33203 = __builtin_expect (D.33202, 0);
        if (D.33203 != 0) goto <D.33204>; else goto <D.33205>;
        <D.33204>:
        monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "aot-compiler.c", 2665, "m != method");
        <D.33205>:
        p.191 = p;
        encode_method_ref (acfg, m, p.191, &p);
        goto <D.26548>;
      }
      <D.26568>:
      {
        struct WrapperInfo * info;

        info = mono_marshal_get_wrapper_info (method);
        D.33206 = info == 0B;
        D.33207 = (long int) D.33206;
        D.33208 = __builtin_expect (D.33207, 0);
        if (D.33208 != 0) goto <D.33209>; else goto <D.33210>;
        <D.33209>:
        monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "aot-compiler.c", 2672, "info");
        <D.33210>:
        D.33211 = info->subtype;
        D.33212 = (int) D.33211;
        p.191 = p;
        encode_value (D.33212, p.191, &p);
        D.33211 = info->subtype;
        if (D.33211 == 1) goto <D.33213>; else goto <D.33214>;
        <D.33213>:
        D.33215 = info->d.element_addr.rank;
        D.33216 = (int) D.33215;
        p.191 = p;
        encode_value (D.33216, p.191, &p);
        D.33217 = info->d.element_addr.elem_size;
        D.33218 = (int) D.33217;
        p.191 = p;
        encode_value (D.33218, p.191, &p);
        goto <D.33219>;
        <D.33214>:
        D.33211 = info->subtype;
        if (D.33211 == 2) goto <D.33220>; else goto <D.33221>;
        <D.33220>:
        D.33222 = info->d.string_ctor.method;
        p.191 = p;
        encode_method_ref (acfg, D.33222, p.191, &p);
        goto <D.33223>;
        <D.33221>:
        monoeg_assertion_message ("* Assertion: should not be reached at %s:%d\n", "aot-compiler.c", 2681);
        <D.33223>:
        <D.33219>:
        goto <D.26548>;
      }
      <D.26570>:
      {
        struct WrapperInfo * info;

        info = mono_marshal_get_wrapper_info (method);
        D.33224 = info == 0B;
        D.33225 = (long int) D.33224;
        D.33226 = __builtin_expect (D.33225, 0);
        if (D.33226 != 0) goto <D.33227>; else goto <D.33228>;
        <D.33227>:
        monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "aot-compiler.c", 2688, "info");
        <D.33228>:
        D.33229 = info->subtype;
        D.33230 = (int) D.33229;
        p.191 = p;
        encode_value (D.33230, p.191, &p);
        goto <D.26548>;
      }
      <D.26572>:
      {
        struct WrapperInfo * info;

        info = mono_marshal_get_wrapper_info (method);
        D.33231 = info == 0B;
        D.33232 = (long int) D.33231;
        D.33233 = __builtin_expect (D.33232, 0);
        if (D.33233 != 0) goto <D.33234>; else goto <D.33235>;
        <D.33234>:
        monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "aot-compiler.c", 2695, "info");
        <D.33235>:
        D.33236 = info->subtype;
        D.33237 = (int) D.33236;
        p.191 = p;
        encode_value (D.33237, p.191, &p);
        D.33236 = info->subtype;
        D.33238 = D.33236 + 4294967283;
        if (D.33238 <= 1) goto <D.33239>; else goto <D.33240>;
        <D.33239>:
        D.33241 = info->d.runtime_invoke.method;
        p.191 = p;
        encode_method_ref (acfg, D.33241, p.191, &p);
        goto <D.33242>;
        <D.33240>:
        D.33236 = info->subtype;
        if (D.33236 == 11) goto <D.33243>; else goto <D.33244>;
        <D.33243>:
        D.33245 = info->d.runtime_invoke.sig;
        p.191 = p;
        encode_signature (acfg, D.33245, p.191, &p);
        <D.33244>:
        <D.33242>:
        goto <D.26548>;
      }
      <D.26574>:
      <D.26575>:
      <D.26576>:
      D.33117 = BIT_FIELD_REF <*method, 8, 168>;
      D.33246 = D.33117 & 16;
      if (D.33246 != 0) goto <D.33247>; else goto <D.33248>;
      <D.33247>:
      p.191 = p;
      encode_value (1, p.191, &p);
      D.33112 = method->klass;
      p.191 = p;
      encode_klass_ref (acfg, D.33112, p.191, &p);
      goto <D.33249>;
      <D.33248>:
      {
        struct MonoMethodSignature * sig;
        struct WrapperInfo * info;

        sig = mono_method_signature (method);
        info = mono_marshal_get_wrapper_info (method);
        p.191 = p;
        encode_value (0, p.191, &p);
        D.33127 = BIT_FIELD_REF <*method, 8, 160>;
        D.33128 = D.33127 & 124;
        if (D.33128 == 4) goto <D.33250>; else goto <D.33251>;
        <D.33250>:
        if (info != 0B) goto <D.33253>; else goto <D.33254>;
        <D.33253>:
        D.33255 = info->subtype;
        iftmp.193 = (gint32) D.33255;
        goto <D.33256>;
        <D.33254>:
        iftmp.193 = 0;
        <D.33256>:
        p.191 = p;
        encode_value (iftmp.193, p.191, &p);
        <D.33251>:
        p.191 = p;
        encode_signature (acfg, sig, p.191, &p);
      }
      <D.33249>:
      goto <D.26548>;
      <D.26579>:
      {
        struct WrapperInfo * info;

        info = mono_marshal_get_wrapper_info (method);
        D.33257 = info == 0B;
        D.33258 = (long int) D.33257;
        D.33259 = __builtin_expect (D.33258, 0);
        if (D.33259 != 0) goto <D.33260>; else goto <D.33261>;
        <D.33260>:
        monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "aot-compiler.c", 2724, "info");
        <D.33261>:
        D.33262 = info->d.native_to_managed.method;
        p.191 = p;
        encode_method_ref (acfg, D.33262, p.191, &p);
        D.33263 = info->d.native_to_managed.klass;
        p.191 = p;
        encode_klass_ref (acfg, D.33263, p.191, &p);
        goto <D.26548>;
      }
      <D.26581>:
      monoeg_assertion_message ("* Assertion: should not be reached at %s:%d\n", "aot-compiler.c", 2730);
      <D.26548>:
      goto <D.33264>;
      <D.33130>:
      D.33265 = mono_method_signature (method);
      D.33266 = BIT_FIELD_REF <*D.33265, 8, 88>;
      D.33267 = D.33266 & 2;
      if (D.33267 != 0) goto <D.33268>; else goto <D.33269>;
      <D.33268>:
      D.33270 = acfg->token_info_hash;
      ji = monoeg_g_hash_table_lookup (D.33270, method);
      if (ji != 0B) goto <D.33271>; else goto <D.33272>;
      <D.33271>:
      D.33273 = ji->image;
      image_index = get_image_index (acfg, D.33273);
      D.33274 = image_index > 249;
      D.33275 = (long int) D.33274;
      D.33276 = __builtin_expect (D.33275, 0);
      if (D.33276 != 0) goto <D.33277>; else goto <D.33278>;
      <D.33277>:
      monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "aot-compiler.c", 2741, "image_index < MAX_IMAGE_INDEX");
      <D.33278>:
      token = ji->token;
      p.191 = p;
      encode_value (-33554432, p.191, &p);
      image_index.194 = (int) image_index;
      p.191 = p;
      encode_value (image_index.194, p.191, &p);
      token.195 = (int) token;
      p.191 = p;
      encode_value (token.195, p.191, &p);
      goto <D.33281>;
      <D.33272>:
      {
        struct MonoMethod * declaring;
        struct MonoGenericContext * context;

        context = mono_method_get_context (method);
        D.33117 = BIT_FIELD_REF <*method, 8, 168>;
        D.33246 = D.33117 & 16;
        D.33282 = D.33246 == 0;
        D.33283 = (long int) D.33282;
        D.33284 = __builtin_expect (D.33283, 0);
        if (D.33284 != 0) goto <D.33285>; else goto <D.33286>;
        <D.33285>:
        monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "aot-compiler.c", 2751, "method->is_inflated");
        <D.33286>:
        declaring = MEM[(struct MonoMethodInflated *)method].declaring;
        p.191 = p;
        encode_value (-50331648, p.191, &p);
        D.33112 = method->klass;
        p.191 = p;
        encode_klass_ref (acfg, D.33112, p.191, &p);
        D.33112 = method->klass;
        D.33113 = D.33112->image;
        image_index = get_image_index (acfg, D.33113);
        D.33274 = image_index > 249;
        D.33275 = (long int) D.33274;
        D.33276 = __builtin_expect (D.33275, 0);
        if (D.33276 != 0) goto <D.33287>; else goto <D.33288>;
        <D.33287>:
        monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "aot-compiler.c", 2764, "image_index < MAX_IMAGE_INDEX");
        <D.33288>:
        D.33289 = declaring->token;
        D.33290 = D.33289 == 0;
        D.33291 = (long int) D.33290;
        D.33292 = __builtin_expect (D.33291, 0);
        if (D.33292 != 0) goto <D.33293>; else goto <D.33294>;
        <D.33293>:
        monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "aot-compiler.c", 2765, "declaring->token");
        <D.33294>:
        token = declaring->token;
        D.33295 = token >> 24;
        D.33296 = D.33295 != 6;
        D.33297 = (long int) D.33296;
        D.33298 = __builtin_expect (D.33297, 0);
        if (D.33298 != 0) goto <D.33299>; else goto <D.33300>;
        <D.33299>:
        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.33300>:
        image_index.194 = (int) image_index;
        p.191 = p;
        encode_value (image_index.194, p.191, &p);
        token.195 = (int) token;
        p.191 = p;
        encode_value (token.195, p.191, &p);
        p.191 = p;
        encode_generic_context (acfg, context, p.191, &p);
      }
      <D.33281>:
      goto <D.33301>;
      <D.33269>:
      if (token == 0) goto <D.33302>; else goto <D.33303>;
      <D.33302>:
      D.33270 = acfg->token_info_hash;
      ji = monoeg_g_hash_table_lookup (D.33270, method);
      if (ji != 0B) goto <D.33304>; else goto <D.33305>;
      <D.33304>:
      D.33273 = ji->image;
      image_index = get_image_index (acfg, D.33273);
      D.33274 = image_index > 249;
      D.33275 = (long int) D.33274;
      D.33276 = __builtin_expect (D.33275, 0);
      if (D.33276 != 0) goto <D.33306>; else goto <D.33307>;
      <D.33306>:
      monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "aot-compiler.c", 2778, "image_index < MAX_IMAGE_INDEX");
      <D.33307>:
      token = ji->token;
      p.191 = p;
      encode_value (-33554432, p.191, &p);
      image_index.194 = (int) image_index;
      p.191 = p;
      encode_value (image_index.194, p.191, &p);
      token.195 = (int) token;
      p.191 = p;
      encode_value (token.195, p.191, &p);
      goto <D.33308>;
      <D.33305>:
      D.33112 = method->klass;
      D.33309 = D.33112->rank;
      D.33310 = D.33309 == 0;
      D.33311 = (long int) D.33310;
      D.33312 = __builtin_expect (D.33311, 0);
      if (D.33312 != 0) goto <D.33313>; else goto <D.33314>;
      <D.33313>:
      monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "aot-compiler.c", 2786, "method->klass->rank");
      <D.33314>:
      p.191 = p;
      encode_value (-100663296, p.191, &p);
      D.33112 = method->klass;
      p.191 = p;
      encode_klass_ref (acfg, D.33112, p.191, &p);
      {
        size_t __s1_len;
        size_t __s2_len;

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

          __s2 = method->name;
          D.33320 = ".ctor";
          D.33321 = MEM[(const unsigned char *)D.33320];
          D.33322 = (int) D.33321;
          D.33323 = *__s2;
          D.33324 = (int) D.33323;
          __result = D.33322 - D.33324;
          {
            D.33325 = __s2_len != 0;
            D.33326 = __result == 0;
            D.33327 = D.33325 & D.33326;
            if (D.33327 != 0) goto <D.33328>; else goto <D.33329>;
            <D.33328>:
            D.33330 = &MEM[(void *)".ctor" + 1B];
            D.33331 = *D.33330;
            D.33332 = (int) D.33331;
            D.33333 = __s2 + 1;
            D.33334 = *D.33333;
            D.33335 = (int) D.33334;
            __result = D.33332 - D.33335;
            D.33336 = __s2_len > 1;
            D.33326 = __result == 0;
            D.33337 = D.33336 & D.33326;
            if (D.33337 != 0) goto <D.33338>; else goto <D.33339>;
            <D.33338>:
            D.33340 = &MEM[(void *)".ctor" + 2B];
            D.33341 = *D.33340;
            D.33342 = (int) D.33341;
            D.33343 = __s2 + 2;
            D.33344 = *D.33343;
            D.33345 = (int) D.33344;
            __result = D.33342 - D.33345;
            D.33346 = __s2_len > 2;
            D.33326 = __result == 0;
            D.33347 = D.33346 & D.33326;
            if (D.33347 != 0) goto <D.33348>; else goto <D.33349>;
            <D.33348>:
            D.33350 = &MEM[(void *)".ctor" + 3B];
            D.33351 = *D.33350;
            D.33352 = (int) D.33351;
            D.33353 = __s2 + 3;
            D.33354 = *D.33353;
            D.33355 = (int) D.33354;
            __result = D.33352 - D.33355;
            <D.33349>:
            <D.33339>:
            <D.33329>:
          }
          D.26591 = __result;
        }
        iftmp.196 = -D.26591;
        goto <D.33356>;
        <D.33319>:
        D.33182 = method->name;
        iftmp.196 = __builtin_strcmp (D.33182, ".ctor");
        <D.33356>:
        D.26592 = iftmp.196;
      }
      if (D.26592 == 0) goto <D.33357>; else goto <D.33315>;
      <D.33357>:
      D.33358 = mono_method_signature (method);
      D.33359 = D.33358->param_count;
      D.33112 = method->klass;
      D.33309 = D.33112->rank;
      D.33360 = (short unsigned int) D.33309;
      if (D.33359 == D.33360) goto <D.33361>; else goto <D.33315>;
      <D.33361>:
      p.191 = p;
      encode_value (0, p.191, &p);
      goto <D.33316>;
      <D.33315>:
      {
        size_t __s1_len;
        size_t __s2_len;

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

          __s2 = method->name;
          D.33320 = ".ctor";
          D.33321 = MEM[(const unsigned char *)D.33320];
          D.33322 = (int) D.33321;
          D.33367 = *__s2;
          D.33368 = (int) D.33367;
          __result = D.33322 - D.33368;
          {
            D.33369 = __s2_len != 0;
            D.33370 = __result == 0;
            D.33371 = D.33369 & D.33370;
            if (D.33371 != 0) goto <D.33372>; else goto <D.33373>;
            <D.33372>:
            D.33330 = &MEM[(void *)".ctor" + 1B];
            D.33331 = *D.33330;
            D.33332 = (int) D.33331;
            D.33374 = __s2 + 1;
            D.33375 = *D.33374;
            D.33376 = (int) D.33375;
            __result = D.33332 - D.33376;
            D.33377 = __s2_len > 1;
            D.33370 = __result == 0;
            D.33378 = D.33377 & D.33370;
            if (D.33378 != 0) goto <D.33379>; else goto <D.33380>;
            <D.33379>:
            D.33340 = &MEM[(void *)".ctor" + 2B];
            D.33341 = *D.33340;
            D.33342 = (int) D.33341;
            D.33381 = __s2 + 2;
            D.33382 = *D.33381;
            D.33383 = (int) D.33382;
            __result = D.33342 - D.33383;
            D.33384 = __s2_len > 2;
            D.33370 = __result == 0;
            D.33385 = D.33384 & D.33370;
            if (D.33385 != 0) goto <D.33386>; else goto <D.33387>;
            <D.33386>:
            D.33350 = &MEM[(void *)".ctor" + 3B];
            D.33351 = *D.33350;
            D.33352 = (int) D.33351;
            D.33388 = __s2 + 3;
            D.33389 = *D.33388;
            D.33390 = (int) D.33389;
            __result = D.33352 - D.33390;
            <D.33387>:
            <D.33380>:
            <D.33373>:
          }
          D.26600 = __result;
        }
        iftmp.197 = -D.26600;
        goto <D.33391>;
        <D.33366>:
        D.33182 = method->name;
        iftmp.197 = __builtin_strcmp (D.33182, ".ctor");
        <D.33391>:
        D.26601 = iftmp.197;
      }
      if (D.26601 == 0) goto <D.33392>; else goto <D.33362>;
      <D.33392>:
      D.33393 = mono_method_signature (method);
      D.33394 = D.33393->param_count;
      D.33395 = (int) D.33394;
      D.33112 = method->klass;
      D.33309 = D.33112->rank;
      D.33396 = (int) D.33309;
      D.33397 = D.33396 * 2;
      if (D.33395 == D.33397) goto <D.33398>; else goto <D.33362>;
      <D.33398>:
      p.191 = p;
      encode_value (1, p.191, &p);
      goto <D.33363>;
      <D.33362>:
      {
        size_t __s1_len;
        size_t __s2_len;

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

          __s2 = method->name;
          D.33402 = "Get";
          D.33403 = MEM[(const unsigned char *)D.33402];
          D.33404 = (int) D.33403;
          D.33405 = *__s2;
          D.33406 = (int) D.33405;
          __result = D.33404 - D.33406;
          {
            D.33407 = __s2_len != 0;
            D.33408 = __result == 0;
            D.33409 = D.33407 & D.33408;
            if (D.33409 != 0) goto <D.33410>; else goto <D.33411>;
            <D.33410>:
            D.33412 = &MEM[(void *)"Get" + 1B];
            D.33413 = *D.33412;
            D.33414 = (int) D.33413;
            D.33415 = __s2 + 1;
            D.33416 = *D.33415;
            D.33417 = (int) D.33416;
            __result = D.33414 - D.33417;
            D.33418 = __s2_len > 1;
            D.33408 = __result == 0;
            D.33419 = D.33418 & D.33408;
            if (D.33419 != 0) goto <D.33420>; else goto <D.33421>;
            <D.33420>:
            D.33422 = &MEM[(void *)"Get" + 2B];
            D.33423 = *D.33422;
            D.33424 = (int) D.33423;
            D.33425 = __s2 + 2;
            D.33426 = *D.33425;
            D.33427 = (int) D.33426;
            __result = D.33424 - D.33427;
            D.33428 = __s2_len > 2;
            D.33408 = __result == 0;
            D.33429 = D.33428 & D.33408;
            if (D.33429 != 0) goto <D.33430>; else goto <D.33431>;
            <D.33430>:
            D.33432 = &MEM[(void *)"Get" + 3B];
            D.33433 = *D.33432;
            D.33434 = (int) D.33433;
            D.33435 = __s2 + 3;
            D.33436 = *D.33435;
            D.33437 = (int) D.33436;
            __result = D.33434 - D.33437;
            <D.33431>:
            <D.33421>:
            <D.33411>:
          }
          D.26609 = __result;
        }
        iftmp.198 = -D.26609;
        goto <D.33438>;
        <D.33401>:
        D.33182 = method->name;
        iftmp.198 = __builtin_strcmp (D.33182, "Get");
        <D.33438>:
        D.26610 = iftmp.198;
      }
      if (D.26610 == 0) goto <D.33439>; else goto <D.33440>;
      <D.33439>:
      p.191 = p;
      encode_value (2, p.191, &p);
      goto <D.33441>;
      <D.33440>:
      {
        size_t __s1_len;
        size_t __s2_len;

        __s2_len = 7;
        if (__s2_len <= 3) goto <D.33443>; else goto <D.33444>;
        <D.33443>:
        {
          const unsigned char * __s2;
          int __result;

          __s2 = method->name;
          D.33445 = "Address";
          D.33446 = MEM[(const unsigned char *)D.33445];
          D.33447 = (int) D.33446;
          D.33448 = *__s2;
          D.33449 = (int) D.33448;
          __result = D.33447 - D.33449;
          {
            D.33450 = __s2_len != 0;
            D.33451 = __result == 0;
            D.33452 = D.33450 & D.33451;
            if (D.33452 != 0) goto <D.33453>; else goto <D.33454>;
            <D.33453>:
            D.33455 = &MEM[(void *)"Address" + 1B];
            D.33456 = *D.33455;
            D.33457 = (int) D.33456;
            D.33458 = __s2 + 1;
            D.33459 = *D.33458;
            D.33460 = (int) D.33459;
            __result = D.33457 - D.33460;
            D.33461 = __s2_len > 1;
            D.33451 = __result == 0;
            D.33462 = D.33461 & D.33451;
            if (D.33462 != 0) goto <D.33463>; else goto <D.33464>;
            <D.33463>:
            D.33465 = &MEM[(void *)"Address" + 2B];
            D.33466 = *D.33465;
            D.33467 = (int) D.33466;
            D.33468 = __s2 + 2;
            D.33469 = *D.33468;
            D.33470 = (int) D.33469;
            __result = D.33467 - D.33470;
            D.33471 = __s2_len > 2;
            D.33451 = __result == 0;
            D.33472 = D.33471 & D.33451;
            if (D.33472 != 0) goto <D.33473>; else goto <D.33474>;
            <D.33473>:
            D.33475 = &MEM[(void *)"Address" + 3B];
            D.33476 = *D.33475;
            D.33477 = (int) D.33476;
            D.33478 = __s2 + 3;
            D.33479 = *D.33478;
            D.33480 = (int) D.33479;
            __result = D.33477 - D.33480;
            <D.33474>:
            <D.33464>:
            <D.33454>:
          }
          D.26618 = __result;
        }
        iftmp.199 = -D.26618;
        goto <D.33481>;
        <D.33444>:
        D.33182 = method->name;
        iftmp.199 = __builtin_strcmp (D.33182, "Address");
        <D.33481>:
        D.26619 = iftmp.199;
      }
      if (D.26619 == 0) goto <D.33482>; else goto <D.33483>;
      <D.33482>:
      p.191 = p;
      encode_value (3, p.191, &p);
      goto <D.33484>;
      <D.33483>:
      {
        size_t __s1_len;
        size_t __s2_len;

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

          __s2 = method->name;
          D.33488 = "Set";
          D.33489 = MEM[(const unsigned char *)D.33488];
          D.33490 = (int) D.33489;
          D.33491 = *__s2;
          D.33492 = (int) D.33491;
          __result = D.33490 - D.33492;
          {
            D.33493 = __s2_len != 0;
            D.33494 = __result == 0;
            D.33495 = D.33493 & D.33494;
            if (D.33495 != 0) goto <D.33496>; else goto <D.33497>;
            <D.33496>:
            D.33498 = &MEM[(void *)"Set" + 1B];
            D.33499 = *D.33498;
            D.33500 = (int) D.33499;
            D.33501 = __s2 + 1;
            D.33502 = *D.33501;
            D.33503 = (int) D.33502;
            __result = D.33500 - D.33503;
            D.33504 = __s2_len > 1;
            D.33494 = __result == 0;
            D.33505 = D.33504 & D.33494;
            if (D.33505 != 0) goto <D.33506>; else goto <D.33507>;
            <D.33506>:
            D.33508 = &MEM[(void *)"Set" + 2B];
            D.33509 = *D.33508;
            D.33510 = (int) D.33509;
            D.33511 = __s2 + 2;
            D.33512 = *D.33511;
            D.33513 = (int) D.33512;
            __result = D.33510 - D.33513;
            D.33514 = __s2_len > 2;
            D.33494 = __result == 0;
            D.33515 = D.33514 & D.33494;
            if (D.33515 != 0) goto <D.33516>; else goto <D.33517>;
            <D.33516>:
            D.33518 = &MEM[(void *)"Set" + 3B];
            D.33519 = *D.33518;
            D.33520 = (int) D.33519;
            D.33521 = __s2 + 3;
            D.33522 = *D.33521;
            D.33523 = (int) D.33522;
            __result = D.33520 - D.33523;
            <D.33517>:
            <D.33507>:
            <D.33497>:
          }
          D.26627 = __result;
        }
        iftmp.200 = -D.26627;
        goto <D.33524>;
        <D.33487>:
        D.33182 = method->name;
        iftmp.200 = __builtin_strcmp (D.33182, "Set");
        <D.33524>:
        D.26628 = iftmp.200;
      }
      if (D.26628 == 0) goto <D.33525>; else goto <D.33526>;
      <D.33525>:
      p.191 = p;
      encode_value (4, p.191, &p);
      goto <D.33527>;
      <D.33526>:
      monoeg_assertion_message ("* Assertion: should not be reached at %s:%d\n", "aot-compiler.c", 2802);
      <D.33527>:
      <D.33484>:
      <D.33441>:
      <D.33363>:
      <D.33316>:
      <D.33308>:
      goto <D.33528>;
      <D.33303>:
      D.33295 = token >> 24;
      D.33296 = D.33295 != 6;
      D.33297 = (long int) D.33296;
      D.33298 = __builtin_expect (D.33297, 0);
      if (D.33298 != 0) goto <D.33529>; else goto <D.33530>;
      <D.33529>:
      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.33530>:
      if (image_index > 239) goto <D.33531>; else goto <D.33532>;
      <D.33531>:
      p.191 = p;
      encode_value (-117440512, p.191, &p);
      image_index.194 = (int) image_index;
      p.191 = p;
      encode_value (image_index.194, p.191, &p);
      token.195 = (int) token;
      D.33533 = token.195 & 16777215;
      p.191 = p;
      encode_value (D.33533, p.191, &p);
      goto <D.33534>;
      <D.33532>:
      D.33535 = image_index << 24;
      D.33536 = token & 16777215;
      D.33537 = D.33535 | D.33536;
      D.33538 = (int) D.33537;
      p.191 = p;
      encode_value (D.33538, p.191, &p);
      <D.33534>:
      <D.33528>:
      <D.33301>:
      <D.33264>:
      p.191 = p;
      *endbuf = p.191;
    }
  finally
    {
      p = {CLOBBER};
    }
}


encode_signature (struct MonoAotCompile * acfg, struct MonoMethodSignature * sig, guint8 * buf, guint8 * * endbuf)
{
  short unsigned int D.33541;
  unsigned char D.33544;
  unsigned char D.33545;
  unsigned char D.33548;
  <unnamed-unsigned:6> D.33551;
  unsigned int D.33552;
  unsigned int D.33553;
  guint8 * p.201;
  unsigned char D.33555;
  guint8 * p.202;
  int D.33559;
  short unsigned int D.33560;
  int D.33561;
  struct MonoType * D.33562;
  short int D.33563;
  int D.33564;
  struct MonoType * D.33567;
  int D.33568;
  guint8 * p;
  guint32 flags;
  int i;

  try
    {
      p = buf;
      flags = 0;
      D.33541 = sig->generic_param_count;
      if (D.33541 != 0) goto <D.33542>; else goto <D.33543>;
      <D.33542>:
      flags = flags | 16;
      <D.33543>:
      D.33544 = BIT_FIELD_REF <*sig, 8, 80>;
      D.33545 = D.33544 & 64;
      if (D.33545 != 0) goto <D.33546>; else goto <D.33547>;
      <D.33546>:
      flags = flags | 32;
      <D.33547>:
      D.33544 = BIT_FIELD_REF <*sig, 8, 80>;
      D.33548 = D.33544 & 128;
      if (D.33548 != 0) goto <D.33549>; else goto <D.33550>;
      <D.33549>:
      flags = flags | 64;
      <D.33550>:
      D.33551 = sig->call_convention;
      D.33552 = (unsigned int) D.33551;
      D.33553 = D.33552 & 15;
      flags = D.33553 | flags;
      p.201 = p;
      D.33555 = (unsigned char) flags;
      *p.201 = D.33555;
      p.201 = p;
      p.202 = p.201 + 1;
      p = p.202;
      D.33541 = sig->generic_param_count;
      if (D.33541 != 0) goto <D.33557>; else goto <D.33558>;
      <D.33557>:
      D.33541 = sig->generic_param_count;
      D.33559 = (int) D.33541;
      p.201 = p;
      encode_value (D.33559, p.201, &p);
      <D.33558>:
      D.33560 = sig->param_count;
      D.33561 = (int) D.33560;
      p.201 = p;
      encode_value (D.33561, p.201, &p);
      D.33562 = sig->ret;
      p.201 = p;
      encode_type (acfg, D.33562, p.201, &p);
      i = 0;
      goto <D.26532>;
      <D.26531>:
      D.33563 = sig->sentinelpos;
      D.33564 = (int) D.33563;
      if (D.33564 == i) goto <D.33565>; else goto <D.33566>;
      <D.33565>:
      p.201 = p;
      *p.201 = 65;
      p.201 = p;
      p.202 = p.201 + 1;
      p = p.202;
      <D.33566>:
      D.33567 = sig->params[i];
      p.201 = p;
      encode_type (acfg, D.33567, p.201, &p);
      i = i + 1;
      <D.26532>:
      D.33560 = sig->param_count;
      D.33568 = (int) D.33560;
      if (D.33568 > i) goto <D.26531>; else goto <D.26533>;
      <D.26533>:
      p.201 = p;
      *endbuf = p.201;
    }
  finally
    {
      p = {CLOBBER};
    }
}


encode_generic_context (struct MonoAotCompile * acfg, struct MonoGenericContext * context, guint8 * buf, guint8 * * endbuf)
{
  unsigned int D.33571;
  unsigned int D.33572;
  _Bool D.33573;
  long int D.33574;
  long int D.33575;
  guint8 * p.203;
  guint8 * p;
  struct MonoGenericInst * inst;

  try
    {
      p = buf;
      inst = context->class_inst;
      if (inst != 0B) goto <D.33569>; else goto <D.33570>;
      <D.33569>:
      D.33571 = BIT_FIELD_REF <*inst, 32, 32>;
      D.33572 = D.33571 & 4194303;
      D.33573 = D.33572 == 0;
      D.33574 = (long int) D.33573;
      D.33575 = __builtin_expect (D.33574, 0);
      if (D.33575 != 0) goto <D.33576>; else goto <D.33577>;
      <D.33576>:
      monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "aot-compiler.c", 2425, "inst->type_argc");
      <D.33577>:
      p.203 = p;
      encode_ginst (acfg, inst, p.203, &p);
      goto <D.33579>;
      <D.33570>:
      p.203 = p;
      encode_value (0, p.203, &p);
      <D.33579>:
      inst = context->method_inst;
      if (inst != 0B) goto <D.33580>; else goto <D.33581>;
      <D.33580>:
      D.33571 = BIT_FIELD_REF <*inst, 32, 32>;
      D.33572 = D.33571 & 4194303;
      D.33573 = D.33572 == 0;
      D.33574 = (long int) D.33573;
      D.33575 = __builtin_expect (D.33574, 0);
      if (D.33575 != 0) goto <D.33582>; else goto <D.33583>;
      <D.33582>:
      monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "aot-compiler.c", 2432, "inst->type_argc");
      <D.33583>:
      p.203 = p;
      encode_ginst (acfg, inst, p.203, &p);
      goto <D.33584>;
      <D.33581>:
      p.203 = p;
      encode_value (0, p.203, &p);
      <D.33584>:
      p.203 = p;
      *endbuf = p.203;
    }
  finally
    {
      p = {CLOBBER};
    }
}


encode_type (struct MonoAotCompile * acfg, struct MonoType * t, guint8 * buf, guint8 * * endbuf)
{
  unsigned char D.33585;
  unsigned char D.33586;
  _Bool D.33587;
  long int D.33588;
  long int D.33589;
  unsigned char D.33592;
  guint8 * p.204;
  guint8 * p.205;
  unsigned char D.33597;
  unsigned char D.33600;
  int D.33601;
  struct MonoClass * D.33602;
  struct MonoClass * D.33603;
  struct MonoType * D.33604;
  struct MonoGenericClass * D.33605;
  struct MonoClass * D.33606;
  unsigned char D.33607;
  int D.33608;
  unsigned char D.33609;
  int D.33610;
  int * D.33611;
  unsigned int i.206;
  unsigned int D.33613;
  int * D.33614;
  int D.33615;
  int D.33616;
  unsigned char D.33617;
  int D.33618;
  int * D.33619;
  int * D.33620;
  int D.33621;
  int D.33622;
  struct MonoClass * D.33623;
  guint8 * p;

  try
    {
      p = buf;
      D.33585 = BIT_FIELD_REF <*t, 8, 56>;
      D.33586 = D.33585 & 63;
      D.33587 = D.33586 != 0;
      D.33588 = (long int) D.33587;
      D.33589 = __builtin_expect (D.33588, 0);
      if (D.33589 != 0) goto <D.33590>; else goto <D.33591>;
      <D.33590>:
      monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "aot-compiler.c", 2445, "t->num_mods == 0");
      <D.33591>:
      D.33585 = BIT_FIELD_REF <*t, 8, 56>;
      D.33592 = D.33585 & 128;
      if (D.33592 != 0) goto <D.33593>; else goto <D.33594>;
      <D.33593>:
      p.204 = p;
      *p.204 = 69;
      p.204 = p;
      p.205 = p.204 + 1;
      p = p.205;
      <D.33594>:
      D.33585 = BIT_FIELD_REF <*t, 8, 56>;
      D.33597 = D.33585 & 64;
      if (D.33597 != 0) goto <D.33598>; else goto <D.33599>;
      <D.33598>:
      p.204 = p;
      *p.204 = 16;
      p.204 = p;
      p.205 = p.204 + 1;
      p = p.205;
      <D.33599>:
      p.204 = p;
      D.33600 = t->type;
      *p.204 = D.33600;
      p.204 = p;
      p.205 = p.204 + 1;
      p = p.205;
      D.33600 = t->type;
      D.33601 = (int) D.33600;
      switch (D.33601) <default: <D.26521>, case 1: <D.26484>, case 2: <D.26485>, case 3: <D.26486>, case 4: <D.26487>, case 5: <D.26488>, case 6: <D.26489>, case 7: <D.26490>, case 8: <D.26491>, case 9: <D.26492>, case 10: <D.26493>, case 11: <D.26494>, case 12: <D.26495>, case 13: <D.26496>, case 14: <D.26499>, case 15: <D.26506>, case 17: <D.26503>, case 18: <D.26504>, case 19: <D.26519>, case 20: <D.26510>, case 21: <D.26507>, case 22: <D.26501>, case 24: <D.26497>, case 25: <D.26498>, case 28: <D.26500>, case 29: <D.26505>, case 30: <D.26520>>
      <D.26484>:
      <D.26485>:
      <D.26486>:
      <D.26487>:
      <D.26488>:
      <D.26489>:
      <D.26490>:
      <D.26491>:
      <D.26492>:
      <D.26493>:
      <D.26494>:
      <D.26495>:
      <D.26496>:
      <D.26497>:
      <D.26498>:
      <D.26499>:
      <D.26500>:
      <D.26501>:
      goto <D.26502>;
      <D.26503>:
      <D.26504>:
      D.33602 = mono_class_from_mono_type (t);
      p.204 = p;
      encode_klass_ref (acfg, D.33602, p.204, &p);
      goto <D.26502>;
      <D.26505>:
      D.33603 = t->data.klass;
      p.204 = p;
      encode_klass_ref (acfg, D.33603, p.204, &p);
      goto <D.26502>;
      <D.26506>:
      D.33604 = t->data.type;
      p.204 = p;
      encode_type (acfg, D.33604, p.204, &p);
      goto <D.26502>;
      <D.26507>:
      {
        struct MonoClass * gclass;
        struct MonoGenericInst * inst;

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

        array = t->data.array;
        D.33606 = array->eklass;
        p.204 = p;
        encode_klass_ref (acfg, D.33606, p.204, &p);
        D.33607 = array->rank;
        D.33608 = (int) D.33607;
        p.204 = p;
        encode_value (D.33608, p.204, &p);
        D.33609 = array->numsizes;
        D.33610 = (int) D.33609;
        p.204 = p;
        encode_value (D.33610, p.204, &p);
        i = 0;
        goto <D.26514>;
        <D.26513>:
        D.33611 = array->sizes;
        i.206 = (unsigned int) i;
        D.33613 = i.206 * 4;
        D.33614 = D.33611 + D.33613;
        D.33615 = *D.33614;
        p.204 = p;
        encode_value (D.33615, p.204, &p);
        i = i + 1;
        <D.26514>:
        D.33609 = array->numsizes;
        D.33616 = (int) D.33609;
        if (D.33616 > i) goto <D.26513>; else goto <D.26515>;
        <D.26515>:
        D.33617 = array->numlobounds;
        D.33618 = (int) D.33617;
        p.204 = p;
        encode_value (D.33618, p.204, &p);
        i = 0;
        goto <D.26517>;
        <D.26516>:
        D.33619 = array->lobounds;
        i.206 = (unsigned int) i;
        D.33613 = i.206 * 4;
        D.33620 = D.33619 + D.33613;
        D.33621 = *D.33620;
        p.204 = p;
        encode_value (D.33621, p.204, &p);
        i = i + 1;
        <D.26517>:
        D.33617 = array->numlobounds;
        D.33622 = (int) D.33617;
        if (D.33622 > i) goto <D.26516>; else goto <D.26518>;
        <D.26518>:
        goto <D.26502>;
      }
      <D.26519>:
      <D.26520>:
      D.33623 = mono_class_from_mono_type (t);
      p.204 = p;
      encode_klass_ref (acfg, D.33623, p.204, &p);
      goto <D.26502>;
      <D.26521>:
      monoeg_assertion_message ("* Assertion: should not be reached at %s:%d\n", "aot-compiler.c", 2518);
      <D.26502>:
      p.204 = p;
      *endbuf = p.204;
    }
  finally
    {
      p = {CLOBBER};
    }
}


encode_value (gint32 value, guint8 * buf, guint8 * * endbuf)
{
  unsigned int value.207;
  guint8 * p.208;
  unsigned char D.33629;
  int D.33633;
  signed char D.33634;
  signed char D.33635;
  unsigned char D.33636;
  guint8 * D.33637;
  unsigned char D.33638;
  int D.33642;
  signed char D.33643;
  signed char D.33644;
  unsigned char D.33645;
  int D.33646;
  unsigned char D.33647;
  guint8 * D.33648;
  unsigned char D.33649;
  guint8 * D.33650;
  unsigned int D.33652;
  unsigned char D.33653;
  guint8 * D.33654;
  guint8 * p;

  p = buf;
  value.207 = (unsigned int) value;
  if (value.207 <= 127) goto <D.33626>; else goto <D.33627>;
  <D.33626>:
  p.208 = p;
  p = p.208 + 1;
  D.33629 = (unsigned char) value;
  *p.208 = D.33629;
  goto <D.33630>;
  <D.33627>:
  value.207 = (unsigned int) value;
  if (value.207 <= 16383) goto <D.33631>; else goto <D.33632>;
  <D.33631>:
  D.33633 = value >> 8;
  D.33634 = (signed char) D.33633;
  D.33635 = D.33634 | -128;
  D.33636 = (unsigned char) D.33635;
  *p = D.33636;
  D.33637 = p + 1;
  D.33638 = (unsigned char) value;
  *D.33637 = D.33638;
  p = p + 2;
  goto <D.33639>;
  <D.33632>:
  value.207 = (unsigned int) value;
  if (value.207 <= 536870911) goto <D.33640>; else goto <D.33641>;
  <D.33640>:
  D.33642 = value >> 24;
  D.33643 = (signed char) D.33642;
  D.33644 = D.33643 | -64;
  D.33645 = (unsigned char) D.33644;
  *p = D.33645;
  D.33637 = p + 1;
  D.33646 = value >> 16;
  D.33647 = (unsigned char) D.33646;
  *D.33637 = D.33647;
  D.33648 = p + 2;
  D.33633 = value >> 8;
  D.33649 = (unsigned char) D.33633;
  *D.33648 = D.33649;
  D.33650 = p + 3;
  D.33638 = (unsigned char) value;
  *D.33650 = D.33638;
  p = p + 4;
  goto <D.33651>;
  <D.33641>:
  *p = 255;
  D.33637 = p + 1;
  value.207 = (unsigned int) value;
  D.33652 = value.207 >> 24;
  D.33653 = (unsigned char) D.33652;
  *D.33637 = D.33653;
  D.33648 = p + 2;
  D.33646 = value >> 16;
  D.33647 = (unsigned char) D.33646;
  *D.33648 = D.33647;
  D.33650 = p + 3;
  D.33633 = value >> 8;
  D.33649 = (unsigned char) D.33633;
  *D.33650 = D.33649;
  D.33654 = p + 4;
  D.33638 = (unsigned char) value;
  *D.33654 = D.33638;
  p = p + 5;
  <D.33651>:
  <D.33639>:
  <D.33630>:
  if (endbuf != 0B) goto <D.33655>; else goto <D.33656>;
  <D.33655>:
  *endbuf = p;
  <D.33656>:
}


encode_patch_list (struct MonoAotCompile * acfg, struct GPtrArray * patches, int n_patches, int first_got_offset, guint8 * buf, guint8 * * endbuf)
{
  guint8 * p.209;
  void * * D.33658;
  unsigned int D.33659;
  void * * D.33660;
  <unnamed type> D.33661;
  _Bool D.33662;
  _Bool D.33663;
  _Bool D.33664;
  int offset.210;
  unsigned int D.33668;
  guint8 * p;
  guint32 pindex;
  guint32 offset;
  struct MonoJumpInfo * patch_info;

  try
    {
      p = buf;
      p.209 = p;
      encode_value (n_patches, p.209, &p);
      pindex = 0;
      goto <D.27570>;
      <D.27569>:
      D.33658 = patches->pdata;
      D.33659 = pindex * 4;
      D.33660 = D.33658 + D.33659;
      patch_info = *D.33660;
      D.33661 = patch_info->type;
      D.33662 = D.33661 == 51;
      D.33663 = D.33661 == 0;
      D.33664 = D.33662 | D.33663;
      if (D.33664 != 0) goto <D.33665>; else goto <D.33666>;
      <D.33665>:
      // predicted unlikely by continue predictor.
      goto <D.27568>;
      <D.33666>:
      offset = get_got_offset (acfg, patch_info);
      offset.210 = (int) offset;
      p.209 = p;
      encode_value (offset.210, p.209, &p);
      <D.27568>:
      pindex = pindex + 1;
      <D.27570>:
      D.33668 = patches->len;
      if (D.33668 > pindex) goto <D.27569>; else goto <D.27571>;
      <D.27571>:
      p.209 = p;
      *endbuf = p.209;
    }
  finally
    {
      p = {CLOBBER};
    }
}


add_to_blob (struct MonoAotCompile * acfg, const guint8 * data, guint32 data_len)
{
  unsigned int D.33669;
  struct MonoDynamicStream * D.33672;
  guint32 D.33673;

  D.33669 = acfg->blob.alloc_size;
  if (D.33669 == 0) goto <D.33670>; else goto <D.33671>;
  <D.33670>:
  D.33672 = &acfg->blob;
  stream_init (D.33672);
  <D.33671>:
  D.33672 = &acfg->blob;
  D.33673 = add_stream_data (D.33672, data, data_len);
  return D.33673;
}


stream_init (struct MonoDynamicStream * sh)
{
  void * D.33675;
  char * D.33676;
  unsigned int D.33677;
  unsigned int D.33678;

  sh->index = 0;
  sh->alloc_size = 4096;
  D.33675 = monoeg_malloc (4096);
  sh->data = D.33675;
  D.33676 = sh->data;
  *D.33676 = 0;
  D.33677 = sh->index;
  D.33678 = D.33677 + 1;
  sh->index = D.33678;
}


add_stream_data (struct MonoDynamicStream * stream, const char * data, guint32 len)
{
  unsigned int D.33679;
  unsigned int D.33680;
  int D.33681;
  char * D.33682;
  char * D.33683;
  guint32 D.33684;
  guint32 idx;

  D.33679 = stream->index;
  D.33680 = D.33679 + len;
  D.33681 = (int) D.33680;
  make_room_in_stream (stream, D.33681);
  D.33682 = stream->data;
  D.33679 = stream->index;
  D.33683 = D.33682 + D.33679;
  memcpy (D.33683, data, len);
  idx = stream->index;
  D.33679 = stream->index;
  D.33680 = D.33679 + len;
  stream->index = D.33680;
  D.33684 = idx;
  return D.33684;
}


make_room_in_stream (struct MonoDynamicStream * stream, int size)
{
  unsigned int size.211;
  unsigned int D.33687;
  unsigned int D.33693;
  char * D.33694;
  void * D.33695;

  size.211 = (unsigned int) size;
  D.33687 = stream->alloc_size;
  if (size.211 <= D.33687) goto <D.33688>; else goto <D.33689>;
  <D.33688>:
  return;
  <D.33689>:
  goto <D.26346>;
  <D.26345>:
  D.33687 = stream->alloc_size;
  if (D.33687 <= 4095) goto <D.33690>; else goto <D.33691>;
  <D.33690>:
  stream->alloc_size = 4096;
  goto <D.33692>;
  <D.33691>:
  D.33687 = stream->alloc_size;
  D.33693 = D.33687 * 2;
  stream->alloc_size = D.33693;
  <D.33692>:
  <D.26346>:
  D.33687 = stream->alloc_size;
  size.211 = (unsigned int) size;
  if (D.33687 <= size.211) goto <D.26345>; else goto <D.26347>;
  <D.26347>:
  D.33694 = stream->data;
  D.33687 = stream->alloc_size;
  D.33695 = monoeg_realloc (D.33694, D.33687);
  stream->data = D.33695;
}


emit_offset_table (struct MonoAotCompile * acfg, int noffsets, int group_size, gint32 * offsets)
{
  int D.33697;
  int D.33698;
  unsigned int ngroups.212;
  unsigned int D.33700;
  unsigned int buf_size.213;
  int D.33702;
  int D.33705;
  unsigned int D.33706;
  unsigned int D.33707;
  guint32 * D.33708;
  guint8 * p.214;
  int p.215;
  int buf.216;
  int D.33712;
  unsigned int D.33713;
  unsigned int i.217;
  unsigned int D.33715;
  gint32 * D.33716;
  int D.33717;
  int D.33719;
  sizetype ngroups.218;
  sizetype D.33724;
  sizetype D.33725;
  guint32 * D.33726;
  unsigned int D.33727;
  guint32 * D.33731;
  unsigned int D.33732;
  int D.33733;
  guint32 D.33735;
  int D.33736;
  int D.33737;
  gint32 current_offset;
  int i;
  int buf_size;
  int ngroups;
  int index_entry_size;
  guint8 * p;
  guint8 * buf;
  guint32 * index_offsets;

  try
    {
      D.33697 = group_size + -1;
      D.33698 = D.33697 + noffsets;
      ngroups = D.33698 / group_size;
      ngroups.212 = (unsigned int) ngroups;
      D.33700 = ngroups.212 * 4;
      index_offsets = monoeg_malloc0 (D.33700);
      buf_size = noffsets * 4;
      buf_size.213 = (unsigned int) buf_size;
      buf = monoeg_malloc0 (buf_size.213);
      p = buf;
      current_offset = 0;
      i = 0;
      goto <D.26382>;
      <D.26381>:
      D.33702 = i % group_size;
      if (D.33702 == 0) goto <D.33703>; else goto <D.33704>;
      <D.33703>:
      D.33705 = i / group_size;
      D.33706 = (unsigned int) D.33705;
      D.33707 = D.33706 * 4;
      D.33708 = index_offsets + D.33707;
      p.214 = p;
      p.215 = (int) p.214;
      buf.216 = (int) buf;
      D.33712 = p.215 - buf.216;
      D.33713 = (unsigned int) D.33712;
      *D.33708 = D.33713;
      i.217 = (unsigned int) i;
      D.33715 = i.217 * 4;
      D.33716 = offsets + D.33715;
      D.33717 = *D.33716;
      p.214 = p;
      encode_value (D.33717, p.214, &p);
      goto <D.33718>;
      <D.33704>:
      i.217 = (unsigned int) i;
      D.33715 = i.217 * 4;
      D.33716 = offsets + D.33715;
      D.33717 = *D.33716;
      D.33719 = D.33717 - current_offset;
      p.214 = p;
      encode_value (D.33719, p.214, &p);
      <D.33718>:
      i.217 = (unsigned int) i;
      D.33715 = i.217 * 4;
      D.33716 = offsets + D.33715;
      current_offset = *D.33716;
      i = i + 1;
      <D.26382>:
      if (i < noffsets) goto <D.26381>; else goto <D.26383>;
      <D.26383>:
      if (ngroups != 0) goto <D.33722>; else goto <D.33720>;
      <D.33722>:
      ngroups.218 = (sizetype) ngroups;
      D.33724 = ngroups.218 + 1073741823;
      D.33725 = D.33724 * 4;
      D.33726 = index_offsets + D.33725;
      D.33727 = *D.33726;
      if (D.33727 <= 64999) goto <D.33728>; else goto <D.33720>;
      <D.33728>:
      index_entry_size = 2;
      goto <D.33721>;
      <D.33720>:
      index_entry_size = 4;
      <D.33721>:
      emit_int32 (acfg, noffsets);
      emit_int32 (acfg, group_size);
      emit_int32 (acfg, ngroups);
      emit_int32 (acfg, index_entry_size);
      i = 0;
      goto <D.26385>;
      <D.26384>:
      if (index_entry_size == 2) goto <D.33729>; else goto <D.33730>;
      <D.33729>:
      i.217 = (unsigned int) i;
      D.33715 = i.217 * 4;
      D.33731 = index_offsets + D.33715;
      D.33732 = *D.33731;
      D.33733 = (int) D.33732;
      emit_int16 (acfg, D.33733);
      goto <D.33734>;
      <D.33730>:
      i.217 = (unsigned int) i;
      D.33715 = i.217 * 4;
      D.33731 = index_offsets + D.33715;
      D.33732 = *D.33731;
      D.33733 = (int) D.33732;
      emit_int32 (acfg, D.33733);
      <D.33734>:
      i = i + 1;
      <D.26385>:
      if (i < ngroups) goto <D.26384>; else goto <D.26386>;
      <D.26386>:
      p.214 = p;
      p.215 = (int) p.214;
      buf.216 = (int) buf;
      D.33712 = p.215 - buf.216;
      emit_bytes (acfg, buf, D.33712);
      p.214 = p;
      p.215 = (int) p.214;
      buf.216 = (int) buf;
      D.33712 = p.215 - buf.216;
      D.33736 = ngroups * 4;
      D.33737 = D.33712 + D.33736;
      D.33735 = (guint32) D.33737;
      return D.33735;
    }
  finally
    {
      p = {CLOBBER};
    }
}


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

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


emit_extra_methods (struct MonoAotCompile * acfg)
{
  struct GPtrArray * D.33741;
  unsigned int D.33742;
  unsigned int D.33743;
  void * * D.33744;
  unsigned int i.219;
  unsigned int D.33746;
  void * * D.33747;
  struct GHashTable * D.33748;
  unsigned int buf_size.220;
  guint8 * p.221;
  int p.222;
  int buf.223;
  int D.33755;
  _Bool D.33756;
  long int D.33757;
  long int D.33758;
  guint32 * D.33761;
  unsigned int D.33762;
  unsigned int D.33763;
  unsigned int i.224;
  double D.33765;
  double D.33766;
  int D.33767;
  unsigned int D.33768;
  unsigned int D.33769;
  unsigned int table_size.225;
  unsigned int table_size.226;
  unsigned int D.33772;
  unsigned int D.33775;
  unsigned int table_size.227;
  unsigned int D.33777;
  int * D.33778;
  int D.33779;
  int D.33780;
  struct MonoMemPool * D.33781;
  void * * D.33782;
  void * * D.33783;
  struct HashEntry * D.33787;
  unsigned int D.33788;
  void * * D.33789;
  unsigned int D.33793;
  int D.33794;
  unsigned int D.33795;
  int D.33796;
  struct HashEntry * D.33797;
  unsigned int D.33800;
  int D.33801;
  int D.33803;
  unsigned int D.33804;
  int D.33805;
  unsigned int D.33806;
  int D.33807;
  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.33741 = acfg->extra_methods;
      D.33742 = D.33741->len;
      D.33743 = D.33742 * 4;
      info_offsets = monoeg_malloc0 (D.33743);
      nmethods = 0;
      i = 0;
      goto <D.28283>;
      <D.28282>:
      {
        struct MonoMethod * method;
        struct MonoCompile * cfg;

        D.33741 = acfg->extra_methods;
        D.33744 = D.33741->pdata;
        i.219 = (unsigned int) i;
        D.33746 = i.219 * 4;
        D.33747 = D.33744 + D.33746;
        method = *D.33747;
        D.33748 = acfg->method_to_cfg;
        cfg = monoeg_g_hash_table_lookup (D.33748, method);
        if (cfg == 0B) goto <D.33749>; else goto <D.33750>;
        <D.33749>:
        // predicted unlikely by continue predictor.
        goto <D.28281>;
        <D.33750>:
        buf_size = 10240;
        buf_size.220 = (unsigned int) buf_size;
        buf = monoeg_malloc (buf_size.220);
        p = buf;
        nmethods = nmethods + 1;
        method = cfg->method_to_register;
        p.221 = p;
        encode_method_ref (acfg, method, p.221, &p);
        p.221 = p;
        p.222 = (int) p.221;
        buf.223 = (int) buf;
        D.33755 = p.222 - buf.223;
        D.33756 = D.33755 >= buf_size;
        D.33757 = (long int) D.33756;
        D.33758 = __builtin_expect (D.33757, 0);
        if (D.33758 != 0) goto <D.33759>; else goto <D.33760>;
        <D.33759>:
        monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "aot-compiler.c", 7508, "(p - buf) < buf_size");
        <D.33760>:
        i.219 = (unsigned int) i;
        D.33746 = i.219 * 4;
        D.33761 = info_offsets + D.33746;
        p.221 = p;
        p.222 = (int) p.221;
        buf.223 = (int) buf;
        D.33755 = p.222 - buf.223;
        D.33762 = (unsigned int) D.33755;
        D.33763 = add_to_blob (acfg, buf, D.33762);
        *D.33761 = D.33763;
        monoeg_g_free (buf);
      }
      <D.28281>:
      i = i + 1;
      <D.28283>:
      i.224 = (unsigned int) i;
      D.33741 = acfg->extra_methods;
      D.33742 = D.33741->len;
      if (i.224 < D.33742) goto <D.28282>; else goto <D.28284>;
      <D.28284>:
      D.33765 = (double) nmethods;
      D.33766 = D.33765 * 1.5e+0;
      D.33767 = (int) D.33766;
      D.33768 = (unsigned int) D.33767;
      D.33769 = monoeg_g_spaced_primes_closest (D.33768);
      table_size = (int) D.33769;
      table_size.225 = (unsigned int) table_size;
      table = monoeg_g_ptr_array_sized_new (table_size.225);
      i = 0;
      goto <D.28286>;
      <D.28285>:
      monoeg_g_ptr_array_add (table, 0B);
      i = i + 1;
      <D.28286>:
      if (i < table_size) goto <D.28285>; else goto <D.28287>;
      <D.28287>:
      table_size.226 = (unsigned int) table_size;
      D.33772 = table_size.226 * 4;
      chain_lengths = monoeg_malloc0 (D.33772);
      max_chain_length = 0;
      i = 0;
      goto <D.28297>;
      <D.28296>:
      {
        struct MonoMethod * method;
        struct MonoCompile * cfg;
        guint32 key;
        guint32 value;

        D.33741 = acfg->extra_methods;
        D.33744 = D.33741->pdata;
        i.219 = (unsigned int) i;
        D.33746 = i.219 * 4;
        D.33747 = D.33744 + D.33746;
        method = *D.33747;
        D.33748 = acfg->method_to_cfg;
        cfg = monoeg_g_hash_table_lookup (D.33748, method);
        if (cfg == 0B) goto <D.33773>; else goto <D.33774>;
        <D.33773>:
        // predicted unlikely by continue predictor.
        goto <D.28292>;
        <D.33774>:
        i.219 = (unsigned int) i;
        D.33746 = i.219 * 4;
        D.33761 = info_offsets + D.33746;
        key = *D.33761;
        value = get_method_index (acfg, method);
        D.33775 = mono_aot_method_hash (method);
        table_size.227 = (unsigned int) table_size;
        hash = D.33775 % table_size.227;
        D.33777 = hash * 4;
        D.33778 = chain_lengths + D.33777;
        D.33779 = *D.33778;
        D.33780 = D.33779 + 1;
        *D.33778 = D.33780;
        D.33777 = hash * 4;
        D.33778 = chain_lengths + D.33777;
        D.33779 = *D.33778;
        max_chain_length = MAX_EXPR <D.33779, max_chain_length>;
        D.33781 = acfg->mempool;
        new_entry = mono_mempool_alloc0 (D.33781, 16);
        new_entry->key = key;
        new_entry->value = value;
        D.33782 = table->pdata;
        D.33777 = hash * 4;
        D.33783 = D.33782 + D.33777;
        entry = *D.33783;
        if (entry == 0B) goto <D.33784>; else goto <D.33785>;
        <D.33784>:
        new_entry->index = hash;
        D.33782 = table->pdata;
        D.33777 = hash * 4;
        D.33783 = D.33782 + D.33777;
        *D.33783 = new_entry;
        goto <D.33786>;
        <D.33785>:
        goto <D.28294>;
        <D.28293>:
        entry = entry->next;
        <D.28294>:
        D.33787 = entry->next;
        if (D.33787 != 0B) goto <D.28293>; else goto <D.28295>;
        <D.28295>:
        entry->next = new_entry;
        D.33788 = table->len;
        new_entry->index = D.33788;
        monoeg_g_ptr_array_add (table, new_entry);
        <D.33786>:
      }
      <D.28292>:
      i = i + 1;
      <D.28297>:
      i.224 = (unsigned int) i;
      D.33741 = acfg->extra_methods;
      D.33742 = D.33741->len;
      if (i.224 < D.33742) goto <D.28296>; else goto <D.28298>;
      <D.28298>:
      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.28301>;
      <D.28300>:
      {
        struct HashEntry * entry;

        D.33782 = table->pdata;
        i.219 = (unsigned int) i;
        D.33746 = i.219 * 4;
        D.33789 = D.33782 + D.33746;
        entry = *D.33789;
        if (entry == 0B) goto <D.33790>; else goto <D.33791>;
        <D.33790>:
        emit_int32 (acfg, 0);
        emit_int32 (acfg, 0);
        emit_int32 (acfg, 0);
        goto <D.33792>;
        <D.33791>:
        D.33793 = entry->key;
        D.33794 = (int) D.33793;
        emit_int32 (acfg, D.33794);
        D.33795 = entry->value;
        D.33796 = (int) D.33795;
        emit_int32 (acfg, D.33796);
        D.33797 = entry->next;
        if (D.33797 != 0B) goto <D.33798>; else goto <D.33799>;
        <D.33798>:
        D.33797 = entry->next;
        D.33800 = D.33797->index;
        D.33801 = (int) D.33800;
        emit_int32 (acfg, D.33801);
        goto <D.33802>;
        <D.33799>:
        emit_int32 (acfg, 0);
        <D.33802>:
        <D.33792>:
      }
      i = i + 1;
      <D.28301>:
      i.224 = (unsigned int) i;
      D.33788 = table->len;
      if (i.224 < D.33788) goto <D.28300>; else goto <D.28302>;
      <D.28302>:
      sprintf (&symbol, "extra_method_info_offsets");
      emit_section_change (acfg, ".rodata", 0);
      emit_alignment (acfg, 8);
      emit_label (acfg, &symbol);
      D.33741 = acfg->extra_methods;
      D.33742 = D.33741->len;
      D.33803 = (int) D.33742;
      emit_int32 (acfg, D.33803);
      i = 0;
      goto <D.28305>;
      <D.28304>:
      {
        struct MonoMethod * method;

        D.33741 = acfg->extra_methods;
        D.33744 = D.33741->pdata;
        i.219 = (unsigned int) i;
        D.33746 = i.219 * 4;
        D.33747 = D.33744 + D.33746;
        method = *D.33747;
        D.33804 = get_method_index (acfg, method);
        D.33805 = (int) D.33804;
        emit_int32 (acfg, D.33805);
        i.219 = (unsigned int) i;
        D.33746 = i.219 * 4;
        D.33761 = info_offsets + D.33746;
        D.33806 = *D.33761;
        D.33807 = (int) D.33806;
        emit_int32 (acfg, D.33807);
      }
      i = i + 1;
      <D.28305>:
      i.224 = (unsigned int) i;
      D.33741 = acfg->extra_methods;
      D.33742 = D.33741->len;
      if (i.224 < D.33742) goto <D.28304>; else goto <D.28306>;
      <D.28306>:
    }
  finally
    {
      symbol = {CLOBBER};
      p = {CLOBBER};
    }
}


emit_trampolines (struct MonoAotCompile * acfg)
{
  int D.33808;
  struct MonoImage * D.33811;
  struct MonoAssembly * D.33812;
  _Bool D.33813;
  long int D.33814;
  long int D.33815;
  int D.27794;
  int iftmp.228;
  int D.27793;
  const char[9] * D.33821;
  unsigned char D.33822;
  int D.33823;
  unsigned char D.33824;
  int D.33825;
  _Bool D.33826;
  _Bool D.33827;
  _Bool D.33828;
  const unsigned char * D.33831;
  unsigned char D.33832;
  int D.33833;
  const unsigned char * D.33834;
  unsigned char D.33835;
  int D.33836;
  _Bool D.33837;
  _Bool D.33838;
  const unsigned char * D.33841;
  unsigned char D.33842;
  int D.33843;
  const unsigned char * D.33844;
  unsigned char D.33845;
  int D.33846;
  _Bool D.33847;
  _Bool D.33848;
  const unsigned char * D.33851;
  unsigned char D.33852;
  int D.33853;
  const unsigned char * D.33854;
  unsigned char D.33855;
  int D.33856;
  const char * D.33858;
  <unnamed type> tramp_type.229;
  int iftmp.230;
  int D.33865;
  unsigned int D.33869;
  int D.33870;
  struct MonoTrampInfo * info.231;
  gchar * D.33874;
  unsigned int offset.232;
  unsigned int i.233;
  unsigned int D.33877;
  int D.33878;
  int D.33879;
  unsigned int tramp_got_offset.234;
  unsigned int D.33883;
  int tramp_size.235;
  _Bool D.33887;
  long int D.33888;
  long int D.33889;
  unsigned int tramp_size.236;
  unsigned int i.237;
  unsigned int D.33894;
  unsigned int D.33895;
  unsigned int D.33896;
  unsigned int D.33897;
  char symbol[256];
  char end_symbol[256];
  int i;
  int tramp_got_offset;
  MonoAotTrampoline ntype;
  int tramp_type;

  try
    {
      D.33808 = acfg->aot_opts.full_aot;
      if (D.33808 == 0) goto <D.33809>; else goto <D.33810>;
      <D.33809>:
      return;
      <D.33810>:
      D.33811 = acfg->image;
      D.33812 = D.33811->assembly;
      D.33813 = D.33812 == 0B;
      D.33814 = (long int) D.33813;
      D.33815 = __builtin_expect (D.33814, 0);
      if (D.33815 != 0) goto <D.33816>; else goto <D.33817>;
      <D.33816>:
      monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "aot-compiler.c", 5896, "acfg->image->assembly");
      <D.33817>:
      {
        size_t __s1_len;
        size_t __s2_len;

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

          D.33811 = acfg->image;
          D.33812 = D.33811->assembly;
          __s2 = D.33812->aname.name;
          D.33821 = "mscorlib";
          D.33822 = MEM[(const unsigned char *)D.33821];
          D.33823 = (int) D.33822;
          D.33824 = *__s2;
          D.33825 = (int) D.33824;
          __result = D.33823 - D.33825;
          {
            D.33826 = __s2_len != 0;
            D.33827 = __result == 0;
            D.33828 = D.33826 & D.33827;
            if (D.33828 != 0) goto <D.33829>; else goto <D.33830>;
            <D.33829>:
            D.33831 = &MEM[(void *)"mscorlib" + 1B];
            D.33832 = *D.33831;
            D.33833 = (int) D.33832;
            D.33834 = __s2 + 1;
            D.33835 = *D.33834;
            D.33836 = (int) D.33835;
            __result = D.33833 - D.33836;
            D.33837 = __s2_len > 1;
            D.33827 = __result == 0;
            D.33838 = D.33837 & D.33827;
            if (D.33838 != 0) goto <D.33839>; else goto <D.33840>;
            <D.33839>:
            D.33841 = &MEM[(void *)"mscorlib" + 2B];
            D.33842 = *D.33841;
            D.33843 = (int) D.33842;
            D.33844 = __s2 + 2;
            D.33845 = *D.33844;
            D.33846 = (int) D.33845;
            __result = D.33843 - D.33846;
            D.33847 = __s2_len > 2;
            D.33827 = __result == 0;
            D.33848 = D.33847 & D.33827;
            if (D.33848 != 0) goto <D.33849>; else goto <D.33850>;
            <D.33849>:
            D.33851 = &MEM[(void *)"mscorlib" + 3B];
            D.33852 = *D.33851;
            D.33853 = (int) D.33852;
            D.33854 = __s2 + 3;
            D.33855 = *D.33854;
            D.33856 = (int) D.33855;
            __result = D.33853 - D.33856;
            <D.33850>:
            <D.33840>:
            <D.33830>:
          }
          D.27793 = __result;
        }
        iftmp.228 = -D.27793;
        goto <D.33857>;
        <D.33820>:
        D.33811 = acfg->image;
        D.33812 = D.33811->assembly;
        D.33858 = D.33812->aname.name;
        iftmp.228 = __builtin_strcmp (D.33858, "mscorlib");
        <D.33857>:
        D.27794 = iftmp.228;
      }
      if (D.27794 == 0) goto <D.33859>; else goto <D.33860>;
      <D.33859>:
      {
        struct MonoTrampInfo * info;

        try
          {
            tramp_type = 0;
            goto <D.27798>;
            <D.27797>:
            if (tramp_type == 13) goto <D.33861>; else goto <D.33862>;
            <D.33861>:
            // predicted unlikely by continue predictor.
            goto <D.27796>;
            <D.33862>:
            tramp_type.229 = (<unnamed type>) tramp_type;
            D.33865 = acfg->aot_opts.use_trampolines_page;
            if (D.33865 != 0) goto <D.33866>; else goto <D.33867>;
            <D.33866>:
            iftmp.230 = 2;
            goto <D.33868>;
            <D.33867>:
            iftmp.230 = 1;
            <D.33868>:
            mono_arch_create_generic_trampoline (tramp_type.229, &info, iftmp.230);
            D.33869 = acfg->got_offset;
            D.33870 = (int) D.33869;
            info.231 = info;
            emit_trampoline (acfg, D.33870, info.231);
            <D.27796>:
            tramp_type = tramp_type + 1;
            <D.27798>:
            if (tramp_type <= 13) goto <D.27797>; else goto <D.27799>;
            <D.27799>:
            mono_arch_get_nullified_class_init_trampoline (&info);
            D.33869 = acfg->got_offset;
            D.33870 = (int) D.33869;
            info.231 = info;
            emit_trampoline (acfg, D.33870, info.231);
            mono_arch_create_generic_class_init_trampoline (&info, 1);
            D.33869 = acfg->got_offset;
            D.33870 = (int) D.33869;
            info.231 = info;
            emit_trampoline (acfg, D.33870, info.231);
            mono_arch_get_restore_context (&info, 1);
            D.33869 = acfg->got_offset;
            D.33870 = (int) D.33869;
            info.231 = info;
            emit_trampoline (acfg, D.33870, info.231);
            mono_arch_get_call_filter (&info, 1);
            D.33869 = acfg->got_offset;
            D.33870 = (int) D.33869;
            info.231 = info;
            emit_trampoline (acfg, D.33870, info.231);
            mono_arch_get_throw_exception (&info, 1);
            D.33869 = acfg->got_offset;
            D.33870 = (int) D.33869;
            info.231 = info;
            emit_trampoline (acfg, D.33870, info.231);
            mono_arch_get_rethrow_exception (&info, 1);
            D.33869 = acfg->got_offset;
            D.33870 = (int) D.33869;
            info.231 = info;
            emit_trampoline (acfg, D.33870, info.231);
            mono_arch_get_throw_corlib_exception (&info, 1);
            D.33869 = acfg->got_offset;
            D.33870 = (int) D.33869;
            info.231 = info;
            emit_trampoline (acfg, D.33870, info.231);
            mono_arch_get_gsharedvt_trampoline (&info, 1);
            info.231 = info;
            if (info.231 != 0B) goto <D.33872>; else goto <D.33873>;
            <D.33872>:
            D.33869 = acfg->got_offset;
            D.33870 = (int) D.33869;
            info.231 = info;
            emit_trampoline_full (acfg, D.33870, info.231, 1);
            info.231 = info;
            D.33874 = monoeg_strdup ("gsharedvt_out_trampoline");
            info.231->name = D.33874;
            D.33869 = acfg->got_offset;
            D.33870 = (int) D.33869;
            info.231 = info;
            emit_trampoline_full (acfg, D.33870, info.231, 1);
            <D.33873>:
            {
              struct GSList * l;

              l = mono_arch_get_trampolines (1);
              goto <D.27803>;
              <D.27802>:
              {
                struct MonoTrampInfo * info;

                info = l->data;
                D.33869 = acfg->got_offset;
                D.33870 = (int) D.33869;
                emit_trampoline (acfg, D.33870, info);
                l = l->next;
              }
              <D.27803>:
              if (l != 0B) goto <D.27802>; else goto <D.27804>;
              <D.27804>:
            }
            i = 0;
            goto <D.27807>;
            <D.27806>:
            {
              int offset;

              offset = i;
              offset.232 = (unsigned int) offset;
              mono_arch_create_rgctx_lazy_fetch_trampoline (offset.232, &info, 1);
              D.33869 = acfg->got_offset;
              D.33870 = (int) D.33869;
              info.231 = info;
              emit_trampoline (acfg, D.33870, info.231);
              i.233 = (unsigned int) i;
              D.33877 = i.233 | 2147483648;
              offset = (int) D.33877;
              offset.232 = (unsigned int) offset;
              mono_arch_create_rgctx_lazy_fetch_trampoline (offset.232, &info, 1);
              D.33869 = acfg->got_offset;
              D.33870 = (int) D.33869;
              info.231 = info;
              emit_trampoline (acfg, D.33870, info.231);
            }
            i = i + 1;
            <D.27807>:
            D.33878 = acfg->aot_opts.nrgctx_fetch_trampolines;
            if (D.33878 > i) goto <D.27806>; else goto <D.27808>;
            <D.27808>:
            mono_arch_create_general_rgctx_lazy_fetch_trampoline (&info, 1);
            D.33869 = acfg->got_offset;
            D.33870 = (int) D.33869;
            info.231 = info;
            emit_trampoline (acfg, D.33870, info.231);
            {
              struct GSList * l;

              l = mono_arch_get_delegate_invoke_impls ();
              goto <D.27812>;
              <D.27811>:
              {
                struct MonoTrampInfo * info;

                info = l->data;
                D.33869 = acfg->got_offset;
                D.33870 = (int) D.33869;
                emit_trampoline (acfg, D.33870, info);
                l = l->next;
              }
              <D.27812>:
              if (l != 0B) goto <D.27811>; else goto <D.27813>;
              <D.27813>:
            }
            emit_section_change (acfg, ".text", 0);
            D.33869 = acfg->got_offset;
            tramp_got_offset = (int) D.33869;
            ntype = 0;
            goto <D.27831>;
            <D.27830>:
            switch (ntype) <default: <D.27819>, case 0: <D.27814>, case 1: <D.27816>, case 2: <D.27817>, case 3: <D.27818>>
            <D.27814>:
            sprintf (&symbol, "specific_trampolines");
            goto <D.27815>;
            <D.27816>:
            sprintf (&symbol, "static_rgctx_trampolines");
            goto <D.27815>;
            <D.27817>:
            sprintf (&symbol, "imt_thunks");
            goto <D.27815>;
            <D.27818>:
            sprintf (&symbol, "gsharedvt_arg_trampolines");
            goto <D.27815>;
            <D.27819>:
            monoeg_assertion_message ("* Assertion: should not be reached at %s:%d\n", "aot-compiler.c", 6053);
            <D.27815>:
            sprintf (&end_symbol, "%s_e", &symbol);
            D.33879 = acfg->aot_opts.write_symbols;
            if (D.33879 != 0) goto <D.33880>; else goto <D.33881>;
            <D.33880>:
            emit_local_symbol (acfg, &symbol, &end_symbol, 1);
            <D.33881>:
            emit_alignment (acfg, 4);
            emit_label (acfg, &symbol);
            tramp_got_offset.234 = (unsigned int) tramp_got_offset;
            acfg->trampoline_got_offset_base[ntype] = tramp_got_offset.234;
            i = 0;
            goto <D.27828>;
            <D.27827>:
            {
              int tramp_size;

              try
                {
                  tramp_size = 0;
                  switch (ntype) <default: <D.27826>, case 0: <D.27821>, case 1: <D.27823>, case 2: <D.27824>, case 3: <D.27825>>
                  <D.27821>:
                  arch_emit_specific_trampoline (acfg, tramp_got_offset, &tramp_size);
                  tramp_got_offset = tramp_got_offset + 2;
                  goto <D.27822>;
                  <D.27823>:
                  arch_emit_static_rgctx_trampoline (acfg, tramp_got_offset, &tramp_size);
                  tramp_got_offset = tramp_got_offset + 2;
                  goto <D.27822>;
                  <D.27824>:
                  arch_emit_imt_thunk (acfg, tramp_got_offset, &tramp_size);
                  tramp_got_offset = tramp_got_offset + 1;
                  goto <D.27822>;
                  <D.27825>:
                  arch_emit_gsharedvt_arg_trampoline (acfg, tramp_got_offset, &tramp_size);
                  tramp_got_offset = tramp_got_offset + 2;
                  goto <D.27822>;
                  <D.27826>:
                  monoeg_assertion_message ("* Assertion: should not be reached at %s:%d\n", "aot-compiler.c", 6087);
                  <D.27822>:
                  D.33883 = acfg->trampoline_size[ntype];
                  if (D.33883 == 0) goto <D.33884>; else goto <D.33885>;
                  <D.33884>:
                  tramp_size.235 = tramp_size;
                  D.33887 = tramp_size.235 == 0;
                  D.33888 = (long int) D.33887;
                  D.33889 = __builtin_expect (D.33888, 0);
                  if (D.33889 != 0) goto <D.33890>; else goto <D.33891>;
                  <D.33890>:
                  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "aot-compiler.c", 6095, "tramp_size");
                  <D.33891>:
                  tramp_size.235 = tramp_size;
                  tramp_size.236 = (unsigned int) tramp_size.235;
                  acfg->trampoline_size[ntype] = tramp_size.236;
                  <D.33885>:
                }
              finally
                {
                  tramp_size = {CLOBBER};
                }
            }
            i = i + 1;
            <D.27828>:
            i.237 = (unsigned int) i;
            D.33894 = acfg->num_trampolines[ntype];
            if (i.237 < D.33894) goto <D.27827>; else goto <D.27829>;
            <D.27829>:
            emit_label (acfg, &end_symbol);
            emit_int32 (acfg, 0);
            ntype = ntype + 1;
            <D.27831>:
            if (ntype <= 3) goto <D.27830>; else goto <D.27832>;
            <D.27832>:
            arch_emit_specific_trampoline_pages (acfg);
            tramp_got_offset.234 = (unsigned int) tramp_got_offset;
            D.33869 = acfg->got_offset;
            D.33895 = tramp_got_offset.234 - D.33869;
            acfg->num_trampoline_got_entries = D.33895;
          }
        finally
          {
            info = {CLOBBER};
          }
      }
      <D.33860>:
      D.33869 = acfg->got_offset;
      D.33896 = acfg->num_trampoline_got_entries;
      D.33897 = D.33869 + D.33896;
      acfg->got_offset = D.33897;
    }
  finally
    {
      symbol = {CLOBBER};
      end_symbol = {CLOBBER};
    }
}


emit_trampoline_full (struct MonoAotCompile * acfg, int got_offset, struct MonoTrampInfo * info, gboolean emit_tinfo)
{
  _Bool D.33901;
  long int D.33902;
  long int D.33903;
  const char * D.33906;
  const char * D.33907;
  <unnamed type> D.33910;
  unsigned int D.33913;
  unsigned int D.33914;
  int D.33915;
  guint8 * p.238;
  int p.239;
  int buf.240;
  int D.33919;
  unsigned int D.33920;
  _Bool D.33921;
  long int D.33922;
  long int D.33923;
  int info_offset.241;
  struct GSList * D.33929;
  unsigned int encoded_len.242;
  int uw_offset.243;
  struct MonoDwarfWriter * D.33934;
  char start_symbol[256];
  char end_symbol[256];
  char symbol[256];
  guint32 buf_size;
  guint32 info_offset;
  struct MonoJumpInfo * patch_info;
  guint8 * buf;
  guint8 * p;
  struct GPtrArray * patches;
  char * name;
  guint8 * code;
  guint32 code_size;
  struct MonoJumpInfo * ji;
  struct GSList * unwind_ops;

  try
    {
      D.33901 = info == 0B;
      D.33902 = (long int) D.33901;
      D.33903 = __builtin_expect (D.33902, 0);
      if (D.33903 != 0) goto <D.33904>; else goto <D.33905>;
      <D.33904>:
      monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "aot-compiler.c", 5785, "info");
      <D.33905>:
      name = info->name;
      code = info->code;
      code_size = info->code_size;
      ji = info->ji;
      unwind_ops = info->unwind_ops;
      D.33906 = acfg->user_symbol_prefix;
      sprintf (&start_symbol, "%s%s", D.33906, name);
      emit_section_change (acfg, ".text", 0);
      emit_global (acfg, &start_symbol, 1);
      emit_alignment (acfg, 4);
      emit_label (acfg, &start_symbol);
      D.33907 = acfg->temp_prefix;
      sprintf (&symbol, "%snamed_%s", D.33907, name);
      emit_label (acfg, &symbol);
      emit_and_reloc_code (acfg, 0B, code, code_size, ji, 1, 0B);
      emit_symbol_size (acfg, &start_symbol, ".");
      if (emit_tinfo != 0) goto <D.33908>; else goto <D.33909>;
      <D.33908>:
      D.33907 = acfg->temp_prefix;
      sprintf (&end_symbol, "%snamede_%s", D.33907, name);
      emit_label (acfg, &end_symbol);
      <D.33909>:
      patches = monoeg_g_ptr_array_new ();
      patch_info = ji;
      goto <D.27766>;
      <D.27765>:
      D.33910 = patch_info->type;
      if (D.33910 != 51) goto <D.33911>; else goto <D.33912>;
      <D.33911>:
      monoeg_g_ptr_array_add (patches, patch_info);
      <D.33912>:
      patch_info = patch_info->next;
      <D.27766>:
      if (patch_info != 0B) goto <D.27765>; else goto <D.27767>;
      <D.27767>:
      monoeg_g_ptr_array_sort (patches, compare_patches);
      D.33913 = patches->len;
      D.33914 = D.33913 + 1;
      buf_size = D.33914 * 128;
      buf = monoeg_malloc (buf_size);
      p = buf;
      D.33913 = patches->len;
      D.33915 = (int) D.33913;
      p.238 = p;
      encode_patch_list (acfg, patches, D.33915, got_offset, p.238, &p);
      p.238 = p;
      p.239 = (int) p.238;
      buf.240 = (int) buf;
      D.33919 = p.239 - buf.240;
      D.33920 = (unsigned int) D.33919;
      D.33921 = D.33920 >= buf_size;
      D.33922 = (long int) D.33921;
      D.33923 = __builtin_expect (D.33922, 0);
      if (D.33923 != 0) goto <D.33924>; else goto <D.33925>;
      <D.33924>:
      monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "aot-compiler.c", 5836, "p - buf < buf_size");
      <D.33925>:
      D.33906 = acfg->user_symbol_prefix;
      sprintf (&symbol, "%s%s_p", D.33906, name);
      p.238 = p;
      p.239 = (int) p.238;
      buf.240 = (int) buf;
      D.33919 = p.239 - buf.240;
      D.33920 = (unsigned int) D.33919;
      info_offset = add_to_blob (acfg, buf, D.33920);
      emit_section_change (acfg, ".rodata", 0);
      emit_global (acfg, &symbol, 0);
      emit_label (acfg, &symbol);
      info_offset.241 = (int) info_offset;
      emit_int32 (acfg, info_offset.241);
      if (emit_tinfo != 0) goto <D.33927>; else goto <D.33928>;
      <D.33927>:
      {
        guint8 * encoded;
        guint32 encoded_len;
        guint32 uw_offset;

        try
          {
            D.33929 = info->unwind_ops;
            encoded = mono_unwind_ops_encode (D.33929, &encoded_len);
            encoded_len.242 = encoded_len;
            uw_offset = get_unwind_info_offset (acfg, encoded, encoded_len.242);
            monoeg_g_free (encoded);
            emit_symbol_diff (acfg, &end_symbol, &start_symbol, 0);
            uw_offset.243 = (int) uw_offset;
            emit_int32 (acfg, uw_offset.243);
          }
        finally
          {
            encoded_len = {CLOBBER};
          }
      }
      <D.33928>:
      if (unwind_ops != 0B) goto <D.33932>; else goto <D.33933>;
      <D.33932>:
      {
        char symbol2[256];

        try
          {
            sprintf (&symbol, "%s", name);
            D.33907 = acfg->temp_prefix;
            sprintf (&symbol2, "%snamed_%s", D.33907, name);
            D.33934 = acfg->dwarf;
            if (D.33934 != 0B) goto <D.33935>; else goto <D.33936>;
            <D.33935>:
            D.33934 = acfg->dwarf;
            mono_dwarf_writer_emit_trampoline (D.33934, &symbol, &symbol2, 0B, 0B, code_size, unwind_ops);
            <D.33936>:
          }
        finally
          {
            symbol2 = {CLOBBER};
          }
      }
      <D.33933>:
    }
  finally
    {
      start_symbol = {CLOBBER};
      end_symbol = {CLOBBER};
      symbol = {CLOBBER};
      p = {CLOBBER};
    }
}


emit_global (struct MonoAotCompile * acfg, const char * name, gboolean func)
{
  int D.33937;
  struct GPtrArray * D.33940;
  gchar * D.33941;
  struct MonoImageWriter * D.33942;

  D.33937 = acfg->aot_opts.no_dlsym;
  if (D.33937 != 0) goto <D.33938>; else goto <D.33939>;
  <D.33938>:
  D.33940 = acfg->globals;
  D.33941 = monoeg_strdup (name);
  monoeg_g_ptr_array_add (D.33940, D.33941);
  D.33942 = acfg->w;
  img_writer_emit_local_symbol (D.33942, name, 0B, func);
  goto <D.33943>;
  <D.33939>:
  D.33942 = acfg->w;
  img_writer_emit_global (D.33942, name, func);
  <D.33943>:
}


get_unwind_info_offset (struct MonoAotCompile * acfg, guint8 * encoded, guint32 encoded_len)
{
  struct GHashTable * D.33944;
  unsigned int D.33945;
  const void * D.33946;
  void * D.33947;
  guint32 D.33950;
  void * D.33951;
  unsigned int D.33952;
  void * D.33953;
  struct GPtrArray * D.33954;
  void * cache_index.244;
  int encoded_len.245;
  guint8 * p.246;
  unsigned int D.33958;
  int p.247;
  int buf.248;
  int D.33961;
  unsigned int D.33962;
  unsigned int D.33963;
  unsigned int D.33964;
  guint32 cache_index;
  guint32 offset;

  cache_index = mono_cache_unwind_info (encoded, encoded_len);
  D.33944 = acfg->unwind_info_offsets;
  D.33945 = cache_index + 1;
  D.33946 = (const void *) D.33945;
  D.33947 = monoeg_g_hash_table_lookup (D.33944, D.33946);
  offset = (guint32) D.33947;
  if (offset != 0) goto <D.33948>; else goto <D.33949>;
  <D.33948>:
  D.33950 = offset + 4294967295;
  return D.33950;
  <D.33949>:
  {
    guint8 buf[16];
    guint8 * p;

    try
      {
        offset = acfg->unwind_info_offset;
        D.33944 = acfg->unwind_info_offsets;
        D.33945 = cache_index + 1;
        D.33951 = (void *) D.33945;
        D.33952 = offset + 1;
        D.33953 = (void *) D.33952;
        monoeg_g_hash_table_insert_replace (D.33944, D.33951, D.33953, 0);
        D.33954 = acfg->unwind_ops;
        cache_index.244 = (void *) cache_index;
        monoeg_g_ptr_array_add (D.33954, cache_index.244);
        p = &buf;
        encoded_len.245 = (int) encoded_len;
        p.246 = p;
        encode_value (encoded_len.245, p.246, &p);
        D.33958 = acfg->unwind_info_offset;
        p.246 = p;
        p.247 = (int) p.246;
        buf.248 = (int) &buf;
        D.33961 = p.247 - buf.248;
        D.33962 = (unsigned int) D.33961;
        D.33963 = D.33962 + encoded_len;
        D.33964 = D.33958 + D.33963;
        acfg->unwind_info_offset = D.33964;
        D.33950 = offset;
        return D.33950;
      }
    finally
      {
        buf = {CLOBBER};
        p = {CLOBBER};
      }
  }
}


emit_trampoline (struct MonoAotCompile * acfg, int got_offset, struct MonoTrampInfo * info)
{
  emit_trampoline_full (acfg, got_offset, info, 0);
}


arch_emit_specific_trampoline (struct MonoAotCompile * acfg, int offset, int * tramp_size)
{
  int code.249;
  int buf.250;
  int D.33969;
  _Bool D.33970;
  long int D.33971;
  long int D.33972;
  char * D.33975;
  unsigned int offset.251;
  unsigned int D.33977;
  int D.33978;
  guint8 buf[128];
  guint8 * code;

  try
    {
      *tramp_size = 20;
      code = &buf;
      {
        arminstr_t * __ainstrp;

        __ainstrp = code;
        *__ainstrp = 3912065023;
        code = __ainstrp + 4;
      }
      {
        arminstr_t * __ainstrp;

        __ainstrp = code;
        *__ainstrp = 3852406788;
        code = __ainstrp + 4;
      }
      {
        arminstr_t * __ainstrp;

        __ainstrp = code;
        *__ainstrp = 3885961217;
        code = __ainstrp + 4;
      }
      {
        arminstr_t * __ainstrp;

        __ainstrp = code;
        *__ainstrp = 3778019121;
        code = __ainstrp + 4;
      }
      code.249 = (int) code;
      buf.250 = (int) &buf;
      D.33969 = code.249 - buf.250;
      D.33970 = D.33969 != 16;
      D.33971 = (long int) D.33970;
      D.33972 = __builtin_expect (D.33971, 0);
      if (D.33972 != 0) goto <D.33973>; else goto <D.33974>;
      <D.33973>:
      monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "aot-compiler.c", 1289, "code - buf == 16");
      <D.33974>:
      code.249 = (int) code;
      buf.250 = (int) &buf;
      D.33969 = code.249 - buf.250;
      emit_bytes (acfg, &buf, D.33969);
      D.33975 = acfg->got_symbol;
      offset.251 = (unsigned int) offset;
      D.33977 = offset.251 * 4;
      D.33978 = (int) D.33977;
      emit_symbol_diff (acfg, D.33975, ".", D.33978);
    }
  finally
    {
      buf = {CLOBBER};
    }
}


arch_emit_static_rgctx_trampoline (struct MonoAotCompile * acfg, int offset, int * tramp_size)
{
  int code.252;
  int buf.253;
  int D.33981;
  _Bool D.33982;
  long int D.33983;
  long int D.33984;
  char * D.33987;
  unsigned int offset.254;
  unsigned int D.33989;
  unsigned int D.33990;
  int D.33991;
  guint8 buf[128];
  guint8 * code;

  try
    {
      *tramp_size = 24;
      code = &buf;
      {
        arminstr_t * __ainstrp;

        __ainstrp = code;
        *__ainstrp = 3852451848;
        code = __ainstrp + 4;
      }
      {
        arminstr_t * __ainstrp;

        __ainstrp = code;
        *__ainstrp = 3885989900;
        code = __ainstrp + 4;
      }
      {
        arminstr_t * __ainstrp;

        __ainstrp = code;
        *__ainstrp = 3852451844;
        code = __ainstrp + 4;
      }
      {
        arminstr_t * __ainstrp;

        __ainstrp = code;
        *__ainstrp = 3886018572;
        code = __ainstrp + 4;
      }
      code.252 = (int) code;
      buf.253 = (int) &buf;
      D.33981 = code.252 - buf.253;
      D.33982 = D.33981 != 16;
      D.33983 = (long int) D.33982;
      D.33984 = __builtin_expect (D.33983, 0);
      if (D.33984 != 0) goto <D.33985>; else goto <D.33986>;
      <D.33985>:
      monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "aot-compiler.c", 1525, "code - buf == 16");
      <D.33986>:
      code.252 = (int) code;
      buf.253 = (int) &buf;
      D.33981 = code.252 - buf.253;
      emit_bytes (acfg, &buf, D.33981);
      D.33987 = acfg->got_symbol;
      offset.254 = (unsigned int) offset;
      D.33989 = offset.254 + 1;
      D.33990 = D.33989 * 4;
      D.33991 = (int) D.33990;
      emit_symbol_diff (acfg, D.33987, ".", D.33991);
      D.33987 = acfg->got_symbol;
      offset.254 = (unsigned int) offset;
      D.33989 = offset.254 + 1;
      D.33990 = D.33989 * 4;
      D.33991 = (int) D.33990;
      emit_symbol_diff (acfg, D.33987, ".", D.33991);
    }
  finally
    {
      buf = {CLOBBER};
    }
}


arch_emit_imt_thunk (struct MonoAotCompile * acfg, int offset, int * tramp_size)
{
  guint8 * D.33992;
  guint8 * D.33993;
  guint8 * D.33994;
  int D.33995;
  int D.33996;
  int iftmp.255;
  int D.34001;
  int D.34002;
  unsigned int D.34003;
  guint8 * D.34004;
  int D.34005;
  int D.34006;
  int iftmp.256;
  int D.34011;
  int D.34012;
  unsigned int D.34013;
  int code.257;
  guint8 * D.34015;
  guint8 * D.34016;
  int D.34017;
  int D.34018;
  int D.34019;
  int D.34020;
  int iftmp.258;
  int D.34025;
  int D.34026;
  unsigned int D.34027;
  int buf.259;
  int D.34029;
  char * D.34030;
  unsigned int offset.260;
  unsigned int D.34032;
  unsigned int D.34033;
  unsigned int D.34034;
  unsigned int D.34035;
  int D.34036;
  int D.34037;
  guint8 buf[128];
  guint8 * code;
  guint8 * code2;
  guint8 * labels[16];

  try
    {
      code = &buf;
      {
        arminstr_t * __ainstrp;

        __ainstrp = code;
        *__ainstrp = 3912040455;
        code = __ainstrp + 4;
      }
      labels[0] = code;
      {
        arminstr_t * __ainstrp;

        __ainstrp = code;
        *__ainstrp = 3852402688;
        code = __ainstrp + 4;
      }
      {
        arminstr_t * __ainstrp;

        __ainstrp = code;
        *__ainstrp = 3885957120;
        code = __ainstrp + 4;
      }
      labels[1] = code;
      {
        arminstr_t * __ainstrp;

        __ainstrp = code;
        *__ainstrp = 3851423744;
        code = __ainstrp + 4;
      }
      {
        arminstr_t * __ainstrp;

        __ainstrp = code;
        *__ainstrp = 3780182024;
        code = __ainstrp + 4;
      }
      labels[2] = code;
      {
        arminstr_t * __ainstrp;

        __ainstrp = code;
        *__ainstrp = 167772160;
        code = __ainstrp + 4;
      }
      {
        arminstr_t * __ainstrp;

        __ainstrp = code;
        *__ainstrp = 3813736448;
        code = __ainstrp + 4;
      }
      labels[3] = code;
      {
        arminstr_t * __ainstrp;

        __ainstrp = code;
        *__ainstrp = 167772160;
        code = __ainstrp + 4;
      }
      {
        arminstr_t * __ainstrp;

        __ainstrp = code;
        *__ainstrp = 3800039432;
        code = __ainstrp + 4;
      }
      labels[4] = code;
      {
        arminstr_t * __ainstrp;

        __ainstrp = code;
        *__ainstrp = 3925868544;
        code = __ainstrp + 4;
      }
      D.33992 = labels[4];
      D.33993 = labels[1];
      arm_patch (D.33992, D.33993);
      D.33994 = labels[2];
      arm_patch (D.33994, code);
      {
        arminstr_t * __ainstrp;

        __ainstrp = code;
        *__ainstrp = 3851419652;
        code = __ainstrp + 4;
      }
      {
        arminstr_t * __ainstrp;

        __ainstrp = code;
        *__ainstrp = 3851419648;
        code = __ainstrp + 4;
      }
      {
        int _imm12;

        _imm12 = 8;
        {
          arminstr_t * __ainstrp;

          __ainstrp = code;
          D.33995 = ABS_EXPR <_imm12>;
          D.33996 = D.33995 | 851968;
          if (_imm12 >= 0) goto <D.33998>; else goto <D.33999>;
          <D.33998>:
          iftmp.255 = 8388608;
          goto <D.34000>;
          <D.33999>:
          iftmp.255 = 0;
          <D.34000>:
          D.34001 = D.33996 | iftmp.255;
          D.34002 = D.34001 | -452984832;
          D.34003 = (unsigned int) D.34002;
          *__ainstrp = D.34003;
          code = __ainstrp + 4;
        }
      }
      {
        arminstr_t * __ainstrp;

        __ainstrp = code;
        *__ainstrp = 3904733187;
        code = __ainstrp + 4;
      }
      D.34004 = labels[3];
      arm_patch (D.34004, code);
      {
        arminstr_t * __ainstrp;

        __ainstrp = code;
        *__ainstrp = 3851419652;
        code = __ainstrp + 4;
      }
      {
        int _imm12;

        _imm12 = 8;
        {
          arminstr_t * __ainstrp;

          __ainstrp = code;
          D.34005 = ABS_EXPR <_imm12>;
          D.34006 = D.34005 | 851968;
          if (_imm12 >= 0) goto <D.34008>; else goto <D.34009>;
          <D.34008>:
          iftmp.256 = 8388608;
          goto <D.34010>;
          <D.34009>:
          iftmp.256 = 0;
          <D.34010>:
          D.34011 = D.34006 | iftmp.256;
          D.34012 = D.34011 | -452984832;
          D.34013 = (unsigned int) D.34012;
          *__ainstrp = D.34013;
          code = __ainstrp + 4;
        }
      }
      {
        arminstr_t * __ainstrp;

        __ainstrp = code;
        *__ainstrp = 3904733187;
        code = __ainstrp + 4;
      }
      code2 = labels[0];
      {
        arminstr_t * __ainstrp;

        __ainstrp = code2;
        code.257 = (int) code;
        D.34015 = labels[0];
        D.34016 = D.34015 + 8;
        D.34017 = (int) D.34016;
        D.34018 = code.257 - D.34017;
        D.34019 = ABS_EXPR <D.34018>;
        D.34020 = D.34019 | 2031616;
        code.257 = (int) code;
        D.34015 = labels[0];
        D.34016 = D.34015 + 8;
        D.34017 = (int) D.34016;
        D.34018 = code.257 - D.34017;
        if (D.34018 >= 0) goto <D.34022>; else goto <D.34023>;
        <D.34022>:
        iftmp.258 = 8388608;
        goto <D.34024>;
        <D.34023>:
        iftmp.258 = 0;
        <D.34024>:
        D.34025 = D.34020 | iftmp.258;
        D.34026 = D.34025 | -452984832;
        D.34027 = (unsigned int) D.34026;
        *__ainstrp = D.34027;
        code2 = __ainstrp + 4;
      }
      code.257 = (int) code;
      buf.259 = (int) &buf;
      D.34029 = code.257 - buf.259;
      emit_bytes (acfg, &buf, D.34029);
      D.34030 = acfg->got_symbol;
      offset.260 = (unsigned int) offset;
      D.34032 = offset.260 * 4;
      code.257 = (int) code;
      D.34015 = labels[0];
      D.34016 = D.34015 + 8;
      D.34017 = (int) D.34016;
      D.34018 = code.257 - D.34017;
      D.34033 = (unsigned int) D.34018;
      D.34034 = D.34032 + D.34033;
      D.34035 = D.34034 + 4294967292;
      D.34036 = (int) D.34035;
      emit_symbol_diff (acfg, D.34030, ".", D.34036);
      code.257 = (int) code;
      buf.259 = (int) &buf;
      D.34029 = code.257 - buf.259;
      D.34037 = D.34029 + 4;
      *tramp_size = D.34037;
    }
  finally
    {
      buf = {CLOBBER};
      labels = {CLOBBER};
    }
}


arch_emit_gsharedvt_arg_trampoline (struct MonoAotCompile * acfg, int offset, int * tramp_size)
{
  int code.261;
  int buf.262;
  int D.34040;
  _Bool D.34041;
  long int D.34042;
  long int D.34043;
  char * D.34046;
  unsigned int offset.263;
  unsigned int D.34048;
  unsigned int D.34049;
  int D.34050;
  guint8 buf[128];
  guint8 * code;

  try
    {
      *tramp_size = 24;
      code = &buf;
      {
        arminstr_t * __ainstrp;

        __ainstrp = code;
        *__ainstrp = 3912040463;
        code = __ainstrp + 4;
      }
      {
        arminstr_t * __ainstrp;

        __ainstrp = code;
        *__ainstrp = 3852406792;
        code = __ainstrp + 4;
      }
      {
        arminstr_t * __ainstrp;

        __ainstrp = code;
        *__ainstrp = 3885957121;
        code = __ainstrp + 4;
      }
      {
        arminstr_t * __ainstrp;

        __ainstrp = code;
        *__ainstrp = 3885961217;
        code = __ainstrp + 4;
      }
      {
        arminstr_t * __ainstrp;

        __ainstrp = code;
        *__ainstrp = 3778019089;
        code = __ainstrp + 4;
      }
      code.261 = (int) code;
      buf.262 = (int) &buf;
      D.34040 = code.261 - buf.262;
      D.34041 = D.34040 != 20;
      D.34042 = (long int) D.34041;
      D.34043 = __builtin_expect (D.34042, 0);
      if (D.34043 != 0) goto <D.34044>; else goto <D.34045>;
      <D.34044>:
      monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "aot-compiler.c", 1945, "code - buf == 20");
      <D.34045>:
      code.261 = (int) code;
      buf.262 = (int) &buf;
      D.34040 = code.261 - buf.262;
      emit_bytes (acfg, &buf, D.34040);
      D.34046 = acfg->got_symbol;
      offset.263 = (unsigned int) offset;
      D.34048 = offset.263 + 1;
      D.34049 = D.34048 * 4;
      D.34050 = (int) D.34049;
      emit_symbol_diff (acfg, D.34046, ".", D.34050);
    }
  finally
    {
      buf = {CLOBBER};
    }
}


arch_emit_specific_trampoline_pages (struct MonoAotCompile * acfg)
{
  int D.34051;
  int D.34052;
  int D.34053;
  int D.34056;
  unsigned int D.34057;
  const char * D.34058;
  int D.34059;
  int D.34060;
  unsigned int D.34061;
  int D.34062;
  int rot_amount.264;
  int D.34064;
  int D.34065;
  int D.34066;
  int D.34067;
  int D.34068;
  unsigned int D.34069;
  int code.265;
  int buf.266;
  int D.34072;
  _Bool D.34073;
  long int D.34074;
  long int D.34075;
  guchar * D.34078;
  int D.34079;
  int D.34080;
  sizetype D.34081;
  sizetype D.34082;
  guint8 * D.34083;
  _Bool D.34084;
  long int D.34085;
  long int D.34086;
  int D.34089;
  unsigned int D.34090;
  int D.34091;
  unsigned int D.34092;
  int D.34097;
  unsigned int D.34098;
  int D.34103;
  unsigned int D.34104;
  int D.34105;
  int D.34106;
  int iftmp.267;
  int D.34111;
  int D.34112;
  unsigned int D.34113;
  int D.34114;
  int D.34115;
  int iftmp.268;
  int D.34120;
  int D.34121;
  unsigned int D.34122;
  _Bool D.34123;
  long int D.34124;
  long int D.34125;
  sizetype D.34128;
  guint8 * D.34129;
  guint8 buf[128];
  guint8 * code;
  guint8 * loop_start;
  guint8 * loop_branch_back;
  guint8 * loop_end_check;
  guint8 * imt_found_check;
  int i;
  int count;
  int imm8;
  int rot_amount;
  char symbol[128];

  try
    {
      D.34051 = mono_pagesize ();
      D.34052 = D.34051 + -16;
      count = D.34052 / 8;
      D.34053 = acfg->aot_opts.use_trampolines_page;
      if (D.34053 == 0) goto <D.34054>; else goto <D.34055>;
      <D.34054>:
      return;
      <D.34055>:
      D.34056 = mono_pagesize ();
      D.34057 = (unsigned int) D.34056;
      acfg->tramp_page_size = D.34057;
      D.34058 = acfg->user_symbol_prefix;
      sprintf (&symbol, "%sspecific_trampolines_page", D.34058);
      D.34059 = mono_pagesize ();
      emit_alignment (acfg, D.34059);
      emit_global (acfg, &symbol, 1);
      emit_label (acfg, &symbol);
      code = &buf;
      D.34060 = mono_pagesize ();
      D.34061 = (unsigned int) D.34060;
      imm8 = mono_arm_is_rotated_imm8 (D.34061, &rot_amount);
      {
        arminstr_t * __ainstrp;

        __ainstrp = code;
        D.34062 = imm8 & 255;
        rot_amount.264 = rot_amount;
        D.34064 = rot_amount.264 >> 1;
        D.34065 = D.34064 & 15;
        D.34066 = D.34065 << 8;
        D.34067 = D.34062 | D.34066;
        D.34068 = D.34067 | -498147328;
        D.34069 = (unsigned int) D.34068;
        *__ainstrp = D.34069;
        code = __ainstrp + 4;
      }
      {
        arminstr_t * __ainstrp;

        __ainstrp = code;
        *__ainstrp = 3843952648;
        code = __ainstrp + 4;
      }
      {
        arminstr_t * __ainstrp;

        __ainstrp = code;
        *__ainstrp = 3844009988;
        code = __ainstrp + 4;
      }
      {
        arminstr_t * __ainstrp;

        __ainstrp = code;
        *__ainstrp = 3785359360;
        code = __ainstrp + 4;
      }
      code.265 = (int) code;
      buf.266 = (int) &buf;
      D.34072 = code.265 - buf.266;
      D.34073 = D.34072 != 16;
      D.34074 = (long int) D.34073;
      D.34075 = __builtin_expect (D.34074, 0);
      if (D.34075 != 0) goto <D.34076>; else goto <D.34077>;
      <D.34076>:
      monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "aot-compiler.c", 1054, "code - buf == COMMON_TRAMP_SIZE");
      <D.34077>:
      code.265 = (int) code;
      buf.266 = (int) &buf;
      D.34072 = code.265 - buf.266;
      emit_bytes (acfg, &buf, D.34072);
      i = 0;
      goto <D.26200>;
      <D.26199>:
      code = &buf;
      {
        arminstr_t * __ainstrp;

        __ainstrp = code;
        *__ainstrp = 3912065023;
        code = __ainstrp + 4;
      }
      {
        arminstr_t * __ainstrp;

        __ainstrp = code;
        *__ainstrp = 3942645760;
        code = __ainstrp + 4;
      }
      D.34078 = code + 4294967292;
      D.34079 = ~i;
      D.34080 = D.34079 * 8;
      D.34081 = (sizetype) D.34080;
      D.34082 = D.34081 + 4294967280;
      D.34083 = code + D.34082;
      arm_patch (D.34078, D.34083);
      code.265 = (int) code;
      buf.266 = (int) &buf;
      D.34072 = code.265 - buf.266;
      D.34084 = D.34072 != 8;
      D.34085 = (long int) D.34084;
      D.34086 = __builtin_expect (D.34085, 0);
      if (D.34086 != 0) goto <D.34087>; else goto <D.34088>;
      <D.34087>:
      monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "aot-compiler.c", 1064, "code - buf == 8");
      <D.34088>:
      code.265 = (int) code;
      buf.266 = (int) &buf;
      D.34072 = code.265 - buf.266;
      emit_bytes (acfg, &buf, D.34072);
      i = i + 1;
      <D.26200>:
      if (i < count) goto <D.26199>; else goto <D.26201>;
      <D.26201>:
      D.34058 = acfg->user_symbol_prefix;
      sprintf (&symbol, "%srgctx_trampolines_page", D.34058);
      emit_global (acfg, &symbol, 1);
      emit_label (acfg, &symbol);
      code = &buf;
      D.34089 = mono_pagesize ();
      D.34090 = (unsigned int) D.34089;
      imm8 = mono_arm_is_rotated_imm8 (D.34090, &rot_amount);
      {
        arminstr_t * __ainstrp;

        __ainstrp = code;
        D.34062 = imm8 & 255;
        rot_amount.264 = rot_amount;
        D.34064 = rot_amount.264 >> 1;
        D.34065 = D.34064 & 15;
        D.34066 = D.34065 << 8;
        D.34067 = D.34062 | D.34066;
        D.34091 = D.34067 | -498286592;
        D.34092 = (unsigned int) D.34091;
        *__ainstrp = D.34092;
        code = __ainstrp + 4;
      }
      {
        arminstr_t * __ainstrp;

        __ainstrp = code;
        *__ainstrp = 3843850248;
        code = __ainstrp + 4;
      }
      {
        arminstr_t * __ainstrp;

        __ainstrp = code;
        *__ainstrp = 3843878916;
        code = __ainstrp + 4;
      }
      {
        arminstr_t * __ainstrp;

        __ainstrp = code;
        *__ainstrp = 3785359360;
        code = __ainstrp + 4;
      }
      code.265 = (int) code;
      buf.266 = (int) &buf;
      D.34072 = code.265 - buf.266;
      D.34073 = D.34072 != 16;
      D.34074 = (long int) D.34073;
      D.34075 = __builtin_expect (D.34074, 0);
      if (D.34075 != 0) goto <D.34093>; else goto <D.34094>;
      <D.34093>:
      monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "aot-compiler.c", 1082, "code - buf == COMMON_TRAMP_SIZE");
      <D.34094>:
      code.265 = (int) code;
      buf.266 = (int) &buf;
      D.34072 = code.265 - buf.266;
      emit_bytes (acfg, &buf, D.34072);
      i = 0;
      goto <D.26209>;
      <D.26208>:
      code = &buf;
      {
        arminstr_t * __ainstrp;

        __ainstrp = code;
        *__ainstrp = 3785408527;
        code = __ainstrp + 4;
      }
      {
        arminstr_t * __ainstrp;

        __ainstrp = code;
        *__ainstrp = 3925868544;
        code = __ainstrp + 4;
      }
      D.34078 = code + 4294967292;
      D.34079 = ~i;
      D.34080 = D.34079 * 8;
      D.34081 = (sizetype) D.34080;
      D.34082 = D.34081 + 4294967280;
      D.34083 = code + D.34082;
      arm_patch (D.34078, D.34083);
      code.265 = (int) code;
      buf.266 = (int) &buf;
      D.34072 = code.265 - buf.266;
      D.34084 = D.34072 != 8;
      D.34085 = (long int) D.34084;
      D.34086 = __builtin_expect (D.34085, 0);
      if (D.34086 != 0) goto <D.34095>; else goto <D.34096>;
      <D.34095>:
      monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "aot-compiler.c", 1092, "code - buf == 8");
      <D.34096>:
      code.265 = (int) code;
      buf.266 = (int) &buf;
      D.34072 = code.265 - buf.266;
      emit_bytes (acfg, &buf, D.34072);
      i = i + 1;
      <D.26209>:
      if (i < count) goto <D.26208>; else goto <D.26210>;
      <D.26210>:
      D.34058 = acfg->user_symbol_prefix;
      sprintf (&symbol, "%sgsharedvt_arg_trampolines_page", D.34058);
      emit_global (acfg, &symbol, 1);
      emit_label (acfg, &symbol);
      code = &buf;
      {
        arminstr_t * __ainstrp;

        __ainstrp = code;
        *__ainstrp = 3912040463;
        code = __ainstrp + 4;
      }
      D.34097 = mono_pagesize ();
      D.34098 = (unsigned int) D.34097;
      imm8 = mono_arm_is_rotated_imm8 (D.34098, &rot_amount);
      {
        arminstr_t * __ainstrp;

        __ainstrp = code;
        D.34062 = imm8 & 255;
        rot_amount.264 = rot_amount;
        D.34064 = rot_amount.264 >> 1;
        D.34065 = D.34064 & 15;
        D.34066 = D.34065 << 8;
        D.34067 = D.34062 | D.34066;
        D.34091 = D.34067 | -498286592;
        D.34092 = (unsigned int) D.34091;
        *__ainstrp = D.34092;
        code = __ainstrp + 4;
      }
      {
        arminstr_t * __ainstrp;

        __ainstrp = code;
        *__ainstrp = 3843817480;
        code = __ainstrp + 4;
      }
      {
        arminstr_t * __ainstrp;

        __ainstrp = code;
        *__ainstrp = 3843878916;
        code = __ainstrp + 4;
      }
      code.265 = (int) code;
      buf.266 = (int) &buf;
      D.34072 = code.265 - buf.266;
      D.34073 = D.34072 != 16;
      D.34074 = (long int) D.34073;
      D.34075 = __builtin_expect (D.34074, 0);
      if (D.34075 != 0) goto <D.34099>; else goto <D.34100>;
      <D.34099>:
      monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "aot-compiler.c", 1108, "code - buf == COMMON_TRAMP_SIZE");
      <D.34100>:
      code.265 = (int) code;
      buf.266 = (int) &buf;
      D.34072 = code.265 - buf.266;
      emit_bytes (acfg, &buf, D.34072);
      i = 0;
      goto <D.26218>;
      <D.26217>:
      code = &buf;
      {
        arminstr_t * __ainstrp;

        __ainstrp = code;
        *__ainstrp = 3785408527;
        code = __ainstrp + 4;
      }
      {
        arminstr_t * __ainstrp;

        __ainstrp = code;
        *__ainstrp = 3925868544;
        code = __ainstrp + 4;
      }
      D.34078 = code + 4294967292;
      D.34079 = ~i;
      D.34080 = D.34079 * 8;
      D.34081 = (sizetype) D.34080;
      D.34082 = D.34081 + 4294967280;
      D.34083 = code + D.34082;
      arm_patch (D.34078, D.34083);
      code.265 = (int) code;
      buf.266 = (int) &buf;
      D.34072 = code.265 - buf.266;
      D.34084 = D.34072 != 8;
      D.34085 = (long int) D.34084;
      D.34086 = __builtin_expect (D.34085, 0);
      if (D.34086 != 0) goto <D.34101>; else goto <D.34102>;
      <D.34101>:
      monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "aot-compiler.c", 1117, "code - buf == 8");
      <D.34102>:
      code.265 = (int) code;
      buf.266 = (int) &buf;
      D.34072 = code.265 - buf.266;
      emit_bytes (acfg, &buf, D.34072);
      i = i + 1;
      <D.26218>:
      if (i < count) goto <D.26217>; else goto <D.26219>;
      <D.26219>:
      D.34058 = acfg->user_symbol_prefix;
      sprintf (&symbol, "%simt_trampolines_page", D.34058);
      emit_global (acfg, &symbol, 1);
      emit_label (acfg, &symbol);
      code = &buf;
      {
        arminstr_t * __ainstrp;

        __ainstrp = code;
        *__ainstrp = 3912040455;
        code = __ainstrp + 4;
      }
      D.34103 = mono_pagesize ();
      D.34104 = (unsigned int) D.34103;
      imm8 = mono_arm_is_rotated_imm8 (D.34104, &rot_amount);
      {
        arminstr_t * __ainstrp;

        __ainstrp = code;
        D.34062 = imm8 & 255;
        rot_amount.264 = rot_amount;
        D.34064 = rot_amount.264 >> 1;
        D.34065 = D.34064 & 15;
        D.34066 = D.34065 << 8;
        D.34067 = D.34062 | D.34066;
        D.34091 = D.34067 | -498286592;
        D.34092 = (unsigned int) D.34091;
        *__ainstrp = D.34092;
        code = __ainstrp + 4;
      }
      {
        arminstr_t * __ainstrp;

        __ainstrp = code;
        *__ainstrp = 3843817480;
        code = __ainstrp + 4;
      }
      loop_start = code;
      {
        arminstr_t * __ainstrp;

        __ainstrp = code;
        *__ainstrp = 3851423744;
        code = __ainstrp + 4;
      }
      {
        arminstr_t * __ainstrp;

        __ainstrp = code;
        *__ainstrp = 3780182024;
        code = __ainstrp + 4;
      }
      imt_found_check = code;
      {
        arminstr_t * __ainstrp;

        __ainstrp = code;
        *__ainstrp = 167772160;
        code = __ainstrp + 4;
      }
      {
        arminstr_t * __ainstrp;

        __ainstrp = code;
        *__ainstrp = 3813736448;
        code = __ainstrp + 4;
      }
      loop_end_check = code;
      {
        arminstr_t * __ainstrp;

        __ainstrp = code;
        *__ainstrp = 167772160;
        code = __ainstrp + 4;
      }
      {
        arminstr_t * __ainstrp;

        __ainstrp = code;
        *__ainstrp = 3800039432;
        code = __ainstrp + 4;
      }
      loop_branch_back = code;
      {
        arminstr_t * __ainstrp;

        __ainstrp = code;
        *__ainstrp = 3925868544;
        code = __ainstrp + 4;
      }
      arm_patch (loop_branch_back, loop_start);
      arm_patch (imt_found_check, code);
      {
        arminstr_t * __ainstrp;

        __ainstrp = code;
        *__ainstrp = 3851419652;
        code = __ainstrp + 4;
      }
      {
        arminstr_t * __ainstrp;

        __ainstrp = code;
        *__ainstrp = 3851419648;
        code = __ainstrp + 4;
      }
      {
        int _imm12;

        _imm12 = 8;
        {
          arminstr_t * __ainstrp;

          __ainstrp = code;
          D.34105 = ABS_EXPR <_imm12>;
          D.34106 = D.34105 | 851968;
          if (_imm12 >= 0) goto <D.34108>; else goto <D.34109>;
          <D.34108>:
          iftmp.267 = 8388608;
          goto <D.34110>;
          <D.34109>:
          iftmp.267 = 0;
          <D.34110>:
          D.34111 = D.34106 | iftmp.267;
          D.34112 = D.34111 | -452984832;
          D.34113 = (unsigned int) D.34112;
          *__ainstrp = D.34113;
          code = __ainstrp + 4;
        }
      }
      {
        arminstr_t * __ainstrp;

        __ainstrp = code;
        *__ainstrp = 3904733187;
        code = __ainstrp + 4;
      }
      arm_patch (loop_end_check, code);
      {
        arminstr_t * __ainstrp;

        __ainstrp = code;
        *__ainstrp = 3851419652;
        code = __ainstrp + 4;
      }
      {
        int _imm12;

        _imm12 = 8;
        {
          arminstr_t * __ainstrp;

          __ainstrp = code;
          D.34114 = ABS_EXPR <_imm12>;
          D.34115 = D.34114 | 851968;
          if (_imm12 >= 0) goto <D.34117>; else goto <D.34118>;
          <D.34117>:
          iftmp.268 = 8388608;
          goto <D.34119>;
          <D.34118>:
          iftmp.268 = 0;
          <D.34119>:
          D.34120 = D.34115 | iftmp.268;
          D.34121 = D.34120 | -452984832;
          D.34122 = (unsigned int) D.34121;
          *__ainstrp = D.34122;
          code = __ainstrp + 4;
        }
      }
      {
        arminstr_t * __ainstrp;

        __ainstrp = code;
        *__ainstrp = 3904733187;
        code = __ainstrp + 4;
      }
      {
        arminstr_t * __ainstrp;

        __ainstrp = code;
        *__ainstrp = 3785359360;
        code = __ainstrp + 4;
      }
      code.265 = (int) code;
      buf.266 = (int) &buf;
      D.34072 = code.265 - buf.266;
      D.34123 = D.34072 != 72;
      D.34124 = (long int) D.34123;
      D.34125 = __builtin_expect (D.34124, 0);
      if (D.34125 != 0) goto <D.34126>; else goto <D.34127>;
      <D.34126>:
      monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "aot-compiler.c", 1174, "code - buf == IMT_TRAMP_SIZE");
      <D.34127>:
      code.265 = (int) code;
      buf.266 = (int) &buf;
      D.34072 = code.265 - buf.266;
      emit_bytes (acfg, &buf, D.34072);
      i = 0;
      goto <D.26243>;
      <D.26242>:
      code = &buf;
      {
        arminstr_t * __ainstrp;

        __ainstrp = code;
        *__ainstrp = 3785408527;
        code = __ainstrp + 4;
      }
      {
        arminstr_t * __ainstrp;

        __ainstrp = code;
        *__ainstrp = 3925868544;
        code = __ainstrp + 4;
      }
      D.34078 = code + 4294967292;
      D.34079 = ~i;
      D.34080 = D.34079 * 8;
      D.34081 = (sizetype) D.34080;
      D.34128 = D.34081 + 4294967224;
      D.34129 = code + D.34128;
      arm_patch (D.34078, D.34129);
      code.265 = (int) code;
      buf.266 = (int) &buf;
      D.34072 = code.265 - buf.266;
      D.34084 = D.34072 != 8;
      D.34085 = (long int) D.34084;
      D.34086 = __builtin_expect (D.34085, 0);
      if (D.34086 != 0) goto <D.34130>; else goto <D.34131>;
      <D.34130>:
      monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "aot-compiler.c", 1182, "code - buf == 8");
      <D.34131>:
      code.265 = (int) code;
      buf.266 = (int) &buf;
      D.34072 = code.265 - buf.266;
      emit_bytes (acfg, &buf, D.34072);
      i = i + 1;
      <D.26243>:
      if (i < count) goto <D.26242>; else goto <D.26244>;
      <D.26244>:
    }
  finally
    {
      buf = {CLOBBER};
      rot_amount = {CLOBBER};
      symbol = {CLOBBER};
    }
}


emit_class_name_table (struct MonoAotCompile * acfg)
{
  struct MonoImage * D.34135;
  <unnamed-unsigned:24> D.34136;
  int D.34137;
  double D.34138;
  double D.34139;
  int D.34140;
  unsigned int D.34141;
  unsigned int D.34142;
  unsigned int table_size.269;
  int D.34144;
  int D.34145;
  struct MonoType * D.34148;
  unsigned int D.34149;
  void * * D.34150;
  unsigned int D.34151;
  void * * D.34152;
  struct ClassNameTableEntry * D.34156;
  unsigned int D.34157;
  _Bool D.34158;
  long int D.34159;
  long int D.34160;
  _Bool D.34163;
  long int D.34164;
  long int D.34165;
  unsigned int i.270;
  unsigned int D.34169;
  void * * D.34170;
  unsigned int D.34174;
  int D.34175;
  int D.34176;
  struct ClassNameTableEntry * D.34177;
  unsigned int D.34180;
  int D.34181;
  unsigned int i.271;
  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.34135 = acfg->image;
      D.34136 = D.34135->tables[2].rows;
      D.34137 = (int) D.34136;
      D.34138 = (double) D.34137;
      D.34139 = D.34138 * 1.5e+0;
      D.34140 = (int) D.34139;
      D.34141 = (unsigned int) D.34140;
      D.34142 = monoeg_g_spaced_primes_closest (D.34141);
      table_size = (int) D.34142;
      table_size.269 = (unsigned int) table_size;
      table = monoeg_g_ptr_array_sized_new (table_size.269);
      i = 0;
      goto <D.28357>;
      <D.28356>:
      monoeg_g_ptr_array_add (table, 0B);
      i = i + 1;
      <D.28357>:
      if (i < table_size) goto <D.28356>; else goto <D.28358>;
      <D.28358>:
      i = 0;
      goto <D.28364>;
      <D.28363>:
      D.34144 = i + 1;
      D.34145 = D.34144 | 33554432;
      token = (guint32) D.34145;
      D.34135 = acfg->image;
      klass = mono_class_get (D.34135, token);
      if (klass == 0B) goto <D.34146>; else goto <D.34147>;
      <D.34146>:
      mono_loader_clear_error ();
      // predicted unlikely by continue predictor.
      goto <D.28359>;
      <D.34147>:
      D.34148 = mono_class_get_type (klass);
      full_name = mono_type_get_name_full (D.34148, 2);
      D.34149 = mono_metadata_str_hash (full_name);
      table_size.269 = (unsigned int) table_size;
      hash = D.34149 % table_size.269;
      monoeg_g_free (full_name);
      new_entry = monoeg_malloc0 (12);
      new_entry->token = token;
      D.34150 = table->pdata;
      D.34151 = hash * 4;
      D.34152 = D.34150 + D.34151;
      entry = *D.34152;
      if (entry == 0B) goto <D.34153>; else goto <D.34154>;
      <D.34153>:
      new_entry->index = hash;
      D.34150 = table->pdata;
      D.34151 = hash * 4;
      D.34152 = D.34150 + D.34151;
      *D.34152 = new_entry;
      goto <D.34155>;
      <D.34154>:
      goto <D.28361>;
      <D.28360>:
      entry = entry->next;
      <D.28361>:
      D.34156 = entry->next;
      if (D.34156 != 0B) goto <D.28360>; else goto <D.28362>;
      <D.28362>:
      entry->next = new_entry;
      D.34157 = table->len;
      new_entry->index = D.34157;
      monoeg_g_ptr_array_add (table, new_entry);
      <D.34155>:
      <D.28359>:
      i = i + 1;
      <D.28364>:
      D.34135 = acfg->image;
      D.34136 = D.34135->tables[2].rows;
      D.34137 = (int) D.34136;
      if (D.34137 > i) goto <D.28363>; else goto <D.28365>;
      <D.28365>:
      sprintf (&symbol, "class_name_table");
      emit_section_change (acfg, ".rodata", 0);
      emit_alignment (acfg, 8);
      emit_label (acfg, &symbol);
      D.34158 = table_size > 64999;
      D.34159 = (long int) D.34158;
      D.34160 = __builtin_expect (D.34159, 0);
      if (D.34160 != 0) goto <D.34161>; else goto <D.34162>;
      <D.34161>:
      monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "aot-compiler.c", 7744, "table_size < 65000");
      <D.34162>:
      emit_int16 (acfg, table_size);
      D.34157 = table->len;
      D.34163 = D.34157 > 64999;
      D.34164 = (long int) D.34163;
      D.34165 = __builtin_expect (D.34164, 0);
      if (D.34165 != 0) goto <D.34166>; else goto <D.34167>;
      <D.34166>:
      monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "aot-compiler.c", 7746, "table->len < 65000");
      <D.34167>:
      i = 0;
      goto <D.28368>;
      <D.28367>:
      {
        struct ClassNameTableEntry * entry;

        D.34150 = table->pdata;
        i.270 = (unsigned int) i;
        D.34169 = i.270 * 4;
        D.34170 = D.34150 + D.34169;
        entry = *D.34170;
        if (entry == 0B) goto <D.34171>; else goto <D.34172>;
        <D.34171>:
        emit_int16 (acfg, 0);
        emit_int16 (acfg, 0);
        goto <D.34173>;
        <D.34172>:
        D.34174 = entry->token;
        D.34175 = (int) D.34174;
        D.34176 = D.34175 & 16777215;
        emit_int16 (acfg, D.34176);
        D.34177 = entry->next;
        if (D.34177 != 0B) goto <D.34178>; else goto <D.34179>;
        <D.34178>:
        D.34177 = entry->next;
        D.34180 = D.34177->index;
        D.34181 = (int) D.34180;
        emit_int16 (acfg, D.34181);
        goto <D.34182>;
        <D.34179>:
        emit_int16 (acfg, 0);
        <D.34182>:
        <D.34173>:
      }
      i = i + 1;
      <D.28368>:
      i.271 = (unsigned int) i;
      D.34157 = table->len;
      if (i.271 < D.34157) goto <D.28367>; else goto <D.28369>;
      <D.28369>:
    }
  finally
    {
      symbol = {CLOBBER};
    }
}


emit_got_info (struct MonoAotCompile * acfg)
{
  unsigned int D.34184;
  struct GPtrArray * D.34185;
  unsigned int D.34186;
  struct GHashTable * D.34187;
  const void * i.272;
  struct MonoJumpInfo * D.34189;
  <unnamed type> D.34190;
  int D.34191;
  int D.34192;
  unsigned int i.273;
  unsigned int D.34194;
  unsigned int D.34195;
  unsigned int D.34196;
  struct MonoMemPool * D.34197;
  unsigned int buf_size.274;
  unsigned int D.34199;
  unsigned int D.34200;
  void * D.34201;
  guint32 * D.34204;
  void * * D.34205;
  unsigned int i.275;
  unsigned int D.34207;
  void * * D.34208;
  <unnamed type> D.34209;
  int D.34210;
  guint8 * p.276;
  int D.34212;
  int p.277;
  int p2.278;
  int D.34215;
  int D.34216;
  int buf.279;
  int D.34218;
  _Bool D.34219;
  long int D.34220;
  long int D.34221;
  guint32 * D.34224;
  unsigned int D.34225;
  unsigned int D.34226;
  int D.34229;
  sizetype D.34230;
  sizetype D.34231;
  sizetype D.34232;
  guint32 * D.34233;
  unsigned int D.34234;
  int D.34235;
  int D.34236;
  unsigned int i.280;
  unsigned int D.34238;
  int D.34239;
  unsigned int D.34240;
  unsigned int D.34241;
  int D.34242;
  char symbol[256];
  int i;
  int first_plt_got_patch;
  int buf_size;
  guint8 * p;
  guint8 * buf;
  guint32 * got_info_offsets;

  try
    {
      D.34184 = acfg->got_offset;
      acfg->plt_got_offset_base = D.34184;
      D.34185 = acfg->got_patches;
      D.34186 = D.34185->len;
      first_plt_got_patch = (int) D.34186;
      i = 1;
      goto <D.28392>;
      <D.28391>:
      {
        struct MonoPltEntry * plt_entry;

        D.34187 = acfg->plt_offset_to_entry;
        i.272 = (const void *) i;
        plt_entry = monoeg_g_hash_table_lookup (D.34187, i.272);
        D.34185 = acfg->got_patches;
        D.34189 = plt_entry->ji;
        monoeg_g_ptr_array_add (D.34185, D.34189);
        D.34189 = plt_entry->ji;
        D.34190 = D.34189->type;
        D.34191 = acfg->stats.got_slot_types[D.34190];
        D.34192 = D.34191 + 1;
        acfg->stats.got_slot_types[D.34190] = D.34192;
      }
      i = i + 1;
      <D.28392>:
      i.273 = (unsigned int) i;
      D.34194 = acfg->plt_offset;
      if (i.273 < D.34194) goto <D.28391>; else goto <D.28393>;
      <D.28393>:
      D.34184 = acfg->got_offset;
      D.34194 = acfg->plt_offset;
      D.34195 = D.34184 + D.34194;
      acfg->got_offset = D.34195;
      D.34185 = acfg->got_patches;
      D.34186 = D.34185->len;
      D.34196 = D.34186 * 128;
      buf_size = (int) D.34196;
      D.34197 = acfg->mempool;
      buf_size.274 = (unsigned int) buf_size;
      buf = mono_mempool_alloc (D.34197, buf_size.274);
      p = buf;
      D.34197 = acfg->mempool;
      D.34185 = acfg->got_patches;
      D.34186 = D.34185->len;
      D.34199 = D.34186 * 4;
      got_info_offsets = mono_mempool_alloc (D.34197, D.34199);
      D.34197 = acfg->mempool;
      D.34194 = acfg->plt_offset;
      D.34200 = D.34194 * 4;
      D.34201 = mono_mempool_alloc (D.34197, D.34200);
      acfg->plt_got_info_offsets = D.34201;
      D.34194 = acfg->plt_offset;
      if (D.34194 != 0) goto <D.34202>; else goto <D.34203>;
      <D.34202>:
      D.34204 = acfg->plt_got_info_offsets;
      *D.34204 = 0;
      <D.34203>:
      i = 0;
      goto <D.28397>;
      <D.28396>:
      {
        struct MonoJumpInfo * ji;
        guint8 * p2;

        D.34185 = acfg->got_patches;
        D.34205 = D.34185->pdata;
        i.275 = (unsigned int) i;
        D.34207 = i.275 * 4;
        D.34208 = D.34205 + D.34207;
        ji = *D.34208;
        p = buf;
        D.34209 = ji->type;
        D.34210 = (int) D.34209;
        p.276 = p;
        encode_value (D.34210, p.276, &p);
        p2 = p;
        p.276 = p;
        encode_patch (acfg, ji, p.276, &p);
        D.34209 = ji->type;
        D.34209 = ji->type;
        D.34212 = acfg->stats.got_slot_info_sizes[D.34209];
        p.276 = p;
        p.277 = (int) p.276;
        p2.278 = (int) p2;
        D.34215 = p.277 - p2.278;
        D.34216 = D.34212 + D.34215;
        acfg->stats.got_slot_info_sizes[D.34209] = D.34216;
        p.276 = p;
        p.277 = (int) p.276;
        buf.279 = (int) buf;
        D.34218 = p.277 - buf.279;
        D.34219 = D.34218 > buf_size;
        D.34220 = (long int) D.34219;
        D.34221 = __builtin_expect (D.34220, 0);
        if (D.34221 != 0) goto <D.34222>; else goto <D.34223>;
        <D.34222>:
        monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "aot-compiler.c", 7851, "p - buf <= buf_size");
        <D.34223>:
        i.275 = (unsigned int) i;
        D.34207 = i.275 * 4;
        D.34224 = got_info_offsets + D.34207;
        p.276 = p;
        p.277 = (int) p.276;
        buf.279 = (int) buf;
        D.34218 = p.277 - buf.279;
        D.34225 = (unsigned int) D.34218;
        D.34226 = add_to_blob (acfg, buf, D.34225);
        *D.34224 = D.34226;
        if (i >= first_plt_got_patch) goto <D.34227>; else goto <D.34228>;
        <D.34227>:
        D.34204 = acfg->plt_got_info_offsets;
        D.34229 = i - first_plt_got_patch;
        D.34230 = (sizetype) D.34229;
        D.34231 = D.34230 + 1;
        D.34232 = D.34231 * 4;
        D.34233 = D.34204 + D.34232;
        i.275 = (unsigned int) i;
        D.34207 = i.275 * 4;
        D.34224 = got_info_offsets + D.34207;
        D.34234 = *D.34224;
        *D.34233 = D.34234;
        <D.34228>:
        D.34235 = acfg->stats.got_info_size;
        p.276 = p;
        p.277 = (int) p.276;
        buf.279 = (int) buf;
        D.34218 = p.277 - buf.279;
        D.34236 = D.34235 + D.34218;
        acfg->stats.got_info_size = D.34236;
      }
      i = i + 1;
      <D.28397>:
      i.280 = (unsigned int) i;
      D.34185 = acfg->got_patches;
      D.34186 = D.34185->len;
      if (i.280 < D.34186) goto <D.28396>; else goto <D.28398>;
      <D.28398>:
      sprintf (&symbol, "got_info_offsets");
      emit_section_change (acfg, ".rodata", 1);
      emit_alignment (acfg, 8);
      emit_label (acfg, &symbol);
      D.34238 = emit_offset_table (acfg, first_plt_got_patch, 10, got_info_offsets);
      D.34239 = acfg->stats.offsets_size;
      D.34240 = (unsigned int) D.34239;
      D.34241 = D.34240 + D.34238;
      D.34242 = (int) D.34241;
      acfg->stats.offsets_size = D.34242;
    }
  finally
    {
      symbol = {CLOBBER};
      p = {CLOBBER};
    }
}


encode_patch (struct MonoAotCompile * acfg, struct MonoJumpInfo * patch_info, guint8 * buf, guint8 * * endbuf)
{
  <unnamed type> D.34243;
  struct MonoImage * D.34244;
  unsigned int D.34245;
  int D.34246;
  guint8 * p.281;
  int D.34248;
  struct MonoJumpInfoBBTable * D.34249;
  int D.34250;
  unsigned int k.282;
  unsigned int D.34252;
  void * * D.34253;
  void * D.34254;
  int D.34255;
  struct MonoMethod * D.34256;
  const char * D.34257;
  int len.283;
  guint8 * p.284;
  guint8 * p.285;
  guint8 * p.286;
  struct MonoJumpInfoToken * D.34262;
  struct MonoImage * D.34263;
  unsigned int D.34264;
  _Bool D.34265;
  long int D.34266;
  long int D.34267;
  int image_index.287;
  unsigned int D.34271;
  unsigned int D.34272;
  int D.34273;
  unsigned int D.34274;
  int D.34275;
  int D.34276;
  int D.34277;
  struct MonoGenericContext * D.34280;
  struct MonoClass * D.34281;
  struct MonoImage * D.34282;
  const void * D.34283;
  _Bool D.34284;
  long int D.34285;
  long int D.34286;
  unsigned int D.34289;
  int D.34290;
  guint32 * D.34291;
  unsigned int D.34292;
  int D.34293;
  struct MonoClass * D.34294;
  struct MonoClassField * D.34295;
  struct GHashTable * D.34296;
  struct MonoMethod * D.34297;
  void * D.34298;
  guint8 * p2.288;
  int p2.289;
  int buf2.290;
  int D.34304;
  _Bool D.34305;
  long int D.34306;
  long int D.34307;
  unsigned int D.34310;
  unsigned int D.34311;
  void * D.34312;
  int offset.291;
  <unnamed type> D.34315;
  int D.34316;
  _Bool D.34317;
  long int D.34318;
  long int D.34319;
  struct MonoJumpInfo * D.34322;
  <unnamed type> D.34323;
  _Bool D.34324;
  long int D.34325;
  long int D.34326;
  unsigned int iftmp.292;
  int D.34330;
  unsigned int D.34334;
  unsigned int D.34335;
  unsigned int D.34336;
  unsigned int D.34337;
  int D.34338;
  struct MonoJumpInfoImtTramp * D.34339;
  struct MonoMethod * D.34340;
  int D.34341;
  int D.34342;
  struct MonoJumpInfoGSharedVtCall * D.34343;
  struct MonoMethodSignature * D.34344;
  struct MonoMethod * D.34345;
  struct MonoMethod * D.34346;
  struct GPtrArray * D.34347;
  unsigned int D.34348;
  int D.34349;
  void * * D.34350;
  unsigned int i.293;
  unsigned int D.34352;
  void * * D.34353;
  <unnamed type> D.34354;
  int D.34355;
  <unnamed type> D.34356;
  void * D.34357;
  struct MonoClass * D.34358;
  unsigned int i.294;
  guint8 * p;

  try
    {
      p = buf;
      D.34243 = patch_info->type;
      switch (D.34243) <default: <D.27555>, case 3: <D.27503>, case 4: <D.27504>, case 5: <D.27495>, case 6: <D.27502>, case 7: <D.27508>, case 8: <D.27496>, case 10: <D.27518>, case 11: <D.27523>, case 12: <D.27490>, case 13: <D.27528>, case 14: <D.27522>, case 15: <D.27526>, case 16: <D.27529>, case 17: <D.27511>, case 18: <D.27516>, case 19: <D.27517>, case 20: <D.27520>, case 21: <D.27521>, case 23: <D.27524>, case 24: <D.27525>, case 28: <D.27515>, case 29: <D.27514>, case 30: <D.27527>, case 31: <D.27505>, case 32: <D.27509>, case 33: <D.27530>, case 34: <D.27506>, case 35: <D.27531>, case 36: <D.27536>, case 37: <D.27537>, case 38: <D.27538>, case 39: <D.27491>, case 40: <D.27539>, case 41: <D.27540>, case 42: <D.27493>, case 43: <D.27494>, case 44: <D.27541>, case 45: <D.27543>, case 46: <D.27544>, case 47: <D.27492>, case 48: <D.27542>, case 50: <D.27507>, case 51: <D.27488>>
      <D.27488>:
      goto <D.27489>;
      <D.27490>:
      D.34244 = patch_info->data.image;
      D.34245 = get_image_index (acfg, D.34244);
      D.34246 = (int) D.34245;
      p.281 = p;
      encode_value (D.34246, p.281, &p);
      goto <D.27489>;
      <D.27491>:
      <D.27492>:
      <D.27493>:
      <D.27494>:
      goto <D.27489>;
      <D.27495>:
      D.34248 = patch_info->data.offset;
      p.281 = p;
      encode_value (D.34248, p.281, &p);
      goto <D.27489>;
      <D.27496>:
      {
        void * * table;
        int k;

        D.34249 = patch_info->data.table;
        table = D.34249->table;
        D.34249 = patch_info->data.table;
        D.34250 = D.34249->table_size;
        p.281 = p;
        encode_value (D.34250, p.281, &p);
        k = 0;
        goto <D.27500>;
        <D.27499>:
        k.282 = (unsigned int) k;
        D.34252 = k.282 * 4;
        D.34253 = table + D.34252;
        D.34254 = *D.34253;
        D.34255 = (int) D.34254;
        p.281 = p;
        encode_value (D.34255, p.281, &p);
        k = k + 1;
        <D.27500>:
        D.34249 = patch_info->data.table;
        D.34250 = D.34249->table_size;
        if (D.34250 > k) goto <D.27499>; else goto <D.27501>;
        <D.27501>:
        goto <D.27489>;
      }
      <D.27502>:
      <D.27503>:
      <D.27504>:
      <D.27505>:
      <D.27506>:
      <D.27507>:
      D.34256 = patch_info->data.method;
      p.281 = p;
      encode_method_ref (acfg, D.34256, p.281, &p);
      goto <D.27489>;
      <D.27508>:
      <D.27509>:
      {
        guint32 len;

        D.34257 = patch_info->data.name;
        len = strlen (D.34257);
        len.283 = (int) len;
        p.281 = p;
        encode_value (len.283, p.281, &p);
        p.281 = p;
        D.34257 = patch_info->data.name;
        memcpy (p.281, D.34257, len);
        p.281 = p;
        p.284 = p.281 + len;
        p = p.284;
        p.281 = p;
        p.285 = p.281;
        p.286 = p.285 + 1;
        p = p.286;
        *p.285 = 0;
        goto <D.27489>;
      }
      <D.27511>:
      {
        guint32 image_index;
        guint32 token;

        D.34262 = patch_info->data.token;
        D.34263 = D.34262->image;
        image_index = get_image_index (acfg, D.34263);
        D.34262 = patch_info->data.token;
        token = D.34262->token;
        D.34264 = token & 4278190080;
        D.34265 = D.34264 != 1879048192;
        D.34266 = (long int) D.34265;
        D.34267 = __builtin_expect (D.34266, 0);
        if (D.34267 != 0) goto <D.34268>; else goto <D.34269>;
        <D.34268>:
        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.34269>:
        image_index.287 = (int) image_index;
        p.281 = p;
        encode_value (image_index.287, p.281, &p);
        D.34262 = patch_info->data.token;
        D.34271 = D.34262->token;
        D.34272 = D.34271 + 2415919104;
        D.34273 = (int) D.34272;
        p.281 = p;
        encode_value (D.34273, p.281, &p);
        goto <D.27489>;
      }
      <D.27514>:
      <D.27515>:
      <D.27516>:
      <D.27517>:
      D.34262 = patch_info->data.token;
      D.34263 = D.34262->image;
      D.34274 = get_image_index (acfg, D.34263);
      D.34275 = (int) D.34274;
      p.281 = p;
      encode_value (D.34275, p.281, &p);
      D.34262 = patch_info->data.token;
      D.34271 = D.34262->token;
      D.34276 = (int) D.34271;
      p.281 = p;
      encode_value (D.34276, p.281, &p);
      D.34262 = patch_info->data.token;
      D.34277 = D.34262->has_context;
      p.281 = p;
      encode_value (D.34277, p.281, &p);
      D.34262 = patch_info->data.token;
      D.34277 = D.34262->has_context;
      if (D.34277 != 0) goto <D.34278>; else goto <D.34279>;
      <D.34278>:
      D.34262 = patch_info->data.token;
      D.34280 = &D.34262->context;
      p.281 = p;
      encode_generic_context (acfg, D.34280, p.281, &p);
      <D.34279>:
      goto <D.27489>;
      <D.27518>:
      {
        struct MonoClass * ex_class;

        D.34281 = mono_defaults.exception_class;
        D.34282 = D.34281->image;
        D.34283 = patch_info->data.target;
        ex_class = mono_class_from_name (D.34282, "System", D.34283);
        D.34284 = ex_class == 0B;
        D.34285 = (long int) D.34284;
        D.34286 = __builtin_expect (D.34285, 0);
        if (D.34286 != 0) goto <D.34287>; else goto <D.34288>;
        <D.34287>:
        monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "aot-compiler.c", 4948, "ex_class");
        <D.34288>:
        p.281 = p;
        encode_klass_ref (acfg, ex_class, p.281, &p);
        goto <D.27489>;
      }
      <D.27520>:
      D.34283 = patch_info->data.target;
      D.34289 = MEM[(guint32 *)D.34283];
      D.34290 = (int) D.34289;
      p.281 = p;
      encode_value (D.34290, p.281, &p);
      goto <D.27489>;
      <D.27521>:
      D.34283 = patch_info->data.target;
      D.34289 = MEM[(guint32 *)D.34283];
      D.34290 = (int) D.34289;
      p.281 = p;
      encode_value (D.34290, p.281, &p);
      D.34283 = patch_info->data.target;
      D.34291 = D.34283 + 4;
      D.34292 = *D.34291;
      D.34293 = (int) D.34292;
      p.281 = p;
      encode_value (D.34293, p.281, &p);
      goto <D.27489>;
      <D.27522>:
      <D.27523>:
      <D.27524>:
      <D.27525>:
      D.34294 = patch_info->data.klass;
      p.281 = p;
      encode_klass_ref (acfg, D.34294, p.281, &p);
      goto <D.27489>;
      <D.27526>:
      <D.27527>:
      D.34294 = patch_info->data.klass;
      p.281 = p;
      encode_klass_ref (acfg, D.34294, p.281, &p);
      goto <D.27489>;
      <D.27528>:
      <D.27529>:
      D.34295 = patch_info->data.field;
      p.281 = p;
      encode_field_info (acfg, D.34295, p.281, &p);
      goto <D.27489>;
      <D.27530>:
      goto <D.27489>;
      <D.27531>:
      {
        struct MonoJumpInfoRgctxEntry * entry;
        guint32 offset;
        guint8 * buf2;
        guint8 * p2;

        try
          {
            entry = patch_info->data.rgctx_entry;
            D.34296 = acfg->method_blob_hash;
            D.34297 = entry->method;
            D.34298 = monoeg_g_hash_table_lookup (D.34296, D.34297);
            offset = (guint32) D.34298;
            if (offset == 0) goto <D.34299>; else goto <D.34300>;
            <D.34299>:
            buf2 = monoeg_malloc (1024);
            p2 = buf2;
            D.34297 = entry->method;
            p2.288 = p2;
            encode_method_ref (acfg, D.34297, p2.288, &p2);
            p2.288 = p2;
            p2.289 = (int) p2.288;
            buf2.290 = (int) buf2;
            D.34304 = p2.289 - buf2.290;
            D.34305 = D.34304 > 1023;
            D.34306 = (long int) D.34305;
            D.34307 = __builtin_expect (D.34306, 0);
            if (D.34307 != 0) goto <D.34308>; else goto <D.34309>;
            <D.34308>:
            monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "aot-compiler.c", 4990, "p2 - buf2 < 1024");
            <D.34309>:
            p2.288 = p2;
            p2.289 = (int) p2.288;
            buf2.290 = (int) buf2;
            D.34304 = p2.289 - buf2.290;
            D.34310 = (unsigned int) D.34304;
            offset = add_to_blob (acfg, buf2, D.34310);
            monoeg_g_free (buf2);
            D.34296 = acfg->method_blob_hash;
            D.34297 = entry->method;
            D.34311 = offset + 1;
            D.34312 = (void *) D.34311;
            monoeg_g_hash_table_insert_replace (D.34296, D.34297, D.34312, 0);
            goto <D.34313>;
            <D.34300>:
            offset = offset + 4294967295;
            <D.34313>:
            offset.291 = (int) offset;
            p.281 = p;
            encode_value (offset.291, p.281, &p);
            D.34315 = entry->info_type;
            D.34316 = (int) D.34315;
            D.34317 = D.34316 > 255;
            D.34318 = (long int) D.34317;
            D.34319 = __builtin_expect (D.34318, 0);
            if (D.34319 != 0) goto <D.34320>; else goto <D.34321>;
            <D.34320>:
            monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "aot-compiler.c", 5001, "(int)entry->info_type < 256");
            <D.34321>:
            D.34322 = entry->data;
            D.34323 = D.34322->type;
            D.34324 = D.34323 > 255;
            D.34325 = (long int) D.34324;
            D.34326 = __builtin_expect (D.34325, 0);
            if (D.34326 != 0) goto <D.34327>; else goto <D.34328>;
            <D.34327>:
            monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "aot-compiler.c", 5002, "entry->data->type < 256");
            <D.34328>:
            D.34330 = entry->in_mrgctx;
            if (D.34330 != 0) goto <D.34331>; else goto <D.34332>;
            <D.34331>:
            iftmp.292 = 1;
            goto <D.34333>;
            <D.34332>:
            iftmp.292 = 0;
            <D.34333>:
            D.34315 = entry->info_type;
            D.34334 = D.34315 << 1;
            D.34335 = iftmp.292 | D.34334;
            D.34322 = entry->data;
            D.34323 = D.34322->type;
            D.34336 = D.34323 << 9;
            D.34337 = D.34335 | D.34336;
            D.34338 = (int) D.34337;
            p.281 = p;
            encode_value (D.34338, p.281, &p);
            D.34322 = entry->data;
            p.281 = p;
            encode_patch (acfg, D.34322, p.281, &p);
            goto <D.27489>;
          }
        finally
          {
            p2 = {CLOBBER};
          }
      }
      <D.27536>:
      <D.27537>:
      <D.27538>:
      <D.27539>:
      goto <D.27489>;
      <D.27540>:
      D.34339 = patch_info->data.imt_tramp;
      D.34340 = D.34339->method;
      p.281 = p;
      encode_method_ref (acfg, D.34340, p.281, &p);
      D.34339 = patch_info->data.imt_tramp;
      D.34341 = D.34339->vt_offset;
      p.281 = p;
      encode_value (D.34341, p.281, &p);
      goto <D.27489>;
      <D.27541>:
      D.34283 = patch_info->data.target;
      p.281 = p;
      encode_signature (acfg, D.34283, p.281, &p);
      goto <D.27489>;
      <D.27542>:
      D.34283 = patch_info->data.target;
      D.34342 = (int) D.34283;
      p.281 = p;
      encode_value (D.34342, p.281, &p);
      goto <D.27489>;
      <D.27543>:
      D.34343 = patch_info->data.gsharedvt;
      D.34344 = D.34343->sig;
      p.281 = p;
      encode_signature (acfg, D.34344, p.281, &p);
      D.34343 = patch_info->data.gsharedvt;
      D.34345 = D.34343->method;
      p.281 = p;
      encode_method_ref (acfg, D.34345, p.281, &p);
      goto <D.27489>;
      <D.27544>:
      {
        struct MonoGSharedVtMethodInfo * info;
        int i;

        info = patch_info->data.gsharedvt_method;
        D.34346 = info->method;
        p.281 = p;
        encode_method_ref (acfg, D.34346, p.281, &p);
        D.34347 = info->entries;
        D.34348 = D.34347->len;
        D.34349 = (int) D.34348;
        p.281 = p;
        encode_value (D.34349, p.281, &p);
        i = 0;
        goto <D.27553>;
        <D.27552>:
        {
          struct MonoRuntimeGenericContextInfoTemplate * template;

          D.34347 = info->entries;
          D.34350 = D.34347->pdata;
          i.293 = (unsigned int) i;
          D.34352 = i.293 * 4;
          D.34353 = D.34350 + D.34352;
          template = *D.34353;
          D.34354 = template->info_type;
          D.34355 = (int) D.34354;
          p.281 = p;
          encode_value (D.34355, p.281, &p);
          D.34354 = template->info_type;
          D.34356 = mini_rgctx_info_type_to_patch_info_type (D.34354);
          switch (D.34356) <default: <D.27551>, case 11: <D.27548>, case 13: <D.27550>>
          <D.27548>:
          D.34357 = template->data;
          D.34358 = mono_class_from_mono_type (D.34357);
          p.281 = p;
          encode_klass_ref (acfg, D.34358, p.281, &p);
          goto <D.27549>;
          <D.27550>:
          D.34357 = template->data;
          p.281 = p;
          encode_field_info (acfg, D.34357, p.281, &p);
          goto <D.27549>;
          <D.27551>:
          monoeg_assertion_message ("* Assertion: should not be reached at %s:%d\n", "aot-compiler.c", 5044);
          <D.27549>:
        }
        i = i + 1;
        <D.27553>:
        i.294 = (unsigned int) i;
        D.34347 = info->entries;
        D.34348 = D.34347->len;
        if (i.294 < D.34348) goto <D.27552>; else goto <D.27554>;
        <D.27554>:
        goto <D.27489>;
      }
      <D.27555>:
      D.34243 = patch_info->type;
      monoeg_g_log (0B, 16, "unable to handle jump info %d", D.34243);
      monoeg_assertion_message ("* Assertion: should not be reached at %s:%d\n", "aot-compiler.c", 5052);
      <D.27489>:
      p.281 = p;
      *endbuf = p.281;
    }
  finally
    {
      p = {CLOBBER};
    }
}


encode_field_info (struct MonoAotCompile * cfg, struct MonoClassField * field, guint8 * buf, guint8 * * endbuf)
{
  struct MonoClass * D.34362;
  guint8 * p.295;
  unsigned int D.34364;
  _Bool D.34365;
  long int D.34366;
  long int D.34367;
  unsigned int D.34370;
  int D.34371;
  guint32 token;
  guint8 * p;

  try
    {
      token = mono_get_field_token (field);
      p = buf;
      D.34362 = field->parent;
      p.295 = p;
      encode_klass_ref (cfg, D.34362, p.295, &p);
      D.34364 = token & 4278190080;
      D.34365 = D.34364 != 67108864;
      D.34366 = (long int) D.34365;
      D.34367 = __builtin_expect (D.34366, 0);
      if (D.34367 != 0) goto <D.34368>; else goto <D.34369>;
      <D.34368>:
      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.34369>:
      D.34370 = token + 4227858432;
      D.34371 = (int) D.34370;
      p.295 = p;
      encode_value (D.34371, p.295, &p);
      p.295 = p;
      *endbuf = p.295;
    }
  finally
    {
      p = {CLOBBER};
    }
}


mono_get_field_token (struct MonoClassField * field)
{
  struct MonoClassField * D.34372;
  unsigned int i.296;
  unsigned int D.34374;
  struct MonoClassField * D.34375;
  guint32 D.34378;
  unsigned int D.34379;
  unsigned int i.297;
  unsigned int D.34381;
  unsigned int D.34382;
  unsigned int D.34383;
  struct MonoClass * klass;
  int i;

  klass = field->parent;
  i = 0;
  goto <D.26330>;
  <D.26329>:
  D.34372 = klass->fields;
  i.296 = (unsigned int) i;
  D.34374 = i.296 * 16;
  D.34375 = D.34372 + D.34374;
  if (D.34375 == field) goto <D.34376>; else goto <D.34377>;
  <D.34376>:
  D.34379 = klass->field.first;
  i.297 = (unsigned int) i;
  D.34381 = D.34379 + i.297;
  D.34382 = D.34381 + 1;
  D.34378 = D.34382 | 67108864;
  return D.34378;
  <D.34377>:
  i = i + 1;
  <D.26330>:
  i.297 = (unsigned int) i;
  D.34383 = klass->field.count;
  if (i.297 < D.34383) goto <D.26329>; else goto <D.26331>;
  <D.26331>:
  monoeg_assertion_message ("* Assertion: should not be reached at %s:%d\n", "aot-compiler.c", 2035);
  D.34378 = 0;
  return D.34378;
}


emit_exception_info (struct MonoAotCompile * acfg)
{
  unsigned int D.34385;
  unsigned int D.34386;
  struct MonoCompile * * D.34387;
  unsigned int i.298;
  unsigned int D.34389;
  struct MonoCompile * * D.34390;
  struct MonoCompile * D.34391;
  gint32 * D.34394;
  unsigned int D.34395;
  int D.34396;
  unsigned int i.299;
  int D.34399;
  unsigned int D.34400;
  int D.34401;
  unsigned int D.34402;
  unsigned int D.34403;
  int D.34404;
  int i;
  char symbol[256];
  gint32 * offsets;

  try
    {
      D.34385 = acfg->nmethods;
      D.34386 = D.34385 * 4;
      offsets = monoeg_malloc0 (D.34386);
      i = 0;
      goto <D.28314>;
      <D.28313>:
      D.34387 = acfg->cfgs;
      i.298 = (unsigned int) i;
      D.34389 = i.298 * 4;
      D.34390 = D.34387 + D.34389;
      D.34391 = *D.34390;
      if (D.34391 != 0B) goto <D.34392>; else goto <D.34393>;
      <D.34392>:
      D.34387 = acfg->cfgs;
      i.298 = (unsigned int) i;
      D.34389 = i.298 * 4;
      D.34390 = D.34387 + D.34389;
      D.34391 = *D.34390;
      emit_exception_debug_info (acfg, D.34391);
      i.298 = (unsigned int) i;
      D.34389 = i.298 * 4;
      D.34394 = offsets + D.34389;
      D.34387 = acfg->cfgs;
      i.298 = (unsigned int) i;
      D.34389 = i.298 * 4;
      D.34390 = D.34387 + D.34389;
      D.34391 = *D.34390;
      D.34395 = D.34391->ex_info_offset;
      D.34396 = (int) D.34395;
      *D.34394 = D.34396;
      goto <D.34397>;
      <D.34393>:
      i.298 = (unsigned int) i;
      D.34389 = i.298 * 4;
      D.34394 = offsets + D.34389;
      *D.34394 = 0;
      <D.34397>:
      i = i + 1;
      <D.28314>:
      i.299 = (unsigned int) i;
      D.34385 = acfg->nmethods;
      if (i.299 < D.34385) goto <D.28313>; else goto <D.28315>;
      <D.28315>:
      sprintf (&symbol, "ex_info_offsets");
      emit_section_change (acfg, ".rodata", 1);
      emit_alignment (acfg, 8);
      emit_label (acfg, &symbol);
      D.34385 = acfg->nmethods;
      D.34399 = (int) D.34385;
      D.34400 = emit_offset_table (acfg, D.34399, 10, offsets);
      D.34401 = acfg->stats.offsets_size;
      D.34402 = (unsigned int) D.34401;
      D.34403 = D.34402 + D.34400;
      D.34404 = (int) D.34403;
      acfg->stats.offsets_size = D.34404;
      monoeg_g_free (offsets);
    }
  finally
    {
      symbol = {CLOBBER};
    }
}


emit_exception_debug_info (struct MonoAotCompile * acfg, struct MonoCompile * cfg)
{
  unsigned int D.34405;
  int D.34406;
  <unnamed-unsigned:15> D.34410;
  int D.34411;
  int D.34412;
  unsigned int D.34413;
  unsigned int debug_info_size.300;
  unsigned int D.34415;
  guint32 iftmp.301;
  int D.34419;
  int D.34420;
  unsigned int D.34422;
  unsigned int D.34423;
  unsigned int D.34424;
  unsigned int D.34425;
  unsigned int buf_size.302;
  struct GSList * D.34427;
  _Bool D.34428;
  unsigned char D.34429;
  unsigned char D.34430;
  _Bool D.34431;
  int D.34432;
  int iftmp.303;
  int D.34437;
  int iftmp.304;
  short unsigned int D.34439;
  short unsigned int D.34440;
  int D.34444;
  int iftmp.305;
  int D.34449;
  int iftmp.306;
  unsigned char D.34451;
  unsigned char D.34452;
  int D.34456;
  int iftmp.307;
  unsigned char D.34458;
  int D.34462;
  int iftmp.308;
  guint8 * D.34464;
  int D.34468;
  int iftmp.309;
  unsigned char D.34470;
  int D.34474;
  int flags.310;
  guint8 * p.311;
  unsigned int encoded_len.312;
  unsigned int D.34480;
  int D.34481;
  unsigned int D.34483;
  int D.34484;
  short unsigned int D.34487;
  int D.34488;
  int D.34493;
  struct MonoExceptionClause * D.34494;
  unsigned int k.313;
  unsigned int D.34496;
  unsigned int D.34497;
  int D.34498;
  struct MonoClass * D.34499;
  unsigned int cindex1.314;
  unsigned int D.34504;
  unsigned int cindex2.315;
  unsigned int D.34506;
  unsigned int D.34509;
  unsigned int D.34510;
  unsigned int D.34513;
  unsigned int D.34514;
  short unsigned int D.34518;
  short unsigned int D.34519;
  <unnamed-unsigned:15> D.34522;
  int D.34523;
  unsigned int D.34524;
  int D.34525;
  int D.34526;
  unsigned int D.34527;
  void * D.34530;
  int D.34531;
  int code.316;
  int D.34533;
  struct MonoClass * D.34535;
  guint8 * p2.317;
  int p2.318;
  int buf2.319;
  _Bool D.34541;
  long int D.34542;
  long int D.34543;
  unsigned int len.320;
  int D.34547;
  sizetype D.34548;
  guint8 * p.321;
  void * D.34551;
  int D.34552;
  int D.34553;
  void * D.34554;
  int D.34555;
  int D.34556;
  void * D.34557;
  int D.34558;
  int D.34559;
  int D.34560;
  short unsigned int D.34563;
  int D.34564;
  short unsigned int D.34565;
  int D.34566;
  unsigned int D.34567;
  int D.34568;
  short unsigned int D.34569;
  int D.34570;
  unsigned int D.34573;
  int D.34574;
  int D.34577;
  struct MonoDwarfLocListEntry * D.34580;
  unsigned int i.322;
  unsigned int D.34582;
  int D.34583;
  _Bool D.34584;
  int D.34585;
  int D.34586;
  int D.34589;
  int D.34592;
  _Bool D.34593;
  long int D.34594;
  long int D.34595;
  int D.34599;
  unsigned char D.34603;
  unsigned char D.34604;
  _Bool D.34605;
  int D.34606;
  unsigned char D.34607;
  int D.34608;
  int D.34609;
  struct MonoMethod * D.34610;
  guint8 * p2.323;
  int p2.324;
  int buf2.325;
  _Bool D.34614;
  long int D.34615;
  long int D.34616;
  unsigned int len.326;
  int D.34620;
  sizetype D.34621;
  guint8 * p.327;
  gboolean * D.34627;
  gboolean * D.34629;
  unsigned char D.34630;
  unsigned char D.34631;
  _Bool D.34632;
  long int D.34633;
  long int D.34634;
  struct MonoGenericInst * D.34637;
  <unnamed-unsigned:22> D.34640;
  int D.34641;
  unsigned int D.34642;
  gboolean * D.34643;
  int D.34644;
  int D.34645;
  struct MonoGenericInst * D.34647;
  gboolean * D.34650;
  int D.34651;
  int D.34655;
  int D.34656;
  int D.34657;
  int D.34658;
  int * D.34659;
  unsigned int j.328;
  unsigned int D.34661;
  int * D.34662;
  int D.34663;
  unsigned int buf_size.329;
  _Bool D.34665;
  long int D.34666;
  long int D.34667;
  int debug_info_size.330;
  guint8 * debug_info.331;
  guint8 * p.332;
  int D.34677;
  guint8 * p.333;
  unsigned int p.334;
  unsigned int D.34680;
  guint8 * p.335;
  int D.34682;
  int p.336;
  int buf.337;
  int D.34685;
  int D.34686;
  _Bool D.34687;
  long int D.34688;
  long int D.34689;
  unsigned int D.34692;
  guint32 iftmp.338;
  unsigned int D.34697;
  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.34405 = get_method_index (acfg, method);
      method_index = (int) D.34405;
      D.34406 = acfg->aot_opts.nodebug;
      if (D.34406 == 0) goto <D.34407>; else goto <D.34408>;
      <D.34407>:
      mono_debug_serialize_debug_info (cfg, &debug_info, &debug_info_size);
      goto <D.34409>;
      <D.34408>:
      debug_info = 0B;
      debug_info_size = 0;
      <D.34409>:
      seq_points = cfg->seq_point_info;
      D.34410 = header->num_clauses;
      D.34411 = (int) D.34410;
      D.34412 = D.34411 * 256;
      D.34413 = (unsigned int) D.34412;
      debug_info_size.300 = debug_info_size;
      D.34415 = D.34413 + debug_info_size.300;
      if (seq_points != 0B) goto <D.34417>; else goto <D.34418>;
      <D.34417>:
      D.34419 = seq_points->len;
      D.34420 = D.34419 * 128;
      iftmp.301 = (guint32) D.34420;
      goto <D.34421>;
      <D.34418>:
      iftmp.301 = 0;
      <D.34421>:
      D.34422 = D.34415 + iftmp.301;
      D.34423 = cfg->gc_map_size;
      D.34424 = D.34422 + D.34423;
      D.34425 = D.34424 + 2048;
      buf_size = (int) D.34425;
      buf_size.302 = (unsigned int) buf_size;
      buf = monoeg_malloc (buf_size.302);
      p = buf;
      D.34427 = cfg->unwind_ops;
      D.34428 = D.34427 != 0B;
      use_unwind_ops = (gboolean) D.34428;
      D.34429 = BIT_FIELD_REF <*jinfo, 8, 176>;
      D.34430 = D.34429 & 2;
      D.34431 = D.34430 != 0;
      D.34432 = (int) D.34431;
      if (use_unwind_ops != 0) goto <D.34434>; else goto <D.34435>;
      <D.34434>:
      iftmp.303 = 2;
      goto <D.34436>;
      <D.34435>:
      iftmp.303 = 0;
      <D.34436>:
      D.34437 = D.34432 | iftmp.303;
      D.34439 = BIT_FIELD_REF <*header, 16, 80>;
      D.34440 = D.34439 & 32767;
      if (D.34440 != 0) goto <D.34441>; else goto <D.34442>;
      <D.34441>:
      iftmp.304 = 4;
      goto <D.34443>;
      <D.34442>:
      iftmp.304 = 0;
      <D.34443>:
      D.34444 = D.34437 | iftmp.304;
      if (seq_points != 0B) goto <D.34446>; else goto <D.34447>;
      <D.34446>:
      iftmp.305 = 8;
      goto <D.34448>;
      <D.34447>:
      iftmp.305 = 0;
      <D.34448>:
      D.34449 = D.34444 | iftmp.305;
      D.34451 = BIT_FIELD_REF <*cfg, 8, 3400>;
      D.34452 = D.34451 & 1;
      if (D.34452 != 0) goto <D.34453>; else goto <D.34454>;
      <D.34453>:
      iftmp.306 = 16;
      goto <D.34455>;
      <D.34454>:
      iftmp.306 = 0;
      <D.34455>:
      D.34456 = D.34449 | iftmp.306;
      D.34429 = BIT_FIELD_REF <*jinfo, 8, 176>;
      D.34458 = D.34429 & 4;
      if (D.34458 != 0) goto <D.34459>; else goto <D.34460>;
      <D.34459>:
      iftmp.307 = 32;
      goto <D.34461>;
      <D.34460>:
      iftmp.307 = 0;
      <D.34461>:
      D.34462 = D.34456 | iftmp.307;
      D.34464 = cfg->gc_map;
      if (D.34464 != 0B) goto <D.34465>; else goto <D.34466>;
      <D.34465>:
      iftmp.308 = 64;
      goto <D.34467>;
      <D.34466>:
      iftmp.308 = 0;
      <D.34467>:
      D.34468 = D.34462 | iftmp.308;
      D.34429 = BIT_FIELD_REF <*jinfo, 8, 176>;
      D.34470 = D.34429 & 8;
      if (D.34470 != 0) goto <D.34471>; else goto <D.34472>;
      <D.34471>:
      iftmp.309 = 128;
      goto <D.34473>;
      <D.34472>:
      iftmp.309 = 0;
      <D.34473>:
      D.34474 = D.34468 | iftmp.309;
      flags = (guint32) D.34474;
      flags.310 = (int) flags;
      p.311 = p;
      encode_value (flags.310, p.311, &p);
      if (use_unwind_ops != 0) goto <D.34477>; else goto <D.34478>;
      <D.34477>:
      {
        guint32 encoded_len;
        guint8 * encoded;

        try
          {
            D.34427 = cfg->unwind_ops;
            encoded = mono_unwind_ops_encode (D.34427, &encoded_len);
            encoded_len.312 = encoded_len;
            D.34480 = get_unwind_info_offset (acfg, encoded, encoded_len.312);
            D.34481 = (int) D.34480;
            p.311 = p;
            encode_value (D.34481, p.311, &p);
            monoeg_g_free (encoded);
          }
        finally
          {
            encoded_len = {CLOBBER};
          }
      }
      goto <D.34482>;
      <D.34478>:
      D.34483 = jinfo->used_regs;
      D.34484 = (int) D.34483;
      p.311 = p;
      encode_value (D.34484, p.311, &p);
      <D.34482>:
      D.34429 = BIT_FIELD_REF <*jinfo, 8, 176>;
      D.34458 = D.34429 & 4;
      if (D.34458 != 0) goto <D.34485>; else goto <D.34486>;
      <D.34485>:
      {
        struct MonoTryBlockHoleTableJitInfo * table;

        table = mono_jit_info_get_try_block_hole_table_info (jinfo);
        D.34487 = table->num_holes;
        D.34488 = (int) D.34487;
        p.311 = p;
        encode_value (D.34488, p.311, &p);
      }
      <D.34486>:
      D.34451 = BIT_FIELD_REF <*cfg, 8, 3400>;
      D.34452 = D.34451 & 1;
      if (D.34452 != 0) goto <D.34489>; else goto <D.34490>;
      <D.34489>:
      D.34439 = BIT_FIELD_REF <*header, 16, 80>;
      D.34440 = D.34439 & 32767;
      if (D.34440 != 0) goto <D.34491>; else goto <D.34492>;
      <D.34491>:
      D.34410 = header->num_clauses;
      D.34493 = (int) D.34410;
      p.311 = p;
      encode_value (D.34493, p.311, &p);
      <D.34492>:
      k = 0;
      goto <D.27638>;
      <D.27637>:
      {
        struct MonoExceptionClause * clause;

        D.34494 = header->clauses;
        k.313 = (unsigned int) k;
        D.34496 = k.313 * 24;
        clause = D.34494 + D.34496;
        D.34497 = clause->flags;
        D.34498 = (int) D.34497;
        p.311 = p;
        encode_value (D.34498, p.311, &p);
        D.34499 = clause->data.catch_class;
        if (D.34499 != 0B) goto <D.34500>; else goto <D.34501>;
        <D.34500>:
        p.311 = p;
        encode_value (1, p.311, &p);
        D.34499 = clause->data.catch_class;
        p.311 = p;
        encode_klass_ref (acfg, D.34499, p.311, &p);
        goto <D.34502>;
        <D.34501>:
        p.311 = p;
        encode_value (0, p.311, &p);
        <D.34502>:
        i = 0;
        goto <D.27635>;
        <D.27634>:
        {
          gint32 cindex1;
          struct MonoExceptionClause * clause1;
          gint32 cindex2;
          struct MonoExceptionClause * clause2;

          cindex1 = k;
          D.34494 = header->clauses;
          cindex1.314 = (unsigned int) cindex1;
          D.34504 = cindex1.314 * 24;
          clause1 = D.34494 + D.34504;
          cindex2 = i;
          D.34494 = header->clauses;
          cindex2.315 = (unsigned int) cindex2;
          D.34506 = cindex2.315 * 24;
          clause2 = D.34494 + D.34506;
          if (cindex1 != cindex2) goto <D.34507>; else goto <D.34508>;
          <D.34507>:
          D.34509 = clause1->try_offset;
          D.34510 = clause2->try_offset;
          if (D.34509 >= D.34510) goto <D.34511>; else goto <D.34512>;
          <D.34511>:
          D.34513 = clause1->handler_offset;
          D.34514 = clause2->handler_offset;
          if (D.34513 <= D.34514) goto <D.34515>; else goto <D.34516>;
          <D.34515>:
          p.311 = p;
          encode_value (i, p.311, &p);
          <D.34516>:
          <D.34512>:
          <D.34508>:
        }
        i = i + 1;
        <D.27635>:
        D.34410 = header->num_clauses;
        D.34411 = (int) D.34410;
        if (D.34411 > i) goto <D.27634>; else goto <D.27636>;
        <D.27636>:
        p.311 = p;
        encode_value (-1, p.311, &p);
      }
      k = k + 1;
      <D.27638>:
      D.34410 = header->num_clauses;
      D.34411 = (int) D.34410;
      if (D.34411 > k) goto <D.27637>; else goto <D.27639>;
      <D.27639>:
      goto <D.34517>;
      <D.34490>:
      D.34518 = BIT_FIELD_REF <*jinfo, 16, 160>;
      D.34519 = D.34518 & 32767;
      if (D.34519 != 0) goto <D.34520>; else goto <D.34521>;
      <D.34520>:
      D.34522 = jinfo->num_clauses;
      D.34523 = (int) D.34522;
      p.311 = p;
      encode_value (D.34523, p.311, &p);
      <D.34521>:
      k = 0;
      goto <D.27645>;
      <D.27644>:
      {
        struct MonoJitExceptionInfo * ei;

        ei = &jinfo->clauses[k];
        D.34524 = ei->flags;
        D.34525 = (int) D.34524;
        p.311 = p;
        encode_value (D.34525, p.311, &p);
        D.34526 = ei->exvar_offset;
        p.311 = p;
        encode_value (D.34526, p.311, &p);
        D.34524 = ei->flags;
        D.34527 = D.34524 + 4294967295;
        if (D.34527 <= 1) goto <D.34528>; else goto <D.34529>;
        <D.34528>:
        D.34530 = ei->data.filter;
        D.34531 = (int) D.34530;
        code.316 = (int) code;
        D.34533 = D.34531 - code.316;
        p.311 = p;
        encode_value (D.34533, p.311, &p);
        goto <D.34534>;
        <D.34529>:
        D.34535 = ei->data.catch_class;
        if (D.34535 != 0B) goto <D.34536>; else goto <D.34537>;
        <D.34536>:
        {
          guint8 * buf2;
          guint8 * p2;
          int len;

          try
            {
              buf2 = monoeg_malloc (4096);
              p2 = buf2;
              D.34535 = ei->data.catch_class;
              p2.317 = p2;
              encode_klass_ref (acfg, D.34535, p2.317, &p2);
              p2.317 = p2;
              p2.318 = (int) p2.317;
              buf2.319 = (int) buf2;
              len = p2.318 - buf2.319;
              D.34541 = len > 4095;
              D.34542 = (long int) D.34541;
              D.34543 = __builtin_expect (D.34542, 0);
              if (D.34543 != 0) goto <D.34544>; else goto <D.34545>;
              <D.34544>:
              monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "aot-compiler.c", 5325, "len < 4096");
              <D.34545>:
              p.311 = p;
              encode_value (len, p.311, &p);
              p.311 = p;
              len.320 = (unsigned int) len;
              memcpy (p.311, buf2, len.320);
              p.311 = p;
              p2.317 = p2;
              p2.318 = (int) p2.317;
              buf2.319 = (int) buf2;
              D.34547 = p2.318 - buf2.319;
              D.34548 = (sizetype) D.34547;
              p.321 = p.311 + D.34548;
              p = p.321;
              monoeg_g_free (buf2);
            }
          finally
            {
              p2 = {CLOBBER};
            }
        }
        goto <D.34550>;
        <D.34537>:
        p.311 = p;
        encode_value (0, p.311, &p);
        <D.34550>:
        <D.34534>:
        D.34551 = ei->try_start;
        D.34552 = (int) D.34551;
        code.316 = (int) code;
        D.34553 = D.34552 - code.316;
        p.311 = p;
        encode_value (D.34553, p.311, &p);
        D.34554 = ei->try_end;
        D.34555 = (int) D.34554;
        code.316 = (int) code;
        D.34556 = D.34555 - code.316;
        p.311 = p;
        encode_value (D.34556, p.311, &p);
        D.34557 = ei->handler_start;
        D.34558 = (int) D.34557;
        code.316 = (int) code;
        D.34559 = D.34558 - code.316;
        p.311 = p;
        encode_value (D.34559, p.311, &p);
      }
      k = k + 1;
      <D.27645>:
      D.34522 = jinfo->num_clauses;
      D.34560 = (int) D.34522;
      if (D.34560 > k) goto <D.27644>; else goto <D.27646>;
      <D.27646>:
      <D.34517>:
      D.34429 = BIT_FIELD_REF <*jinfo, 8, 176>;
      D.34458 = D.34429 & 4;
      if (D.34458 != 0) goto <D.34561>; else goto <D.34562>;
      <D.34561>:
      {
        struct MonoTryBlockHoleTableJitInfo * table;

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

          hole = &table->holes[i];
          D.34563 = hole->clause;
          D.34564 = (int) D.34563;
          p.311 = p;
          encode_value (D.34564, p.311, &p);
          D.34565 = hole->length;
          D.34566 = (int) D.34565;
          p.311 = p;
          encode_value (D.34566, p.311, &p);
          D.34567 = hole->offset;
          D.34568 = (int) D.34567;
          p.311 = p;
          encode_value (D.34568, p.311, &p);
        }
        i = i + 1;
        <D.27650>:
        D.34569 = table->num_holes;
        D.34570 = (int) D.34569;
        if (D.34570 > i) goto <D.27649>; else goto <D.27651>;
        <D.27651>:
      }
      <D.34562>:
      D.34429 = BIT_FIELD_REF <*jinfo, 8, 176>;
      D.34470 = D.34429 & 8;
      if (D.34470 != 0) goto <D.34571>; else goto <D.34572>;
      <D.34571>:
      {
        struct MonoArchEHJitInfo * eh_info;

        eh_info = mono_jit_info_get_arch_eh_info (jinfo);
        D.34573 = eh_info->stack_size;
        D.34574 = (int) D.34573;
        p.311 = p;
        encode_value (D.34574, p.311, &p);
      }
      <D.34572>:
      D.34429 = BIT_FIELD_REF <*jinfo, 8, 176>;
      D.34430 = D.34429 & 2;
      if (D.34430 != 0) goto <D.34575>; else goto <D.34576>;
      <D.34575>:
      {
        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.34577 = gi->nlocs;
            p.311 = p;
            encode_value (D.34577, p.311, &p);
            D.34577 = gi->nlocs;
            if (D.34577 != 0) goto <D.34578>; else goto <D.34579>;
            <D.34578>:
            i = 0;
            goto <D.27661>;
            <D.27660>:
            {
              struct MonoDwarfLocListEntry * entry;

              D.34580 = gi->locations;
              i.322 = (unsigned int) i;
              D.34582 = i.322 * 20;
              entry = D.34580 + D.34582;
              D.34583 = entry->is_reg;
              D.34584 = D.34583 != 0;
              D.34585 = (int) D.34584;
              p.311 = p;
              encode_value (D.34585, p.311, &p);
              D.34586 = entry->reg;
              p.311 = p;
              encode_value (D.34586, p.311, &p);
              D.34583 = entry->is_reg;
              if (D.34583 == 0) goto <D.34587>; else goto <D.34588>;
              <D.34587>:
              D.34589 = entry->offset;
              p.311 = p;
              encode_value (D.34589, p.311, &p);
              <D.34588>:
              if (i == 0) goto <D.34590>; else goto <D.34591>;
              <D.34590>:
              D.34592 = entry->from;
              D.34593 = D.34592 != 0;
              D.34594 = (long int) D.34593;
              D.34595 = __builtin_expect (D.34594, 0);
              if (D.34595 != 0) goto <D.34596>; else goto <D.34597>;
              <D.34596>:
              monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "aot-compiler.c", 5376, "entry->from == 0");
              <D.34597>:
              goto <D.34598>;
              <D.34591>:
              D.34592 = entry->from;
              p.311 = p;
              encode_value (D.34592, p.311, &p);
              <D.34598>:
              D.34599 = entry->to;
              p.311 = p;
              encode_value (D.34599, p.311, &p);
            }
            i = i + 1;
            <D.27661>:
            D.34577 = gi->nlocs;
            if (D.34577 > i) goto <D.27660>; else goto <D.27662>;
            <D.27662>:
            goto <D.34600>;
            <D.34579>:
            D.34451 = BIT_FIELD_REF <*cfg, 8, 3400>;
            D.34452 = D.34451 & 1;
            if (D.34452 == 0) goto <D.34601>; else goto <D.34602>;
            <D.34601>:
            D.34603 = BIT_FIELD_REF <*gi, 8, 136>;
            D.34604 = D.34603 & 1;
            D.34605 = D.34604 != 0;
            D.34606 = (int) D.34605;
            p.311 = p;
            encode_value (D.34606, p.311, &p);
            D.34607 = gi->this_reg;
            D.34608 = (int) D.34607;
            p.311 = p;
            encode_value (D.34608, p.311, &p);
            D.34609 = gi->this_offset;
            p.311 = p;
            encode_value (D.34609, p.311, &p);
            <D.34602>:
            <D.34600>:
            buf2 = monoeg_malloc (4096);
            p2 = buf2;
            D.34610 = jinfo->d.method;
            p2.323 = p2;
            encode_method_ref (acfg, D.34610, p2.323, &p2);
            p2.323 = p2;
            p2.324 = (int) p2.323;
            buf2.325 = (int) buf2;
            len = p2.324 - buf2.325;
            D.34614 = len > 4095;
            D.34615 = (long int) D.34614;
            D.34616 = __builtin_expect (D.34615, 0);
            if (D.34616 != 0) goto <D.34617>; else goto <D.34618>;
            <D.34617>:
            monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "aot-compiler.c", 5397, "len < 4096");
            <D.34618>:
            p.311 = p;
            encode_value (len, p.311, &p);
            p.311 = p;
            len.326 = (unsigned int) len;
            memcpy (p.311, buf2, len.326);
            p.311 = p;
            p2.323 = p2;
            p2.324 = (int) p2.323;
            buf2.325 = (int) buf2;
            D.34620 = p2.324 - buf2.325;
            D.34621 = (sizetype) D.34620;
            p.327 = p.311 + D.34621;
            p = p.327;
            monoeg_g_free (buf2);
            if (gsctx != 0B) goto <D.34626>; else goto <D.34623>;
            <D.34626>:
            D.34627 = gsctx->var_is_vt;
            if (D.34627 != 0B) goto <D.34624>; else goto <D.34628>;
            <D.34628>:
            D.34629 = gsctx->mvar_is_vt;
            if (D.34629 != 0B) goto <D.34624>; else goto <D.34623>;
            <D.34624>:
            {
              struct MonoMethodInflated * inflated;
              struct MonoGenericContext * context;
              struct MonoGenericInst * inst;

              D.34610 = jinfo->d.method;
              D.34630 = BIT_FIELD_REF <*D.34610, 8, 168>;
              D.34631 = D.34630 & 16;
              D.34632 = D.34631 == 0;
              D.34633 = (long int) D.34632;
              D.34634 = __builtin_expect (D.34633, 0);
              if (D.34634 != 0) goto <D.34635>; else goto <D.34636>;
              <D.34635>:
              monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "aot-compiler.c", 5408, "jinfo->d.method->is_inflated");
              <D.34636>:
              inflated = jinfo->d.method;
              context = &inflated->context;
              p.311 = p;
              encode_value (1, p.311, &p);
              D.34637 = context->class_inst;
              if (D.34637 != 0B) goto <D.34638>; else goto <D.34639>;
              <D.34638>:
              inst = context->class_inst;
              D.34640 = inst->type_argc;
              D.34641 = (int) D.34640;
              p.311 = p;
              encode_value (D.34641, p.311, &p);
              i = 0;
              goto <D.27667>;
              <D.27666>:
              D.34627 = gsctx->var_is_vt;
              i.322 = (unsigned int) i;
              D.34642 = i.322 * 4;
              D.34643 = D.34627 + D.34642;
              D.34644 = *D.34643;
              p.311 = p;
              encode_value (D.34644, p.311, &p);
              i = i + 1;
              <D.27667>:
              D.34640 = inst->type_argc;
              D.34645 = (int) D.34640;
              if (D.34645 > i) goto <D.27666>; else goto <D.27668>;
              <D.27668>:
              goto <D.34646>;
              <D.34639>:
              p.311 = p;
              encode_value (0, p.311, &p);
              <D.34646>:
              D.34647 = context->method_inst;
              if (D.34647 != 0B) goto <D.34648>; else goto <D.34649>;
              <D.34648>:
              inst = context->method_inst;
              D.34640 = inst->type_argc;
              D.34641 = (int) D.34640;
              p.311 = p;
              encode_value (D.34641, p.311, &p);
              i = 0;
              goto <D.27670>;
              <D.27669>:
              D.34629 = gsctx->mvar_is_vt;
              i.322 = (unsigned int) i;
              D.34642 = i.322 * 4;
              D.34650 = D.34629 + D.34642;
              D.34651 = *D.34650;
              p.311 = p;
              encode_value (D.34651, p.311, &p);
              i = i + 1;
              <D.27670>:
              D.34640 = inst->type_argc;
              D.34645 = (int) D.34640;
              if (D.34645 > i) goto <D.27669>; else goto <D.27671>;
              <D.27671>:
              goto <D.34652>;
              <D.34649>:
              p.311 = p;
              encode_value (0, p.311, &p);
              <D.34652>:
            }
            goto <D.34625>;
            <D.34623>:
            p.311 = p;
            encode_value (0, p.311, &p);
            <D.34625>:
          }
        finally
          {
            p2 = {CLOBBER};
          }
      }
      <D.34576>:
      if (seq_points != 0B) goto <D.34653>; else goto <D.34654>;
      <D.34653>:
      {
        int il_offset;
        int native_offset;
        int last_il_offset;
        int last_native_offset;
        int j;

        D.34419 = seq_points->len;
        p.311 = p;
        encode_value (D.34419, p.311, &p);
        last_native_offset = 0;
        last_il_offset = last_native_offset;
        i = 0;
        goto <D.27682>;
        <D.27681>:
        {
          struct SeqPoint * sp;

          sp = &seq_points->seq_points[i];
          il_offset = sp->il_offset;
          native_offset = sp->native_offset;
          D.34655 = il_offset - last_il_offset;
          p.311 = p;
          encode_value (D.34655, p.311, &p);
          D.34656 = native_offset - last_native_offset;
          p.311 = p;
          encode_value (D.34656, p.311, &p);
          last_il_offset = il_offset;
          last_native_offset = native_offset;
          D.34657 = sp->flags;
          p.311 = p;
          encode_value (D.34657, p.311, &p);
          D.34658 = sp->next_len;
          p.311 = p;
          encode_value (D.34658, p.311, &p);
          j = 0;
          goto <D.27679>;
          <D.27678>:
          D.34659 = sp->next;
          j.328 = (unsigned int) j;
          D.34661 = j.328 * 4;
          D.34662 = D.34659 + D.34661;
          D.34663 = *D.34662;
          p.311 = p;
          encode_value (D.34663, p.311, &p);
          j = j + 1;
          <D.27679>:
          D.34658 = sp->next_len;
          if (D.34658 > j) goto <D.27678>; else goto <D.27680>;
          <D.27680>:
        }
        i = i + 1;
        <D.27682>:
        D.34419 = seq_points->len;
        if (D.34419 > i) goto <D.27681>; else goto <D.27683>;
        <D.27683>:
      }
      <D.34654>:
      buf_size.329 = (unsigned int) buf_size;
      debug_info_size.300 = debug_info_size;
      D.34665 = buf_size.329 <= debug_info_size.300;
      D.34666 = (long int) D.34665;
      D.34667 = __builtin_expect (D.34666, 0);
      if (D.34667 != 0) goto <D.34668>; else goto <D.34669>;
      <D.34668>:
      monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "aot-compiler.c", 5457, "debug_info_size < buf_size");
      <D.34669>:
      debug_info_size.300 = debug_info_size;
      debug_info_size.330 = (int) debug_info_size.300;
      p.311 = p;
      encode_value (debug_info_size.330, p.311, &p);
      debug_info_size.300 = debug_info_size;
      if (debug_info_size.300 != 0) goto <D.34671>; else goto <D.34672>;
      <D.34671>:
      p.311 = p;
      debug_info.331 = debug_info;
      debug_info_size.300 = debug_info_size;
      memcpy (p.311, debug_info.331, debug_info_size.300);
      p.311 = p;
      debug_info_size.300 = debug_info_size;
      p.332 = p.311 + debug_info_size.300;
      p = p.332;
      debug_info.331 = debug_info;
      monoeg_g_free (debug_info.331);
      <D.34672>:
      D.34464 = cfg->gc_map;
      if (D.34464 != 0B) goto <D.34675>; else goto <D.34676>;
      <D.34675>:
      D.34423 = cfg->gc_map_size;
      D.34677 = (int) D.34423;
      p.311 = p;
      encode_value (D.34677, p.311, &p);
      goto <D.27685>;
      <D.27684>:
      p.311 = p;
      p.333 = p.311 + 1;
      p = p.333;
      <D.27685>:
      p.311 = p;
      p.334 = (unsigned int) p.311;
      D.34680 = p.334 & 3;
      if (D.34680 != 0) goto <D.27684>; else goto <D.27686>;
      <D.27686>:
      p.311 = p;
      D.34464 = cfg->gc_map;
      D.34423 = cfg->gc_map_size;
      memcpy (p.311, D.34464, D.34423);
      p.311 = p;
      D.34423 = cfg->gc_map_size;
      p.335 = p.311 + D.34423;
      p = p.335;
      <D.34676>:
      D.34682 = acfg->stats.ex_info_size;
      p.311 = p;
      p.336 = (int) p.311;
      buf.337 = (int) buf;
      D.34685 = p.336 - buf.337;
      D.34686 = D.34682 + D.34685;
      acfg->stats.ex_info_size = D.34686;
      p.311 = p;
      p.336 = (int) p.311;
      buf.337 = (int) buf;
      D.34685 = p.336 - buf.337;
      D.34687 = D.34685 >= buf_size;
      D.34688 = (long int) D.34687;
      D.34689 = __builtin_expect (D.34688, 0);
      if (D.34689 != 0) goto <D.34690>; else goto <D.34691>;
      <D.34690>:
      monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "aot-compiler.c", 5478, "p - buf < buf_size");
      <D.34691>:
      p.311 = p;
      p.336 = (int) p.311;
      buf.337 = (int) buf;
      D.34685 = p.336 - buf.337;
      D.34692 = (unsigned int) D.34685;
      D.34464 = cfg->gc_map;
      if (D.34464 != 0B) goto <D.34694>; else goto <D.34695>;
      <D.34694>:
      iftmp.338 = 4;
      goto <D.34696>;
      <D.34695>:
      iftmp.338 = 1;
      <D.34696>:
      D.34697 = add_to_blob_aligned (acfg, buf, D.34692, iftmp.338);
      cfg->ex_info_offset = D.34697;
      monoeg_g_free (buf);
    }
  finally
    {
      debug_info_size = {CLOBBER};
      p = {CLOBBER};
      debug_info = {CLOBBER};
    }
}


add_to_blob_aligned (struct MonoAotCompile * acfg, const guint8 * data, guint32 data_len, guint32 align)
{
  unsigned int D.34698;
  struct MonoDynamicStream * D.34701;
  unsigned int D.34702;
  unsigned int D.34705;
  guint32 D.34706;
  char buf[4];
  guint32 count;

  try
    {
      buf = {};
      D.34698 = acfg->blob.alloc_size;
      if (D.34698 == 0) goto <D.34699>; else goto <D.34700>;
      <D.34699>:
      D.34701 = &acfg->blob;
      stream_init (D.34701);
      <D.34700>:
      D.34702 = acfg->blob.index;
      count = D.34702 % align;
      if (count != 0) goto <D.34703>; else goto <D.34704>;
      <D.34703>:
      D.34701 = &acfg->blob;
      D.34705 = 4 - count;
      add_stream_data (D.34701, &buf, D.34705);
      <D.34704>:
      D.34701 = &acfg->blob;
      D.34706 = add_stream_data (D.34701, data, data_len);
      return D.34706;
    }
  finally
    {
      buf = {CLOBBER};
    }
}


emit_unwind_info (struct MonoAotCompile * acfg)
{
  struct GPtrArray * D.34709;
  void * * D.34710;
  unsigned int i.339;
  unsigned int D.34712;
  void * * D.34713;
  void * D.34714;
  unsigned int unwind_info_len.340;
  int unwind_info_len.341;
  guint8 * p.342;
  int p.343;
  int buf.344;
  int D.34720;
  int unwind_info_len.345;
  int D.34722;
  unsigned int D.34723;
  unsigned int D.34724;
  unsigned int D.34725;
  unsigned int D.34726;
  int D.34727;
  unsigned int i.346;
  unsigned int D.34729;
  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.28327>;
      <D.28326>:
      {
        guint32 index;
        guint8 * unwind_info;
        guint32 unwind_info_len;
        guint8 buf[16];
        guint8 * p;

        try
          {
            D.34709 = acfg->unwind_ops;
            D.34710 = D.34709->pdata;
            i.339 = (unsigned int) i;
            D.34712 = i.339 * 4;
            D.34713 = D.34710 + D.34712;
            D.34714 = *D.34713;
            index = (guint32) D.34714;
            unwind_info = mono_get_cached_unwind_info (index, &unwind_info_len);
            p = &buf;
            unwind_info_len.340 = unwind_info_len;
            unwind_info_len.341 = (int) unwind_info_len.340;
            p.342 = p;
            encode_value (unwind_info_len.341, p.342, &p);
            p.342 = p;
            p.343 = (int) p.342;
            buf.344 = (int) &buf;
            D.34720 = p.343 - buf.344;
            emit_bytes (acfg, &buf, D.34720);
            unwind_info_len.340 = unwind_info_len;
            unwind_info_len.345 = (int) unwind_info_len.340;
            emit_bytes (acfg, unwind_info, unwind_info_len.345);
            D.34722 = acfg->stats.unwind_info_size;
            D.34723 = (unsigned int) D.34722;
            p.342 = p;
            p.343 = (int) p.342;
            buf.344 = (int) &buf;
            D.34720 = p.343 - buf.344;
            D.34724 = (unsigned int) D.34720;
            unwind_info_len.340 = unwind_info_len;
            D.34725 = D.34724 + unwind_info_len.340;
            D.34726 = D.34723 + D.34725;
            D.34727 = (int) D.34726;
            acfg->stats.unwind_info_size = D.34727;
          }
        finally
          {
            unwind_info_len = {CLOBBER};
            buf = {CLOBBER};
            p = {CLOBBER};
          }
      }
      i = i + 1;
      <D.28327>:
      i.346 = (unsigned int) i;
      D.34709 = acfg->unwind_ops;
      D.34729 = D.34709->len;
      if (i.346 < D.34729) goto <D.28326>; else goto <D.28328>;
      <D.28328>:
    }
  finally
    {
      symbol = {CLOBBER};
    }
}


emit_class_info (struct MonoAotCompile * acfg)
{
  struct MonoImage * D.34730;
  <unnamed-unsigned:24> D.34731;
  unsigned int D.34732;
  unsigned int D.34733;
  unsigned int i.347;
  unsigned int D.34735;
  gint32 * D.34736;
  int D.34737;
  int D.34738;
  unsigned int D.34739;
  unsigned int D.34740;
  int D.34741;
  int D.34742;
  unsigned int D.34743;
  int D.34744;
  unsigned int D.34745;
  unsigned int D.34746;
  int D.34747;
  int i;
  char symbol[256];
  gint32 * offsets;

  try
    {
      D.34730 = acfg->image;
      D.34731 = D.34730->tables[2].rows;
      D.34732 = (unsigned int) D.34731;
      D.34733 = D.34732 * 4;
      offsets = monoeg_malloc0 (D.34733);
      i = 0;
      goto <D.28336>;
      <D.28335>:
      i.347 = (unsigned int) i;
      D.34735 = i.347 * 4;
      D.34736 = offsets + D.34735;
      D.34737 = i + 1;
      D.34738 = D.34737 | 33554432;
      D.34739 = (unsigned int) D.34738;
      D.34740 = emit_klass_info (acfg, D.34739);
      D.34741 = (int) D.34740;
      *D.34736 = D.34741;
      i = i + 1;
      <D.28336>:
      D.34730 = acfg->image;
      D.34731 = D.34730->tables[2].rows;
      D.34742 = (int) D.34731;
      if (D.34742 > i) goto <D.28335>; else goto <D.28337>;
      <D.28337>:
      sprintf (&symbol, "class_info_offsets");
      emit_section_change (acfg, ".rodata", 1);
      emit_alignment (acfg, 8);
      emit_label (acfg, &symbol);
      D.34730 = acfg->image;
      D.34731 = D.34730->tables[2].rows;
      D.34742 = (int) D.34731;
      D.34743 = emit_offset_table (acfg, D.34742, 10, offsets);
      D.34744 = acfg->stats.offsets_size;
      D.34745 = (unsigned int) D.34744;
      D.34746 = D.34745 + D.34743;
      D.34747 = (int) D.34746;
      acfg->stats.offsets_size = D.34747;
      monoeg_g_free (offsets);
    }
  finally
    {
      symbol = {CLOBBER};
    }
}


emit_klass_info (struct MonoAotCompile * acfg, guint32 token)
{
  struct MonoImage * D.34748;
  unsigned int buf_size.348;
  guint8 * p.349;
  int p.350;
  int buf.351;
  int D.34755;
  unsigned int D.34756;
  unsigned int D.34757;
  guint32 D.34758;
  int D.34759;
  int D.34760;
  _Bool D.34761;
  long int D.34762;
  long int D.34763;
  unsigned char D.34766;
  signed char D.34767;
  _Bool D.34768;
  long int D.34769;
  long int D.34770;
  int D.34773;
  _Bool D.34774;
  struct MonoMethod * * D.34775;
  unsigned int i.352;
  unsigned int D.34777;
  struct MonoMethod * * D.34778;
  struct MonoMethodSignature * D.34781;
  unsigned char D.34782;
  unsigned char D.34783;
  struct GHashTable * D.34786;
  void * D.34787;
  struct MonoGenericContainer * D.34792;
  gboolean iftmp.353;
  int D.34798;
  int D.34799;
  <unnamed-unsigned:1> D.34800;
  int D.34801;
  int D.34802;
  int D.34803;
  <unnamed-unsigned:1> D.34804;
  int D.34805;
  int D.34806;
  int D.34807;
  <unnamed-unsigned:1> D.34808;
  int D.34809;
  int D.34810;
  int iftmp.354;
  struct MonoClassExt * D.34814;
  struct GList * D.34816;
  int D.34818;
  int D.34819;
  int D.34820;
  <unnamed-unsigned:1> D.34821;
  int D.34822;
  int D.34823;
  int D.34824;
  <unnamed-unsigned:1> D.34825;
  int D.34826;
  int D.34827;
  int D.34828;
  <unnamed-unsigned:1> D.34829;
  int D.34830;
  int D.34831;
  unsigned char D.34832;
  struct MonoMethod * D.34835;
  unsigned char D.34836;
  unsigned char D.34837;
  struct MonoMethod * D.34840;
  int D.34841;
  int D.34842;
  <unnamed-unsigned:4> D.34843;
  int D.34844;
  unsigned char D.34845;
  int D.34846;
  int D.34850;
  int D.34851;
  _Bool D.34852;
  long int D.34853;
  long int D.34854;
  unsigned int D.34857;
  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.34748 = acfg->image;
      klass = mono_class_get (D.34748, token);
      iter = 0B;
      if (klass == 0B) goto <D.34749>; else goto <D.34750>;
      <D.34749>:
      mono_loader_clear_error ();
      buf_size = 16;
      buf_size.348 = (unsigned int) buf_size;
      buf = monoeg_malloc (buf_size.348);
      p = buf;
      p.349 = p;
      encode_value (-1, p.349, &p);
      p.349 = p;
      p.350 = (int) p.349;
      buf.351 = (int) buf;
      D.34755 = p.350 - buf.351;
      D.34756 = (unsigned int) D.34755;
      D.34757 = add_to_blob (acfg, buf, D.34756);
      res = (int) D.34757;
      monoeg_g_free (buf);
      D.34758 = (guint32) res;
      return D.34758;
      <D.34750>:
      D.34759 = klass->vtable_size;
      D.34760 = D.34759 + 640;
      buf_size = D.34760 * 16;
      buf_size.348 = (unsigned int) buf_size;
      buf = monoeg_malloc (buf_size.348);
      p = buf;
      D.34761 = klass == 0B;
      D.34762 = (long int) D.34761;
      D.34763 = __builtin_expect (D.34762, 0);
      if (D.34763 != 0) goto <D.34764>; else goto <D.34765>;
      <D.34764>:
      monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "aot-compiler.c", 5514, "klass");
      <D.34765>:
      mono_class_init (klass);
      mono_class_get_nested_types (klass, &iter);
      D.34766 = BIT_FIELD_REF <*klass, 8, 184>;
      D.34767 = (signed char) D.34766;
      D.34768 = D.34767 >= 0;
      D.34769 = (long int) D.34768;
      D.34770 = __builtin_expect (D.34769, 0);
      if (D.34770 != 0) goto <D.34771>; else goto <D.34772>;
      <D.34771>:
      monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "aot-compiler.c", 5519, "klass->nested_classes_inited");
      <D.34772>:
      mono_class_setup_vtable (klass);
      D.34773 = mono_class_has_special_static_fields (klass);
      D.34774 = D.34773 == 0;
      no_special_static = (gboolean) D.34774;
      cant_encode = 0;
      i = 0;
      goto <D.27702>;
      <D.27701>:
      {
        struct MonoMethod * cm;

        D.34775 = klass->vtable;
        i.352 = (unsigned int) i;
        D.34777 = i.352 * 4;
        D.34778 = D.34775 + D.34777;
        cm = *D.34778;
        if (cm != 0B) goto <D.34779>; else goto <D.34780>;
        <D.34779>:
        D.34781 = mono_method_signature (cm);
        D.34782 = BIT_FIELD_REF <*D.34781, 8, 88>;
        D.34783 = D.34782 & 2;
        if (D.34783 != 0) goto <D.34784>; else goto <D.34785>;
        <D.34784>:
        D.34786 = acfg->token_info_hash;
        D.34787 = monoeg_g_hash_table_lookup (D.34786, cm);
        if (D.34787 == 0B) goto <D.34788>; else goto <D.34789>;
        <D.34788>:
        cant_encode = 1;
        <D.34789>:
        <D.34785>:
        <D.34780>:
      }
      i = i + 1;
      <D.27702>:
      D.34759 = klass->vtable_size;
      if (D.34759 > i) goto <D.27701>; else goto <D.27703>;
      <D.27703>:
      mono_class_has_finalizer (klass);
      D.34792 = klass->generic_container;
      if (D.34792 != 0B) goto <D.34790>; else goto <D.34793>;
      <D.34793>:
      if (cant_encode != 0) goto <D.34790>; else goto <D.34791>;
      <D.34790>:
      p.349 = p;
      encode_value (-1, p.349, &p);
      goto <D.27707>;
      <D.34791>:
      D.34759 = klass->vtable_size;
      p.349 = p;
      encode_value (D.34759, p.349, &p);
      D.34792 = klass->generic_container;
      if (D.34792 != 0B) goto <D.34795>; else goto <D.34796>;
      <D.34795>:
      iftmp.353 = 256;
      goto <D.34797>;
      <D.34796>:
      iftmp.353 = 0;
      <D.34797>:
      D.34798 = no_special_static << 7;
      D.34799 = iftmp.353 | D.34798;
      D.34800 = klass->has_static_refs;
      D.34801 = (int) D.34800;
      D.34802 = D.34801 << 6;
      D.34803 = D.34799 | D.34802;
      D.34804 = klass->has_references;
      D.34805 = (int) D.34804;
      D.34806 = D.34805 << 5;
      D.34807 = D.34803 | D.34806;
      D.34808 = klass->blittable;
      D.34809 = (int) D.34808;
      D.34810 = D.34809 << 4;
      D.34814 = klass->ext;
      if (D.34814 != 0B) goto <D.34815>; else goto <D.34812>;
      <D.34815>:
      D.34814 = klass->ext;
      D.34816 = D.34814->nested_classes;
      if (D.34816 != 0B) goto <D.34817>; else goto <D.34812>;
      <D.34817>:
      iftmp.354 = 1;
      goto <D.34813>;
      <D.34812>:
      iftmp.354 = 0;
      <D.34813>:
      D.34818 = iftmp.354 << 3;
      D.34819 = D.34810 | D.34818;
      D.34820 = D.34807 | D.34819;
      D.34821 = klass->has_cctor;
      D.34822 = (int) D.34821;
      D.34823 = D.34822 << 2;
      D.34824 = D.34820 | D.34823;
      D.34825 = klass->has_finalize;
      D.34826 = (int) D.34825;
      D.34827 = D.34826 << 1;
      D.34828 = D.34824 | D.34827;
      D.34829 = klass->ghcimpl;
      D.34830 = (int) D.34829;
      D.34831 = D.34828 | D.34830;
      p.349 = p;
      encode_value (D.34831, p.349, &p);
      D.34766 = BIT_FIELD_REF <*klass, 8, 184>;
      D.34832 = D.34766 & 4;
      if (D.34832 != 0) goto <D.34833>; else goto <D.34834>;
      <D.34833>:
      D.34835 = mono_class_get_cctor (klass);
      p.349 = p;
      encode_method_ref (acfg, D.34835, p.349, &p);
      <D.34834>:
      D.34836 = BIT_FIELD_REF <*klass, 8, 176>;
      D.34837 = D.34836 & 32;
      if (D.34837 != 0) goto <D.34838>; else goto <D.34839>;
      <D.34838>:
      D.34840 = mono_class_get_finalizer (klass);
      p.349 = p;
      encode_method_ref (acfg, D.34840, p.349, &p);
      <D.34839>:
      D.34841 = klass->instance_size;
      p.349 = p;
      encode_value (D.34841, p.349, &p);
      D.34842 = mono_class_data_size (klass);
      p.349 = p;
      encode_value (D.34842, p.349, &p);
      D.34843 = klass->packing_size;
      D.34844 = (int) D.34843;
      p.349 = p;
      encode_value (D.34844, p.349, &p);
      D.34845 = klass->min_align;
      D.34846 = (int) D.34845;
      p.349 = p;
      encode_value (D.34846, p.349, &p);
      i = 0;
      goto <D.27706>;
      <D.27705>:
      {
        struct MonoMethod * cm;

        D.34775 = klass->vtable;
        i.352 = (unsigned int) i;
        D.34777 = i.352 * 4;
        D.34778 = D.34775 + D.34777;
        cm = *D.34778;
        if (cm != 0B) goto <D.34847>; else goto <D.34848>;
        <D.34847>:
        p.349 = p;
        encode_method_ref (acfg, cm, p.349, &p);
        goto <D.34849>;
        <D.34848>:
        p.349 = p;
        encode_value (0, p.349, &p);
        <D.34849>:
      }
      i = i + 1;
      <D.27706>:
      D.34759 = klass->vtable_size;
      if (D.34759 > i) goto <D.27705>; else goto <D.27707>;
      <D.27707>:
      D.34850 = acfg->stats.class_info_size;
      p.349 = p;
      p.350 = (int) p.349;
      buf.351 = (int) buf;
      D.34755 = p.350 - buf.351;
      D.34851 = D.34850 + D.34755;
      acfg->stats.class_info_size = D.34851;
      p.349 = p;
      p.350 = (int) p.349;
      buf.351 = (int) buf;
      D.34755 = p.350 - buf.351;
      D.34852 = D.34755 >= buf_size;
      D.34853 = (long int) D.34852;
      D.34854 = __builtin_expect (D.34853, 0);
      if (D.34854 != 0) goto <D.34855>; else goto <D.34856>;
      <D.34855>:
      monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "aot-compiler.c", 5569, "p - buf < buf_size");
      <D.34856>:
      p.349 = p;
      p.350 = (int) p.349;
      buf.351 = (int) buf;
      D.34755 = p.350 - buf.351;
      D.34756 = (unsigned int) D.34755;
      D.34857 = add_to_blob (acfg, buf, D.34756);
      res = (int) D.34857;
      monoeg_g_free (buf);
      D.34758 = (guint32) res;
      return D.34758;
    }
  finally
    {
      p = {CLOBBER};
      iter = {CLOBBER};
    }
}


emit_plt (struct MonoAotCompile * acfg)
{
  char * D.34860;
  struct GHashTable * D.34863;
  const void * i.355;
  int D.34865;
  int D.34870;
  int D.34873;
  struct GHashTable * D.34876;
  struct MonoMethod * D.34877;
  int D.34882;
  unsigned char D.34884;
  unsigned char D.34885;
  struct FILE * D.34887;
  char * D.34888;
  char * D.34889;
  int D.34892;
  int D.34901;
  char * D.34904;
  unsigned int i.356;
  unsigned int D.34908;
  int D.34915;
  int D.34920;
  int D.34923;
  char * D.34926;
  char * D.34931;
  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.34860 = acfg->plt_symbol;
      emit_label (acfg, D.34860);
      i = 0;
      goto <D.27736>;
      <D.27735>:
      {
        char * debug_sym;
        struct MonoPltEntry * plt_entry;
        struct MonoJumpInfo * ji;

        debug_sym = 0B;
        plt_entry = 0B;
        if (i == 0) goto <D.34861>; else goto <D.34862>;
        <D.34861>:
        // predicted unlikely by continue predictor.
        goto <D.27733>;
        <D.34862>:
        D.34863 = acfg->plt_offset_to_entry;
        i.355 = (const void *) i;
        plt_entry = monoeg_g_hash_table_lookup (D.34863, i.355);
        ji = plt_entry->ji;
        D.34865 = acfg->llvm;
        if (D.34865 != 0) goto <D.34866>; else goto <D.34867>;
        <D.34866>:
        if (ji != 0B) goto <D.34868>; else goto <D.34869>;
        <D.34868>:
        D.34870 = is_direct_callable (acfg, 0B, ji);
        if (D.34870 != 0) goto <D.34871>; else goto <D.34872>;
        <D.34871>:
        D.34873 = acfg->use_bin_writer;
        if (D.34873 == 0) goto <D.34874>; else goto <D.34875>;
        <D.34874>:
        {
          struct MonoCompile * callee_cfg;

          D.34876 = acfg->method_to_cfg;
          D.34877 = ji->data.method;
          callee_cfg = monoeg_g_hash_table_lookup (D.34876, D.34877);
          if (callee_cfg != 0B) goto <D.34878>; else goto <D.34879>;
          <D.34878>:
          D.34882 = acfg->thumb_mixed;
          if (D.34882 != 0) goto <D.34883>; else goto <D.34880>;
          <D.34883>:
          D.34884 = BIT_FIELD_REF <*callee_cfg, 8, 3400>;
          D.34885 = D.34884 & 1;
          if (D.34885 == 0) goto <D.34886>; else goto <D.34880>;
          <D.34886>:
          emit_set_thumb_mode (acfg);
          D.34887 = acfg->fp;
          fprintf (D.34887, "\n.thumb_func\n");
          D.34888 = plt_entry->llvm_symbol;
          emit_label (acfg, D.34888);
          D.34887 = acfg->fp;
          fprintf (D.34887, "bx pc\n");
          D.34887 = acfg->fp;
          fprintf (D.34887, "nop\n");
          emit_set_arm_mode (acfg);
          D.34887 = acfg->fp;
          D.34889 = callee_cfg->asm_symbol;
          fprintf (D.34887, "b %s\n", D.34889);
          goto <D.34881>;
          <D.34880>:
          D.34887 = acfg->fp;
          D.34888 = plt_entry->llvm_symbol;
          D.34889 = callee_cfg->asm_symbol;
          fprintf (D.34887, "\n.set %s, %s\n", D.34888, D.34889);
          <D.34881>:
          // predicted unlikely by continue predictor.
          goto <D.27733>;
          <D.34879>:
        }
        <D.34875>:
        <D.34872>:
        <D.34869>:
        <D.34867>:
        debug_sym = plt_entry->debug_sym;
        D.34882 = acfg->thumb_mixed;
        if (D.34882 != 0) goto <D.34890>; else goto <D.34891>;
        <D.34890>:
        D.34892 = plt_entry->jit_used;
        if (D.34892 == 0) goto <D.34893>; else goto <D.34894>;
        <D.34893>:
        // predicted unlikely by continue predictor.
        goto <D.27733>;
        <D.34894>:
        <D.34891>:
        D.34865 = acfg->llvm;
        if (D.34865 != 0) goto <D.34895>; else goto <D.34896>;
        <D.34895>:
        D.34882 = acfg->thumb_mixed;
        if (D.34882 == 0) goto <D.34897>; else goto <D.34898>;
        <D.34897>:
        D.34888 = plt_entry->llvm_symbol;
        emit_label (acfg, D.34888);
        <D.34898>:
        <D.34896>:
        if (debug_sym != 0B) goto <D.34899>; else goto <D.34900>;
        <D.34899>:
        D.34901 = acfg->need_no_dead_strip;
        if (D.34901 != 0) goto <D.34902>; else goto <D.34903>;
        <D.34902>:
        emit_unset_mode (acfg);
        D.34887 = acfg->fp;
        fprintf (D.34887, "\t.no_dead_strip %s\n", debug_sym);
        <D.34903>:
        emit_local_symbol (acfg, debug_sym, 0B, 1);
        emit_label (acfg, debug_sym);
        <D.34900>:
        D.34904 = plt_entry->symbol;
        emit_label (acfg, D.34904);
        arch_emit_plt_entry (acfg, i);
        if (debug_sym != 0B) goto <D.34905>; else goto <D.34906>;
        <D.34905>:
        emit_symbol_size (acfg, debug_sym, ".");
        <D.34906>:
      }
      <D.27733>:
      i = i + 1;
      <D.27736>:
      i.356 = (unsigned int) i;
      D.34908 = acfg->plt_offset;
      if (i.356 < D.34908) goto <D.27735>; else goto <D.27737>;
      <D.27737>:
      D.34882 = acfg->thumb_mixed;
      if (D.34882 != 0) goto <D.34909>; else goto <D.34910>;
      <D.34909>:
      emit_zero_bytes (acfg, 16);
      i = 0;
      goto <D.27743>;
      <D.27742>:
      {
        char * debug_sym;
        struct MonoPltEntry * plt_entry;
        struct MonoJumpInfo * ji;

        debug_sym = 0B;
        plt_entry = 0B;
        if (i == 0) goto <D.34911>; else goto <D.34912>;
        <D.34911>:
        // predicted unlikely by continue predictor.
        goto <D.27741>;
        <D.34912>:
        D.34863 = acfg->plt_offset_to_entry;
        i.355 = (const void *) i;
        plt_entry = monoeg_g_hash_table_lookup (D.34863, i.355);
        ji = plt_entry->ji;
        if (ji != 0B) goto <D.34913>; else goto <D.34914>;
        <D.34913>:
        D.34915 = is_direct_callable (acfg, 0B, ji);
        if (D.34915 != 0) goto <D.34916>; else goto <D.34917>;
        <D.34916>:
        D.34873 = acfg->use_bin_writer;
        if (D.34873 == 0) goto <D.34918>; else goto <D.34919>;
        <D.34918>:
        // predicted unlikely by continue predictor.
        goto <D.27741>;
        <D.34919>:
        <D.34917>:
        <D.34914>:
        D.34920 = plt_entry->llvm_used;
        if (D.34920 == 0) goto <D.34921>; else goto <D.34922>;
        <D.34921>:
        // predicted unlikely by continue predictor.
        goto <D.27741>;
        <D.34922>:
        D.34923 = acfg->aot_opts.write_symbols;
        if (D.34923 != 0) goto <D.34924>; else goto <D.34925>;
        <D.34924>:
        D.34926 = plt_entry->debug_sym;
        if (D.34926 != 0B) goto <D.34927>; else goto <D.34928>;
        <D.34927>:
        D.34926 = plt_entry->debug_sym;
        debug_sym = monoeg_g_strdup_printf ("%s_thumb", D.34926);
        <D.34928>:
        <D.34925>:
        if (debug_sym != 0B) goto <D.34929>; else goto <D.34930>;
        <D.34929>:
        emit_local_symbol (acfg, debug_sym, 0B, 1);
        emit_label (acfg, debug_sym);
        <D.34930>:
        D.34887 = acfg->fp;
        fprintf (D.34887, "\n.thumb_func\n");
        D.34931 = plt_entry->llvm_symbol;
        emit_label (acfg, D.34931);
        arch_emit_llvm_plt_entry (acfg, i);
        if (debug_sym != 0B) goto <D.34932>; else goto <D.34933>;
        <D.34932>:
        emit_symbol_size (acfg, debug_sym, ".");
        monoeg_g_free (debug_sym);
        <D.34933>:
      }
      <D.27741>:
      i = i + 1;
      <D.27743>:
      i.356 = (unsigned int) i;
      D.34908 = acfg->plt_offset;
      if (i.356 < D.34908) goto <D.27742>; else goto <D.27744>;
      <D.27744>:
      <D.34910>:
      D.34860 = acfg->plt_symbol;
      emit_symbol_size (acfg, D.34860, ".");
      sprintf (&symbol, "plt_end");
      emit_label (acfg, &symbol);
    }
  finally
    {
      symbol = {CLOBBER};
    }
}


arch_emit_plt_entry (struct MonoAotCompile * acfg, int index)
{
  int code.357;
  int buf.358;
  int D.34936;
  char * D.34937;
  unsigned int D.34938;
  unsigned int index.359;
  unsigned int D.34940;
  unsigned int D.34941;
  unsigned int D.34942;
  int D.34943;
  guint32 * D.34944;
  unsigned int index.360;
  unsigned int D.34946;
  guint32 * D.34947;
  unsigned int D.34948;
  int D.34949;
  guint8 buf[256];
  guint8 * code;

  try
    {
      code = &buf;
      {
        arminstr_t * __ainstrp;

        __ainstrp = code;
        *__ainstrp = 3852451840;
        code = __ainstrp + 4;
      }
      {
        arminstr_t * __ainstrp;

        __ainstrp = code;
        *__ainstrp = 3886018572;
        code = __ainstrp + 4;
      }
      code.357 = (int) code;
      buf.358 = (int) &buf;
      D.34936 = code.357 - buf.358;
      emit_bytes (acfg, &buf, D.34936);
      D.34937 = acfg->got_symbol;
      D.34938 = acfg->plt_got_offset_base;
      index.359 = (unsigned int) index;
      D.34940 = D.34938 + index.359;
      D.34941 = D.34940 + 1073741823;
      D.34942 = D.34941 * 4;
      D.34943 = (int) D.34942;
      emit_symbol_diff (acfg, D.34937, ".", D.34943);
      D.34944 = acfg->plt_got_info_offsets;
      index.360 = (unsigned int) index;
      D.34946 = index.360 * 4;
      D.34947 = D.34944 + D.34946;
      D.34948 = *D.34947;
      D.34949 = (int) D.34948;
      emit_int32 (acfg, D.34949);
    }
  finally
    {
      buf = {CLOBBER};
    }
}


arch_emit_llvm_plt_entry (struct MonoAotCompile * acfg, int index)
{
  struct FILE * D.34950;
  char * D.34951;
  unsigned int D.34952;
  unsigned int index.361;
  unsigned int D.34954;
  unsigned int D.34955;
  unsigned int D.34956;
  int D.34957;
  guint32 * D.34958;
  unsigned int index.362;
  unsigned int D.34960;
  guint32 * D.34961;
  unsigned int D.34962;
  int D.34963;

  emit_set_thumb_mode (acfg);
  D.34950 = acfg->fp;
  fprintf (D.34950, ".4byte 0xc008f8df\n");
  D.34950 = acfg->fp;
  fprintf (D.34950, ".2byte 0x44fc\n");
  D.34950 = acfg->fp;
  fprintf (D.34950, ".4byte 0xc000f8dc\n");
  D.34950 = acfg->fp;
  fprintf (D.34950, ".2byte 0x4760\n");
  D.34951 = acfg->got_symbol;
  D.34952 = acfg->plt_got_offset_base;
  index.361 = (unsigned int) index;
  D.34954 = D.34952 + index.361;
  D.34955 = D.34954 + 1;
  D.34956 = D.34955 * 4;
  D.34957 = (int) D.34956;
  emit_symbol_diff (acfg, D.34951, ".", D.34957);
  D.34958 = acfg->plt_got_info_offsets;
  index.362 = (unsigned int) index;
  D.34960 = index.362 * 4;
  D.34961 = D.34958 + D.34960;
  D.34962 = *D.34961;
  D.34963 = (int) D.34962;
  emit_int32 (acfg, D.34963);
  emit_unset_mode (acfg);
  emit_set_arm_mode (acfg);
}


emit_image_table (struct MonoAotCompile * acfg)
{
  struct GPtrArray * D.34964;
  unsigned int D.34965;
  int D.34966;
  void * * D.34967;
  unsigned int i.363;
  unsigned int D.34969;
  void * * D.34970;
  struct MonoAssembly * D.34971;
  struct MonoImage * D.34972;
  _Bool D.34973;
  long int D.34974;
  long int D.34975;
  const char * D.34978;
  char * D.34979;
  const char * iftmp.364;
  const char * D.34981;
  mono_byte[17] * D.34985;
  unsigned int D.34986;
  int D.34987;
  short unsigned int D.34988;
  int D.34989;
  short unsigned int D.34990;
  int D.34991;
  short unsigned int D.34992;
  int D.34993;
  short unsigned int D.34994;
  int D.34995;
  unsigned int i.365;
  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.34964 = acfg->image_table;
      D.34965 = D.34964->len;
      D.34966 = (int) D.34965;
      emit_int32 (acfg, D.34966);
      i = 0;
      goto <D.28378>;
      <D.28377>:
      {
        struct MonoImage * image;
        struct MonoAssemblyName * aname;

        D.34964 = acfg->image_table;
        D.34967 = D.34964->pdata;
        i.363 = (unsigned int) i;
        D.34969 = i.363 * 4;
        D.34970 = D.34967 + D.34969;
        image = *D.34970;
        D.34971 = image->assembly;
        aname = &D.34971->aname;
        D.34971 = image->assembly;
        D.34972 = D.34971->image;
        D.34973 = D.34972 != image;
        D.34974 = (long int) D.34973;
        D.34975 = __builtin_expect (D.34974, 0);
        if (D.34975 != 0) goto <D.34976>; else goto <D.34977>;
        <D.34976>:
        monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "aot-compiler.c", 7785, "image->assembly->image == image");
        <D.34977>:
        D.34978 = image->assembly_name;
        emit_string (acfg, D.34978);
        D.34979 = image->guid;
        emit_string (acfg, D.34979);
        D.34981 = aname->culture;
        if (D.34981 != 0B) goto <D.34982>; else goto <D.34983>;
        <D.34982>:
        iftmp.364 = aname->culture;
        goto <D.34984>;
        <D.34983>:
        iftmp.364 = "";
        <D.34984>:
        emit_string (acfg, iftmp.364);
        D.34985 = &aname->public_key_token;
        emit_string (acfg, D.34985);
        emit_alignment (acfg, 8);
        D.34986 = aname->flags;
        D.34987 = (int) D.34986;
        emit_int32 (acfg, D.34987);
        D.34988 = aname->major;
        D.34989 = (int) D.34988;
        emit_int32 (acfg, D.34989);
        D.34990 = aname->minor;
        D.34991 = (int) D.34990;
        emit_int32 (acfg, D.34991);
        D.34992 = aname->build;
        D.34993 = (int) D.34992;
        emit_int32 (acfg, D.34993);
        D.34994 = aname->revision;
        D.34995 = (int) D.34994;
        emit_int32 (acfg, D.34995);
      }
      i = i + 1;
      <D.28378>:
      i.365 = (unsigned int) i;
      D.34964 = acfg->image_table;
      D.34965 = D.34964->len;
      if (i.365 < D.34965) goto <D.28377>; else goto <D.28379>;
      <D.28379>:
    }
  finally
    {
      symbol = {CLOBBER};
    }
}


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

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


emit_got (struct MonoAotCompile * acfg)
{
  int D.34998;
  char * D.35001;
  unsigned int D.35002;
  unsigned int D.35005;
  int D.35006;
  char symbol[256];

  try
    {
      D.34998 = acfg->llvm;
      if (D.34998 == 0) goto <D.34999>; else goto <D.35000>;
      <D.34999>:
      D.35001 = acfg->got_symbol;
      sprintf (&symbol, "%s", D.35001);
      emit_section_change (acfg, ".bss", 0);
      emit_alignment (acfg, 8);
      emit_local_symbol (acfg, &symbol, "got_end", 0);
      emit_label (acfg, &symbol);
      D.35002 = acfg->got_offset;
      if (D.35002 != 0) goto <D.35003>; else goto <D.35004>;
      <D.35003>:
      D.35002 = acfg->got_offset;
      D.35005 = D.35002 * 4;
      D.35006 = (int) D.35005;
      emit_zero_bytes (acfg, D.35006);
      <D.35004>:
      sprintf (&symbol, "got_end");
      emit_label (acfg, &symbol);
      <D.35000>:
    }
  finally
    {
      symbol = {CLOBBER};
    }
}


emit_file_info (struct MonoAotCompile * acfg)
{
  struct MonoImage * D.35007;
  char * D.35008;
  int D.35009;
  struct MonoAssembly * D.35013;
  const char * D.35014;
  unsigned int D.35015;
  unsigned int D.35016;
  unsigned int D.35017;
  const char * D.35018;
  int D.35019;
  char * D.35022;
  char * D.35023;
  int D.35024;
  int D.35028;
  unsigned int D.35032;
  int D.35036;
  unsigned int D.35043;
  int D.35044;
  unsigned int D.35045;
  unsigned int D.35046;
  int D.35047;
  unsigned int D.35048;
  int D.35049;
  unsigned int D.35050;
  int D.35051;
  <unnamed type> D.35052;
  int D.35053;
  unsigned int D.35054;
  int D.35055;
  unsigned int D.35056;
  int D.35057;
  unsigned int D.35058;
  int D.35059;
  unsigned int D.35060;
  int D.35061;
  unsigned int D.35062;
  int D.35063;
  int D.35064;
  unsigned int D.35065;
  int D.35066;
  unsigned int D.35067;
  int D.35068;
  const short unsigned int * * D.35071;
  const short unsigned int * D.35072;
  char D.35073;
  unsigned int D.35074;
  unsigned int D.35075;
  const short unsigned int * D.35076;
  short unsigned int D.35077;
  int D.35078;
  int D.35079;
  gchar * D.35084;
  char symbol[256];
  int i;
  int gc_name_offset;
  const char * gc_name;
  char * build_info;

  try
    {
      D.35007 = acfg->image;
      D.35008 = D.35007->guid;
      emit_string_symbol (acfg, "assembly_guid", D.35008);
      D.35009 = acfg->aot_opts.bind_to_runtime_version;
      if (D.35009 != 0) goto <D.35010>; else goto <D.35011>;
      <D.35010>:
      build_info = mono_get_runtime_build_info ();
      emit_string_symbol (acfg, "runtime_version", build_info);
      monoeg_g_free (build_info);
      goto <D.35012>;
      <D.35011>:
      emit_string_symbol (acfg, "runtime_version", "");
      <D.35012>:
      D.35007 = acfg->image;
      D.35013 = D.35007->assembly;
      D.35014 = D.35013->aname.name;
      emit_string_symbol (acfg, "assembly_name", D.35014);
      gc_name = mono_gc_get_gc_name ();
      D.35015 = strlen (gc_name);
      D.35016 = D.35015 + 1;
      D.35017 = add_to_blob (acfg, gc_name, D.35016);
      gc_name_offset = (int) D.35017;
      D.35018 = acfg->user_symbol_prefix;
      sprintf (&symbol, "%smono_aot_file_info", D.35018);
      emit_section_change (acfg, ".data", 0);
      emit_alignment (acfg, 8);
      emit_label (acfg, &symbol);
      D.35019 = acfg->aot_opts.static_link;
      if (D.35019 == 0) goto <D.35020>; else goto <D.35021>;
      <D.35020>:
      emit_global (acfg, &symbol, 0);
      <D.35021>:
      emit_int32 (acfg, 97);
      emit_int32 (acfg, 0);
      D.35022 = acfg->got_symbol;
      emit_pointer (acfg, D.35022);
      D.35023 = acfg->methods_symbol;
      emit_pointer (acfg, D.35023);
      D.35024 = acfg->llvm;
      if (D.35024 != 0) goto <D.35025>; else goto <D.35026>;
      <D.35025>:
      emit_pointer (acfg, "mono_eh_frame");
      goto <D.35027>;
      <D.35026>:
      emit_pointer (acfg, 0B);
      <D.35027>:
      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.35028 = acfg->direct_method_addresses;
      if (D.35028 != 0) goto <D.35029>; else goto <D.35030>;
      <D.35029>:
      emit_pointer (acfg, "method_addresses");
      goto <D.35031>;
      <D.35030>:
      emit_pointer (acfg, 0B);
      <D.35031>:
      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.35032 = acfg->num_trampoline_got_entries;
      if (D.35032 != 0) goto <D.35033>; else goto <D.35034>;
      <D.35033>:
      emit_pointer (acfg, "specific_trampolines");
      emit_pointer (acfg, "static_rgctx_trampolines");
      emit_pointer (acfg, "imt_thunks");
      emit_pointer (acfg, "gsharedvt_arg_trampolines");
      goto <D.35035>;
      <D.35034>:
      emit_pointer (acfg, 0B);
      emit_pointer (acfg, 0B);
      emit_pointer (acfg, 0B);
      emit_pointer (acfg, 0B);
      <D.35035>:
      D.35036 = acfg->thumb_mixed;
      if (D.35036 != 0) goto <D.35037>; else goto <D.35038>;
      <D.35037>:
      emit_pointer (acfg, "thumb_end");
      goto <D.35039>;
      <D.35038>:
      emit_pointer (acfg, 0B);
      <D.35039>:
      D.35019 = acfg->aot_opts.static_link;
      if (D.35019 != 0) goto <D.35040>; else goto <D.35041>;
      <D.35040>:
      emit_pointer (acfg, "globals");
      goto <D.35042>;
      <D.35041>:
      emit_pointer (acfg, 0B);
      <D.35042>:
      emit_pointer (acfg, "assembly_name");
      emit_pointer (acfg, "unbox_trampolines");
      emit_pointer (acfg, "unbox_trampolines_end");
      D.35043 = acfg->plt_got_offset_base;
      D.35044 = (int) D.35043;
      emit_int32 (acfg, D.35044);
      D.35045 = acfg->got_offset;
      D.35046 = D.35045 * 4;
      D.35047 = (int) D.35046;
      emit_int32 (acfg, D.35047);
      D.35048 = acfg->plt_offset;
      D.35049 = (int) D.35048;
      emit_int32 (acfg, D.35049);
      D.35050 = acfg->nmethods;
      D.35051 = (int) D.35050;
      emit_int32 (acfg, D.35051);
      D.35052 = acfg->flags;
      D.35053 = (int) D.35052;
      emit_int32 (acfg, D.35053);
      D.35054 = acfg->opts;
      D.35055 = (int) D.35054;
      emit_int32 (acfg, D.35055);
      D.35056 = acfg->simd_opts;
      D.35057 = (int) D.35056;
      emit_int32 (acfg, D.35057);
      emit_int32 (acfg, gc_name_offset);
      i = 0;
      goto <D.28457>;
      <D.28456>:
      D.35058 = acfg->num_trampolines[i];
      D.35059 = (int) D.35058;
      emit_int32 (acfg, D.35059);
      i = i + 1;
      <D.28457>:
      if (i <= 3) goto <D.28456>; else goto <D.28458>;
      <D.28458>:
      i = 0;
      goto <D.28460>;
      <D.28459>:
      D.35060 = acfg->trampoline_got_offset_base[i];
      D.35061 = (int) D.35060;
      emit_int32 (acfg, D.35061);
      i = i + 1;
      <D.28460>:
      if (i <= 3) goto <D.28459>; else goto <D.28461>;
      <D.28461>:
      i = 0;
      goto <D.28463>;
      <D.28462>:
      D.35062 = acfg->trampoline_size[i];
      D.35063 = (int) D.35062;
      emit_int32 (acfg, D.35063);
      i = i + 1;
      <D.28463>:
      if (i <= 3) goto <D.28462>; else goto <D.28464>;
      <D.28464>:
      D.35064 = acfg->aot_opts.nrgctx_fetch_trampolines;
      emit_int32 (acfg, D.35064);
      emit_int32 (acfg, 8);
      emit_int32 (acfg, 8);
      emit_int32 (acfg, 14);
      D.35065 = acfg->tramp_page_size;
      D.35066 = (int) D.35065;
      emit_int32 (acfg, D.35066);
      i = 0;
      goto <D.28466>;
      <D.28465>:
      D.35067 = acfg->tramp_page_code_offsets[i];
      D.35068 = (int) D.35067;
      emit_int32 (acfg, D.35068);
      i = i + 1;
      <D.28466>:
      if (i <= 3) goto <D.28465>; else goto <D.28467>;
      <D.28467>:
      D.35019 = acfg->aot_opts.static_link;
      if (D.35019 != 0) goto <D.35069>; else goto <D.35070>;
      <D.35069>:
      {
        char * p;

        D.35018 = acfg->user_symbol_prefix;
        D.35007 = acfg->image;
        D.35013 = D.35007->assembly;
        D.35014 = D.35013->aname.name;
        sprintf (&symbol, "%smono_aot_module_%s_info", D.35018, D.35014);
        p = &symbol;
        p = &symbol;
        goto <D.28470>;
        <D.28469>:
        D.35071 = __ctype_b_loc ();
        D.35072 = *D.35071;
        D.35073 = *p;
        D.35074 = (unsigned int) D.35073;
        D.35075 = D.35074 * 2;
        D.35076 = D.35072 + D.35075;
        D.35077 = *D.35076;
        D.35078 = (int) D.35077;
        D.35079 = D.35078 & 8;
        if (D.35079 == 0) goto <D.35080>; else goto <D.35081>;
        <D.35080>:
        D.35073 = *p;
        if (D.35073 != 95) goto <D.35082>; else goto <D.35083>;
        <D.35082>:
        *p = 95;
        <D.35083>:
        <D.35081>:
        p = p + 1;
        <D.28470>:
        D.35073 = *p;
        if (D.35073 != 0) goto <D.28469>; else goto <D.28471>;
        <D.28471>:
        D.35084 = monoeg_strdup (&symbol);
        acfg->static_linking_symbol = D.35084;
        emit_global_inner (acfg, &symbol, 0);
        emit_alignment (acfg, 4);
        emit_label (acfg, &symbol);
        D.35018 = acfg->user_symbol_prefix;
        emit_pointer_2 (acfg, D.35018, "mono_aot_file_info");
      }
      <D.35070>:
    }
  finally
    {
      symbol = {CLOBBER};
    }
}


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

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


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

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


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

  D.35087 = *prefix;
  if (D.35087 != 0) goto <D.35088>; else goto <D.35089>;
  <D.35088>:
  {
    char * s;

    s = monoeg_g_strdup_printf ("%s%s", prefix, target);
    D.35090 = acfg->w;
    img_writer_emit_pointer (D.35090, s);
    monoeg_g_free (s);
  }
  goto <D.35091>;
  <D.35089>:
  D.35090 = acfg->w;
  img_writer_emit_pointer (D.35090, target);
  <D.35091>:
}


emit_blob (struct MonoAotCompile * acfg)
{
  char * D.35092;
  unsigned int D.35093;
  int D.35094;
  char symbol[128];

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


emit_objc_selectors (struct MonoAotCompile * acfg)
{
  struct GPtrArray * D.35097;
  unsigned int D.35099;
  struct MonoImageWriter * D.35100;
  struct FILE * D.35101;
  _Bool D.35102;
  long int D.35103;
  long int D.35104;
  unsigned int i.366;
  void * * D.35108;
  unsigned int i.367;
  unsigned int D.35110;
  void * * D.35111;
  void * D.35112;
  int i;

  D.35097 = acfg->objc_selectors;
  if (D.35097 == 0B) goto <D.35095>; else goto <D.35098>;
  <D.35098>:
  D.35097 = acfg->objc_selectors;
  D.35099 = D.35097->len;
  if (D.35099 == 0) goto <D.35095>; else goto <D.35096>;
  <D.35095>:
  return;
  <D.35096>:
  D.35100 = acfg->w;
  img_writer_emit_unset_mode (D.35100);
  D.35101 = acfg->fp;
  D.35102 = D.35101 == 0B;
  D.35103 = (long int) D.35102;
  D.35104 = __builtin_expect (D.35103, 0);
  if (D.35104 != 0) goto <D.35105>; else goto <D.35106>;
  <D.35105>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "aot-compiler.c", 8235, "acfg->fp");
  <D.35106>:
  D.35101 = acfg->fp;
  fprintf (D.35101, ".section\t__DATA,__objc_selrefs,literal_pointers,no_dead_strip\n");
  D.35101 = acfg->fp;
  fprintf (D.35101, ".align\t2\n");
  i = 0;
  goto <D.28481>;
  <D.28480>:
  D.35101 = acfg->fp;
  fprintf (D.35101, "L_OBJC_SELECTOR_REFERENCES_%d:\n", i);
  D.35101 = acfg->fp;
  fprintf (D.35101, ".long\tL_OBJC_METH_VAR_NAME_%d\n", i);
  i = i + 1;
  <D.28481>:
  i.366 = (unsigned int) i;
  D.35097 = acfg->objc_selectors;
  D.35099 = D.35097->len;
  if (i.366 < D.35099) goto <D.28480>; else goto <D.28482>;
  <D.28482>:
  D.35101 = acfg->fp;
  fprintf (D.35101, ".section\t__TEXT,__cstring,cstring_literals\n");
  i = 0;
  goto <D.28484>;
  <D.28483>:
  D.35101 = acfg->fp;
  fprintf (D.35101, "L_OBJC_METH_VAR_NAME_%d:\n", i);
  D.35101 = acfg->fp;
  D.35097 = acfg->objc_selectors;
  D.35108 = D.35097->pdata;
  i.367 = (unsigned int) i;
  D.35110 = i.367 * 4;
  D.35111 = D.35108 + D.35110;
  D.35112 = *D.35111;
  fprintf (D.35101, ".asciz \"%s\"\n", D.35112);
  i = i + 1;
  <D.28484>:
  i.366 = (unsigned int) i;
  D.35097 = acfg->objc_selectors;
  D.35099 = D.35097->len;
  if (i.366 < D.35099) goto <D.28483>; else goto <D.28485>;
  <D.28485>:
  D.35101 = acfg->fp;
  fprintf (D.35101, ".section\t__DATA,__objc_imageinfo,regular,no_dead_strip\n");
  D.35101 = acfg->fp;
  fprintf (D.35101, ".align\t2\n");
  D.35101 = acfg->fp;
  fprintf (D.35101, "L_OBJC_IMAGE_INFO:\n");
  D.35101 = acfg->fp;
  fprintf (D.35101, ".long\t0\n");
  D.35101 = acfg->fp;
  fprintf (D.35101, ".long\t16\n");
}


emit_globals (struct MonoAotCompile * acfg)
{
  int D.35114;
  struct GPtrArray * D.35117;
  unsigned int D.35118;
  double D.35119;
  double D.35120;
  int D.35121;
  unsigned int D.35122;
  unsigned int D.35123;
  unsigned int table_size.368;
  void * * D.35125;
  unsigned int i.369;
  unsigned int D.35127;
  void * * D.35128;
  unsigned int D.35129;
  unsigned int i.370;
  void * * D.35131;
  unsigned int D.35132;
  void * * D.35133;
  struct GlobalsTableEntry * D.35137;
  unsigned int D.35138;
  unsigned int i.371;
  _Bool D.35140;
  long int D.35141;
  long int D.35142;
  void * * D.35145;
  unsigned int D.35149;
  unsigned int D.35150;
  int D.35151;
  struct GlobalsTableEntry * D.35152;
  unsigned int D.35155;
  int D.35156;
  const char * D.35158;
  int i;
  int table_size;
  guint32 hash;
  struct GPtrArray * table;
  char symbol[256];
  struct GlobalsTableEntry * entry;
  struct GlobalsTableEntry * new_entry;

  try
    {
      D.35114 = acfg->aot_opts.static_link;
      if (D.35114 == 0) goto <D.35115>; else goto <D.35116>;
      <D.35115>:
      return;
      <D.35116>:
      D.35117 = acfg->globals;
      D.35118 = D.35117->len;
      D.35119 = (double) D.35118;
      D.35120 = D.35119 * 1.5e+0;
      D.35121 = (int) D.35120;
      D.35122 = (unsigned int) D.35121;
      D.35123 = monoeg_g_spaced_primes_closest (D.35122);
      table_size = (int) D.35123;
      table_size.368 = (unsigned int) table_size;
      table = monoeg_g_ptr_array_sized_new (table_size.368);
      i = 0;
      goto <D.28419>;
      <D.28418>:
      monoeg_g_ptr_array_add (table, 0B);
      i = i + 1;
      <D.28419>:
      if (i < table_size) goto <D.28418>; else goto <D.28420>;
      <D.28420>:
      i = 0;
      goto <D.28426>;
      <D.28425>:
      {
        char * name;

        D.35117 = acfg->globals;
        D.35125 = D.35117->pdata;
        i.369 = (unsigned int) i;
        D.35127 = i.369 * 4;
        D.35128 = D.35125 + D.35127;
        name = *D.35128;
        D.35129 = mono_metadata_str_hash (name);
        table_size.368 = (unsigned int) table_size;
        hash = D.35129 % table_size.368;
        new_entry = monoeg_malloc0 (12);
        i.370 = (unsigned int) i;
        new_entry->value = i.370;
        D.35131 = table->pdata;
        D.35132 = hash * 4;
        D.35133 = D.35131 + D.35132;
        entry = *D.35133;
        if (entry == 0B) goto <D.35134>; else goto <D.35135>;
        <D.35134>:
        new_entry->index = hash;
        D.35131 = table->pdata;
        D.35132 = hash * 4;
        D.35133 = D.35131 + D.35132;
        *D.35133 = new_entry;
        goto <D.35136>;
        <D.35135>:
        goto <D.28423>;
        <D.28422>:
        entry = entry->next;
        <D.28423>:
        D.35137 = entry->next;
        if (D.35137 != 0B) goto <D.28422>; else goto <D.28424>;
        <D.28424>:
        entry->next = new_entry;
        D.35138 = table->len;
        new_entry->index = D.35138;
        monoeg_g_ptr_array_add (table, new_entry);
        <D.35136>:
      }
      i = i + 1;
      <D.28426>:
      i.371 = (unsigned int) i;
      D.35117 = acfg->globals;
      D.35118 = D.35117->len;
      if (i.371 < D.35118) goto <D.28425>; else goto <D.28427>;
      <D.28427>:
      sprintf (&symbol, ".Lglobals_hash");
      emit_section_change (acfg, ".rodata", 0);
      emit_alignment (acfg, 8);
      emit_label (acfg, &symbol);
      D.35140 = table_size > 64999;
      D.35141 = (long int) D.35140;
      D.35142 = __builtin_expect (D.35141, 0);
      if (D.35142 != 0) goto <D.35143>; else goto <D.35144>;
      <D.35143>:
      monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "aot-compiler.c", 7948, "table_size < 65000");
      <D.35144>:
      emit_int16 (acfg, table_size);
      i = 0;
      goto <D.28430>;
      <D.28429>:
      {
        struct GlobalsTableEntry * entry;

        D.35131 = table->pdata;
        i.369 = (unsigned int) i;
        D.35127 = i.369 * 4;
        D.35145 = D.35131 + D.35127;
        entry = *D.35145;
        if (entry == 0B) goto <D.35146>; else goto <D.35147>;
        <D.35146>:
        emit_int16 (acfg, 0);
        emit_int16 (acfg, 0);
        goto <D.35148>;
        <D.35147>:
        D.35149 = entry->value;
        D.35150 = D.35149 + 1;
        D.35151 = (int) D.35150;
        emit_int16 (acfg, D.35151);
        D.35152 = entry->next;
        if (D.35152 != 0B) goto <D.35153>; else goto <D.35154>;
        <D.35153>:
        D.35152 = entry->next;
        D.35155 = D.35152->index;
        D.35156 = (int) D.35155;
        emit_int16 (acfg, D.35156);
        goto <D.35157>;
        <D.35154>:
        emit_int16 (acfg, 0);
        <D.35157>:
        <D.35148>:
      }
      i = i + 1;
      <D.28430>:
      i.371 = (unsigned int) i;
      D.35138 = table->len;
      if (i.371 < D.35138) goto <D.28429>; else goto <D.28431>;
      <D.28431>:
      i = 0;
      goto <D.28434>;
      <D.28433>:
      {
        char * name;

        D.35117 = acfg->globals;
        D.35125 = D.35117->pdata;
        i.369 = (unsigned int) i;
        D.35127 = i.369 * 4;
        D.35128 = D.35125 + D.35127;
        name = *D.35128;
        sprintf (&symbol, "name_%d", i);
        emit_section_change (acfg, ".rodata", 1);
        emit_label (acfg, &symbol);
        emit_string (acfg, name);
      }
      i = i + 1;
      <D.28434>:
      i.371 = (unsigned int) i;
      D.35117 = acfg->globals;
      D.35118 = D.35117->len;
      if (i.371 < D.35118) goto <D.28433>; else goto <D.28435>;
      <D.28435>:
      sprintf (&symbol, "globals");
      emit_section_change (acfg, ".data", 0);
      emit_alignment (acfg, 8);
      emit_label (acfg, &symbol);
      D.35158 = acfg->temp_prefix;
      sprintf (&symbol, "%sglobals_hash", D.35158);
      emit_pointer (acfg, &symbol);
      i = 0;
      goto <D.28438>;
      <D.28437>:
      {
        char * name;

        D.35117 = acfg->globals;
        D.35125 = D.35117->pdata;
        i.369 = (unsigned int) i;
        D.35127 = i.369 * 4;
        D.35128 = D.35125 + D.35127;
        name = *D.35128;
        sprintf (&symbol, "name_%d", i);
        emit_pointer (acfg, &symbol);
        sprintf (&symbol, "%s", name);
        emit_pointer (acfg, &symbol);
      }
      i = i + 1;
      <D.28438>:
      i.371 = (unsigned int) i;
      D.35117 = acfg->globals;
      D.35118 = D.35117->len;
      if (i.371 < D.35118) goto <D.28437>; else goto <D.28439>;
      <D.28439>:
      emit_int32 (acfg, 0);
      emit_int32 (acfg, 0);
    }
  finally
    {
      symbol = {CLOBBER};
    }
}


emit_autoreg (struct MonoAotCompile * acfg)
{
  int D.35164;
  int D.35166;
  int D.35168;
  char * D.35169;
  char * symbol;

  D.35164 = acfg->use_bin_writer;
  if (D.35164 != 0) goto <D.35162>; else goto <D.35165>;
  <D.35165>:
  D.35166 = acfg->aot_opts.static_link;
  if (D.35166 == 0) goto <D.35162>; else goto <D.35167>;
  <D.35167>:
  D.35168 = acfg->aot_opts.autoreg;
  if (D.35168 == 0) goto <D.35162>; else goto <D.35163>;
  <D.35162>:
  return;
  <D.35163>:
  D.35169 = acfg->static_linking_symbol;
  symbol = monoeg_g_strdup_printf ("_%s_autoreg", D.35169);
  arch_emit_autoreg (acfg, symbol);
  monoeg_g_free (symbol);
}


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

}


emit_dwarf_info (struct MonoAotCompile * acfg)
{
  struct MonoCompile * * D.35171;
  unsigned int i.372;
  unsigned int D.35173;
  struct MonoCompile * * D.35174;
  unsigned char D.35177;
  unsigned char D.35178;
  const char * D.35181;
  struct MonoDwarfWriter * D.35182;
  struct MonoMethod * D.35183;
  char * D.35184;
  struct MonoJitInfo * D.35185;
  void * D.35186;
  int D.35187;
  unsigned int D.35188;
  struct MonoInst * * D.35189;
  struct MonoInst * * D.35190;
  struct GSList * D.35191;
  struct MonoMethod * D.35192;
  struct MonoDomain * D.35193;
  struct MonoDebugMethodJitInfo * D.35194;
  unsigned int i.373;
  unsigned int D.35196;
  int i;
  char symbol2[128];

  try
    {
      i = 0;
      goto <D.28494>;
      <D.28493>:
      {
        struct MonoCompile * cfg;

        D.35171 = acfg->cfgs;
        i.372 = (unsigned int) i;
        D.35173 = i.372 * 4;
        D.35174 = D.35171 + D.35173;
        cfg = *D.35174;
        if (cfg == 0B) goto <D.35175>; else goto <D.35176>;
        <D.35175>:
        // predicted unlikely by continue predictor.
        goto <D.28492>;
        <D.35176>:
        D.35177 = BIT_FIELD_REF <*cfg, 8, 3400>;
        D.35178 = D.35177 & 1;
        if (D.35178 != 0) goto <D.35179>; else goto <D.35180>;
        <D.35179>:
        // predicted unlikely by continue predictor.
        goto <D.28492>;
        <D.35180>:
        D.35181 = acfg->temp_prefix;
        sprintf (&symbol2, "%sme_%x", D.35181, i);
        D.35182 = acfg->dwarf;
        D.35183 = cfg->method;
        D.35184 = cfg->asm_symbol;
        D.35185 = cfg->jit_info;
        D.35186 = D.35185->code_start;
        D.35185 = cfg->jit_info;
        D.35187 = D.35185->code_size;
        D.35188 = (unsigned int) D.35187;
        D.35189 = cfg->args;
        D.35190 = cfg->locals;
        D.35191 = cfg->unwind_ops;
        D.35185 = cfg->jit_info;
        D.35192 = D.35185->d.method;
        D.35193 = mono_domain_get ();
        D.35194 = mono_debug_find_method (D.35192, D.35193);
        mono_dwarf_writer_emit_method (D.35182, cfg, D.35183, D.35184, &symbol2, D.35186, D.35188, D.35189, D.35190, D.35191, D.35194);
      }
      <D.28492>:
      i = i + 1;
      <D.28494>:
      i.373 = (unsigned int) i;
      D.35196 = acfg->nmethods;
      if (i.373 < D.35196) goto <D.28493>; else goto <D.28495>;
      <D.28495>:
    }
  finally
    {
      symbol2 = {CLOBBER};
    }
}


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};
    }
}


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

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


strcpy (char * restrict __dest, const char * restrict __src)
{
  char * D.35199;
  unsigned int D.35200;

  D.35200 = __builtin_object_size (__dest, 1);
  D.35199 = __builtin___strcpy_chk (__dest, __src, D.35200);
  return D.35199;
}


compile_asm (struct MonoAotCompile * acfg)
{
  const char * iftmp.374;
  char * D.35203;
  int D.35207;
  char * D.35210;
  int D.35211;
  char * D.35214;
  int D.35215;
  char * D.35218;
  struct MonoImage * D.35222;
  char * D.35223;
  const char * iftmp.375;
  struct GString * D.35226;
  int D.35230;
  int D.35238;
  int D.35241;
  int D.35244;
  char * command;
  char * objfile;
  char * outfile_name;
  char * tmp_outfile_name;
  const char * tool_prefix;

  D.35203 = acfg->aot_opts.tool_prefix;
  if (D.35203 != 0B) goto <D.35204>; else goto <D.35205>;
  <D.35204>:
  iftmp.374 = acfg->aot_opts.tool_prefix;
  goto <D.35206>;
  <D.35205>:
  iftmp.374 = "";
  <D.35206>:
  tool_prefix = iftmp.374;
  D.35207 = acfg->aot_opts.asm_only;
  if (D.35207 != 0) goto <D.35208>; else goto <D.35209>;
  <D.35208>:
  D.35210 = acfg->tmpfname;
  printf ("Output file: \'%s\'.\n", D.35210);
  D.35211 = acfg->aot_opts.static_link;
  if (D.35211 != 0) goto <D.35212>; else goto <D.35213>;
  <D.35212>:
  D.35214 = acfg->static_linking_symbol;
  printf ("Linking symbol: \'%s\'.\n", D.35214);
  <D.35213>:
  D.35215 = 0;
  return D.35215;
  <D.35209>:
  D.35211 = acfg->aot_opts.static_link;
  if (D.35211 != 0) goto <D.35216>; else goto <D.35217>;
  <D.35216>:
  D.35218 = acfg->aot_opts.outfile;
  if (D.35218 != 0B) goto <D.35219>; else goto <D.35220>;
  <D.35219>:
  D.35218 = acfg->aot_opts.outfile;
  objfile = monoeg_g_strdup_printf ("%s", D.35218);
  goto <D.35221>;
  <D.35220>:
  D.35222 = acfg->image;
  D.35223 = D.35222->name;
  objfile = monoeg_g_strdup_printf ("%s.o", D.35223);
  <D.35221>:
  goto <D.35224>;
  <D.35217>:
  D.35210 = acfg->tmpfname;
  objfile = monoeg_g_strdup_printf ("%s.o", D.35210);
  <D.35224>:
  D.35226 = acfg->as_args;
  if (D.35226 != 0B) goto <D.35227>; else goto <D.35228>;
  <D.35227>:
  D.35226 = acfg->as_args;
  iftmp.375 = D.35226->str;
  goto <D.35229>;
  <D.35228>:
  iftmp.375 = "";
  <D.35229>:
  D.35210 = acfg->tmpfname;
  command = monoeg_g_strdup_printf ("%s%s %s %s -o %s %s", tool_prefix, "as", "", iftmp.375, objfile, D.35210);
  printf ("Executing the native assembler: %s\n", command);
  D.35230 = system (command);
  if (D.35230 != 0) goto <D.35231>; else goto <D.35232>;
  <D.35231>:
  monoeg_g_free (command);
  monoeg_g_free (objfile);
  D.35215 = 1;
  return D.35215;
  <D.35232>:
  monoeg_g_free (command);
  D.35211 = acfg->aot_opts.static_link;
  if (D.35211 != 0) goto <D.35233>; else goto <D.35234>;
  <D.35233>:
  printf ("Output file: \'%s\'.\n", objfile);
  D.35214 = acfg->static_linking_symbol;
  printf ("Linking symbol: \'%s\'.\n", D.35214);
  monoeg_g_free (objfile);
  D.35215 = 0;
  return D.35215;
  <D.35234>:
  D.35218 = acfg->aot_opts.outfile;
  if (D.35218 != 0B) goto <D.35235>; else goto <D.35236>;
  <D.35235>:
  D.35218 = acfg->aot_opts.outfile;
  outfile_name = monoeg_g_strdup_printf ("%s", D.35218);
  goto <D.35237>;
  <D.35236>:
  D.35222 = acfg->image;
  D.35223 = D.35222->name;
  outfile_name = monoeg_g_strdup_printf ("%s%s", D.35223, ".so");
  <D.35237>:
  tmp_outfile_name = monoeg_g_strdup_printf ("%s.tmp", outfile_name);
  D.35210 = acfg->tmpfname;
  command = monoeg_g_strdup_printf ("%sld %s -shared -o %s %s.o", tool_prefix, "", tmp_outfile_name, D.35210);
  printf ("Executing the native linker: %s\n", command);
  D.35238 = system (command);
  if (D.35238 != 0) goto <D.35239>; else goto <D.35240>;
  <D.35239>:
  monoeg_g_free (tmp_outfile_name);
  monoeg_g_free (outfile_name);
  monoeg_g_free (command);
  monoeg_g_free (objfile);
  D.35215 = 1;
  return D.35215;
  <D.35240>:
  monoeg_g_free (command);
  command = monoeg_g_strdup_printf ("%sstrip --strip-symbol=\\$a --strip-symbol=\\$d %s", tool_prefix, tmp_outfile_name);
  printf ("Stripping the binary: %s\n", command);
  D.35241 = system (command);
  if (D.35241 != 0) goto <D.35242>; else goto <D.35243>;
  <D.35242>:
  monoeg_g_free (tmp_outfile_name);
  monoeg_g_free (outfile_name);
  monoeg_g_free (command);
  monoeg_g_free (objfile);
  D.35215 = 1;
  return D.35215;
  <D.35243>:
  rename (tmp_outfile_name, outfile_name);
  D.35244 = acfg->aot_opts.save_temps;
  if (D.35244 == 0) goto <D.35245>; else goto <D.35246>;
  <D.35245>:
  unlink (objfile);
  <D.35246>:
  monoeg_g_free (tmp_outfile_name);
  monoeg_g_free (outfile_name);
  monoeg_g_free (objfile);
  D.35244 = acfg->aot_opts.save_temps;
  if (D.35244 != 0) goto <D.35247>; else goto <D.35248>;
  <D.35247>:
  printf ("Retained input file.\n");
  goto <D.35249>;
  <D.35248>:
  D.35210 = acfg->tmpfname;
  unlink (D.35210);
  <D.35249>:
  D.35215 = 0;
  return D.35215;
}


get_patch_name (int info)
{
  const char * D.35251;
  short int D.35252;
  sizetype D.35253;

  D.35252 = opidx[info];
  D.35253 = (sizetype) D.35252;
  D.35251 = &opstr + D.35253;
  return D.35251;
}


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

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


acfg_free (struct MonoAotCompile * acfg)
{
  struct MonoImageWriter * D.35257;
  struct MonoCompile * * D.35258;
  unsigned int i.376;
  unsigned int D.35260;
  struct MonoCompile * * D.35261;
  struct MonoCompile * D.35262;
  unsigned int i.377;
  unsigned int D.35266;
  char * D.35267;
  char * D.35268;
  char * D.35269;
  struct GPtrArray * D.35270;
  struct GPtrArray * D.35271;
  struct GPtrArray * D.35272;
  struct GPtrArray * D.35273;
  struct GPtrArray * D.35274;
  struct GHashTable * D.35275;
  struct GHashTable * D.35276;
  struct GHashTable * D.35277;
  struct GHashTable * * D.35278;
  struct GHashTable * * D.35279;
  struct GHashTable * D.35280;
  struct GHashTable * D.35283;
  struct GHashTable * D.35284;
  struct GHashTable * D.35285;
  struct GHashTable * D.35286;
  struct GHashTable * D.35287;
  struct GHashTable * D.35288;
  struct GHashTable * D.35289;
  struct GHashTable * D.35290;
  struct GHashTable * D.35291;
  struct GHashTable * D.35292;
  struct GHashTable * D.35293;
  struct GHashTable * * D.35294;
  struct GHashTable * * D.35295;
  struct GHashTable * D.35296;
  struct MonoMemPool * D.35297;
  int i;

  D.35257 = acfg->w;
  img_writer_destroy (D.35257);
  i = 0;
  goto <D.28565>;
  <D.28564>:
  D.35258 = acfg->cfgs;
  i.376 = (unsigned int) i;
  D.35260 = i.376 * 4;
  D.35261 = D.35258 + D.35260;
  D.35262 = *D.35261;
  if (D.35262 != 0B) goto <D.35263>; else goto <D.35264>;
  <D.35263>:
  D.35258 = acfg->cfgs;
  i.376 = (unsigned int) i;
  D.35260 = i.376 * 4;
  D.35261 = D.35258 + D.35260;
  D.35262 = *D.35261;
  monoeg_g_free (D.35262);
  <D.35264>:
  i = i + 1;
  <D.28565>:
  i.377 = (unsigned int) i;
  D.35266 = acfg->nmethods;
  if (i.377 < D.35266) goto <D.28564>; else goto <D.28566>;
  <D.28566>:
  D.35258 = acfg->cfgs;
  monoeg_g_free (D.35258);
  D.35267 = acfg->static_linking_symbol;
  monoeg_g_free (D.35267);
  D.35268 = acfg->got_symbol;
  monoeg_g_free (D.35268);
  D.35269 = acfg->plt_symbol;
  monoeg_g_free (D.35269);
  D.35270 = acfg->methods;
  monoeg_g_ptr_array_free (D.35270, 1);
  D.35271 = acfg->got_patches;
  monoeg_g_ptr_array_free (D.35271, 1);
  D.35272 = acfg->image_table;
  monoeg_g_ptr_array_free (D.35272, 1);
  D.35273 = acfg->globals;
  monoeg_g_ptr_array_free (D.35273, 1);
  D.35274 = acfg->unwind_ops;
  monoeg_g_ptr_array_free (D.35274, 1);
  D.35275 = acfg->method_indexes;
  monoeg_g_hash_table_destroy (D.35275);
  D.35276 = acfg->method_depth;
  monoeg_g_hash_table_destroy (D.35276);
  D.35277 = acfg->plt_offset_to_entry;
  monoeg_g_hash_table_destroy (D.35277);
  i = 0;
  goto <D.28568>;
  <D.28567>:
  D.35278 = acfg->patch_to_plt_entry;
  i.376 = (unsigned int) i;
  D.35260 = i.376 * 4;
  D.35279 = D.35278 + D.35260;
  D.35280 = *D.35279;
  if (D.35280 != 0B) goto <D.35281>; else goto <D.35282>;
  <D.35281>:
  D.35278 = acfg->patch_to_plt_entry;
  i.376 = (unsigned int) i;
  D.35260 = i.376 * 4;
  D.35279 = D.35278 + D.35260;
  D.35280 = *D.35279;
  monoeg_g_hash_table_destroy (D.35280);
  <D.35282>:
  i = i + 1;
  <D.28568>:
  if (i <= 51) goto <D.28567>; else goto <D.28569>;
  <D.28569>:
  D.35278 = acfg->patch_to_plt_entry;
  monoeg_g_free (D.35278);
  D.35283 = acfg->patch_to_got_offset;
  monoeg_g_hash_table_destroy (D.35283);
  D.35284 = acfg->method_to_cfg;
  monoeg_g_hash_table_destroy (D.35284);
  D.35285 = acfg->token_info_hash;
  monoeg_g_hash_table_destroy (D.35285);
  D.35286 = acfg->method_to_pinvoke_import;
  monoeg_g_hash_table_destroy (D.35286);
  D.35287 = acfg->image_hash;
  monoeg_g_hash_table_destroy (D.35287);
  D.35288 = acfg->unwind_info_offsets;
  monoeg_g_hash_table_destroy (D.35288);
  D.35289 = acfg->method_label_hash;
  monoeg_g_hash_table_destroy (D.35289);
  D.35290 = acfg->export_names;
  monoeg_g_hash_table_destroy (D.35290);
  D.35291 = acfg->plt_entry_debug_sym_cache;
  monoeg_g_hash_table_destroy (D.35291);
  D.35292 = acfg->klass_blob_hash;
  monoeg_g_hash_table_destroy (D.35292);
  D.35293 = acfg->method_blob_hash;
  monoeg_g_hash_table_destroy (D.35293);
  i = 0;
  goto <D.28571>;
  <D.28570>:
  D.35294 = acfg->patch_to_got_offset_by_type;
  i.376 = (unsigned int) i;
  D.35260 = i.376 * 4;
  D.35295 = D.35294 + D.35260;
  D.35296 = *D.35295;
  monoeg_g_hash_table_destroy (D.35296);
  i = i + 1;
  <D.28571>:
  if (i <= 51) goto <D.28570>; else goto <D.28572>;
  <D.28572>:
  D.35294 = acfg->patch_to_got_offset_by_type;
  monoeg_g_free (D.35294);
  D.35297 = acfg->mempool;
  mono_mempool_destroy (D.35297);
  monoeg_g_free (acfg);
}