mono_aot_readonly_field_override (struct MonoClassField * field)
{
  struct MonoClass * D.25571;
  const char * D.25572;
  unsigned int D.25573;
  unsigned int len.0;
  int D.25575;
  sizetype len.1;
  char * p.2;
  char D.25580;
  const char * D.25583;
  unsigned int D.25584;
  int D.25585;
  char * p.3;
  char D.25589;
  int D.24846;
  const char * D.25592;
  int D.25595;
  void * D.25596;
  struct ReadOnlyValue * rdv;

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

    p = rdv->name;
    D.25571 = field->parent;
    D.25572 = D.25571->name_space;
    D.25573 = strlen (D.25572);
    len = (int) D.25573;
    D.25571 = field->parent;
    D.25572 = D.25571->name_space;
    len.0 = (unsigned int) len;
    D.25575 = strncmp (p, D.25572, len.0);
    if (D.25575 != 0) goto <D.25576>; else goto <D.25577>;
    <D.25576>:
    // predicted unlikely by continue predictor.
    goto <D.24828>;
    <D.25577>:
    len.1 = (sizetype) len;
    p = p + len.1;
    p.2 = p;
    p = p.2 + 1;
    D.25580 = *p.2;
    if (D.25580 != 46) goto <D.25581>; else goto <D.25582>;
    <D.25581>:
    // predicted unlikely by continue predictor.
    goto <D.24828>;
    <D.25582>:
    D.25571 = field->parent;
    D.25583 = D.25571->name;
    D.25584 = strlen (D.25583);
    len = (int) D.25584;
    D.25571 = field->parent;
    D.25583 = D.25571->name;
    len.0 = (unsigned int) len;
    D.25585 = strncmp (p, D.25583, len.0);
    if (D.25585 != 0) goto <D.25586>; else goto <D.25587>;
    <D.25586>:
    // predicted unlikely by continue predictor.
    goto <D.24828>;
    <D.25587>:
    len.1 = (sizetype) len;
    p = p + len.1;
    p.3 = p;
    p = p.3 + 1;
    D.25589 = *p.3;
    if (D.25589 != 46) goto <D.25590>; else goto <D.25591>;
    <D.25590>:
    // predicted unlikely by continue predictor.
    goto <D.24828>;
    <D.25591>:
    {
      size_t __s1_len;
      size_t __s2_len;

      D.25592 = field->name;
      D.24846 = __builtin_strcmp (p, D.25592);
    }
    if (D.24846 != 0) goto <D.25593>; else goto <D.25594>;
    <D.25593>:
    // predicted unlikely by continue predictor.
    goto <D.24828>;
    <D.25594>:
    D.25595 = rdv->type;
    switch (D.25595) <default: <D.24850>, case 4: <D.24847>, case 6: <D.24848>, case 8: <D.24849>>
    <D.24847>:
    D.25596 = &rdv->value.i1;
    return D.25596;
    <D.24848>:
    D.25596 = &rdv->value.i2;
    return D.25596;
    <D.24849>:
    D.25596 = &rdv->value.i4;
    return D.25596;
    <D.24850>:
    goto <D.24851>;
    <D.24851>:
  }
  <D.24828>:
  rdv = rdv->next;
  <D.24853>:
  if (rdv != 0B) goto <D.24852>; else goto <D.24854>;
  <D.24854>:
  D.25596 = 0B;
  return D.25596;
}


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

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


get_got_offset (struct MonoAotCompile * acfg, struct MonoJumpInfo * ji)
{
  struct GHashTable * * D.25602;
  <unnamed type> D.25603;
  unsigned int D.25604;
  struct GHashTable * * D.25605;
  struct GHashTable * D.25606;
  void * D.25607;
  guint32 D.25610;
  unsigned int D.25611;
  unsigned int D.25612;
  unsigned int D.25613;
  _Bool D.25616;
  long int D.25617;
  long int D.25618;
  int D.25621;
  int D.25622;
  int D.25623;
  int D.25624;
  struct GHashTable * D.25625;
  unsigned int D.25626;
  void * D.25627;
  struct GPtrArray * D.25628;
  guint32 got_offset;

  D.25602 = acfg->patch_to_got_offset_by_type;
  D.25603 = ji->type;
  D.25604 = D.25603 * 4;
  D.25605 = D.25602 + D.25604;
  D.25606 = *D.25605;
  D.25607 = monoeg_g_hash_table_lookup (D.25606, ji);
  got_offset = (guint32) D.25607;
  if (got_offset != 0) goto <D.25608>; else goto <D.25609>;
  <D.25608>:
  D.25610 = got_offset + 4294967295;
  return D.25610;
  <D.25609>:
  got_offset = acfg->got_offset;
  D.25611 = acfg->got_offset;
  D.25612 = D.25611 + 1;
  acfg->got_offset = D.25612;
  D.25613 = acfg->final_got_size;
  if (D.25613 != 0) goto <D.25614>; else goto <D.25615>;
  <D.25614>:
  D.25613 = acfg->final_got_size;
  D.25616 = D.25613 <= got_offset;
  D.25617 = (long int) D.25616;
  D.25618 = __builtin_expect (D.25617, 0);
  if (D.25618 != 0) goto <D.25619>; else goto <D.25620>;
  <D.25619>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "aot-compiler.c", 2978, "got_offset < acfg->final_got_size");
  <D.25620>:
  <D.25615>:
  D.25621 = acfg->stats.got_slots;
  D.25622 = D.25621 + 1;
  acfg->stats.got_slots = D.25622;
  D.25603 = ji->type;
  D.25623 = acfg->stats.got_slot_types[D.25603];
  D.25624 = D.25623 + 1;
  acfg->stats.got_slot_types[D.25603] = D.25624;
  D.25625 = acfg->patch_to_got_offset;
  D.25626 = got_offset + 1;
  D.25627 = (void *) D.25626;
  monoeg_g_hash_table_insert_replace (D.25625, ji, D.25627, 0);
  D.25602 = acfg->patch_to_got_offset_by_type;
  D.25603 = ji->type;
  D.25604 = D.25603 * 4;
  D.25605 = D.25602 + D.25604;
  D.25606 = *D.25605;
  D.25626 = got_offset + 1;
  D.25627 = (void *) D.25626;
  monoeg_g_hash_table_insert_replace (D.25606, ji, D.25627, 0);
  D.25628 = acfg->got_patches;
  monoeg_g_ptr_array_add (D.25628, ji);
  D.25610 = got_offset;
  return D.25610;
}


mono_aot_get_method_name (struct MonoCompile * cfg)
{
  struct MonoAotCompile * llvm_acfg.5;
  int D.25631;
  char * D.25634;
  char * D.25635;
  struct MonoMethod * D.25636;
  struct GHashTable * D.25637;
  char * D.25638;

  llvm_acfg.5 = llvm_acfg;
  D.25631 = llvm_acfg.5->aot_opts.static_link;
  if (D.25631 != 0) goto <D.25632>; else goto <D.25633>;
  <D.25632>:
  llvm_acfg.5 = llvm_acfg;
  D.25635 = llvm_acfg.5->assembly_name_sym;
  D.25636 = cfg->orig_method;
  llvm_acfg.5 = llvm_acfg;
  D.25637 = llvm_acfg.5->method_label_hash;
  D.25638 = get_debug_sym (D.25636, "", D.25637);
  D.25634 = monoeg_g_strdup_printf ("%s_%s", D.25635, D.25638);
  return D.25634;
  <D.25633>:
  D.25636 = cfg->orig_method;
  llvm_acfg.5 = llvm_acfg;
  D.25637 = llvm_acfg.5->method_label_hash;
  D.25634 = get_debug_sym (D.25636, "", D.25637);
  return D.25634;
}


get_debug_sym (struct MonoMethod * method, const char * prefix, struct GHashTable * cache)
{
  unsigned int D.25640;
  unsigned int D.25641;
  unsigned int len.6;
  unsigned int D.25643;
  unsigned int D.25644;
  unsigned int D.25645;
  unsigned int D.25646;
  const short unsigned int * * D.25647;
  const short unsigned int * D.25648;
  sizetype i.7;
  char * D.25650;
  char D.25651;
  unsigned int D.25652;
  unsigned int D.25653;
  const short unsigned int * D.25654;
  short unsigned int D.25655;
  int D.25656;
  int D.25657;
  int j.8;
  sizetype j.9;
  char * D.25662;
  sizetype D.25667;
  char * D.25668;
  char D.25669;
  sizetype D.25671;
  char * D.25672;
  char D.25673;
  int j.10;
  sizetype j.11;
  char * D.25681;
  unsigned char D.25682;
  unsigned char D.25683;
  int j.12;
  sizetype j.13;
  char * D.25691;
  sizetype j.14;
  char * D.25693;
  void * D.25694;
  char * D.25695;
  char * name1;
  char * name2;
  char * cached;
  int i;
  int j;
  int len;
  int count;

  name1 = mono_method_full_name (method, 1);
  D.25640 = strlen (name1);
  len = (int) D.25640;
  D.25641 = strlen (prefix);
  len.6 = (unsigned int) len;
  D.25643 = D.25641 + len.6;
  D.25644 = D.25643 + 16;
  name2 = malloc (D.25644);
  D.25645 = strlen (prefix);
  memcpy (name2, prefix, D.25645);
  D.25646 = strlen (prefix);
  j = (int) D.25646;
  i = 0;
  goto <D.24450>;
  <D.24449>:
  D.25647 = __ctype_b_loc ();
  D.25648 = *D.25647;
  i.7 = (sizetype) i;
  D.25650 = name1 + i.7;
  D.25651 = *D.25650;
  D.25652 = (unsigned int) D.25651;
  D.25653 = D.25652 * 2;
  D.25654 = D.25648 + D.25653;
  D.25655 = *D.25654;
  D.25656 = (int) D.25655;
  D.25657 = D.25656 & 8;
  if (D.25657 != 0) goto <D.25658>; else goto <D.25659>;
  <D.25658>:
  j.8 = j;
  j = j.8 + 1;
  j.9 = (sizetype) j.8;
  D.25662 = name2 + j.9;
  i.7 = (sizetype) i;
  D.25650 = name1 + i.7;
  D.25651 = *D.25650;
  *D.25662 = D.25651;
  goto <D.25663>;
  <D.25659>:
  i.7 = (sizetype) i;
  D.25650 = name1 + i.7;
  D.25651 = *D.25650;
  if (D.25651 == 32) goto <D.25666>; else goto <D.25664>;
  <D.25666>:
  i.7 = (sizetype) i;
  D.25667 = i.7 + 1;
  D.25668 = name1 + D.25667;
  D.25669 = *D.25668;
  if (D.25669 == 40) goto <D.25670>; else goto <D.25664>;
  <D.25670>:
  i.7 = (sizetype) i;
  D.25671 = i.7 + 2;
  D.25672 = name1 + D.25671;
  D.25673 = *D.25672;
  if (D.25673 == 41) goto <D.25674>; else goto <D.25664>;
  <D.25674>:
  i = i + 2;
  goto <D.25665>;
  <D.25664>:
  i.7 = (sizetype) i;
  D.25650 = name1 + i.7;
  D.25651 = *D.25650;
  if (D.25651 == 44) goto <D.25677>; else goto <D.25675>;
  <D.25677>:
  i.7 = (sizetype) i;
  D.25667 = i.7 + 1;
  D.25668 = name1 + D.25667;
  D.25669 = *D.25668;
  if (D.25669 == 32) goto <D.25678>; else goto <D.25675>;
  <D.25678>:
  j.10 = j;
  j = j.10 + 1;
  j.11 = (sizetype) j.10;
  D.25681 = name2 + j.11;
  *D.25681 = 95;
  i = i + 1;
  goto <D.25676>;
  <D.25675>:
  i.7 = (sizetype) i;
  D.25650 = name1 + i.7;
  D.25651 = *D.25650;
  D.25682 = (unsigned char) D.25651;
  D.25683 = D.25682 + 216;
  if (D.25683 <= 1) goto <D.25684>; else goto <D.25685>;
  <D.25685>:
  i.7 = (sizetype) i;
  D.25650 = name1 + i.7;
  D.25651 = *D.25650;
  if (D.25651 == 62) goto <D.25686>; else goto <D.25687>;
  <D.25686>:
  goto <D.25688>;
  <D.25687>:
  j.12 = j;
  j = j.12 + 1;
  j.13 = (sizetype) j.12;
  D.25691 = name2 + j.13;
  *D.25691 = 95;
  <D.25688>:
  <D.25684>:
  <D.25676>:
  <D.25665>:
  <D.25663>:
  i = i + 1;
  <D.24450>:
  if (i < len) goto <D.24449>; else goto <D.24451>;
  <D.24451>:
  j.14 = (sizetype) j;
  D.25693 = name2 + j.14;
  *D.25693 = 0;
  monoeg_g_free (name1);
  count = 0;
  goto <D.24453>;
  <D.24452>:
  j.14 = (sizetype) j;
  D.25693 = name2 + j.14;
  sprintf (D.25693, "_%d", count);
  count = count + 1;
  <D.24453>:
  D.25694 = monoeg_g_hash_table_lookup (cache, name2);
  if (D.25694 != 0B) goto <D.24452>; else goto <D.24454>;
  <D.24454>:
  cached = monoeg_strdup (name2);
  monoeg_g_hash_table_insert_replace (cache, cached, cached, 0);
  D.25695 = name2;
  return D.25695;
}


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

  D.25698 = __builtin_object_size (__dest, 0);
  D.25697 = __builtin___memcpy_chk (__dest, __src, __len, D.25698);
  return D.25697;
}


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

  D.25701 = __builtin_object_size (__s, 1);
  D.25700 = __builtin___sprintf_chk (__s, 1, D.25701, __fmt, __builtin_va_arg_pack ());
  return D.25700;
}


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

  if (str != 0B) goto <D.25703>; else goto <D.25704>;
  <D.25703>:
  D.25705 = __strdup (str);
  return D.25705;
  <D.25704>:
  D.25705 = 0B;
  return D.25705;
}


mono_aot_get_plt_symbol (MonoJumpInfoType type, const void * data)
{
  struct MonoAotCompile * llvm_acfg.15;
  struct MonoMemPool * D.25708;
  int D.25709;
  char * D.25712;
  char * D.25713;
  struct MonoJumpInfo * ji;
  struct MonoPltEntry * plt_entry;

  llvm_acfg.15 = llvm_acfg;
  D.25708 = llvm_acfg.15->mempool;
  ji = mono_mempool_alloc (D.25708, 20);
  ji->type = type;
  ji->data.target = data;
  llvm_acfg.15 = llvm_acfg;
  D.25709 = can_encode_patch (llvm_acfg.15, ji);
  if (D.25709 == 0) goto <D.25710>; else goto <D.25711>;
  <D.25710>:
  D.25712 = 0B;
  return D.25712;
  <D.25711>:
  llvm_acfg.15 = llvm_acfg;
  plt_entry = get_plt_entry (llvm_acfg.15, ji);
  plt_entry->llvm_used = 1;
  D.25713 = plt_entry->llvm_symbol;
  D.25712 = monoeg_g_strdup_printf (D.25713);
  return D.25712;
}


can_encode_patch (struct MonoAotCompile * acfg, struct MonoJumpInfo * patch_info)
{
  <unnamed type> D.25715;
  gboolean D.25716;
  struct MonoClass * D.25717;
  int D.25718;
  struct MonoMethod * D.25721;
  int D.25722;
  struct MonoJumpInfo * D.25725;
  int D.25726;

  D.25715 = patch_info->type;
  switch (D.25715) <default: <D.24957>, case 3: <D.24944>, case 6: <D.24945>, case 11: <D.24951>, case 14: <D.24948>, case 15: <D.24949>, case 23: <D.24952>, case 24: <D.24953>, case 30: <D.24950>, case 35: <D.24955>, case 50: <D.24946>>
  <D.24944>:
  <D.24945>:
  <D.24946>:
  {
    struct MonoMethod * method;

    method = patch_info->data.method;
    D.25716 = can_encode_method (acfg, method);
    return D.25716;
  }
  <D.24948>:
  <D.24949>:
  <D.24950>:
  <D.24951>:
  <D.24952>:
  <D.24953>:
  D.25717 = patch_info->data.klass;
  D.25718 = can_encode_class (acfg, D.25717);
  if (D.25718 == 0) goto <D.25719>; else goto <D.25720>;
  <D.25719>:
  D.25716 = 0;
  return D.25716;
  <D.25720>:
  goto <D.24954>;
  <D.24955>:
  {
    struct MonoJumpInfoRgctxEntry * entry;

    entry = patch_info->data.rgctx_entry;
    D.25721 = entry->method;
    D.25722 = can_encode_method (acfg, D.25721);
    if (D.25722 == 0) goto <D.25723>; else goto <D.25724>;
    <D.25723>:
    D.25716 = 0;
    return D.25716;
    <D.25724>:
    D.25725 = entry->data;
    D.25726 = can_encode_patch (acfg, D.25725);
    if (D.25726 == 0) goto <D.25727>; else goto <D.25728>;
    <D.25727>:
    D.25716 = 0;
    return D.25716;
    <D.25728>:
    goto <D.24954>;
  }
  <D.24957>:
  goto <D.24954>;
  <D.24954>:
  D.25716 = 1;
  return D.25716;
}


can_encode_class (struct MonoAotCompile * acfg, struct MonoClass * klass)
{
  unsigned int D.25731;
  gboolean D.25734;
  unsigned char D.25737;
  unsigned char D.25740;
  struct MonoClass * D.25743;

  D.25731 = klass->type_token;
  if (D.25731 != 0) goto <D.25732>; else goto <D.25733>;
  <D.25732>:
  D.25734 = 1;
  return D.25734;
  <D.25733>:
  D.25737 = klass->byval_arg.type;
  if (D.25737 == 19) goto <D.25735>; else goto <D.25738>;
  <D.25738>:
  D.25737 = klass->byval_arg.type;
  if (D.25737 == 30) goto <D.25735>; else goto <D.25739>;
  <D.25739>:
  D.25737 = klass->byval_arg.type;
  if (D.25737 == 15) goto <D.25735>; else goto <D.25736>;
  <D.25735>:
  D.25734 = 1;
  return D.25734;
  <D.25736>:
  D.25740 = klass->rank;
  if (D.25740 != 0) goto <D.25741>; else goto <D.25742>;
  <D.25741>:
  D.25743 = klass->element_class;
  D.25734 = can_encode_class (acfg, D.25743);
  return D.25734;
  <D.25742>:
  D.25734 = 0;
  return D.25734;
}


can_encode_method (struct MonoAotCompile * acfg, struct MonoMethod * method)
{
  unsigned int D.25745;
  unsigned int D.25746;
  <unnamed-unsigned:5> D.25749;
  int D.25750;
  gboolean D.25753;
  unsigned int D.25755;
  struct GHashTable * D.25758;
  void * D.25759;
  struct MonoClass * D.25762;
  unsigned char D.25763;

  D.25745 = BIT_FIELD_REF <*method, 32, 160>;
  D.25746 = D.25745 & 124;
  if (D.25746 != 0) goto <D.25747>; else goto <D.25748>;
  <D.25747>:
  D.25749 = method->wrapper_type;
  D.25750 = (int) D.25749;
  switch (D.25750) <default: <D.24939>, case 0: <D.24916>, case 1: <D.24931>, case 2: <D.24932>, case 3: <D.24933>, case 7: <D.24936>, case 8: <D.24928>, case 9: <D.24917>, case 10: <D.24918>, case 12: <D.24920>, case 13: <D.24919>, case 14: <D.24922>, case 15: <D.24923>, case 16: <D.24934>, case 18: <D.24925>, case 19: <D.24937>, case 20: <D.24926>, case 21: <D.24924>, case 23: <D.24921>, case 24: <D.24930>, case 25: <D.24929>, case 28: <D.24927>>
  <D.24916>:
  <D.24917>:
  <D.24918>:
  <D.24919>:
  <D.24920>:
  <D.24921>:
  <D.24922>:
  <D.24923>:
  <D.24924>:
  <D.24925>:
  <D.24926>:
  <D.24927>:
  <D.24928>:
  <D.24929>:
  <D.24930>:
  <D.24931>:
  <D.24932>:
  <D.24933>:
  <D.24934>:
  goto <D.24935>;
  <D.24936>:
  <D.24937>:
  {
    struct WrapperInfo * info;

    info = mono_marshal_get_wrapper_info (method);
    if (info != 0B) goto <D.25751>; else goto <D.25752>;
    <D.25751>:
    D.25753 = 1;
    return D.25753;
    <D.25752>:
    D.25753 = 0;
    return D.25753;
  }
  <D.24939>:
  D.25753 = 0;
  return D.25753;
  <D.24935>:
  goto <D.25754>;
  <D.25748>:
  D.25755 = method->token;
  if (D.25755 == 0) goto <D.25756>; else goto <D.25757>;
  <D.25756>:
  D.25758 = acfg->token_info_hash;
  D.25759 = monoeg_g_hash_table_lookup (D.25758, method);
  if (D.25759 == 0B) goto <D.25760>; else goto <D.25761>;
  <D.25760>:
  D.25762 = method->klass;
  D.25763 = D.25762->rank;
  if (D.25763 != 0) goto <D.25764>; else goto <D.25765>;
  <D.25764>:
  D.25753 = 1;
  return D.25753;
  <D.25765>:
  D.25753 = 0;
  return D.25753;
  <D.25761>:
  <D.25757>:
  <D.25754>:
  D.25753 = 1;
  return D.25753;
}


get_plt_entry (struct MonoAotCompile * acfg, struct MonoJumpInfo * patch_info)
{
  int D.25769;
  struct MonoPltEntry * D.25772;
  struct GHashTable * * D.25773;
  <unnamed type> D.25774;
  unsigned int D.25775;
  struct GHashTable * * D.25776;
  struct GHashTable * D.25777;
  struct GHashTable * D.25780;
  int D.25781;
  struct MonoMethod * D.25786;
  short unsigned int D.25787;
  int D.25788;
  int D.25789;
  unsigned int D.25794;
  _Bool D.25795;
  long int D.25796;
  long int D.25797;
  struct MonoMemPool * D.25800;
  unsigned int D.25801;
  int D.25802;
  int D.25803;
  char * D.25804;
  int D.25805;
  struct MonoJumpInfo * D.25808;
  struct GHashTable * D.25809;
  char * D.25810;
  char * D.25811;
  char * D.25814;
  gchar * D.25815;
  gchar * D.25817;
  <unnamed type> D.25818;
  unsigned int D.25819;
  struct GHashTable * * D.25820;
  struct GHashTable * D.25821;
  struct GHashTable * D.25822;
  void * D.25823;
  unsigned int D.25824;
  struct MonoPltEntry * res;

  D.25769 = is_plt_patch (patch_info);
  if (D.25769 == 0) goto <D.25770>; else goto <D.25771>;
  <D.25770>:
  D.25772 = 0B;
  return D.25772;
  <D.25771>:
  D.25773 = acfg->patch_to_plt_entry;
  D.25774 = patch_info->type;
  D.25775 = D.25774 * 4;
  D.25776 = D.25773 + D.25775;
  D.25777 = *D.25776;
  if (D.25777 == 0B) goto <D.25778>; else goto <D.25779>;
  <D.25778>:
  D.25773 = acfg->patch_to_plt_entry;
  D.25774 = patch_info->type;
  D.25775 = D.25774 * 4;
  D.25776 = D.25773 + D.25775;
  D.25780 = monoeg_g_hash_table_new (mono_patch_info_hash, mono_patch_info_equal);
  *D.25776 = D.25780;
  <D.25779>:
  D.25773 = acfg->patch_to_plt_entry;
  D.25774 = patch_info->type;
  D.25775 = D.25774 * 4;
  D.25776 = D.25773 + D.25775;
  D.25777 = *D.25776;
  res = monoeg_g_hash_table_lookup (D.25777, patch_info);
  D.25781 = acfg->llvm;
  if (D.25781 == 0) goto <D.25782>; else goto <D.25783>;
  <D.25782>:
  D.25774 = patch_info->type;
  if (D.25774 == 3) goto <D.25784>; else goto <D.25785>;
  <D.25784>:
  D.25786 = patch_info->data.method;
  D.25787 = D.25786->iflags;
  D.25788 = (int) D.25787;
  D.25789 = D.25788 & 32;
  if (D.25789 != 0) goto <D.25790>; else goto <D.25791>;
  <D.25790>:
  res = 0B;
  <D.25791>:
  <D.25785>:
  <D.25783>:
  if (res == 0B) goto <D.25792>; else goto <D.25793>;
  <D.25792>:
  {
    struct MonoJumpInfo * new_ji;

    D.25794 = acfg->final_got_size;
    D.25795 = D.25794 != 0;
    D.25796 = (long int) D.25795;
    D.25797 = __builtin_expect (D.25796, 0);
    if (D.25797 != 0) goto <D.25798>; else goto <D.25799>;
    <D.25798>:
    monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "aot-compiler.c", 2930, "!acfg->final_got_size");
    <D.25799>:
    D.25800 = acfg->mempool;
    new_ji = mono_patch_info_dup_mp (D.25800, patch_info);
    D.25800 = acfg->mempool;
    res = mono_mempool_alloc0 (D.25800, 28);
    D.25801 = acfg->plt_offset;
    D.25802 = (int) D.25801;
    res->plt_offset = D.25802;
    res->ji = new_ji;
    D.25803 = res->plt_offset;
    D.25804 = get_plt_symbol (acfg, D.25803, patch_info);
    res->symbol = D.25804;
    D.25805 = acfg->aot_opts.write_symbols;
    if (D.25805 != 0) goto <D.25806>; else goto <D.25807>;
    <D.25806>:
    D.25808 = res->ji;
    D.25809 = acfg->plt_entry_debug_sym_cache;
    D.25810 = get_plt_entry_debug_sym (acfg, D.25808, D.25809);
    res->debug_sym = D.25810;
    <D.25807>:
    D.25811 = res->debug_sym;
    if (D.25811 != 0B) goto <D.25812>; else goto <D.25813>;
    <D.25812>:
    D.25814 = res->symbol;
    D.25811 = res->debug_sym;
    D.25815 = monoeg_g_strdup_printf ("%s_%s_llvm", D.25814, D.25811);
    res->llvm_symbol = D.25815;
    goto <D.25816>;
    <D.25813>:
    D.25814 = res->symbol;
    D.25817 = monoeg_g_strdup_printf ("%s_llvm", D.25814);
    res->llvm_symbol = D.25817;
    <D.25816>:
    D.25773 = acfg->patch_to_plt_entry;
    D.25818 = new_ji->type;
    D.25819 = D.25818 * 4;
    D.25820 = D.25773 + D.25819;
    D.25821 = *D.25820;
    monoeg_g_hash_table_insert_replace (D.25821, new_ji, res, 0);
    D.25822 = acfg->plt_offset_to_entry;
    D.25803 = res->plt_offset;
    D.25823 = (void *) D.25803;
    monoeg_g_hash_table_insert_replace (D.25822, D.25823, res, 0);
    D.25801 = acfg->plt_offset;
    D.25824 = D.25801 + 1;
    acfg->plt_offset = D.25824;
  }
  <D.25793>:
  D.25772 = res;
  return D.25772;
}


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

  D.25826 = patch_info->type;
  switch (D.25826) <default: <D.23678>, case 3: <D.23668>, case 7: <D.23669>, case 15: <D.23672>, case 31: <D.23671>, case 32: <D.23670>, case 35: <D.23673>, case 36: <D.23674>, case 37: <D.23675>, case 38: <D.23676>, case 41: <D.23677>>
  <D.23668>:
  <D.23669>:
  <D.23670>:
  <D.23671>:
  <D.23672>:
  <D.23673>:
  <D.23674>:
  <D.23675>:
  <D.23676>:
  <D.23677>:
  D.25827 = 1;
  return D.25827;
  <D.23678>:
  D.25827 = 0;
  return D.25827;
}


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

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


get_plt_entry_debug_sym (struct MonoAotCompile * acfg, struct MonoJumpInfo * ji, struct GHashTable * cache)
{
  <unnamed type> D.25832;
  struct MonoMethod * D.25833;
  const char * D.25834;
  struct MonoClass * D.25835;
  struct MonoType * D.25836;
  unsigned int D.25837;
  unsigned int D.25838;
  unsigned int D.25839;
  char * D.25840;
  char * debug_sym;
  char * s;

  debug_sym = 0B;
  D.25832 = ji->type;
  switch (D.25832) <default: <D.24710>, case 3: <D.24701>, case 7: <D.24703>, case 15: <D.24704>, case 31: <D.24706>, case 32: <D.24708>, case 35: <D.24705>, case 36: <D.24709>>
  <D.24701>:
  D.25833 = ji->data.method;
  debug_sym = get_debug_sym (D.25833, "plt_", cache);
  goto <D.24702>;
  <D.24703>:
  D.25834 = ji->data.name;
  debug_sym = monoeg_g_strdup_printf ("plt__jit_icall_%s", D.25834);
  goto <D.24702>;
  <D.24704>:
  D.25835 = ji->data.klass;
  D.25836 = &D.25835->byval_arg;
  s = mono_type_get_name (D.25836);
  debug_sym = monoeg_g_strdup_printf ("plt__class_init_%s", s);
  monoeg_g_free (s);
  goto <D.24702>;
  <D.24705>:
  D.25837 = acfg->label_generator;
  D.25838 = D.25837;
  D.25839 = D.25838 + 1;
  acfg->label_generator = D.25839;
  debug_sym = monoeg_g_strdup_printf ("plt__rgctx_fetch_%d", D.25838);
  goto <D.24702>;
  <D.24706>:
  {
    char * s;

    D.25833 = ji->data.method;
    s = get_debug_sym (D.25833, "", cache);
    debug_sym = monoeg_g_strdup_printf ("plt__icall_native_%s", s);
    monoeg_g_free (s);
    goto <D.24702>;
  }
  <D.24708>:
  D.25834 = ji->data.name;
  debug_sym = monoeg_g_strdup_printf ("plt__jit_icall_native_%s", D.25834);
  goto <D.24702>;
  <D.24709>:
  debug_sym = monoeg_g_strdup_printf ("plt__generic_class_init");
  goto <D.24702>;
  <D.24710>:
  goto <D.24702>;
  <D.24702>:
  D.25840 = sanitize_symbol (acfg, debug_sym);
  return D.25840;
}


sanitize_symbol (struct MonoAotCompile * acfg, char * s)
{
  char * D.25845;
  unsigned int D.25846;
  const short unsigned int * * D.25847;
  const short unsigned int * D.25848;
  sizetype i.16;
  char * D.25850;
  char D.25851;
  unsigned int D.25852;
  unsigned int D.25853;
  const short unsigned int * D.25854;
  short unsigned int D.25855;
  int D.25856;
  int D.25857;
  unsigned int len.17;
  signed char c.18;
  unsigned int D.25870;
  unsigned int D.25871;
  const short unsigned int * D.25872;
  short unsigned int D.25873;
  int D.25874;
  int D.25875;
  char c.19;
  int D.25878;
  int D.25881;
  unsigned char D.25882;
  struct MonoMemPool * D.25884;
  char * D.25885;
  gboolean process;
  int i;
  int len;
  struct GString * gs;
  char * res;

  process = 0;
  if (s == 0B) goto <D.25843>; else goto <D.25844>;
  <D.25843>:
  D.25845 = s;
  return D.25845;
  <D.25844>:
  D.25846 = strlen (s);
  len = (int) D.25846;
  i = 0;
  goto <D.24428>;
  <D.24427>:
  D.25847 = __ctype_b_loc ();
  D.25848 = *D.25847;
  i.16 = (sizetype) i;
  D.25850 = s + i.16;
  D.25851 = *D.25850;
  D.25852 = (unsigned int) D.25851;
  D.25853 = D.25852 * 2;
  D.25854 = D.25848 + D.25853;
  D.25855 = *D.25854;
  D.25856 = (int) D.25855;
  D.25857 = D.25856 & 8;
  if (D.25857 == 0) goto <D.25858>; else goto <D.25859>;
  <D.25858>:
  i.16 = (sizetype) i;
  D.25850 = s + i.16;
  D.25851 = *D.25850;
  if (D.25851 != 95) goto <D.25860>; else goto <D.25861>;
  <D.25860>:
  process = 1;
  <D.25861>:
  <D.25859>:
  i = i + 1;
  <D.24428>:
  if (i < len) goto <D.24427>; else goto <D.24429>;
  <D.24429>:
  if (process == 0) goto <D.25862>; else goto <D.25863>;
  <D.25862>:
  D.25845 = s;
  return D.25845;
  <D.25863>:
  len.17 = (unsigned int) len;
  gs = monoeg_g_string_sized_new (len.17);
  i = 0;
  goto <D.24435>;
  <D.24434>:
  {
    guint8 c;

    i.16 = (sizetype) i;
    D.25850 = s + i.16;
    D.25851 = *D.25850;
    c = (guint8) D.25851;
    c.18 = (signed char) c;
    if (c.18 >= 0) goto <D.25869>; else goto <D.25865>;
    <D.25869>:
    D.25847 = __ctype_b_loc ();
    D.25848 = *D.25847;
    D.25870 = (unsigned int) c;
    D.25871 = D.25870 * 2;
    D.25872 = D.25848 + D.25871;
    D.25873 = *D.25872;
    D.25874 = (int) D.25873;
    D.25875 = D.25874 & 8;
    if (D.25875 != 0) goto <D.25866>; else goto <D.25876>;
    <D.25876>:
    if (c == 95) goto <D.25866>; else goto <D.25865>;
    <D.25866>:
    c.19 = (char) c;
    D.25878 = (int) c.19;
    monoeg_g_string_append_c (gs, D.25878);
    goto <D.25867>;
    <D.25865>:
    c.18 = (signed char) c;
    if (c.18 < 0) goto <D.25879>; else goto <D.25880>;
    <D.25879>:
    D.25881 = (int) c;
    monoeg_g_string_append_printf (gs, "_0x%x", D.25881);
    i = i + 1;
    i.16 = (sizetype) i;
    D.25850 = s + i.16;
    D.25851 = *D.25850;
    c = (guint8) D.25851;
    goto <D.24432>;
    <D.24431>:
    D.25881 = (int) c;
    monoeg_g_string_append_printf (gs, "%x", D.25881);
    i = i + 1;
    i.16 = (sizetype) i;
    D.25850 = s + i.16;
    D.25851 = *D.25850;
    c = (guint8) D.25851;
    <D.24432>:
    D.25882 = c >> 6;
    if (D.25882 == 2) goto <D.24431>; else goto <D.24433>;
    <D.24433>:
    monoeg_g_string_append_printf (gs, "_");
    i = i + -1;
    goto <D.25883>;
    <D.25880>:
    monoeg_g_string_append_c (gs, 95);
    <D.25883>:
    <D.25867>:
  }
  i = i + 1;
  <D.24435>:
  if (i < len) goto <D.24434>; else goto <D.24436>;
  <D.24436>:
  D.25884 = acfg->mempool;
  D.25885 = gs->str;
  res = mono_mempool_strdup (D.25884, D.25885);
  monoeg_g_string_free (gs, 1);
  D.25845 = res;
  return D.25845;
}


mono_aot_get_method_index (struct MonoMethod * method)
{
  struct MonoAotCompile * llvm_acfg.20;
  _Bool D.25888;
  long int D.25889;
  long int D.25890;
  int D.25893;
  unsigned int D.25894;

  llvm_acfg.20 = llvm_acfg;
  D.25888 = llvm_acfg.20 == 0B;
  D.25889 = (long int) D.25888;
  D.25890 = __builtin_expect (D.25889, 0);
  if (D.25890 != 0) goto <D.25891>; else goto <D.25892>;
  <D.25891>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "aot-compiler.c", 6895, "llvm_acfg");
  <D.25892>:
  llvm_acfg.20 = llvm_acfg;
  D.25894 = get_method_index (llvm_acfg.20, method);
  D.25893 = (int) D.25894;
  return D.25893;
}


get_method_index (struct MonoAotCompile * acfg, struct MonoMethod * method)
{
  struct GHashTable * D.25896;
  void * D.25897;
  _Bool D.25898;
  long int D.25899;
  long int D.25900;
  guint32 D.25903;
  int D.25904;
  int index;

  D.25896 = acfg->method_indexes;
  D.25897 = monoeg_g_hash_table_lookup (D.25896, method);
  index = (int) D.25897;
  D.25898 = index == 0;
  D.25899 = (long int) D.25898;
  D.25900 = __builtin_expect (D.25899, 0);
  if (D.25900 != 0) goto <D.25901>; else goto <D.25902>;
  <D.25901>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "aot-compiler.c", 3010, "index");
  <D.25902>:
  D.25904 = index + -1;
  D.25903 = (guint32) D.25904;
  return D.25903;
}


mono_aot_patch_info_dup (struct MonoJumpInfo * ji)
{
  struct MonoAotCompile * llvm_acfg.21;
  union mono_mutex_t * D.25907;
  _Bool D.25910;
  long int D.25911;
  long int D.25912;
  struct MonoMemPool * D.25915;
  _Bool D.25918;
  long int D.25919;
  long int D.25920;
  struct MonoJumpInfo * D.25923;
  struct MonoJumpInfo * res;

  {
    int ret;

    llvm_acfg.21 = llvm_acfg;
    D.25907 = &llvm_acfg.21->mutex.mutex;
    ret = pthread_mutex_lock (D.25907);
    if (ret != 0) goto <D.25908>; else goto <D.25909>;
    <D.25908>:
    monoeg_g_log (0B, 16, "Bad call to mono_mutex_lock result %d", ret);
    <D.25909>:
    D.25910 = ret != 0;
    D.25911 = (long int) D.25910;
    D.25912 = __builtin_expect (D.25911, 0);
    if (D.25912 != 0) goto <D.25913>; else goto <D.25914>;
    <D.25913>:
    monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "aot-compiler.c", 6904, "ret == 0");
    <D.25914>:
  }
  llvm_acfg.21 = llvm_acfg;
  D.25915 = llvm_acfg.21->mempool;
  res = mono_patch_info_dup_mp (D.25915, ji);
  {
    int ret;

    llvm_acfg.21 = llvm_acfg;
    D.25907 = &llvm_acfg.21->mutex.mutex;
    ret = pthread_mutex_unlock (D.25907);
    if (ret != 0) goto <D.25916>; else goto <D.25917>;
    <D.25916>:
    monoeg_g_log (0B, 16, "Bad call to mono_mutex_unlock result %d", ret);
    <D.25917>:
    D.25918 = ret != 0;
    D.25919 = (long int) D.25918;
    D.25920 = __builtin_expect (D.25919, 0);
    if (D.25920 != 0) goto <D.25921>; else goto <D.25922>;
    <D.25921>:
    monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "aot-compiler.c", 6906, "ret == 0");
    <D.25922>:
  }
  D.25923 = res;
  return D.25923;
}


mono_aot_method_hash (struct MonoMethod * method)
{
  unsigned int D.25925;
  unsigned int D.25926;
  short unsigned int D.25929;
  int D.25930;
  int D.25931;
  int iftmp.22;
  <unnamed-unsigned:22> D.25935;
  unsigned int hashes_count.23;
  unsigned int D.25938;
  unsigned int D.25942;
  struct MonoType * D.25946;
  unsigned int D.25947;
  guint32 * D.25948;
  const char * D.25950;
  unsigned int D.25951;
  const char * D.25952;
  unsigned int D.25953;
  guint32 * D.25959;
  const char * D.25960;
  unsigned int D.25961;
  guint32 * D.25962;
  <unnamed-unsigned:5> D.25963;
  unsigned int D.25964;
  guint32 * D.25965;
  struct MonoType * D.25966;
  unsigned int D.25967;
  int hindex.24;
  unsigned int hindex.25;
  unsigned int D.25970;
  guint32 * D.25971;
  struct MonoType * D.25972;
  unsigned int D.25973;
  int hindex.26;
  unsigned int hindex.27;
  unsigned int D.25978;
  guint32 * D.25979;
  struct MonoType * D.25980;
  unsigned int D.25981;
  int D.25982;
  _Bool D.25983;
  long int D.25984;
  long int D.25985;
  unsigned int D.25988;
  unsigned int D.25989;
  unsigned int D.25990;
  unsigned int D.25991;
  unsigned int D.25992;
  unsigned int D.25993;
  unsigned int D.25994;
  unsigned int D.25995;
  unsigned int D.25996;
  unsigned int D.25997;
  unsigned int D.25998;
  unsigned int D.25999;
  unsigned int D.26000;
  unsigned int D.26001;
  unsigned int D.26002;
  unsigned int D.26003;
  guint32 D.26005;
  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.25925 = BIT_FIELD_REF <*method, 32, 160>;
  D.25926 = D.25925 & 4096;
  if (D.25926 != 0) goto <D.25927>; else goto <D.25928>;
  <D.25927>:
  ginst = MEM[(struct MonoMethodInflated *)method].context.method_inst;
  <D.25928>:
  D.25929 = sig->param_count;
  D.25930 = (int) D.25929;
  D.25931 = D.25930 + 5;
  if (ginst != 0B) goto <D.25933>; else goto <D.25934>;
  <D.25933>:
  D.25935 = ginst->type_argc;
  iftmp.22 = (int) D.25935;
  goto <D.25936>;
  <D.25934>:
  iftmp.22 = 0;
  <D.25936>:
  hashes_count = D.25931 + iftmp.22;
  hashes_count.23 = (unsigned int) hashes_count;
  D.25938 = hashes_count.23 * 4;
  hashes_start = monoeg_malloc0 (D.25938);
  hashes = hashes_start;
  D.25925 = BIT_FIELD_REF <*method, 32, 160>;
  D.25942 = D.25925 & 124;
  if (D.25942 == 0) goto <D.25939>; else goto <D.25943>;
  <D.25943>:
  D.25925 = BIT_FIELD_REF <*method, 32, 160>;
  D.25942 = D.25925 & 124;
  if (D.25942 == 36) goto <D.25939>; else goto <D.25940>;
  <D.25939>:
  klass = method->klass;
  goto <D.25941>;
  <D.25940>:
  klass = mono_defaults.object_class;
  <D.25941>:
  D.25925 = BIT_FIELD_REF <*method, 32, 160>;
  D.25942 = D.25925 & 124;
  if (D.25942 == 0) goto <D.25944>; else goto <D.25945>;
  <D.25944>:
  {
    char * full_name;

    D.25946 = &klass->byval_arg;
    full_name = mono_type_full_name (D.25946);
    D.25947 = mono_metadata_str_hash (full_name);
    *hashes = D.25947;
    D.25948 = hashes + 4;
    *D.25948 = 0;
    monoeg_g_free (full_name);
  }
  goto <D.25949>;
  <D.25945>:
  D.25950 = klass->name;
  D.25951 = mono_metadata_str_hash (D.25950);
  *hashes = D.25951;
  D.25948 = hashes + 4;
  D.25952 = klass->name_space;
  D.25953 = mono_metadata_str_hash (D.25952);
  *D.25948 = D.25953;
  <D.25949>:
  D.25925 = BIT_FIELD_REF <*method, 32, 160>;
  D.25942 = D.25925 & 124;
  if (D.25942 == 52) goto <D.25954>; else goto <D.25957>;
  <D.25957>:
  D.25925 = BIT_FIELD_REF <*method, 32, 160>;
  D.25942 = D.25925 & 124;
  if (D.25942 == 48) goto <D.25954>; else goto <D.25958>;
  <D.25958>:
  D.25925 = BIT_FIELD_REF <*method, 32, 160>;
  D.25942 = D.25925 & 124;
  if (D.25942 == 92) goto <D.25954>; else goto <D.25955>;
  <D.25954>:
  D.25959 = hashes + 8;
  *D.25959 = 0;
  goto <D.25956>;
  <D.25955>:
  D.25959 = hashes + 8;
  D.25960 = method->name;
  D.25961 = mono_metadata_str_hash (D.25960);
  *D.25959 = D.25961;
  <D.25956>:
  D.25962 = hashes + 12;
  D.25963 = method->wrapper_type;
  D.25964 = (unsigned int) D.25963;
  *D.25962 = D.25964;
  D.25965 = hashes + 16;
  D.25966 = sig->ret;
  D.25967 = mono_aot_type_hash (D.25966);
  *D.25965 = D.25967;
  hindex = 5;
  i = 0;
  goto <D.25188>;
  <D.25187>:
  hindex.24 = hindex;
  hindex = hindex.24 + 1;
  hindex.25 = (unsigned int) hindex.24;
  D.25970 = hindex.25 * 4;
  D.25971 = hashes + D.25970;
  D.25972 = sig->params[i];
  D.25973 = mono_aot_type_hash (D.25972);
  *D.25971 = D.25973;
  i = i + 1;
  <D.25188>:
  D.25929 = sig->param_count;
  D.25930 = (int) D.25929;
  if (D.25930 > i) goto <D.25187>; else goto <D.25189>;
  <D.25189>:
  if (ginst != 0B) goto <D.25974>; else goto <D.25975>;
  <D.25974>:
  i = 0;
  goto <D.25191>;
  <D.25190>:
  hindex.26 = hindex;
  hindex = hindex.26 + 1;
  hindex.27 = (unsigned int) hindex.26;
  D.25978 = hindex.27 * 4;
  D.25979 = hashes + D.25978;
  D.25980 = ginst->type_argv[i];
  D.25981 = mono_aot_type_hash (D.25980);
  *D.25979 = D.25981;
  i = i + 1;
  <D.25191>:
  D.25935 = ginst->type_argc;
  D.25982 = (int) D.25935;
  if (D.25982 > i) goto <D.25190>; else goto <D.25192>;
  <D.25192>:
  <D.25975>:
  D.25983 = hindex != hashes_count;
  D.25984 = (long int) D.25983;
  D.25985 = __builtin_expect (D.25984, 0);
  if (D.25985 != 0) goto <D.25986>; else goto <D.25987>;
  <D.25986>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "aot-compiler.c", 7387, "hindex == hashes_count");
  <D.25987>:
  hashes_count.23 = (unsigned int) hashes_count;
  D.25988 = hashes_count.23 << 2;
  c = D.25988 + 3735928559;
  b = c;
  a = b;
  goto <D.25194>;
  <D.25193>:
  D.25989 = *hashes;
  a = D.25989 + a;
  D.25948 = hashes + 4;
  D.25990 = *D.25948;
  b = D.25990 + b;
  D.25959 = hashes + 8;
  D.25991 = *D.25959;
  c = D.25991 + c;
  a = a - c;
  D.25992 = c r>> 28;
  a = D.25992 ^ a;
  c = c + b;
  b = b - a;
  D.25993 = a r>> 26;
  b = D.25993 ^ b;
  a = a + c;
  c = c - b;
  D.25994 = b r>> 24;
  c = D.25994 ^ c;
  b = b + a;
  a = a - c;
  D.25995 = c r>> 16;
  a = D.25995 ^ a;
  c = c + b;
  b = b - a;
  D.25996 = a r>> 13;
  b = D.25996 ^ b;
  a = a + c;
  c = c - b;
  D.25997 = b r>> 28;
  c = D.25997 ^ c;
  b = b + a;
  hashes_count = hashes_count + -3;
  hashes = hashes + 12;
  <D.25194>:
  if (hashes_count > 3) goto <D.25193>; else goto <D.25195>;
  <D.25195>:
  switch (hashes_count) <default: <D.26004>, case 0: <D.25199>, case 1: <D.25198>, case 2: <D.25197>, case 3: <D.25196>>
  <D.25196>:
  D.25959 = hashes + 8;
  D.25991 = *D.25959;
  c = D.25991 + c;
  <D.25197>:
  D.25948 = hashes + 4;
  D.25990 = *D.25948;
  b = D.25990 + b;
  <D.25198>:
  D.25989 = *hashes;
  a = D.25989 + a;
  c = c ^ b;
  D.25998 = b r>> 18;
  c = c - D.25998;
  a = a ^ c;
  D.25999 = c r>> 21;
  a = a - D.25999;
  b = b ^ a;
  D.26000 = a r>> 7;
  b = b - D.26000;
  c = c ^ b;
  D.26001 = b r>> 16;
  c = c - D.26001;
  a = a ^ c;
  D.25992 = c r>> 28;
  a = a - D.25992;
  b = b ^ a;
  D.26002 = a r>> 18;
  b = b - D.26002;
  c = c ^ b;
  D.26003 = b r>> 8;
  c = c - D.26003;
  <D.25199>:
  goto <D.25200>;
  <D.26004>:
  <D.25200>:
  free (hashes_start);
  D.26005 = c;
  return D.26005;
}


mono_aot_type_hash (struct MonoType * t1)
{
  unsigned char D.26007;
  <unnamed-unsigned:1> D.26008;
  int D.26009;
  int D.26010;
  unsigned int D.26011;
  int D.26012;
  guint D.26013;
  unsigned int D.26014;
  unsigned int D.26015;
  struct MonoClass * D.26016;
  const char * D.26017;
  unsigned int D.26018;
  struct MonoType * D.26019;
  unsigned int D.26020;
  struct MonoArrayType * D.26021;
  struct MonoClass * D.26022;
  struct MonoType * D.26023;
  unsigned int D.26024;
  guint hash;

  D.26007 = t1->type;
  hash = (guint) D.26007;
  D.26008 = t1->byref;
  D.26009 = (int) D.26008;
  D.26010 = D.26009 << 6;
  D.26011 = (unsigned int) D.26010;
  hash = D.26011 | hash;
  D.26007 = t1->type;
  D.26012 = (int) D.26007;
  switch (D.26012) <default: <D.25171>, case 15: <D.25168>, case 17: <D.25165>, case 18: <D.25166>, case 20: <D.25169>, case 21: <D.25170>, case 29: <D.25167>>
  <D.25165>:
  <D.25166>:
  <D.25167>:
  D.26014 = hash << 5;
  D.26015 = D.26014 - hash;
  D.26016 = t1->data.klass;
  D.26017 = D.26016->name;
  D.26018 = mono_metadata_str_hash (D.26017);
  D.26013 = D.26015 ^ D.26018;
  return D.26013;
  <D.25168>:
  D.26014 = hash << 5;
  D.26015 = D.26014 - hash;
  D.26019 = t1->data.type;
  D.26020 = mono_metadata_type_hash (D.26019);
  D.26013 = D.26015 ^ D.26020;
  return D.26013;
  <D.25169>:
  D.26014 = hash << 5;
  D.26015 = D.26014 - hash;
  D.26021 = t1->data.array;
  D.26022 = D.26021->eklass;
  D.26023 = &D.26022->byval_arg;
  D.26024 = mono_metadata_type_hash (D.26023);
  D.26013 = D.26015 ^ D.26024;
  return D.26013;
  <D.25170>:
  D.26014 = hash << 5;
  D.26013 = D.26014 - hash;
  return D.26013;
  <D.25171>:
  D.26013 = hash;
  return D.26013;
}


mono_aot_get_array_helper_from_wrapper (struct MonoMethod * method)
{
  const char * D.26026;
  unsigned int D.26027;
  sizetype D.26028;
  const char * D.26029;
  _Bool D.26030;
  long int D.26031;
  long int D.26032;
  int D.25221;
  int iftmp.28;
  int D.25220;
  const char[6] * D.26038;
  unsigned char D.26039;
  int D.26040;
  unsigned char D.26041;
  int D.26042;
  const unsigned char * D.26047;
  unsigned char D.26048;
  int D.26049;
  const unsigned char * D.26050;
  unsigned char D.26051;
  int D.26052;
  const unsigned char * D.26057;
  unsigned char D.26058;
  int D.26059;
  const unsigned char * D.26060;
  unsigned char D.26061;
  int D.26062;
  const unsigned char * D.26067;
  unsigned char D.26068;
  int D.26069;
  const unsigned char * D.26070;
  unsigned char D.26071;
  int D.26072;
  struct MonoClass * D.26077;
  struct MonoMethodSignature * D.26078;
  short unsigned int D.26079;
  int D.26080;
  _Bool D.26081;
  long int D.26082;
  long int D.26083;
  unsigned int D.26086;
  unsigned int D.26087;
  struct MonoClass * D.26090;
  struct MonoClass * D.26091;
  struct MonoType * D.26092;
  struct MonoGenericInst * D.26093;
  struct MonoMethod * D.26094;
  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.26026 = method->name;
      D.26027 = strlen (prefix);
      D.26028 = D.26027 + 1;
      D.26029 = D.26026 + D.26028;
      s = monoeg_g_strdup_printf ("%s", D.26029);
      s2 = strstr (s, "`1.");
      D.26030 = s2 == 0B;
      D.26031 = (long int) D.26030;
      D.26032 = __builtin_expect (D.26031, 0);
      if (D.26032 != 0) goto <D.26033>; else goto <D.26034>;
      <D.26033>:
      monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "aot-compiler.c", 7437, "s2");
      <D.26034>:
      *s2 = 0;
      iname = s;
      mname = s2 + 3;
      {
        size_t __s1_len;
        size_t __s2_len;

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

          __s2 = iname;
          D.26038 = "IList";
          D.26039 = MEM[(const unsigned char *)D.26038];
          D.26040 = (int) D.26039;
          D.26041 = *__s2;
          D.26042 = (int) D.26041;
          __result = D.26040 - D.26042;
          {
            if (__s2_len != 0) goto <D.26043>; else goto <D.26044>;
            <D.26043>:
            if (__result == 0) goto <D.26045>; else goto <D.26046>;
            <D.26045>:
            D.26047 = &MEM[(void *)"IList" + 1B];
            D.26048 = *D.26047;
            D.26049 = (int) D.26048;
            D.26050 = __s2 + 1;
            D.26051 = *D.26050;
            D.26052 = (int) D.26051;
            __result = D.26049 - D.26052;
            if (__s2_len > 1) goto <D.26053>; else goto <D.26054>;
            <D.26053>:
            if (__result == 0) goto <D.26055>; else goto <D.26056>;
            <D.26055>:
            D.26057 = &MEM[(void *)"IList" + 2B];
            D.26058 = *D.26057;
            D.26059 = (int) D.26058;
            D.26060 = __s2 + 2;
            D.26061 = *D.26060;
            D.26062 = (int) D.26061;
            __result = D.26059 - D.26062;
            if (__s2_len > 2) goto <D.26063>; else goto <D.26064>;
            <D.26063>:
            if (__result == 0) goto <D.26065>; else goto <D.26066>;
            <D.26065>:
            D.26067 = &MEM[(void *)"IList" + 3B];
            D.26068 = *D.26067;
            D.26069 = (int) D.26068;
            D.26070 = __s2 + 3;
            D.26071 = *D.26070;
            D.26072 = (int) D.26071;
            __result = D.26069 - D.26072;
            <D.26066>:
            <D.26064>:
            <D.26056>:
            <D.26054>:
            <D.26046>:
            <D.26044>:
          }
          D.25220 = __result;
        }
        iftmp.28 = -D.25220;
        goto <D.26073>;
        <D.26037>:
        iftmp.28 = __builtin_strcmp (iname, "IList");
        <D.26073>:
        D.25221 = iftmp.28;
      }
      if (D.25221 == 0) goto <D.26074>; else goto <D.26075>;
      <D.26074>:
      helper_name = monoeg_g_strdup_printf ("InternalArray__%s", mname);
      goto <D.26076>;
      <D.26075>:
      helper_name = monoeg_g_strdup_printf ("InternalArray__%s_%s", iname, mname);
      <D.26076>:
      D.26077 = mono_defaults.array_class;
      D.26078 = mono_method_signature (method);
      D.26079 = D.26078->param_count;
      D.26080 = (int) D.26079;
      m = mono_class_get_method_from_name (D.26077, helper_name, D.26080);
      D.26081 = m == 0B;
      D.26082 = (long int) D.26081;
      D.26083 = __builtin_expect (D.26082, 0);
      if (D.26083 != 0) goto <D.26084>; else goto <D.26085>;
      <D.26084>:
      monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "aot-compiler.c", 7449, "m");
      <D.26085>:
      monoeg_g_free (helper_name);
      monoeg_g_free (s);
      D.26086 = BIT_FIELD_REF <*m, 32, 160>;
      D.26087 = D.26086 & 2048;
      if (D.26087 != 0) goto <D.26088>; else goto <D.26089>;
      <D.26088>:
      memset (&ctx, 0, 8);
      D.26090 = method->klass;
      D.26091 = D.26090->element_class;
      D.26092 = &D.26091->byval_arg;
      args[0] = D.26092;
      D.26093 = mono_metadata_get_generic_inst (1, &args);
      ctx.method_inst = D.26093;
      m = mono_class_inflate_generic_method (m, &ctx);
      <D.26089>:
      D.26094 = m;
      return D.26094;
    }
  finally
    {
      ctx = {CLOBBER};
      args = {CLOBBER};
    }
}


memset (void * __dest, int __ch, size_t __len)
{
  int D.26099;
  int D.26104;
  void * D.26106;
  unsigned int D.26107;

  D.26099 = __builtin_constant_p (__len);
  if (D.26099 != 0) goto <D.26100>; else goto <D.26101>;
  <D.26100>:
  if (__len == 0) goto <D.26102>; else goto <D.26103>;
  <D.26102>:
  D.26104 = __builtin_constant_p (__ch);
  if (D.26104 == 0) goto <D.26097>; else goto <D.26105>;
  <D.26105>:
  if (__ch != 0) goto <D.26097>; else goto <D.26098>;
  <D.26097>:
  __warn_memset_zero_len ();
  D.26106 = __dest;
  return D.26106;
  <D.26098>:
  <D.26103>:
  <D.26101>:
  D.26107 = __builtin_object_size (__dest, 0);
  D.26106 = __builtin___memset_chk (__dest, __ch, __len, D.26107);
  return D.26106;
}


mono_compile_assembly (struct MonoAssembly * ass, guint32 opts, const char * aot_options)
{
  unsigned int D.26109;
  struct _IO_FILE * stderr.29;
  char * D.26113;
  struct MonoAotOptions * D.26114;
  gchar * D.26115;
  int D.26116;
  int D.26119;
  int D.26122;
  int D.26123;
  int D.26130;
  int D.26133;
  <unnamed type> D.26136;
  unsigned int D.26137;
  int mono_use_llvm.30;
  unsigned int D.26141;
  unsigned int D.26146;
  guint32 iftmp.31;
  int D.26150;
  guint32 iftmp.32;
  int D.26155;
  guint32 iftmp.33;
  int D.26160;
  const char * D.26162;
  struct MonoImage * D.26163;
  struct MonoAssembly * D.26164;
  const char * D.26165;
  gchar * D.26166;
  const char * D.26167;
  gchar * D.26168;
  gchar * D.26169;
  const short unsigned int * * D.26170;
  const short unsigned int * D.26171;
  char D.26172;
  unsigned int D.26173;
  unsigned int D.26174;
  const short unsigned int * D.26175;
  short unsigned int D.26176;
  int D.26177;
  int D.26178;
  struct GPtrArray * D.26191;
  unsigned int D.26192;
  unsigned int D.26193;
  int D.26194;
  int D.26195;
  unsigned int D.26196;
  unsigned int D.26197;
  void * D.26198;
  struct MonoMemPool * D.26199;
  long long int D.26200;
  long long int D.26201;
  int D.26202;
  int D.26205;
  int D.26207;
  int D.26209;
  char * D.26211;
  char * D.26215;
  struct FILE * D.26216;
  struct FILE * D.26217;
  int * D.26220;
  int D.26221;
  char * D.26222;
  struct MonoImageWriter * D.26223;
  int D.26224;
  char * D.26227;
  struct FILE * D.26228;
  gchar * D.26234;
  gchar * D.26236;
  struct FILE * D.26237;
  char * * D.26239;
  struct FILE * D.26240;
  char * D.26243;
  struct MonoImageWriter * D.26244;
  char * D.26245;
  gchar * D.26246;
  struct MonoCompile * * D.26247;
  unsigned int i.34;
  unsigned int D.26249;
  struct MonoCompile * * D.26250;
  struct MonoCompile * D.26251;
  struct MonoMethod * D.26254;
  unsigned int D.26255;
  char * D.26258;
  gchar * D.26259;
  int D.26261;
  struct MonoMethod * D.26264;
  struct GHashTable * D.26265;
  char * D.26266;
  const char * D.26268;
  gchar * D.26269;
  unsigned int i.35;
  unsigned int D.26271;
  int D.26272;
  int D.26277;
  int D.26282;
  int D.26286;
  struct MonoImageWriter * D.26289;
  int D.26290;
  _Bool D.26291;
  int D.26292;
  struct MonoDwarfWriter * D.26293;
  struct MonoDwarfWriter * D.26294;
  gchar * D.26297;
  struct GSList * D.26298;
  int D.26299;
  int D.26304;
  int D.26307;
  unsigned int D.26312;
  unsigned int D.26313;
  _Bool D.26314;
  long int D.26315;
  long int D.26316;
  int D.26321;
  int iftmp.36;
  int D.26323;
  int D.26326;
  int D.26329;
  int D.26330;
  int D.26331;
  int D.26332;
  int D.26333;
  unsigned int D.26334;
  int D.26335;
  unsigned int D.26336;
  int D.26337;
  int D.26338;
  int D.26339;
  int iftmp.37;
  int D.26343;
  int D.26345;
  int iftmp.38;
  int D.26349;
  int D.26351;
  int iftmp.39;
  int D.26353;
  int D.26356;
  int D.26358;
  int iftmp.40;
  int D.26364;
  int D.26366;
  int iftmp.41;
  int D.26372;
  int D.26374;
  int iftmp.42;
  int D.26380;
  int D.26382;
  int iftmp.43;
  int D.26388;
  char * D.26396;
  int D.26400;
  int D.26403;
  const char * D.26406;
  int D.26407;
  int D.26408;
  int D.26409;
  int D.26410;
  int D.26411;
  int D.26412;
  int D.26413;
  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.26109 = opts & 16777216;
      if (D.26109 != 0) goto <D.26110>; else goto <D.26111>;
      <D.26110>:
      stderr.29 = stderr;
      fprintf (stderr.29, "-O=gsharedvt not supported on this platform.\n");
      exit (1);
      <D.26111>:
      D.26113 = image->name;
      printf ("Mono Ahead of Time compiler - compiling assembly %s\n", D.26113);
      acfg = acfg_create (ass, opts);
      D.26114 = &acfg->aot_opts;
      memset (D.26114, 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.26115 = monoeg_strdup ("");
      acfg->aot_opts.llvm_path = D.26115;
      D.26114 = &acfg->aot_opts;
      mono_aot_parse_options (aot_options, D.26114);
      D.26116 = acfg->aot_opts.static_link;
      if (D.26116 != 0) goto <D.26117>; else goto <D.26118>;
      <D.26117>:
      acfg->aot_opts.autoreg = 1;
      <D.26118>:
      D.26119 = acfg->aot_opts.full_aot;
      if (D.26119 != 0) goto <D.26120>; else goto <D.26121>;
      <D.26120>:
      printf ("--aot=full is not supported on this platform.\n");
      D.26122 = 1;
      return D.26122;
      <D.26121>:
      D.26123 = acfg->aot_opts.direct_pinvoke;
      if (D.26123 != 0) goto <D.26124>; else goto <D.26125>;
      <D.26124>:
      D.26116 = acfg->aot_opts.static_link;
      if (D.26116 == 0) goto <D.26126>; else goto <D.26127>;
      <D.26126>:
      stderr.29 = stderr;
      fprintf (stderr.29, "The \'direct-pinvoke\' AOT option also requires the \'static\' AOT option.\n");
      exit (1);
      <D.26127>:
      <D.26125>:
      D.26116 = acfg->aot_opts.static_link;
      if (D.26116 != 0) goto <D.26128>; else goto <D.26129>;
      <D.26128>:
      acfg->aot_opts.asm_writer = 1;
      <D.26129>:
      D.26130 = acfg->aot_opts.soft_debug;
      if (D.26130 != 0) goto <D.26131>; else goto <D.26132>;
      <D.26131>:
      {
        struct MonoDebugOptions * opt;

        opt = mini_get_debug_options ();
        opt->mdb_optimizations = 1;
        opt->gen_seq_points = 1;
        D.26133 = mono_debug_enabled ();
        if (D.26133 == 0) goto <D.26134>; else goto <D.26135>;
        <D.26134>:
        stderr.29 = stderr;
        fprintf (stderr.29, "The soft-debug AOT option requires the --debug option.\n");
        D.26122 = 1;
        return D.26122;
        <D.26135>:
        D.26136 = acfg->flags;
        D.26137 = D.26136 | 4;
        acfg->flags = D.26137;
      }
      <D.26132>:
      mono_use_llvm.30 = mono_use_llvm;
      if (mono_use_llvm.30 != 0) goto <D.26139>; else goto <D.26140>;
      <D.26139>:
      acfg->llvm = 1;
      acfg->aot_opts.asm_writer = 1;
      D.26136 = acfg->flags;
      D.26141 = D.26136 | 1;
      acfg->flags = D.26141;
      D.26130 = acfg->aot_opts.soft_debug;
      if (D.26130 != 0) goto <D.26142>; else goto <D.26143>;
      <D.26142>:
      stderr.29 = stderr;
      fprintf (stderr.29, "The \'soft-debug\' option is not supported when compiling with LLVM.\n");
      exit (1);
      <D.26143>:
      <D.26140>:
      D.26119 = acfg->aot_opts.full_aot;
      if (D.26119 != 0) goto <D.26144>; else goto <D.26145>;
      <D.26144>:
      D.26136 = acfg->flags;
      D.26146 = D.26136 | 2;
      acfg->flags = D.26146;
      <D.26145>:
      load_profile_files (acfg);
      D.26119 = acfg->aot_opts.full_aot;
      if (D.26119 != 0) goto <D.26148>; else goto <D.26149>;
      <D.26148>:
      D.26150 = acfg->aot_opts.ntrampolines;
      iftmp.31 = (guint32) D.26150;
      goto <D.26151>;
      <D.26149>:
      iftmp.31 = 0;
      <D.26151>:
      acfg->num_trampolines[0] = iftmp.31;
      D.26119 = acfg->aot_opts.full_aot;
      if (D.26119 != 0) goto <D.26153>; else goto <D.26154>;
      <D.26153>:
      D.26155 = acfg->aot_opts.nrgctx_trampolines;
      iftmp.32 = (guint32) D.26155;
      goto <D.26156>;
      <D.26154>:
      iftmp.32 = 0;
      <D.26156>:
      acfg->num_trampolines[1] = iftmp.32;
      D.26119 = acfg->aot_opts.full_aot;
      if (D.26119 != 0) goto <D.26158>; else goto <D.26159>;
      <D.26158>:
      D.26160 = acfg->aot_opts.nimt_trampolines;
      iftmp.33 = (guint32) D.26160;
      goto <D.26161>;
      <D.26159>:
      iftmp.33 = 0;
      <D.26161>:
      acfg->num_trampolines[2] = iftmp.33;
      D.26162 = img_writer_get_temp_label_prefix (0B);
      acfg->temp_prefix = D.26162;
      arch_init (acfg);
      D.26163 = acfg->image;
      D.26164 = D.26163->assembly;
      D.26165 = D.26164->aname.name;
      D.26166 = monoeg_g_strdup_printf ("mono_aot_%s_got", D.26165);
      acfg->got_symbol_base = D.26166;
      D.26167 = acfg->llvm_label_prefix;
      D.26163 = acfg->image;
      D.26164 = D.26163->assembly;
      D.26165 = D.26164->aname.name;
      D.26168 = monoeg_g_strdup_printf ("%smono_aot_%s_plt", D.26167, D.26165);
      acfg->plt_symbol = D.26168;
      D.26163 = acfg->image;
      D.26164 = D.26163->assembly;
      D.26165 = D.26164->aname.name;
      D.26169 = monoeg_strdup (D.26165);
      acfg->assembly_name_sym = D.26169;
      p = acfg->got_symbol_base;
      goto <D.25549>;
      <D.25548>:
      D.26170 = __ctype_b_loc ();
      D.26171 = *D.26170;
      D.26172 = *p;
      D.26173 = (unsigned int) D.26172;
      D.26174 = D.26173 * 2;
      D.26175 = D.26171 + D.26174;
      D.26176 = *D.26175;
      D.26177 = (int) D.26176;
      D.26178 = D.26177 & 8;
      if (D.26178 == 0) goto <D.26179>; else goto <D.26180>;
      <D.26179>:
      D.26172 = *p;
      if (D.26172 != 95) goto <D.26181>; else goto <D.26182>;
      <D.26181>:
      *p = 95;
      <D.26182>:
      <D.26180>:
      p = p + 1;
      <D.25549>:
      D.26172 = *p;
      if (D.26172 != 0) goto <D.25548>; else goto <D.25550>;
      <D.25550>:
      p = acfg->plt_symbol;
      goto <D.25552>;
      <D.25551>:
      D.26170 = __ctype_b_loc ();
      D.26171 = *D.26170;
      D.26172 = *p;
      D.26173 = (unsigned int) D.26172;
      D.26174 = D.26173 * 2;
      D.26175 = D.26171 + D.26174;
      D.26176 = *D.26175;
      D.26177 = (int) D.26176;
      D.26178 = D.26177 & 8;
      if (D.26178 == 0) goto <D.26183>; else goto <D.26184>;
      <D.26183>:
      D.26172 = *p;
      if (D.26172 != 95) goto <D.26185>; else goto <D.26186>;
      <D.26185>:
      *p = 95;
      <D.26186>:
      <D.26184>:
      p = p + 1;
      <D.25552>:
      D.26172 = *p;
      if (D.26172 != 0) goto <D.25551>; else goto <D.25553>;
      <D.25553>:
      p = acfg->assembly_name_sym;
      goto <D.25555>;
      <D.25554>:
      D.26170 = __ctype_b_loc ();
      D.26171 = *D.26170;
      D.26172 = *p;
      D.26173 = (unsigned int) D.26172;
      D.26174 = D.26173 * 2;
      D.26175 = D.26171 + D.26174;
      D.26176 = *D.26175;
      D.26177 = (int) D.26176;
      D.26178 = D.26177 & 8;
      if (D.26178 == 0) goto <D.26187>; else goto <D.26188>;
      <D.26187>:
      D.26172 = *p;
      if (D.26172 != 95) goto <D.26189>; else goto <D.26190>;
      <D.26189>:
      *p = 95;
      <D.26190>:
      <D.26188>:
      p = p + 1;
      <D.25555>:
      D.26172 = *p;
      if (D.26172 != 0) goto <D.25554>; else goto <D.25556>;
      <D.25556>:
      acfg->method_index = 1;
      collect_methods (acfg);
      D.26191 = acfg->methods;
      D.26192 = D.26191->len;
      D.26193 = D.26192 + 32;
      D.26194 = (int) D.26193;
      acfg->cfgs_size = D.26194;
      D.26195 = acfg->cfgs_size;
      D.26196 = (unsigned int) D.26195;
      D.26197 = D.26196 * 4;
      D.26198 = monoeg_malloc0 (D.26197);
      acfg->cfgs = D.26198;
      acfg->plt_offset = 1;
      {
        struct MonoJumpInfo * ji;

        D.26199 = acfg->mempool;
        ji = mono_mempool_alloc0 (D.26199, 1032);
        ji->type = 12;
        D.26163 = acfg->image;
        ji->data.image = D.26163;
        get_got_offset (acfg, ji);
        D.26199 = acfg->mempool;
        ji = mono_mempool_alloc0 (D.26199, 1032);
        ji->type = 39;
        get_got_offset (acfg, ji);
        D.26199 = acfg->mempool;
        ji = mono_mempool_alloc0 (D.26199, 1032);
        ji->type = 42;
        get_got_offset (acfg, ji);
        D.26199 = acfg->mempool;
        ji = mono_mempool_alloc0 (D.26199, 1032);
        ji->type = 47;
        get_got_offset (acfg, ji);
      }
      atv = mono_100ns_ticks ();
      compile_methods (acfg);
      btv = mono_100ns_ticks ();
      D.26200 = btv - atv;
      D.26201 = D.26200 / 10;
      D.26202 = (int) D.26201;
      acfg->stats.jit_time = D.26202;
      atv = mono_100ns_ticks ();
      D.26205 = acfg->aot_opts.asm_only;
      if (D.26205 == 0) goto <D.26206>; else goto <D.26203>;
      <D.26206>:
      D.26207 = acfg->aot_opts.asm_writer;
      if (D.26207 == 0) goto <D.26208>; else goto <D.26203>;
      <D.26208>:
      D.26209 = bin_writer_supported ();
      if (D.26209 != 0) goto <D.26210>; else goto <D.26203>;
      <D.26210>:
      D.26211 = acfg->aot_opts.outfile;
      if (D.26211 != 0B) goto <D.26212>; else goto <D.26213>;
      <D.26212>:
      D.26211 = acfg->aot_opts.outfile;
      outfile_name = monoeg_g_strdup_printf ("%s", D.26211);
      goto <D.26214>;
      <D.26213>:
      D.26163 = acfg->image;
      D.26215 = D.26163->name;
      outfile_name = monoeg_g_strdup_printf ("%s%s", D.26215, ".so");
      <D.26214>:
      tmp_outfile_name = monoeg_g_strdup_printf ("%s.tmp", outfile_name);
      D.26216 = fopen (tmp_outfile_name, "w");
      acfg->fp = D.26216;
      D.26217 = acfg->fp;
      if (D.26217 == 0B) goto <D.26218>; else goto <D.26219>;
      <D.26218>:
      D.26220 = __errno_location ();
      D.26221 = *D.26220;
      D.26222 = strerror (D.26221);
      printf ("Unable to create temporary file \'%s\': %s\n", tmp_outfile_name, D.26222);
      D.26122 = 1;
      return D.26122;
      <D.26219>:
      D.26217 = acfg->fp;
      D.26223 = img_writer_create (D.26217, 1);
      acfg->w = D.26223;
      acfg->use_bin_writer = 1;
      goto <D.26204>;
      <D.26203>:
      D.26224 = acfg->llvm;
      if (D.26224 != 0) goto <D.26225>; else goto <D.26226>;
      <D.26225>:
      D.26227 = acfg->tmpfname;
      D.26228 = fopen (D.26227, "a+");
      acfg->fp = D.26228;
      goto <D.26229>;
      <D.26226>:
      D.26205 = acfg->aot_opts.asm_only;
      if (D.26205 != 0) goto <D.26230>; else goto <D.26231>;
      <D.26230>:
      D.26211 = acfg->aot_opts.outfile;
      if (D.26211 != 0B) goto <D.26232>; else goto <D.26233>;
      <D.26232>:
      D.26211 = acfg->aot_opts.outfile;
      D.26234 = monoeg_g_strdup_printf ("%s", D.26211);
      acfg->tmpfname = D.26234;
      goto <D.26235>;
      <D.26233>:
      D.26163 = acfg->image;
      D.26215 = D.26163->name;
      D.26236 = monoeg_g_strdup_printf ("%s.s", D.26215);
      acfg->tmpfname = D.26236;
      <D.26235>:
      D.26227 = acfg->tmpfname;
      D.26237 = fopen (D.26227, "w+");
      acfg->fp = D.26237;
      goto <D.26238>;
      <D.26231>:
      {
        int i;

        D.26239 = &acfg->tmpfname;
        i = monoeg_g_file_open_tmp ("mono_aot_XXXXXX", D.26239, 0B);
        D.26240 = fdopen (i, "w+");
        acfg->fp = D.26240;
      }
      <D.26238>:
      <D.26229>:
      D.26217 = acfg->fp;
      if (D.26217 == 0B) goto <D.26241>; else goto <D.26242>;
      <D.26241>:
      stderr.29 = stderr;
      D.26227 = acfg->tmpfname;
      D.26220 = __errno_location ();
      D.26221 = *D.26220;
      D.26243 = strerror (D.26221);
      fprintf (stderr.29, "Unable to open file \'%s\': %s\n", D.26227, D.26243);
      D.26122 = 1;
      return D.26122;
      <D.26242>:
      D.26217 = acfg->fp;
      D.26244 = img_writer_create (D.26217, 0);
      acfg->w = D.26244;
      tmp_outfile_name = 0B;
      outfile_name = 0B;
      <D.26204>:
      D.26167 = acfg->llvm_label_prefix;
      D.26245 = acfg->got_symbol_base;
      D.26246 = monoeg_g_strdup_printf ("%s%s", D.26167, D.26245);
      acfg->got_symbol = D.26246;
      i = 0;
      goto <D.25562>;
      <D.25561>:
      D.26247 = acfg->cfgs;
      i.34 = (unsigned int) i;
      D.26249 = i.34 * 4;
      D.26250 = D.26247 + D.26249;
      D.26251 = *D.26250;
      if (D.26251 != 0B) goto <D.26252>; else goto <D.26253>;
      <D.26252>:
      {
        struct MonoCompile * cfg;
        int method_index;

        D.26247 = acfg->cfgs;
        i.34 = (unsigned int) i;
        D.26249 = i.34 * 4;
        D.26250 = D.26247 + D.26249;
        cfg = *D.26250;
        D.26254 = cfg->orig_method;
        D.26255 = get_method_index (acfg, D.26254);
        method_index = (int) D.26255;
        if (0 != 0) goto <D.26256>; else goto <D.26257>;
        <D.26256>:
        D.26167 = acfg->llvm_label_prefix;
        D.26258 = cfg->llvm_method_name;
        D.26259 = monoeg_g_strdup_printf ("%s%s", D.26167, D.26258);
        cfg->asm_symbol = D.26259;
        goto <D.26260>;
        <D.26257>:
        D.26261 = acfg->global_symbols;
        if (D.26261 != 0) goto <D.26262>; else goto <D.26263>;
        <D.26262>:
        D.26264 = cfg->method;
        D.26265 = acfg->method_label_hash;
        D.26266 = get_debug_sym (D.26264, "", D.26265);
        cfg->asm_symbol = D.26266;
        goto <D.26267>;
        <D.26263>:
        D.26268 = acfg->temp_prefix;
        D.26167 = acfg->llvm_label_prefix;
        D.26269 = monoeg_g_strdup_printf ("%s%sm_%x", D.26268, D.26167, method_index);
        cfg->asm_symbol = D.26269;
        <D.26267>:
        <D.26260>:
      }
      <D.26253>:
      i = i + 1;
      <D.25562>:
      i.35 = (unsigned int) i;
      D.26271 = acfg->nmethods;
      if (i.35 < D.26271) goto <D.25561>; else goto <D.25563>;
      <D.25563>:
      D.26272 = acfg->aot_opts.dwarf_debug;
      if (D.26272 != 0) goto <D.26273>; else goto <D.26274>;
      <D.26273>:
      D.26205 = acfg->aot_opts.asm_only;
      if (D.26205 != 0) goto <D.26275>; else goto <D.26276>;
      <D.26275>:
      D.26277 = acfg->aot_opts.gnu_asm;
      if (D.26277 != 0) goto <D.26278>; else goto <D.26279>;
      <D.26278>:
      acfg->gas_line_numbers = 1;
      <D.26279>:
      <D.26276>:
      <D.26274>:
      D.26282 = acfg->aot_opts.nodebug;
      if (D.26282 == 0) goto <D.26280>; else goto <D.26283>;
      <D.26283>:
      D.26272 = acfg->aot_opts.dwarf_debug;
      if (D.26272 != 0) goto <D.26280>; else goto <D.26281>;
      <D.26280>:
      D.26272 = acfg->aot_opts.dwarf_debug;
      if (D.26272 != 0) goto <D.26284>; else goto <D.26285>;
      <D.26284>:
      D.26286 = mono_debug_enabled ();
      if (D.26286 == 0) goto <D.26287>; else goto <D.26288>;
      <D.26287>:
      stderr.29 = stderr;
      fprintf (stderr.29, "The dwarf AOT option requires the --debug option.\n");
      D.26122 = 1;
      return D.26122;
      <D.26288>:
      <D.26285>:
      D.26289 = acfg->w;
      D.26290 = acfg->gas_line_numbers;
      D.26291 = D.26290 == 0;
      D.26292 = (int) D.26291;
      D.26293 = mono_dwarf_writer_create (D.26289, 0B, 0, 0, D.26292);
      acfg->dwarf = D.26293;
      <D.26281>:
      D.26289 = acfg->w;
      img_writer_emit_start (D.26289);
      D.26294 = acfg->dwarf;
      if (D.26294 != 0B) goto <D.26295>; else goto <D.26296>;
      <D.26295>:
      D.26294 = acfg->dwarf;
      D.26163 = acfg->image;
      D.26215 = D.26163->name;
      D.26297 = monoeg_g_path_get_basename (D.26215);
      D.26298 = mono_unwind_get_cie_program ();
      mono_dwarf_writer_emit_base_info (D.26294, D.26297, D.26298);
      <D.26296>:
      D.26299 = acfg->thumb_mixed;
      if (D.26299 != 0) goto <D.26300>; else goto <D.26301>;
      <D.26300>:
      {
        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.26217 = acfg->fp;
            fprintf (D.26217, ".arm\n");
          }
        finally
          {
            symbol = {CLOBBER};
          }
      }
      <D.26301>:
      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.26294 = acfg->dwarf;
      if (D.26294 != 0B) goto <D.26302>; else goto <D.26303>;
      <D.26302>:
      emit_dwarf_info (acfg);
      D.26294 = acfg->dwarf;
      mono_dwarf_writer_close (D.26294);
      <D.26303>:
      emit_mem_end (acfg);
      D.26304 = acfg->need_pt_gnu_stack;
      if (D.26304 != 0) goto <D.26305>; else goto <D.26306>;
      <D.26305>:
      D.26307 = acfg->use_bin_writer;
      if (D.26307 == 0) goto <D.26308>; else goto <D.26309>;
      <D.26308>:
      D.26217 = acfg->fp;
      fprintf (D.26217, "\n.section\t.note.GNU-stack,\"\",@progbits\n");
      <D.26309>:
      <D.26306>:
      btv = mono_100ns_ticks ();
      D.26200 = btv - atv;
      D.26201 = D.26200 / 10;
      D.26202 = (int) D.26201;
      acfg->stats.gen_time = D.26202;
      D.26224 = acfg->llvm;
      if (D.26224 != 0) goto <D.26310>; else goto <D.26311>;
      <D.26310>:
      D.26312 = acfg->got_offset;
      D.26313 = acfg->final_got_size;
      D.26314 = D.26312 > D.26313;
      D.26315 = (long int) D.26314;
      D.26316 = __builtin_expect (D.26315, 0);
      if (D.26316 != 0) goto <D.26317>; else goto <D.26318>;
      <D.26317>:
      monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "aot-compiler.c", 9004, "acfg->got_offset <= acfg->final_got_size");
      <D.26318>:
      <D.26311>:
      D.26224 = acfg->llvm;
      if (D.26224 != 0) goto <D.26319>; else goto <D.26320>;
      <D.26319>:
      D.26321 = acfg->stats.llvm_count;
      D.26323 = acfg->stats.mcount;
      if (D.26323 != 0) goto <D.26324>; else goto <D.26325>;
      <D.26324>:
      D.26321 = acfg->stats.llvm_count;
      D.26326 = D.26321 * 100;
      D.26323 = acfg->stats.mcount;
      iftmp.36 = D.26326 / D.26323;
      goto <D.26327>;
      <D.26325>:
      iftmp.36 = 100;
      <D.26327>:
      sprintf (&llvm_stats_msg, ", LLVM: %d (%d%%)", D.26321, iftmp.36);
      goto <D.26328>;
      <D.26320>:
      strcpy (&llvm_stats_msg, "");
      <D.26328>:
      D.26329 = acfg->stats.code_size;
      D.26330 = acfg->stats.info_size;
      D.26331 = acfg->stats.ex_info_size;
      D.26332 = acfg->stats.unwind_info_size;
      D.26333 = acfg->stats.class_info_size;
      D.26334 = acfg->plt_offset;
      D.26335 = acfg->stats.got_info_size;
      D.26312 = acfg->got_offset;
      D.26336 = D.26312 * 4;
      D.26337 = (int) D.26336;
      D.26338 = 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.26329, D.26330, D.26331, D.26332, D.26333, D.26334, D.26335, D.26337, D.26338);
      D.26339 = acfg->stats.ccount;
      D.26323 = acfg->stats.mcount;
      D.26323 = acfg->stats.mcount;
      if (D.26323 != 0) goto <D.26341>; else goto <D.26342>;
      <D.26341>:
      D.26339 = acfg->stats.ccount;
      D.26343 = D.26339 * 100;
      D.26323 = acfg->stats.mcount;
      iftmp.37 = D.26343 / D.26323;
      goto <D.26344>;
      <D.26342>:
      iftmp.37 = 100;
      <D.26344>:
      D.26345 = acfg->stats.methods_without_got_slots;
      D.26323 = acfg->stats.mcount;
      if (D.26323 != 0) goto <D.26347>; else goto <D.26348>;
      <D.26347>:
      D.26345 = acfg->stats.methods_without_got_slots;
      D.26349 = D.26345 * 100;
      D.26323 = acfg->stats.mcount;
      iftmp.38 = D.26349 / D.26323;
      goto <D.26350>;
      <D.26348>:
      iftmp.38 = 100;
      <D.26350>:
      D.26351 = acfg->stats.direct_calls;
      D.26353 = acfg->stats.all_calls;
      if (D.26353 != 0) goto <D.26354>; else goto <D.26355>;
      <D.26354>:
      D.26351 = acfg->stats.direct_calls;
      D.26356 = D.26351 * 100;
      D.26353 = acfg->stats.all_calls;
      iftmp.39 = D.26356 / D.26353;
      goto <D.26357>;
      <D.26355>:
      iftmp.39 = 100;
      <D.26357>:
      printf ("Compiled: %d/%d (%d%%)%s, No GOT slots: %d (%d%%), Direct calls: %d (%d%%)\n", D.26339, D.26323, iftmp.37, &llvm_stats_msg, D.26345, iftmp.38, D.26351, iftmp.39);
      D.26358 = acfg->stats.genericcount;
      if (D.26358 != 0) goto <D.26359>; else goto <D.26360>;
      <D.26359>:
      D.26358 = acfg->stats.genericcount;
      D.26323 = acfg->stats.mcount;
      if (D.26323 != 0) goto <D.26362>; else goto <D.26363>;
      <D.26362>:
      D.26358 = acfg->stats.genericcount;
      D.26364 = D.26358 * 100;
      D.26323 = acfg->stats.mcount;
      iftmp.40 = D.26364 / D.26323;
      goto <D.26365>;
      <D.26363>:
      iftmp.40 = 100;
      <D.26365>:
      printf ("%d methods are generic (%d%%)\n", D.26358, iftmp.40);
      <D.26360>:
      D.26366 = acfg->stats.abscount;
      if (D.26366 != 0) goto <D.26367>; else goto <D.26368>;
      <D.26367>:
      D.26366 = acfg->stats.abscount;
      D.26323 = acfg->stats.mcount;
      if (D.26323 != 0) goto <D.26370>; else goto <D.26371>;
      <D.26370>:
      D.26366 = acfg->stats.abscount;
      D.26372 = D.26366 * 100;
      D.26323 = acfg->stats.mcount;
      iftmp.41 = D.26372 / D.26323;
      goto <D.26373>;
      <D.26371>:
      iftmp.41 = 100;
      <D.26373>:
      printf ("%d methods contain absolute addresses (%d%%)\n", D.26366, iftmp.41);
      <D.26368>:
      D.26374 = acfg->stats.lmfcount;
      if (D.26374 != 0) goto <D.26375>; else goto <D.26376>;
      <D.26375>:
      D.26374 = acfg->stats.lmfcount;
      D.26323 = acfg->stats.mcount;
      if (D.26323 != 0) goto <D.26378>; else goto <D.26379>;
      <D.26378>:
      D.26374 = acfg->stats.lmfcount;
      D.26380 = D.26374 * 100;
      D.26323 = acfg->stats.mcount;
      iftmp.42 = D.26380 / D.26323;
      goto <D.26381>;
      <D.26379>:
      iftmp.42 = 100;
      <D.26381>:
      printf ("%d methods contain lmf pointers (%d%%)\n", D.26374, iftmp.42);
      <D.26376>:
      D.26382 = acfg->stats.ocount;
      if (D.26382 != 0) goto <D.26383>; else goto <D.26384>;
      <D.26383>:
      D.26382 = acfg->stats.ocount;
      D.26323 = acfg->stats.mcount;
      if (D.26323 != 0) goto <D.26386>; else goto <D.26387>;
      <D.26386>:
      D.26382 = acfg->stats.ocount;
      D.26388 = D.26382 * 100;
      D.26323 = acfg->stats.mcount;
      iftmp.43 = D.26388 / D.26323;
      goto <D.26389>;
      <D.26387>:
      iftmp.43 = 100;
      <D.26389>:
      printf ("%d methods have other problems (%d%%)\n", D.26382, iftmp.43);
      <D.26384>:
      atv = mono_100ns_ticks ();
      D.26289 = acfg->w;
      res = img_writer_emit_writeout (D.26289);
      if (res != 0) goto <D.26390>; else goto <D.26391>;
      <D.26390>:
      acfg_free (acfg);
      D.26122 = res;
      return D.26122;
      <D.26391>:
      D.26307 = acfg->use_bin_writer;
      if (D.26307 != 0) goto <D.26392>; else goto <D.26393>;
      <D.26392>:
      {
        int err;

        err = rename (tmp_outfile_name, outfile_name);
        if (err != 0) goto <D.26394>; else goto <D.26395>;
        <D.26394>:
        D.26220 = __errno_location ();
        D.26221 = *D.26220;
        D.26396 = strerror (D.26221);
        printf ("Unable to rename \'%s\' to \'%s\': %s\n", tmp_outfile_name, outfile_name, D.26396);
        D.26122 = 1;
        return D.26122;
        <D.26395>:
      }
      goto <D.26397>;
      <D.26393>:
      res = compile_asm (acfg);
      if (res != 0) goto <D.26398>; else goto <D.26399>;
      <D.26398>:
      acfg_free (acfg);
      D.26122 = res;
      return D.26122;
      <D.26399>:
      <D.26397>:
      btv = mono_100ns_ticks ();
      D.26200 = btv - atv;
      D.26201 = D.26200 / 10;
      D.26202 = (int) D.26201;
      acfg->stats.link_time = D.26202;
      D.26400 = acfg->aot_opts.stats;
      if (D.26400 != 0) goto <D.26401>; else goto <D.26402>;
      <D.26401>:
      {
        int i;

        printf ("GOT slot distribution:\n");
        i = 0;
        goto <D.25568>;
        <D.25567>:
        D.26403 = acfg->stats.got_slot_types[i];
        if (D.26403 != 0) goto <D.26404>; else goto <D.26405>;
        <D.26404>:
        D.26406 = get_patch_name (i);
        D.26403 = acfg->stats.got_slot_types[i];
        D.26407 = acfg->stats.got_slot_info_sizes[i];
        printf ("\t%s: %d (%d)\n", D.26406, D.26403, D.26407);
        <D.26405>:
        i = i + 1;
        <D.25568>:
        if (i <= 50) goto <D.25567>; else goto <D.25569>;
        <D.25569>:
      }
      <D.26402>:
      D.26408 = acfg->stats.jit_time;
      D.26409 = D.26408 / 1000;
      D.26410 = acfg->stats.gen_time;
      D.26411 = D.26410 / 1000;
      D.26412 = acfg->stats.link_time;
      D.26413 = D.26412 / 1000;
      printf ("JIT time: %d ms, Generation time: %d ms, Assembly+Link time: %d ms.\n", D.26409, D.26411, D.26413);
      acfg_free (acfg);
      D.26122 = 0;
      return D.26122;
    }
  finally
    {
      llvm_stats_msg = {CLOBBER};
    }
}


acfg_create (struct MonoAssembly * ass, guint32 opts)
{
  struct GPtrArray * D.26416;
  struct GHashTable * D.26417;
  struct GHashTable * D.26418;
  struct GHashTable * D.26419;
  void * D.26420;
  struct GHashTable * D.26421;
  void * D.26422;
  struct GHashTable * * D.26423;
  unsigned int i.44;
  unsigned int D.26425;
  struct GHashTable * * D.26426;
  struct GHashTable * D.26427;
  struct GPtrArray * D.26428;
  struct GHashTable * D.26429;
  struct GHashTable * D.26430;
  struct GHashTable * D.26431;
  struct GHashTable * D.26432;
  struct GPtrArray * D.26433;
  struct GPtrArray * D.26434;
  unsigned int D.26435;
  struct MonoMemPool * D.26436;
  struct GPtrArray * D.26437;
  struct GHashTable * D.26438;
  struct GPtrArray * D.26439;
  struct GHashTable * D.26440;
  struct GPtrArray * D.26441;
  struct GHashTable * D.26442;
  struct GHashTable * D.26443;
  struct GHashTable * D.26444;
  struct GHashTable * D.26445;
  struct CRITICAL_SECTION * D.26446;
  struct MonoAotCompile * D.26447;
  struct MonoImage * image;
  struct MonoAotCompile * acfg;
  int i;

  image = ass->image;
  acfg = monoeg_malloc0 (1032);
  D.26416 = monoeg_g_ptr_array_new ();
  acfg->methods = D.26416;
  D.26417 = monoeg_g_hash_table_new (0B, 0B);
  acfg->method_indexes = D.26417;
  D.26418 = monoeg_g_hash_table_new (0B, 0B);
  acfg->method_depth = D.26418;
  D.26419 = monoeg_g_hash_table_new (0B, 0B);
  acfg->plt_offset_to_entry = D.26419;
  D.26420 = monoeg_malloc0 (208);
  acfg->patch_to_plt_entry = D.26420;
  D.26421 = monoeg_g_hash_table_new (mono_patch_info_hash, mono_patch_info_equal);
  acfg->patch_to_got_offset = D.26421;
  D.26422 = monoeg_malloc0 (208);
  acfg->patch_to_got_offset_by_type = D.26422;
  i = 0;
  goto <D.25517>;
  <D.25516>:
  D.26423 = acfg->patch_to_got_offset_by_type;
  i.44 = (unsigned int) i;
  D.26425 = i.44 * 4;
  D.26426 = D.26423 + D.26425;
  D.26427 = monoeg_g_hash_table_new (mono_patch_info_hash, mono_patch_info_equal);
  *D.26426 = D.26427;
  i = i + 1;
  <D.25517>:
  if (i <= 51) goto <D.25516>; else goto <D.25518>;
  <D.25518>:
  D.26428 = monoeg_g_ptr_array_new ();
  acfg->got_patches = D.26428;
  D.26429 = monoeg_g_hash_table_new (0B, 0B);
  acfg->method_to_cfg = D.26429;
  D.26430 = monoeg_g_hash_table_new_full (0B, 0B, 0B, monoeg_g_free);
  acfg->token_info_hash = D.26430;
  D.26431 = monoeg_g_hash_table_new_full (0B, 0B, 0B, monoeg_g_free);
  acfg->method_to_pinvoke_import = D.26431;
  D.26432 = monoeg_g_hash_table_new (0B, 0B);
  acfg->image_hash = D.26432;
  D.26433 = monoeg_g_ptr_array_new ();
  acfg->image_table = D.26433;
  D.26434 = monoeg_g_ptr_array_new ();
  acfg->globals = D.26434;
  acfg->image = image;
  acfg->opts = opts;
  D.26435 = mono_arch_cpu_enumerate_simd_versions ();
  acfg->simd_opts = D.26435;
  D.26436 = mono_mempool_new ();
  acfg->mempool = D.26436;
  D.26437 = monoeg_g_ptr_array_new ();
  acfg->extra_methods = D.26437;
  D.26438 = monoeg_g_hash_table_new (0B, 0B);
  acfg->unwind_info_offsets = D.26438;
  D.26439 = monoeg_g_ptr_array_new ();
  acfg->unwind_ops = D.26439;
  D.26440 = monoeg_g_hash_table_new_full (monoeg_g_str_hash, monoeg_g_str_equal, monoeg_g_free, 0B);
  acfg->method_label_hash = D.26440;
  D.26441 = monoeg_g_ptr_array_new ();
  acfg->method_order = D.26441;
  D.26442 = monoeg_g_hash_table_new (0B, 0B);
  acfg->export_names = D.26442;
  D.26443 = monoeg_g_hash_table_new (0B, 0B);
  acfg->klass_blob_hash = D.26443;
  D.26444 = monoeg_g_hash_table_new (0B, 0B);
  acfg->method_blob_hash = D.26444;
  D.26445 = monoeg_g_hash_table_new (monoeg_g_str_hash, monoeg_g_str_equal);
  acfg->plt_entry_debug_sym_cache = D.26445;
  D.26446 = &acfg->mutex;
  InitializeCriticalSection (D.26446);
  D.26447 = acfg;
  return D.26447;
}


mono_aot_parse_options (const char * aot_options, struct MonoAotOptions * opts)
{
  const gchar * iftmp.45;
  int D.26453;
  const gchar * D.26456;
  gchar * D.26457;
  int D.26459;
  int D.26463;
  int D.26467;
  int D.26471;
  int D.26475;
  int D.26479;
  int D.26483;
  int D.26487;
  const char * D.26490;
  int D.26491;
  int D.26493;
  int D.26497;
  int D.26501;
  int D.26505;
  int D.26509;
  int D.26513;
  int D.26517;
  const char * D.26520;
  int D.26521;
  int D.26523;
  const char * D.26526;
  int D.26527;
  int D.26529;
  const char * D.26532;
  int D.26533;
  int D.26535;
  const char * D.26538;
  int D.26539;
  int D.26541;
  int D.26545;
  const gchar * D.26548;
  gchar * D.26549;
  int D.26551;
  int D.26555;
  int D.26559;
  int D.26563;
  int D.26567;
  int D.26571;
  int D.26575;
  int D.26579;
  int D.26583;
  gchar * D.26586;
  int D.26588;
  const gchar * D.26591;
  gchar * D.26592;
  int D.26594;
  const char * D.26597;
  int D.26599;
  int D.26602;
  int D.26608;
  int D.26610;
  struct _IO_FILE * stderr.46;
  gchar * D.26613;
  int D.26614;
  gchar * * args;
  gchar * * ptr;

  if (aot_options != 0B) goto <D.26450>; else goto <D.26451>;
  <D.26450>:
  iftmp.45 = aot_options;
  goto <D.26452>;
  <D.26451>:
  iftmp.45 = "";
  <D.26452>:
  args = monoeg_g_strsplit (iftmp.45, ",", -1);
  ptr = args;
  goto <D.24897>;
  <D.24896>:
  {
    const char * arg;

    arg = *ptr;
    D.26453 = str_begins_with (arg, "outfile=");
    if (D.26453 != 0) goto <D.26454>; else goto <D.26455>;
    <D.26454>:
    D.26456 = arg + 8;
    D.26457 = monoeg_strdup (D.26456);
    opts->outfile = D.26457;
    goto <D.26458>;
    <D.26455>:
    D.26459 = str_begins_with (arg, "save-temps");
    if (D.26459 != 0) goto <D.26460>; else goto <D.26461>;
    <D.26460>:
    opts->save_temps = 1;
    goto <D.26462>;
    <D.26461>:
    D.26463 = str_begins_with (arg, "keep-temps");
    if (D.26463 != 0) goto <D.26464>; else goto <D.26465>;
    <D.26464>:
    opts->save_temps = 1;
    goto <D.26466>;
    <D.26465>:
    D.26467 = str_begins_with (arg, "write-symbols");
    if (D.26467 != 0) goto <D.26468>; else goto <D.26469>;
    <D.26468>:
    opts->write_symbols = 1;
    goto <D.26470>;
    <D.26469>:
    D.26471 = str_begins_with (arg, "no-write-symbols");
    if (D.26471 != 0) goto <D.26472>; else goto <D.26473>;
    <D.26472>:
    opts->write_symbols = 0;
    goto <D.26474>;
    <D.26473>:
    D.26475 = str_begins_with (arg, "metadata-only");
    if (D.26475 != 0) goto <D.26476>; else goto <D.26477>;
    <D.26476>:
    opts->metadata_only = 1;
    goto <D.26478>;
    <D.26477>:
    D.26479 = str_begins_with (arg, "bind-to-runtime-version");
    if (D.26479 != 0) goto <D.26480>; else goto <D.26481>;
    <D.26480>:
    opts->bind_to_runtime_version = 1;
    goto <D.26482>;
    <D.26481>:
    D.26483 = str_begins_with (arg, "full");
    if (D.26483 != 0) goto <D.26484>; else goto <D.26485>;
    <D.26484>:
    opts->full_aot = 1;
    goto <D.26486>;
    <D.26485>:
    D.26487 = str_begins_with (arg, "threads=");
    if (D.26487 != 0) goto <D.26488>; else goto <D.26489>;
    <D.26488>:
    D.26490 = arg + 8;
    D.26491 = atoi (D.26490);
    opts->nthreads = D.26491;
    goto <D.26492>;
    <D.26489>:
    D.26493 = str_begins_with (arg, "static");
    if (D.26493 != 0) goto <D.26494>; else goto <D.26495>;
    <D.26494>:
    opts->static_link = 1;
    opts->no_dlsym = 1;
    goto <D.26496>;
    <D.26495>:
    D.26497 = str_begins_with (arg, "asmonly");
    if (D.26497 != 0) goto <D.26498>; else goto <D.26499>;
    <D.26498>:
    opts->asm_only = 1;
    goto <D.26500>;
    <D.26499>:
    D.26501 = str_begins_with (arg, "asmwriter");
    if (D.26501 != 0) goto <D.26502>; else goto <D.26503>;
    <D.26502>:
    opts->asm_writer = 1;
    goto <D.26504>;
    <D.26503>:
    D.26505 = str_begins_with (arg, "nodebug");
    if (D.26505 != 0) goto <D.26506>; else goto <D.26507>;
    <D.26506>:
    opts->nodebug = 1;
    goto <D.26508>;
    <D.26507>:
    D.26509 = str_begins_with (arg, "dwarfdebug");
    if (D.26509 != 0) goto <D.26510>; else goto <D.26511>;
    <D.26510>:
    opts->dwarf_debug = 1;
    goto <D.26512>;
    <D.26511>:
    D.26513 = str_begins_with (arg, "nopagetrampolines");
    if (D.26513 != 0) goto <D.26514>; else goto <D.26515>;
    <D.26514>:
    opts->use_trampolines_page = 0;
    goto <D.26516>;
    <D.26515>:
    D.26517 = str_begins_with (arg, "ntrampolines=");
    if (D.26517 != 0) goto <D.26518>; else goto <D.26519>;
    <D.26518>:
    D.26520 = arg + 13;
    D.26521 = atoi (D.26520);
    opts->ntrampolines = D.26521;
    goto <D.26522>;
    <D.26519>:
    D.26523 = str_begins_with (arg, "nrgctx-trampolines=");
    if (D.26523 != 0) goto <D.26524>; else goto <D.26525>;
    <D.26524>:
    D.26526 = arg + 19;
    D.26527 = atoi (D.26526);
    opts->nrgctx_trampolines = D.26527;
    goto <D.26528>;
    <D.26525>:
    D.26529 = str_begins_with (arg, "nimt-trampolines=");
    if (D.26529 != 0) goto <D.26530>; else goto <D.26531>;
    <D.26530>:
    D.26532 = arg + 17;
    D.26533 = atoi (D.26532);
    opts->nimt_trampolines = D.26533;
    goto <D.26534>;
    <D.26531>:
    D.26535 = str_begins_with (arg, "ngsharedvt-trampolines=");
    if (D.26535 != 0) goto <D.26536>; else goto <D.26537>;
    <D.26536>:
    D.26538 = arg + 23;
    D.26539 = atoi (D.26538);
    opts->ngsharedvt_arg_trampolines = D.26539;
    goto <D.26540>;
    <D.26537>:
    D.26541 = str_begins_with (arg, "autoreg");
    if (D.26541 != 0) goto <D.26542>; else goto <D.26543>;
    <D.26542>:
    opts->autoreg = 1;
    goto <D.26544>;
    <D.26543>:
    D.26545 = str_begins_with (arg, "tool-prefix=");
    if (D.26545 != 0) goto <D.26546>; else goto <D.26547>;
    <D.26546>:
    D.26548 = arg + 12;
    D.26549 = monoeg_strdup (D.26548);
    opts->tool_prefix = D.26549;
    goto <D.26550>;
    <D.26547>:
    D.26551 = str_begins_with (arg, "soft-debug");
    if (D.26551 != 0) goto <D.26552>; else goto <D.26553>;
    <D.26552>:
    opts->soft_debug = 1;
    goto <D.26554>;
    <D.26553>:
    D.26555 = str_begins_with (arg, "direct-pinvoke");
    if (D.26555 != 0) goto <D.26556>; else goto <D.26557>;
    <D.26556>:
    opts->direct_pinvoke = 1;
    goto <D.26558>;
    <D.26557>:
    D.26559 = str_begins_with (arg, "direct-icalls");
    if (D.26559 != 0) goto <D.26560>; else goto <D.26561>;
    <D.26560>:
    opts->direct_icalls = 1;
    goto <D.26562>;
    <D.26561>:
    D.26563 = str_begins_with (arg, "no-direct-calls");
    if (D.26563 != 0) goto <D.26564>; else goto <D.26565>;
    <D.26564>:
    opts->no_direct_calls = 1;
    goto <D.26566>;
    <D.26565>:
    D.26567 = str_begins_with (arg, "print-skipped");
    if (D.26567 != 0) goto <D.26568>; else goto <D.26569>;
    <D.26568>:
    opts->print_skipped_methods = 1;
    goto <D.26570>;
    <D.26569>:
    D.26571 = str_begins_with (arg, "stats");
    if (D.26571 != 0) goto <D.26572>; else goto <D.26573>;
    <D.26572>:
    opts->stats = 1;
    goto <D.26574>;
    <D.26573>:
    D.26575 = str_begins_with (arg, "no-instances");
    if (D.26575 != 0) goto <D.26576>; else goto <D.26577>;
    <D.26576>:
    opts->no_instances = 1;
    goto <D.26578>;
    <D.26577>:
    D.26579 = str_begins_with (arg, "log-generics");
    if (D.26579 != 0) goto <D.26580>; else goto <D.26581>;
    <D.26580>:
    opts->log_generics = 1;
    goto <D.26582>;
    <D.26581>:
    D.26583 = str_begins_with (arg, "mtriple=");
    if (D.26583 != 0) goto <D.26584>; else goto <D.26585>;
    <D.26584>:
    D.26456 = arg + 8;
    D.26586 = monoeg_strdup (D.26456);
    opts->mtriple = D.26586;
    goto <D.26587>;
    <D.26585>:
    D.26588 = str_begins_with (arg, "llvm-path=");
    if (D.26588 != 0) goto <D.26589>; else goto <D.26590>;
    <D.26589>:
    D.26591 = arg + 10;
    D.26592 = monoeg_strdup (D.26591);
    opts->llvm_path = D.26592;
    goto <D.26593>;
    <D.26590>:
    D.26594 = str_begins_with (arg, "readonly-value=");
    if (D.26594 != 0) goto <D.26595>; else goto <D.26596>;
    <D.26595>:
    D.26597 = arg + 15;
    add_readonly_value (opts, D.26597);
    goto <D.26598>;
    <D.26596>:
    D.26599 = str_begins_with (arg, "info");
    if (D.26599 != 0) goto <D.26600>; else goto <D.26601>;
    <D.26600>:
    printf ("AOT target setup: %s.\n", "");
    exit (0);
    <D.26601>:
    D.26602 = str_begins_with (arg, "gc-maps");
    if (D.26602 != 0) goto <D.26603>; else goto <D.26604>;
    <D.26603>:
    mini_gc_enable_gc_maps_for_aot ();
    goto <D.26605>;
    <D.26604>:
    D.26608 = str_begins_with (arg, "help");
    if (D.26608 != 0) goto <D.26606>; else goto <D.26609>;
    <D.26609>:
    D.26610 = str_begins_with (arg, "?");
    if (D.26610 != 0) goto <D.26606>; else goto <D.26607>;
    <D.26606>:
    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.26607>:
    stderr.46 = stderr;
    fprintf (stderr.46, "AOT : Unknown argument \'%s\'.\n", arg);
    exit (1);
    <D.26605>:
    <D.26598>:
    <D.26593>:
    <D.26587>:
    <D.26582>:
    <D.26578>:
    <D.26574>:
    <D.26570>:
    <D.26566>:
    <D.26562>:
    <D.26558>:
    <D.26554>:
    <D.26550>:
    <D.26544>:
    <D.26540>:
    <D.26534>:
    <D.26528>:
    <D.26522>:
    <D.26516>:
    <D.26512>:
    <D.26508>:
    <D.26504>:
    <D.26500>:
    <D.26496>:
    <D.26492>:
    <D.26486>:
    <D.26482>:
    <D.26478>:
    <D.26474>:
    <D.26470>:
    <D.26466>:
    <D.26462>:
    <D.26458>:
  }
  ptr = ptr + 4;
  <D.24897>:
  if (ptr != 0B) goto <D.26612>; else goto <D.24898>;
  <D.26612>:
  D.26613 = *ptr;
  if (D.26613 != 0B) goto <D.24896>; else goto <D.24898>;
  <D.24898>:
  D.26614 = opts->use_trampolines_page;
  if (D.26614 != 0) goto <D.26615>; else goto <D.26616>;
  <D.26615>:
  opts->ntrampolines = 0;
  opts->nrgctx_trampolines = 0;
  opts->nimt_trampolines = 0;
  opts->ngsharedvt_arg_trampolines = 0;
  <D.26616>:
  monoeg_g_strfreev (args);
}


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

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


add_readonly_value (struct MonoAotOptions * opts, const char * val)
{
  struct _IO_FILE * stderr.47;
  int tval.48;
  int val.49;
  int D.26626;
  int D.26627;
  unsigned int D.26628;
  void * D.26629;
  char * D.26630;
  unsigned int D.26631;
  int D.26632;
  int D.26635;
  unsigned char D.26636;
  int D.26638;
  int D.26641;
  short unsigned int D.26642;
  int D.26644;
  int D.26647;
  unsigned int D.26648;
  struct ReadOnlyValue * readonly_values.50;
  struct ReadOnlyValue * rdv;
  const char * fval;
  const char * tval;

  fval = strrchr (val, 47);
  if (fval == 0B) goto <D.26619>; else goto <D.26620>;
  <D.26619>:
  stderr.47 = stderr;
  fprintf (stderr.47, "AOT : invalid format for readonly field \'%s\', missing /.\n", val);
  exit (1);
  <D.26620>:
  tval = strrchr (val, 61);
  if (tval == 0B) goto <D.26622>; else goto <D.26623>;
  <D.26622>:
  stderr.47 = stderr;
  fprintf (stderr.47, "AOT : invalid format for readonly field \'%s\', missing =.\n", val);
  exit (1);
  <D.26623>:
  rdv = monoeg_malloc0 (24);
  tval.48 = (int) tval;
  val.49 = (int) val;
  D.26626 = tval.48 - val.49;
  D.26627 = D.26626 + 1;
  D.26628 = (unsigned int) D.26627;
  D.26629 = monoeg_malloc0 (D.26628);
  rdv->name = D.26629;
  D.26630 = rdv->name;
  tval.48 = (int) tval;
  val.49 = (int) val;
  D.26626 = tval.48 - val.49;
  D.26631 = (unsigned int) D.26626;
  memcpy (D.26630, val, D.26631);
  tval = tval + 1;
  fval = fval + 1;
  D.26632 = strncmp (tval, "i1", 2);
  if (D.26632 == 0) goto <D.26633>; else goto <D.26634>;
  <D.26633>:
  D.26635 = atoi (fval);
  D.26636 = (unsigned char) D.26635;
  rdv->value.i1 = D.26636;
  rdv->type = 4;
  goto <D.26637>;
  <D.26634>:
  D.26638 = strncmp (tval, "i2", 2);
  if (D.26638 == 0) goto <D.26639>; else goto <D.26640>;
  <D.26639>:
  D.26641 = atoi (fval);
  D.26642 = (short unsigned int) D.26641;
  rdv->value.i2 = D.26642;
  rdv->type = 6;
  goto <D.26643>;
  <D.26640>:
  D.26644 = strncmp (tval, "i4", 2);
  if (D.26644 == 0) goto <D.26645>; else goto <D.26646>;
  <D.26645>:
  D.26647 = atoi (fval);
  D.26648 = (unsigned int) D.26647;
  rdv->value.i4 = D.26648;
  rdv->type = 8;
  goto <D.26649>;
  <D.26646>:
  stderr.47 = stderr;
  fprintf (stderr.47, "AOT : unsupported type for readonly field \'%s\'.\n", tval);
  exit (1);
  <D.26649>:
  <D.26643>:
  <D.26637>:
  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.26651;
  gboolean D.26652;
  unsigned int len.51;
  int D.26654;
  _Bool D.26655;
  int len;

  D.26651 = strlen (str2);
  len = (int) D.26651;
  len.51 = (unsigned int) len;
  D.26654 = strncmp (str1, str2, len.51);
  D.26655 = D.26654 == 0;
  D.26652 = (gboolean) D.26655;
  return D.26652;
}


load_profile_files (struct MonoAotCompile * acfg)
{
  const gchar * D.26657;
  struct MonoImage * D.26658;
  const char * D.26659;
  int D.26660;
  _Bool D.26663;
  long int D.26664;
  long int D.26665;
  int D.25081;
  int iftmp.52;
  int D.25080;
  const char[7] * D.26674;
  unsigned char D.26675;
  int D.26676;
  unsigned char D.26677;
  int D.26678;
  const unsigned char * D.26683;
  unsigned char D.26684;
  int D.26685;
  const unsigned char * D.26686;
  unsigned char D.26687;
  int D.26688;
  const unsigned char * D.26693;
  unsigned char D.26694;
  int D.26695;
  const unsigned char * D.26696;
  unsigned char D.26697;
  int D.26698;
  const unsigned char * D.26703;
  unsigned char D.26704;
  int D.26705;
  const unsigned char * D.26706;
  unsigned char D.26707;
  int D.26708;
  char * D.26710;
  char[1024] * name.53;
  char D.26713;
  unsigned int D.26716;
  unsigned int D.26717;
  unsigned int D.26720;
  unsigned int D.26723;
  unsigned int D.26724;
  struct GPtrArray * D.26725;
  void * * D.26726;
  unsigned int i.54;
  unsigned int D.26728;
  void * * D.26729;
  void * D.26730;
  void * method_index.55;
  unsigned int i.56;
  unsigned int D.26735;
  <unnamed-unsigned:24> D.26743;
  int D.26744;
  void * D.26745;
  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.25091>:
      D.26657 = monoeg_g_get_home_dir ();
      D.26658 = acfg->image;
      D.26659 = D.26658->assembly_name;
      tmp = monoeg_g_strdup_printf ("%s/.mono/aot-profile-data/%s-%d", D.26657, D.26659, file_index);
      D.26660 = monoeg_g_file_test (tmp, 1);
      if (D.26660 == 0) goto <D.26661>; else goto <D.26662>;
      <D.26661>:
      monoeg_g_free (tmp);
      goto <D.25072>;
      <D.26662>:
      infile = fopen (tmp, "r");
      D.26663 = infile == 0B;
      D.26664 = (long int) D.26663;
      D.26665 = __builtin_expect (D.26664, 0);
      if (D.26665 != 0) goto <D.26666>; else goto <D.26667>;
      <D.26666>:
      monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "aot-compiler.c", 6785, "infile");
      <D.26667>:
      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.26668>; else goto <D.26670>;
      <D.26670>:
      {
        size_t __s1_len;
        size_t __s2_len;

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

          __s2 = &ver;
          D.26674 = "#VER:2";
          D.26675 = MEM[(const unsigned char *)D.26674];
          D.26676 = (int) D.26675;
          D.26677 = *__s2;
          D.26678 = (int) D.26677;
          __result = D.26676 - D.26678;
          {
            if (__s2_len != 0) goto <D.26679>; else goto <D.26680>;
            <D.26679>:
            if (__result == 0) goto <D.26681>; else goto <D.26682>;
            <D.26681>:
            D.26683 = &MEM[(void *)"#VER:2" + 1B];
            D.26684 = *D.26683;
            D.26685 = (int) D.26684;
            D.26686 = __s2 + 1;
            D.26687 = *D.26686;
            D.26688 = (int) D.26687;
            __result = D.26685 - D.26688;
            if (__s2_len > 1) goto <D.26689>; else goto <D.26690>;
            <D.26689>:
            if (__result == 0) goto <D.26691>; else goto <D.26692>;
            <D.26691>:
            D.26693 = &MEM[(void *)"#VER:2" + 2B];
            D.26694 = *D.26693;
            D.26695 = (int) D.26694;
            D.26696 = __s2 + 2;
            D.26697 = *D.26696;
            D.26698 = (int) D.26697;
            __result = D.26695 - D.26698;
            if (__s2_len > 2) goto <D.26699>; else goto <D.26700>;
            <D.26699>:
            if (__result == 0) goto <D.26701>; else goto <D.26702>;
            <D.26701>:
            D.26703 = &MEM[(void *)"#VER:2" + 3B];
            D.26704 = *D.26703;
            D.26705 = (int) D.26704;
            D.26706 = __s2 + 3;
            D.26707 = *D.26706;
            D.26708 = (int) D.26707;
            __result = D.26705 - D.26708;
            <D.26702>:
            <D.26700>:
            <D.26692>:
            <D.26690>:
            <D.26682>:
            <D.26680>:
          }
          D.25080 = __result;
        }
        iftmp.52 = -D.25080;
        goto <D.26709>;
        <D.26673>:
        iftmp.52 = __builtin_strcmp (&ver, "#VER:2");
        <D.26709>:
        D.25081 = iftmp.52;
      }
      if (D.25081 != 0) goto <D.26668>; else goto <D.26669>;
      <D.26668>:
      printf ("Profile file has wrong version or invalid.\n");
      fclose (infile);
      // predicted unlikely by continue predictor.
      goto <D.25082>;
      <D.26669>:
      <D.25090>:
      {
        char name[1024];
        struct MonoMethodDesc * desc;
        struct MonoMethod * method;

        try
          {
            D.26710 = fgets (&name, 1023, infile);
            if (D.26710 == 0B) goto <D.25086>; else goto <D.26711>;
            <D.26711>:
            name.53 = &name;
            D.26713 = MEM[(const char *)name.53];
            if (D.26713 != 0) goto <D.26714>; else goto <D.26715>;
            <D.26714>:
            D.26716 = strlen (&name);
            D.26717 = D.26716 + 4294967295;
            name[D.26717] = 0;
            <D.26715>:
            desc = mono_method_desc_new (&name, 1);
            D.26658 = acfg->image;
            method = mono_method_desc_search_in_image (desc, D.26658);
            if (method != 0B) goto <D.26718>; else goto <D.26719>;
            <D.26718>:
            D.26720 = mono_method_get_token (method);
            if (D.26720 != 0) goto <D.26721>; else goto <D.26722>;
            <D.26721>:
            token = mono_method_get_token (method);
            D.26723 = token & 16777215;
            D.26724 = D.26723 + 4294967295;
            method_index = (int) D.26724;
            found = 0;
            i = 0;
            goto <D.25089>;
            <D.25088>:
            D.26725 = acfg->method_order;
            D.26726 = D.26725->pdata;
            i.54 = (unsigned int) i;
            D.26728 = i.54 * 4;
            D.26729 = D.26726 + D.26728;
            D.26730 = *D.26729;
            method_index.55 = (void *) method_index;
            if (D.26730 == method_index.55) goto <D.26732>; else goto <D.26733>;
            <D.26732>:
            found = 1;
            goto <D.25087>;
            <D.26733>:
            i = i + 1;
            <D.25089>:
            i.56 = (unsigned int) i;
            D.26725 = acfg->method_order;
            D.26735 = D.26725->len;
            if (i.56 < D.26735) goto <D.25088>; else goto <D.25087>;
            <D.25087>:
            if (found == 0) goto <D.26736>; else goto <D.26737>;
            <D.26736>:
            D.26725 = acfg->method_order;
            method_index.55 = (void *) method_index;
            monoeg_g_ptr_array_add (D.26725, method_index.55);
            <D.26737>:
            goto <D.26738>;
            <D.26722>:
            <D.26738>:
            <D.26719>:
          }
        finally
          {
            name = {CLOBBER};
          }
      }
      goto <D.25090>;
      <D.25086>:
      fclose (infile);
      <D.25082>:
      goto <D.25091>;
      <D.25072>:
      unordered = 0B;
      method_index = 0;
      goto <D.25096>;
      <D.25095>:
      found = 0;
      i = 0;
      goto <D.25094>;
      <D.25093>:
      D.26725 = acfg->method_order;
      D.26726 = D.26725->pdata;
      i.54 = (unsigned int) i;
      D.26728 = i.54 * 4;
      D.26729 = D.26726 + D.26728;
      D.26730 = *D.26729;
      method_index.55 = (void *) method_index;
      if (D.26730 == method_index.55) goto <D.26739>; else goto <D.26740>;
      <D.26739>:
      found = 1;
      goto <D.25092>;
      <D.26740>:
      i = i + 1;
      <D.25094>:
      i.56 = (unsigned int) i;
      D.26725 = acfg->method_order;
      D.26735 = D.26725->len;
      if (i.56 < D.26735) goto <D.25093>; else goto <D.25092>;
      <D.25092>:
      if (found == 0) goto <D.26741>; else goto <D.26742>;
      <D.26741>:
      method_index.55 = (void *) method_index;
      unordered = monoeg_g_list_prepend (unordered, method_index.55);
      <D.26742>:
      method_index = method_index + 1;
      <D.25096>:
      D.26658 = acfg->image;
      D.26743 = D.26658->tables[6].rows;
      D.26744 = (int) D.26743;
      if (D.26744 > method_index) goto <D.25095>; else goto <D.25097>;
      <D.25097>:
      unordered = monoeg_g_list_reverse (unordered);
      l = unordered;
      goto <D.25099>;
      <D.25098>:
      D.26725 = acfg->method_order;
      D.26745 = l->data;
      monoeg_g_ptr_array_add (D.26725, D.26745);
      l = l->next;
      <D.25099>:
      if (l != 0B) goto <D.25098>; else goto <D.25100>;
      <D.25100>:
    }
  finally
    {
      ver = {CLOBBER};
    }
}


fgets (char * restrict __s, int __n, struct FILE * restrict __stream)
{
  unsigned int D.26748;
  int D.26753;
  char * D.26755;
  unsigned int D.26756;
  unsigned int __n.57;
  unsigned int D.26758;
  unsigned int D.26761;

  D.26748 = __builtin_object_size (__s, 1);
  if (D.26748 != 4294967295) goto <D.26749>; else goto <D.26750>;
  <D.26749>:
  D.26753 = __builtin_constant_p (__n);
  if (D.26753 == 0) goto <D.26751>; else goto <D.26754>;
  <D.26754>:
  if (__n <= 0) goto <D.26751>; else goto <D.26752>;
  <D.26751>:
  D.26756 = __builtin_object_size (__s, 1);
  D.26755 = __fgets_chk (__s, D.26756, __n, __stream);
  return D.26755;
  <D.26752>:
  __n.57 = (unsigned int) __n;
  D.26758 = __builtin_object_size (__s, 1);
  if (__n.57 > D.26758) goto <D.26759>; else goto <D.26760>;
  <D.26759>:
  D.26761 = __builtin_object_size (__s, 1);
  D.26755 = __fgets_chk_warn (__s, D.26761, __n, __stream);
  return D.26755;
  <D.26760>:
  <D.26750>:
  D.26755 = __fgets_alias (__s, __n, __stream);
  return D.26755;
}


arch_init (struct MonoAotCompile * acfg)
{
  struct GString * D.26763;
  struct GString * D.26764;

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


collect_methods (struct MonoAotCompile * acfg)
{
  int D.26765;
  int D.26766;
  struct MonoImage * D.26767;
  char * D.26770;
  struct MonoClass * D.26771;
  int D.26772;
  short unsigned int D.26775;
  int D.26776;
  int D.26777;
  int check_for_pending_exc.58;
  int D.26781;
  int D.26782;
  <unnamed-unsigned:24> D.26783;
  int D.26784;
  int D.26785;
  int D.26786;
  unsigned int D.26787;
  unsigned int D.26788;
  unsigned int D.26795;
  unsigned int D.26796;
  struct MonoClass * D.26798;
  struct MonoGenericContainer * D.26799;
  int mindex;
  int i;
  struct MonoImage * image;

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

    D.26765 = i + 1;
    D.26766 = D.26765 | 100663296;
    token = (guint32) D.26766;
    D.26767 = acfg->image;
    method = mono_get_method (D.26767, token, 0B);
    if (method == 0B) goto <D.26768>; else goto <D.26769>;
    <D.26768>:
    D.26770 = image->name;
    printf ("Failed to load method 0x%x from \'%s\'.\n", token, D.26770);
    exit (1);
    <D.26769>:
    D.26771 = method->klass;
    mono_class_setup_methods (D.26771);
    D.26772 = acfg->aot_opts.full_aot;
    if (D.26772 != 0) goto <D.26773>; else goto <D.26774>;
    <D.26773>:
    D.26775 = method->iflags;
    D.26776 = (int) D.26775;
    D.26777 = D.26776 & 4096;
    if (D.26777 != 0) goto <D.26778>; else goto <D.26779>;
    <D.26778>:
    {
      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.26779>:
    <D.26774>:
    add_method_with_index (acfg, method, i, 0);
    D.26781 = acfg->method_index;
    D.26782 = D.26781 + 1;
    acfg->method_index = D.26782;
  }
  i = i + 1;
  <D.25465>:
  D.26783 = image->tables[6].rows;
  D.26784 = (int) D.26783;
  if (D.26784 > i) goto <D.25464>; else goto <D.25466>;
  <D.25466>:
  mindex = 0;
  goto <D.25472>;
  <D.25471>:
  {
    struct MonoMethod * method;
    guint32 token;

    D.26785 = mindex + 1;
    D.26786 = D.26785 | 100663296;
    token = (guint32) D.26786;
    D.26787 = acfg->opts;
    D.26788 = D.26787 & 16777216;
    if (D.26788 == 0) goto <D.26789>; else goto <D.26790>;
    <D.26789>:
    // predicted unlikely by continue predictor.
    goto <D.25469>;
    <D.26790>:
    D.26767 = acfg->image;
    method = mono_get_method (D.26767, token, 0B);
    if (method == 0B) goto <D.26791>; else goto <D.26792>;
    <D.26791>:
    // predicted unlikely by continue predictor.
    goto <D.25469>;
    <D.26792>:
    D.26795 = BIT_FIELD_REF <*method, 32, 160>;
    D.26796 = D.26795 & 2048;
    if (D.26796 != 0) goto <D.26793>; else goto <D.26797>;
    <D.26797>:
    D.26798 = method->klass;
    D.26799 = D.26798->generic_container;
    if (D.26799 != 0B) goto <D.26793>; else goto <D.26794>;
    <D.26793>:
    {
      struct MonoMethod * gshared;

      gshared = mini_get_shared_method_full (method, 1, 1);
      add_extra_method (acfg, gshared);
    }
    <D.26794>:
  }
  <D.25469>:
  mindex = mindex + 1;
  <D.25472>:
  D.26783 = image->tables[6].rows;
  D.26784 = (int) D.26783;
  if (D.26784 > mindex) goto <D.25471>; else goto <D.25473>;
  <D.25473>:
  add_generic_instances (acfg);
  D.26772 = acfg->aot_opts.full_aot;
  if (D.26772 != 0) goto <D.26800>; else goto <D.26801>;
  <D.26800>:
  add_wrappers (acfg);
  <D.26801>:
}


add_method_with_index (struct MonoAotCompile * acfg, struct MonoMethod * method, int index, gboolean extra)
{
  _Bool D.26802;
  long int D.26803;
  long int D.26804;
  struct GHashTable * D.26807;
  void * D.26808;
  struct GPtrArray * D.26811;
  int D.26812;
  void * D.26813;
  unsigned int D.26814;
  unsigned int D.26815;
  unsigned int D.26818;
  unsigned int D.26819;
  struct GPtrArray * D.26821;

  D.26802 = method == 0B;
  D.26803 = (long int) D.26802;
  D.26804 = __builtin_expect (D.26803, 0);
  if (D.26804 != 0) goto <D.26805>; else goto <D.26806>;
  <D.26805>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "aot-compiler.c", 2994, "method");
  <D.26806>:
  D.26807 = acfg->method_indexes;
  D.26808 = monoeg_g_hash_table_lookup (D.26807, method);
  if (D.26808 == 0B) goto <D.26809>; else goto <D.26810>;
  <D.26809>:
  D.26811 = acfg->methods;
  monoeg_g_ptr_array_add (D.26811, method);
  D.26807 = acfg->method_indexes;
  D.26812 = index + 1;
  D.26813 = (void *) D.26812;
  monoeg_g_hash_table_insert_replace (D.26807, method, D.26813, 0);
  D.26811 = acfg->methods;
  D.26814 = D.26811->len;
  D.26815 = D.26814 + 1;
  acfg->nmethods = D.26815;
  <D.26810>:
  D.26818 = BIT_FIELD_REF <*method, 32, 160>;
  D.26819 = D.26818 & 124;
  if (D.26819 != 0) goto <D.26816>; else goto <D.26820>;
  <D.26820>:
  if (extra != 0) goto <D.26816>; else goto <D.26817>;
  <D.26816>:
  D.26821 = acfg->extra_methods;
  monoeg_g_ptr_array_add (D.26821, method);
  <D.26817>:
}


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.26822;
  int D.26825;
  char * D.26828;

  D.26822 = mono_method_is_generic_sharable_full (method, 0, 1, 0);
  if (D.26822 != 0) goto <D.26823>; else goto <D.26824>;
  <D.26823>:
  method = mini_get_shared_method (method);
  <D.26824>:
  D.26825 = acfg->aot_opts.log_generics;
  if (D.26825 != 0) goto <D.26826>; else goto <D.26827>;
  <D.26826>:
  D.26828 = mono_method_full_name (method, 1);
  printf ("%*sAdding method %s.\n", depth, "", D.26828);
  <D.26827>:
  add_method_full (acfg, method, 1, depth);
}


add_method_full (struct MonoAotCompile * acfg, struct MonoMethod * method, gboolean extra, int depth)
{
  struct GHashTable * D.26829;
  void * D.26830;
  int D.26833;
  struct GPtrArray * D.26834;
  void * index.59;
  struct GHashTable * D.26836;
  void * depth.60;
  int D.26838;
  int D.26839;
  int index;

  D.26829 = acfg->method_indexes;
  D.26830 = monoeg_g_hash_table_lookup (D.26829, method);
  index = (int) D.26830;
  if (index != 0) goto <D.26831>; else goto <D.26832>;
  <D.26831>:
  D.26833 = index + -1;
  return D.26833;
  <D.26832>:
  index = acfg->method_index;
  add_method_with_index (acfg, method, index, extra);
  D.26834 = acfg->method_order;
  index.59 = (void *) index;
  monoeg_g_ptr_array_add (D.26834, index.59);
  D.26836 = acfg->method_depth;
  depth.60 = (void *) depth;
  monoeg_g_hash_table_insert_replace (D.26836, method, depth.60, 0);
  D.26838 = acfg->method_index;
  D.26839 = D.26838 + 1;
  acfg->method_index = D.26839;
  D.26833 = index;
  return D.26833;
}


add_generic_instances (struct MonoAotCompile * acfg)
{
  int D.26841;
  int D.26844;
  int D.26845;
  struct MonoImage * D.26846;
  struct MonoClass * D.26849;
  struct MonoImage * D.26850;
  struct MonoGenericInst * D.26855;
  unsigned int D.26858;
  unsigned int D.26859;
  struct MonoGenericInst * D.26864;
  unsigned int D.26867;
  unsigned int D.26868;
  struct MonoType * D.26875;
  int D.26876;
  unsigned char D.26878;
  int D.26880;
  <unnamed-unsigned:22> D.26883;
  int D.26884;
  int D.26889;
  int D.26892;
  unsigned int D.26899;
  unsigned int D.26900;
  int D.26904;
  unsigned int i.61;
  unsigned int D.26908;
  struct MonoType * * D.26909;
  struct MonoClass * D.26910;
  struct MonoType * D.26911;
  struct MonoGenericInst * D.26912;
  int D.26918;
  struct MonoGenericInst * D.26921;
  unsigned int D.26925;
  unsigned int D.26926;
  struct MonoGenericContainer * D.26928;
  int D.26929;
  <unnamed-unsigned:24> D.26932;
  int D.26933;
  int D.26934;
  unsigned char D.26938;
  <unnamed-unsigned:24> D.26939;
  int D.26940;
  struct GPtrArray * D.26941;
  void * * D.26942;
  unsigned int i.62;
  unsigned int D.26944;
  void * * D.26945;
  unsigned int i.63;
  unsigned int D.26947;
  struct MonoImage * D.26948;
  int ninsts.64;
  struct MonoClass * D.26952;
  struct MonoType * D.26953;
  int ninsts.65;
  struct MonoClass * D.26955;
  struct MonoType * D.26956;
  int ninsts.66;
  struct MonoClass * D.26958;
  struct MonoType * D.26959;
  int ninsts.67;
  struct MonoClass * D.26961;
  struct MonoType * D.26962;
  int ninsts.68;
  struct MonoClass * D.26964;
  struct MonoType * D.26965;
  int ninsts.69;
  struct MonoClass * D.26967;
  struct MonoType * D.26968;
  int ninsts.70;
  struct MonoClass * D.26970;
  struct MonoType * D.26971;
  int ninsts.71;
  struct MonoClass * D.26973;
  struct MonoType * D.26974;
  int ninsts.72;
  struct MonoClass * D.26976;
  struct MonoType * D.26977;
  int ninsts.73;
  struct MonoClass * D.26979;
  struct MonoType * D.26980;
  int ninsts.74;
  struct MonoClass * D.26982;
  struct MonoType * D.26983;
  int ninsts.75;
  struct MonoClass * D.26985;
  struct MonoType * D.26986;
  struct MonoClass * D.26997;
  struct MonoGenericInst * D.27000;
  struct MonoMethod * D.27001;
  struct MonoMethod * D.27002;
  int D.24292;
  int iftmp.76;
  int D.24291;
  const char[16] * D.27008;
  unsigned char D.27009;
  int D.27010;
  unsigned char D.27011;
  int D.27012;
  const unsigned char * D.27017;
  unsigned char D.27018;
  int D.27019;
  const unsigned char * D.27020;
  unsigned char D.27021;
  int D.27022;
  const unsigned char * D.27027;
  unsigned char D.27028;
  int D.27029;
  const unsigned char * D.27030;
  unsigned char D.27031;
  int D.27032;
  const unsigned char * D.27037;
  unsigned char D.27038;
  int D.27039;
  const unsigned char * D.27040;
  unsigned char D.27041;
  int D.27042;
  const char * D.27044;
  int D.24301;
  int iftmp.77;
  int D.24300;
  const char[9] * D.27049;
  unsigned char D.27050;
  int D.27051;
  unsigned char D.27052;
  int D.27053;
  const unsigned char * D.27058;
  unsigned char D.27059;
  int D.27060;
  const unsigned char * D.27061;
  unsigned char D.27062;
  int D.27063;
  const unsigned char * D.27068;
  unsigned char D.27069;
  int D.27070;
  const unsigned char * D.27071;
  unsigned char D.27072;
  int D.27073;
  const unsigned char * D.27078;
  unsigned char D.27079;
  int D.27080;
  const unsigned char * D.27081;
  unsigned char D.27082;
  int D.27083;
  unsigned int D.27085;
  unsigned int D.27086;
  struct MonoGenericInst * D.27089;
  struct MonoMethod * D.27090;
  struct MonoMethod * D.27091;
  int D.24318;
  int iftmp.78;
  int D.24317;
  const char[5] * D.27099;
  unsigned char D.27100;
  int D.27101;
  unsigned char D.27102;
  int D.27103;
  const unsigned char * D.27108;
  unsigned char D.27109;
  int D.27110;
  const unsigned char * D.27111;
  unsigned char D.27112;
  int D.27113;
  const unsigned char * D.27118;
  unsigned char D.27119;
  int D.27120;
  const unsigned char * D.27121;
  unsigned char D.27122;
  int D.27123;
  const unsigned char * D.27128;
  unsigned char D.27129;
  int D.27130;
  const unsigned char * D.27131;
  unsigned char D.27132;
  int D.27133;
  const char * D.27135;
  int D.24327;
  int iftmp.79;
  int D.24326;
  const char[6] * D.27140;
  unsigned char D.27141;
  int D.27142;
  unsigned char D.27143;
  int D.27144;
  const unsigned char * D.27149;
  unsigned char D.27150;
  int D.27151;
  const unsigned char * D.27152;
  unsigned char D.27153;
  int D.27154;
  const unsigned char * D.27159;
  unsigned char D.27160;
  int D.27161;
  const unsigned char * D.27162;
  unsigned char D.27163;
  int D.27164;
  const unsigned char * D.27169;
  unsigned char D.27170;
  int D.27171;
  const unsigned char * D.27172;
  unsigned char D.27173;
  int D.27174;
  unsigned int D.27176;
  unsigned int D.27177;
  struct MonoGenericInst * D.27180;
  struct MonoMethod * D.27181;
  struct MonoMethod * D.27182;
  int i;
  guint32 token;
  struct MonoMethod * method;
  struct MonoGenericContext * context;

  D.26841 = acfg->aot_opts.no_instances;
  if (D.26841 != 0) goto <D.26842>; else goto <D.26843>;
  <D.26842>:
  return;
  <D.26843>:
  i = 0;
  goto <D.24262>;
  <D.24261>:
  D.26844 = i + 1;
  D.26845 = D.26844 | 721420288;
  token = (guint32) D.26845;
  D.26846 = acfg->image;
  method = mono_get_method (D.26846, token, 0B);
  if (method == 0B) goto <D.26847>; else goto <D.26848>;
  <D.26847>:
  // predicted unlikely by continue predictor.
  goto <D.24240>;
  <D.26848>:
  D.26849 = method->klass;
  D.26850 = D.26849->image;
  D.26846 = acfg->image;
  if (D.26850 != D.26846) goto <D.26851>; else goto <D.26852>;
  <D.26851>:
  // predicted unlikely by continue predictor.
  goto <D.24240>;
  <D.26852>:
  context = mono_method_get_context (method);
  if (context != 0B) goto <D.26853>; else goto <D.26854>;
  <D.26853>:
  D.26855 = context->class_inst;
  if (D.26855 != 0B) goto <D.26856>; else goto <D.26857>;
  <D.26856>:
  D.26855 = context->class_inst;
  D.26858 = BIT_FIELD_REF <*D.26855, 32, 32>;
  D.26859 = D.26858 & 4194304;
  if (D.26859 != 0) goto <D.26860>; else goto <D.26861>;
  <D.26860>:
  // predicted unlikely by continue predictor.
  goto <D.24240>;
  <D.26861>:
  <D.26857>:
  <D.26854>:
  if (context != 0B) goto <D.26862>; else goto <D.26863>;
  <D.26862>:
  D.26864 = context->method_inst;
  if (D.26864 != 0B) goto <D.26865>; else goto <D.26866>;
  <D.26865>:
  D.26864 = context->method_inst;
  D.26867 = BIT_FIELD_REF <*D.26864, 32, 32>;
  D.26868 = D.26867 & 4194304;
  if (D.26868 != 0) goto <D.26869>; else goto <D.26870>;
  <D.26869>:
  {
    struct MonoGenericContext shared_context;
    struct MonoGenericInst * inst;
    struct MonoType * * type_argv;
    int i;
    struct MonoMethod * declaring_method;
    gboolean supported;

    try
      {
        supported = 1;
        D.26855 = context->class_inst;
        if (D.26855 != 0B) goto <D.26871>; else goto <D.26872>;
        <D.26871>:
        inst = context->class_inst;
        i = 0;
        goto <D.24249>;
        <D.24248>:
        D.26875 = inst->type_argv[i];
        D.26876 = mono_type_is_reference (D.26875);
        if (D.26876 != 0) goto <D.26873>; else goto <D.26877>;
        <D.26877>:
        D.26875 = inst->type_argv[i];
        D.26878 = D.26875->type;
        if (D.26878 == 19) goto <D.26873>; else goto <D.26879>;
        <D.26879>:
        D.26875 = inst->type_argv[i];
        D.26878 = D.26875->type;
        if (D.26878 == 30) goto <D.26873>; else goto <D.26874>;
        <D.26873>:
        // predicted unlikely by continue predictor.
        goto <D.24247>;
        <D.26874>:
        D.26875 = inst->type_argv[i];
        D.26880 = mono_class_is_open_constructed_type (D.26875);
        if (D.26880 != 0) goto <D.26881>; else goto <D.26882>;
        <D.26881>:
        supported = 0;
        <D.26882>:
        <D.24247>:
        i = i + 1;
        <D.24249>:
        D.26883 = inst->type_argc;
        D.26884 = (int) D.26883;
        if (D.26884 > i) goto <D.24248>; else goto <D.24250>;
        <D.24250>:
        <D.26872>:
        D.26864 = context->method_inst;
        if (D.26864 != 0B) goto <D.26885>; else goto <D.26886>;
        <D.26885>:
        inst = context->method_inst;
        i = 0;
        goto <D.24253>;
        <D.24252>:
        D.26875 = inst->type_argv[i];
        D.26889 = mono_type_is_reference (D.26875);
        if (D.26889 != 0) goto <D.26887>; else goto <D.26890>;
        <D.26890>:
        D.26875 = inst->type_argv[i];
        D.26878 = D.26875->type;
        if (D.26878 == 19) goto <D.26887>; else goto <D.26891>;
        <D.26891>:
        D.26875 = inst->type_argv[i];
        D.26878 = D.26875->type;
        if (D.26878 == 30) goto <D.26887>; else goto <D.26888>;
        <D.26887>:
        // predicted unlikely by continue predictor.
        goto <D.24251>;
        <D.26888>:
        D.26875 = inst->type_argv[i];
        D.26892 = mono_class_is_open_constructed_type (D.26875);
        if (D.26892 != 0) goto <D.26893>; else goto <D.26894>;
        <D.26893>:
        supported = 0;
        <D.26894>:
        <D.24251>:
        i = i + 1;
        <D.24253>:
        D.26883 = inst->type_argc;
        D.26884 = (int) D.26883;
        if (D.26884 > i) goto <D.24252>; else goto <D.24254>;
        <D.24254>:
        <D.26886>:
        if (supported == 0) goto <D.26895>; else goto <D.26896>;
        <D.26895>:
        // predicted unlikely by continue predictor.
        goto <D.24240>;
        <D.26896>:
        memset (&shared_context, 0, 8);
        inst = context->class_inst;
        if (inst != 0B) goto <D.26897>; else goto <D.26898>;
        <D.26897>:
        D.26883 = inst->type_argc;
        D.26899 = (unsigned int) D.26883;
        D.26900 = D.26899 * 4;
        type_argv = monoeg_malloc0 (D.26900);
        i = 0;
        goto <D.24256>;
        <D.24255>:
        D.26875 = inst->type_argv[i];
        D.26904 = mono_type_is_reference (D.26875);
        if (D.26904 != 0) goto <D.26901>; else goto <D.26905>;
        <D.26905>:
        D.26875 = inst->type_argv[i];
        D.26878 = D.26875->type;
        if (D.26878 == 19) goto <D.26901>; else goto <D.26906>;
        <D.26906>:
        D.26875 = inst->type_argv[i];
        D.26878 = D.26875->type;
        if (D.26878 == 30) goto <D.26901>; else goto <D.26902>;
        <D.26901>:
        i.61 = (unsigned int) i;
        D.26908 = i.61 * 4;
        D.26909 = type_argv + D.26908;
        D.26910 = mono_defaults.object_class;
        D.26911 = &D.26910->byval_arg;
        *D.26909 = D.26911;
        goto <D.26903>;
        <D.26902>:
        i.61 = (unsigned int) i;
        D.26908 = i.61 * 4;
        D.26909 = type_argv + D.26908;
        D.26875 = inst->type_argv[i];
        *D.26909 = D.26875;
        <D.26903>:
        i = i + 1;
        <D.24256>:
        D.26883 = inst->type_argc;
        D.26884 = (int) D.26883;
        if (D.26884 > i) goto <D.24255>; else goto <D.24257>;
        <D.24257>:
        D.26883 = inst->type_argc;
        D.26884 = (int) D.26883;
        D.26912 = mono_metadata_get_generic_inst (D.26884, type_argv);
        shared_context.class_inst = D.26912;
        monoeg_g_free (type_argv);
        <D.26898>:
        inst = context->method_inst;
        if (inst != 0B) goto <D.26913>; else goto <D.26914>;
        <D.26913>:
        D.26883 = inst->type_argc;
        D.26899 = (unsigned int) D.26883;
        D.26900 = D.26899 * 4;
        type_argv = monoeg_malloc0 (D.26900);
        i = 0;
        goto <D.24259>;
        <D.24258>:
        D.26875 = inst->type_argv[i];
        D.26918 = mono_type_is_reference (D.26875);
        if (D.26918 != 0) goto <D.26915>; else goto <D.26919>;
        <D.26919>:
        D.26875 = inst->type_argv[i];
        D.26878 = D.26875->type;
        if (D.26878 == 19) goto <D.26915>; else goto <D.26920>;
        <D.26920>:
        D.26875 = inst->type_argv[i];
        D.26878 = D.26875->type;
        if (D.26878 == 30) goto <D.26915>; else goto <D.26916>;
        <D.26915>:
        i.61 = (unsigned int) i;
        D.26908 = i.61 * 4;
        D.26909 = type_argv + D.26908;
        D.26910 = mono_defaults.object_class;
        D.26911 = &D.26910->byval_arg;
        *D.26909 = D.26911;
        goto <D.26917>;
        <D.26916>:
        i.61 = (unsigned int) i;
        D.26908 = i.61 * 4;
        D.26909 = type_argv + D.26908;
        D.26875 = inst->type_argv[i];
        *D.26909 = D.26875;
        <D.26917>:
        i = i + 1;
        <D.24259>:
        D.26883 = inst->type_argc;
        D.26884 = (int) D.26883;
        if (D.26884 > i) goto <D.24258>; else goto <D.24260>;
        <D.24260>:
        D.26883 = inst->type_argc;
        D.26884 = (int) D.26883;
        D.26921 = mono_metadata_get_generic_inst (D.26884, type_argv);
        shared_context.method_inst = D.26921;
        monoeg_g_free (type_argv);
        <D.26914>:
        D.26925 = BIT_FIELD_REF <*method, 32, 160>;
        D.26926 = D.26925 & 2048;
        if (D.26926 != 0) goto <D.26922>; else goto <D.26927>;
        <D.26927>:
        D.26849 = method->klass;
        D.26928 = D.26849->generic_container;
        if (D.26928 != 0B) goto <D.26922>; else goto <D.26923>;
        <D.26922>:
        declaring_method = method;
        goto <D.26924>;
        <D.26923>:
        declaring_method = mono_method_get_declaring_generic_method (method);
        <D.26924>:
        method = mono_class_inflate_generic_method (declaring_method, &shared_context);
      }
    finally
      {
        shared_context = {CLOBBER};
      }
  }
  <D.26870>:
  <D.26866>:
  <D.26863>:
  D.26929 = mono_method_is_generic_sharable_full (method, 0, 0, 0);
  if (D.26929 != 0) goto <D.26930>; else goto <D.26931>;
  <D.26930>:
  // predicted unlikely by continue predictor.
  goto <D.24240>;
  <D.26931>:
  add_extra_method (acfg, method);
  <D.24240>:
  i = i + 1;
  <D.24262>:
  D.26846 = acfg->image;
  D.26932 = D.26846->tables[43].rows;
  D.26933 = (int) D.26932;
  if (D.26933 > i) goto <D.24261>; else goto <D.24263>;
  <D.24263>:
  i = 0;
  goto <D.24267>;
  <D.24266>:
  {
    struct MonoClass * klass;

    D.26844 = i + 1;
    D.26934 = D.26844 | 452984832;
    token = (guint32) D.26934;
    D.26846 = acfg->image;
    klass = mono_class_get (D.26846, token);
    if (klass == 0B) goto <D.26935>; else goto <D.26937>;
    <D.26937>:
    D.26938 = klass->rank;
    if (D.26938 != 0) goto <D.26935>; else goto <D.26936>;
    <D.26935>:
    mono_loader_clear_error ();
    // predicted unlikely by continue predictor.
    goto <D.24265>;
    <D.26936>:
    add_generic_class (acfg, klass, 0, "typespec");
  }
  <D.24265>:
  i = i + 1;
  <D.24267>:
  D.26846 = acfg->image;
  D.26939 = D.26846->tables[27].rows;
  D.26940 = (int) D.26939;
  if (D.26940 > i) goto <D.24266>; else goto <D.24268>;
  <D.24268>:
  i = 0;
  goto <D.24270>;
  <D.24269>:
  D.26941 = acfg->methods;
  D.26942 = D.26941->pdata;
  i.62 = (unsigned int) i;
  D.26944 = i.62 * 4;
  D.26945 = D.26942 + D.26944;
  method = *D.26945;
  add_types_from_method_header (acfg, method);
  i = i + 1;
  <D.24270>:
  i.63 = (unsigned int) i;
  D.26941 = acfg->methods;
  D.26947 = D.26941->len;
  if (i.63 < D.26947) goto <D.24269>; else goto <D.24271>;
  <D.24271>:
  D.26846 = acfg->image;
  D.26948 = mono_defaults.corlib;
  if (D.26846 == D.26948) goto <D.26949>; else goto <D.26950>;
  <D.26949>:
  {
    struct MonoClass * klass;
    struct MonoType * insts[256];
    int ninsts;

    try
      {
        ninsts = 0;
        ninsts.64 = ninsts;
        ninsts = ninsts.64 + 1;
        D.26952 = mono_defaults.byte_class;
        D.26953 = &D.26952->byval_arg;
        insts[ninsts.64] = D.26953;
        ninsts.65 = ninsts;
        ninsts = ninsts.65 + 1;
        D.26955 = mono_defaults.sbyte_class;
        D.26956 = &D.26955->byval_arg;
        insts[ninsts.65] = D.26956;
        ninsts.66 = ninsts;
        ninsts = ninsts.66 + 1;
        D.26958 = mono_defaults.int16_class;
        D.26959 = &D.26958->byval_arg;
        insts[ninsts.66] = D.26959;
        ninsts.67 = ninsts;
        ninsts = ninsts.67 + 1;
        D.26961 = mono_defaults.uint16_class;
        D.26962 = &D.26961->byval_arg;
        insts[ninsts.67] = D.26962;
        ninsts.68 = ninsts;
        ninsts = ninsts.68 + 1;
        D.26964 = mono_defaults.int32_class;
        D.26965 = &D.26964->byval_arg;
        insts[ninsts.68] = D.26965;
        ninsts.69 = ninsts;
        ninsts = ninsts.69 + 1;
        D.26967 = mono_defaults.uint32_class;
        D.26968 = &D.26967->byval_arg;
        insts[ninsts.69] = D.26968;
        ninsts.70 = ninsts;
        ninsts = ninsts.70 + 1;
        D.26970 = mono_defaults.int64_class;
        D.26971 = &D.26970->byval_arg;
        insts[ninsts.70] = D.26971;
        ninsts.71 = ninsts;
        ninsts = ninsts.71 + 1;
        D.26973 = mono_defaults.uint64_class;
        D.26974 = &D.26973->byval_arg;
        insts[ninsts.71] = D.26974;
        ninsts.72 = ninsts;
        ninsts = ninsts.72 + 1;
        D.26976 = mono_defaults.single_class;
        D.26977 = &D.26976->byval_arg;
        insts[ninsts.72] = D.26977;
        ninsts.73 = ninsts;
        ninsts = ninsts.73 + 1;
        D.26979 = mono_defaults.double_class;
        D.26980 = &D.26979->byval_arg;
        insts[ninsts.73] = D.26980;
        ninsts.74 = ninsts;
        ninsts = ninsts.74 + 1;
        D.26982 = mono_defaults.char_class;
        D.26983 = &D.26982->byval_arg;
        insts[ninsts.74] = D.26983;
        ninsts.75 = ninsts;
        ninsts = ninsts.75 + 1;
        D.26985 = mono_defaults.boolean_class;
        D.26986 = &D.26985->byval_arg;
        insts[ninsts.75] = D.26986;
        D.26846 = acfg->image;
        klass = mono_class_from_name (D.26846, "System.Collections.Generic", "GenericComparer`1");
        if (klass != 0B) goto <D.26987>; else goto <D.26988>;
        <D.26987>:
        add_instances_of (acfg, klass, &insts, ninsts, 1);
        <D.26988>:
        D.26846 = acfg->image;
        klass = mono_class_from_name (D.26846, "System.Collections.Generic", "GenericEqualityComparer`1");
        if (klass != 0B) goto <D.26989>; else goto <D.26990>;
        <D.26989>:
        add_instances_of (acfg, klass, &insts, ninsts, 1);
        <D.26990>:
        D.26846 = acfg->image;
        klass = mono_class_from_name (D.26846, "System.Collections.Generic", "ICollection`1");
        if (klass != 0B) goto <D.26991>; else goto <D.26992>;
        <D.26991>:
        add_instances_of (acfg, klass, &insts, ninsts, 1);
        <D.26992>:
        D.26846 = acfg->image;
        klass = mono_class_from_name (D.26846, "System.Collections.Generic", "IList`1");
        if (klass != 0B) goto <D.26993>; else goto <D.26994>;
        <D.26993>:
        add_instances_of (acfg, klass, &insts, ninsts, 1);
        <D.26994>:
        D.26846 = acfg->image;
        klass = mono_class_from_name (D.26846, "System.Collections.Generic", "IEnumerable`1");
        if (klass != 0B) goto <D.26995>; else goto <D.26996>;
        <D.26995>:
        add_instances_of (acfg, klass, &insts, ninsts, 1);
        <D.26996>:
        {
          struct MonoGenericContext ctx;
          struct MonoType * args[16];
          struct MonoMethod * get_method;
          struct MonoClass * array_klass;

          try
            {
              D.26910 = mono_defaults.object_class;
              D.26997 = mono_array_class_get (D.26910, 1);
              array_klass = D.26997->parent;
              get_method = mono_class_get_method_from_name (array_klass, "GetGenericValueImpl", 2);
              if (get_method != 0B) goto <D.26998>; else goto <D.26999>;
              <D.26998>:
              memset (&ctx, 0, 8);
              D.26910 = mono_defaults.object_class;
              D.26911 = &D.26910->byval_arg;
              args[0] = D.26911;
              D.27000 = mono_metadata_get_generic_inst (1, &args);
              ctx.method_inst = D.27000;
              D.27001 = mono_class_inflate_generic_method (get_method, &ctx);
              D.27002 = mono_marshal_get_native_wrapper (D.27001, 1, 1);
              add_extra_method (acfg, D.27002);
              <D.26999>:
            }
          finally
            {
              ctx = {CLOBBER};
              args = {CLOBBER};
            }
        }
        {
          struct MonoGenericContext ctx;
          struct MonoType * args[16];
          struct MonoMethod * m;
          struct MonoClass * interlocked_klass;
          void * iter;

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

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

                  __s2 = m->name;
                  D.27008 = "CompareExchange";
                  D.27009 = MEM[(const unsigned char *)D.27008];
                  D.27010 = (int) D.27009;
                  D.27011 = *__s2;
                  D.27012 = (int) D.27011;
                  __result = D.27010 - D.27012;
                  {
                    if (__s2_len != 0) goto <D.27013>; else goto <D.27014>;
                    <D.27013>:
                    if (__result == 0) goto <D.27015>; else goto <D.27016>;
                    <D.27015>:
                    D.27017 = &MEM[(void *)"CompareExchange" + 1B];
                    D.27018 = *D.27017;
                    D.27019 = (int) D.27018;
                    D.27020 = __s2 + 1;
                    D.27021 = *D.27020;
                    D.27022 = (int) D.27021;
                    __result = D.27019 - D.27022;
                    if (__s2_len > 1) goto <D.27023>; else goto <D.27024>;
                    <D.27023>:
                    if (__result == 0) goto <D.27025>; else goto <D.27026>;
                    <D.27025>:
                    D.27027 = &MEM[(void *)"CompareExchange" + 2B];
                    D.27028 = *D.27027;
                    D.27029 = (int) D.27028;
                    D.27030 = __s2 + 2;
                    D.27031 = *D.27030;
                    D.27032 = (int) D.27031;
                    __result = D.27029 - D.27032;
                    if (__s2_len > 2) goto <D.27033>; else goto <D.27034>;
                    <D.27033>:
                    if (__result == 0) goto <D.27035>; else goto <D.27036>;
                    <D.27035>:
                    D.27037 = &MEM[(void *)"CompareExchange" + 3B];
                    D.27038 = *D.27037;
                    D.27039 = (int) D.27038;
                    D.27040 = __s2 + 3;
                    D.27041 = *D.27040;
                    D.27042 = (int) D.27041;
                    __result = D.27039 - D.27042;
                    <D.27036>:
                    <D.27034>:
                    <D.27026>:
                    <D.27024>:
                    <D.27016>:
                    <D.27014>:
                  }
                  D.24291 = __result;
                }
                iftmp.76 = -D.24291;
                goto <D.27043>;
                <D.27007>:
                D.27044 = m->name;
                iftmp.76 = __builtin_strcmp (D.27044, "CompareExchange");
                <D.27043>:
                D.24292 = iftmp.76;
              }
              if (D.24292 == 0) goto <D.27003>; else goto <D.27045>;
              <D.27045>:
              {
                size_t __s1_len;
                size_t __s2_len;

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

                  __s2 = m->name;
                  D.27049 = "Exchange";
                  D.27050 = MEM[(const unsigned char *)D.27049];
                  D.27051 = (int) D.27050;
                  D.27052 = *__s2;
                  D.27053 = (int) D.27052;
                  __result = D.27051 - D.27053;
                  {
                    if (__s2_len != 0) goto <D.27054>; else goto <D.27055>;
                    <D.27054>:
                    if (__result == 0) goto <D.27056>; else goto <D.27057>;
                    <D.27056>:
                    D.27058 = &MEM[(void *)"Exchange" + 1B];
                    D.27059 = *D.27058;
                    D.27060 = (int) D.27059;
                    D.27061 = __s2 + 1;
                    D.27062 = *D.27061;
                    D.27063 = (int) D.27062;
                    __result = D.27060 - D.27063;
                    if (__s2_len > 1) goto <D.27064>; else goto <D.27065>;
                    <D.27064>:
                    if (__result == 0) goto <D.27066>; else goto <D.27067>;
                    <D.27066>:
                    D.27068 = &MEM[(void *)"Exchange" + 2B];
                    D.27069 = *D.27068;
                    D.27070 = (int) D.27069;
                    D.27071 = __s2 + 2;
                    D.27072 = *D.27071;
                    D.27073 = (int) D.27072;
                    __result = D.27070 - D.27073;
                    if (__s2_len > 2) goto <D.27074>; else goto <D.27075>;
                    <D.27074>:
                    if (__result == 0) goto <D.27076>; else goto <D.27077>;
                    <D.27076>:
                    D.27078 = &MEM[(void *)"Exchange" + 3B];
                    D.27079 = *D.27078;
                    D.27080 = (int) D.27079;
                    D.27081 = __s2 + 3;
                    D.27082 = *D.27081;
                    D.27083 = (int) D.27082;
                    __result = D.27080 - D.27083;
                    <D.27077>:
                    <D.27075>:
                    <D.27067>:
                    <D.27065>:
                    <D.27057>:
                    <D.27055>:
                  }
                  D.24300 = __result;
                }
                iftmp.77 = -D.24300;
                goto <D.27084>;
                <D.27048>:
                D.27044 = m->name;
                iftmp.77 = __builtin_strcmp (D.27044, "Exchange");
                <D.27084>:
                D.24301 = iftmp.77;
              }
              if (D.24301 == 0) goto <D.27003>; else goto <D.27004>;
              <D.27003>:
              D.27085 = BIT_FIELD_REF <*m, 32, 160>;
              D.27086 = D.27085 & 2048;
              if (D.27086 != 0) goto <D.27087>; else goto <D.27088>;
              <D.27087>:
              memset (&ctx, 0, 8);
              D.26910 = mono_defaults.object_class;
              D.26911 = &D.26910->byval_arg;
              args[0] = D.26911;
              D.27089 = mono_metadata_get_generic_inst (1, &args);
              ctx.method_inst = D.27089;
              D.27090 = mono_class_inflate_generic_method (m, &ctx);
              D.27091 = mono_marshal_get_native_wrapper (D.27090, 1, 1);
              add_extra_method (acfg, D.27091);
              <D.27088>:
              <D.27004>:
              <D.24303>:
              m = mono_class_get_methods (interlocked_klass, &iter);
              if (m != 0B) goto <D.24302>; else goto <D.24304>;
              <D.24304>:
            }
          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.26948 = mono_defaults.corlib;
              volatile_klass = mono_class_from_name (D.26948, "System.Threading", "Volatile");
              iter = 0B;
              if (volatile_klass != 0B) goto <D.27092>; else goto <D.27093>;
              <D.27092>:
              goto <D.24329>;
              <D.24328>:
              {
                size_t __s1_len;
                size_t __s2_len;

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

                  __s2 = m->name;
                  D.27099 = "Read";
                  D.27100 = MEM[(const unsigned char *)D.27099];
                  D.27101 = (int) D.27100;
                  D.27102 = *__s2;
                  D.27103 = (int) D.27102;
                  __result = D.27101 - D.27103;
                  {
                    if (__s2_len != 0) goto <D.27104>; else goto <D.27105>;
                    <D.27104>:
                    if (__result == 0) goto <D.27106>; else goto <D.27107>;
                    <D.27106>:
                    D.27108 = &MEM[(void *)"Read" + 1B];
                    D.27109 = *D.27108;
                    D.27110 = (int) D.27109;
                    D.27111 = __s2 + 1;
                    D.27112 = *D.27111;
                    D.27113 = (int) D.27112;
                    __result = D.27110 - D.27113;
                    if (__s2_len > 1) goto <D.27114>; else goto <D.27115>;
                    <D.27114>:
                    if (__result == 0) goto <D.27116>; else goto <D.27117>;
                    <D.27116>:
                    D.27118 = &MEM[(void *)"Read" + 2B];
                    D.27119 = *D.27118;
                    D.27120 = (int) D.27119;
                    D.27121 = __s2 + 2;
                    D.27122 = *D.27121;
                    D.27123 = (int) D.27122;
                    __result = D.27120 - D.27123;
                    if (__s2_len > 2) goto <D.27124>; else goto <D.27125>;
                    <D.27124>:
                    if (__result == 0) goto <D.27126>; else goto <D.27127>;
                    <D.27126>:
                    D.27128 = &MEM[(void *)"Read" + 3B];
                    D.27129 = *D.27128;
                    D.27130 = (int) D.27129;
                    D.27131 = __s2 + 3;
                    D.27132 = *D.27131;
                    D.27133 = (int) D.27132;
                    __result = D.27130 - D.27133;
                    <D.27127>:
                    <D.27125>:
                    <D.27117>:
                    <D.27115>:
                    <D.27107>:
                    <D.27105>:
                  }
                  D.24317 = __result;
                }
                iftmp.78 = -D.24317;
                goto <D.27134>;
                <D.27098>:
                D.27135 = m->name;
                iftmp.78 = __builtin_strcmp (D.27135, "Read");
                <D.27134>:
                D.24318 = iftmp.78;
              }
              if (D.24318 == 0) goto <D.27094>; else goto <D.27136>;
              <D.27136>:
              {
                size_t __s1_len;
                size_t __s2_len;

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

                  __s2 = m->name;
                  D.27140 = "Write";
                  D.27141 = MEM[(const unsigned char *)D.27140];
                  D.27142 = (int) D.27141;
                  D.27143 = *__s2;
                  D.27144 = (int) D.27143;
                  __result = D.27142 - D.27144;
                  {
                    if (__s2_len != 0) goto <D.27145>; else goto <D.27146>;
                    <D.27145>:
                    if (__result == 0) goto <D.27147>; else goto <D.27148>;
                    <D.27147>:
                    D.27149 = &MEM[(void *)"Write" + 1B];
                    D.27150 = *D.27149;
                    D.27151 = (int) D.27150;
                    D.27152 = __s2 + 1;
                    D.27153 = *D.27152;
                    D.27154 = (int) D.27153;
                    __result = D.27151 - D.27154;
                    if (__s2_len > 1) goto <D.27155>; else goto <D.27156>;
                    <D.27155>:
                    if (__result == 0) goto <D.27157>; else goto <D.27158>;
                    <D.27157>:
                    D.27159 = &MEM[(void *)"Write" + 2B];
                    D.27160 = *D.27159;
                    D.27161 = (int) D.27160;
                    D.27162 = __s2 + 2;
                    D.27163 = *D.27162;
                    D.27164 = (int) D.27163;
                    __result = D.27161 - D.27164;
                    if (__s2_len > 2) goto <D.27165>; else goto <D.27166>;
                    <D.27165>:
                    if (__result == 0) goto <D.27167>; else goto <D.27168>;
                    <D.27167>:
                    D.27169 = &MEM[(void *)"Write" + 3B];
                    D.27170 = *D.27169;
                    D.27171 = (int) D.27170;
                    D.27172 = __s2 + 3;
                    D.27173 = *D.27172;
                    D.27174 = (int) D.27173;
                    __result = D.27171 - D.27174;
                    <D.27168>:
                    <D.27166>:
                    <D.27158>:
                    <D.27156>:
                    <D.27148>:
                    <D.27146>:
                  }
                  D.24326 = __result;
                }
                iftmp.79 = -D.24326;
                goto <D.27175>;
                <D.27139>:
                D.27135 = m->name;
                iftmp.79 = __builtin_strcmp (D.27135, "Write");
                <D.27175>:
                D.24327 = iftmp.79;
              }
              if (D.24327 == 0) goto <D.27094>; else goto <D.27095>;
              <D.27094>:
              D.27176 = BIT_FIELD_REF <*m, 32, 160>;
              D.27177 = D.27176 & 2048;
              if (D.27177 != 0) goto <D.27178>; else goto <D.27179>;
              <D.27178>:
              memset (&ctx, 0, 8);
              D.26910 = mono_defaults.object_class;
              D.26911 = &D.26910->byval_arg;
              args[0] = D.26911;
              D.27180 = mono_metadata_get_generic_inst (1, &args);
              ctx.method_inst = D.27180;
              D.27181 = mono_class_inflate_generic_method (m, &ctx);
              D.27182 = mono_marshal_get_native_wrapper (D.27181, 1, 1);
              add_extra_method (acfg, D.27182);
              <D.27179>:
              <D.27095>:
              <D.24329>:
              m = mono_class_get_methods (volatile_klass, &iter);
              if (m != 0B) goto <D.24328>; else goto <D.24330>;
              <D.24330>:
              <D.27093>:
            }
          finally
            {
              ctx = {CLOBBER};
              args = {CLOBBER};
              iter = {CLOBBER};
            }
        }
      }
    finally
      {
        insts = {CLOBBER};
      }
  }
  <D.26950>:
}


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

  D.27186 = acfg->aot_opts.full_aot;
  if (D.27186 == 0) goto <D.27187>; else goto <D.27188>;
  <D.27187>:
  if (force == 0) goto <D.27189>; else goto <D.27190>;
  <D.27189>:
  return;
  <D.27190>:
  <D.27188>:
  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.27192;
  struct GHashTable * D.27195;
  struct MonoGenericClass * D.27196;
  struct MonoGenericInst * D.27199;
  unsigned int D.27200;
  unsigned int D.27201;
  int D.27204;
  unsigned char D.27209;
  unsigned char D.27212;
  struct GHashTable * D.27217;
  void * D.27218;
  struct MonoType * D.27221;
  int D.27222;
  int D.27225;
  char * D.27228;
  unsigned int D.27231;
  unsigned int D.27232;
  struct MonoImage * D.27235;
  struct MonoImage * D.27236;
  int D.27243;
  int D.24042;
  int iftmp.80;
  int D.24041;
  const char[13] * D.27249;
  unsigned char D.27250;
  int D.27251;
  unsigned char D.27252;
  int D.27253;
  const unsigned char * D.27258;
  unsigned char D.27259;
  int D.27260;
  const unsigned char * D.27261;
  unsigned char D.27262;
  int D.27263;
  const unsigned char * D.27268;
  unsigned char D.27269;
  int D.27270;
  const unsigned char * D.27271;
  unsigned char D.27272;
  int D.27273;
  const unsigned char * D.27278;
  unsigned char D.27279;
  int D.27280;
  const unsigned char * D.27281;
  unsigned char D.27282;
  int D.27283;
  const char * D.27285;
  int D.24051;
  int iftmp.81;
  int D.24050;
  const char[7] * D.27290;
  unsigned char D.27291;
  int D.27292;
  unsigned char D.27293;
  int D.27294;
  const unsigned char * D.27299;
  unsigned char D.27300;
  int D.27301;
  const unsigned char * D.27302;
  unsigned char D.27303;
  int D.27304;
  const unsigned char * D.27309;
  unsigned char D.27310;
  int D.27311;
  const unsigned char * D.27312;
  unsigned char D.27313;
  int D.27314;
  const unsigned char * D.27319;
  unsigned char D.27320;
  int D.27321;
  const unsigned char * D.27322;
  unsigned char D.27323;
  int D.27324;
  unsigned int D.27328;
  unsigned int D.27329;
  struct MonoGenericContext * D.27332;
  struct MonoGenericInst * D.27333;
  int D.27336;
  unsigned int D.27339;
  int D.27342;
  struct MonoType * D.27343;
  unsigned char D.27344;
  struct MonoClass * D.27347;
  unsigned int D.27348;
  unsigned int D.27349;
  char * D.27354;
  struct MonoClass * D.27355;
  int D.24066;
  int iftmp.82;
  int D.24065;
  const char[27] * D.27365;
  unsigned char D.27366;
  int D.27367;
  unsigned char D.27368;
  int D.27369;
  const unsigned char * D.27374;
  unsigned char D.27375;
  int D.27376;
  const unsigned char * D.27377;
  unsigned char D.27378;
  int D.27379;
  const unsigned char * D.27384;
  unsigned char D.27385;
  int D.27386;
  const unsigned char * D.27387;
  unsigned char D.27388;
  int D.27389;
  const unsigned char * D.27394;
  unsigned char D.27395;
  int D.27396;
  const unsigned char * D.27397;
  unsigned char D.27398;
  int D.27399;
  const char * D.27401;
  int D.24075;
  int iftmp.83;
  int D.24074;
  const char[14] * D.27407;
  unsigned char D.27408;
  int D.27409;
  unsigned char D.27410;
  int D.27411;
  const unsigned char * D.27416;
  unsigned char D.27417;
  int D.27418;
  const unsigned char * D.27419;
  unsigned char D.27420;
  int D.27421;
  const unsigned char * D.27426;
  unsigned char D.27427;
  int D.27428;
  const unsigned char * D.27429;
  unsigned char D.27430;
  int D.27431;
  const unsigned char * D.27436;
  unsigned char D.27437;
  int D.27438;
  const unsigned char * D.27439;
  unsigned char D.27440;
  int D.27441;
  int D.24084;
  int iftmp.84;
  int D.24083;
  const char[14] * D.27447;
  unsigned char D.27448;
  int D.27449;
  unsigned char D.27450;
  int D.27451;
  const unsigned char * D.27456;
  unsigned char D.27457;
  int D.27458;
  const unsigned char * D.27459;
  unsigned char D.27460;
  int D.27461;
  const unsigned char * D.27466;
  unsigned char D.27467;
  int D.27468;
  const unsigned char * D.27469;
  unsigned char D.27470;
  int D.27471;
  const unsigned char * D.27476;
  unsigned char D.27477;
  int D.27478;
  const unsigned char * D.27479;
  unsigned char D.27480;
  int D.27481;
  int D.24093;
  int iftmp.85;
  int D.24092;
  const char[8] * D.27487;
  unsigned char D.27488;
  int D.27489;
  unsigned char D.27490;
  int D.27491;
  const unsigned char * D.27496;
  unsigned char D.27497;
  int D.27498;
  const unsigned char * D.27499;
  unsigned char D.27500;
  int D.27501;
  const unsigned char * D.27506;
  unsigned char D.27507;
  int D.27508;
  const unsigned char * D.27509;
  unsigned char D.27510;
  int D.27511;
  const unsigned char * D.27516;
  unsigned char D.27517;
  int D.27518;
  const unsigned char * D.27519;
  unsigned char D.27520;
  int D.27521;
  int D.24102;
  int iftmp.86;
  int D.24101;
  const char[14] * D.27527;
  unsigned char D.27528;
  int D.27529;
  unsigned char D.27530;
  int D.27531;
  const unsigned char * D.27536;
  unsigned char D.27537;
  int D.27538;
  const unsigned char * D.27539;
  unsigned char D.27540;
  int D.27541;
  const unsigned char * D.27546;
  unsigned char D.27547;
  int D.27548;
  const unsigned char * D.27549;
  unsigned char D.27550;
  int D.27551;
  const unsigned char * D.27556;
  unsigned char D.27557;
  int D.27558;
  const unsigned char * D.27559;
  unsigned char D.27560;
  int D.27561;
  int D.24111;
  int iftmp.87;
  int D.24110;
  const char[16] * D.27567;
  unsigned char D.27568;
  int D.27569;
  unsigned char D.27570;
  int D.27571;
  const unsigned char * D.27576;
  unsigned char D.27577;
  int D.27578;
  const unsigned char * D.27579;
  unsigned char D.27580;
  int D.27581;
  const unsigned char * D.27586;
  unsigned char D.27587;
  int D.27588;
  const unsigned char * D.27589;
  unsigned char D.27590;
  int D.27591;
  const unsigned char * D.27596;
  unsigned char D.27597;
  int D.27598;
  const unsigned char * D.27599;
  unsigned char D.27600;
  int D.27601;
  struct MonoType * D.27603;
  int D.24124;
  int iftmp.88;
  int D.24123;
  unsigned char D.27607;
  int D.27608;
  const unsigned char * D.27613;
  unsigned char D.27614;
  int D.27615;
  const unsigned char * D.27620;
  unsigned char D.27621;
  int D.27622;
  const unsigned char * D.27627;
  unsigned char D.27628;
  int D.27629;
  int D.24133;
  int iftmp.89;
  int D.24132;
  unsigned char D.27639;
  int D.27640;
  const unsigned char * D.27645;
  unsigned char D.27646;
  int D.27647;
  const unsigned char * D.27652;
  unsigned char D.27653;
  int D.27654;
  const unsigned char * D.27659;
  unsigned char D.27660;
  int D.27661;
  int D.24142;
  int iftmp.90;
  int D.24141;
  unsigned char D.27667;
  int D.27668;
  const unsigned char * D.27673;
  unsigned char D.27674;
  int D.27675;
  const unsigned char * D.27680;
  unsigned char D.27681;
  int D.27682;
  const unsigned char * D.27687;
  unsigned char D.27688;
  int D.27689;
  int D.24152;
  int iftmp.91;
  int D.24151;
  const char[21] * D.27694;
  unsigned char D.27695;
  int D.27696;
  unsigned char D.27697;
  int D.27698;
  const unsigned char * D.27703;
  unsigned char D.27704;
  int D.27705;
  const unsigned char * D.27706;
  unsigned char D.27707;
  int D.27708;
  const unsigned char * D.27713;
  unsigned char D.27714;
  int D.27715;
  const unsigned char * D.27716;
  unsigned char D.27717;
  int D.27718;
  const unsigned char * D.27723;
  unsigned char D.27724;
  int D.27725;
  const unsigned char * D.27726;
  unsigned char D.27727;
  int D.27728;
  const char * D.27730;
  struct MonoClass * D.27732;
  _Bool D.27733;
  long int D.27734;
  long int D.27735;
  struct MonoGenericContext * D.27738;
  const char * D.27739;
  char * D.27740;
  int D.24168;
  int iftmp.92;
  int D.24167;
  unsigned char D.27748;
  int D.27749;
  const unsigned char * D.27754;
  unsigned char D.27755;
  int D.27756;
  const unsigned char * D.27761;
  unsigned char D.27762;
  int D.27763;
  const unsigned char * D.27768;
  unsigned char D.27769;
  int D.27770;
  int D.24177;
  int iftmp.93;
  int D.24176;
  const char[11] * D.27777;
  unsigned char D.27778;
  int D.27779;
  unsigned char D.27780;
  int D.27781;
  const unsigned char * D.27786;
  unsigned char D.27787;
  int D.27788;
  const unsigned char * D.27789;
  unsigned char D.27790;
  int D.27791;
  const unsigned char * D.27796;
  unsigned char D.27797;
  int D.27798;
  const unsigned char * D.27799;
  unsigned char D.27800;
  int D.27801;
  const unsigned char * D.27806;
  unsigned char D.27807;
  int D.27808;
  const unsigned char * D.27809;
  unsigned char D.27810;
  int D.27811;
  _Bool D.27815;
  long int D.27816;
  long int D.27817;
  struct MonoType * D.27820;
  struct MonoGenericInst * D.27821;
  struct MonoClass * D.27822;
  int D.27823;
  _Bool D.27826;
  long int D.27827;
  long int D.27828;
  struct MonoClass * D.27831;
  int D.24191;
  int iftmp.94;
  int D.24190;
  unsigned char D.27837;
  int D.27838;
  const unsigned char * D.27843;
  unsigned char D.27844;
  int D.27845;
  const unsigned char * D.27850;
  unsigned char D.27851;
  int D.27852;
  const unsigned char * D.27857;
  unsigned char D.27858;
  int D.27859;
  int D.24200;
  int iftmp.95;
  int D.24199;
  const char[19] * D.27866;
  unsigned char D.27867;
  int D.27868;
  unsigned char D.27869;
  int D.27870;
  const unsigned char * D.27875;
  unsigned char D.27876;
  int D.27877;
  const unsigned char * D.27878;
  unsigned char D.27879;
  int D.27880;
  const unsigned char * D.27885;
  unsigned char D.27886;
  int D.27887;
  const unsigned char * D.27888;
  unsigned char D.27889;
  int D.27890;
  const unsigned char * D.27895;
  unsigned char D.27896;
  int D.27897;
  const unsigned char * D.27898;
  unsigned char D.27899;
  int D.27900;
  _Bool D.27904;
  long int D.27905;
  long int D.27906;
  struct MonoType * D.27909;
  struct MonoGenericInst * D.27910;
  struct MonoClass * D.27911;
  int D.27912;
  _Bool D.27915;
  long int D.27916;
  long int D.27917;
  struct MonoClass * D.27920;
  struct MonoMethod * method;
  struct MonoClassField * field;
  void * iter;
  gboolean use_gsharedvt;

  try
    {
      use_gsharedvt = 0;
      D.27192 = acfg->ginst_hash;
      if (D.27192 == 0B) goto <D.27193>; else goto <D.27194>;
      <D.27193>:
      D.27195 = monoeg_g_hash_table_new (0B, 0B);
      acfg->ginst_hash = D.27195;
      <D.27194>:
      mono_class_init (klass);
      D.27196 = klass->generic_class;
      if (D.27196 != 0B) goto <D.27197>; else goto <D.27198>;
      <D.27197>:
      D.27196 = klass->generic_class;
      D.27199 = D.27196->context.class_inst;
      D.27200 = BIT_FIELD_REF <*D.27199, 32, 32>;
      D.27201 = D.27200 & 4194304;
      if (D.27201 != 0) goto <D.27202>; else goto <D.27203>;
      <D.27202>:
      return;
      <D.27203>:
      <D.27198>:
      D.27204 = has_type_vars (klass);
      if (D.27204 != 0) goto <D.27205>; else goto <D.27206>;
      <D.27205>:
      return;
      <D.27206>:
      D.27196 = klass->generic_class;
      if (D.27196 == 0B) goto <D.27207>; else goto <D.27208>;
      <D.27207>:
      D.27209 = klass->rank;
      if (D.27209 == 0) goto <D.27210>; else goto <D.27211>;
      <D.27210>:
      return;
      <D.27211>:
      <D.27208>:
      D.27212 = klass->exception_type;
      if (D.27212 != 0) goto <D.27213>; else goto <D.27214>;
      <D.27213>:
      return;
      <D.27214>:
      D.27192 = acfg->ginst_hash;
      if (D.27192 == 0B) goto <D.27215>; else goto <D.27216>;
      <D.27215>:
      D.27217 = monoeg_g_hash_table_new (0B, 0B);
      acfg->ginst_hash = D.27217;
      <D.27216>:
      D.27192 = acfg->ginst_hash;
      D.27218 = monoeg_g_hash_table_lookup (D.27192, klass);
      if (D.27218 != 0B) goto <D.27219>; else goto <D.27220>;
      <D.27219>:
      return;
      <D.27220>:
      D.27221 = &klass->byval_arg;
      D.27222 = check_type_depth (D.27221, 0);
      if (D.27222 != 0) goto <D.27223>; else goto <D.27224>;
      <D.27223>:
      return;
      <D.27224>:
      D.27225 = acfg->aot_opts.log_generics;
      if (D.27225 != 0) goto <D.27226>; else goto <D.27227>;
      <D.27226>:
      D.27221 = &klass->byval_arg;
      D.27228 = mono_type_full_name (D.27221);
      printf ("%*sAdding generic instance %s [%s].\n", depth, "", D.27228, ref);
      <D.27227>:
      D.27192 = acfg->ginst_hash;
      monoeg_g_hash_table_insert_replace (D.27192, klass, klass, 0);
      D.27231 = acfg->opts;
      D.27232 = D.27231 & 16777216;
      if (D.27232 != 0) goto <D.27233>; else goto <D.27234>;
      <D.27233>:
      D.27235 = klass->image;
      D.27236 = mono_defaults.corlib;
      if (D.27235 == D.27236) goto <D.27237>; else goto <D.27238>;
      <D.27237>:
      D.27196 = klass->generic_class;
      if (D.27196 != 0B) goto <D.27239>; else goto <D.27240>;
      <D.27239>:
      D.27196 = klass->generic_class;
      D.27199 = D.27196->context.class_inst;
      if (D.27199 != 0B) goto <D.27241>; else goto <D.27242>;
      <D.27241>:
      D.27196 = klass->generic_class;
      D.27199 = D.27196->context.class_inst;
      D.27243 = is_vt_inst (D.27199);
      if (D.27243 != 0) goto <D.27244>; else goto <D.27245>;
      <D.27244>:
      {
        size_t __s1_len;
        size_t __s2_len;

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

          __s2 = klass->name;
          D.27249 = "Dictionary`2";
          D.27250 = MEM[(const unsigned char *)D.27249];
          D.27251 = (int) D.27250;
          D.27252 = *__s2;
          D.27253 = (int) D.27252;
          __result = D.27251 - D.27253;
          {
            if (__s2_len != 0) goto <D.27254>; else goto <D.27255>;
            <D.27254>:
            if (__result == 0) goto <D.27256>; else goto <D.27257>;
            <D.27256>:
            D.27258 = &MEM[(void *)"Dictionary`2" + 1B];
            D.27259 = *D.27258;
            D.27260 = (int) D.27259;
            D.27261 = __s2 + 1;
            D.27262 = *D.27261;
            D.27263 = (int) D.27262;
            __result = D.27260 - D.27263;
            if (__s2_len > 1) goto <D.27264>; else goto <D.27265>;
            <D.27264>:
            if (__result == 0) goto <D.27266>; else goto <D.27267>;
            <D.27266>:
            D.27268 = &MEM[(void *)"Dictionary`2" + 2B];
            D.27269 = *D.27268;
            D.27270 = (int) D.27269;
            D.27271 = __s2 + 2;
            D.27272 = *D.27271;
            D.27273 = (int) D.27272;
            __result = D.27270 - D.27273;
            if (__s2_len > 2) goto <D.27274>; else goto <D.27275>;
            <D.27274>:
            if (__result == 0) goto <D.27276>; else goto <D.27277>;
            <D.27276>:
            D.27278 = &MEM[(void *)"Dictionary`2" + 3B];
            D.27279 = *D.27278;
            D.27280 = (int) D.27279;
            D.27281 = __s2 + 3;
            D.27282 = *D.27281;
            D.27283 = (int) D.27282;
            __result = D.27280 - D.27283;
            <D.27277>:
            <D.27275>:
            <D.27267>:
            <D.27265>:
            <D.27257>:
            <D.27255>:
          }
          D.24041 = __result;
        }
        iftmp.80 = -D.24041;
        goto <D.27284>;
        <D.27248>:
        D.27285 = klass->name;
        iftmp.80 = __builtin_strcmp (D.27285, "Dictionary`2");
        <D.27284>:
        D.24042 = iftmp.80;
      }
      if (D.24042 == 0) goto <D.27229>; else goto <D.27286>;
      <D.27286>:
      {
        size_t __s1_len;
        size_t __s2_len;

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

          __s2 = klass->name;
          D.27290 = "List`1";
          D.27291 = MEM[(const unsigned char *)D.27290];
          D.27292 = (int) D.27291;
          D.27293 = *__s2;
          D.27294 = (int) D.27293;
          __result = D.27292 - D.27294;
          {
            if (__s2_len != 0) goto <D.27295>; else goto <D.27296>;
            <D.27295>:
            if (__result == 0) goto <D.27297>; else goto <D.27298>;
            <D.27297>:
            D.27299 = &MEM[(void *)"List`1" + 1B];
            D.27300 = *D.27299;
            D.27301 = (int) D.27300;
            D.27302 = __s2 + 1;
            D.27303 = *D.27302;
            D.27304 = (int) D.27303;
            __result = D.27301 - D.27304;
            if (__s2_len > 1) goto <D.27305>; else goto <D.27306>;
            <D.27305>:
            if (__result == 0) goto <D.27307>; else goto <D.27308>;
            <D.27307>:
            D.27309 = &MEM[(void *)"List`1" + 2B];
            D.27310 = *D.27309;
            D.27311 = (int) D.27310;
            D.27312 = __s2 + 2;
            D.27313 = *D.27312;
            D.27314 = (int) D.27313;
            __result = D.27311 - D.27314;
            if (__s2_len > 2) goto <D.27315>; else goto <D.27316>;
            <D.27315>:
            if (__result == 0) goto <D.27317>; else goto <D.27318>;
            <D.27317>:
            D.27319 = &MEM[(void *)"List`1" + 3B];
            D.27320 = *D.27319;
            D.27321 = (int) D.27320;
            D.27322 = __s2 + 3;
            D.27323 = *D.27322;
            D.27324 = (int) D.27323;
            __result = D.27321 - D.27324;
            <D.27318>:
            <D.27316>:
            <D.27308>:
            <D.27306>:
            <D.27298>:
            <D.27296>:
          }
          D.24050 = __result;
        }
        iftmp.81 = -D.24050;
        goto <D.27325>;
        <D.27289>:
        D.27285 = klass->name;
        iftmp.81 = __builtin_strcmp (D.27285, "List`1");
        <D.27325>:
        D.24051 = iftmp.81;
      }
      if (D.24051 == 0) goto <D.27229>; else goto <D.27230>;
      <D.27229>:
      use_gsharedvt = 1;
      <D.27230>:
      <D.27245>:
      <D.27242>:
      <D.27240>:
      <D.27238>:
      <D.27234>:
      iter = 0B;
      goto <D.24052>;
      <D.24053>:
      D.27231 = acfg->opts;
      D.27232 = D.27231 & 16777216;
      if (D.27232 != 0) goto <D.27326>; else goto <D.27327>;
      <D.27326>:
      D.27328 = BIT_FIELD_REF <*method, 32, 160>;
      D.27329 = D.27328 & 4096;
      if (D.27329 != 0) goto <D.27330>; else goto <D.27331>;
      <D.27330>:
      D.27332 = mono_method_get_context (method);
      D.27333 = D.27332->method_inst;
      if (D.27333 != 0B) goto <D.27334>; else goto <D.27335>;
      <D.27334>:
      // predicted unlikely by continue predictor.
      goto <D.24052>;
      <D.27335>:
      <D.27331>:
      <D.27327>:
      D.27336 = mono_method_is_generic_sharable_full (method, 0, 0, use_gsharedvt);
      if (D.27336 != 0) goto <D.27337>; else goto <D.27338>;
      <D.27337>:
      add_types_from_method_header (acfg, method);
      // predicted unlikely by continue predictor.
      goto <D.24052>;
      <D.27338>:
      D.27328 = BIT_FIELD_REF <*method, 32, 160>;
      D.27339 = D.27328 & 2048;
      if (D.27339 != 0) goto <D.27340>; else goto <D.27341>;
      <D.27340>:
      // predicted unlikely by continue predictor.
      goto <D.24052>;
      <D.27341>:
      D.27342 = depth + 1;
      add_extra_method_with_depth (acfg, method, D.27342);
      <D.24052>:
      method = mono_class_get_methods (klass, &iter);
      if (method != 0B) goto <D.24053>; else goto <D.24054>;
      <D.24054>:
      iter = 0B;
      goto <D.24056>;
      <D.24055>:
      D.27343 = field->type;
      D.27344 = D.27343->type;
      if (D.27344 == 21) goto <D.27345>; else goto <D.27346>;
      <D.27345>:
      D.27343 = field->type;
      D.27347 = mono_class_from_mono_type (D.27343);
      D.27342 = depth + 1;
      add_generic_class_with_depth (acfg, D.27347, D.27342, "field");
      <D.27346>:
      <D.24056>:
      field = mono_class_get_fields (klass, &iter);
      if (field != 0B) goto <D.24055>; else goto <D.24057>;
      <D.24057>:
      D.27348 = BIT_FIELD_REF <*klass, 32, 160>;
      D.27349 = D.27348 & 16777216;
      if (D.27349 != 0) goto <D.27350>; else goto <D.27351>;
      <D.27350>:
      method = mono_get_delegate_invoke (klass);
      method = mono_marshal_get_delegate_invoke (method, 0B);
      D.27225 = acfg->aot_opts.log_generics;
      if (D.27225 != 0) goto <D.27352>; else goto <D.27353>;
      <D.27352>:
      D.27354 = mono_method_full_name (method, 1);
      printf ("%*sAdding method %s.\n", depth, "", D.27354);
      <D.27353>:
      add_method (acfg, method);
      <D.27351>:
      D.27355 = klass->parent;
      if (D.27355 != 0B) goto <D.27356>; else goto <D.27357>;
      <D.27356>:
      D.27355 = klass->parent;
      add_generic_class_with_depth (acfg, D.27355, depth, "parent");
      <D.27357>:
      D.27235 = klass->image;
      D.27236 = mono_defaults.corlib;
      if (D.27235 == D.27236) goto <D.27360>; else goto <D.27361>;
      <D.27360>:
      {
        size_t __s1_len;
        size_t __s2_len;

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

          __s2 = klass->name_space;
          D.27365 = "System.Collections.Generic";
          D.27366 = MEM[(const unsigned char *)D.27365];
          D.27367 = (int) D.27366;
          D.27368 = *__s2;
          D.27369 = (int) D.27368;
          __result = D.27367 - D.27369;
          {
            if (__s2_len != 0) goto <D.27370>; else goto <D.27371>;
            <D.27370>:
            if (__result == 0) goto <D.27372>; else goto <D.27373>;
            <D.27372>:
            D.27374 = &MEM[(void *)"System.Collections.Generic" + 1B];
            D.27375 = *D.27374;
            D.27376 = (int) D.27375;
            D.27377 = __s2 + 1;
            D.27378 = *D.27377;
            D.27379 = (int) D.27378;
            __result = D.27376 - D.27379;
            if (__s2_len > 1) goto <D.27380>; else goto <D.27381>;
            <D.27380>:
            if (__result == 0) goto <D.27382>; else goto <D.27383>;
            <D.27382>:
            D.27384 = &MEM[(void *)"System.Collections.Generic" + 2B];
            D.27385 = *D.27384;
            D.27386 = (int) D.27385;
            D.27387 = __s2 + 2;
            D.27388 = *D.27387;
            D.27389 = (int) D.27388;
            __result = D.27386 - D.27389;
            if (__s2_len > 2) goto <D.27390>; else goto <D.27391>;
            <D.27390>:
            if (__result == 0) goto <D.27392>; else goto <D.27393>;
            <D.27392>:
            D.27394 = &MEM[(void *)"System.Collections.Generic" + 3B];
            D.27395 = *D.27394;
            D.27396 = (int) D.27395;
            D.27397 = __s2 + 3;
            D.27398 = *D.27397;
            D.27399 = (int) D.27398;
            __result = D.27396 - D.27399;
            <D.27393>:
            <D.27391>:
            <D.27383>:
            <D.27381>:
            <D.27373>:
            <D.27371>:
          }
          D.24065 = __result;
        }
        iftmp.82 = -D.24065;
        goto <D.27400>;
        <D.27364>:
        D.27401 = klass->name_space;
        iftmp.82 = __builtin_strcmp (D.27401, "System.Collections.Generic");
        <D.27400>:
        D.24066 = iftmp.82;
      }
      if (D.24066 == 0) goto <D.27402>; else goto <D.27403>;
      <D.27402>:
      {
        size_t __s1_len;
        size_t __s2_len;

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

          __s2 = klass->name;
          D.27407 = "ICollection`1";
          D.27408 = MEM[(const unsigned char *)D.27407];
          D.27409 = (int) D.27408;
          D.27410 = *__s2;
          D.27411 = (int) D.27410;
          __result = D.27409 - D.27411;
          {
            if (__s2_len != 0) goto <D.27412>; else goto <D.27413>;
            <D.27412>:
            if (__result == 0) goto <D.27414>; else goto <D.27415>;
            <D.27414>:
            D.27416 = &MEM[(void *)"ICollection`1" + 1B];
            D.27417 = *D.27416;
            D.27418 = (int) D.27417;
            D.27419 = __s2 + 1;
            D.27420 = *D.27419;
            D.27421 = (int) D.27420;
            __result = D.27418 - D.27421;
            if (__s2_len > 1) goto <D.27422>; else goto <D.27423>;
            <D.27422>:
            if (__result == 0) goto <D.27424>; else goto <D.27425>;
            <D.27424>:
            D.27426 = &MEM[(void *)"ICollection`1" + 2B];
            D.27427 = *D.27426;
            D.27428 = (int) D.27427;
            D.27429 = __s2 + 2;
            D.27430 = *D.27429;
            D.27431 = (int) D.27430;
            __result = D.27428 - D.27431;
            if (__s2_len > 2) goto <D.27432>; else goto <D.27433>;
            <D.27432>:
            if (__result == 0) goto <D.27434>; else goto <D.27435>;
            <D.27434>:
            D.27436 = &MEM[(void *)"ICollection`1" + 3B];
            D.27437 = *D.27436;
            D.27438 = (int) D.27437;
            D.27439 = __s2 + 3;
            D.27440 = *D.27439;
            D.27441 = (int) D.27440;
            __result = D.27438 - D.27441;
            <D.27435>:
            <D.27433>:
            <D.27425>:
            <D.27423>:
            <D.27415>:
            <D.27413>:
          }
          D.24074 = __result;
        }
        iftmp.83 = -D.24074;
        goto <D.27442>;
        <D.27406>:
        D.27285 = klass->name;
        iftmp.83 = __builtin_strcmp (D.27285, "ICollection`1");
        <D.27442>:
        D.24075 = iftmp.83;
      }
      if (D.24075 == 0) goto <D.27358>; else goto <D.27443>;
      <D.27443>:
      {
        size_t __s1_len;
        size_t __s2_len;

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

          __s2 = klass->name;
          D.27447 = "IEnumerable`1";
          D.27448 = MEM[(const unsigned char *)D.27447];
          D.27449 = (int) D.27448;
          D.27450 = *__s2;
          D.27451 = (int) D.27450;
          __result = D.27449 - D.27451;
          {
            if (__s2_len != 0) goto <D.27452>; else goto <D.27453>;
            <D.27452>:
            if (__result == 0) goto <D.27454>; else goto <D.27455>;
            <D.27454>:
            D.27456 = &MEM[(void *)"IEnumerable`1" + 1B];
            D.27457 = *D.27456;
            D.27458 = (int) D.27457;
            D.27459 = __s2 + 1;
            D.27460 = *D.27459;
            D.27461 = (int) D.27460;
            __result = D.27458 - D.27461;
            if (__s2_len > 1) goto <D.27462>; else goto <D.27463>;
            <D.27462>:
            if (__result == 0) goto <D.27464>; else goto <D.27465>;
            <D.27464>:
            D.27466 = &MEM[(void *)"IEnumerable`1" + 2B];
            D.27467 = *D.27466;
            D.27468 = (int) D.27467;
            D.27469 = __s2 + 2;
            D.27470 = *D.27469;
            D.27471 = (int) D.27470;
            __result = D.27468 - D.27471;
            if (__s2_len > 2) goto <D.27472>; else goto <D.27473>;
            <D.27472>:
            if (__result == 0) goto <D.27474>; else goto <D.27475>;
            <D.27474>:
            D.27476 = &MEM[(void *)"IEnumerable`1" + 3B];
            D.27477 = *D.27476;
            D.27478 = (int) D.27477;
            D.27479 = __s2 + 3;
            D.27480 = *D.27479;
            D.27481 = (int) D.27480;
            __result = D.27478 - D.27481;
            <D.27475>:
            <D.27473>:
            <D.27465>:
            <D.27463>:
            <D.27455>:
            <D.27453>:
          }
          D.24083 = __result;
        }
        iftmp.84 = -D.24083;
        goto <D.27482>;
        <D.27446>:
        D.27285 = klass->name;
        iftmp.84 = __builtin_strcmp (D.27285, "IEnumerable`1");
        <D.27482>:
        D.24084 = iftmp.84;
      }
      if (D.24084 == 0) goto <D.27358>; else goto <D.27483>;
      <D.27483>:
      {
        size_t __s1_len;
        size_t __s2_len;

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

          __s2 = klass->name;
          D.27487 = "IList`1";
          D.27488 = MEM[(const unsigned char *)D.27487];
          D.27489 = (int) D.27488;
          D.27490 = *__s2;
          D.27491 = (int) D.27490;
          __result = D.27489 - D.27491;
          {
            if (__s2_len != 0) goto <D.27492>; else goto <D.27493>;
            <D.27492>:
            if (__result == 0) goto <D.27494>; else goto <D.27495>;
            <D.27494>:
            D.27496 = &MEM[(void *)"IList`1" + 1B];
            D.27497 = *D.27496;
            D.27498 = (int) D.27497;
            D.27499 = __s2 + 1;
            D.27500 = *D.27499;
            D.27501 = (int) D.27500;
            __result = D.27498 - D.27501;
            if (__s2_len > 1) goto <D.27502>; else goto <D.27503>;
            <D.27502>:
            if (__result == 0) goto <D.27504>; else goto <D.27505>;
            <D.27504>:
            D.27506 = &MEM[(void *)"IList`1" + 2B];
            D.27507 = *D.27506;
            D.27508 = (int) D.27507;
            D.27509 = __s2 + 2;
            D.27510 = *D.27509;
            D.27511 = (int) D.27510;
            __result = D.27508 - D.27511;
            if (__s2_len > 2) goto <D.27512>; else goto <D.27513>;
            <D.27512>:
            if (__result == 0) goto <D.27514>; else goto <D.27515>;
            <D.27514>:
            D.27516 = &MEM[(void *)"IList`1" + 3B];
            D.27517 = *D.27516;
            D.27518 = (int) D.27517;
            D.27519 = __s2 + 3;
            D.27520 = *D.27519;
            D.27521 = (int) D.27520;
            __result = D.27518 - D.27521;
            <D.27515>:
            <D.27513>:
            <D.27505>:
            <D.27503>:
            <D.27495>:
            <D.27493>:
          }
          D.24092 = __result;
        }
        iftmp.85 = -D.24092;
        goto <D.27522>;
        <D.27486>:
        D.27285 = klass->name;
        iftmp.85 = __builtin_strcmp (D.27285, "IList`1");
        <D.27522>:
        D.24093 = iftmp.85;
      }
      if (D.24093 == 0) goto <D.27358>; else goto <D.27523>;
      <D.27523>:
      {
        size_t __s1_len;
        size_t __s2_len;

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

          __s2 = klass->name;
          D.27527 = "IEnumerator`1";
          D.27528 = MEM[(const unsigned char *)D.27527];
          D.27529 = (int) D.27528;
          D.27530 = *__s2;
          D.27531 = (int) D.27530;
          __result = D.27529 - D.27531;
          {
            if (__s2_len != 0) goto <D.27532>; else goto <D.27533>;
            <D.27532>:
            if (__result == 0) goto <D.27534>; else goto <D.27535>;
            <D.27534>:
            D.27536 = &MEM[(void *)"IEnumerator`1" + 1B];
            D.27537 = *D.27536;
            D.27538 = (int) D.27537;
            D.27539 = __s2 + 1;
            D.27540 = *D.27539;
            D.27541 = (int) D.27540;
            __result = D.27538 - D.27541;
            if (__s2_len > 1) goto <D.27542>; else goto <D.27543>;
            <D.27542>:
            if (__result == 0) goto <D.27544>; else goto <D.27545>;
            <D.27544>:
            D.27546 = &MEM[(void *)"IEnumerator`1" + 2B];
            D.27547 = *D.27546;
            D.27548 = (int) D.27547;
            D.27549 = __s2 + 2;
            D.27550 = *D.27549;
            D.27551 = (int) D.27550;
            __result = D.27548 - D.27551;
            if (__s2_len > 2) goto <D.27552>; else goto <D.27553>;
            <D.27552>:
            if (__result == 0) goto <D.27554>; else goto <D.27555>;
            <D.27554>:
            D.27556 = &MEM[(void *)"IEnumerator`1" + 3B];
            D.27557 = *D.27556;
            D.27558 = (int) D.27557;
            D.27559 = __s2 + 3;
            D.27560 = *D.27559;
            D.27561 = (int) D.27560;
            __result = D.27558 - D.27561;
            <D.27555>:
            <D.27553>:
            <D.27545>:
            <D.27543>:
            <D.27535>:
            <D.27533>:
          }
          D.24101 = __result;
        }
        iftmp.86 = -D.24101;
        goto <D.27562>;
        <D.27526>:
        D.27285 = klass->name;
        iftmp.86 = __builtin_strcmp (D.27285, "IEnumerator`1");
        <D.27562>:
        D.24102 = iftmp.86;
      }
      if (D.24102 == 0) goto <D.27358>; else goto <D.27563>;
      <D.27563>:
      {
        size_t __s1_len;
        size_t __s2_len;

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

          __s2 = klass->name;
          D.27567 = "IReadOnlyList`1";
          D.27568 = MEM[(const unsigned char *)D.27567];
          D.27569 = (int) D.27568;
          D.27570 = *__s2;
          D.27571 = (int) D.27570;
          __result = D.27569 - D.27571;
          {
            if (__s2_len != 0) goto <D.27572>; else goto <D.27573>;
            <D.27572>:
            if (__result == 0) goto <D.27574>; else goto <D.27575>;
            <D.27574>:
            D.27576 = &MEM[(void *)"IReadOnlyList`1" + 1B];
            D.27577 = *D.27576;
            D.27578 = (int) D.27577;
            D.27579 = __s2 + 1;
            D.27580 = *D.27579;
            D.27581 = (int) D.27580;
            __result = D.27578 - D.27581;
            if (__s2_len > 1) goto <D.27582>; else goto <D.27583>;
            <D.27582>:
            if (__result == 0) goto <D.27584>; else goto <D.27585>;
            <D.27584>:
            D.27586 = &MEM[(void *)"IReadOnlyList`1" + 2B];
            D.27587 = *D.27586;
            D.27588 = (int) D.27587;
            D.27589 = __s2 + 2;
            D.27590 = *D.27589;
            D.27591 = (int) D.27590;
            __result = D.27588 - D.27591;
            if (__s2_len > 2) goto <D.27592>; else goto <D.27593>;
            <D.27592>:
            if (__result == 0) goto <D.27594>; else goto <D.27595>;
            <D.27594>:
            D.27596 = &MEM[(void *)"IReadOnlyList`1" + 3B];
            D.27597 = *D.27596;
            D.27598 = (int) D.27597;
            D.27599 = __s2 + 3;
            D.27600 = *D.27599;
            D.27601 = (int) D.27600;
            __result = D.27598 - D.27601;
            <D.27595>:
            <D.27593>:
            <D.27585>:
            <D.27583>:
            <D.27575>:
            <D.27573>:
          }
          D.24110 = __result;
        }
        iftmp.87 = -D.24110;
        goto <D.27602>;
        <D.27566>:
        D.27285 = klass->name;
        iftmp.87 = __builtin_strcmp (D.27285, "IReadOnlyList`1");
        <D.27602>:
        D.24111 = iftmp.87;
      }
      if (D.24111 == 0) goto <D.27358>; else goto <D.27359>;
      <D.27358>:
      {
        struct MonoClass * tclass;
        struct MonoClass * array_class;
        void * iter;
        char * name_prefix;

        try
          {
            D.27196 = klass->generic_class;
            D.27199 = D.27196->context.class_inst;
            D.27603 = D.27199->type_argv[0];
            tclass = mono_class_from_mono_type (D.27603);
            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.27605>; else goto <D.27606>;
              <D.27605>:
              {
                const unsigned char * __s2;
                int __result;

                __s2 = klass->name;
                D.27527 = "IEnumerator`1";
                D.27528 = MEM[(const unsigned char *)D.27527];
                D.27529 = (int) D.27528;
                D.27607 = *__s2;
                D.27608 = (int) D.27607;
                __result = D.27529 - D.27608;
                {
                  if (__s2_len != 0) goto <D.27609>; else goto <D.27610>;
                  <D.27609>:
                  if (__result == 0) goto <D.27611>; else goto <D.27612>;
                  <D.27611>:
                  D.27536 = &MEM[(void *)"IEnumerator`1" + 1B];
                  D.27537 = *D.27536;
                  D.27538 = (int) D.27537;
                  D.27613 = __s2 + 1;
                  D.27614 = *D.27613;
                  D.27615 = (int) D.27614;
                  __result = D.27538 - D.27615;
                  if (__s2_len > 1) goto <D.27616>; else goto <D.27617>;
                  <D.27616>:
                  if (__result == 0) goto <D.27618>; else goto <D.27619>;
                  <D.27618>:
                  D.27546 = &MEM[(void *)"IEnumerator`1" + 2B];
                  D.27547 = *D.27546;
                  D.27548 = (int) D.27547;
                  D.27620 = __s2 + 2;
                  D.27621 = *D.27620;
                  D.27622 = (int) D.27621;
                  __result = D.27548 - D.27622;
                  if (__s2_len > 2) goto <D.27623>; else goto <D.27624>;
                  <D.27623>:
                  if (__result == 0) goto <D.27625>; else goto <D.27626>;
                  <D.27625>:
                  D.27556 = &MEM[(void *)"IEnumerator`1" + 3B];
                  D.27557 = *D.27556;
                  D.27558 = (int) D.27557;
                  D.27627 = __s2 + 3;
                  D.27628 = *D.27627;
                  D.27629 = (int) D.27628;
                  __result = D.27558 - D.27629;
                  <D.27626>:
                  <D.27624>:
                  <D.27619>:
                  <D.27617>:
                  <D.27612>:
                  <D.27610>:
                }
                D.24123 = __result;
              }
              iftmp.88 = -D.24123;
              goto <D.27630>;
              <D.27606>:
              D.27285 = klass->name;
              iftmp.88 = __builtin_strcmp (D.27285, "IEnumerator`1");
              <D.27630>:
              D.24124 = iftmp.88;
            }
            if (D.24124 == 0) goto <D.27631>; else goto <D.27632>;
            <D.27631>:
            D.27401 = klass->name_space;
            name_prefix = monoeg_g_strdup_printf ("%s.%s", D.27401, "IEnumerable`1");
            goto <D.27633>;
            <D.27632>:
            D.27401 = klass->name_space;
            D.27285 = klass->name;
            name_prefix = monoeg_g_strdup_printf ("%s.%s", D.27401, D.27285);
            <D.27633>:
            {
              size_t __s1_len;
              size_t __s2_len;

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

                __s2 = klass->name;
                D.27447 = "IEnumerable`1";
                D.27448 = MEM[(const unsigned char *)D.27447];
                D.27449 = (int) D.27448;
                D.27639 = *__s2;
                D.27640 = (int) D.27639;
                __result = D.27449 - D.27640;
                {
                  if (__s2_len != 0) goto <D.27641>; else goto <D.27642>;
                  <D.27641>:
                  if (__result == 0) goto <D.27643>; else goto <D.27644>;
                  <D.27643>:
                  D.27456 = &MEM[(void *)"IEnumerable`1" + 1B];
                  D.27457 = *D.27456;
                  D.27458 = (int) D.27457;
                  D.27645 = __s2 + 1;
                  D.27646 = *D.27645;
                  D.27647 = (int) D.27646;
                  __result = D.27458 - D.27647;
                  if (__s2_len > 1) goto <D.27648>; else goto <D.27649>;
                  <D.27648>:
                  if (__result == 0) goto <D.27650>; else goto <D.27651>;
                  <D.27650>:
                  D.27466 = &MEM[(void *)"IEnumerable`1" + 2B];
                  D.27467 = *D.27466;
                  D.27468 = (int) D.27467;
                  D.27652 = __s2 + 2;
                  D.27653 = *D.27652;
                  D.27654 = (int) D.27653;
                  __result = D.27468 - D.27654;
                  if (__s2_len > 2) goto <D.27655>; else goto <D.27656>;
                  <D.27655>:
                  if (__result == 0) goto <D.27657>; else goto <D.27658>;
                  <D.27657>:
                  D.27476 = &MEM[(void *)"IEnumerable`1" + 3B];
                  D.27477 = *D.27476;
                  D.27478 = (int) D.27477;
                  D.27659 = __s2 + 3;
                  D.27660 = *D.27659;
                  D.27661 = (int) D.27660;
                  __result = D.27478 - D.27661;
                  <D.27658>:
                  <D.27656>:
                  <D.27651>:
                  <D.27649>:
                  <D.27644>:
                  <D.27642>:
                }
                D.24132 = __result;
              }
              iftmp.89 = -D.24132;
              goto <D.27662>;
              <D.27638>:
              D.27285 = klass->name;
              iftmp.89 = __builtin_strcmp (D.27285, "IEnumerable`1");
              <D.27662>:
              D.24133 = iftmp.89;
            }
            if (D.24133 == 0) goto <D.27634>; else goto <D.27663>;
            <D.27663>:
            {
              size_t __s1_len;
              size_t __s2_len;

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

                __s2 = klass->name;
                D.27527 = "IEnumerator`1";
                D.27528 = MEM[(const unsigned char *)D.27527];
                D.27529 = (int) D.27528;
                D.27667 = *__s2;
                D.27668 = (int) D.27667;
                __result = D.27529 - D.27668;
                {
                  if (__s2_len != 0) goto <D.27669>; else goto <D.27670>;
                  <D.27669>:
                  if (__result == 0) goto <D.27671>; else goto <D.27672>;
                  <D.27671>:
                  D.27536 = &MEM[(void *)"IEnumerator`1" + 1B];
                  D.27537 = *D.27536;
                  D.27538 = (int) D.27537;
                  D.27673 = __s2 + 1;
                  D.27674 = *D.27673;
                  D.27675 = (int) D.27674;
                  __result = D.27538 - D.27675;
                  if (__s2_len > 1) goto <D.27676>; else goto <D.27677>;
                  <D.27676>:
                  if (__result == 0) goto <D.27678>; else goto <D.27679>;
                  <D.27678>:
                  D.27546 = &MEM[(void *)"IEnumerator`1" + 2B];
                  D.27547 = *D.27546;
                  D.27548 = (int) D.27547;
                  D.27680 = __s2 + 2;
                  D.27681 = *D.27680;
                  D.27682 = (int) D.27681;
                  __result = D.27548 - D.27682;
                  if (__s2_len > 2) goto <D.27683>; else goto <D.27684>;
                  <D.27683>:
                  if (__result == 0) goto <D.27685>; else goto <D.27686>;
                  <D.27685>:
                  D.27556 = &MEM[(void *)"IEnumerator`1" + 3B];
                  D.27557 = *D.27556;
                  D.27558 = (int) D.27557;
                  D.27687 = __s2 + 3;
                  D.27688 = *D.27687;
                  D.27689 = (int) D.27688;
                  __result = D.27558 - D.27689;
                  <D.27686>:
                  <D.27684>:
                  <D.27679>:
                  <D.27677>:
                  <D.27672>:
                  <D.27670>:
                }
                D.24141 = __result;
              }
              iftmp.90 = -D.24141;
              goto <D.27690>;
              <D.27666>:
              D.27285 = klass->name;
              iftmp.90 = __builtin_strcmp (D.27285, "IEnumerator`1");
              <D.27690>:
              D.24142 = iftmp.90;
            }
            if (D.24142 == 0) goto <D.27634>; else goto <D.27635>;
            <D.27634>:
            {
              struct MonoClass * nclass;

              iter = 0B;
              goto <D.24155>;
              <D.24154>:
              {
                size_t __s1_len;
                size_t __s2_len;

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

                  __s2 = nclass->name;
                  D.27694 = "InternalEnumerator`1";
                  D.27695 = MEM[(const unsigned char *)D.27694];
                  D.27696 = (int) D.27695;
                  D.27697 = *__s2;
                  D.27698 = (int) D.27697;
                  __result = D.27696 - D.27698;
                  {
                    if (__s2_len != 0) goto <D.27699>; else goto <D.27700>;
                    <D.27699>:
                    if (__result == 0) goto <D.27701>; else goto <D.27702>;
                    <D.27701>:
                    D.27703 = &MEM[(void *)"InternalEnumerator`1" + 1B];
                    D.27704 = *D.27703;
                    D.27705 = (int) D.27704;
                    D.27706 = __s2 + 1;
                    D.27707 = *D.27706;
                    D.27708 = (int) D.27707;
                    __result = D.27705 - D.27708;
                    if (__s2_len > 1) goto <D.27709>; else goto <D.27710>;
                    <D.27709>:
                    if (__result == 0) goto <D.27711>; else goto <D.27712>;
                    <D.27711>:
                    D.27713 = &MEM[(void *)"InternalEnumerator`1" + 2B];
                    D.27714 = *D.27713;
                    D.27715 = (int) D.27714;
                    D.27716 = __s2 + 2;
                    D.27717 = *D.27716;
                    D.27718 = (int) D.27717;
                    __result = D.27715 - D.27718;
                    if (__s2_len > 2) goto <D.27719>; else goto <D.27720>;
                    <D.27719>:
                    if (__result == 0) goto <D.27721>; else goto <D.27722>;
                    <D.27721>:
                    D.27723 = &MEM[(void *)"InternalEnumerator`1" + 3B];
                    D.27724 = *D.27723;
                    D.27725 = (int) D.27724;
                    D.27726 = __s2 + 3;
                    D.27727 = *D.27726;
                    D.27728 = (int) D.27727;
                    __result = D.27725 - D.27728;
                    <D.27722>:
                    <D.27720>:
                    <D.27712>:
                    <D.27710>:
                    <D.27702>:
                    <D.27700>:
                  }
                  D.24151 = __result;
                }
                iftmp.91 = -D.24151;
                goto <D.27729>;
                <D.27693>:
                D.27730 = nclass->name;
                iftmp.91 = __builtin_strcmp (D.27730, "InternalEnumerator`1");
                <D.27729>:
                D.24152 = iftmp.91;
              }
              if (D.24152 == 0) goto <D.24153>; else goto <D.27731>;
              <D.27731>:
              <D.24155>:
              D.27732 = array_class->parent;
              nclass = mono_class_get_nested_types (D.27732, &iter);
              if (nclass != 0B) goto <D.24154>; else goto <D.24153>;
              <D.24153>:
              D.27733 = nclass == 0B;
              D.27734 = (long int) D.27733;
              D.27735 = __builtin_expect (D.27734, 0);
              if (D.27735 != 0) goto <D.27736>; else goto <D.27737>;
              <D.27736>:
              monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "aot-compiler.c", 3948, "nclass");
              <D.27737>:
              D.27196 = klass->generic_class;
              D.27738 = mono_generic_class_get_context (D.27196);
              nclass = mono_class_inflate_generic_class (nclass, D.27738);
              add_generic_class (acfg, nclass, 0, "ICollection<T>");
            }
            <D.27635>:
            iter = 0B;
            goto <D.24158>;
            <D.24157>:
            D.27739 = method->name;
            D.27740 = strstr (D.27739, name_prefix);
            if (D.27740 != 0B) goto <D.27741>; else goto <D.27742>;
            <D.27741>:
            {
              struct MonoMethod * m;

              m = mono_aot_get_array_helper_from_wrapper (method);
              add_extra_method_with_depth (acfg, m, depth);
            }
            <D.27742>:
            <D.24158>:
            method = mono_class_get_methods (array_class, &iter);
            if (method != 0B) goto <D.24157>; else goto <D.24159>;
            <D.24159>:
            monoeg_g_free (name_prefix);
          }
        finally
          {
            iter = {CLOBBER};
          }
      }
      <D.27359>:
      <D.27403>:
      <D.27361>:
      D.27235 = klass->image;
      D.27236 = mono_defaults.corlib;
      if (D.27235 == D.27236) goto <D.27743>; else goto <D.27744>;
      <D.27743>:
      {
        size_t __s1_len;
        size_t __s2_len;

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

          __s2 = klass->name_space;
          D.27365 = "System.Collections.Generic";
          D.27366 = MEM[(const unsigned char *)D.27365];
          D.27367 = (int) D.27366;
          D.27748 = *__s2;
          D.27749 = (int) D.27748;
          __result = D.27367 - D.27749;
          {
            if (__s2_len != 0) goto <D.27750>; else goto <D.27751>;
            <D.27750>:
            if (__result == 0) goto <D.27752>; else goto <D.27753>;
            <D.27752>:
            D.27374 = &MEM[(void *)"System.Collections.Generic" + 1B];
            D.27375 = *D.27374;
            D.27376 = (int) D.27375;
            D.27754 = __s2 + 1;
            D.27755 = *D.27754;
            D.27756 = (int) D.27755;
            __result = D.27376 - D.27756;
            if (__s2_len > 1) goto <D.27757>; else goto <D.27758>;
            <D.27757>:
            if (__result == 0) goto <D.27759>; else goto <D.27760>;
            <D.27759>:
            D.27384 = &MEM[(void *)"System.Collections.Generic" + 2B];
            D.27385 = *D.27384;
            D.27386 = (int) D.27385;
            D.27761 = __s2 + 2;
            D.27762 = *D.27761;
            D.27763 = (int) D.27762;
            __result = D.27386 - D.27763;
            if (__s2_len > 2) goto <D.27764>; else goto <D.27765>;
            <D.27764>:
            if (__result == 0) goto <D.27766>; else goto <D.27767>;
            <D.27766>:
            D.27394 = &MEM[(void *)"System.Collections.Generic" + 3B];
            D.27395 = *D.27394;
            D.27396 = (int) D.27395;
            D.27768 = __s2 + 3;
            D.27769 = *D.27768;
            D.27770 = (int) D.27769;
            __result = D.27396 - D.27770;
            <D.27767>:
            <D.27765>:
            <D.27760>:
            <D.27758>:
            <D.27753>:
            <D.27751>:
          }
          D.24167 = __result;
        }
        iftmp.92 = -D.24167;
        goto <D.27771>;
        <D.27747>:
        D.27401 = klass->name_space;
        iftmp.92 = __builtin_strcmp (D.27401, "System.Collections.Generic");
        <D.27771>:
        D.24168 = iftmp.92;
      }
      if (D.24168 == 0) goto <D.27772>; else goto <D.27773>;
      <D.27772>:
      {
        size_t __s1_len;
        size_t __s2_len;

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

          __s2 = klass->name;
          D.27777 = "Comparer`1";
          D.27778 = MEM[(const unsigned char *)D.27777];
          D.27779 = (int) D.27778;
          D.27780 = *__s2;
          D.27781 = (int) D.27780;
          __result = D.27779 - D.27781;
          {
            if (__s2_len != 0) goto <D.27782>; else goto <D.27783>;
            <D.27782>:
            if (__result == 0) goto <D.27784>; else goto <D.27785>;
            <D.27784>:
            D.27786 = &MEM[(void *)"Comparer`1" + 1B];
            D.27787 = *D.27786;
            D.27788 = (int) D.27787;
            D.27789 = __s2 + 1;
            D.27790 = *D.27789;
            D.27791 = (int) D.27790;
            __result = D.27788 - D.27791;
            if (__s2_len > 1) goto <D.27792>; else goto <D.27793>;
            <D.27792>:
            if (__result == 0) goto <D.27794>; else goto <D.27795>;
            <D.27794>:
            D.27796 = &MEM[(void *)"Comparer`1" + 2B];
            D.27797 = *D.27796;
            D.27798 = (int) D.27797;
            D.27799 = __s2 + 2;
            D.27800 = *D.27799;
            D.27801 = (int) D.27800;
            __result = D.27798 - D.27801;
            if (__s2_len > 2) goto <D.27802>; else goto <D.27803>;
            <D.27802>:
            if (__result == 0) goto <D.27804>; else goto <D.27805>;
            <D.27804>:
            D.27806 = &MEM[(void *)"Comparer`1" + 3B];
            D.27807 = *D.27806;
            D.27808 = (int) D.27807;
            D.27809 = __s2 + 3;
            D.27810 = *D.27809;
            D.27811 = (int) D.27810;
            __result = D.27808 - D.27811;
            <D.27805>:
            <D.27803>:
            <D.27795>:
            <D.27793>:
            <D.27785>:
            <D.27783>:
          }
          D.24176 = __result;
        }
        iftmp.93 = -D.24176;
        goto <D.27812>;
        <D.27776>:
        D.27285 = klass->name;
        iftmp.93 = __builtin_strcmp (D.27285, "Comparer`1");
        <D.27812>:
        D.24177 = iftmp.93;
      }
      if (D.24177 == 0) goto <D.27813>; else goto <D.27814>;
      <D.27813>:
      {
        struct MonoClass * tclass;
        struct MonoClass * icomparable;
        struct MonoClass * gcomparer;
        struct MonoGenericContext ctx;
        struct MonoType * args[16];

        try
          {
            D.27196 = klass->generic_class;
            D.27199 = D.27196->context.class_inst;
            D.27603 = D.27199->type_argv[0];
            tclass = mono_class_from_mono_type (D.27603);
            memset (&ctx, 0, 8);
            D.27236 = mono_defaults.corlib;
            icomparable = mono_class_from_name (D.27236, "System", "IComparable`1");
            D.27815 = icomparable == 0B;
            D.27816 = (long int) D.27815;
            D.27817 = __builtin_expect (D.27816, 0);
            if (D.27817 != 0) goto <D.27818>; else goto <D.27819>;
            <D.27818>:
            monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "aot-compiler.c", 3975, "icomparable");
            <D.27819>:
            D.27820 = &tclass->byval_arg;
            args[0] = D.27820;
            D.27821 = mono_metadata_get_generic_inst (1, &args);
            ctx.class_inst = D.27821;
            D.27822 = mono_class_inflate_generic_class (icomparable, &ctx);
            D.27823 = mono_class_is_assignable_from (D.27822, tclass);
            if (D.27823 != 0) goto <D.27824>; else goto <D.27825>;
            <D.27824>:
            D.27236 = mono_defaults.corlib;
            gcomparer = mono_class_from_name (D.27236, "System.Collections.Generic", "GenericComparer`1");
            D.27826 = gcomparer == 0B;
            D.27827 = (long int) D.27826;
            D.27828 = __builtin_expect (D.27827, 0);
            if (D.27828 != 0) goto <D.27829>; else goto <D.27830>;
            <D.27829>:
            monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "aot-compiler.c", 3981, "gcomparer");
            <D.27830>:
            D.27831 = mono_class_inflate_generic_class (gcomparer, &ctx);
            add_generic_class (acfg, D.27831, 0, "Comparer<T>");
            <D.27825>:
          }
        finally
          {
            ctx = {CLOBBER};
            args = {CLOBBER};
          }
      }
      <D.27814>:
      <D.27773>:
      <D.27744>:
      D.27235 = klass->image;
      D.27236 = mono_defaults.corlib;
      if (D.27235 == D.27236) goto <D.27832>; else goto <D.27833>;
      <D.27832>:
      {
        size_t __s1_len;
        size_t __s2_len;

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

          __s2 = klass->name_space;
          D.27365 = "System.Collections.Generic";
          D.27366 = MEM[(const unsigned char *)D.27365];
          D.27367 = (int) D.27366;
          D.27837 = *__s2;
          D.27838 = (int) D.27837;
          __result = D.27367 - D.27838;
          {
            if (__s2_len != 0) goto <D.27839>; else goto <D.27840>;
            <D.27839>:
            if (__result == 0) goto <D.27841>; else goto <D.27842>;
            <D.27841>:
            D.27374 = &MEM[(void *)"System.Collections.Generic" + 1B];
            D.27375 = *D.27374;
            D.27376 = (int) D.27375;
            D.27843 = __s2 + 1;
            D.27844 = *D.27843;
            D.27845 = (int) D.27844;
            __result = D.27376 - D.27845;
            if (__s2_len > 1) goto <D.27846>; else goto <D.27847>;
            <D.27846>:
            if (__result == 0) goto <D.27848>; else goto <D.27849>;
            <D.27848>:
            D.27384 = &MEM[(void *)"System.Collections.Generic" + 2B];
            D.27385 = *D.27384;
            D.27386 = (int) D.27385;
            D.27850 = __s2 + 2;
            D.27851 = *D.27850;
            D.27852 = (int) D.27851;
            __result = D.27386 - D.27852;
            if (__s2_len > 2) goto <D.27853>; else goto <D.27854>;
            <D.27853>:
            if (__result == 0) goto <D.27855>; else goto <D.27856>;
            <D.27855>:
            D.27394 = &MEM[(void *)"System.Collections.Generic" + 3B];
            D.27395 = *D.27394;
            D.27396 = (int) D.27395;
            D.27857 = __s2 + 3;
            D.27858 = *D.27857;
            D.27859 = (int) D.27858;
            __result = D.27396 - D.27859;
            <D.27856>:
            <D.27854>:
            <D.27849>:
            <D.27847>:
            <D.27842>:
            <D.27840>:
          }
          D.24190 = __result;
        }
        iftmp.94 = -D.24190;
        goto <D.27860>;
        <D.27836>:
        D.27401 = klass->name_space;
        iftmp.94 = __builtin_strcmp (D.27401, "System.Collections.Generic");
        <D.27860>:
        D.24191 = iftmp.94;
      }
      if (D.24191 == 0) goto <D.27861>; else goto <D.27862>;
      <D.27861>:
      {
        size_t __s1_len;
        size_t __s2_len;

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

          __s2 = klass->name;
          D.27866 = "EqualityComparer`1";
          D.27867 = MEM[(const unsigned char *)D.27866];
          D.27868 = (int) D.27867;
          D.27869 = *__s2;
          D.27870 = (int) D.27869;
          __result = D.27868 - D.27870;
          {
            if (__s2_len != 0) goto <D.27871>; else goto <D.27872>;
            <D.27871>:
            if (__result == 0) goto <D.27873>; else goto <D.27874>;
            <D.27873>:
            D.27875 = &MEM[(void *)"EqualityComparer`1" + 1B];
            D.27876 = *D.27875;
            D.27877 = (int) D.27876;
            D.27878 = __s2 + 1;
            D.27879 = *D.27878;
            D.27880 = (int) D.27879;
            __result = D.27877 - D.27880;
            if (__s2_len > 1) goto <D.27881>; else goto <D.27882>;
            <D.27881>:
            if (__result == 0) goto <D.27883>; else goto <D.27884>;
            <D.27883>:
            D.27885 = &MEM[(void *)"EqualityComparer`1" + 2B];
            D.27886 = *D.27885;
            D.27887 = (int) D.27886;
            D.27888 = __s2 + 2;
            D.27889 = *D.27888;
            D.27890 = (int) D.27889;
            __result = D.27887 - D.27890;
            if (__s2_len > 2) goto <D.27891>; else goto <D.27892>;
            <D.27891>:
            if (__result == 0) goto <D.27893>; else goto <D.27894>;
            <D.27893>:
            D.27895 = &MEM[(void *)"EqualityComparer`1" + 3B];
            D.27896 = *D.27895;
            D.27897 = (int) D.27896;
            D.27898 = __s2 + 3;
            D.27899 = *D.27898;
            D.27900 = (int) D.27899;
            __result = D.27897 - D.27900;
            <D.27894>:
            <D.27892>:
            <D.27884>:
            <D.27882>:
            <D.27874>:
            <D.27872>:
          }
          D.24199 = __result;
        }
        iftmp.95 = -D.24199;
        goto <D.27901>;
        <D.27865>:
        D.27285 = klass->name;
        iftmp.95 = __builtin_strcmp (D.27285, "EqualityComparer`1");
        <D.27901>:
        D.24200 = iftmp.95;
      }
      if (D.24200 == 0) goto <D.27902>; else goto <D.27903>;
      <D.27902>:
      {
        struct MonoClass * tclass;
        struct MonoClass * iface;
        struct MonoClass * gcomparer;
        struct MonoGenericContext ctx;
        struct MonoType * args[16];

        try
          {
            D.27196 = klass->generic_class;
            D.27199 = D.27196->context.class_inst;
            D.27603 = D.27199->type_argv[0];
            tclass = mono_class_from_mono_type (D.27603);
            memset (&ctx, 0, 8);
            D.27236 = mono_defaults.corlib;
            iface = mono_class_from_name (D.27236, "System", "IEquatable`1");
            D.27904 = iface == 0B;
            D.27905 = (long int) D.27904;
            D.27906 = __builtin_expect (D.27905, 0);
            if (D.27906 != 0) goto <D.27907>; else goto <D.27908>;
            <D.27907>:
            monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "aot-compiler.c", 3996, "iface");
            <D.27908>:
            D.27909 = &tclass->byval_arg;
            args[0] = D.27909;
            D.27910 = mono_metadata_get_generic_inst (1, &args);
            ctx.class_inst = D.27910;
            D.27911 = mono_class_inflate_generic_class (iface, &ctx);
            D.27912 = mono_class_is_assignable_from (D.27911, tclass);
            if (D.27912 != 0) goto <D.27913>; else goto <D.27914>;
            <D.27913>:
            D.27236 = mono_defaults.corlib;
            gcomparer = mono_class_from_name (D.27236, "System.Collections.Generic", "GenericEqualityComparer`1");
            D.27915 = gcomparer == 0B;
            D.27916 = (long int) D.27915;
            D.27917 = __builtin_expect (D.27916, 0);
            if (D.27917 != 0) goto <D.27918>; else goto <D.27919>;
            <D.27918>:
            monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "aot-compiler.c", 4002, "gcomparer");
            <D.27919>:
            D.27920 = mono_class_inflate_generic_class (gcomparer, &ctx);
            add_generic_class (acfg, D.27920, 0, "EqualityComparer<T>");
            <D.27914>:
          }
        finally
          {
            ctx = {CLOBBER};
            args = {CLOBBER};
          }
      }
      <D.27903>:
      <D.27862>:
      <D.27833>:
    }
  finally
    {
      iter = {CLOBBER};
    }
}


has_type_vars (struct MonoClass * klass)
{
  unsigned char D.27926;
  gboolean D.27928;
  unsigned char D.27929;
  struct MonoClass * D.27932;
  struct MonoGenericClass * D.27933;
  struct MonoGenericInst * D.27936;
  struct MonoType * D.27939;
  struct MonoClass * D.27940;
  int D.27941;
  <unnamed-unsigned:22> D.27944;
  int D.27945;
  struct MonoGenericContainer * D.27946;

  D.27926 = klass->byval_arg.type;
  if (D.27926 == 19) goto <D.27924>; else goto <D.27927>;
  <D.27927>:
  D.27926 = klass->byval_arg.type;
  if (D.27926 == 30) goto <D.27924>; else goto <D.27925>;
  <D.27924>:
  D.27928 = 1;
  return D.27928;
  <D.27925>:
  D.27929 = klass->rank;
  if (D.27929 != 0) goto <D.27930>; else goto <D.27931>;
  <D.27930>:
  D.27932 = klass->element_class;
  D.27928 = has_type_vars (D.27932);
  return D.27928;
  <D.27931>:
  D.27933 = klass->generic_class;
  if (D.27933 != 0B) goto <D.27934>; else goto <D.27935>;
  <D.27934>:
  {
    struct MonoGenericContext * context;

    D.27933 = klass->generic_class;
    context = &D.27933->context;
    D.27936 = context->class_inst;
    if (D.27936 != 0B) goto <D.27937>; else goto <D.27938>;
    <D.27937>:
    {
      int i;

      i = 0;
      goto <D.23979>;
      <D.23978>:
      D.27936 = context->class_inst;
      D.27939 = D.27936->type_argv[i];
      D.27940 = mono_class_from_mono_type (D.27939);
      D.27941 = has_type_vars (D.27940);
      if (D.27941 != 0) goto <D.27942>; else goto <D.27943>;
      <D.27942>:
      D.27928 = 1;
      return D.27928;
      <D.27943>:
      i = i + 1;
      <D.23979>:
      D.27936 = context->class_inst;
      D.27944 = D.27936->type_argc;
      D.27945 = (int) D.27944;
      if (D.27945 > i) goto <D.23978>; else goto <D.23980>;
      <D.23980>:
    }
    <D.27938>:
  }
  <D.27935>:
  D.27946 = klass->generic_container;
  if (D.27946 != 0B) goto <D.27947>; else goto <D.27948>;
  <D.27947>:
  D.27928 = 1;
  return D.27928;
  <D.27948>:
  D.27928 = 0;
  return D.27928;
}


check_type_depth (struct MonoType * t, int depth)
{
  gboolean D.27952;
  unsigned char D.27953;
  int D.27954;
  struct MonoType * D.27957;
  int D.27958;
  int D.27959;
  <unnamed-unsigned:22> D.27962;
  int D.27963;
  int i;

  if (depth > 8) goto <D.27950>; else goto <D.27951>;
  <D.27950>:
  D.27952 = 1;
  return D.27952;
  <D.27951>:
  D.27953 = t->type;
  D.27954 = (int) D.27953;
  switch (D.27954) <default: <D.24020>, case 21: <D.24013>>
  <D.24013>:
  {
    struct MonoGenericClass * gklass;
    struct MonoGenericInst * ginst;

    gklass = t->data.generic_class;
    ginst = gklass->context.class_inst;
    if (ginst != 0B) goto <D.27955>; else goto <D.27956>;
    <D.27955>:
    i = 0;
    goto <D.24017>;
    <D.24016>:
    D.27957 = ginst->type_argv[i];
    D.27958 = depth + 1;
    D.27959 = check_type_depth (D.27957, D.27958);
    if (D.27959 != 0) goto <D.27960>; else goto <D.27961>;
    <D.27960>:
    D.27952 = 1;
    return D.27952;
    <D.27961>:
    i = i + 1;
    <D.24017>:
    D.27962 = ginst->type_argc;
    D.27963 = (int) D.27962;
    if (D.27963 > i) goto <D.24016>; else goto <D.24018>;
    <D.24018>:
    <D.27956>:
    goto <D.24019>;
  }
  <D.24020>:
  goto <D.24019>;
  <D.24019>:
  D.27952 = 0;
  return D.27952;
}


is_vt_inst (struct MonoGenericInst * inst)
{
  unsigned char D.27966;
  gboolean D.27969;
  <unnamed-unsigned:22> D.27970;
  int D.27971;
  int i;

  i = 0;
  goto <D.23987>;
  <D.23986>:
  {
    struct MonoType * t;

    t = inst->type_argv[i];
    D.27966 = t->type;
    if (D.27966 == 17) goto <D.27967>; else goto <D.27968>;
    <D.27967>:
    D.27969 = 1;
    return D.27969;
    <D.27968>:
  }
  i = i + 1;
  <D.23987>:
  D.27970 = inst->type_argc;
  D.27971 = (int) D.27970;
  if (D.27971 > i) goto <D.23986>; else goto <D.23988>;
  <D.23988>:
  D.27969 = 0;
  return D.27969;
}


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

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


add_types_from_method_header (struct MonoAotCompile * acfg, struct MonoMethod * method)
{
  struct GHashTable * D.27975;
  void * D.27976;
  struct MonoType * D.27979;
  unsigned char D.27980;
  struct MonoClass * D.27983;
  int D.27984;
  short unsigned int D.27985;
  int D.27986;
  struct MonoType * D.27989;
  unsigned char D.27990;
  struct MonoClass * D.27993;
  short unsigned int D.27994;
  int D.27995;
  struct MonoMethodHeader * header;
  struct MonoMethodSignature * sig;
  int j;
  int depth;

  D.27975 = acfg->method_depth;
  D.27976 = monoeg_g_hash_table_lookup (D.27975, method);
  depth = (int) D.27976;
  sig = mono_method_signature (method);
  if (sig != 0B) goto <D.27977>; else goto <D.27978>;
  <D.27977>:
  j = 0;
  goto <D.24228>;
  <D.24227>:
  D.27979 = sig->params[j];
  D.27980 = D.27979->type;
  if (D.27980 == 21) goto <D.27981>; else goto <D.27982>;
  <D.27981>:
  D.27979 = sig->params[j];
  D.27983 = mono_class_from_mono_type (D.27979);
  D.27984 = depth + 1;
  add_generic_class_with_depth (acfg, D.27983, D.27984, "arg");
  <D.27982>:
  j = j + 1;
  <D.24228>:
  D.27985 = sig->param_count;
  D.27986 = (int) D.27985;
  if (D.27986 > j) goto <D.24227>; else goto <D.24229>;
  <D.24229>:
  <D.27978>:
  header = mono_method_get_header (method);
  if (header != 0B) goto <D.27987>; else goto <D.27988>;
  <D.27987>:
  j = 0;
  goto <D.24231>;
  <D.24230>:
  D.27989 = header->locals[j];
  D.27990 = D.27989->type;
  if (D.27990 == 21) goto <D.27991>; else goto <D.27992>;
  <D.27991>:
  D.27989 = header->locals[j];
  D.27993 = mono_class_from_mono_type (D.27989);
  D.27984 = depth + 1;
  add_generic_class_with_depth (acfg, D.27993, D.27984, "local");
  <D.27992>:
  j = j + 1;
  <D.24231>:
  D.27994 = header->num_locals;
  D.27995 = (int) D.27994;
  if (D.27995 > j) goto <D.24230>; else goto <D.24232>;
  <D.24232>:
  goto <D.27996>;
  <D.27988>:
  mono_loader_clear_error ();
  <D.27996>:
}


add_instances_of (struct MonoAotCompile * acfg, struct MonoClass * klass, struct MonoType * * insts, int ninsts, gboolean force)
{
  int D.27997;
  unsigned int i.96;
  unsigned int D.28001;
  struct MonoType * * D.28002;
  struct MonoType * D.28003;
  struct MonoGenericInst * D.28004;
  struct MonoClass * D.28005;
  int i;
  struct MonoGenericContext ctx;
  struct MonoType * args[16];

  try
    {
      D.27997 = acfg->aot_opts.no_instances;
      if (D.27997 != 0) goto <D.27998>; else goto <D.27999>;
      <D.27998>:
      return;
      <D.27999>:
      memset (&ctx, 0, 8);
      i = 0;
      goto <D.24217>;
      <D.24216>:
      i.96 = (unsigned int) i;
      D.28001 = i.96 * 4;
      D.28002 = insts + D.28001;
      D.28003 = *D.28002;
      args[0] = D.28003;
      D.28004 = mono_metadata_get_generic_inst (1, &args);
      ctx.class_inst = D.28004;
      D.28005 = mono_class_inflate_generic_class (klass, &ctx);
      add_generic_class (acfg, D.28005, force, "");
      i = i + 1;
      <D.24217>:
      if (i < ninsts) goto <D.24216>; else goto <D.24218>;
      <D.24218>:
    }
  finally
    {
      ctx = {CLOBBER};
      args = {CLOBBER};
    }
}


add_wrappers (struct MonoAotCompile * acfg)
{
  int D.28009;
  int D.28010;
  struct MonoImage * D.28011;
  short unsigned int D.28014;
  int D.28015;
  int D.28016;
  short unsigned int D.28018;
  int D.28019;
  int D.28020;
  int D.28022;
  struct MonoType * D.28027;
  unsigned char D.28028;
  int D.28030;
  struct MonoType * D.28033;
  unsigned char D.28034;
  int D.28037;
  short unsigned int D.28040;
  int D.28041;
  struct MonoMethod * D.28044;
  <unnamed-unsigned:24> D.28045;
  int D.28046;
  int D.23853;
  int iftmp.97;
  int D.23852;
  struct MonoAssembly * D.28050;
  const char[9] * D.28051;
  unsigned char D.28052;
  int D.28053;
  unsigned char D.28054;
  int D.28055;
  const unsigned char * D.28060;
  unsigned char D.28061;
  int D.28062;
  const unsigned char * D.28063;
  unsigned char D.28064;
  int D.28065;
  const unsigned char * D.28070;
  unsigned char D.28071;
  int D.28072;
  const unsigned char * D.28073;
  unsigned char D.28074;
  int D.28075;
  const unsigned char * D.28080;
  unsigned char D.28081;
  int D.28082;
  const unsigned char * D.28083;
  unsigned char D.28084;
  int D.28085;
  const char * D.28087;
  struct MonoImage * D.28090;
  struct MonoClass * D.28091;
  struct MonoType * D.28092;
  struct MonoMethod * D.28093;
  struct MonoMethod * D.28094;
  struct MonoClass * D.28095;
  struct MonoType * D.28096;
  struct MonoMethod * D.28097;
  struct MonoMethod * D.28098;
  struct MonoMethod * D.28099;
  struct MonoClass * D.28100;
  struct MonoType * D.28101;
  struct MonoMethod * D.28102;
  struct MonoClass * D.28103;
  struct MonoType * D.28104;
  struct MonoClass * D.28105;
  struct MonoType * D.28106;
  struct MonoMethod * D.28107;
  struct MonoClass * D.28108;
  struct MonoMethod * D.28109;
  struct MonoMethod * D.28110;
  struct MonoMethod * D.28113;
  struct MonoMethod * D.28114;
  unsigned int D.28117;
  struct MonoClass * D.28120;
  _Bool D.28125;
  long int D.28126;
  long int D.28127;
  unsigned int i.98;
  unsigned int D.28133;
  struct MonoMethod * * D.28134;
  struct MonoMethod * D.28135;
  int nwrappers.99;
  struct MonoMethod * D.28137;
  struct MonoMethod * D.28138;
  struct GHashTable * D.28139;
  int D.28140;
  unsigned int D.28145;
  unsigned int D.28146;
  struct MonoClass * D.28148;
  struct MonoClass * D.28150;
  struct MonoGenericContainer * D.28151;
  struct MonoMethod * D.28156;
  struct MonoMethod * D.28159;
  struct MonoMethod * D.28162;
  int D.23877;
  int iftmp.100;
  int D.23876;
  struct MonoClass * D.28168;
  const char[35] * D.28169;
  unsigned char D.28170;
  int D.28171;
  unsigned char D.28172;
  int D.28173;
  const unsigned char * D.28178;
  unsigned char D.28179;
  int D.28180;
  const unsigned char * D.28181;
  unsigned char D.28182;
  int D.28183;
  const unsigned char * D.28188;
  unsigned char D.28189;
  int D.28190;
  const unsigned char * D.28191;
  unsigned char D.28192;
  int D.28193;
  const unsigned char * D.28198;
  unsigned char D.28199;
  int D.28200;
  const unsigned char * D.28201;
  unsigned char D.28202;
  int D.28203;
  const char * D.28205;
  int D.23886;
  int iftmp.101;
  int D.23885;
  const char[34] * D.28210;
  unsigned char D.28211;
  int D.28212;
  unsigned char D.28213;
  int D.28214;
  const unsigned char * D.28219;
  unsigned char D.28220;
  int D.28221;
  const unsigned char * D.28222;
  unsigned char D.28223;
  int D.28224;
  const unsigned char * D.28229;
  unsigned char D.28230;
  int D.28231;
  const unsigned char * D.28232;
  unsigned char D.28233;
  int D.28234;
  const unsigned char * D.28239;
  unsigned char D.28240;
  int D.28241;
  const unsigned char * D.28242;
  unsigned char D.28243;
  int D.28244;
  int D.28247;
  struct MonoMethod * D.28250;
  unsigned int D.28252;
  unsigned int D.28253;
  unsigned int D.28258;
  unsigned int D.28259;
  _Bool D.28260;
  long int D.28261;
  long int D.28262;
  <unnamed-unsigned:24> D.28269;
  int D.28270;
  int D.28271;
  unsigned char D.28276;
  struct MonoClass * D.28279;
  unsigned int D.28280;
  unsigned int D.28281;
  unsigned char D.28284;
  unsigned char D.28285;
  unsigned char D.28287;
  _Bool D.28288;
  long int D.28289;
  long int D.28290;
  struct MonoMethod * D.28293;
  struct MonoMethod * D.28296;
  <unnamed-unsigned:24> D.28297;
  int D.28298;
  short unsigned int D.28299;
  int D.28300;
  int D.28301;
  unsigned int D.28304;
  unsigned int D.28305;
  struct MonoClass * D.28309;
  struct MonoGenericContainer * D.28310;
  unsigned int D.28313;
  unsigned int D.28314;
  _Bool D.28315;
  long int D.28316;
  long int D.28317;
  struct MonoMethod * D.28321;
  short unsigned int D.28324;
  int D.28325;
  int D.28326;
  short unsigned int D.28328;
  int D.28329;
  int D.28330;
  struct MonoMethod * D.28331;
  struct MonoMethod * D.28334;
  int D.23927;
  int iftmp.102;
  int D.23926;
  struct MonoClass * D.28340;
  const char[29] * D.28341;
  unsigned char D.28342;
  int D.28343;
  unsigned char D.28344;
  int D.28345;
  const unsigned char * D.28350;
  unsigned char D.28351;
  int D.28352;
  const unsigned char * D.28353;
  unsigned char D.28354;
  int D.28355;
  const unsigned char * D.28360;
  unsigned char D.28361;
  int D.28362;
  const unsigned char * D.28363;
  unsigned char D.28364;
  int D.28365;
  const unsigned char * D.28370;
  unsigned char D.28371;
  int D.28372;
  const unsigned char * D.28373;
  unsigned char D.28374;
  int D.28375;
  const char * D.28377;
  int D.28379;
  struct MonoMethod * D.28382;
  const mono_byte * p.103;
  short unsigned int D.28384;
  int D.28385;
  int D.28386;
  char * D.28389;
  short unsigned int D.28390;
  _Bool D.28391;
  long int D.28392;
  long int D.28393;
  int iftmp.104;
  struct MonoType * D.28400;
  unsigned char D.28401;
  int D.23952;
  int iftmp.105;
  int D.23951;
  struct MonoClass * D.28406;
  const char[5] * D.28407;
  unsigned char D.28408;
  int D.28409;
  unsigned char D.28410;
  int D.28411;
  const unsigned char * D.28416;
  unsigned char D.28417;
  int D.28418;
  const unsigned char * D.28419;
  unsigned char D.28420;
  int D.28421;
  const unsigned char * D.28426;
  unsigned char D.28427;
  int D.28428;
  const unsigned char * D.28429;
  unsigned char D.28430;
  int D.28431;
  const unsigned char * D.28436;
  unsigned char D.28437;
  int D.28438;
  const unsigned char * D.28439;
  unsigned char D.28440;
  int D.28441;
  struct MonoClass * D.28443;
  const char * D.28444;
  _Bool D.28445;
  long int D.28446;
  long int D.28447;
  const char * p.106;
  const char * p.107;
  unsigned int D.28452;
  int D.28453;
  unsigned int D.28454;
  sizetype slen.108;
  char * D.28456;
  _Bool D.28457;
  long int D.28458;
  long int D.28459;
  struct MonoClass * D.28462;
  _Bool D.28463;
  long int D.28464;
  long int D.28465;
  const char * p.109;
  short unsigned int D.28469;
  _Bool D.28470;
  long int D.28471;
  long int D.28472;
  const char * named.110;
  char D.28478;
  const char * named.111;
  unsigned int D.28480;
  int D.28481;
  unsigned int D.28482;
  unsigned int name_len.112;
  sizetype name_len.113;
  char * D.28485;
  const char * named.114;
  _Bool D.28487;
  long int D.28488;
  long int D.28489;
  int D.23964;
  int iftmp.115;
  int D.23963;
  const char[13] * D.28495;
  unsigned char D.28496;
  int D.28497;
  unsigned char D.28498;
  int D.28499;
  const unsigned char * D.28504;
  unsigned char D.28505;
  int D.28506;
  const unsigned char * D.28507;
  unsigned char D.28508;
  int D.28509;
  const unsigned char * D.28514;
  unsigned char D.28515;
  int D.28516;
  const unsigned char * D.28517;
  unsigned char D.28518;
  int D.28519;
  const unsigned char * D.28524;
  unsigned char D.28525;
  int D.28526;
  const unsigned char * D.28527;
  unsigned char D.28528;
  int D.28529;
  _Bool D.28531;
  long int D.28532;
  long int D.28533;
  _Bool D.28536;
  long int D.28537;
  long int D.28538;
  unsigned int D.28541;
  unsigned int D.28542;
  unsigned int slen.116;
  char * D.28544;
  const char * named.117;
  struct GHashTable * D.28548;
  int D.28551;
  short unsigned int D.28553;
  int D.28554;
  int D.28555;
  struct MonoMethod * D.28556;
  unsigned int D.28561;
  unsigned int D.28562;
  struct MonoGenericContainer * D.28565;
  int D.28568;
  struct MonoClass * D.28571;
  const char * D.28573;
  char * D.28574;
  struct MonoMethod * D.28575;
  struct MonoMethod * D.28576;
  struct MonoMethod * method;
  struct MonoMethod * m;
  int i;
  int j;
  struct MonoMethodSignature * sig;
  struct MonoMethodSignature * csig;
  guint32 token;

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

    D.28009 = i + 1;
    D.28010 = D.28009 | 100663296;
    token = (guint32) D.28010;
    skip = 0;
    D.28011 = acfg->image;
    method = mono_get_method (D.28011, token, 0B);
    D.28014 = method->flags;
    D.28015 = (int) D.28014;
    D.28016 = D.28015 & 8192;
    if (D.28016 != 0) goto <D.28012>; else goto <D.28017>;
    <D.28017>:
    D.28018 = method->iflags;
    D.28019 = (int) D.28018;
    D.28020 = D.28019 & 3;
    if (D.28020 != 0) goto <D.28012>; else goto <D.28021>;
    <D.28021>:
    D.28014 = method->flags;
    D.28015 = (int) D.28014;
    D.28022 = D.28015 & 1024;
    if (D.28022 != 0) goto <D.28012>; else goto <D.28013>;
    <D.28012>:
    skip = 1;
    <D.28013>:
    sig = mono_method_signature (method);
    if (sig == 0B) goto <D.28023>; else goto <D.28024>;
    <D.28023>:
    // predicted unlikely by continue predictor.
    goto <D.23838>;
    <D.28024>:
    D.28027 = sig->ret;
    D.28028 = D.28027->type;
    if (D.28028 == 15) goto <D.28025>; else goto <D.28029>;
    <D.28029>:
    D.28027 = sig->ret;
    D.28028 = D.28027->type;
    if (D.28028 == 22) goto <D.28025>; else goto <D.28026>;
    <D.28025>:
    skip = 1;
    <D.28026>:
    D.28027 = sig->ret;
    D.28030 = mono_class_is_open_constructed_type (D.28027);
    if (D.28030 != 0) goto <D.28031>; else goto <D.28032>;
    <D.28031>:
    skip = 1;
    <D.28032>:
    j = 0;
    goto <D.23840>;
    <D.23839>:
    D.28033 = sig->params[j];
    D.28034 = D.28033->type;
    if (D.28034 == 22) goto <D.28035>; else goto <D.28036>;
    <D.28035>:
    skip = 1;
    <D.28036>:
    D.28033 = sig->params[j];
    D.28037 = mono_class_is_open_constructed_type (D.28033);
    if (D.28037 != 0) goto <D.28038>; else goto <D.28039>;
    <D.28038>:
    skip = 1;
    <D.28039>:
    j = j + 1;
    <D.23840>:
    D.28040 = sig->param_count;
    D.28041 = (int) D.28040;
    if (D.28041 > j) goto <D.23839>; else goto <D.23841>;
    <D.23841>:
    if (skip == 0) goto <D.28042>; else goto <D.28043>;
    <D.28042>:
    D.28044 = mono_marshal_get_runtime_invoke (method, 0);
    add_method (acfg, D.28044);
    <D.28043>:
  }
  <D.23838>:
  i = i + 1;
  <D.23843>:
  D.28011 = acfg->image;
  D.28045 = D.28011->tables[6].rows;
  D.28046 = (int) D.28045;
  if (D.28046 > i) goto <D.23842>; else goto <D.23844>;
  <D.23844>:
  {
    size_t __s1_len;
    size_t __s2_len;

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

      D.28011 = acfg->image;
      D.28050 = D.28011->assembly;
      __s2 = D.28050->aname.name;
      D.28051 = "mscorlib";
      D.28052 = MEM[(const unsigned char *)D.28051];
      D.28053 = (int) D.28052;
      D.28054 = *__s2;
      D.28055 = (int) D.28054;
      __result = D.28053 - D.28055;
      {
        if (__s2_len != 0) goto <D.28056>; else goto <D.28057>;
        <D.28056>:
        if (__result == 0) goto <D.28058>; else goto <D.28059>;
        <D.28058>:
        D.28060 = &MEM[(void *)"mscorlib" + 1B];
        D.28061 = *D.28060;
        D.28062 = (int) D.28061;
        D.28063 = __s2 + 1;
        D.28064 = *D.28063;
        D.28065 = (int) D.28064;
        __result = D.28062 - D.28065;
        if (__s2_len > 1) goto <D.28066>; else goto <D.28067>;
        <D.28066>:
        if (__result == 0) goto <D.28068>; else goto <D.28069>;
        <D.28068>:
        D.28070 = &MEM[(void *)"mscorlib" + 2B];
        D.28071 = *D.28070;
        D.28072 = (int) D.28071;
        D.28073 = __s2 + 2;
        D.28074 = *D.28073;
        D.28075 = (int) D.28074;
        __result = D.28072 - D.28075;
        if (__s2_len > 2) goto <D.28076>; else goto <D.28077>;
        <D.28076>:
        if (__result == 0) goto <D.28078>; else goto <D.28079>;
        <D.28078>:
        D.28080 = &MEM[(void *)"mscorlib" + 3B];
        D.28081 = *D.28080;
        D.28082 = (int) D.28081;
        D.28083 = __s2 + 3;
        D.28084 = *D.28083;
        D.28085 = (int) D.28084;
        __result = D.28082 - D.28085;
        <D.28079>:
        <D.28077>:
        <D.28069>:
        <D.28067>:
        <D.28059>:
        <D.28057>:
      }
      D.23852 = __result;
    }
    iftmp.97 = -D.23852;
    goto <D.28086>;
    <D.28049>:
    D.28011 = acfg->image;
    D.28050 = D.28011->assembly;
    D.28087 = D.28050->aname.name;
    iftmp.97 = __builtin_strcmp (D.28087, "mscorlib");
    <D.28086>:
    D.23853 = iftmp.97;
  }
  if (D.23853 == 0) goto <D.28088>; else goto <D.28089>;
  <D.28088>:
  {
    struct MonoMethodDesc * desc;
    struct MonoMethod * orig_method;
    int nallocators;

    D.28090 = mono_defaults.corlib;
    csig = mono_metadata_signature_alloc (D.28090, 0);
    D.28091 = mono_defaults.void_class;
    D.28092 = &D.28091->byval_arg;
    csig->ret = D.28092;
    D.28093 = get_runtime_invoke_sig (csig);
    add_method (acfg, D.28093);
    D.28090 = mono_defaults.corlib;
    csig = mono_metadata_signature_alloc (D.28090, 0);
    csig->hasthis = 1;
    D.28091 = mono_defaults.void_class;
    D.28092 = &D.28091->byval_arg;
    csig->ret = D.28092;
    D.28094 = get_runtime_invoke_sig (csig);
    add_method (acfg, D.28094);
    D.28090 = mono_defaults.corlib;
    csig = mono_metadata_signature_alloc (D.28090, 1);
    csig->hasthis = 1;
    D.28091 = mono_defaults.void_class;
    D.28092 = &D.28091->byval_arg;
    csig->ret = D.28092;
    D.28095 = mono_defaults.string_class;
    D.28096 = &D.28095->byval_arg;
    csig->params[0] = D.28096;
    D.28097 = get_runtime_invoke_sig (csig);
    add_method (acfg, D.28097);
    D.28090 = mono_defaults.corlib;
    csig = mono_metadata_signature_alloc (D.28090, 2);
    csig->hasthis = 1;
    D.28091 = mono_defaults.void_class;
    D.28092 = &D.28091->byval_arg;
    csig->ret = D.28092;
    D.28095 = mono_defaults.string_class;
    D.28096 = &D.28095->byval_arg;
    csig->params[0] = D.28096;
    D.28095 = mono_defaults.string_class;
    D.28096 = &D.28095->byval_arg;
    csig->params[1] = D.28096;
    D.28098 = get_runtime_invoke_sig (csig);
    add_method (acfg, D.28098);
    D.28090 = mono_defaults.corlib;
    csig = mono_metadata_signature_alloc (D.28090, 0);
    csig->hasthis = 1;
    D.28095 = mono_defaults.string_class;
    D.28096 = &D.28095->byval_arg;
    csig->ret = D.28096;
    D.28099 = get_runtime_invoke_sig (csig);
    add_method (acfg, D.28099);
    D.28090 = mono_defaults.corlib;
    csig = mono_metadata_signature_alloc (D.28090, 2);
    csig->hasthis = 1;
    D.28091 = mono_defaults.void_class;
    D.28092 = &D.28091->byval_arg;
    csig->ret = D.28092;
    D.28095 = mono_defaults.string_class;
    D.28096 = &D.28095->byval_arg;
    csig->params[0] = D.28096;
    D.28100 = mono_defaults.exception_class;
    D.28101 = &D.28100->byval_arg;
    csig->params[1] = D.28101;
    D.28102 = get_runtime_invoke_sig (csig);
    add_method (acfg, D.28102);
    D.28090 = mono_defaults.corlib;
    csig = mono_metadata_signature_alloc (D.28090, 2);
    csig->hasthis = 1;
    D.28090 = mono_defaults.corlib;
    D.28103 = mono_class_from_name (D.28090, "System.Reflection", "Assembly");
    D.28104 = &D.28103->byval_arg;
    csig->ret = D.28104;
    D.28095 = mono_defaults.string_class;
    D.28096 = &D.28095->byval_arg;
    csig->params[0] = D.28096;
    D.28105 = mono_defaults.boolean_class;
    D.28106 = &D.28105->byval_arg;
    csig->params[1] = D.28106;
    D.28107 = get_runtime_invoke_sig (csig);
    add_method (acfg, D.28107);
    D.28108 = mono_defaults.object_class;
    D.28109 = mono_class_get_method_from_name_flags (D.28108, "Finalize", 0, 0);
    D.28110 = mono_marshal_get_runtime_invoke (D.28109, 1);
    add_method (acfg, D.28110);
    method = mono_get_context_capture_method ();
    if (method != 0B) goto <D.28111>; else goto <D.28112>;
    <D.28111>:
    D.28113 = mono_marshal_get_runtime_invoke (method, 0);
    add_method (acfg, D.28113);
    <D.28112>:
    D.28114 = mono_marshal_get_stelemref ();
    add_method (acfg, D.28114);
    if (0 != 0) goto <D.28115>; else goto <D.28116>;
    <D.28115>:
    D.28117 = mono_gc_get_managed_allocator_types ();
    nallocators = (int) D.28117;
    i = 0;
    goto <D.23858>;
    <D.23857>:
    m = mono_gc_get_managed_allocator_by_type (i);
    if (m != 0B) goto <D.28118>; else goto <D.28119>;
    <D.28118>:
    add_method (acfg, m);
    <D.28119>:
    i = i + 1;
    <D.23858>:
    if (i < nallocators) goto <D.23857>; else goto <D.23859>;
    <D.23859>:
    desc = mono_method_desc_new ("Monitor:Enter(object,bool&)", 0);
    D.28120 = mono_defaults.monitor_class;
    orig_method = mono_method_desc_search_in_class (desc, D.28120);
    if (orig_method != 0B) goto <D.28121>; else goto <D.28122>;
    <D.28121>:
    method = mono_monitor_get_fast_path (orig_method);
    if (method != 0B) goto <D.28123>; else goto <D.28124>;
    <D.28123>:
    add_method (acfg, method);
    <D.28124>:
    <D.28122>:
    mono_method_desc_free (desc);
    desc = mono_method_desc_new ("Monitor:Exit(object)", 0);
    D.28120 = mono_defaults.monitor_class;
    orig_method = mono_method_desc_search_in_class (desc, D.28120);
    D.28125 = orig_method == 0B;
    D.28126 = (long int) D.28125;
    D.28127 = __builtin_expect (D.28126, 0);
    if (D.28127 != 0) goto <D.28128>; else goto <D.28129>;
    <D.28128>:
    monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "aot-compiler.c", 3370, "orig_method");
    <D.28129>:
    mono_method_desc_free (desc);
    method = mono_monitor_get_fast_path (orig_method);
    if (method != 0B) goto <D.28130>; else goto <D.28131>;
    <D.28130>:
    add_method (acfg, method);
    <D.28131>:
    <D.28116>:
    {
      struct MonoMethod * * wrappers;
      int nwrappers;

      try
        {
          wrappers = mono_marshal_get_virtual_stelemref_wrappers (&nwrappers);
          i = 0;
          goto <D.23863>;
          <D.23862>:
          i.98 = (unsigned int) i;
          D.28133 = i.98 * 4;
          D.28134 = wrappers + D.28133;
          D.28135 = *D.28134;
          add_method (acfg, D.28135);
          i = i + 1;
          <D.23863>:
          nwrappers.99 = nwrappers;
          if (i < nwrappers.99) goto <D.23862>; else goto <D.23864>;
          <D.23864>:
          monoeg_g_free (wrappers);
        }
      finally
        {
          nwrappers = {CLOBBER};
        }
    }
    D.28137 = mono_marshal_get_castclass_with_cache ();
    add_method (acfg, D.28137);
    D.28138 = mono_marshal_get_isinst_with_cache ();
    add_method (acfg, D.28138);
    D.28139 = mono_get_jit_icall_info ();
    monoeg_g_hash_table_foreach (D.28139, add_jit_icall_wrapper, acfg);
  }
  <D.28089>:
  i = 0;
  goto <D.23894>;
  <D.23893>:
  {
    struct MonoClass * klass;
    struct MonoCustomAttrInfo * cattr;

    D.28009 = i + 1;
    D.28140 = D.28009 | 33554432;
    token = (guint32) D.28140;
    D.28011 = acfg->image;
    klass = mono_class_get (D.28011, token);
    if (klass == 0B) goto <D.28141>; else goto <D.28142>;
    <D.28141>:
    mono_loader_clear_error ();
    // predicted unlikely by continue predictor.
    goto <D.23867>;
    <D.28142>:
    D.28145 = BIT_FIELD_REF <*klass, 32, 160>;
    D.28146 = D.28145 & 16777216;
    if (D.28146 == 0) goto <D.28143>; else goto <D.28147>;
    <D.28147>:
    D.28148 = mono_defaults.delegate_class;
    if (D.28148 == klass) goto <D.28143>; else goto <D.28149>;
    <D.28149>:
    D.28150 = mono_defaults.multicastdelegate_class;
    if (D.28150 == klass) goto <D.28143>; else goto <D.28144>;
    <D.28143>:
    // predicted unlikely by continue predictor.
    goto <D.23867>;
    <D.28144>:
    D.28151 = klass->generic_container;
    if (D.28151 == 0B) goto <D.28152>; else goto <D.28153>;
    <D.28152>:
    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.28154>; else goto <D.28155>;
    <D.28154>:
    D.28156 = mono_marshal_get_delegate_begin_invoke (method);
    add_method (acfg, D.28156);
    <D.28155>:
    method = mono_class_get_method_from_name_flags (klass, "EndInvoke", -1, 0);
    if (method != 0B) goto <D.28157>; else goto <D.28158>;
    <D.28157>:
    D.28159 = mono_marshal_get_delegate_end_invoke (method);
    add_method (acfg, D.28159);
    <D.28158>:
    cattr = mono_custom_attrs_from_class (klass);
    if (cattr != 0B) goto <D.28160>; else goto <D.28161>;
    <D.28160>:
    {
      int j;

      j = 0;
      goto <D.23889>;
      <D.23888>:
      D.28162 = cattr->attrs[j].ctor;
      if (D.28162 != 0B) goto <D.28163>; else goto <D.28164>;
      <D.28163>:
      {
        size_t __s1_len;
        size_t __s2_len;

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

          D.28162 = cattr->attrs[j].ctor;
          D.28168 = D.28162->klass;
          __s2 = D.28168->name;
          D.28169 = "MonoNativeFunctionWrapperAttribute";
          D.28170 = MEM[(const unsigned char *)D.28169];
          D.28171 = (int) D.28170;
          D.28172 = *__s2;
          D.28173 = (int) D.28172;
          __result = D.28171 - D.28173;
          {
            if (__s2_len != 0) goto <D.28174>; else goto <D.28175>;
            <D.28174>:
            if (__result == 0) goto <D.28176>; else goto <D.28177>;
            <D.28176>:
            D.28178 = &MEM[(void *)"MonoNativeFunctionWrapperAttribute" + 1B];
            D.28179 = *D.28178;
            D.28180 = (int) D.28179;
            D.28181 = __s2 + 1;
            D.28182 = *D.28181;
            D.28183 = (int) D.28182;
            __result = D.28180 - D.28183;
            if (__s2_len > 1) goto <D.28184>; else goto <D.28185>;
            <D.28184>:
            if (__result == 0) goto <D.28186>; else goto <D.28187>;
            <D.28186>:
            D.28188 = &MEM[(void *)"MonoNativeFunctionWrapperAttribute" + 2B];
            D.28189 = *D.28188;
            D.28190 = (int) D.28189;
            D.28191 = __s2 + 2;
            D.28192 = *D.28191;
            D.28193 = (int) D.28192;
            __result = D.28190 - D.28193;
            if (__s2_len > 2) goto <D.28194>; else goto <D.28195>;
            <D.28194>:
            if (__result == 0) goto <D.28196>; else goto <D.28197>;
            <D.28196>:
            D.28198 = &MEM[(void *)"MonoNativeFunctionWrapperAttribute" + 3B];
            D.28199 = *D.28198;
            D.28200 = (int) D.28199;
            D.28201 = __s2 + 3;
            D.28202 = *D.28201;
            D.28203 = (int) D.28202;
            __result = D.28200 - D.28203;
            <D.28197>:
            <D.28195>:
            <D.28187>:
            <D.28185>:
            <D.28177>:
            <D.28175>:
          }
          D.23876 = __result;
        }
        iftmp.100 = -D.23876;
        goto <D.28204>;
        <D.28167>:
        D.28162 = cattr->attrs[j].ctor;
        D.28168 = D.28162->klass;
        D.28205 = D.28168->name;
        iftmp.100 = __builtin_strcmp (D.28205, "MonoNativeFunctionWrapperAttribute");
        <D.28204>:
        D.23877 = iftmp.100;
      }
      if (D.23877 == 0) goto <D.23887>; else goto <D.28206>;
      <D.28206>:
      {
        size_t __s1_len;
        size_t __s2_len;

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

          D.28162 = cattr->attrs[j].ctor;
          D.28168 = D.28162->klass;
          __s2 = D.28168->name;
          D.28210 = "UnmanagedFunctionPointerAttribute";
          D.28211 = MEM[(const unsigned char *)D.28210];
          D.28212 = (int) D.28211;
          D.28213 = *__s2;
          D.28214 = (int) D.28213;
          __result = D.28212 - D.28214;
          {
            if (__s2_len != 0) goto <D.28215>; else goto <D.28216>;
            <D.28215>:
            if (__result == 0) goto <D.28217>; else goto <D.28218>;
            <D.28217>:
            D.28219 = &MEM[(void *)"UnmanagedFunctionPointerAttribute" + 1B];
            D.28220 = *D.28219;
            D.28221 = (int) D.28220;
            D.28222 = __s2 + 1;
            D.28223 = *D.28222;
            D.28224 = (int) D.28223;
            __result = D.28221 - D.28224;
            if (__s2_len > 1) goto <D.28225>; else goto <D.28226>;
            <D.28225>:
            if (__result == 0) goto <D.28227>; else goto <D.28228>;
            <D.28227>:
            D.28229 = &MEM[(void *)"UnmanagedFunctionPointerAttribute" + 2B];
            D.28230 = *D.28229;
            D.28231 = (int) D.28230;
            D.28232 = __s2 + 2;
            D.28233 = *D.28232;
            D.28234 = (int) D.28233;
            __result = D.28231 - D.28234;
            if (__s2_len > 2) goto <D.28235>; else goto <D.28236>;
            <D.28235>:
            if (__result == 0) goto <D.28237>; else goto <D.28238>;
            <D.28237>:
            D.28239 = &MEM[(void *)"UnmanagedFunctionPointerAttribute" + 3B];
            D.28240 = *D.28239;
            D.28241 = (int) D.28240;
            D.28242 = __s2 + 3;
            D.28243 = *D.28242;
            D.28244 = (int) D.28243;
            __result = D.28241 - D.28244;
            <D.28238>:
            <D.28236>:
            <D.28228>:
            <D.28226>:
            <D.28218>:
            <D.28216>:
          }
          D.23885 = __result;
        }
        iftmp.101 = -D.23885;
        goto <D.28245>;
        <D.28209>:
        D.28162 = cattr->attrs[j].ctor;
        D.28168 = D.28162->klass;
        D.28205 = D.28168->name;
        iftmp.101 = __builtin_strcmp (D.28205, "UnmanagedFunctionPointerAttribute");
        <D.28245>:
        D.23886 = iftmp.101;
      }
      if (D.23886 == 0) goto <D.23887>; else goto <D.28246>;
      <D.28246>:
      <D.28164>:
      j = j + 1;
      <D.23889>:
      D.28247 = cattr->num_attrs;
      if (D.28247 > j) goto <D.23888>; else goto <D.23887>;
      <D.23887>:
      D.28247 = cattr->num_attrs;
      if (D.28247 > j) goto <D.28248>; else goto <D.28249>;
      <D.28248>:
      D.28250 = mono_marshal_get_native_func_wrapper_aot (klass);
      add_method (acfg, D.28250);
      <D.28249>:
    }
    <D.28161>:
    goto <D.28251>;
    <D.28153>:
    D.28252 = acfg->opts;
    D.28253 = D.28252 & 16777216;
    if (D.28253 != 0) goto <D.28254>; else goto <D.28255>;
    <D.28254>:
    D.28151 = klass->generic_container;
    if (D.28151 != 0B) goto <D.28256>; else goto <D.28257>;
    <D.28256>:
    {
      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.28258 = BIT_FIELD_REF <*m, 32, 160>;
          D.28259 = D.28258 & 4096;
          D.28260 = D.28259 == 0;
          D.28261 = (long int) D.28260;
          D.28262 = __builtin_expect (D.28261, 0);
          if (D.28262 != 0) goto <D.28263>; else goto <D.28264>;
          <D.28263>:
          monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "aot-compiler.c", 3493, "m->is_inflated");
          <D.28264>:
          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.28258 = BIT_FIELD_REF <*m, 32, 160>;
          D.28259 = D.28258 & 4096;
          D.28260 = D.28259 == 0;
          D.28261 = (long int) D.28260;
          D.28262 = __builtin_expect (D.28261, 0);
          if (D.28262 != 0) goto <D.28265>; else goto <D.28266>;
          <D.28265>:
          monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "aot-compiler.c", 3505, "m->is_inflated");
          <D.28266>:
          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.28258 = BIT_FIELD_REF <*m, 32, 160>;
          D.28259 = D.28258 & 4096;
          D.28260 = D.28259 == 0;
          D.28261 = (long int) D.28260;
          D.28262 = __builtin_expect (D.28261, 0);
          if (D.28262 != 0) goto <D.28267>; else goto <D.28268>;
          <D.28267>:
          monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "aot-compiler.c", 3517, "m->is_inflated");
          <D.28268>:
          gshared = mini_get_shared_method_full (m, 0, 1);
          add_extra_method (acfg, gshared);
        }
      finally
        {
          ctx = {CLOBBER};
        }
    }
    <D.28257>:
    <D.28255>:
    <D.28251>:
  }
  <D.23867>:
  i = i + 1;
  <D.23894>:
  D.28011 = acfg->image;
  D.28269 = D.28011->tables[2].rows;
  D.28270 = (int) D.28269;
  if (D.28270 > i) goto <D.23893>; else goto <D.23895>;
  <D.23895>:
  i = 0;
  goto <D.23901>;
  <D.23900>:
  {
    struct MonoClass * klass;

    D.28009 = i + 1;
    D.28271 = D.28009 | 452984832;
    token = (guint32) D.28271;
    D.28011 = acfg->image;
    klass = mono_class_get (D.28011, token);
    if (klass == 0B) goto <D.28272>; else goto <D.28273>;
    <D.28272>:
    mono_loader_clear_error ();
    // predicted unlikely by continue predictor.
    goto <D.23897>;
    <D.28273>:
    D.28276 = klass->rank;
    if (D.28276 != 0) goto <D.28277>; else goto <D.28278>;
    <D.28277>:
    D.28279 = klass->element_class;
    D.28280 = BIT_FIELD_REF <*D.28279, 32, 1056>;
    D.28281 = D.28280 & 1073741824;
    if (D.28281 == 0) goto <D.28282>; else goto <D.28283>;
    <D.28282>:
    D.28279 = klass->element_class;
    D.28284 = D.28279->byval_arg.type;
    D.28285 = D.28284 + 254;
    if (D.28285 <= 11) goto <D.28274>; else goto <D.28286>;
    <D.28286>:
    D.28279 = klass->element_class;
    D.28284 = D.28279->byval_arg.type;
    D.28287 = D.28284 + 232;
    if (D.28287 <= 1) goto <D.28274>; else goto <D.28275>;
    <D.28274>:
    {
      struct MonoMethod * m;
      struct MonoMethod * wrapper;

      m = mono_class_get_method_from_name (klass, "Get", -1);
      D.28288 = m == 0B;
      D.28289 = (long int) D.28288;
      D.28290 = __builtin_expect (D.28289, 0);
      if (D.28290 != 0) goto <D.28291>; else goto <D.28292>;
      <D.28291>:
      monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "aot-compiler.c", 3543, "m");
      <D.28292>:
      wrapper = mono_marshal_get_array_accessor_wrapper (m);
      add_extra_method (acfg, wrapper);
      D.28293 = mono_marshal_get_runtime_invoke (wrapper, 0);
      add_extra_method (acfg, D.28293);
      m = mono_class_get_method_from_name (klass, "Set", -1);
      D.28288 = m == 0B;
      D.28289 = (long int) D.28288;
      D.28290 = __builtin_expect (D.28289, 0);
      if (D.28290 != 0) goto <D.28294>; else goto <D.28295>;
      <D.28294>:
      monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "aot-compiler.c", 3549, "m");
      <D.28295>:
      wrapper = mono_marshal_get_array_accessor_wrapper (m);
      add_extra_method (acfg, wrapper);
      D.28296 = mono_marshal_get_runtime_invoke (wrapper, 0);
      add_extra_method (acfg, D.28296);
    }
    <D.28275>:
    <D.28283>:
    <D.28278>:
  }
  <D.23897>:
  i = i + 1;
  <D.23901>:
  D.28011 = acfg->image;
  D.28297 = D.28011->tables[27].rows;
  D.28298 = (int) D.28297;
  if (D.28298 > i) goto <D.23900>; else goto <D.23902>;
  <D.23902>:
  i = 0;
  goto <D.23908>;
  <D.23907>:
  D.28009 = i + 1;
  D.28010 = D.28009 | 100663296;
  token = (guint32) D.28010;
  D.28011 = acfg->image;
  method = mono_get_method (D.28011, token, 0B);
  D.28299 = method->iflags;
  D.28300 = (int) D.28299;
  D.28301 = D.28300 & 32;
  if (D.28301 != 0) goto <D.28302>; else goto <D.28303>;
  <D.28302>:
  D.28304 = BIT_FIELD_REF <*method, 32, 160>;
  D.28305 = D.28304 & 2048;
  if (D.28305 != 0) goto <D.28306>; else goto <D.28307>;
  <D.28306>:
  goto <D.28308>;
  <D.28307>:
  D.28309 = method->klass;
  D.28310 = D.28309->generic_container;
  if (D.28310 != 0B) goto <D.28311>; else goto <D.28312>;
  <D.28311>:
  {
    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.28313 = BIT_FIELD_REF <*m, 32, 160>;
        D.28314 = D.28313 & 4096;
        D.28315 = D.28314 == 0;
        D.28316 = (long int) D.28315;
        D.28317 = __builtin_expect (D.28316, 0);
        if (D.28317 != 0) goto <D.28318>; else goto <D.28319>;
        <D.28318>:
        monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "aot-compiler.c", 3574, "m->is_inflated");
        <D.28319>:
        gshared = mini_get_shared_method_full (m, 0, 1);
        add_method (acfg, gshared);
      }
    finally
      {
        ctx = {CLOBBER};
      }
  }
  goto <D.28320>;
  <D.28312>:
  D.28321 = mono_marshal_get_synchronized_wrapper (method);
  add_method (acfg, D.28321);
  <D.28320>:
  <D.28308>:
  <D.28303>:
  i = i + 1;
  <D.23908>:
  D.28011 = acfg->image;
  D.28045 = D.28011->tables[6].rows;
  D.28046 = (int) D.28045;
  if (D.28046 > i) goto <D.23907>; else goto <D.23909>;
  <D.23909>:
  i = 0;
  goto <D.23913>;
  <D.23912>:
  {
    struct MonoMethod * method;
    guint32 token;

    D.28009 = i + 1;
    D.28010 = D.28009 | 100663296;
    token = (guint32) D.28010;
    D.28011 = acfg->image;
    method = mono_get_method (D.28011, token, 0B);
    D.28324 = method->flags;
    D.28325 = (int) D.28324;
    D.28326 = D.28325 & 8192;
    if (D.28326 != 0) goto <D.28322>; else goto <D.28327>;
    <D.28327>:
    D.28328 = method->iflags;
    D.28329 = (int) D.28328;
    D.28330 = D.28329 & 4096;
    if (D.28330 != 0) goto <D.28322>; else goto <D.28323>;
    <D.28322>:
    D.28331 = mono_marshal_get_native_wrapper (method, 1, 1);
    add_method (acfg, D.28331);
    <D.28323>:
  }
  i = i + 1;
  <D.23913>:
  D.28011 = acfg->image;
  D.28045 = D.28011->tables[6].rows;
  D.28046 = (int) D.28045;
  if (D.28046 > i) goto <D.23912>; else goto <D.23914>;
  <D.23914>:
  i = 0;
  goto <D.23966>;
  <D.23965>:
  {
    struct MonoMethod * method;
    guint32 token;
    struct MonoCustomAttrInfo * cattr;
    int j;

    D.28009 = i + 1;
    D.28010 = D.28009 | 100663296;
    token = (guint32) D.28010;
    D.28011 = acfg->image;
    method = mono_get_method (D.28011, token, 0B);
    cattr = mono_custom_attrs_from_method (method);
    if (cattr != 0B) goto <D.28332>; else goto <D.28333>;
    <D.28332>:
    j = 0;
    goto <D.23930>;
    <D.23929>:
    D.28334 = cattr->attrs[j].ctor;
    if (D.28334 != 0B) goto <D.28335>; else goto <D.28336>;
    <D.28335>:
    {
      size_t __s1_len;
      size_t __s2_len;

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

        D.28334 = cattr->attrs[j].ctor;
        D.28340 = D.28334->klass;
        __s2 = D.28340->name;
        D.28341 = "MonoPInvokeCallbackAttribute";
        D.28342 = MEM[(const unsigned char *)D.28341];
        D.28343 = (int) D.28342;
        D.28344 = *__s2;
        D.28345 = (int) D.28344;
        __result = D.28343 - D.28345;
        {
          if (__s2_len != 0) goto <D.28346>; else goto <D.28347>;
          <D.28346>:
          if (__result == 0) goto <D.28348>; else goto <D.28349>;
          <D.28348>:
          D.28350 = &MEM[(void *)"MonoPInvokeCallbackAttribute" + 1B];
          D.28351 = *D.28350;
          D.28352 = (int) D.28351;
          D.28353 = __s2 + 1;
          D.28354 = *D.28353;
          D.28355 = (int) D.28354;
          __result = D.28352 - D.28355;
          if (__s2_len > 1) goto <D.28356>; else goto <D.28357>;
          <D.28356>:
          if (__result == 0) goto <D.28358>; else goto <D.28359>;
          <D.28358>:
          D.28360 = &MEM[(void *)"MonoPInvokeCallbackAttribute" + 2B];
          D.28361 = *D.28360;
          D.28362 = (int) D.28361;
          D.28363 = __s2 + 2;
          D.28364 = *D.28363;
          D.28365 = (int) D.28364;
          __result = D.28362 - D.28365;
          if (__s2_len > 2) goto <D.28366>; else goto <D.28367>;
          <D.28366>:
          if (__result == 0) goto <D.28368>; else goto <D.28369>;
          <D.28368>:
          D.28370 = &MEM[(void *)"MonoPInvokeCallbackAttribute" + 3B];
          D.28371 = *D.28370;
          D.28372 = (int) D.28371;
          D.28373 = __s2 + 3;
          D.28374 = *D.28373;
          D.28375 = (int) D.28374;
          __result = D.28372 - D.28375;
          <D.28369>:
          <D.28367>:
          <D.28359>:
          <D.28357>:
          <D.28349>:
          <D.28347>:
        }
        D.23926 = __result;
      }
      iftmp.102 = -D.23926;
      goto <D.28376>;
      <D.28339>:
      D.28334 = cattr->attrs[j].ctor;
      D.28340 = D.28334->klass;
      D.28377 = D.28340->name;
      iftmp.102 = __builtin_strcmp (D.28377, "MonoPInvokeCallbackAttribute");
      <D.28376>:
      D.23927 = iftmp.102;
    }
    if (D.23927 == 0) goto <D.23928>; else goto <D.28378>;
    <D.28378>:
    <D.28336>:
    j = j + 1;
    <D.23930>:
    D.28379 = cattr->num_attrs;
    if (D.28379 > j) goto <D.23929>; else goto <D.23928>;
    <D.23928>:
    D.28379 = cattr->num_attrs;
    if (D.28379 > j) goto <D.28380>; else goto <D.28381>;
    <D.28380>:
    {
      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.28382 = e->ctor;
          sig = mono_method_signature (D.28382);
          p.103 = e->data;
          p = p.103;
          export_name = 0B;
          D.28384 = method->flags;
          D.28385 = (int) D.28384;
          D.28386 = D.28385 & 16;
          if (D.28386 == 0) goto <D.28387>; else goto <D.28388>;
          <D.28387>:
          D.28389 = 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.28389);
          exit (1);
          <D.28388>:
          D.28390 = sig->param_count;
          D.28391 = D.28390 != 1;
          D.28392 = (long int) D.28391;
          D.28393 = __builtin_expect (D.28392, 0);
          if (D.28393 != 0) goto <D.28394>; else goto <D.28395>;
          <D.28394>:
          monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "aot-compiler.c", 3635, "sig->param_count == 1");
          <D.28395>:
          D.28400 = sig->params[0];
          D.28401 = D.28400->type;
          if (D.28401 != 18) goto <D.28397>; else goto <D.28402>;
          <D.28402>:
          {
            size_t __s1_len;
            size_t __s2_len;

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

              D.28400 = sig->params[0];
              D.28406 = mono_class_from_mono_type (D.28400);
              __s2 = D.28406->name;
              D.28407 = "Type";
              D.28408 = MEM[(const unsigned char *)D.28407];
              D.28409 = (int) D.28408;
              D.28410 = *__s2;
              D.28411 = (int) D.28410;
              __result = D.28409 - D.28411;
              {
                if (__s2_len != 0) goto <D.28412>; else goto <D.28413>;
                <D.28412>:
                if (__result == 0) goto <D.28414>; else goto <D.28415>;
                <D.28414>:
                D.28416 = &MEM[(void *)"Type" + 1B];
                D.28417 = *D.28416;
                D.28418 = (int) D.28417;
                D.28419 = __s2 + 1;
                D.28420 = *D.28419;
                D.28421 = (int) D.28420;
                __result = D.28418 - D.28421;
                if (__s2_len > 1) goto <D.28422>; else goto <D.28423>;
                <D.28422>:
                if (__result == 0) goto <D.28424>; else goto <D.28425>;
                <D.28424>:
                D.28426 = &MEM[(void *)"Type" + 2B];
                D.28427 = *D.28426;
                D.28428 = (int) D.28427;
                D.28429 = __s2 + 2;
                D.28430 = *D.28429;
                D.28431 = (int) D.28430;
                __result = D.28428 - D.28431;
                if (__s2_len > 2) goto <D.28432>; else goto <D.28433>;
                <D.28432>:
                if (__result == 0) goto <D.28434>; else goto <D.28435>;
                <D.28434>:
                D.28436 = &MEM[(void *)"Type" + 3B];
                D.28437 = *D.28436;
                D.28438 = (int) D.28437;
                D.28439 = __s2 + 3;
                D.28440 = *D.28439;
                D.28441 = (int) D.28440;
                __result = D.28438 - D.28441;
                <D.28435>:
                <D.28433>:
                <D.28425>:
                <D.28423>:
                <D.28415>:
                <D.28413>:
              }
              D.23951 = __result;
            }
            iftmp.105 = -D.23951;
            goto <D.28442>;
            <D.28405>:
            D.28400 = sig->params[0];
            D.28443 = mono_class_from_mono_type (D.28400);
            D.28444 = D.28443->name;
            iftmp.105 = __builtin_strcmp (D.28444, "Type");
            <D.28442>:
            D.23952 = iftmp.105;
          }
          if (D.23952 != 0) goto <D.28397>; else goto <D.28398>;
          <D.28397>:
          iftmp.104 = 1;
          goto <D.28399>;
          <D.28398>:
          iftmp.104 = 0;
          <D.28399>:
          D.28445 = iftmp.104 != 0;
          D.28446 = (long int) D.28445;
          D.28447 = __builtin_expect (D.28446, 0);
          if (D.28447 != 0) goto <D.28448>; else goto <D.28449>;
          <D.28448>:
          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.28449>:
          p.106 = p;
          p.107 = p.106 + 2;
          p = p.107;
          p.106 = p;
          D.28452 = mono_metadata_decode_value (p.106, &p);
          slen = (int) D.28452;
          p.106 = p;
          D.28453 = slen + 1;
          D.28454 = (unsigned int) D.28453;
          n = monoeg_g_memdup (p.106, D.28454);
          slen.108 = (sizetype) slen;
          D.28456 = n + slen.108;
          *D.28456 = 0;
          D.28011 = acfg->image;
          t = mono_reflection_type_from_name (n, D.28011);
          D.28457 = t == 0B;
          D.28458 = (long int) D.28457;
          D.28459 = __builtin_expect (D.28458, 0);
          if (D.28459 != 0) goto <D.28460>; else goto <D.28461>;
          <D.28460>:
          monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "aot-compiler.c", 3651, "t");
          <D.28461>:
          monoeg_g_free (n);
          klass = mono_class_from_mono_type (t);
          D.28462 = klass->parent;
          D.28150 = mono_defaults.multicastdelegate_class;
          D.28463 = D.28462 != D.28150;
          D.28464 = (long int) D.28463;
          D.28465 = __builtin_expect (D.28464, 0);
          if (D.28465 != 0) goto <D.28466>; else goto <D.28467>;
          <D.28466>:
          monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "aot-compiler.c", 3655, "klass->parent == mono_defaults.multicastdelegate_class");
          <D.28467>:
          p.106 = p;
          slen.108 = (sizetype) slen;
          p.109 = p.106 + slen.108;
          p = p.109;
          p.106 = p;
          D.28469 = mono_read16 (p.106);
          num_named = (int) D.28469;
          p.106 = p;
          p.107 = p.106 + 2;
          p = p.107;
          D.28470 = num_named > 1;
          D.28471 = (long int) D.28470;
          D.28472 = __builtin_expect (D.28471, 0);
          if (D.28472 != 0) goto <D.28473>; else goto <D.28474>;
          <D.28473>:
          monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "aot-compiler.c", 3662, "num_named < 2");
          <D.28474>:
          if (num_named == 1) goto <D.28475>; else goto <D.28476>;
          <D.28475>:
          {
            int name_len;
            char * name;
            struct MonoType * prop_type;

            p.106 = p;
            named = p.106;
            named.110 = named;
            D.28478 = *named.110;
            named_type = (int) D.28478;
            named.110 = named;
            named.111 = named.110 + 1;
            named = named.111;
            named.110 = named;
            D.28478 = *named.110;
            data_type = (int) D.28478;
            named.110 = named;
            named.111 = named.110 + 1;
            named = named.111;
            named.110 = named;
            D.28480 = mono_metadata_decode_blob_size (named.110, &named);
            name_len = (int) D.28480;
            D.28481 = name_len + 1;
            D.28482 = (unsigned int) D.28481;
            name = monoeg_malloc (D.28482);
            named.110 = named;
            name_len.112 = (unsigned int) name_len;
            memcpy (name, named.110, name_len.112);
            name_len.113 = (sizetype) name_len;
            D.28485 = name + name_len.113;
            *D.28485 = 0;
            named.110 = named;
            name_len.113 = (sizetype) name_len;
            named.114 = named.110 + name_len.113;
            named = named.114;
            D.28487 = named_type != 84;
            D.28488 = (long int) D.28487;
            D.28489 = __builtin_expect (D.28488, 0);
            if (D.28489 != 0) goto <D.28490>; else goto <D.28491>;
            <D.28490>:
            monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "aot-compiler.c", 3681, "named_type == 0x54");
            <D.28491>:
            {
              size_t __s1_len;
              size_t __s2_len;

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

                __s2 = name;
                D.28495 = "ExportSymbol";
                D.28496 = MEM[(const unsigned char *)D.28495];
                D.28497 = (int) D.28496;
                D.28498 = *__s2;
                D.28499 = (int) D.28498;
                __result = D.28497 - D.28499;
                {
                  if (__s2_len != 0) goto <D.28500>; else goto <D.28501>;
                  <D.28500>:
                  if (__result == 0) goto <D.28502>; else goto <D.28503>;
                  <D.28502>:
                  D.28504 = &MEM[(void *)"ExportSymbol" + 1B];
                  D.28505 = *D.28504;
                  D.28506 = (int) D.28505;
                  D.28507 = __s2 + 1;
                  D.28508 = *D.28507;
                  D.28509 = (int) D.28508;
                  __result = D.28506 - D.28509;
                  if (__s2_len > 1) goto <D.28510>; else goto <D.28511>;
                  <D.28510>:
                  if (__result == 0) goto <D.28512>; else goto <D.28513>;
                  <D.28512>:
                  D.28514 = &MEM[(void *)"ExportSymbol" + 2B];
                  D.28515 = *D.28514;
                  D.28516 = (int) D.28515;
                  D.28517 = __s2 + 2;
                  D.28518 = *D.28517;
                  D.28519 = (int) D.28518;
                  __result = D.28516 - D.28519;
                  if (__s2_len > 2) goto <D.28520>; else goto <D.28521>;
                  <D.28520>:
                  if (__result == 0) goto <D.28522>; else goto <D.28523>;
                  <D.28522>:
                  D.28524 = &MEM[(void *)"ExportSymbol" + 3B];
                  D.28525 = *D.28524;
                  D.28526 = (int) D.28525;
                  D.28527 = __s2 + 3;
                  D.28528 = *D.28527;
                  D.28529 = (int) D.28528;
                  __result = D.28526 - D.28529;
                  <D.28523>:
                  <D.28521>:
                  <D.28513>:
                  <D.28511>:
                  <D.28503>:
                  <D.28501>:
                }
                D.23963 = __result;
              }
              iftmp.115 = -D.23963;
              goto <D.28530>;
              <D.28494>:
              iftmp.115 = __builtin_strcmp (name, "ExportSymbol");
              <D.28530>:
              D.23964 = iftmp.115;
            }
            D.28531 = D.23964 != 0;
            D.28532 = (long int) D.28531;
            D.28533 = __builtin_expect (D.28532, 0);
            if (D.28533 != 0) goto <D.28534>; else goto <D.28535>;
            <D.28534>:
            monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "aot-compiler.c", 3682, "!strcmp (name, \"ExportSymbol\")");
            <D.28535>:
            D.28095 = mono_defaults.string_class;
            prop_type = &D.28095->byval_arg;
            named.110 = named;
            D.28478 = *named.110;
            D.28536 = D.28478 == -1;
            D.28537 = (long int) D.28536;
            D.28538 = __builtin_expect (D.28537, 0);
            if (D.28538 != 0) goto <D.28539>; else goto <D.28540>;
            <D.28539>:
            monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "aot-compiler.c", 3687, "*named != (char)0xff");
            <D.28540>:
            named.110 = named;
            D.28541 = mono_metadata_decode_value (named.110, &named);
            slen = (int) D.28541;
            D.28453 = slen + 1;
            D.28542 = (unsigned int) D.28453;
            export_name = monoeg_malloc (D.28542);
            named.110 = named;
            slen.116 = (unsigned int) slen;
            memcpy (export_name, named.110, slen.116);
            slen.108 = (sizetype) slen;
            D.28544 = export_name + slen.108;
            *D.28544 = 0;
            named.110 = named;
            slen.108 = (sizetype) slen;
            named.117 = named.110 + slen.108;
            named = named.117;
          }
          <D.28476>:
          wrapper = mono_marshal_get_managed_wrapper (method, klass, 0);
          add_method (acfg, wrapper);
          if (export_name != 0B) goto <D.28546>; else goto <D.28547>;
          <D.28546>:
          D.28548 = acfg->export_names;
          monoeg_g_hash_table_insert_replace (D.28548, wrapper, export_name, 0);
          <D.28547>:
        }
      finally
        {
          p = {CLOBBER};
          named = {CLOBBER};
        }
    }
    <D.28381>:
    <D.28333>:
    D.28384 = method->flags;
    D.28385 = (int) D.28384;
    D.28551 = D.28385 & 8192;
    if (D.28551 != 0) goto <D.28549>; else goto <D.28552>;
    <D.28552>:
    D.28553 = method->iflags;
    D.28554 = (int) D.28553;
    D.28555 = D.28554 & 4096;
    if (D.28555 != 0) goto <D.28549>; else goto <D.28550>;
    <D.28549>:
    D.28556 = mono_marshal_get_native_wrapper (method, 1, 1);
    add_method (acfg, D.28556);
    <D.28550>:
  }
  i = i + 1;
  <D.23966>:
  D.28011 = acfg->image;
  D.28045 = D.28011->tables[6].rows;
  D.28046 = (int) D.28045;
  if (D.28046 > i) goto <D.23965>; else goto <D.23967>;
  <D.23967>:
  i = 0;
  goto <D.23971>;
  <D.23970>:
  {
    struct MonoClass * klass;

    D.28009 = i + 1;
    D.28140 = D.28009 | 33554432;
    token = (guint32) D.28140;
    D.28011 = acfg->image;
    klass = mono_class_get (D.28011, token);
    if (klass == 0B) goto <D.28557>; else goto <D.28558>;
    <D.28557>:
    mono_loader_clear_error ();
    // predicted unlikely by continue predictor.
    goto <D.23969>;
    <D.28558>:
    D.28561 = BIT_FIELD_REF <*klass, 32, 160>;
    D.28562 = D.28561 & 8;
    if (D.28562 != 0) goto <D.28563>; else goto <D.28564>;
    <D.28563>:
    D.28565 = klass->generic_container;
    if (D.28565 == 0B) goto <D.28566>; else goto <D.28567>;
    <D.28566>:
    D.28568 = can_marshal_struct (klass);
    if (D.28568 != 0) goto <D.28569>; else goto <D.28570>;
    <D.28569>:
    D.28571 = klass->nested_in;
    if (D.28571 == 0B) goto <D.28559>; else goto <D.28572>;
    <D.28572>:
    D.28571 = klass->nested_in;
    D.28573 = D.28571->name;
    D.28574 = strstr (D.28573, "<PrivateImplementationDetails>");
    D.28571 = klass->nested_in;
    D.28573 = D.28571->name;
    if (D.28574 != D.28573) goto <D.28559>; else goto <D.28560>;
    <D.28559>:
    D.28575 = mono_marshal_get_struct_to_ptr (klass);
    add_method (acfg, D.28575);
    D.28576 = mono_marshal_get_ptr_to_struct (klass);
    add_method (acfg, D.28576);
    <D.28560>:
    <D.28570>:
    <D.28567>:
    <D.28564>:
  }
  <D.23969>:
  i = i + 1;
  <D.23971>:
  D.28011 = acfg->image;
  D.28269 = D.28011->tables[2].rows;
  D.28270 = (int) D.28269;
  if (D.28270 > i) goto <D.23970>; else goto <D.23972>;
  <D.23972>:
}


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

  acfg = user_data;
  callinfo = value;
  D.28577 = callinfo->sig;
  if (D.28577 == 0B) goto <D.28578>; else goto <D.28579>;
  <D.28578>:
  return;
  <D.28579>:
  D.28580 = callinfo->name;
  name = monoeg_g_strdup_printf ("__icall_wrapper_%s", D.28580);
  D.28577 = callinfo->sig;
  D.28581 = callinfo->func;
  check_for_pending_exc.118 = check_for_pending_exc;
  wrapper = mono_marshal_get_icall_wrapper (D.28577, name, D.28581, check_for_pending_exc.118);
  monoeg_g_free (name);
  add_method (acfg, wrapper);
}


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

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


create_gsharedvt_inst (struct MonoAotCompile * acfg, struct MonoMethod * method, struct MonoGenericContext * ctx)
{
  struct MonoClass * D.28587;
  struct MonoGenericContainer * D.28588;
  <unnamed-unsigned:22> D.28591;
  unsigned int D.28592;
  unsigned int D.28593;
  unsigned int i.119;
  unsigned int D.28595;
  struct MonoType * * D.28596;
  struct MonoClass * D.28597;
  struct MonoType * D.28598;
  int D.28599;
  struct MonoGenericInst * D.28600;
  unsigned int D.28601;
  unsigned int D.28602;
  struct MonoGenericParamFull * D.28605;
  unsigned int D.28606;
  struct MonoGenericParamFull * D.28607;
  struct MonoClass * * D.28610;
  struct MonoClass * D.28615;
  struct MonoImage * D.28618;
  struct MonoImage * D.28619;
  int D.23818;
  int iftmp.120;
  int D.23817;
  const char[10] * D.28624;
  unsigned char D.28625;
  int D.28626;
  unsigned char D.28627;
  int D.28628;
  const unsigned char * D.28633;
  unsigned char D.28634;
  int D.28635;
  const unsigned char * D.28636;
  unsigned char D.28637;
  int D.28638;
  const unsigned char * D.28643;
  unsigned char D.28644;
  int D.28645;
  const unsigned char * D.28646;
  unsigned char D.28647;
  int D.28648;
  const unsigned char * D.28653;
  unsigned char D.28654;
  int D.28655;
  const unsigned char * D.28656;
  unsigned char D.28657;
  int D.28658;
  const char * D.28660;
  struct MonoClass * D.28661;
  struct MonoType * D.28664;
  <unnamed-signed:31> D.28666;
  int D.28667;
  struct MonoGenericInst * D.28668;
  struct MonoGenericContext shared_context;
  struct MonoType * * args;
  struct MonoGenericInst * inst;
  struct MonoGenericContainer * container;
  struct MonoClass * * constraints;
  int i;

  try
    {
      memset (ctx, 0, 8);
      D.28587 = method->klass;
      D.28588 = D.28587->generic_container;
      if (D.28588 != 0B) goto <D.28589>; else goto <D.28590>;
      <D.28589>:
      D.28587 = method->klass;
      D.28588 = D.28587->generic_container;
      shared_context = D.28588->context;
      inst = shared_context.class_inst;
      D.28591 = inst->type_argc;
      D.28592 = (unsigned int) D.28591;
      D.28593 = D.28592 * 4;
      args = monoeg_malloc0 (D.28593);
      i = 0;
      goto <D.23805>;
      <D.23804>:
      i.119 = (unsigned int) i;
      D.28595 = i.119 * 4;
      D.28596 = args + D.28595;
      D.28597 = mono_defaults.int_class;
      D.28598 = &D.28597->byval_arg;
      *D.28596 = D.28598;
      i = i + 1;
      <D.23805>:
      D.28591 = inst->type_argc;
      D.28599 = (int) D.28591;
      if (D.28599 > i) goto <D.23804>; else goto <D.23806>;
      <D.23806>:
      D.28591 = inst->type_argc;
      D.28599 = (int) D.28591;
      D.28600 = mono_metadata_get_generic_inst (D.28599, args);
      ctx->class_inst = D.28600;
      <D.28590>:
      D.28601 = BIT_FIELD_REF <*method, 32, 160>;
      D.28602 = D.28601 & 2048;
      if (D.28602 != 0) goto <D.28603>; else goto <D.28604>;
      <D.28603>:
      container = mono_method_get_generic_container (method);
      shared_context = container->context;
      inst = shared_context.method_inst;
      D.28591 = inst->type_argc;
      D.28592 = (unsigned int) D.28591;
      D.28593 = D.28592 * 4;
      args = monoeg_malloc0 (D.28593);
      i = 0;
      goto <D.23823>;
      <D.23822>:
      {
        struct MonoGenericParamInfo * info;
        gboolean ref_only;

        D.28605 = container->type_params;
        i.119 = (unsigned int) i;
        D.28606 = i.119 * 32;
        D.28607 = D.28605 + D.28606;
        info = &D.28607->info;
        ref_only = 0;
        if (info != 0B) goto <D.28608>; else goto <D.28609>;
        <D.28608>:
        D.28610 = info->constraints;
        if (D.28610 != 0B) goto <D.28611>; else goto <D.28612>;
        <D.28611>:
        constraints = info->constraints;
        goto <D.23820>;
        <D.23819>:
        {
          struct MonoClass * cklass;

          cklass = *constraints;
          D.28615 = mono_defaults.object_class;
          if (D.28615 != cklass) goto <D.28616>; else goto <D.28617>;
          <D.28616>:
          D.28618 = cklass->image;
          D.28619 = mono_defaults.corlib;
          if (D.28618 != D.28619) goto <D.28613>; else goto <D.28620>;
          <D.28620>:
          {
            size_t __s1_len;
            size_t __s2_len;

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

              __s2 = cklass->name;
              D.28624 = "ValueType";
              D.28625 = MEM[(const unsigned char *)D.28624];
              D.28626 = (int) D.28625;
              D.28627 = *__s2;
              D.28628 = (int) D.28627;
              __result = D.28626 - D.28628;
              {
                if (__s2_len != 0) goto <D.28629>; else goto <D.28630>;
                <D.28629>:
                if (__result == 0) goto <D.28631>; else goto <D.28632>;
                <D.28631>:
                D.28633 = &MEM[(void *)"ValueType" + 1B];
                D.28634 = *D.28633;
                D.28635 = (int) D.28634;
                D.28636 = __s2 + 1;
                D.28637 = *D.28636;
                D.28638 = (int) D.28637;
                __result = D.28635 - D.28638;
                if (__s2_len > 1) goto <D.28639>; else goto <D.28640>;
                <D.28639>:
                if (__result == 0) goto <D.28641>; else goto <D.28642>;
                <D.28641>:
                D.28643 = &MEM[(void *)"ValueType" + 2B];
                D.28644 = *D.28643;
                D.28645 = (int) D.28644;
                D.28646 = __s2 + 2;
                D.28647 = *D.28646;
                D.28648 = (int) D.28647;
                __result = D.28645 - D.28648;
                if (__s2_len > 2) goto <D.28649>; else goto <D.28650>;
                <D.28649>:
                if (__result == 0) goto <D.28651>; else goto <D.28652>;
                <D.28651>:
                D.28653 = &MEM[(void *)"ValueType" + 3B];
                D.28654 = *D.28653;
                D.28655 = (int) D.28654;
                D.28656 = __s2 + 3;
                D.28657 = *D.28656;
                D.28658 = (int) D.28657;
                __result = D.28655 - D.28658;
                <D.28652>:
                <D.28650>:
                <D.28642>:
                <D.28640>:
                <D.28632>:
                <D.28630>:
              }
              D.23817 = __result;
            }
            iftmp.120 = -D.23817;
            goto <D.28659>;
            <D.28623>:
            D.28660 = cklass->name;
            iftmp.120 = __builtin_strcmp (D.28660, "ValueType");
            <D.28659>:
            D.23818 = iftmp.120;
          }
          if (D.23818 != 0) goto <D.28613>; else goto <D.28614>;
          <D.28613>:
          ref_only = 1;
          <D.28614>:
          <D.28617>:
          constraints = constraints + 4;
        }
        <D.23820>:
        D.28661 = *constraints;
        if (D.28661 != 0B) goto <D.23819>; else goto <D.23821>;
        <D.23821>:
        <D.28612>:
        <D.28609>:
        if (ref_only != 0) goto <D.28662>; else goto <D.28663>;
        <D.28662>:
        i.119 = (unsigned int) i;
        D.28595 = i.119 * 4;
        D.28596 = args + D.28595;
        D.28615 = mono_defaults.object_class;
        D.28664 = &D.28615->byval_arg;
        *D.28596 = D.28664;
        goto <D.28665>;
        <D.28663>:
        i.119 = (unsigned int) i;
        D.28595 = i.119 * 4;
        D.28596 = args + D.28595;
        D.28597 = mono_defaults.int_class;
        D.28598 = &D.28597->byval_arg;
        *D.28596 = D.28598;
        <D.28665>:
      }
      i = i + 1;
      <D.23823>:
      D.28666 = container->type_argc;
      D.28667 = (int) D.28666;
      if (D.28667 > i) goto <D.23822>; else goto <D.23824>;
      <D.23824>:
      D.28591 = inst->type_argc;
      D.28599 = (int) D.28591;
      D.28668 = mono_metadata_get_generic_inst (D.28599, args);
      ctx->method_inst = D.28668;
      <D.28604>:
    }
  finally
    {
      shared_context = {CLOBBER};
    }
}


can_marshal_struct (struct MonoClass * klass)
{
  unsigned int D.28669;
  unsigned int D.28670;
  gboolean D.28673;
  struct MonoType * D.28674;
  short unsigned int D.28675;
  int D.28676;
  int D.28677;
  unsigned char D.28680;
  int D.28681;
  struct MonoClass * D.28682;
  unsigned int D.28683;
  unsigned int D.28684;
  struct MonoClass * D.28687;
  int D.28688;
  struct MonoClassField * D.28693;
  struct MonoMarshalSpec * D.28696;
  unsigned int i.121;
  unsigned int D.28700;
  int D.23783;
  int iftmp.122;
  int D.23782;
  const char[43] * D.28706;
  unsigned char D.28707;
  int D.28708;
  unsigned char D.28709;
  int D.28710;
  const unsigned char * D.28715;
  unsigned char D.28716;
  int D.28717;
  const unsigned char * D.28718;
  unsigned char D.28719;
  int D.28720;
  const unsigned char * D.28725;
  unsigned char D.28726;
  int D.28727;
  const unsigned char * D.28728;
  unsigned char D.28729;
  int D.28730;
  const unsigned char * D.28735;
  unsigned char D.28736;
  int D.28737;
  const unsigned char * D.28738;
  unsigned char D.28739;
  int D.28740;
  const char * D.28742;
  int D.23792;
  int iftmp.123;
  int D.23791;
  const char[12] * D.28748;
  unsigned char D.28749;
  int D.28750;
  unsigned char D.28751;
  int D.28752;
  const unsigned char * D.28757;
  unsigned char D.28758;
  int D.28759;
  const unsigned char * D.28760;
  unsigned char D.28761;
  int D.28762;
  const unsigned char * D.28767;
  unsigned char D.28768;
  int D.28769;
  const unsigned char * D.28770;
  unsigned char D.28771;
  int D.28772;
  const unsigned char * D.28777;
  unsigned char D.28778;
  int D.28779;
  const unsigned char * D.28780;
  unsigned char D.28781;
  int D.28782;
  const char * D.28784;
  struct MonoClassField * field;
  gboolean can_marshal;
  void * iter;
  struct MonoMarshalType * info;
  int i;

  try
    {
      can_marshal = 1;
      iter = 0B;
      D.28669 = klass->flags;
      D.28670 = D.28669 & 24;
      if (D.28670 == 0) goto <D.28671>; else goto <D.28672>;
      <D.28671>:
      D.28673 = 0;
      return D.28673;
      <D.28672>:
      info = mono_marshal_load_type_info (klass);
      goto <D.23748>;
      <D.23773>:
      D.28674 = field->type;
      D.28675 = D.28674->attrs;
      D.28676 = (int) D.28675;
      D.28677 = D.28676 & 16;
      if (D.28677 != 0) goto <D.28678>; else goto <D.28679>;
      <D.28678>:
      // predicted unlikely by continue predictor.
      goto <D.23748>;
      <D.28679>:
      D.28674 = field->type;
      D.28680 = D.28674->type;
      D.28681 = (int) D.28680;
      switch (D.28681) <default: <D.23772>, case 2: <D.23753>, case 3: <D.23756>, case 4: <D.23751>, case 5: <D.23752>, case 6: <D.23754>, case 7: <D.23755>, case 8: <D.23749>, case 9: <D.23750>, case 10: <D.23757>, case 11: <D.23758>, case 12: <D.23762>, case 13: <D.23763>, case 14: <D.23764>, case 15: <D.23761>, case 17: <D.23766>, case 24: <D.23759>, case 25: <D.23760>, case 29: <D.23767>>
      <D.23749>:
      <D.23750>:
      <D.23751>:
      <D.23752>:
      <D.23753>:
      <D.23754>:
      <D.23755>:
      <D.23756>:
      <D.23757>:
      <D.23758>:
      <D.23759>:
      <D.23760>:
      <D.23761>:
      <D.23762>:
      <D.23763>:
      <D.23764>:
      goto <D.23765>;
      <D.23766>:
      D.28674 = field->type;
      D.28682 = mono_class_from_mono_type (D.28674);
      D.28683 = BIT_FIELD_REF <*D.28682, 32, 160>;
      D.28684 = D.28683 & 16;
      if (D.28684 == 0) goto <D.28685>; else goto <D.28686>;
      <D.28685>:
      D.28674 = field->type;
      D.28687 = mono_class_from_mono_type (D.28674);
      D.28688 = can_marshal_struct (D.28687);
      if (D.28688 == 0) goto <D.28689>; else goto <D.28690>;
      <D.28689>:
      can_marshal = 0;
      <D.28690>:
      <D.28686>:
      goto <D.23765>;
      <D.23767>:
      {
        gboolean has_mspec;

        has_mspec = 0;
        if (info != 0B) goto <D.28691>; else goto <D.28692>;
        <D.28691>:
        i = 0;
        goto <D.23770>;
        <D.23769>:
        D.28693 = info->fields[i].field;
        if (D.28693 == field) goto <D.28694>; else goto <D.28695>;
        <D.28694>:
        D.28696 = info->fields[i].mspec;
        if (D.28696 != 0B) goto <D.28697>; else goto <D.28698>;
        <D.28697>:
        has_mspec = 1;
        <D.28698>:
        <D.28695>:
        i = i + 1;
        <D.23770>:
        i.121 = (unsigned int) i;
        D.28700 = info->num_fields;
        if (i.121 < D.28700) goto <D.23769>; else goto <D.23771>;
        <D.23771>:
        <D.28692>:
        if (has_mspec == 0) goto <D.28701>; else goto <D.28702>;
        <D.28701>:
        can_marshal = 0;
        <D.28702>:
        goto <D.23765>;
      }
      <D.23772>:
      can_marshal = 0;
      goto <D.23765>;
      <D.23765>:
      <D.23748>:
      field = mono_class_get_fields (klass, &iter);
      if (field != 0B) goto <D.23773>; else goto <D.23774>;
      <D.23774>:
      {
        size_t __s1_len;
        size_t __s2_len;

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

          __s2 = klass->name_space;
          D.28706 = "System.Net.NetworkInformation.MacOsStructs";
          D.28707 = MEM[(const unsigned char *)D.28706];
          D.28708 = (int) D.28707;
          D.28709 = *__s2;
          D.28710 = (int) D.28709;
          __result = D.28708 - D.28710;
          {
            if (__s2_len != 0) goto <D.28711>; else goto <D.28712>;
            <D.28711>:
            if (__result == 0) goto <D.28713>; else goto <D.28714>;
            <D.28713>:
            D.28715 = &MEM[(void *)"System.Net.NetworkInformation.MacOsStructs" + 1B];
            D.28716 = *D.28715;
            D.28717 = (int) D.28716;
            D.28718 = __s2 + 1;
            D.28719 = *D.28718;
            D.28720 = (int) D.28719;
            __result = D.28717 - D.28720;
            if (__s2_len > 1) goto <D.28721>; else goto <D.28722>;
            <D.28721>:
            if (__result == 0) goto <D.28723>; else goto <D.28724>;
            <D.28723>:
            D.28725 = &MEM[(void *)"System.Net.NetworkInformation.MacOsStructs" + 2B];
            D.28726 = *D.28725;
            D.28727 = (int) D.28726;
            D.28728 = __s2 + 2;
            D.28729 = *D.28728;
            D.28730 = (int) D.28729;
            __result = D.28727 - D.28730;
            if (__s2_len > 2) goto <D.28731>; else goto <D.28732>;
            <D.28731>:
            if (__result == 0) goto <D.28733>; else goto <D.28734>;
            <D.28733>:
            D.28735 = &MEM[(void *)"System.Net.NetworkInformation.MacOsStructs" + 3B];
            D.28736 = *D.28735;
            D.28737 = (int) D.28736;
            D.28738 = __s2 + 3;
            D.28739 = *D.28738;
            D.28740 = (int) D.28739;
            __result = D.28737 - D.28740;
            <D.28734>:
            <D.28732>:
            <D.28724>:
            <D.28722>:
            <D.28714>:
            <D.28712>:
          }
          D.23782 = __result;
        }
        iftmp.122 = -D.23782;
        goto <D.28741>;
        <D.28705>:
        D.28742 = klass->name_space;
        iftmp.122 = __builtin_strcmp (D.28742, "System.Net.NetworkInformation.MacOsStructs");
        <D.28741>:
        D.23783 = iftmp.122;
      }
      if (D.23783 == 0) goto <D.28743>; else goto <D.28744>;
      <D.28743>:
      {
        size_t __s1_len;
        size_t __s2_len;

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

          __s2 = klass->name;
          D.28748 = "sockaddr_dl";
          D.28749 = MEM[(const unsigned char *)D.28748];
          D.28750 = (int) D.28749;
          D.28751 = *__s2;
          D.28752 = (int) D.28751;
          __result = D.28750 - D.28752;
          {
            if (__s2_len != 0) goto <D.28753>; else goto <D.28754>;
            <D.28753>:
            if (__result == 0) goto <D.28755>; else goto <D.28756>;
            <D.28755>:
            D.28757 = &MEM[(void *)"sockaddr_dl" + 1B];
            D.28758 = *D.28757;
            D.28759 = (int) D.28758;
            D.28760 = __s2 + 1;
            D.28761 = *D.28760;
            D.28762 = (int) D.28761;
            __result = D.28759 - D.28762;
            if (__s2_len > 1) goto <D.28763>; else goto <D.28764>;
            <D.28763>:
            if (__result == 0) goto <D.28765>; else goto <D.28766>;
            <D.28765>:
            D.28767 = &MEM[(void *)"sockaddr_dl" + 2B];
            D.28768 = *D.28767;
            D.28769 = (int) D.28768;
            D.28770 = __s2 + 2;
            D.28771 = *D.28770;
            D.28772 = (int) D.28771;
            __result = D.28769 - D.28772;
            if (__s2_len > 2) goto <D.28773>; else goto <D.28774>;
            <D.28773>:
            if (__result == 0) goto <D.28775>; else goto <D.28776>;
            <D.28775>:
            D.28777 = &MEM[(void *)"sockaddr_dl" + 3B];
            D.28778 = *D.28777;
            D.28779 = (int) D.28778;
            D.28780 = __s2 + 3;
            D.28781 = *D.28780;
            D.28782 = (int) D.28781;
            __result = D.28779 - D.28782;
            <D.28776>:
            <D.28774>:
            <D.28766>:
            <D.28764>:
            <D.28756>:
            <D.28754>:
          }
          D.23791 = __result;
        }
        iftmp.123 = -D.23791;
        goto <D.28783>;
        <D.28747>:
        D.28784 = klass->name;
        iftmp.123 = __builtin_strcmp (D.28784, "sockaddr_dl");
        <D.28783>:
        D.23792 = iftmp.123;
      }
      if (D.23792 != 0) goto <D.28785>; else goto <D.28786>;
      <D.28785>:
      D.28673 = 1;
      return D.28673;
      <D.28786>:
      <D.28744>:
      D.28673 = can_marshal;
      return D.28673;
    }
  finally
    {
      iter = {CLOBBER};
    }
}


compile_methods (struct MonoAotCompile * acfg)
{
  int D.28790;
  struct GPtrArray * D.28793;
  unsigned int D.28794;
  unsigned int D.28795;
  unsigned int D.28796;
  _Bool D.28797;
  long int D.28798;
  long int D.28799;
  unsigned int methods_len.124;
  unsigned int D.28803;
  unsigned int i.125;
  unsigned int D.28805;
  struct MonoMethod * * D.28806;
  void * * D.28807;
  void * * D.28808;
  void * D.28809;
  struct MonoMethod * D.28812;
  struct MonoDomain * D.28813;
  void * * D.28814;
  void * * D.28815;
  void * * D.28816;
  void * * D.28817;
  void * D.28818;
  unsigned int i.126;
  unsigned int D.28820;
  int i;
  int methods_len;

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

    D.28793 = acfg->methods;
    D.28794 = D.28793->len;
    methods_len = (int) D.28794;
    D.28793 = acfg->methods;
    D.28794 = D.28793->len;
    D.28790 = acfg->aot_opts.nthreads;
    D.28795 = (unsigned int) D.28790;
    D.28796 = D.28794 / D.28795;
    len = (int) D.28796;
    D.28797 = len <= 0;
    D.28798 = (long int) D.28797;
    D.28799 = __builtin_expect (D.28798, 0);
    if (D.28799 != 0) goto <D.28800>; else goto <D.28801>;
    <D.28800>:
    monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "aot-compiler.c", 8377, "len > 0");
    <D.28801>:
    threads = monoeg_g_ptr_array_new ();
    methods_len.124 = (unsigned int) methods_len;
    D.28803 = methods_len.124 * 4;
    methods = monoeg_malloc0 (D.28803);
    i = 0;
    goto <D.25487>;
    <D.25486>:
    i.125 = (unsigned int) i;
    D.28805 = i.125 * 4;
    D.28806 = methods + D.28805;
    D.28793 = acfg->methods;
    D.28807 = D.28793->pdata;
    i.125 = (unsigned int) i;
    D.28805 = i.125 * 4;
    D.28808 = D.28807 + D.28805;
    D.28809 = *D.28808;
    *D.28806 = D.28809;
    i = i + 1;
    <D.25487>:
    if (i < methods_len) goto <D.25486>; else goto <D.25488>;
    <D.25488>:
    i = 0;
    goto <D.25493>;
    <D.25492>:
    frag = monoeg_g_ptr_array_new ();
    j = 0;
    goto <D.25490>;
    <D.25489>:
    if (i < methods_len) goto <D.28810>; else goto <D.28811>;
    <D.28810>:
    i.125 = (unsigned int) i;
    D.28805 = i.125 * 4;
    D.28806 = methods + D.28805;
    D.28812 = *D.28806;
    monoeg_g_ptr_array_add (frag, D.28812);
    i = i + 1;
    <D.28811>:
    j = j + 1;
    <D.25490>:
    if (j < len) goto <D.25489>; else goto <D.25491>;
    <D.25491>:
    user_data = monoeg_malloc0 (12);
    D.28813 = mono_domain_get ();
    *user_data = D.28813;
    D.28814 = user_data + 4;
    *D.28814 = acfg;
    D.28815 = user_data + 8;
    *D.28815 = frag;
    handle = mono_threads_create_thread (compile_thread_main, user_data, 0, 0, 0B);
    monoeg_g_ptr_array_add (threads, handle);
    <D.25493>:
    if (i < methods_len) goto <D.25492>; else goto <D.25494>;
    <D.25494>:
    monoeg_g_free (methods);
    i = 0;
    goto <D.25496>;
    <D.25495>:
    D.28816 = threads->pdata;
    i.125 = (unsigned int) i;
    D.28805 = i.125 * 4;
    D.28817 = D.28816 + D.28805;
    D.28818 = *D.28817;
    WaitForSingleObjectEx (D.28818, 4294967295, 0);
    i = i + 1;
    <D.25496>:
    i.126 = (unsigned int) i;
    D.28820 = threads->len;
    if (i.126 < D.28820) goto <D.25495>; else goto <D.25497>;
    <D.25497>:
  }
  goto <D.28821>;
  <D.28792>:
  methods_len = 0;
  <D.28821>:
  i = methods_len;
  goto <D.25499>;
  <D.25498>:
  D.28793 = acfg->methods;
  D.28807 = D.28793->pdata;
  i.125 = (unsigned int) i;
  D.28805 = i.125 * 4;
  D.28808 = D.28807 + D.28805;
  D.28809 = *D.28808;
  compile_method (acfg, D.28809);
  i = i + 1;
  <D.25499>:
  i.126 = (unsigned int) i;
  D.28793 = acfg->methods;
  D.28794 = D.28793->len;
  if (i.126 < D.28794) goto <D.25498>; else goto <D.25500>;
  <D.25500>:
}


compile_thread_main (void * * user_data)
{
  void * * D.28822;
  unsigned int i.127;
  unsigned int D.28824;
  void * * D.28825;
  void * D.28826;
  unsigned int i.128;
  unsigned int D.28828;
  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.25056>;
  <D.25055>:
  D.28822 = methods->pdata;
  i.127 = (unsigned int) i;
  D.28824 = i.127 * 4;
  D.28825 = D.28822 + D.28824;
  D.28826 = *D.28825;
  compile_method (acfg, D.28826);
  i = i + 1;
  <D.25056>:
  i.128 = (unsigned int) i;
  D.28828 = methods->len;
  if (i.128 < D.28828) goto <D.25055>; else goto <D.25057>;
  <D.25057>:
}


compile_method (struct MonoAotCompile * acfg, struct MonoMethod * method)
{
  int D.28829;
  union mono_mutex_t * D.28832;
  _Bool D.28835;
  long int D.28836;
  long int D.28837;
  unsigned int D.28840;
  _Bool D.28843;
  long int D.28844;
  long int D.28845;
  short unsigned int D.28850;
  int D.28851;
  int D.28852;
  short unsigned int D.28854;
  int D.28855;
  int D.28856;
  int D.28858;
  int D.28859;
  short unsigned int D.28864;
  int D.28865;
  int D.28866;
  unsigned int D.28869;
  unsigned int D.28870;
  unsigned int D.28873;
  unsigned int D.28874;
  int * D.28877;
  unsigned int D.28878;
  struct MonoDomain * D.28879;
  JitFlags iftmp.129;
  int D.28881;
  unsigned int D.28885;
  int D.28888;
  char * D.28891;
  char * D.28892;
  int * D.28893;
  char * D.28898;
  unsigned int D.28899;
  unsigned int D.28900;
  char * D.28905;
  int * D.28906;
  unsigned int index.130;
  <unnamed type> D.28908;
  _Bool D.28911;
  long int D.28912;
  long int D.28913;
  struct GHashTable * D.28916;
  _Bool D.28919;
  long int D.28920;
  long int D.28921;
  char * D.28928;
  int * D.28929;
  _Bool D.28932;
  long int D.28933;
  long int D.28934;
  int D.28937;
  char * D.28944;
  int D.28945;
  int D.28946;
  _Bool D.28949;
  long int D.28950;
  long int D.28951;
  struct GHashTable * D.28954;
  void * D.28955;
  int D.28956;
  unsigned int D.28961;
  unsigned int D.28962;
  struct MonoClass * D.28967;
  int D.28968;
  int D.28970;
  int D.28971;
  short unsigned int D.28974;
  int D.28975;
  int D.28976;
  struct MonoMethod * D.28981;
  int D.28982;
  int D.28984;
  unsigned int D.28985;
  int D.25000;
  int iftmp.131;
  int D.24999;
  const char[12] * D.28991;
  unsigned char D.28992;
  int D.28993;
  unsigned char D.28994;
  int D.28995;
  const unsigned char * D.29000;
  unsigned char D.29001;
  int D.29002;
  const unsigned char * D.29003;
  unsigned char D.29004;
  int D.29005;
  const unsigned char * D.29010;
  unsigned char D.29011;
  int D.29012;
  const unsigned char * D.29013;
  unsigned char D.29014;
  int D.29015;
  const unsigned char * D.29020;
  unsigned char D.29021;
  int D.29022;
  const unsigned char * D.29023;
  unsigned char D.29024;
  int D.29025;
  const char * D.29027;
  struct MonoGenericClass * D.29030;
  int D.29033;
  struct MonoClassField * D.29036;
  struct MonoGenericClass * D.29037;
  struct MonoGenericContext * D.29040;
  int D.29041;
  struct MonoMethod * D.29044;
  struct MonoMethod * D.29047;
  struct MonoImage * D.29048;
  struct MonoImage * D.29049;
  int D.29052;
  unsigned int D.29055;
  unsigned int D.29056;
  int * D.29059;
  struct MonoMemPool * D.29060;
  void * D.29064;
  struct GSList * D.29065;
  short unsigned int D.29066;
  int D.29067;
  <unnamed-unsigned:1> D.29068;
  int D.29069;
  int D.29070;
  unsigned int D.29071;
  unsigned int D.29072;
  unsigned int i.132;
  unsigned int D.29074;
  struct MonoInst * * D.29075;
  void * D.29076;
  struct MonoInst * D.29077;
  struct MonoInst * * D.29078;
  struct MonoInst * * D.29079;
  struct MonoInst * D.29080;
  short unsigned int D.29081;
  unsigned int D.29082;
  unsigned int D.29083;
  struct MonoInst * * D.29084;
  void * D.29085;
  struct MonoInst * D.29086;
  struct MonoInst * * D.29087;
  struct MonoInst * * D.29088;
  struct MonoInst * D.29089;
  int D.29090;
  struct MonoMemPool * D.29091;
  struct MonoInst * * D.29092;
  struct MonoMethodVar * D.29093;
  struct MonoRegState * D.29094;
  int D.29097;
  unsigned int new_size.133;
  unsigned int D.29099;
  struct MonoCompile * * D.29100;
  unsigned int D.29101;
  unsigned int D.29102;
  unsigned int index.134;
  unsigned int D.29104;
  struct MonoCompile * * D.29105;
  struct GHashTable * D.29106;
  struct MonoMethod * D.29107;
  _Bool D.29110;
  long int D.29111;
  long int D.29112;
  int * D.29115;
  struct MonoCompile * cfg;
  struct MonoJumpInfo * patch_info;
  gboolean skip;
  int index;
  int depth;
  struct MonoMethod * wrapped;

  D.28829 = acfg->aot_opts.metadata_only;
  if (D.28829 != 0) goto <D.28830>; else goto <D.28831>;
  <D.28830>:
  return;
  <D.28831>:
  {
    int ret;

    D.28832 = &acfg->mutex.mutex;
    ret = pthread_mutex_lock (D.28832);
    if (ret != 0) goto <D.28833>; else goto <D.28834>;
    <D.28833>:
    monoeg_g_log (0B, 16, "Bad call to mono_mutex_lock result %d", ret);
    <D.28834>:
    D.28835 = ret != 0;
    D.28836 = (long int) D.28835;
    D.28837 = __builtin_expect (D.28836, 0);
    if (D.28837 != 0) goto <D.28838>; else goto <D.28839>;
    <D.28838>:
    monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "aot-compiler.c", 6458, "ret == 0");
    <D.28839>:
  }
  D.28840 = get_method_index (acfg, method);
  index = (int) D.28840;
  {
    int ret;

    D.28832 = &acfg->mutex.mutex;
    ret = pthread_mutex_unlock (D.28832);
    if (ret != 0) goto <D.28841>; else goto <D.28842>;
    <D.28841>:
    monoeg_g_log (0B, 16, "Bad call to mono_mutex_unlock result %d", ret);
    <D.28842>:
    D.28843 = ret != 0;
    D.28844 = (long int) D.28843;
    D.28845 = __builtin_expect (D.28844, 0);
    if (D.28845 != 0) goto <D.28846>; else goto <D.28847>;
    <D.28846>:
    monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "aot-compiler.c", 6460, "ret == 0");
    <D.28847>:
  }
  D.28850 = method->flags;
  D.28851 = (int) D.28850;
  D.28852 = D.28851 & 8192;
  if (D.28852 != 0) goto <D.28848>; else goto <D.28853>;
  <D.28853>:
  D.28854 = method->iflags;
  D.28855 = (int) D.28854;
  D.28856 = D.28855 & 3;
  if (D.28856 != 0) goto <D.28848>; else goto <D.28857>;
  <D.28857>:
  D.28850 = method->flags;
  D.28851 = (int) D.28850;
  D.28858 = D.28851 & 1024;
  if (D.28858 != 0) goto <D.28848>; else goto <D.28849>;
  <D.28848>:
  return;
  <D.28849>:
  D.28854 = method->iflags;
  D.28855 = (int) D.28854;
  D.28859 = D.28855 & 4096;
  if (D.28859 != 0) goto <D.28860>; else goto <D.28861>;
  <D.28860>:
  return;
  <D.28861>:
  wrapped = mono_marshal_method_from_wrapper (method);
  if (wrapped != 0B) goto <D.28862>; else goto <D.28863>;
  <D.28862>:
  D.28864 = wrapped->iflags;
  D.28865 = (int) D.28864;
  D.28866 = D.28865 & 4096;
  if (D.28866 != 0) goto <D.28867>; else goto <D.28868>;
  <D.28867>:
  D.28869 = BIT_FIELD_REF <*wrapped, 32, 160>;
  D.28870 = D.28869 & 2048;
  if (D.28870 != 0) goto <D.28871>; else goto <D.28872>;
  <D.28871>:
  return;
  <D.28872>:
  <D.28868>:
  <D.28863>:
  D.28873 = BIT_FIELD_REF <*method, 32, 160>;
  D.28874 = D.28873 & 124;
  if (D.28874 == 108) goto <D.28875>; else goto <D.28876>;
  <D.28875>:
  return;
  <D.28876>:
  D.28877 = &acfg->stats.mcount;
  InterlockedIncrement (D.28877);
  D.28878 = acfg->opts;
  D.28879 = mono_get_root_domain ();
  D.28881 = acfg->aot_opts.full_aot;
  if (D.28881 != 0) goto <D.28882>; else goto <D.28883>;
  <D.28882>:
  iftmp.129 = 6;
  goto <D.28884>;
  <D.28883>:
  iftmp.129 = 2;
  <D.28884>:
  cfg = mini_method_compile (method, D.28878, D.28879, iftmp.129, 0);
  mono_loader_clear_error ();
  D.28885 = cfg->exception_type;
  if (D.28885 == 11) goto <D.28886>; else goto <D.28887>;
  <D.28886>:
  D.28888 = acfg->aot_opts.print_skipped_methods;
  if (D.28888 != 0) goto <D.28889>; else goto <D.28890>;
  <D.28889>:
  D.28891 = mono_method_full_name (method, 1);
  D.28892 = cfg->exception_message;
  printf ("Skip (gshared failure): %s (%s)\n", D.28891, D.28892);
  <D.28890>:
  D.28893 = &acfg->stats.genericcount;
  InterlockedIncrement (D.28893);
  return;
  <D.28887>:
  D.28885 = cfg->exception_type;
  if (D.28885 != 0) goto <D.28894>; else goto <D.28895>;
  <D.28894>:
  D.28888 = acfg->aot_opts.print_skipped_methods;
  if (D.28888 != 0) goto <D.28896>; else goto <D.28897>;
  <D.28896>:
  D.28898 = mono_method_full_name (method, 1);
  printf ("Skip (JIT failure): %s\n", D.28898);
  <D.28897>:
  return;
  <D.28895>:
  D.28899 = BIT_FIELD_REF <*cfg, 32, 3392>;
  D.28900 = D.28899 & 1;
  if (D.28900 != 0) goto <D.28901>; else goto <D.28902>;
  <D.28901>:
  D.28888 = acfg->aot_opts.print_skipped_methods;
  if (D.28888 != 0) goto <D.28903>; else goto <D.28904>;
  <D.28903>:
  D.28905 = mono_method_full_name (method, 1);
  printf ("Skip (disabled): %s\n", D.28905);
  <D.28904>:
  D.28906 = &acfg->stats.ocount;
  InterlockedIncrement (D.28906);
  mono_destroy_compile (cfg);
  return;
  <D.28902>:
  index.130 = (unsigned int) index;
  cfg->method_index = index.130;
  patch_info = cfg->patch_info;
  goto <D.24975>;
  <D.24974>:
  D.28908 = patch_info->type;
  switch (D.28908) <default: <D.24973>, case 0: <D.24971>, case 2: <D.24970>>
  <D.24970>:
  <D.24971>:
  patch_info->type = 51;
  goto <D.24972>;
  <D.24973>:
  goto <D.24972>;
  <D.24972>:
  patch_info = patch_info->next;
  <D.24975>:
  if (patch_info != 0B) goto <D.24974>; else goto <D.24976>;
  <D.24976>:
  {
    int ret;

    D.28832 = &acfg->mutex.mutex;
    ret = pthread_mutex_lock (D.28832);
    if (ret != 0) goto <D.28909>; else goto <D.28910>;
    <D.28909>:
    monoeg_g_log (0B, 16, "Bad call to mono_mutex_lock result %d", ret);
    <D.28910>:
    D.28911 = ret != 0;
    D.28912 = (long int) D.28911;
    D.28913 = __builtin_expect (D.28912, 0);
    if (D.28913 != 0) goto <D.28914>; else goto <D.28915>;
    <D.28914>:
    monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "aot-compiler.c", 6536, "ret == 0");
    <D.28915>:
  }
  D.28916 = cfg->token_info_hash;
  monoeg_g_hash_table_foreach (D.28916, add_token_info_hash, acfg);
  {
    int ret;

    D.28832 = &acfg->mutex.mutex;
    ret = pthread_mutex_unlock (D.28832);
    if (ret != 0) goto <D.28917>; else goto <D.28918>;
    <D.28917>:
    monoeg_g_log (0B, 16, "Bad call to mono_mutex_unlock result %d", ret);
    <D.28918>:
    D.28919 = ret != 0;
    D.28920 = (long int) D.28919;
    D.28921 = __builtin_expect (D.28920, 0);
    if (D.28921 != 0) goto <D.28922>; else goto <D.28923>;
    <D.28922>:
    monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "aot-compiler.c", 6538, "ret == 0");
    <D.28923>:
  }
  skip = 0;
  patch_info = cfg->patch_info;
  goto <D.24983>;
  <D.24982>:
  D.28908 = patch_info->type;
  switch (D.28908) <default: <D.24981>, case 1: <D.24979>>
  <D.24979>:
  skip = 1;
  goto <D.24980>;
  <D.24981>:
  goto <D.24980>;
  <D.24980>:
  patch_info = patch_info->next;
  <D.24983>:
  if (patch_info != 0B) goto <D.24982>; else goto <D.24984>;
  <D.24984>:
  if (skip != 0) goto <D.28924>; else goto <D.28925>;
  <D.28924>:
  D.28888 = acfg->aot_opts.print_skipped_methods;
  if (D.28888 != 0) goto <D.28926>; else goto <D.28927>;
  <D.28926>:
  D.28928 = mono_method_full_name (method, 1);
  printf ("Skip (abs call): %s\n", D.28928);
  <D.28927>:
  D.28929 = &acfg->stats.abscount;
  InterlockedIncrement (D.28929);
  mono_destroy_compile (cfg);
  return;
  <D.28925>:
  {
    int ret;

    D.28832 = &acfg->mutex.mutex;
    ret = pthread_mutex_lock (D.28832);
    if (ret != 0) goto <D.28930>; else goto <D.28931>;
    <D.28930>:
    monoeg_g_log (0B, 16, "Bad call to mono_mutex_lock result %d", ret);
    <D.28931>:
    D.28932 = ret != 0;
    D.28933 = (long int) D.28932;
    D.28934 = __builtin_expect (D.28933, 0);
    if (D.28934 != 0) goto <D.28935>; else goto <D.28936>;
    <D.28935>:
    monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "aot-compiler.c", 6564, "ret == 0");
    <D.28936>:
  }
  skip = 0;
  patch_info = cfg->patch_info;
  goto <D.24987>;
  <D.24986>:
  D.28937 = can_encode_patch (acfg, patch_info);
  if (D.28937 == 0) goto <D.28938>; else goto <D.28939>;
  <D.28938>:
  skip = 1;
  <D.28939>:
  patch_info = patch_info->next;
  <D.24987>:
  if (patch_info != 0B) goto <D.24986>; else goto <D.24988>;
  <D.24988>:
  if (skip != 0) goto <D.28940>; else goto <D.28941>;
  <D.28940>:
  D.28888 = acfg->aot_opts.print_skipped_methods;
  if (D.28888 != 0) goto <D.28942>; else goto <D.28943>;
  <D.28942>:
  D.28944 = mono_method_full_name (method, 1);
  printf ("Skip (patches): %s\n", D.28944);
  <D.28943>:
  D.28945 = acfg->stats.ocount;
  D.28946 = D.28945 + 1;
  acfg->stats.ocount = D.28946;
  mono_destroy_compile (cfg);
  {
    int ret;

    D.28832 = &acfg->mutex.mutex;
    ret = pthread_mutex_unlock (D.28832);
    if (ret != 0) goto <D.28947>; else goto <D.28948>;
    <D.28947>:
    monoeg_g_log (0B, 16, "Bad call to mono_mutex_unlock result %d", ret);
    <D.28948>:
    D.28949 = ret != 0;
    D.28950 = (long int) D.28949;
    D.28951 = __builtin_expect (D.28950, 0);
    if (D.28951 != 0) goto <D.28952>; else goto <D.28953>;
    <D.28952>:
    monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "aot-compiler.c", 6580, "ret == 0");
    <D.28953>:
  }
  return;
  <D.28941>:
  D.28954 = acfg->method_depth;
  D.28955 = monoeg_g_hash_table_lookup (D.28954, method);
  depth = (int) D.28955;
  D.28956 = acfg->aot_opts.no_instances;
  if (D.28956 == 0) goto <D.28957>; else goto <D.28958>;
  <D.28957>:
  if (depth <= 31) goto <D.28959>; else goto <D.28960>;
  <D.28959>:
  patch_info = cfg->patch_info;
  goto <D.25008>;
  <D.25007>:
  D.28908 = patch_info->type;
  switch (D.28908) <default: <D.25006>, case 3: <D.24990>, case 14: <D.25002>, case 16: <D.25004>>
  <D.24990>:
  {
    struct MonoMethod * m;

    m = patch_info->data.method;
    D.28961 = BIT_FIELD_REF <*m, 32, 160>;
    D.28962 = D.28961 & 4096;
    if (D.28962 != 0) goto <D.28963>; else goto <D.28964>;
    <D.28963>:
    D.28967 = m->klass;
    D.28968 = mono_class_generic_sharing_enabled (D.28967);
    if (D.28968 == 0) goto <D.28965>; else goto <D.28969>;
    <D.28969>:
    D.28970 = mono_method_is_generic_sharable_full (m, 0, 0, 0);
    if (D.28970 == 0) goto <D.28965>; else goto <D.28966>;
    <D.28965>:
    D.28971 = method_has_type_vars (m);
    if (D.28971 == 0) goto <D.28972>; else goto <D.28973>;
    <D.28972>:
    D.28974 = m->iflags;
    D.28975 = (int) D.28974;
    D.28976 = D.28975 & 4096;
    if (D.28976 != 0) goto <D.28977>; else goto <D.28978>;
    <D.28977>:
    D.28881 = acfg->aot_opts.full_aot;
    if (D.28881 != 0) goto <D.28979>; else goto <D.28980>;
    <D.28979>:
    D.28981 = mono_marshal_get_native_wrapper (m, 1, 1);
    D.28982 = depth + 1;
    add_extra_method_with_depth (acfg, D.28981, D.28982);
    <D.28980>:
    goto <D.28983>;
    <D.28978>:
    D.28982 = depth + 1;
    add_extra_method_with_depth (acfg, m, D.28982);
    add_types_from_method_header (acfg, m);
    <D.28983>:
    <D.28973>:
    <D.28966>:
    D.28967 = m->klass;
    D.28984 = depth + 5;
    add_generic_class_with_depth (acfg, D.28967, D.28984, "method");
    <D.28964>:
    D.28961 = BIT_FIELD_REF <*m, 32, 160>;
    D.28985 = D.28961 & 124;
    if (D.28985 == 28) goto <D.28986>; else goto <D.28987>;
    <D.28986>:
    {
      size_t __s1_len;
      size_t __s2_len;

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

        __s2 = m->name;
        D.28991 = "ElementAddr";
        D.28992 = MEM[(const unsigned char *)D.28991];
        D.28993 = (int) D.28992;
        D.28994 = *__s2;
        D.28995 = (int) D.28994;
        __result = D.28993 - D.28995;
        {
          if (__s2_len != 0) goto <D.28996>; else goto <D.28997>;
          <D.28996>:
          if (__result == 0) goto <D.28998>; else goto <D.28999>;
          <D.28998>:
          D.29000 = &MEM[(void *)"ElementAddr" + 1B];
          D.29001 = *D.29000;
          D.29002 = (int) D.29001;
          D.29003 = __s2 + 1;
          D.29004 = *D.29003;
          D.29005 = (int) D.29004;
          __result = D.29002 - D.29005;
          if (__s2_len > 1) goto <D.29006>; else goto <D.29007>;
          <D.29006>:
          if (__result == 0) goto <D.29008>; else goto <D.29009>;
          <D.29008>:
          D.29010 = &MEM[(void *)"ElementAddr" + 2B];
          D.29011 = *D.29010;
          D.29012 = (int) D.29011;
          D.29013 = __s2 + 2;
          D.29014 = *D.29013;
          D.29015 = (int) D.29014;
          __result = D.29012 - D.29015;
          if (__s2_len > 2) goto <D.29016>; else goto <D.29017>;
          <D.29016>:
          if (__result == 0) goto <D.29018>; else goto <D.29019>;
          <D.29018>:
          D.29020 = &MEM[(void *)"ElementAddr" + 3B];
          D.29021 = *D.29020;
          D.29022 = (int) D.29021;
          D.29023 = __s2 + 3;
          D.29024 = *D.29023;
          D.29025 = (int) D.29024;
          __result = D.29022 - D.29025;
          <D.29019>:
          <D.29017>:
          <D.29009>:
          <D.29007>:
          <D.28999>:
          <D.28997>:
        }
        D.24999 = __result;
      }
      iftmp.131 = -D.24999;
      goto <D.29026>;
      <D.28990>:
      D.29027 = m->name;
      iftmp.131 = __builtin_strcmp (D.29027, "ElementAddr");
      <D.29026>:
      D.25000 = iftmp.131;
    }
    if (D.25000 == 0) goto <D.29028>; else goto <D.29029>;
    <D.29028>:
    D.28982 = depth + 1;
    add_extra_method_with_depth (acfg, m, D.28982);
    <D.29029>:
    <D.28987>:
    goto <D.25001>;
  }
  <D.25002>:
  {
    struct MonoClass * klass;

    klass = patch_info->data.klass;
    D.29030 = klass->generic_class;
    if (D.29030 != 0B) goto <D.29031>; else goto <D.29032>;
    <D.29031>:
    D.29033 = mini_class_is_generic_sharable (klass);
    if (D.29033 == 0) goto <D.29034>; else goto <D.29035>;
    <D.29034>:
    D.28984 = depth + 5;
    add_generic_class_with_depth (acfg, klass, D.28984, "vtable");
    <D.29035>:
    <D.29032>:
    goto <D.25001>;
  }
  <D.25004>:
  {
    struct MonoClass * klass;

    D.29036 = patch_info->data.field;
    klass = D.29036->parent;
    D.29037 = klass->generic_class;
    if (D.29037 != 0B) goto <D.29038>; else goto <D.29039>;
    <D.29038>:
    D.29037 = klass->generic_class;
    D.29040 = &D.29037->context;
    D.29041 = mono_generic_context_is_sharable (D.29040, 0);
    if (D.29041 == 0) goto <D.29042>; else goto <D.29043>;
    <D.29042>:
    D.29044 = mono_class_get_cctor (klass);
    if (D.29044 != 0B) goto <D.29045>; else goto <D.29046>;
    <D.29045>:
    D.29047 = mono_class_get_cctor (klass);
    D.28982 = depth + 1;
    add_extra_method_with_depth (acfg, D.29047, D.28982);
    <D.29046>:
    <D.29043>:
    <D.29039>:
    goto <D.25001>;
  }
  <D.25006>:
  goto <D.25001>;
  <D.25001>:
  patch_info = patch_info->next;
  <D.25008>:
  if (patch_info != 0B) goto <D.25007>; else goto <D.25009>;
  <D.25009>:
  <D.28960>:
  <D.28958>:
  patch_info = cfg->patch_info;
  goto <D.25017>;
  <D.25016>:
  D.28908 = patch_info->type;
  switch (D.28908) <default: <D.25015>, case 12: <D.25014>, case 27: <D.25010>, case 42: <D.25012>, case 51: <D.25011>>
  <D.25010>:
  <D.25011>:
  <D.25012>:
  goto <D.25013>;
  <D.25014>:
  D.29048 = patch_info->data.image;
  D.29049 = acfg->image;
  if (D.29048 != D.29049) goto <D.29050>; else goto <D.29051>;
  <D.29050>:
  cfg->has_got_slots = 1;
  <D.29051>:
  goto <D.25013>;
  <D.25015>:
  D.29052 = is_plt_patch (patch_info);
  if (D.29052 == 0) goto <D.29053>; else goto <D.29054>;
  <D.29053>:
  cfg->has_got_slots = 1;
  <D.29054>:
  goto <D.25013>;
  <D.25013>:
  patch_info = patch_info->next;
  <D.25017>:
  if (patch_info != 0B) goto <D.25016>; else goto <D.25018>;
  <D.25018>:
  D.29055 = BIT_FIELD_REF <*cfg, 32, 3424>;
  D.29056 = D.29055 & 1;
  if (D.29056 == 0) goto <D.29057>; else goto <D.29058>;
  <D.29057>:
  D.29059 = &acfg->stats.methods_without_got_slots;
  InterlockedIncrement (D.29059);
  <D.29058>:
  {
    struct MonoJumpInfo * patches;
    struct MonoJumpInfo * patches_end;

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

      D.29060 = acfg->mempool;
      new_patch_info = mono_patch_info_dup_mp (D.29060, patch_info);
      if (patches == 0B) goto <D.29061>; else goto <D.29062>;
      <D.29061>:
      patches = new_patch_info;
      goto <D.29063>;
      <D.29062>:
      patches_end->next = new_patch_info;
      <D.29063>:
      patches_end = new_patch_info;
    }
    patch_info = patch_info->next;
    <D.25023>:
    if (patch_info != 0B) goto <D.25022>; else goto <D.25024>;
    <D.25024>:
    cfg->patch_info = patches;
  }
  {
    struct GSList * l;
    struct GSList * unwind_ops;
    struct MonoUnwindOp * op;

    unwind_ops = 0B;
    l = cfg->unwind_ops;
    goto <D.25029>;
    <D.25028>:
    D.29060 = acfg->mempool;
    op = mono_mempool_alloc (D.29060, 12);
    D.29064 = l->data;
    memcpy (op, D.29064, 12);
    D.29060 = acfg->mempool;
    unwind_ops = g_slist_prepend_mempool (D.29060, unwind_ops, op);
    l = l->next;
    <D.25029>:
    if (l != 0B) goto <D.25028>; else goto <D.25030>;
    <D.25030>:
    D.29065 = monoeg_g_slist_reverse (unwind_ops);
    cfg->unwind_ops = D.29065;
  }
  {
    struct MonoInst * * args;
    struct MonoInst * * locals;
    struct MonoMethodSignature * sig;
    struct MonoMethodHeader * header;
    int i;

    sig = mono_method_signature (method);
    D.29060 = acfg->mempool;
    D.29066 = sig->param_count;
    D.29067 = (int) D.29066;
    D.29068 = sig->hasthis;
    D.29069 = (int) D.29068;
    D.29070 = D.29067 + D.29069;
    D.29071 = (unsigned int) D.29070;
    D.29072 = D.29071 * 4;
    args = mono_mempool_alloc (D.29060, D.29072);
    i = 0;
    goto <D.25037>;
    <D.25036>:
    i.132 = (unsigned int) i;
    D.29074 = i.132 * 4;
    D.29075 = args + D.29074;
    D.29060 = acfg->mempool;
    D.29076 = mono_mempool_alloc (D.29060, 56);
    *D.29075 = D.29076;
    i.132 = (unsigned int) i;
    D.29074 = i.132 * 4;
    D.29075 = args + D.29074;
    D.29077 = *D.29075;
    D.29078 = cfg->args;
    i.132 = (unsigned int) i;
    D.29074 = i.132 * 4;
    D.29079 = D.29078 + D.29074;
    D.29080 = *D.29079;
    memcpy (D.29077, D.29080, 56);
    i = i + 1;
    <D.25037>:
    D.29066 = sig->param_count;
    D.29067 = (int) D.29066;
    D.29068 = sig->hasthis;
    D.29069 = (int) D.29068;
    D.29070 = D.29067 + D.29069;
    if (D.29070 > i) goto <D.25036>; else goto <D.25038>;
    <D.25038>:
    cfg->args = args;
    header = mono_method_get_header (method);
    D.29060 = acfg->mempool;
    D.29081 = header->num_locals;
    D.29082 = (unsigned int) D.29081;
    D.29083 = D.29082 * 4;
    locals = mono_mempool_alloc (D.29060, D.29083);
    i = 0;
    goto <D.25040>;
    <D.25039>:
    i.132 = (unsigned int) i;
    D.29074 = i.132 * 4;
    D.29084 = locals + D.29074;
    D.29060 = acfg->mempool;
    D.29085 = mono_mempool_alloc (D.29060, 56);
    *D.29084 = D.29085;
    i.132 = (unsigned int) i;
    D.29074 = i.132 * 4;
    D.29084 = locals + D.29074;
    D.29086 = *D.29084;
    D.29087 = cfg->locals;
    i.132 = (unsigned int) i;
    D.29074 = i.132 * 4;
    D.29088 = D.29087 + D.29074;
    D.29089 = *D.29088;
    memcpy (D.29086, D.29089, 56);
    i = i + 1;
    <D.25040>:
    D.29081 = header->num_locals;
    D.29090 = (int) D.29081;
    if (D.29090 > i) goto <D.25039>; else goto <D.25041>;
    <D.25041>:
    cfg->locals = locals;
  }
  D.29091 = cfg->mempool;
  mono_mempool_destroy (D.29091);
  cfg->mempool = 0B;
  D.29092 = cfg->varinfo;
  monoeg_g_free (D.29092);
  cfg->varinfo = 0B;
  D.29093 = cfg->vars;
  monoeg_g_free (D.29093);
  cfg->vars = 0B;
  D.29094 = cfg->rs;
  if (D.29094 != 0B) goto <D.29095>; else goto <D.29096>;
  <D.29095>:
  D.29094 = cfg->rs;
  mono_regstate_free (D.29094);
  cfg->rs = 0B;
  <D.29096>:
  goto <D.25045>;
  <D.25044>:
  {
    struct MonoCompile * * new_cfgs;
    int new_size;

    D.29097 = acfg->cfgs_size;
    new_size = D.29097 * 2;
    new_size.133 = (unsigned int) new_size;
    D.29099 = new_size.133 * 4;
    new_cfgs = monoeg_malloc0 (D.29099);
    D.29100 = acfg->cfgs;
    D.29097 = acfg->cfgs_size;
    D.29101 = (unsigned int) D.29097;
    D.29102 = D.29101 * 4;
    memcpy (new_cfgs, D.29100, D.29102);
    D.29100 = acfg->cfgs;
    monoeg_g_free (D.29100);
    acfg->cfgs = new_cfgs;
    acfg->cfgs_size = new_size;
  }
  <D.25045>:
  D.29097 = acfg->cfgs_size;
  if (D.29097 <= index) goto <D.25044>; else goto <D.25046>;
  <D.25046>:
  D.29100 = acfg->cfgs;
  index.134 = (unsigned int) index;
  D.29104 = index.134 * 4;
  D.29105 = D.29100 + D.29104;
  *D.29105 = cfg;
  D.29106 = acfg->method_to_cfg;
  D.29107 = cfg->orig_method;
  monoeg_g_hash_table_insert_replace (D.29106, D.29107, cfg, 0);
  {
    int ret;

    D.28832 = &acfg->mutex.mutex;
    ret = pthread_mutex_unlock (D.28832);
    if (ret != 0) goto <D.29108>; else goto <D.29109>;
    <D.29108>:
    monoeg_g_log (0B, 16, "Bad call to mono_mutex_unlock result %d", ret);
    <D.29109>:
    D.29110 = ret != 0;
    D.29111 = (long int) D.29110;
    D.29112 = __builtin_expect (D.29111, 0);
    if (D.29112 != 0) goto <D.29113>; else goto <D.29114>;
    <D.29113>:
    monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "aot-compiler.c", 6745, "ret == 0");
    <D.29114>:
  }
  D.29115 = &acfg->stats.ccount;
  InterlockedIncrement (D.29115);
}


add_token_info_hash (void * key, void * value, void * user_data)
{
  struct MonoImage * D.29121;
  unsigned int D.29122;
  struct GHashTable * D.29123;
  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.29121 = ji->image;
  new_ji->image = D.29121;
  D.29122 = ji->token;
  new_ji->token = D.29122;
  D.29123 = acfg->token_info_hash;
  monoeg_g_hash_table_insert_replace (D.29123, method, new_ji, 0);
}


method_has_type_vars (struct MonoMethod * method)
{
  struct MonoClass * D.29124;
  int D.29125;
  gboolean D.29128;
  unsigned int D.29129;
  unsigned int D.29130;
  struct MonoGenericInst * D.29133;
  struct MonoType * D.29136;
  struct MonoClass * D.29137;
  int D.29138;
  <unnamed-unsigned:22> D.29141;
  int D.29142;

  D.29124 = method->klass;
  D.29125 = has_type_vars (D.29124);
  if (D.29125 != 0) goto <D.29126>; else goto <D.29127>;
  <D.29126>:
  D.29128 = 1;
  return D.29128;
  <D.29127>:
  D.29129 = BIT_FIELD_REF <*method, 32, 160>;
  D.29130 = D.29129 & 4096;
  if (D.29130 != 0) goto <D.29131>; else goto <D.29132>;
  <D.29131>:
  {
    struct MonoGenericContext * context;

    context = mono_method_get_context (method);
    D.29133 = context->method_inst;
    if (D.29133 != 0B) goto <D.29134>; else goto <D.29135>;
    <D.29134>:
    {
      int i;

      i = 0;
      goto <D.23995>;
      <D.23994>:
      D.29133 = context->method_inst;
      D.29136 = D.29133->type_argv[i];
      D.29137 = mono_class_from_mono_type (D.29136);
      D.29138 = has_type_vars (D.29137);
      if (D.29138 != 0) goto <D.29139>; else goto <D.29140>;
      <D.29139>:
      D.29128 = 1;
      return D.29128;
      <D.29140>:
      i = i + 1;
      <D.23995>:
      D.29133 = context->method_inst;
      D.29141 = D.29133->type_argc;
      D.29142 = (int) D.29141;
      if (D.29142 > i) goto <D.23994>; else goto <D.23996>;
      <D.23996>:
    }
    <D.29135>:
  }
  <D.29132>:
  D.29128 = 0;
  return D.29128;
}


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

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


InterlockedIncrement (volatile gint32 * val)
{
  gint32 D.29146;
  unsigned int D.29147;

  D.29147 = __sync_add_and_fetch_4 (val, 1);
  D.29146 = (gint32) D.29147;
  return D.29146;
}


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

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


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

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


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

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


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

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


emit_code (struct MonoAotCompile * acfg)
{
  int D.29153;
  struct MonoCompile * * D.29156;
  unsigned int i.135;
  unsigned int D.29158;
  struct MonoCompile * * D.29159;
  struct MonoCompile * D.29160;
  unsigned int D.29163;
  unsigned int D.29164;
  char * D.29167;
  gchar * D.29168;
  unsigned int i.136;
  unsigned int D.29170;
  char * D.29171;
  gchar * D.29174;
  struct GPtrArray * D.29175;
  void * * D.29176;
  unsigned int oindex.137;
  unsigned int D.29178;
  void * * D.29179;
  void * D.29180;
  int D.29183;
  struct MonoMethod * D.29186;
  struct MonoClass * D.29187;
  unsigned int D.29188;
  unsigned int D.29189;
  unsigned int D.29192;
  int D.29193;
  unsigned int D.29196;
  unsigned int D.29197;
  struct FILE * D.29200;
  char * D.29201;
  int D.29208;
  int D.29209;
  unsigned int oindex.138;
  unsigned int D.29212;
  int D.29215;
  int D.29222;
  unsigned int D.29223;
  unsigned int D.29224;
  unsigned int D.29225;
  int D.29226;
  int D.29230;
  struct MonoMethod * D.29238;
  struct MonoClass * D.29239;
  unsigned int D.29240;
  unsigned int D.29241;
  unsigned int D.29244;
  unsigned int D.29250;
  unsigned int D.29251;
  _Bool D.29254;
  long int D.29255;
  long int D.29256;
  int oindex;
  int i;
  int prev_index;
  char symbol[256];

  try
    {
      emit_section_change (acfg, ".text", 0);
      emit_alignment (acfg, 8);
      D.29153 = acfg->llvm;
      if (D.29153 != 0) goto <D.29154>; else goto <D.29155>;
      <D.29154>:
      i = 0;
      goto <D.25131>;
      <D.25130>:
      D.29156 = acfg->cfgs;
      i.135 = (unsigned int) i;
      D.29158 = i.135 * 4;
      D.29159 = D.29156 + D.29158;
      D.29160 = *D.29159;
      if (D.29160 != 0B) goto <D.29161>; else goto <D.29162>;
      <D.29161>:
      D.29156 = acfg->cfgs;
      i.135 = (unsigned int) i;
      D.29158 = i.135 * 4;
      D.29159 = D.29156 + D.29158;
      D.29160 = *D.29159;
      D.29163 = BIT_FIELD_REF <*D.29160, 32, 3392>;
      D.29164 = D.29163 & 256;
      if (D.29164 != 0) goto <D.29165>; else goto <D.29166>;
      <D.29165>:
      D.29156 = acfg->cfgs;
      i.135 = (unsigned int) i;
      D.29158 = i.135 * 4;
      D.29159 = D.29156 + D.29158;
      D.29160 = *D.29159;
      D.29167 = D.29160->asm_symbol;
      D.29168 = monoeg_strdup (D.29167);
      acfg->methods_symbol = D.29168;
      goto <D.25129>;
      <D.29166>:
      <D.29162>:
      i = i + 1;
      <D.25131>:
      i.136 = (unsigned int) i;
      D.29170 = acfg->nmethods;
      if (i.136 < D.29170) goto <D.25130>; else goto <D.25129>;
      <D.25129>:
      <D.29155>:
      D.29171 = acfg->methods_symbol;
      if (D.29171 == 0B) goto <D.29172>; else goto <D.29173>;
      <D.29172>:
      sprintf (&symbol, "methods");
      emit_label (acfg, &symbol);
      D.29174 = monoeg_strdup (&symbol);
      acfg->methods_symbol = D.29174;
      <D.29173>:
      emit_zero_bytes (acfg, 16);
      oindex = 0;
      goto <D.25136>;
      <D.25135>:
      {
        struct MonoCompile * cfg;
        struct MonoMethod * method;

        D.29175 = acfg->method_order;
        D.29176 = D.29175->pdata;
        oindex.137 = (unsigned int) oindex;
        D.29178 = oindex.137 * 4;
        D.29179 = D.29176 + D.29178;
        D.29180 = *D.29179;
        i = (int) D.29180;
        D.29156 = acfg->cfgs;
        i.135 = (unsigned int) i;
        D.29158 = i.135 * 4;
        D.29159 = D.29156 + D.29158;
        cfg = *D.29159;
        if (cfg == 0B) goto <D.29181>; else goto <D.29182>;
        <D.29181>:
        // predicted unlikely by continue predictor.
        goto <D.25134>;
        <D.29182>:
        method = cfg->orig_method;
        D.29183 = acfg->aot_opts.full_aot;
        if (D.29183 != 0) goto <D.29184>; else goto <D.29185>;
        <D.29184>:
        D.29186 = cfg->orig_method;
        D.29187 = D.29186->klass;
        D.29188 = BIT_FIELD_REF <*D.29187, 32, 160>;
        D.29189 = D.29188 & 8;
        if (D.29189 != 0) goto <D.29190>; else goto <D.29191>;
        <D.29190>:
        D.29192 = get_method_index (acfg, method);
        sprintf (&symbol, "ut_%d", D.29192);
        emit_section_change (acfg, ".text", 0);
        D.29193 = acfg->thumb_mixed;
        if (D.29193 != 0) goto <D.29194>; else goto <D.29195>;
        <D.29194>:
        D.29196 = BIT_FIELD_REF <*cfg, 32, 3392>;
        D.29197 = D.29196 & 256;
        if (D.29197 != 0) goto <D.29198>; else goto <D.29199>;
        <D.29198>:
        emit_set_thumb_mode (acfg);
        D.29200 = acfg->fp;
        fprintf (D.29200, "\n.thumb_func\n");
        <D.29199>:
        <D.29195>:
        emit_label (acfg, &symbol);
        D.29186 = cfg->orig_method;
        D.29201 = cfg->asm_symbol;
        arch_emit_unbox_trampoline (acfg, cfg, D.29186, D.29201);
        D.29193 = acfg->thumb_mixed;
        if (D.29193 != 0) goto <D.29202>; else goto <D.29203>;
        <D.29202>:
        D.29196 = BIT_FIELD_REF <*cfg, 32, 3392>;
        D.29197 = D.29196 & 256;
        if (D.29197 != 0) goto <D.29204>; else goto <D.29205>;
        <D.29204>:
        emit_set_arm_mode (acfg);
        <D.29205>:
        <D.29203>:
        <D.29191>:
        <D.29185>:
        D.29196 = BIT_FIELD_REF <*cfg, 32, 3392>;
        D.29197 = D.29196 & 256;
        if (D.29197 != 0) goto <D.29206>; else goto <D.29207>;
        <D.29206>:
        D.29208 = acfg->stats.llvm_count;
        D.29209 = D.29208 + 1;
        acfg->stats.llvm_count = D.29209;
        goto <D.29210>;
        <D.29207>:
        emit_method_code (acfg, cfg);
        <D.29210>:
      }
      <D.25134>:
      oindex = oindex + 1;
      <D.25136>:
      oindex.138 = (unsigned int) oindex;
      D.29175 = acfg->method_order;
      D.29212 = D.29175->len;
      if (oindex.138 < D.29212) goto <D.25135>; else goto <D.25137>;
      <D.25137>:
      sprintf (&symbol, "methods_end");
      emit_section_change (acfg, ".text", 0);
      emit_alignment (acfg, 8);
      emit_label (acfg, &symbol);
      emit_int32 (acfg, 0);
      D.29153 = acfg->llvm;
      if (D.29153 != 0) goto <D.29213>; else goto <D.29214>;
      <D.29213>:
      D.29215 = acfg->need_no_dead_strip;
      if (D.29215 != 0) goto <D.29216>; else goto <D.29217>;
      <D.29216>:
      D.29200 = acfg->fp;
      fprintf (D.29200, "\n");
      i = 0;
      goto <D.25139>;
      <D.25138>:
      D.29156 = acfg->cfgs;
      i.135 = (unsigned int) i;
      D.29158 = i.135 * 4;
      D.29159 = D.29156 + D.29158;
      D.29160 = *D.29159;
      if (D.29160 != 0B) goto <D.29218>; else goto <D.29219>;
      <D.29218>:
      D.29156 = acfg->cfgs;
      i.135 = (unsigned int) i;
      D.29158 = i.135 * 4;
      D.29159 = D.29156 + D.29158;
      D.29160 = *D.29159;
      D.29163 = BIT_FIELD_REF <*D.29160, 32, 3392>;
      D.29164 = D.29163 & 256;
      if (D.29164 != 0) goto <D.29220>; else goto <D.29221>;
      <D.29220>:
      D.29200 = acfg->fp;
      D.29156 = acfg->cfgs;
      i.135 = (unsigned int) i;
      D.29158 = i.135 * 4;
      D.29159 = D.29156 + D.29158;
      D.29160 = *D.29159;
      D.29167 = D.29160->asm_symbol;
      fprintf (D.29200, ".no_dead_strip %s\n", D.29167);
      <D.29221>:
      <D.29219>:
      i = i + 1;
      <D.25139>:
      i.136 = (unsigned int) i;
      D.29170 = acfg->nmethods;
      if (i.136 < D.29170) goto <D.25138>; else goto <D.25140>;
      <D.25140>:
      <D.29217>:
      <D.29214>:
      sprintf (&symbol, "code_offsets");
      emit_section_change (acfg, ".rodata", 1);
      emit_alignment (acfg, 8);
      emit_label (acfg, &symbol);
      D.29222 = acfg->stats.offsets_size;
      D.29223 = (unsigned int) D.29222;
      D.29170 = acfg->nmethods;
      D.29224 = D.29170 * 4;
      D.29225 = D.29223 + D.29224;
      D.29226 = (int) D.29225;
      acfg->stats.offsets_size = D.29226;
      i = 0;
      goto <D.25142>;
      <D.25141>:
      D.29156 = acfg->cfgs;
      i.135 = (unsigned int) i;
      D.29158 = i.135 * 4;
      D.29159 = D.29156 + D.29158;
      D.29160 = *D.29159;
      if (D.29160 != 0B) goto <D.29227>; else goto <D.29228>;
      <D.29227>:
      D.29156 = acfg->cfgs;
      i.135 = (unsigned int) i;
      D.29158 = i.135 * 4;
      D.29159 = D.29156 + D.29158;
      D.29160 = *D.29159;
      D.29167 = D.29160->asm_symbol;
      D.29171 = acfg->methods_symbol;
      emit_symbol_diff (acfg, D.29167, D.29171, 0);
      goto <D.29229>;
      <D.29228>:
      emit_int32 (acfg, -1);
      <D.29229>:
      i = i + 1;
      <D.25142>:
      i.136 = (unsigned int) i;
      D.29170 = acfg->nmethods;
      if (i.136 < D.29170) goto <D.25141>; else goto <D.25143>;
      <D.25143>:
      emit_line (acfg);
      sprintf (&symbol, "unbox_trampolines");
      D.29230 = acfg->direct_method_addresses;
      if (D.29230 != 0) goto <D.29231>; else goto <D.29232>;
      <D.29231>:
      emit_section_change (acfg, ".text", 0);
      goto <D.29233>;
      <D.29232>:
      emit_section_change (acfg, ".rodata", 0);
      <D.29233>:
      emit_alignment (acfg, 8);
      emit_label (acfg, &symbol);
      prev_index = -1;
      i = 0;
      goto <D.25149>;
      <D.25148>:
      {
        struct MonoCompile * cfg;
        struct MonoMethod * method;
        int index;

        D.29156 = acfg->cfgs;
        i.135 = (unsigned int) i;
        D.29158 = i.135 * 4;
        D.29159 = D.29156 + D.29158;
        cfg = *D.29159;
        if (cfg == 0B) goto <D.29234>; else goto <D.29235>;
        <D.29234>:
        // predicted unlikely by continue predictor.
        goto <D.25147>;
        <D.29235>:
        method = cfg->orig_method;
        D.29183 = acfg->aot_opts.full_aot;
        if (D.29183 != 0) goto <D.29236>; else goto <D.29237>;
        <D.29236>:
        D.29238 = cfg->orig_method;
        D.29239 = D.29238->klass;
        D.29240 = BIT_FIELD_REF <*D.29239, 32, 160>;
        D.29241 = D.29240 & 8;
        if (D.29241 != 0) goto <D.29242>; else goto <D.29243>;
        <D.29242>:
        D.29244 = get_method_index (acfg, method);
        index = (int) D.29244;
        sprintf (&symbol, "ut_%d", index);
        emit_int32 (acfg, index);
        D.29230 = acfg->direct_method_addresses;
        if (D.29230 != 0) goto <D.29245>; else goto <D.29246>;
        <D.29245>:
        emit_unset_mode (acfg);
        D.29193 = acfg->thumb_mixed;
        if (D.29193 != 0) goto <D.29249>; else goto <D.29247>;
        <D.29249>:
        D.29250 = BIT_FIELD_REF <*cfg, 32, 3392>;
        D.29251 = D.29250 & 256;
        if (D.29251 != 0) goto <D.29252>; else goto <D.29247>;
        <D.29252>:
        D.29200 = acfg->fp;
        fprintf (D.29200, "\n\tblx %s\n", &symbol);
        goto <D.29248>;
        <D.29247>:
        D.29200 = acfg->fp;
        fprintf (D.29200, "\n\tbl %s\n", &symbol);
        <D.29248>:
        goto <D.29253>;
        <D.29246>:
        D.29171 = acfg->methods_symbol;
        emit_symbol_diff (acfg, &symbol, D.29171, 0);
        <D.29253>:
        D.29254 = index <= prev_index;
        D.29255 = (long int) D.29254;
        D.29256 = __builtin_expect (D.29255, 0);
        if (D.29256 != 0) goto <D.29257>; else goto <D.29258>;
        <D.29257>:
        monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "aot-compiler.c", 7246, "index > prev_index");
        <D.29258>:
        prev_index = index;
        <D.29243>:
        <D.29237>:
      }
      <D.25147>:
      i = i + 1;
      <D.25149>:
      i.136 = (unsigned int) i;
      D.29170 = acfg->nmethods;
      if (i.136 < D.29170) goto <D.25148>; else goto <D.25150>;
      <D.25150>:
      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.29259;

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


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


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

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


emit_method_code (struct MonoAotCompile * acfg, struct MonoCompile * cfg)
{
  unsigned int D.29261;
  const char * D.29262;
  int D.29263;
  int D.29266;
  struct FILE * D.29269;
  char * D.29270;
  int D.29271;
  struct GHashTable * D.29276;
  struct GHashTable * D.29279;
  unsigned int D.29282;
  char * D.29285;
  int D.29286;
  unsigned int D.29287;
  unsigned int D.29288;
  unsigned int D.29289;
  int D.29290;
  struct MonoCompile * * D.29291;
  unsigned int method_index.139;
  unsigned int D.29293;
  struct MonoCompile * * D.29294;
  struct MonoCompile * D.29295;
  unsigned int D.29296;
  struct MonoJumpInfo * D.29297;
  struct MonoJitInfo * D.29298;
  struct MonoMethod * D.29299;
  struct MonoDomain * D.29300;
  struct MonoDebugMethodJitInfo * D.29301;
  struct MonoMethod * method;
  int method_index;
  guint8 * code;
  char * debug_sym;
  char * symbol;
  int func_alignment;
  struct MonoMethodHeader * header;
  char * export_name;

  debug_sym = 0B;
  symbol = 0B;
  func_alignment = 16;
  method = cfg->orig_method;
  code = cfg->native_code;
  header = cfg->header;
  D.29261 = get_method_index (acfg, method);
  method_index = (int) D.29261;
  D.29262 = acfg->temp_prefix;
  symbol = monoeg_g_strdup_printf ("%sme_%x", D.29262, method_index);
  emit_section_change (acfg, ".text", 0);
  emit_alignment (acfg, func_alignment);
  D.29263 = acfg->global_symbols;
  if (D.29263 != 0) goto <D.29264>; else goto <D.29265>;
  <D.29264>:
  D.29266 = acfg->need_no_dead_strip;
  if (D.29266 != 0) goto <D.29267>; else goto <D.29268>;
  <D.29267>:
  D.29269 = acfg->fp;
  D.29270 = cfg->asm_symbol;
  fprintf (D.29269, "\t.no_dead_strip %s\n", D.29270);
  <D.29268>:
  <D.29265>:
  D.29270 = cfg->asm_symbol;
  emit_label (acfg, D.29270);
  D.29271 = acfg->aot_opts.write_symbols;
  if (D.29271 != 0) goto <D.29272>; else goto <D.29273>;
  <D.29272>:
  D.29263 = acfg->global_symbols;
  if (D.29263 == 0) goto <D.29274>; else goto <D.29275>;
  <D.29274>:
  D.29276 = acfg->method_label_hash;
  debug_sym = get_debug_sym (method, "", D.29276);
  D.29266 = acfg->need_no_dead_strip;
  if (D.29266 != 0) goto <D.29277>; else goto <D.29278>;
  <D.29277>:
  D.29269 = acfg->fp;
  fprintf (D.29269, "\t.no_dead_strip %s\n", debug_sym);
  <D.29278>:
  emit_local_symbol (acfg, debug_sym, symbol, 1);
  emit_label (acfg, debug_sym);
  <D.29275>:
  <D.29273>:
  D.29279 = acfg->export_names;
  export_name = monoeg_g_hash_table_lookup (D.29279, method);
  if (export_name != 0B) goto <D.29280>; else goto <D.29281>;
  <D.29280>:
  emit_global_inner (acfg, export_name, 1);
  emit_label (acfg, export_name);
  <D.29281>:
  D.29282 = cfg->verbose_level;
  if (D.29282 != 0) goto <D.29283>; else goto <D.29284>;
  <D.29283>:
  D.29285 = mono_method_full_name (method, 1);
  D.29270 = cfg->asm_symbol;
  monoeg_g_print ("Method %s emitted as %s\n", D.29285, D.29270);
  <D.29284>:
  D.29286 = acfg->stats.code_size;
  D.29287 = (unsigned int) D.29286;
  D.29288 = cfg->code_len;
  D.29289 = D.29287 + D.29288;
  D.29290 = (int) D.29289;
  acfg->stats.code_size = D.29290;
  D.29291 = acfg->cfgs;
  method_index.139 = (unsigned int) method_index;
  D.29293 = method_index.139 * 4;
  D.29294 = D.29291 + D.29293;
  D.29295 = *D.29294;
  D.29296 = acfg->got_offset;
  D.29295->got_offset = D.29296;
  D.29288 = cfg->code_len;
  D.29297 = cfg->patch_info;
  D.29298 = cfg->jit_info;
  D.29299 = D.29298->d.method;
  D.29300 = mono_domain_get ();
  D.29301 = mono_debug_find_method (D.29299, D.29300);
  emit_and_reloc_code (acfg, method, code, D.29288, D.29297, 0, D.29301);
  emit_line (acfg);
  D.29271 = acfg->aot_opts.write_symbols;
  if (D.29271 != 0) goto <D.29302>; else goto <D.29303>;
  <D.29302>:
  emit_symbol_size (acfg, debug_sym, ".");
  monoeg_g_free (debug_sym);
  <D.29303>:
  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.29304;

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


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

  D.29305 = acfg->w;
  img_writer_emit_global (D.29305, 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.29308;
  int D.29309;
  int code_len.140;
  struct FILE * D.29319;
  void * * D.29320;
  unsigned int pindex.141;
  unsigned int D.29322;
  void * * D.29323;
  int D.29324;
  unsigned int pindex.142;
  unsigned int D.29327;
  unsigned int i.143;
  unsigned int D.29331;
  struct MonoDebugSourceLocation * * D.29332;
  struct MonoDebugSourceLocation * D.29333;
  char * D.29336;
  unsigned int D.29337;
  unsigned int limit.144;
  unsigned int D.29348;
  struct MonoDebugSourceLocation * * D.29349;
  struct MonoDebugSourceLocation * D.29350;
  sizetype i.145;
  const guint8 * D.29353;
  int D.29354;
  unsigned int i.146;
  int i;
  int pindex;
  int start_index;
  int method_index;
  struct GPtrArray * patches;
  struct MonoJumpInfo * patch_info;
  struct MonoMethodHeader * header;
  struct MonoDebugSourceLocation * * locs;
  gboolean skip;

  locs = 0B;
  if (method != 0B) goto <D.29306>; else goto <D.29307>;
  <D.29306>:
  header = mono_method_get_header (method);
  D.29308 = get_method_index (acfg, method);
  method_index = (int) D.29308;
  <D.29307>:
  D.29309 = acfg->gas_line_numbers;
  if (D.29309 != 0) goto <D.29310>; else goto <D.29311>;
  <D.29310>:
  if (method != 0B) goto <D.29312>; else goto <D.29313>;
  <D.29312>:
  if (debug_info != 0B) goto <D.29314>; else goto <D.29315>;
  <D.29314>:
  code_len.140 = (int) code_len;
  locs = compute_line_numbers (method, code_len.140, debug_info);
  if (locs == 0B) goto <D.29317>; else goto <D.29318>;
  <D.29317>:
  {
    int findex;

    findex = get_file_index (acfg, "<unknown>");
    emit_unset_mode (acfg);
    D.29319 = acfg->fp;
    fprintf (D.29319, ".loc %d %d 0\n", findex, 1);
  }
  <D.29318>:
  <D.29315>:
  <D.29313>:
  <D.29311>:
  patches = monoeg_g_ptr_array_new ();
  patch_info = relocs;
  goto <D.24401>;
  <D.24400>:
  monoeg_g_ptr_array_add (patches, patch_info);
  patch_info = patch_info->next;
  <D.24401>:
  if (patch_info != 0B) goto <D.24400>; else goto <D.24402>;
  <D.24402>:
  monoeg_g_ptr_array_sort (patches, compare_patches);
  start_index = 0;
  i = 0;
  goto <D.24416>;
  <D.24415>:
  patch_info = 0B;
  pindex = start_index;
  goto <D.24405>;
  <D.24404>:
  D.29320 = patches->pdata;
  pindex.141 = (unsigned int) pindex;
  D.29322 = pindex.141 * 4;
  D.29323 = D.29320 + D.29322;
  patch_info = *D.29323;
  D.29324 = patch_info->ip.i;
  if (D.29324 >= i) goto <D.24403>; else goto <D.29325>;
  <D.29325>:
  pindex = pindex + 1;
  <D.24405>:
  pindex.142 = (unsigned int) pindex;
  D.29327 = patches->len;
  if (pindex.142 < D.29327) goto <D.24404>; else goto <D.24403>;
  <D.24403>:
  if (locs != 0B) goto <D.29328>; else goto <D.29329>;
  <D.29328>:
  i.143 = (unsigned int) i;
  D.29331 = i.143 * 4;
  D.29332 = locs + D.29331;
  D.29333 = *D.29332;
  if (D.29333 != 0B) goto <D.29334>; else goto <D.29335>;
  <D.29334>:
  {
    struct MonoDebugSourceLocation * loc;
    int findex;

    i.143 = (unsigned int) i;
    D.29331 = i.143 * 4;
    D.29332 = locs + D.29331;
    loc = *D.29332;
    D.29336 = loc->source_file;
    findex = get_file_index (acfg, D.29336);
    emit_unset_mode (acfg);
    D.29319 = acfg->fp;
    D.29337 = loc->row;
    fprintf (D.29319, ".loc %d %d 0\n", findex, D.29337);
    mono_debug_symfile_free_location (loc);
  }
  <D.29335>:
  <D.29329>:
  skip = 0;
  if (skip == 0) goto <D.29338>; else goto <D.29339>;
  <D.29338>:
  patch_info = 0B;
  pindex = start_index;
  goto <D.24410>;
  <D.24409>:
  D.29320 = patches->pdata;
  pindex.141 = (unsigned int) pindex;
  D.29322 = pindex.141 * 4;
  D.29323 = D.29320 + D.29322;
  patch_info = *D.29323;
  D.29324 = patch_info->ip.i;
  if (D.29324 >= i) goto <D.24408>; else goto <D.29340>;
  <D.29340>:
  pindex = pindex + 1;
  <D.24410>:
  pindex.142 = (unsigned int) pindex;
  D.29327 = patches->len;
  if (pindex.142 < D.29327) goto <D.24409>; else goto <D.24408>;
  <D.24408>:
  pindex.142 = (unsigned int) pindex;
  D.29327 = patches->len;
  if (pindex.142 < D.29327) goto <D.29343>; else goto <D.29341>;
  <D.29343>:
  D.29324 = patch_info->ip.i;
  if (D.29324 > i) goto <D.29344>; else goto <D.29341>;
  <D.29344>:
  {
    int limit;

    limit = i + 1;
    goto <D.24414>;
    <D.24413>:
    if (locs != 0B) goto <D.29345>; else goto <D.29346>;
    <D.29345>:
    limit.144 = (unsigned int) limit;
    D.29348 = limit.144 * 4;
    D.29349 = locs + D.29348;
    D.29350 = *D.29349;
    if (D.29350 != 0B) goto <D.24412>; else goto <D.29351>;
    <D.29351>:
    <D.29346>:
    limit = limit + 1;
    <D.24414>:
    D.29324 = patch_info->ip.i;
    if (D.29324 > limit) goto <D.24413>; else goto <D.24412>;
    <D.24412>:
    i.145 = (sizetype) i;
    D.29353 = code + i.145;
    D.29354 = limit - i;
    emit_bytes (acfg, D.29353, D.29354);
    i = limit + -1;
  }
  goto <D.29342>;
  <D.29341>:
  i.145 = (sizetype) i;
  D.29353 = code + i.145;
  emit_bytes (acfg, D.29353, 1);
  <D.29342>:
  <D.29339>:
  i = i + 1;
  <D.24416>:
  i.146 = (unsigned int) i;
  if (i.146 < code_len) goto <D.24415>; else goto <D.24417>;
  <D.24417>:
  monoeg_g_free (locs);
}


compare_patches (const void * a, const void * b)
{
  struct MonoJumpInfo * D.29356;
  struct MonoJumpInfo * D.29357;
  gint D.29360;
  int i;
  int j;

  D.29356 = MEM[(struct MonoJumpInfo * *)a];
  i = D.29356->ip.i;
  D.29357 = MEM[(struct MonoJumpInfo * *)b];
  j = D.29357->ip.i;
  if (i < j) goto <D.29358>; else goto <D.29359>;
  <D.29358>:
  D.29360 = -1;
  return D.29360;
  <D.29359>:
  if (i > j) goto <D.29361>; else goto <D.29362>;
  <D.29361>:
  D.29360 = 1;
  return D.29360;
  <D.29362>:
  D.29360 = 0;
  return D.29360;
}


compute_line_numbers (struct MonoMethod * method, int code_size, struct MonoDebugMethodJitInfo * debug_info)
{
  struct MonoDebugSourceLocation * * D.29366;
  unsigned int D.29367;
  unsigned int code_size.147;
  _Bool D.29371;
  long int D.29372;
  long int D.29373;
  unsigned int D.29376;
  unsigned int D.29377;
  struct MonoDebugLineNumberEntry * D.29378;
  unsigned int D.29379;
  int D.29380;
  unsigned int D.29381;
  unsigned int D.29382;
  unsigned int i.148;
  unsigned int D.29384;
  unsigned int j.149;
  unsigned int D.29388;
  int * D.29389;
  unsigned int j.150;
  unsigned int D.29391;
  unsigned int i.151;
  unsigned int D.29393;
  sizetype i.152;
  sizetype D.29397;
  sizetype D.29398;
  unsigned int D.29399;
  int D.29400;
  unsigned int D.29401;
  unsigned int code_size.153;
  unsigned int D.29404;
  unsigned int D.29405;
  int * D.29406;
  unsigned int il_offset.154;
  char * D.29414;
  unsigned int D.29415;
  unsigned int prev_line.155;
  struct MonoDebugSourceLocation * * D.29422;
  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.29364>; else goto <D.29365>;
  <D.29364>:
  D.29366 = 0B;
  return D.29366;
  <D.29365>:
  D.29367 = debug_info->code_size;
  code_size.147 = (unsigned int) code_size;
  if (D.29367 != code_size.147) goto <D.29369>; else goto <D.29370>;
  <D.29369>:
  D.29366 = 0B;
  return D.29366;
  <D.29370>:
  D.29371 = code_size == 0;
  D.29372 = (long int) D.29371;
  D.29373 = __builtin_expect (D.29372, 0);
  if (D.29373 != 0) goto <D.29374>; else goto <D.29375>;
  <D.29374>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "aot-compiler.c", 4403, "code_size");
  <D.29375>:
  D.29376 = debug_info->num_line_numbers;
  D.29377 = D.29376 * 8;
  ln_array = monoeg_malloc0 (D.29377);
  D.29378 = debug_info->line_numbers;
  D.29376 = debug_info->num_line_numbers;
  D.29379 = D.29376 * 8;
  memcpy (ln_array, D.29378, D.29379);
  D.29376 = debug_info->num_line_numbers;
  qsort (ln_array, D.29376, 8, compare_lne);
  D.29380 = code_size + 1;
  D.29381 = (unsigned int) D.29380;
  D.29382 = D.29381 * 4;
  native_to_il_offset = monoeg_malloc0 (D.29382);
  i = 0;
  goto <D.24369>;
  <D.24368>:
  {
    int j;
    struct MonoDebugLineNumberEntry * lne;

    i.148 = (unsigned int) i;
    D.29384 = i.148 * 8;
    lne = ln_array + D.29384;
    if (i == 0) goto <D.29385>; else goto <D.29386>;
    <D.29385>:
    j = 0;
    goto <D.24359>;
    <D.24358>:
    j.149 = (unsigned int) j;
    D.29388 = j.149 * 4;
    D.29389 = native_to_il_offset + D.29388;
    *D.29389 = -1;
    j = j + 1;
    <D.24359>:
    j.150 = (unsigned int) j;
    D.29391 = lne->native_offset;
    if (j.150 < D.29391) goto <D.24358>; else goto <D.24360>;
    <D.24360>:
    <D.29386>:
    i.151 = (unsigned int) i;
    D.29376 = debug_info->num_line_numbers;
    D.29393 = D.29376 + 4294967295;
    if (i.151 < D.29393) goto <D.29394>; else goto <D.29395>;
    <D.29394>:
    {
      struct MonoDebugLineNumberEntry * lne_next;

      i.152 = (sizetype) i;
      D.29397 = i.152 + 1;
      D.29398 = D.29397 * 8;
      lne_next = ln_array + D.29398;
      D.29391 = lne->native_offset;
      j = (int) D.29391;
      goto <D.24363>;
      <D.24362>:
      j.149 = (unsigned int) j;
      D.29388 = j.149 * 4;
      D.29389 = native_to_il_offset + D.29388;
      D.29399 = lne->il_offset;
      D.29400 = (int) D.29399;
      *D.29389 = D.29400;
      j = j + 1;
      <D.24363>:
      j.150 = (unsigned int) j;
      D.29401 = lne_next->native_offset;
      if (j.150 < D.29401) goto <D.24362>; else goto <D.24364>;
      <D.24364>:
    }
    goto <D.29402>;
    <D.29395>:
    D.29391 = lne->native_offset;
    j = (int) D.29391;
    goto <D.24366>;
    <D.24365>:
    j.149 = (unsigned int) j;
    D.29388 = j.149 * 4;
    D.29389 = native_to_il_offset + D.29388;
    D.29399 = lne->il_offset;
    D.29400 = (int) D.29399;
    *D.29389 = D.29400;
    j = j + 1;
    <D.24366>:
    if (j < code_size) goto <D.24365>; else goto <D.24367>;
    <D.24367>:
    <D.29402>:
  }
  i = i + 1;
  <D.24369>:
  i.151 = (unsigned int) i;
  D.29376 = debug_info->num_line_numbers;
  if (i.151 < D.29376) goto <D.24368>; else goto <D.24370>;
  <D.24370>:
  monoeg_g_free (ln_array);
  code_size.153 = (unsigned int) code_size;
  D.29404 = code_size.153 * 4;
  res = monoeg_malloc0 (D.29404);
  prev_il_offset = -1;
  prev_line = -1;
  first = 1;
  i = 0;
  goto <D.24374>;
  <D.24373>:
  {
    int il_offset;

    i.148 = (unsigned int) i;
    D.29405 = i.148 * 4;
    D.29406 = native_to_il_offset + D.29405;
    il_offset = *D.29406;
    if (il_offset == -1) goto <D.29407>; else goto <D.29409>;
    <D.29409>:
    if (il_offset == prev_il_offset) goto <D.29407>; else goto <D.29408>;
    <D.29407>:
    // predicted unlikely by continue predictor.
    goto <D.24372>;
    <D.29408>:
    prev_il_offset = il_offset;
    il_offset.154 = (unsigned int) il_offset;
    loc = mono_debug_symfile_lookup_location (minfo, il_offset.154);
    if (loc == 0B) goto <D.29411>; else goto <D.29413>;
    <D.29413>:
    D.29414 = loc->source_file;
    if (D.29414 == 0B) goto <D.29411>; else goto <D.29412>;
    <D.29411>:
    // predicted unlikely by continue predictor.
    goto <D.24372>;
    <D.29412>:
    D.29415 = loc->row;
    prev_line.155 = (unsigned int) prev_line;
    if (D.29415 == prev_line.155) goto <D.29417>; else goto <D.29418>;
    <D.29417>:
    mono_debug_symfile_free_location (loc);
    // predicted unlikely by continue predictor.
    goto <D.24372>;
    <D.29418>:
    D.29415 = loc->row;
    prev_line = (int) D.29415;
    if (first != 0) goto <D.29419>; else goto <D.29420>;
    <D.29419>:
    *res = loc;
    goto <D.29421>;
    <D.29420>:
    i.148 = (unsigned int) i;
    D.29405 = i.148 * 4;
    D.29422 = res + D.29405;
    *D.29422 = loc;
    <D.29421>:
    first = 0;
  }
  <D.24372>:
  i = i + 1;
  <D.24374>:
  if (i < code_size) goto <D.24373>; else goto <D.24375>;
  <D.24375>:
  D.29366 = res;
  return D.29366;
}


compare_lne (struct MonoDebugLineNumberEntry * a, struct MonoDebugLineNumberEntry * b)
{
  unsigned int D.29424;
  unsigned int D.29425;
  gint D.29428;
  unsigned int D.29429;
  unsigned int D.29430;
  unsigned int D.29431;
  unsigned int D.29432;

  D.29424 = a->native_offset;
  D.29425 = b->native_offset;
  if (D.29424 == D.29425) goto <D.29426>; else goto <D.29427>;
  <D.29426>:
  D.29429 = a->il_offset;
  D.29430 = b->il_offset;
  D.29431 = D.29429 - D.29430;
  D.29428 = (gint) D.29431;
  return D.29428;
  <D.29427>:
  D.29424 = a->native_offset;
  D.29425 = b->native_offset;
  D.29432 = D.29424 - D.29425;
  D.29428 = (gint) D.29432;
  return D.29428;
}


get_file_index (struct MonoAotCompile * acfg, const char * source_file)
{
  struct GHashTable * D.29434;
  struct GHashTable * D.29437;
  void * D.29438;
  unsigned int D.29441;
  unsigned int D.29442;
  gchar * D.29443;
  void * findex.156;
  struct FILE * D.29445;
  char * D.29446;
  int D.29447;
  int findex;

  D.29434 = acfg->dwarf_ln_filenames;
  if (D.29434 == 0B) goto <D.29435>; else goto <D.29436>;
  <D.29435>:
  D.29437 = monoeg_g_hash_table_new (monoeg_g_str_hash, monoeg_g_str_equal);
  acfg->dwarf_ln_filenames = D.29437;
  <D.29436>:
  D.29434 = acfg->dwarf_ln_filenames;
  D.29438 = monoeg_g_hash_table_lookup (D.29434, source_file);
  findex = (int) D.29438;
  if (findex == 0) goto <D.29439>; else goto <D.29440>;
  <D.29439>:
  D.29434 = acfg->dwarf_ln_filenames;
  D.29441 = monoeg_g_hash_table_size (D.29434);
  D.29442 = D.29441 + 1;
  findex = (int) D.29442;
  D.29434 = acfg->dwarf_ln_filenames;
  D.29443 = monoeg_strdup (source_file);
  findex.156 = (void *) findex;
  monoeg_g_hash_table_insert_replace (D.29434, D.29443, findex.156, 0);
  emit_unset_mode (acfg);
  D.29445 = acfg->fp;
  D.29446 = mono_dwarf_escape_path (source_file);
  fprintf (D.29445, ".file %d \"%s\"\n", findex, D.29446);
  <D.29440>:
  D.29447 = findex;
  return D.29447;
}


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

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


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

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


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

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


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

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


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

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


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

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


emit_info (struct MonoAotCompile * acfg)
{
  unsigned int D.29455;
  unsigned int D.29456;
  struct GPtrArray * D.29457;
  void * * D.29458;
  unsigned int oindex.157;
  unsigned int D.29460;
  void * * D.29461;
  void * D.29462;
  struct MonoCompile * * D.29463;
  unsigned int i.158;
  unsigned int D.29465;
  struct MonoCompile * * D.29466;
  struct MonoCompile * D.29467;
  gint32 * D.29470;
  unsigned int D.29471;
  int D.29472;
  unsigned int oindex.159;
  unsigned int D.29475;
  int D.29476;
  unsigned int D.29477;
  int D.29478;
  unsigned int D.29479;
  unsigned int D.29480;
  int D.29481;
  int oindex;
  int i;
  char symbol[256];
  gint32 * offsets;

  try
    {
      D.29455 = acfg->nmethods;
      D.29456 = D.29455 * 4;
      offsets = monoeg_malloc0 (D.29456);
      oindex = 0;
      goto <D.25159>;
      <D.25158>:
      D.29457 = acfg->method_order;
      D.29458 = D.29457->pdata;
      oindex.157 = (unsigned int) oindex;
      D.29460 = oindex.157 * 4;
      D.29461 = D.29458 + D.29460;
      D.29462 = *D.29461;
      i = (int) D.29462;
      D.29463 = acfg->cfgs;
      i.158 = (unsigned int) i;
      D.29465 = i.158 * 4;
      D.29466 = D.29463 + D.29465;
      D.29467 = *D.29466;
      if (D.29467 != 0B) goto <D.29468>; else goto <D.29469>;
      <D.29468>:
      D.29463 = acfg->cfgs;
      i.158 = (unsigned int) i;
      D.29465 = i.158 * 4;
      D.29466 = D.29463 + D.29465;
      D.29467 = *D.29466;
      emit_method_info (acfg, D.29467);
      i.158 = (unsigned int) i;
      D.29465 = i.158 * 4;
      D.29470 = offsets + D.29465;
      D.29463 = acfg->cfgs;
      i.158 = (unsigned int) i;
      D.29465 = i.158 * 4;
      D.29466 = D.29463 + D.29465;
      D.29467 = *D.29466;
      D.29471 = D.29467->method_info_offset;
      D.29472 = (int) D.29471;
      *D.29470 = D.29472;
      goto <D.29473>;
      <D.29469>:
      i.158 = (unsigned int) i;
      D.29465 = i.158 * 4;
      D.29470 = offsets + D.29465;
      *D.29470 = 0;
      <D.29473>:
      oindex = oindex + 1;
      <D.25159>:
      oindex.159 = (unsigned int) oindex;
      D.29457 = acfg->method_order;
      D.29475 = D.29457->len;
      if (oindex.159 < D.29475) goto <D.25158>; else goto <D.25160>;
      <D.25160>:
      sprintf (&symbol, "method_info_offsets");
      emit_section_change (acfg, ".rodata", 1);
      emit_alignment (acfg, 8);
      emit_label (acfg, &symbol);
      D.29455 = acfg->nmethods;
      D.29476 = (int) D.29455;
      D.29477 = emit_offset_table (acfg, D.29476, 10, offsets);
      D.29478 = acfg->stats.offsets_size;
      D.29479 = (unsigned int) D.29478;
      D.29480 = D.29479 + D.29477;
      D.29481 = (int) D.29480;
      acfg->stats.offsets_size = D.29481;
      monoeg_g_free (offsets);
    }
  finally
    {
      symbol = {CLOBBER};
    }
}


emit_method_info (struct MonoAotCompile * acfg, struct MonoCompile * cfg)
{
  struct MonoCompile * * D.29482;
  unsigned int D.29483;
  struct MonoCompile * * D.29484;
  struct MonoCompile * D.29485;
  int iftmp.160;
  unsigned int D.29487;
  unsigned int D.29490;
  unsigned int D.29491;
  unsigned int buf_size.161;
  struct MonoClass * D.29494;
  struct MonoMethod * D.29495;
  guint8 * p.162;
  unsigned int D.29500;
  unsigned int D.29501;
  struct GList * D.29504;
  unsigned int D.29505;
  int D.29506;
  void * D.29507;
  int D.29508;
  _Bool D.29510;
  long int D.29511;
  long int D.29512;
  void * * D.29515;
  unsigned int pindex.163;
  unsigned int D.29517;
  void * * D.29518;
  <unnamed type> D.29521;
  struct MonoImage * D.29525;
  struct MonoImage * D.29526;
  int D.29531;
  unsigned int pindex.164;
  unsigned int D.29537;
  unsigned int D.29538;
  _Bool D.29539;
  long int D.29540;
  long int D.29541;
  int first_got_offset.165;
  int D.29545;
  int p.166;
  int buf.167;
  int D.29548;
  int D.29549;
  _Bool D.29550;
  long int D.29551;
  long int D.29552;
  unsigned int D.29555;
  unsigned int D.29556;
  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.24575>;
      <D.24574>:
      monoeg_g_ptr_array_add (patches, patch_info);
      patch_info = patch_info->next;
      <D.24575>:
      if (patch_info != 0B) goto <D.24574>; else goto <D.24576>;
      <D.24576>:
      monoeg_g_ptr_array_sort (patches, compare_patches);
      D.29482 = acfg->cfgs;
      D.29483 = method_index * 4;
      D.29484 = D.29482 + D.29483;
      D.29485 = *D.29484;
      first_got_offset = D.29485->got_offset;
      D.29487 = patches->len;
      if (D.29487 > 999) goto <D.29488>; else goto <D.29489>;
      <D.29488>:
      D.29487 = patches->len;
      D.29490 = D.29487 + 640;
      D.29491 = D.29490 * 64;
      iftmp.160 = (int) D.29491;
      goto <D.29492>;
      <D.29489>:
      iftmp.160 = 40960;
      <D.29492>:
      buf_size = iftmp.160;
      buf_size.161 = (unsigned int) buf_size;
      buf = monoeg_malloc (buf_size.161);
      p = buf;
      D.29494 = method->klass;
      D.29495 = mono_class_get_cctor (D.29494);
      if (D.29495 != 0B) goto <D.29496>; else goto <D.29497>;
      <D.29496>:
      D.29494 = method->klass;
      p.162 = p;
      encode_klass_ref (acfg, D.29494, p.162, &p);
      goto <D.29499>;
      <D.29497>:
      p.162 = p;
      encode_value (0, p.162, &p);
      <D.29499>:
      D.29500 = cfg->opt;
      D.29501 = D.29500 & 512;
      if (D.29501 != 0) goto <D.29502>; else goto <D.29503>;
      <D.29502>:
      D.29504 = cfg->ldstr_list;
      D.29505 = monoeg_g_list_length (D.29504);
      D.29506 = (int) D.29505;
      p.162 = p;
      encode_value (D.29506, p.162, &p);
      l = cfg->ldstr_list;
      goto <D.24578>;
      <D.24577>:
      D.29507 = l->data;
      D.29508 = (int) D.29507;
      p.162 = p;
      encode_value (D.29508, p.162, &p);
      l = l->next;
      <D.24578>:
      if (l != 0B) goto <D.24577>; else goto <D.24579>;
      <D.24579>:
      goto <D.29509>;
      <D.29503>:
      D.29504 = cfg->ldstr_list;
      D.29510 = D.29504 != 0B;
      D.29511 = (long int) D.29510;
      D.29512 = __builtin_expect (D.29511, 0);
      if (D.29512 != 0) goto <D.29513>; else goto <D.29514>;
      <D.29513>:
      monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "aot-compiler.c", 5129, "!cfg->ldstr_list");
      <D.29514>:
      <D.29509>:
      n_patches = 0;
      pindex = 0;
      goto <D.24582>;
      <D.24581>:
      D.29515 = patches->pdata;
      pindex.163 = (unsigned int) pindex;
      D.29517 = pindex.163 * 4;
      D.29518 = D.29515 + D.29517;
      patch_info = *D.29518;
      D.29521 = patch_info->type;
      if (D.29521 == 27) goto <D.29519>; else goto <D.29522>;
      <D.29522>:
      D.29521 = patch_info->type;
      if (D.29521 == 51) goto <D.29519>; else goto <D.29520>;
      <D.29519>:
      patch_info->type = 51;
      // predicted unlikely by continue predictor.
      goto <D.24580>;
      <D.29520>:
      D.29521 = patch_info->type;
      if (D.29521 == 12) goto <D.29523>; else goto <D.29524>;
      <D.29523>:
      D.29525 = patch_info->data.image;
      D.29526 = acfg->image;
      if (D.29525 == D.29526) goto <D.29527>; else goto <D.29528>;
      <D.29527>:
      patch_info->type = 51;
      // predicted unlikely by continue predictor.
      goto <D.24580>;
      <D.29528>:
      <D.29524>:
      D.29521 = patch_info->type;
      if (D.29521 == 42) goto <D.29529>; else goto <D.29530>;
      <D.29529>:
      patch_info->type = 51;
      // predicted unlikely by continue predictor.
      goto <D.24580>;
      <D.29530>:
      D.29531 = is_plt_patch (patch_info);
      if (D.29531 != 0) goto <D.29532>; else goto <D.29533>;
      <D.29532>:
      patch_info->type = 51;
      // predicted unlikely by continue predictor.
      goto <D.24580>;
      <D.29533>:
      n_patches = n_patches + 1;
      <D.24580>:
      pindex = pindex + 1;
      <D.24582>:
      pindex.164 = (unsigned int) pindex;
      D.29487 = patches->len;
      if (pindex.164 < D.29487) goto <D.24581>; else goto <D.24583>;
      <D.24583>:
      if (n_patches != 0) goto <D.29535>; else goto <D.29536>;
      <D.29535>:
      D.29537 = BIT_FIELD_REF <*cfg, 32, 3424>;
      D.29538 = D.29537 & 1;
      D.29539 = D.29538 == 0;
      D.29540 = (long int) D.29539;
      D.29541 = __builtin_expect (D.29540, 0);
      if (D.29541 != 0) goto <D.29542>; else goto <D.29543>;
      <D.29542>:
      monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "aot-compiler.c", 5164, "cfg->has_got_slots");
      <D.29543>:
      <D.29536>:
      first_got_offset.165 = (int) first_got_offset;
      p.162 = p;
      encode_patch_list (acfg, patches, n_patches, first_got_offset.165, p.162, &p);
      D.29545 = acfg->stats.info_size;
      p.162 = p;
      p.166 = (int) p.162;
      buf.167 = (int) buf;
      D.29548 = p.166 - buf.167;
      D.29549 = D.29545 + D.29548;
      acfg->stats.info_size = D.29549;
      p.162 = p;
      p.166 = (int) p.162;
      buf.167 = (int) buf;
      D.29548 = p.166 - buf.167;
      D.29550 = D.29548 >= buf_size;
      D.29551 = (long int) D.29550;
      D.29552 = __builtin_expect (D.29551, 0);
      if (D.29552 != 0) goto <D.29553>; else goto <D.29554>;
      <D.29553>:
      monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "aot-compiler.c", 5170, "p - buf < buf_size");
      <D.29554>:
      p.162 = p;
      p.166 = (int) p.162;
      buf.167 = (int) buf;
      D.29548 = p.166 - buf.167;
      D.29555 = (unsigned int) D.29548;
      D.29556 = add_to_blob (acfg, buf, D.29555);
      cfg->method_info_offset = D.29556;
      monoeg_g_free (buf);
    }
  finally
    {
      p = {CLOBBER};
    }
}


encode_klass_ref (struct MonoAotCompile * acfg, struct MonoClass * klass, guint8 * buf, guint8 * * endbuf)
{
  struct MonoGenericClass * D.29557;
  unsigned int D.29560;
  _Bool D.29561;
  long int D.29562;
  long int D.29563;
  unsigned char D.29571;
  struct GHashTable * D.29575;
  void * D.29576;
  guint8 * p.168;
  int p.169;
  int buf2.170;
  int D.29582;
  _Bool D.29583;
  long int D.29584;
  long int D.29585;
  unsigned int D.29588;
  unsigned int D.29589;
  void * D.29590;
  int offset.171;
  gboolean shared;

  shared = 0;
  D.29557 = klass->generic_class;
  if (D.29557 != 0B) goto <D.29558>; else goto <D.29559>;
  <D.29558>:
  {
    guint32 token;

    D.29560 = klass->type_token;
    D.29561 = D.29560 == 0;
    D.29562 = (long int) D.29561;
    D.29563 = __builtin_expect (D.29562, 0);
    if (D.29563 != 0) goto <D.29564>; else goto <D.29565>;
    <D.29564>:
    monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "aot-compiler.c", 2354, "klass->type_token");
    <D.29565>:
    token = find_typespec_for_class (acfg, klass);
    if (token == 0) goto <D.29566>; else goto <D.29567>;
    <D.29566>:
    shared = 1;
    <D.29567>:
  }
  goto <D.29568>;
  <D.29559>:
  D.29571 = klass->byval_arg.type;
  if (D.29571 == 19) goto <D.29569>; else goto <D.29572>;
  <D.29572>:
  D.29571 = klass->byval_arg.type;
  if (D.29571 == 30) goto <D.29569>; else goto <D.29570>;
  <D.29569>:
  shared = 1;
  <D.29570>:
  <D.29568>:
  if (shared != 0) goto <D.29573>; else goto <D.29574>;
  <D.29573>:
  {
    guint offset;
    guint8 * buf2;
    guint8 * p;

    try
      {
        D.29575 = acfg->klass_blob_hash;
        D.29576 = monoeg_g_hash_table_lookup (D.29575, klass);
        offset = (guint) D.29576;
        if (offset == 0) goto <D.29577>; else goto <D.29578>;
        <D.29577>:
        buf2 = monoeg_malloc (1024);
        p = buf2;
        p.168 = p;
        encode_klass_ref_inner (acfg, klass, p.168, &p);
        p.168 = p;
        p.169 = (int) p.168;
        buf2.170 = (int) buf2;
        D.29582 = p.169 - buf2.170;
        D.29583 = D.29582 > 1023;
        D.29584 = (long int) D.29583;
        D.29585 = __builtin_expect (D.29584, 0);
        if (D.29585 != 0) goto <D.29586>; else goto <D.29587>;
        <D.29586>:
        monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "aot-compiler.c", 2373, "p - buf2 < 1024");
        <D.29587>:
        p.168 = p;
        p.169 = (int) p.168;
        buf2.170 = (int) buf2;
        D.29582 = p.169 - buf2.170;
        D.29588 = (unsigned int) D.29582;
        offset = add_to_blob (acfg, buf2, D.29588);
        monoeg_g_free (buf2);
        D.29575 = acfg->klass_blob_hash;
        D.29589 = offset + 1;
        D.29590 = (void *) D.29589;
        monoeg_g_hash_table_insert_replace (D.29575, klass, D.29590, 0);
        goto <D.29591>;
        <D.29578>:
        offset = offset + 4294967295;
        <D.29591>:
        p = buf;
        p.168 = p;
        encode_value (7, p.168, &p);
        offset.171 = (int) offset;
        p.168 = p;
        encode_value (offset.171, p.168, &p);
        p.168 = p;
        *endbuf = p.168;
        return;
      }
    finally
      {
        p = {CLOBBER};
      }
  }
  <D.29574>:
  encode_klass_ref_inner (acfg, klass, buf, endbuf);
}


find_typespec_for_class (struct MonoAotCompile * acfg, struct MonoClass * klass)
{
  struct MonoImage * D.29595;
  <unnamed-unsigned:24> D.29596;
  struct MonoClass * * D.29597;
  struct MonoMemPool * D.29600;
  unsigned int len.172;
  unsigned int D.29602;
  void * D.29603;
  unsigned int i.173;
  unsigned int D.29605;
  struct MonoClass * * D.29606;
  int D.29607;
  int D.29608;
  unsigned int D.29609;
  struct MonoClass * D.29610;
  struct MonoClass * D.29611;
  guint32 D.29615;
  int i;
  int len;

  D.29595 = acfg->image;
  D.29596 = D.29595->tables[27].rows;
  len = (int) D.29596;
  D.29597 = acfg->typespec_classes;
  if (D.29597 == 0B) goto <D.29598>; else goto <D.29599>;
  <D.29598>:
  D.29600 = acfg->mempool;
  len.172 = (unsigned int) len;
  D.29602 = len.172 * 4;
  D.29603 = mono_mempool_alloc0 (D.29600, D.29602);
  acfg->typespec_classes = D.29603;
  i = 0;
  goto <D.23422>;
  <D.23421>:
  D.29597 = acfg->typespec_classes;
  i.173 = (unsigned int) i;
  D.29605 = i.173 * 4;
  D.29606 = D.29597 + D.29605;
  D.29595 = acfg->image;
  D.29607 = i + 1;
  D.29608 = D.29607 | 452984832;
  D.29609 = (unsigned int) D.29608;
  D.29610 = mono_class_get_full (D.29595, D.29609, 0B);
  *D.29606 = D.29610;
  i = i + 1;
  <D.23422>:
  if (i < len) goto <D.23421>; else goto <D.23423>;
  <D.23423>:
  <D.29599>:
  i = 0;
  goto <D.23426>;
  <D.23425>:
  D.29597 = acfg->typespec_classes;
  i.173 = (unsigned int) i;
  D.29605 = i.173 * 4;
  D.29606 = D.29597 + D.29605;
  D.29611 = *D.29606;
  if (D.29611 == klass) goto <D.23424>; else goto <D.29612>;
  <D.29612>:
  i = i + 1;
  <D.23426>:
  if (i < len) goto <D.23425>; else goto <D.23424>;
  <D.23424>:
  if (i < len) goto <D.29613>; else goto <D.29614>;
  <D.29613>:
  D.29607 = i + 1;
  D.29608 = D.29607 | 452984832;
  D.29615 = (guint32) D.29608;
  return D.29615;
  <D.29614>:
  D.29615 = 0;
  return D.29615;
}


encode_klass_ref_inner (struct MonoAotCompile * acfg, struct MonoClass * klass, guint8 * buf, guint8 * * endbuf)
{
  struct MonoGenericClass * D.29617;
  unsigned int D.29620;
  _Bool D.29621;
  long int D.29622;
  long int D.29623;
  guint8 * p.174;
  int token.175;
  int p.176;
  int p1.177;
  int D.29633;
  int count.178;
  int count.179;
  struct MonoImage * D.29639;
  unsigned int D.29640;
  unsigned int D.29641;
  _Bool D.29642;
  long int D.29643;
  long int D.29644;
  unsigned int D.29649;
  int D.29650;
  unsigned int D.29652;
  int D.29653;
  unsigned char D.29658;
  struct MonoGenericParam * D.29660;
  int D.29661;
  short unsigned int D.29662;
  int D.29663;
  _Bool D.29664;
  int D.29665;
  <unnamed-signed:1> D.29668;
  int D.29669;
  short unsigned int D.29670;
  _Bool D.29671;
  long int D.29672;
  long int D.29673;
  unsigned int D.29676;
  unsigned int D.29677;
  struct MonoMethod * D.29680;
  struct MonoClass * D.29682;
  int D.29684;
  struct MonoType * D.29687;
  unsigned char D.29689;
  _Bool D.29690;
  long int D.29691;
  long int D.29692;
  int D.29695;
  struct MonoClass * D.29696;
  guint8 * p;

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

        D.29620 = klass->type_token;
        D.29621 = D.29620 == 0;
        D.29622 = (long int) D.29621;
        D.29623 = __builtin_expect (D.29622, 0);
        if (D.29623 != 0) goto <D.29624>; else goto <D.29625>;
        <D.29624>:
        monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "aot-compiler.c", 2275, "klass->type_token");
        <D.29625>:
        token = find_typespec_for_class (acfg, klass);
        if (token != 0) goto <D.29626>; else goto <D.29627>;
        <D.29626>:
        p.174 = p;
        encode_value (3, p.174, &p);
        token.175 = (int) token;
        p.174 = p;
        encode_value (token.175, p.174, &p);
        goto <D.29630>;
        <D.29627>:
        {
          struct MonoClass * gclass;
          struct MonoGenericInst * inst;
          static int count = 0;
          guint8 * p1;

          D.29617 = klass->generic_class;
          gclass = D.29617->container_class;
          D.29617 = klass->generic_class;
          inst = D.29617->context.class_inst;
          p1 = p;
          p.174 = p;
          encode_value (4, p.174, &p);
          p.174 = p;
          encode_klass_ref (acfg, gclass, p.174, &p);
          p.174 = p;
          encode_ginst (acfg, inst, p.174, &p);
          p.174 = p;
          p.176 = (int) p.174;
          p1.177 = (int) p1;
          D.29633 = p.176 - p1.177;
          count.178 = count;
          count.179 = D.29633 + count.178;
          count = count.179;
        }
        <D.29630>:
      }
      goto <D.29636>;
      <D.29619>:
      D.29620 = klass->type_token;
      if (D.29620 != 0) goto <D.29637>; else goto <D.29638>;
      <D.29637>:
      {
        int iindex;

        D.29639 = klass->image;
        D.29640 = get_image_index (acfg, D.29639);
        iindex = (int) D.29640;
        D.29620 = klass->type_token;
        D.29641 = D.29620 & 4278190080;
        D.29642 = D.29641 != 33554432;
        D.29643 = (long int) D.29642;
        D.29644 = __builtin_expect (D.29643, 0);
        if (D.29644 != 0) goto <D.29645>; else goto <D.29646>;
        <D.29645>:
        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.29646>:
        if (iindex == 0) goto <D.29647>; else goto <D.29648>;
        <D.29647>:
        p.174 = p;
        encode_value (1, p.174, &p);
        D.29620 = klass->type_token;
        D.29649 = D.29620 + 4261412864;
        D.29650 = (int) D.29649;
        p.174 = p;
        encode_value (D.29650, p.174, &p);
        goto <D.29651>;
        <D.29648>:
        p.174 = p;
        encode_value (2, p.174, &p);
        D.29620 = klass->type_token;
        D.29649 = D.29620 + 4261412864;
        D.29650 = (int) D.29649;
        p.174 = p;
        encode_value (D.29650, p.174, &p);
        D.29639 = klass->image;
        D.29652 = get_image_index (acfg, D.29639);
        D.29653 = (int) D.29652;
        p.174 = p;
        encode_value (D.29653, p.174, &p);
        <D.29651>:
      }
      goto <D.29654>;
      <D.29638>:
      D.29658 = klass->byval_arg.type;
      if (D.29658 == 19) goto <D.29655>; else goto <D.29659>;
      <D.29659>:
      D.29658 = klass->byval_arg.type;
      if (D.29658 == 30) goto <D.29655>; else goto <D.29656>;
      <D.29655>:
      {
        struct MonoGenericContainer * container;
        struct MonoGenericParam * par;

        D.29660 = klass->byval_arg.data.generic_param;
        container = D.29660->owner;
        par = klass->byval_arg.data.generic_param;
        p.174 = p;
        encode_value (5, p.174, &p);
        D.29658 = klass->byval_arg.type;
        D.29661 = (int) D.29658;
        p.174 = p;
        encode_value (D.29661, p.174, &p);
        D.29660 = klass->byval_arg.data.generic_param;
        D.29662 = D.29660->num;
        D.29663 = (int) D.29662;
        p.174 = p;
        encode_value (D.29663, p.174, &p);
        D.29664 = container != 0B;
        D.29665 = (int) D.29664;
        p.174 = p;
        encode_value (D.29665, p.174, &p);
        if (container != 0B) goto <D.29666>; else goto <D.29667>;
        <D.29666>:
        D.29668 = container->is_method;
        D.29669 = (int) D.29668;
        p.174 = p;
        encode_value (D.29669, p.174, &p);
        D.29670 = par->serial;
        D.29671 = D.29670 != 0;
        D.29672 = (long int) D.29671;
        D.29673 = __builtin_expect (D.29672, 0);
        if (D.29673 != 0) goto <D.29674>; else goto <D.29675>;
        <D.29674>:
        monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "aot-compiler.c", 2317, "par->serial == 0");
        <D.29675>:
        D.29676 = BIT_FIELD_REF <*container, 32, 128>;
        D.29677 = D.29676 & 2147483648;
        if (D.29677 != 0) goto <D.29678>; else goto <D.29679>;
        <D.29678>:
        D.29680 = container->owner.method;
        p.174 = p;
        encode_method_ref (acfg, D.29680, p.174, &p);
        goto <D.29681>;
        <D.29679>:
        D.29682 = container->owner.klass;
        p.174 = p;
        encode_klass_ref (acfg, D.29682, p.174, &p);
        <D.29681>:
        goto <D.29683>;
        <D.29667>:
        D.29670 = par->serial;
        D.29684 = (int) D.29670;
        p.174 = p;
        encode_value (D.29684, p.174, &p);
        <D.29683>:
      }
      goto <D.29657>;
      <D.29656>:
      D.29658 = klass->byval_arg.type;
      if (D.29658 == 15) goto <D.29685>; else goto <D.29686>;
      <D.29685>:
      p.174 = p;
      encode_value (8, p.174, &p);
      D.29687 = &klass->byval_arg;
      p.174 = p;
      encode_type (acfg, D.29687, p.174, &p);
      goto <D.29688>;
      <D.29686>:
      D.29689 = klass->rank;
      D.29690 = D.29689 == 0;
      D.29691 = (long int) D.29690;
      D.29692 = __builtin_expect (D.29691, 0);
      if (D.29692 != 0) goto <D.29693>; else goto <D.29694>;
      <D.29693>:
      monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "aot-compiler.c", 2330, "klass->rank > 0");
      <D.29694>:
      p.174 = p;
      encode_value (6, p.174, &p);
      D.29689 = klass->rank;
      D.29695 = (int) D.29689;
      p.174 = p;
      encode_value (D.29695, p.174, &p);
      D.29696 = klass->element_class;
      p.174 = p;
      encode_klass_ref (acfg, D.29696, p.174, &p);
      <D.29688>:
      <D.29657>:
      <D.29654>:
      <D.29636>:
      p.174 = p;
      *endbuf = p.174;
    }
  finally
    {
      p = {CLOBBER};
    }
}


encode_ginst (struct MonoAotCompile * acfg, struct MonoGenericInst * inst, guint8 * buf, guint8 * * endbuf)
{
  <unnamed-unsigned:22> D.29697;
  int D.29698;
  guint8 * p.180;
  struct MonoType * D.29700;
  struct MonoClass * D.29701;
  int D.29702;
  guint8 * p;
  int i;

  try
    {
      p = buf;
      D.29697 = inst->type_argc;
      D.29698 = (int) D.29697;
      p.180 = p;
      encode_value (D.29698, p.180, &p);
      i = 0;
      goto <D.23490>;
      <D.23489>:
      D.29700 = inst->type_argv[i];
      D.29701 = mono_class_from_mono_type (D.29700);
      p.180 = p;
      encode_klass_ref (acfg, D.29701, p.180, &p);
      i = i + 1;
      <D.23490>:
      D.29697 = inst->type_argc;
      D.29702 = (int) D.29697;
      if (D.29702 > i) goto <D.23489>; else goto <D.23491>;
      <D.23491>:
      p.180 = p;
      *endbuf = p.180;
    }
  finally
    {
      p = {CLOBBER};
    }
}


get_image_index (struct MonoAotCompile * cfg, struct MonoImage * image)
{
  struct GHashTable * D.29703;
  void * D.29704;
  guint32 D.29707;
  unsigned int D.29708;
  void * D.29709;
  struct GPtrArray * D.29710;
  guint32 index;

  D.29703 = cfg->image_hash;
  D.29704 = monoeg_g_hash_table_lookup (D.29703, image);
  index = (guint32) D.29704;
  if (index != 0) goto <D.29705>; else goto <D.29706>;
  <D.29705>:
  D.29707 = index + 4294967295;
  return D.29707;
  <D.29706>:
  D.29703 = cfg->image_hash;
  index = monoeg_g_hash_table_size (D.29703);
  D.29703 = cfg->image_hash;
  D.29708 = index + 1;
  D.29709 = (void *) D.29708;
  monoeg_g_hash_table_insert_replace (D.29703, image, D.29709, 0);
  D.29710 = cfg->image_table;
  monoeg_g_ptr_array_add (D.29710, image);
  D.29707 = index;
  return D.29707;
}


encode_method_ref (struct MonoAotCompile * acfg, struct MonoMethod * method, guint8 * buf, guint8 * * endbuf)
{
  struct MonoClass * D.29712;
  struct MonoImage * D.29713;
  unsigned int D.29717;
  unsigned int D.29718;
  short unsigned int D.29720;
  int D.29721;
  int D.29722;
  short unsigned int D.29723;
  int D.29724;
  int D.29725;
  guint8 * p.181;
  unsigned int D.29727;
  <unnamed-unsigned:5> D.29730;
  int D.29731;
  int D.29732;
  _Bool D.29733;
  long int D.29734;
  long int D.29735;
  int D.29738;
  _Bool D.29739;
  long int D.29740;
  long int D.29741;
  _Bool D.29744;
  long int D.29745;
  long int D.29746;
  <unnamed type> D.29749;
  int D.29750;
  int D.29753;
  _Bool D.29754;
  long int D.29755;
  long int D.29756;
  <unnamed type> D.29759;
  int D.29760;
  unsigned int D.29761;
  struct MonoMethod * D.29767;
  struct MonoMethod * D.29771;
  _Bool D.29772;
  long int D.29773;
  long int D.29774;
  <unnamed type> D.29777;
  int D.29778;
  const char * D.29781;
  unsigned int D.29782;
  sizetype D.29783;
  guint8 * p.182;
  struct MonoMethod * D.29788;
  _Bool D.29790;
  long int D.29791;
  long int D.29792;
  _Bool D.29795;
  long int D.29796;
  long int D.29797;
  _Bool D.29800;
  long int D.29801;
  long int D.29802;
  _Bool D.29805;
  long int D.29806;
  long int D.29807;
  <unnamed type> D.29810;
  int D.29811;
  unsigned int D.29814;
  int D.29815;
  unsigned int D.29816;
  int D.29817;
  struct MonoMethod * D.29821;
  _Bool D.29823;
  long int D.29824;
  long int D.29825;
  <unnamed type> D.29828;
  int D.29829;
  _Bool D.29830;
  long int D.29831;
  long int D.29832;
  <unnamed type> D.29835;
  int D.29836;
  unsigned int D.29837;
  struct MonoMethod * D.29840;
  struct MonoMethodSignature * D.29844;
  unsigned int D.29845;
  gint32 iftmp.183;
  <unnamed type> D.29854;
  _Bool D.29856;
  long int D.29857;
  long int D.29858;
  struct MonoMethod * D.29861;
  struct MonoClass * D.29862;
  struct MonoMethodSignature * D.29864;
  unsigned int D.29865;
  unsigned int D.29866;
  struct GHashTable * D.29869;
  struct MonoImage * D.29872;
  _Bool D.29873;
  long int D.29874;
  long int D.29875;
  int image_index.184;
  int token.185;
  _Bool D.29881;
  long int D.29882;
  long int D.29883;
  unsigned int D.29888;
  _Bool D.29889;
  long int D.29890;
  long int D.29891;
  unsigned int D.29894;
  _Bool D.29895;
  long int D.29896;
  long int D.29897;
  unsigned char D.29908;
  _Bool D.29909;
  long int D.29910;
  long int D.29911;
  int D.23615;
  int iftmp.186;
  int D.23614;
  const char[6] * D.29919;
  unsigned char D.29920;
  int D.29921;
  unsigned char D.29922;
  int D.29923;
  const unsigned char * D.29928;
  unsigned char D.29929;
  int D.29930;
  const unsigned char * D.29931;
  unsigned char D.29932;
  int D.29933;
  const unsigned char * D.29938;
  unsigned char D.29939;
  int D.29940;
  const unsigned char * D.29941;
  unsigned char D.29942;
  int D.29943;
  const unsigned char * D.29948;
  unsigned char D.29949;
  int D.29950;
  const unsigned char * D.29951;
  unsigned char D.29952;
  int D.29953;
  struct MonoMethodSignature * D.29956;
  short unsigned int D.29957;
  short unsigned int D.29958;
  int D.23624;
  int iftmp.187;
  int D.23623;
  unsigned char D.29965;
  int D.29966;
  const unsigned char * D.29971;
  unsigned char D.29972;
  int D.29973;
  const unsigned char * D.29978;
  unsigned char D.29979;
  int D.29980;
  const unsigned char * D.29985;
  unsigned char D.29986;
  int D.29987;
  struct MonoMethodSignature * D.29990;
  short unsigned int D.29991;
  int D.29992;
  int D.29993;
  int D.29994;
  int D.23633;
  int iftmp.188;
  int D.23632;
  const char[4] * D.29999;
  unsigned char D.30000;
  int D.30001;
  unsigned char D.30002;
  int D.30003;
  const unsigned char * D.30008;
  unsigned char D.30009;
  int D.30010;
  const unsigned char * D.30011;
  unsigned char D.30012;
  int D.30013;
  const unsigned char * D.30018;
  unsigned char D.30019;
  int D.30020;
  const unsigned char * D.30021;
  unsigned char D.30022;
  int D.30023;
  const unsigned char * D.30028;
  unsigned char D.30029;
  int D.30030;
  const unsigned char * D.30031;
  unsigned char D.30032;
  int D.30033;
  int D.23642;
  int iftmp.189;
  int D.23641;
  const char[8] * D.30041;
  unsigned char D.30042;
  int D.30043;
  unsigned char D.30044;
  int D.30045;
  const unsigned char * D.30050;
  unsigned char D.30051;
  int D.30052;
  const unsigned char * D.30053;
  unsigned char D.30054;
  int D.30055;
  const unsigned char * D.30060;
  unsigned char D.30061;
  int D.30062;
  const unsigned char * D.30063;
  unsigned char D.30064;
  int D.30065;
  const unsigned char * D.30070;
  unsigned char D.30071;
  int D.30072;
  const unsigned char * D.30073;
  unsigned char D.30074;
  int D.30075;
  int D.23651;
  int iftmp.190;
  int D.23650;
  const char[4] * D.30083;
  unsigned char D.30084;
  int D.30085;
  unsigned char D.30086;
  int D.30087;
  const unsigned char * D.30092;
  unsigned char D.30093;
  int D.30094;
  const unsigned char * D.30095;
  unsigned char D.30096;
  int D.30097;
  const unsigned char * D.30102;
  unsigned char D.30103;
  int D.30104;
  const unsigned char * D.30105;
  unsigned char D.30106;
  int D.30107;
  const unsigned char * D.30112;
  unsigned char D.30113;
  int D.30114;
  const unsigned char * D.30115;
  unsigned char D.30116;
  int D.30117;
  int D.30127;
  unsigned int D.30129;
  unsigned int D.30130;
  unsigned int D.30131;
  int D.30132;
  guint32 image_index;
  guint32 token;
  struct MonoJumpInfoToken * ji;
  guint8 * p;

  try
    {
      D.29712 = method->klass;
      D.29713 = D.29712->image;
      image_index = get_image_index (acfg, D.29713);
      token = method->token;
      p = buf;
      D.29717 = BIT_FIELD_REF <*method, 32, 160>;
      D.29718 = D.29717 & 2048;
      if (D.29718 != 0) goto <D.29719>; else goto <D.29714>;
      <D.29719>:
      D.29720 = method->flags;
      D.29721 = (int) D.29720;
      D.29722 = D.29721 & 64;
      if (D.29722 != 0) goto <D.29715>; else goto <D.29714>;
      <D.29714>:
      D.29723 = method->iflags;
      D.29724 = (int) D.29723;
      D.29725 = D.29724 & 32;
      if (D.29725 != 0) goto <D.29715>; else goto <D.29716>;
      <D.29715>:
      p.181 = p;
      encode_value (-83886080, p.181, &p);
      <D.29716>:
      D.29717 = BIT_FIELD_REF <*method, 32, 160>;
      D.29727 = D.29717 & 124;
      if (D.29727 != 0) goto <D.29728>; else goto <D.29729>;
      <D.29728>:
      p.181 = p;
      encode_value (-67108864, p.181, &p);
      D.29730 = method->wrapper_type;
      D.29731 = (int) D.29730;
      p.181 = p;
      encode_value (D.29731, p.181, &p);
      D.29730 = method->wrapper_type;
      D.29732 = (int) D.29730;
      switch (D.29732) <default: <D.23604>, case 1: <D.23597>, case 2: <D.23598>, case 3: <D.23599>, case 4: <D.23595>, case 5: <D.23602>, case 6: <D.23587>, case 7: <D.23591>, case 8: <D.23567>, case 9: <D.23568>, case 10: <D.23569>, case 12: <D.23573>, case 13: <D.23575>, case 14: <D.23578>, case 15: <D.23579>, case 16: <D.23589>, case 18: <D.23576>, case 19: <D.23593>, case 20: <D.23572>, case 21: <D.23583>, case 23: <D.23574>, case 24: <D.23582>, case 25: <D.23585>, case 28: <D.23580>>
      <D.23567>:
      <D.23568>:
      <D.23569>:
      {
        struct MonoMethod * m;

        m = mono_marshal_method_from_wrapper (method);
        D.29733 = m == 0B;
        D.29734 = (long int) D.29733;
        D.29735 = __builtin_expect (D.29734, 0);
        if (D.29735 != 0) goto <D.29736>; else goto <D.29737>;
        <D.29736>:
        monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "aot-compiler.c", 2595, "m");
        <D.29737>:
        p.181 = p;
        encode_method_ref (acfg, m, p.181, &p);
        goto <D.23571>;
      }
      <D.23572>:
      <D.23573>:
      <D.23574>:
      <D.23575>:
      <D.23576>:
      {
        struct MonoClass * proxy_class;

        proxy_class = mono_marshal_get_wrapper_info (method);
        p.181 = p;
        encode_klass_ref (acfg, proxy_class, p.181, &p);
        goto <D.23571>;
      }
      <D.23578>:
      <D.23579>:
      goto <D.23571>;
      <D.23580>:
      {
        struct AllocatorWrapperInfo * info;

        info = mono_marshal_get_wrapper_info (method);
        D.29738 = info->alloc_type;
        D.29739 = D.29738 == -1;
        D.29740 = (long int) D.29739;
        D.29741 = __builtin_expect (D.29740, 0);
        if (D.29741 != 0) goto <D.29742>; else goto <D.29743>;
        <D.29742>:
        monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "aot-compiler.c", 2615, "info->alloc_type != -1");
        <D.29743>:
        D.29738 = info->alloc_type;
        p.181 = p;
        encode_value (D.29738, p.181, &p);
        goto <D.23571>;
      }
      <D.23582>:
      goto <D.23571>;
      <D.23583>:
      {
        struct WrapperInfo * info;

        info = mono_marshal_get_wrapper_info (method);
        D.29744 = info == 0B;
        D.29745 = (long int) D.29744;
        D.29746 = __builtin_expect (D.29745, 0);
        if (D.29746 != 0) goto <D.29747>; else goto <D.29748>;
        <D.29747>:
        monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "aot-compiler.c", 2624, "info");
        <D.29748>:
        D.29749 = info->subtype;
        D.29750 = (int) D.29749;
        p.181 = p;
        encode_value (D.29750, p.181, &p);
        D.29749 = info->subtype;
        if (D.29749 == 3) goto <D.29751>; else goto <D.29752>;
        <D.29751>:
        D.29753 = info->d.virtual_stelemref.kind;
        p.181 = p;
        encode_value (D.29753, p.181, &p);
        <D.29752>:
        goto <D.23571>;
      }
      <D.23585>:
      {
        struct WrapperInfo * info;

        info = mono_marshal_get_wrapper_info (method);
        D.29754 = info == 0B;
        D.29755 = (long int) D.29754;
        D.29756 = __builtin_expect (D.29755, 0);
        if (D.29756 != 0) goto <D.29757>; else goto <D.29758>;
        <D.29757>:
        monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "aot-compiler.c", 2633, "info");
        <D.29758>:
        D.29759 = info->subtype;
        D.29760 = (int) D.29759;
        p.181 = p;
        encode_value (D.29760, p.181, &p);
        D.29759 = info->subtype;
        D.29761 = D.29759 + 4294967289;
        if (D.29761 <= 1) goto <D.29762>; else goto <D.29763>;
        <D.29762>:
        D.29712 = method->klass;
        p.181 = p;
        encode_klass_ref (acfg, D.29712, p.181, &p);
        goto <D.29764>;
        <D.29763>:
        D.29759 = info->subtype;
        if (D.29759 == 17) goto <D.29765>; else goto <D.29766>;
        <D.29765>:
        D.29767 = info->d.synchronized_inner.method;
        p.181 = p;
        encode_method_ref (acfg, D.29767, p.181, &p);
        goto <D.29768>;
        <D.29766>:
        D.29759 = info->subtype;
        if (D.29759 == 20) goto <D.29769>; else goto <D.29770>;
        <D.29769>:
        D.29771 = info->d.array_accessor.method;
        p.181 = p;
        encode_method_ref (acfg, D.29771, p.181, &p);
        <D.29770>:
        <D.29768>:
        <D.29764>:
        goto <D.23571>;
      }
      <D.23587>:
      {
        struct WrapperInfo * info;

        info = mono_marshal_get_wrapper_info (method);
        D.29772 = info == 0B;
        D.29773 = (long int) D.29772;
        D.29774 = __builtin_expect (D.29773, 0);
        if (D.29774 != 0) goto <D.29775>; else goto <D.29776>;
        <D.29775>:
        monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "aot-compiler.c", 2647, "info");
        <D.29776>:
        D.29777 = info->subtype;
        D.29778 = (int) D.29777;
        p.181 = p;
        encode_value (D.29778, p.181, &p);
        D.29777 = info->subtype;
        if (D.29777 == 15) goto <D.29779>; else goto <D.29780>;
        <D.29779>:
        p.181 = p;
        D.29781 = method->name;
        strcpy (p.181, D.29781);
        p.181 = p;
        D.29781 = method->name;
        D.29782 = strlen (D.29781);
        D.29783 = D.29782 + 1;
        p.182 = p.181 + D.29783;
        p = p.182;
        goto <D.29785>;
        <D.29780>:
        D.29777 = info->subtype;
        if (D.29777 == 16) goto <D.29786>; else goto <D.29787>;
        <D.29786>:
        D.29788 = info->d.managed_to_native.method;
        p.181 = p;
        encode_method_ref (acfg, D.29788, p.181, &p);
        goto <D.29789>;
        <D.29787>:
        D.29777 = info->subtype;
        D.29790 = D.29777 != 0;
        D.29791 = (long int) D.29790;
        D.29792 = __builtin_expect (D.29791, 0);
        if (D.29792 != 0) goto <D.29793>; else goto <D.29794>;
        <D.29793>:
        monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "aot-compiler.c", 2655, "info->subtype == WRAPPER_SUBTYPE_NONE");
        <D.29794>:
        D.29788 = info->d.managed_to_native.method;
        p.181 = p;
        encode_method_ref (acfg, D.29788, p.181, &p);
        <D.29789>:
        <D.29785>:
        goto <D.23571>;
      }
      <D.23589>:
      {
        struct MonoMethod * m;

        m = mono_marshal_method_from_wrapper (method);
        D.29795 = m == 0B;
        D.29796 = (long int) D.29795;
        D.29797 = __builtin_expect (D.29796, 0);
        if (D.29797 != 0) goto <D.29798>; else goto <D.29799>;
        <D.29798>:
        monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "aot-compiler.c", 2664, "m");
        <D.29799>:
        D.29800 = m == method;
        D.29801 = (long int) D.29800;
        D.29802 = __builtin_expect (D.29801, 0);
        if (D.29802 != 0) goto <D.29803>; else goto <D.29804>;
        <D.29803>:
        monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "aot-compiler.c", 2665, "m != method");
        <D.29804>:
        p.181 = p;
        encode_method_ref (acfg, m, p.181, &p);
        goto <D.23571>;
      }
      <D.23591>:
      {
        struct WrapperInfo * info;

        info = mono_marshal_get_wrapper_info (method);
        D.29805 = info == 0B;
        D.29806 = (long int) D.29805;
        D.29807 = __builtin_expect (D.29806, 0);
        if (D.29807 != 0) goto <D.29808>; else goto <D.29809>;
        <D.29808>:
        monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "aot-compiler.c", 2672, "info");
        <D.29809>:
        D.29810 = info->subtype;
        D.29811 = (int) D.29810;
        p.181 = p;
        encode_value (D.29811, p.181, &p);
        D.29810 = info->subtype;
        if (D.29810 == 1) goto <D.29812>; else goto <D.29813>;
        <D.29812>:
        D.29814 = info->d.element_addr.rank;
        D.29815 = (int) D.29814;
        p.181 = p;
        encode_value (D.29815, p.181, &p);
        D.29816 = info->d.element_addr.elem_size;
        D.29817 = (int) D.29816;
        p.181 = p;
        encode_value (D.29817, p.181, &p);
        goto <D.29818>;
        <D.29813>:
        D.29810 = info->subtype;
        if (D.29810 == 2) goto <D.29819>; else goto <D.29820>;
        <D.29819>:
        D.29821 = info->d.string_ctor.method;
        p.181 = p;
        encode_method_ref (acfg, D.29821, p.181, &p);
        goto <D.29822>;
        <D.29820>:
        monoeg_assertion_message ("* Assertion: should not be reached at %s:%d\n", "aot-compiler.c", 2681);
        <D.29822>:
        <D.29818>:
        goto <D.23571>;
      }
      <D.23593>:
      {
        struct WrapperInfo * info;

        info = mono_marshal_get_wrapper_info (method);
        D.29823 = info == 0B;
        D.29824 = (long int) D.29823;
        D.29825 = __builtin_expect (D.29824, 0);
        if (D.29825 != 0) goto <D.29826>; else goto <D.29827>;
        <D.29826>:
        monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "aot-compiler.c", 2688, "info");
        <D.29827>:
        D.29828 = info->subtype;
        D.29829 = (int) D.29828;
        p.181 = p;
        encode_value (D.29829, p.181, &p);
        goto <D.23571>;
      }
      <D.23595>:
      {
        struct WrapperInfo * info;

        info = mono_marshal_get_wrapper_info (method);
        D.29830 = info == 0B;
        D.29831 = (long int) D.29830;
        D.29832 = __builtin_expect (D.29831, 0);
        if (D.29832 != 0) goto <D.29833>; else goto <D.29834>;
        <D.29833>:
        monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "aot-compiler.c", 2695, "info");
        <D.29834>:
        D.29835 = info->subtype;
        D.29836 = (int) D.29835;
        p.181 = p;
        encode_value (D.29836, p.181, &p);
        D.29835 = info->subtype;
        D.29837 = D.29835 + 4294967283;
        if (D.29837 <= 1) goto <D.29838>; else goto <D.29839>;
        <D.29838>:
        D.29840 = info->d.runtime_invoke.method;
        p.181 = p;
        encode_method_ref (acfg, D.29840, p.181, &p);
        goto <D.29841>;
        <D.29839>:
        D.29835 = info->subtype;
        if (D.29835 == 11) goto <D.29842>; else goto <D.29843>;
        <D.29842>:
        D.29844 = info->d.runtime_invoke.sig;
        p.181 = p;
        encode_signature (acfg, D.29844, p.181, &p);
        <D.29843>:
        <D.29841>:
        goto <D.23571>;
      }
      <D.23597>:
      <D.23598>:
      <D.23599>:
      D.29717 = BIT_FIELD_REF <*method, 32, 160>;
      D.29845 = D.29717 & 4096;
      if (D.29845 != 0) goto <D.29846>; else goto <D.29847>;
      <D.29846>:
      p.181 = p;
      encode_value (1, p.181, &p);
      D.29712 = method->klass;
      p.181 = p;
      encode_klass_ref (acfg, D.29712, p.181, &p);
      goto <D.29848>;
      <D.29847>:
      {
        struct MonoMethodSignature * sig;
        struct WrapperInfo * info;

        sig = mono_method_signature (method);
        info = mono_marshal_get_wrapper_info (method);
        p.181 = p;
        encode_value (0, p.181, &p);
        D.29717 = BIT_FIELD_REF <*method, 32, 160>;
        D.29727 = D.29717 & 124;
        if (D.29727 == 4) goto <D.29849>; else goto <D.29850>;
        <D.29849>:
        if (info != 0B) goto <D.29852>; else goto <D.29853>;
        <D.29852>:
        D.29854 = info->subtype;
        iftmp.183 = (gint32) D.29854;
        goto <D.29855>;
        <D.29853>:
        iftmp.183 = 0;
        <D.29855>:
        p.181 = p;
        encode_value (iftmp.183, p.181, &p);
        <D.29850>:
        p.181 = p;
        encode_signature (acfg, sig, p.181, &p);
      }
      <D.29848>:
      goto <D.23571>;
      <D.23602>:
      {
        struct WrapperInfo * info;

        info = mono_marshal_get_wrapper_info (method);
        D.29856 = info == 0B;
        D.29857 = (long int) D.29856;
        D.29858 = __builtin_expect (D.29857, 0);
        if (D.29858 != 0) goto <D.29859>; else goto <D.29860>;
        <D.29859>:
        monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "aot-compiler.c", 2724, "info");
        <D.29860>:
        D.29861 = info->d.native_to_managed.method;
        p.181 = p;
        encode_method_ref (acfg, D.29861, p.181, &p);
        D.29862 = info->d.native_to_managed.klass;
        p.181 = p;
        encode_klass_ref (acfg, D.29862, p.181, &p);
        goto <D.23571>;
      }
      <D.23604>:
      monoeg_assertion_message ("* Assertion: should not be reached at %s:%d\n", "aot-compiler.c", 2730);
      <D.23571>:
      goto <D.29863>;
      <D.29729>:
      D.29864 = mono_method_signature (method);
      D.29865 = BIT_FIELD_REF <*D.29864, 32, 64>;
      D.29866 = D.29865 & 33554432;
      if (D.29866 != 0) goto <D.29867>; else goto <D.29868>;
      <D.29867>:
      D.29869 = acfg->token_info_hash;
      ji = monoeg_g_hash_table_lookup (D.29869, method);
      if (ji != 0B) goto <D.29870>; else goto <D.29871>;
      <D.29870>:
      D.29872 = ji->image;
      image_index = get_image_index (acfg, D.29872);
      D.29873 = image_index > 249;
      D.29874 = (long int) D.29873;
      D.29875 = __builtin_expect (D.29874, 0);
      if (D.29875 != 0) goto <D.29876>; else goto <D.29877>;
      <D.29876>:
      monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "aot-compiler.c", 2741, "image_index < MAX_IMAGE_INDEX");
      <D.29877>:
      token = ji->token;
      p.181 = p;
      encode_value (-33554432, p.181, &p);
      image_index.184 = (int) image_index;
      p.181 = p;
      encode_value (image_index.184, p.181, &p);
      token.185 = (int) token;
      p.181 = p;
      encode_value (token.185, p.181, &p);
      goto <D.29880>;
      <D.29871>:
      {
        struct MonoMethod * declaring;
        struct MonoGenericContext * context;

        context = mono_method_get_context (method);
        D.29717 = BIT_FIELD_REF <*method, 32, 160>;
        D.29845 = D.29717 & 4096;
        D.29881 = D.29845 == 0;
        D.29882 = (long int) D.29881;
        D.29883 = __builtin_expect (D.29882, 0);
        if (D.29883 != 0) goto <D.29884>; else goto <D.29885>;
        <D.29884>:
        monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "aot-compiler.c", 2751, "method->is_inflated");
        <D.29885>:
        declaring = MEM[(struct MonoMethodInflated *)method].declaring;
        p.181 = p;
        encode_value (-50331648, p.181, &p);
        D.29712 = method->klass;
        p.181 = p;
        encode_klass_ref (acfg, D.29712, p.181, &p);
        D.29712 = method->klass;
        D.29713 = D.29712->image;
        image_index = get_image_index (acfg, D.29713);
        D.29873 = image_index > 249;
        D.29874 = (long int) D.29873;
        D.29875 = __builtin_expect (D.29874, 0);
        if (D.29875 != 0) goto <D.29886>; else goto <D.29887>;
        <D.29886>:
        monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "aot-compiler.c", 2764, "image_index < MAX_IMAGE_INDEX");
        <D.29887>:
        D.29888 = declaring->token;
        D.29889 = D.29888 == 0;
        D.29890 = (long int) D.29889;
        D.29891 = __builtin_expect (D.29890, 0);
        if (D.29891 != 0) goto <D.29892>; else goto <D.29893>;
        <D.29892>:
        monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "aot-compiler.c", 2765, "declaring->token");
        <D.29893>:
        token = declaring->token;
        D.29894 = token >> 24;
        D.29895 = D.29894 != 6;
        D.29896 = (long int) D.29895;
        D.29897 = __builtin_expect (D.29896, 0);
        if (D.29897 != 0) goto <D.29898>; else goto <D.29899>;
        <D.29898>:
        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.29899>:
        image_index.184 = (int) image_index;
        p.181 = p;
        encode_value (image_index.184, p.181, &p);
        token.185 = (int) token;
        p.181 = p;
        encode_value (token.185, p.181, &p);
        p.181 = p;
        encode_generic_context (acfg, context, p.181, &p);
      }
      <D.29880>:
      goto <D.29900>;
      <D.29868>:
      if (token == 0) goto <D.29901>; else goto <D.29902>;
      <D.29901>:
      D.29869 = acfg->token_info_hash;
      ji = monoeg_g_hash_table_lookup (D.29869, method);
      if (ji != 0B) goto <D.29903>; else goto <D.29904>;
      <D.29903>:
      D.29872 = ji->image;
      image_index = get_image_index (acfg, D.29872);
      D.29873 = image_index > 249;
      D.29874 = (long int) D.29873;
      D.29875 = __builtin_expect (D.29874, 0);
      if (D.29875 != 0) goto <D.29905>; else goto <D.29906>;
      <D.29905>:
      monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "aot-compiler.c", 2778, "image_index < MAX_IMAGE_INDEX");
      <D.29906>:
      token = ji->token;
      p.181 = p;
      encode_value (-33554432, p.181, &p);
      image_index.184 = (int) image_index;
      p.181 = p;
      encode_value (image_index.184, p.181, &p);
      token.185 = (int) token;
      p.181 = p;
      encode_value (token.185, p.181, &p);
      goto <D.29907>;
      <D.29904>:
      D.29712 = method->klass;
      D.29908 = D.29712->rank;
      D.29909 = D.29908 == 0;
      D.29910 = (long int) D.29909;
      D.29911 = __builtin_expect (D.29910, 0);
      if (D.29911 != 0) goto <D.29912>; else goto <D.29913>;
      <D.29912>:
      monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "aot-compiler.c", 2786, "method->klass->rank");
      <D.29913>:
      p.181 = p;
      encode_value (-100663296, p.181, &p);
      D.29712 = method->klass;
      p.181 = p;
      encode_klass_ref (acfg, D.29712, p.181, &p);
      {
        size_t __s1_len;
        size_t __s2_len;

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

          __s2 = method->name;
          D.29919 = ".ctor";
          D.29920 = MEM[(const unsigned char *)D.29919];
          D.29921 = (int) D.29920;
          D.29922 = *__s2;
          D.29923 = (int) D.29922;
          __result = D.29921 - D.29923;
          {
            if (__s2_len != 0) goto <D.29924>; else goto <D.29925>;
            <D.29924>:
            if (__result == 0) goto <D.29926>; else goto <D.29927>;
            <D.29926>:
            D.29928 = &MEM[(void *)".ctor" + 1B];
            D.29929 = *D.29928;
            D.29930 = (int) D.29929;
            D.29931 = __s2 + 1;
            D.29932 = *D.29931;
            D.29933 = (int) D.29932;
            __result = D.29930 - D.29933;
            if (__s2_len > 1) goto <D.29934>; else goto <D.29935>;
            <D.29934>:
            if (__result == 0) goto <D.29936>; else goto <D.29937>;
            <D.29936>:
            D.29938 = &MEM[(void *)".ctor" + 2B];
            D.29939 = *D.29938;
            D.29940 = (int) D.29939;
            D.29941 = __s2 + 2;
            D.29942 = *D.29941;
            D.29943 = (int) D.29942;
            __result = D.29940 - D.29943;
            if (__s2_len > 2) goto <D.29944>; else goto <D.29945>;
            <D.29944>:
            if (__result == 0) goto <D.29946>; else goto <D.29947>;
            <D.29946>:
            D.29948 = &MEM[(void *)".ctor" + 3B];
            D.29949 = *D.29948;
            D.29950 = (int) D.29949;
            D.29951 = __s2 + 3;
            D.29952 = *D.29951;
            D.29953 = (int) D.29952;
            __result = D.29950 - D.29953;
            <D.29947>:
            <D.29945>:
            <D.29937>:
            <D.29935>:
            <D.29927>:
            <D.29925>:
          }
          D.23614 = __result;
        }
        iftmp.186 = -D.23614;
        goto <D.29954>;
        <D.29918>:
        D.29781 = method->name;
        iftmp.186 = __builtin_strcmp (D.29781, ".ctor");
        <D.29954>:
        D.23615 = iftmp.186;
      }
      if (D.23615 == 0) goto <D.29955>; else goto <D.29914>;
      <D.29955>:
      D.29956 = mono_method_signature (method);
      D.29957 = D.29956->param_count;
      D.29712 = method->klass;
      D.29908 = D.29712->rank;
      D.29958 = (short unsigned int) D.29908;
      if (D.29957 == D.29958) goto <D.29959>; else goto <D.29914>;
      <D.29959>:
      p.181 = p;
      encode_value (0, p.181, &p);
      goto <D.29915>;
      <D.29914>:
      {
        size_t __s1_len;
        size_t __s2_len;

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

          __s2 = method->name;
          D.29919 = ".ctor";
          D.29920 = MEM[(const unsigned char *)D.29919];
          D.29921 = (int) D.29920;
          D.29965 = *__s2;
          D.29966 = (int) D.29965;
          __result = D.29921 - D.29966;
          {
            if (__s2_len != 0) goto <D.29967>; else goto <D.29968>;
            <D.29967>:
            if (__result == 0) goto <D.29969>; else goto <D.29970>;
            <D.29969>:
            D.29928 = &MEM[(void *)".ctor" + 1B];
            D.29929 = *D.29928;
            D.29930 = (int) D.29929;
            D.29971 = __s2 + 1;
            D.29972 = *D.29971;
            D.29973 = (int) D.29972;
            __result = D.29930 - D.29973;
            if (__s2_len > 1) goto <D.29974>; else goto <D.29975>;
            <D.29974>:
            if (__result == 0) goto <D.29976>; else goto <D.29977>;
            <D.29976>:
            D.29938 = &MEM[(void *)".ctor" + 2B];
            D.29939 = *D.29938;
            D.29940 = (int) D.29939;
            D.29978 = __s2 + 2;
            D.29979 = *D.29978;
            D.29980 = (int) D.29979;
            __result = D.29940 - D.29980;
            if (__s2_len > 2) goto <D.29981>; else goto <D.29982>;
            <D.29981>:
            if (__result == 0) goto <D.29983>; else goto <D.29984>;
            <D.29983>:
            D.29948 = &MEM[(void *)".ctor" + 3B];
            D.29949 = *D.29948;
            D.29950 = (int) D.29949;
            D.29985 = __s2 + 3;
            D.29986 = *D.29985;
            D.29987 = (int) D.29986;
            __result = D.29950 - D.29987;
            <D.29984>:
            <D.29982>:
            <D.29977>:
            <D.29975>:
            <D.29970>:
            <D.29968>:
          }
          D.23623 = __result;
        }
        iftmp.187 = -D.23623;
        goto <D.29988>;
        <D.29964>:
        D.29781 = method->name;
        iftmp.187 = __builtin_strcmp (D.29781, ".ctor");
        <D.29988>:
        D.23624 = iftmp.187;
      }
      if (D.23624 == 0) goto <D.29989>; else goto <D.29960>;
      <D.29989>:
      D.29990 = mono_method_signature (method);
      D.29991 = D.29990->param_count;
      D.29992 = (int) D.29991;
      D.29712 = method->klass;
      D.29908 = D.29712->rank;
      D.29993 = (int) D.29908;
      D.29994 = D.29993 * 2;
      if (D.29992 == D.29994) goto <D.29995>; else goto <D.29960>;
      <D.29995>:
      p.181 = p;
      encode_value (1, p.181, &p);
      goto <D.29961>;
      <D.29960>:
      {
        size_t __s1_len;
        size_t __s2_len;

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

          __s2 = method->name;
          D.29999 = "Get";
          D.30000 = MEM[(const unsigned char *)D.29999];
          D.30001 = (int) D.30000;
          D.30002 = *__s2;
          D.30003 = (int) D.30002;
          __result = D.30001 - D.30003;
          {
            if (__s2_len != 0) goto <D.30004>; else goto <D.30005>;
            <D.30004>:
            if (__result == 0) goto <D.30006>; else goto <D.30007>;
            <D.30006>:
            D.30008 = &MEM[(void *)"Get" + 1B];
            D.30009 = *D.30008;
            D.30010 = (int) D.30009;
            D.30011 = __s2 + 1;
            D.30012 = *D.30011;
            D.30013 = (int) D.30012;
            __result = D.30010 - D.30013;
            if (__s2_len > 1) goto <D.30014>; else goto <D.30015>;
            <D.30014>:
            if (__result == 0) goto <D.30016>; else goto <D.30017>;
            <D.30016>:
            D.30018 = &MEM[(void *)"Get" + 2B];
            D.30019 = *D.30018;
            D.30020 = (int) D.30019;
            D.30021 = __s2 + 2;
            D.30022 = *D.30021;
            D.30023 = (int) D.30022;
            __result = D.30020 - D.30023;
            if (__s2_len > 2) goto <D.30024>; else goto <D.30025>;
            <D.30024>:
            if (__result == 0) goto <D.30026>; else goto <D.30027>;
            <D.30026>:
            D.30028 = &MEM[(void *)"Get" + 3B];
            D.30029 = *D.30028;
            D.30030 = (int) D.30029;
            D.30031 = __s2 + 3;
            D.30032 = *D.30031;
            D.30033 = (int) D.30032;
            __result = D.30030 - D.30033;
            <D.30027>:
            <D.30025>:
            <D.30017>:
            <D.30015>:
            <D.30007>:
            <D.30005>:
          }
          D.23632 = __result;
        }
        iftmp.188 = -D.23632;
        goto <D.30034>;
        <D.29998>:
        D.29781 = method->name;
        iftmp.188 = __builtin_strcmp (D.29781, "Get");
        <D.30034>:
        D.23633 = iftmp.188;
      }
      if (D.23633 == 0) goto <D.30035>; else goto <D.30036>;
      <D.30035>:
      p.181 = p;
      encode_value (2, p.181, &p);
      goto <D.30037>;
      <D.30036>:
      {
        size_t __s1_len;
        size_t __s2_len;

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

          __s2 = method->name;
          D.30041 = "Address";
          D.30042 = MEM[(const unsigned char *)D.30041];
          D.30043 = (int) D.30042;
          D.30044 = *__s2;
          D.30045 = (int) D.30044;
          __result = D.30043 - D.30045;
          {
            if (__s2_len != 0) goto <D.30046>; else goto <D.30047>;
            <D.30046>:
            if (__result == 0) goto <D.30048>; else goto <D.30049>;
            <D.30048>:
            D.30050 = &MEM[(void *)"Address" + 1B];
            D.30051 = *D.30050;
            D.30052 = (int) D.30051;
            D.30053 = __s2 + 1;
            D.30054 = *D.30053;
            D.30055 = (int) D.30054;
            __result = D.30052 - D.30055;
            if (__s2_len > 1) goto <D.30056>; else goto <D.30057>;
            <D.30056>:
            if (__result == 0) goto <D.30058>; else goto <D.30059>;
            <D.30058>:
            D.30060 = &MEM[(void *)"Address" + 2B];
            D.30061 = *D.30060;
            D.30062 = (int) D.30061;
            D.30063 = __s2 + 2;
            D.30064 = *D.30063;
            D.30065 = (int) D.30064;
            __result = D.30062 - D.30065;
            if (__s2_len > 2) goto <D.30066>; else goto <D.30067>;
            <D.30066>:
            if (__result == 0) goto <D.30068>; else goto <D.30069>;
            <D.30068>:
            D.30070 = &MEM[(void *)"Address" + 3B];
            D.30071 = *D.30070;
            D.30072 = (int) D.30071;
            D.30073 = __s2 + 3;
            D.30074 = *D.30073;
            D.30075 = (int) D.30074;
            __result = D.30072 - D.30075;
            <D.30069>:
            <D.30067>:
            <D.30059>:
            <D.30057>:
            <D.30049>:
            <D.30047>:
          }
          D.23641 = __result;
        }
        iftmp.189 = -D.23641;
        goto <D.30076>;
        <D.30040>:
        D.29781 = method->name;
        iftmp.189 = __builtin_strcmp (D.29781, "Address");
        <D.30076>:
        D.23642 = iftmp.189;
      }
      if (D.23642 == 0) goto <D.30077>; else goto <D.30078>;
      <D.30077>:
      p.181 = p;
      encode_value (3, p.181, &p);
      goto <D.30079>;
      <D.30078>:
      {
        size_t __s1_len;
        size_t __s2_len;

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

          __s2 = method->name;
          D.30083 = "Set";
          D.30084 = MEM[(const unsigned char *)D.30083];
          D.30085 = (int) D.30084;
          D.30086 = *__s2;
          D.30087 = (int) D.30086;
          __result = D.30085 - D.30087;
          {
            if (__s2_len != 0) goto <D.30088>; else goto <D.30089>;
            <D.30088>:
            if (__result == 0) goto <D.30090>; else goto <D.30091>;
            <D.30090>:
            D.30092 = &MEM[(void *)"Set" + 1B];
            D.30093 = *D.30092;
            D.30094 = (int) D.30093;
            D.30095 = __s2 + 1;
            D.30096 = *D.30095;
            D.30097 = (int) D.30096;
            __result = D.30094 - D.30097;
            if (__s2_len > 1) goto <D.30098>; else goto <D.30099>;
            <D.30098>:
            if (__result == 0) goto <D.30100>; else goto <D.30101>;
            <D.30100>:
            D.30102 = &MEM[(void *)"Set" + 2B];
            D.30103 = *D.30102;
            D.30104 = (int) D.30103;
            D.30105 = __s2 + 2;
            D.30106 = *D.30105;
            D.30107 = (int) D.30106;
            __result = D.30104 - D.30107;
            if (__s2_len > 2) goto <D.30108>; else goto <D.30109>;
            <D.30108>:
            if (__result == 0) goto <D.30110>; else goto <D.30111>;
            <D.30110>:
            D.30112 = &MEM[(void *)"Set" + 3B];
            D.30113 = *D.30112;
            D.30114 = (int) D.30113;
            D.30115 = __s2 + 3;
            D.30116 = *D.30115;
            D.30117 = (int) D.30116;
            __result = D.30114 - D.30117;
            <D.30111>:
            <D.30109>:
            <D.30101>:
            <D.30099>:
            <D.30091>:
            <D.30089>:
          }
          D.23650 = __result;
        }
        iftmp.190 = -D.23650;
        goto <D.30118>;
        <D.30082>:
        D.29781 = method->name;
        iftmp.190 = __builtin_strcmp (D.29781, "Set");
        <D.30118>:
        D.23651 = iftmp.190;
      }
      if (D.23651 == 0) goto <D.30119>; else goto <D.30120>;
      <D.30119>:
      p.181 = p;
      encode_value (4, p.181, &p);
      goto <D.30121>;
      <D.30120>:
      monoeg_assertion_message ("* Assertion: should not be reached at %s:%d\n", "aot-compiler.c", 2802);
      <D.30121>:
      <D.30079>:
      <D.30037>:
      <D.29961>:
      <D.29915>:
      <D.29907>:
      goto <D.30122>;
      <D.29902>:
      D.29894 = token >> 24;
      D.29895 = D.29894 != 6;
      D.29896 = (long int) D.29895;
      D.29897 = __builtin_expect (D.29896, 0);
      if (D.29897 != 0) goto <D.30123>; else goto <D.30124>;
      <D.30123>:
      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.30124>:
      if (image_index > 239) goto <D.30125>; else goto <D.30126>;
      <D.30125>:
      p.181 = p;
      encode_value (-117440512, p.181, &p);
      image_index.184 = (int) image_index;
      p.181 = p;
      encode_value (image_index.184, p.181, &p);
      token.185 = (int) token;
      D.30127 = token.185 & 16777215;
      p.181 = p;
      encode_value (D.30127, p.181, &p);
      goto <D.30128>;
      <D.30126>:
      D.30129 = image_index << 24;
      D.30130 = token & 16777215;
      D.30131 = D.30129 | D.30130;
      D.30132 = (int) D.30131;
      p.181 = p;
      encode_value (D.30132, p.181, &p);
      <D.30128>:
      <D.30122>:
      <D.29900>:
      <D.29863>:
      p.181 = p;
      *endbuf = p.181;
    }
  finally
    {
      p = {CLOBBER};
    }
}


encode_signature (struct MonoAotCompile * acfg, struct MonoMethodSignature * sig, guint8 * buf, guint8 * * endbuf)
{
  short unsigned int D.30135;
  unsigned int D.30138;
  unsigned int D.30139;
  unsigned int D.30142;
  <unnamed-unsigned:6> D.30145;
  unsigned int D.30146;
  unsigned int D.30147;
  guint8 * p.191;
  unsigned char D.30149;
  guint8 * p.192;
  int D.30153;
  short unsigned int D.30154;
  int D.30155;
  struct MonoType * D.30156;
  short int D.30157;
  int D.30158;
  struct MonoType * D.30161;
  int D.30162;
  guint8 * p;
  guint32 flags;
  int i;

  try
    {
      p = buf;
      flags = 0;
      D.30135 = sig->generic_param_count;
      if (D.30135 != 0) goto <D.30136>; else goto <D.30137>;
      <D.30136>:
      flags = flags | 16;
      <D.30137>:
      D.30138 = BIT_FIELD_REF <*sig, 32, 64>;
      D.30139 = D.30138 & 4194304;
      if (D.30139 != 0) goto <D.30140>; else goto <D.30141>;
      <D.30140>:
      flags = flags | 32;
      <D.30141>:
      D.30138 = BIT_FIELD_REF <*sig, 32, 64>;
      D.30142 = D.30138 & 8388608;
      if (D.30142 != 0) goto <D.30143>; else goto <D.30144>;
      <D.30143>:
      flags = flags | 64;
      <D.30144>:
      D.30145 = sig->call_convention;
      D.30146 = (unsigned int) D.30145;
      D.30147 = D.30146 & 15;
      flags = D.30147 | flags;
      p.191 = p;
      D.30149 = (unsigned char) flags;
      *p.191 = D.30149;
      p.191 = p;
      p.192 = p.191 + 1;
      p = p.192;
      D.30135 = sig->generic_param_count;
      if (D.30135 != 0) goto <D.30151>; else goto <D.30152>;
      <D.30151>:
      D.30135 = sig->generic_param_count;
      D.30153 = (int) D.30135;
      p.191 = p;
      encode_value (D.30153, p.191, &p);
      <D.30152>:
      D.30154 = sig->param_count;
      D.30155 = (int) D.30154;
      p.191 = p;
      encode_value (D.30155, p.191, &p);
      D.30156 = sig->ret;
      p.191 = p;
      encode_type (acfg, D.30156, p.191, &p);
      i = 0;
      goto <D.23555>;
      <D.23554>:
      D.30157 = sig->sentinelpos;
      D.30158 = (int) D.30157;
      if (D.30158 == i) goto <D.30159>; else goto <D.30160>;
      <D.30159>:
      p.191 = p;
      *p.191 = 65;
      p.191 = p;
      p.192 = p.191 + 1;
      p = p.192;
      <D.30160>:
      D.30161 = sig->params[i];
      p.191 = p;
      encode_type (acfg, D.30161, p.191, &p);
      i = i + 1;
      <D.23555>:
      D.30154 = sig->param_count;
      D.30162 = (int) D.30154;
      if (D.30162 > i) goto <D.23554>; else goto <D.23556>;
      <D.23556>:
      p.191 = p;
      *endbuf = p.191;
    }
  finally
    {
      p = {CLOBBER};
    }
}


encode_generic_context (struct MonoAotCompile * acfg, struct MonoGenericContext * context, guint8 * buf, guint8 * * endbuf)
{
  unsigned int D.30165;
  unsigned int D.30166;
  _Bool D.30167;
  long int D.30168;
  long int D.30169;
  guint8 * p.193;
  guint8 * p;
  struct MonoGenericInst * inst;

  try
    {
      p = buf;
      inst = context->class_inst;
      if (inst != 0B) goto <D.30163>; else goto <D.30164>;
      <D.30163>:
      D.30165 = BIT_FIELD_REF <*inst, 32, 32>;
      D.30166 = D.30165 & 4194303;
      D.30167 = D.30166 == 0;
      D.30168 = (long int) D.30167;
      D.30169 = __builtin_expect (D.30168, 0);
      if (D.30169 != 0) goto <D.30170>; else goto <D.30171>;
      <D.30170>:
      monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "aot-compiler.c", 2425, "inst->type_argc");
      <D.30171>:
      p.193 = p;
      encode_ginst (acfg, inst, p.193, &p);
      goto <D.30173>;
      <D.30164>:
      p.193 = p;
      encode_value (0, p.193, &p);
      <D.30173>:
      inst = context->method_inst;
      if (inst != 0B) goto <D.30174>; else goto <D.30175>;
      <D.30174>:
      D.30165 = BIT_FIELD_REF <*inst, 32, 32>;
      D.30166 = D.30165 & 4194303;
      D.30167 = D.30166 == 0;
      D.30168 = (long int) D.30167;
      D.30169 = __builtin_expect (D.30168, 0);
      if (D.30169 != 0) goto <D.30176>; else goto <D.30177>;
      <D.30176>:
      monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "aot-compiler.c", 2432, "inst->type_argc");
      <D.30177>:
      p.193 = p;
      encode_ginst (acfg, inst, p.193, &p);
      goto <D.30178>;
      <D.30175>:
      p.193 = p;
      encode_value (0, p.193, &p);
      <D.30178>:
      p.193 = p;
      *endbuf = p.193;
    }
  finally
    {
      p = {CLOBBER};
    }
}


encode_type (struct MonoAotCompile * acfg, struct MonoType * t, guint8 * buf, guint8 * * endbuf)
{
  unsigned int D.30179;
  unsigned int D.30180;
  _Bool D.30181;
  long int D.30182;
  long int D.30183;
  unsigned int D.30186;
  guint8 * p.194;
  guint8 * p.195;
  unsigned int D.30191;
  unsigned char D.30194;
  int D.30195;
  struct MonoClass * D.30196;
  struct MonoClass * D.30197;
  struct MonoType * D.30198;
  struct MonoGenericClass * D.30199;
  struct MonoClass * D.30200;
  unsigned char D.30201;
  int D.30202;
  unsigned char D.30203;
  int D.30204;
  int * D.30205;
  unsigned int i.196;
  unsigned int D.30207;
  int * D.30208;
  int D.30209;
  int D.30210;
  unsigned char D.30211;
  int D.30212;
  int * D.30213;
  int * D.30214;
  int D.30215;
  int D.30216;
  struct MonoClass * D.30217;
  guint8 * p;

  try
    {
      p = buf;
      D.30179 = BIT_FIELD_REF <*t, 32, 32>;
      D.30180 = D.30179 & 1056964608;
      D.30181 = D.30180 != 0;
      D.30182 = (long int) D.30181;
      D.30183 = __builtin_expect (D.30182, 0);
      if (D.30183 != 0) goto <D.30184>; else goto <D.30185>;
      <D.30184>:
      monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "aot-compiler.c", 2445, "t->num_mods == 0");
      <D.30185>:
      D.30179 = BIT_FIELD_REF <*t, 32, 32>;
      D.30186 = D.30179 & 2147483648;
      if (D.30186 != 0) goto <D.30187>; else goto <D.30188>;
      <D.30187>:
      p.194 = p;
      *p.194 = 69;
      p.194 = p;
      p.195 = p.194 + 1;
      p = p.195;
      <D.30188>:
      D.30179 = BIT_FIELD_REF <*t, 32, 32>;
      D.30191 = D.30179 & 1073741824;
      if (D.30191 != 0) goto <D.30192>; else goto <D.30193>;
      <D.30192>:
      p.194 = p;
      *p.194 = 16;
      p.194 = p;
      p.195 = p.194 + 1;
      p = p.195;
      <D.30193>:
      p.194 = p;
      D.30194 = t->type;
      *p.194 = D.30194;
      p.194 = p;
      p.195 = p.194 + 1;
      p = p.195;
      D.30194 = t->type;
      D.30195 = (int) D.30194;
      switch (D.30195) <default: <D.23544>, case 1: <D.23507>, case 2: <D.23508>, case 3: <D.23509>, case 4: <D.23510>, case 5: <D.23511>, case 6: <D.23512>, case 7: <D.23513>, case 8: <D.23514>, case 9: <D.23515>, case 10: <D.23516>, case 11: <D.23517>, case 12: <D.23518>, case 13: <D.23519>, case 14: <D.23522>, case 15: <D.23529>, case 17: <D.23526>, case 18: <D.23527>, case 19: <D.23542>, case 20: <D.23533>, case 21: <D.23530>, case 22: <D.23524>, case 24: <D.23520>, case 25: <D.23521>, case 28: <D.23523>, case 29: <D.23528>, case 30: <D.23543>>
      <D.23507>:
      <D.23508>:
      <D.23509>:
      <D.23510>:
      <D.23511>:
      <D.23512>:
      <D.23513>:
      <D.23514>:
      <D.23515>:
      <D.23516>:
      <D.23517>:
      <D.23518>:
      <D.23519>:
      <D.23520>:
      <D.23521>:
      <D.23522>:
      <D.23523>:
      <D.23524>:
      goto <D.23525>;
      <D.23526>:
      <D.23527>:
      D.30196 = mono_class_from_mono_type (t);
      p.194 = p;
      encode_klass_ref (acfg, D.30196, p.194, &p);
      goto <D.23525>;
      <D.23528>:
      D.30197 = t->data.klass;
      p.194 = p;
      encode_klass_ref (acfg, D.30197, p.194, &p);
      goto <D.23525>;
      <D.23529>:
      D.30198 = t->data.type;
      p.194 = p;
      encode_type (acfg, D.30198, p.194, &p);
      goto <D.23525>;
      <D.23530>:
      {
        struct MonoClass * gclass;
        struct MonoGenericInst * inst;

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

        array = t->data.array;
        D.30200 = array->eklass;
        p.194 = p;
        encode_klass_ref (acfg, D.30200, p.194, &p);
        D.30201 = array->rank;
        D.30202 = (int) D.30201;
        p.194 = p;
        encode_value (D.30202, p.194, &p);
        D.30203 = array->numsizes;
        D.30204 = (int) D.30203;
        p.194 = p;
        encode_value (D.30204, p.194, &p);
        i = 0;
        goto <D.23537>;
        <D.23536>:
        D.30205 = array->sizes;
        i.196 = (unsigned int) i;
        D.30207 = i.196 * 4;
        D.30208 = D.30205 + D.30207;
        D.30209 = *D.30208;
        p.194 = p;
        encode_value (D.30209, p.194, &p);
        i = i + 1;
        <D.23537>:
        D.30203 = array->numsizes;
        D.30210 = (int) D.30203;
        if (D.30210 > i) goto <D.23536>; else goto <D.23538>;
        <D.23538>:
        D.30211 = array->numlobounds;
        D.30212 = (int) D.30211;
        p.194 = p;
        encode_value (D.30212, p.194, &p);
        i = 0;
        goto <D.23540>;
        <D.23539>:
        D.30213 = array->lobounds;
        i.196 = (unsigned int) i;
        D.30207 = i.196 * 4;
        D.30214 = D.30213 + D.30207;
        D.30215 = *D.30214;
        p.194 = p;
        encode_value (D.30215, p.194, &p);
        i = i + 1;
        <D.23540>:
        D.30211 = array->numlobounds;
        D.30216 = (int) D.30211;
        if (D.30216 > i) goto <D.23539>; else goto <D.23541>;
        <D.23541>:
        goto <D.23525>;
      }
      <D.23542>:
      <D.23543>:
      D.30217 = mono_class_from_mono_type (t);
      p.194 = p;
      encode_klass_ref (acfg, D.30217, p.194, &p);
      goto <D.23525>;
      <D.23544>:
      monoeg_assertion_message ("* Assertion: should not be reached at %s:%d\n", "aot-compiler.c", 2518);
      <D.23525>:
      p.194 = p;
      *endbuf = p.194;
    }
  finally
    {
      p = {CLOBBER};
    }
}


encode_value (gint32 value, guint8 * buf, guint8 * * endbuf)
{
  unsigned int value.197;
  guint8 * p.198;
  unsigned char D.30223;
  int D.30227;
  signed char D.30228;
  signed char D.30229;
  unsigned char D.30230;
  guint8 * D.30231;
  unsigned char D.30232;
  int D.30236;
  signed char D.30237;
  signed char D.30238;
  unsigned char D.30239;
  int D.30240;
  unsigned char D.30241;
  guint8 * D.30242;
  unsigned char D.30243;
  guint8 * D.30244;
  unsigned int D.30246;
  unsigned char D.30247;
  guint8 * D.30248;
  guint8 * p;

  p = buf;
  value.197 = (unsigned int) value;
  if (value.197 <= 127) goto <D.30220>; else goto <D.30221>;
  <D.30220>:
  p.198 = p;
  p = p.198 + 1;
  D.30223 = (unsigned char) value;
  *p.198 = D.30223;
  goto <D.30224>;
  <D.30221>:
  value.197 = (unsigned int) value;
  if (value.197 <= 16383) goto <D.30225>; else goto <D.30226>;
  <D.30225>:
  D.30227 = value >> 8;
  D.30228 = (signed char) D.30227;
  D.30229 = D.30228 | -128;
  D.30230 = (unsigned char) D.30229;
  *p = D.30230;
  D.30231 = p + 1;
  D.30232 = (unsigned char) value;
  *D.30231 = D.30232;
  p = p + 2;
  goto <D.30233>;
  <D.30226>:
  value.197 = (unsigned int) value;
  if (value.197 <= 536870911) goto <D.30234>; else goto <D.30235>;
  <D.30234>:
  D.30236 = value >> 24;
  D.30237 = (signed char) D.30236;
  D.30238 = D.30237 | -64;
  D.30239 = (unsigned char) D.30238;
  *p = D.30239;
  D.30231 = p + 1;
  D.30240 = value >> 16;
  D.30241 = (unsigned char) D.30240;
  *D.30231 = D.30241;
  D.30242 = p + 2;
  D.30227 = value >> 8;
  D.30243 = (unsigned char) D.30227;
  *D.30242 = D.30243;
  D.30244 = p + 3;
  D.30232 = (unsigned char) value;
  *D.30244 = D.30232;
  p = p + 4;
  goto <D.30245>;
  <D.30235>:
  *p = 255;
  D.30231 = p + 1;
  value.197 = (unsigned int) value;
  D.30246 = value.197 >> 24;
  D.30247 = (unsigned char) D.30246;
  *D.30231 = D.30247;
  D.30242 = p + 2;
  D.30240 = value >> 16;
  D.30241 = (unsigned char) D.30240;
  *D.30242 = D.30241;
  D.30244 = p + 3;
  D.30227 = value >> 8;
  D.30243 = (unsigned char) D.30227;
  *D.30244 = D.30243;
  D.30248 = p + 4;
  D.30232 = (unsigned char) value;
  *D.30248 = D.30232;
  p = p + 5;
  <D.30245>:
  <D.30233>:
  <D.30224>:
  if (endbuf != 0B) goto <D.30249>; else goto <D.30250>;
  <D.30249>:
  *endbuf = p;
  <D.30250>:
}


encode_patch_list (struct MonoAotCompile * acfg, struct GPtrArray * patches, int n_patches, int first_got_offset, guint8 * buf, guint8 * * endbuf)
{
  guint8 * p.199;
  void * * D.30252;
  unsigned int D.30253;
  void * * D.30254;
  <unnamed type> D.30257;
  int offset.200;
  unsigned int D.30260;
  guint8 * p;
  guint32 pindex;
  guint32 offset;
  struct MonoJumpInfo * patch_info;

  try
    {
      p = buf;
      p.199 = p;
      encode_value (n_patches, p.199, &p);
      pindex = 0;
      goto <D.24556>;
      <D.24555>:
      D.30252 = patches->pdata;
      D.30253 = pindex * 4;
      D.30254 = D.30252 + D.30253;
      patch_info = *D.30254;
      D.30257 = patch_info->type;
      if (D.30257 == 51) goto <D.30255>; else goto <D.30258>;
      <D.30258>:
      D.30257 = patch_info->type;
      if (D.30257 == 0) goto <D.30255>; else goto <D.30256>;
      <D.30255>:
      // predicted unlikely by continue predictor.
      goto <D.24554>;
      <D.30256>:
      offset = get_got_offset (acfg, patch_info);
      offset.200 = (int) offset;
      p.199 = p;
      encode_value (offset.200, p.199, &p);
      <D.24554>:
      pindex = pindex + 1;
      <D.24556>:
      D.30260 = patches->len;
      if (D.30260 > pindex) goto <D.24555>; else goto <D.24557>;
      <D.24557>:
      p.199 = p;
      *endbuf = p.199;
    }
  finally
    {
      p = {CLOBBER};
    }
}


add_to_blob (struct MonoAotCompile * acfg, const guint8 * data, guint32 data_len)
{
  unsigned int D.30261;
  struct MonoDynamicStream * D.30264;
  guint32 D.30265;

  D.30261 = acfg->blob.alloc_size;
  if (D.30261 == 0) goto <D.30262>; else goto <D.30263>;
  <D.30262>:
  D.30264 = &acfg->blob;
  stream_init (D.30264);
  <D.30263>:
  D.30264 = &acfg->blob;
  D.30265 = add_stream_data (D.30264, data, data_len);
  return D.30265;
}


stream_init (struct MonoDynamicStream * sh)
{
  void * D.30267;
  char * D.30268;
  unsigned int D.30269;
  unsigned int D.30270;

  sh->index = 0;
  sh->alloc_size = 4096;
  D.30267 = monoeg_malloc (4096);
  sh->data = D.30267;
  D.30268 = sh->data;
  *D.30268 = 0;
  D.30269 = sh->index;
  D.30270 = D.30269 + 1;
  sh->index = D.30270;
}


add_stream_data (struct MonoDynamicStream * stream, const char * data, guint32 len)
{
  unsigned int D.30271;
  unsigned int D.30272;
  int D.30273;
  char * D.30274;
  char * D.30275;
  guint32 D.30276;
  guint32 idx;

  D.30271 = stream->index;
  D.30272 = D.30271 + len;
  D.30273 = (int) D.30272;
  make_room_in_stream (stream, D.30273);
  D.30274 = stream->data;
  D.30271 = stream->index;
  D.30275 = D.30274 + D.30271;
  memcpy (D.30275, data, len);
  idx = stream->index;
  D.30271 = stream->index;
  D.30272 = D.30271 + len;
  stream->index = D.30272;
  D.30276 = idx;
  return D.30276;
}


make_room_in_stream (struct MonoDynamicStream * stream, int size)
{
  unsigned int size.201;
  unsigned int D.30279;
  unsigned int D.30285;
  char * D.30286;
  void * D.30287;

  size.201 = (unsigned int) size;
  D.30279 = stream->alloc_size;
  if (size.201 <= D.30279) goto <D.30280>; else goto <D.30281>;
  <D.30280>:
  return;
  <D.30281>:
  goto <D.23369>;
  <D.23368>:
  D.30279 = stream->alloc_size;
  if (D.30279 <= 4095) goto <D.30282>; else goto <D.30283>;
  <D.30282>:
  stream->alloc_size = 4096;
  goto <D.30284>;
  <D.30283>:
  D.30279 = stream->alloc_size;
  D.30285 = D.30279 * 2;
  stream->alloc_size = D.30285;
  <D.30284>:
  <D.23369>:
  D.30279 = stream->alloc_size;
  size.201 = (unsigned int) size;
  if (D.30279 <= size.201) goto <D.23368>; else goto <D.23370>;
  <D.23370>:
  D.30286 = stream->data;
  D.30279 = stream->alloc_size;
  D.30287 = monoeg_realloc (D.30286, D.30279);
  stream->data = D.30287;
}


emit_offset_table (struct MonoAotCompile * acfg, int noffsets, int group_size, gint32 * offsets)
{
  int D.30289;
  int D.30290;
  unsigned int ngroups.202;
  unsigned int D.30292;
  unsigned int buf_size.203;
  int D.30294;
  int D.30297;
  unsigned int D.30298;
  unsigned int D.30299;
  guint32 * D.30300;
  guint8 * p.204;
  int p.205;
  int buf.206;
  int D.30304;
  unsigned int D.30305;
  unsigned int i.207;
  unsigned int D.30307;
  gint32 * D.30308;
  int D.30309;
  int D.30311;
  sizetype ngroups.208;
  sizetype D.30316;
  sizetype D.30317;
  guint32 * D.30318;
  unsigned int D.30319;
  guint32 * D.30323;
  unsigned int D.30324;
  int D.30325;
  guint32 D.30327;
  int D.30328;
  int D.30329;
  gint32 current_offset;
  int i;
  int buf_size;
  int ngroups;
  int index_entry_size;
  guint8 * p;
  guint8 * buf;
  guint32 * index_offsets;

  try
    {
      D.30289 = group_size + -1;
      D.30290 = D.30289 + noffsets;
      ngroups = D.30290 / group_size;
      ngroups.202 = (unsigned int) ngroups;
      D.30292 = ngroups.202 * 4;
      index_offsets = monoeg_malloc0 (D.30292);
      buf_size = noffsets * 4;
      buf_size.203 = (unsigned int) buf_size;
      buf = monoeg_malloc0 (buf_size.203);
      p = buf;
      current_offset = 0;
      i = 0;
      goto <D.23405>;
      <D.23404>:
      D.30294 = i % group_size;
      if (D.30294 == 0) goto <D.30295>; else goto <D.30296>;
      <D.30295>:
      D.30297 = i / group_size;
      D.30298 = (unsigned int) D.30297;
      D.30299 = D.30298 * 4;
      D.30300 = index_offsets + D.30299;
      p.204 = p;
      p.205 = (int) p.204;
      buf.206 = (int) buf;
      D.30304 = p.205 - buf.206;
      D.30305 = (unsigned int) D.30304;
      *D.30300 = D.30305;
      i.207 = (unsigned int) i;
      D.30307 = i.207 * 4;
      D.30308 = offsets + D.30307;
      D.30309 = *D.30308;
      p.204 = p;
      encode_value (D.30309, p.204, &p);
      goto <D.30310>;
      <D.30296>:
      i.207 = (unsigned int) i;
      D.30307 = i.207 * 4;
      D.30308 = offsets + D.30307;
      D.30309 = *D.30308;
      D.30311 = D.30309 - current_offset;
      p.204 = p;
      encode_value (D.30311, p.204, &p);
      <D.30310>:
      i.207 = (unsigned int) i;
      D.30307 = i.207 * 4;
      D.30308 = offsets + D.30307;
      current_offset = *D.30308;
      i = i + 1;
      <D.23405>:
      if (i < noffsets) goto <D.23404>; else goto <D.23406>;
      <D.23406>:
      if (ngroups != 0) goto <D.30314>; else goto <D.30312>;
      <D.30314>:
      ngroups.208 = (sizetype) ngroups;
      D.30316 = ngroups.208 + 1073741823;
      D.30317 = D.30316 * 4;
      D.30318 = index_offsets + D.30317;
      D.30319 = *D.30318;
      if (D.30319 <= 64999) goto <D.30320>; else goto <D.30312>;
      <D.30320>:
      index_entry_size = 2;
      goto <D.30313>;
      <D.30312>:
      index_entry_size = 4;
      <D.30313>:
      emit_int32 (acfg, noffsets);
      emit_int32 (acfg, group_size);
      emit_int32 (acfg, ngroups);
      emit_int32 (acfg, index_entry_size);
      i = 0;
      goto <D.23408>;
      <D.23407>:
      if (index_entry_size == 2) goto <D.30321>; else goto <D.30322>;
      <D.30321>:
      i.207 = (unsigned int) i;
      D.30307 = i.207 * 4;
      D.30323 = index_offsets + D.30307;
      D.30324 = *D.30323;
      D.30325 = (int) D.30324;
      emit_int16 (acfg, D.30325);
      goto <D.30326>;
      <D.30322>:
      i.207 = (unsigned int) i;
      D.30307 = i.207 * 4;
      D.30323 = index_offsets + D.30307;
      D.30324 = *D.30323;
      D.30325 = (int) D.30324;
      emit_int32 (acfg, D.30325);
      <D.30326>:
      i = i + 1;
      <D.23408>:
      if (i < ngroups) goto <D.23407>; else goto <D.23409>;
      <D.23409>:
      p.204 = p;
      p.205 = (int) p.204;
      buf.206 = (int) buf;
      D.30304 = p.205 - buf.206;
      emit_bytes (acfg, buf, D.30304);
      p.204 = p;
      p.205 = (int) p.204;
      buf.206 = (int) buf;
      D.30304 = p.205 - buf.206;
      D.30328 = ngroups * 4;
      D.30329 = D.30304 + D.30328;
      D.30327 = (guint32) D.30329;
      return D.30327;
    }
  finally
    {
      p = {CLOBBER};
    }
}


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

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


emit_extra_methods (struct MonoAotCompile * acfg)
{
  struct GPtrArray * D.30333;
  unsigned int D.30334;
  unsigned int D.30335;
  void * * D.30336;
  unsigned int i.209;
  unsigned int D.30338;
  void * * D.30339;
  struct GHashTable * D.30340;
  unsigned int buf_size.210;
  guint8 * p.211;
  int p.212;
  int buf.213;
  int D.30347;
  _Bool D.30348;
  long int D.30349;
  long int D.30350;
  guint32 * D.30353;
  unsigned int D.30354;
  unsigned int D.30355;
  unsigned int i.214;
  double D.30357;
  double D.30358;
  int D.30359;
  unsigned int D.30360;
  unsigned int D.30361;
  unsigned int table_size.215;
  unsigned int table_size.216;
  unsigned int D.30364;
  unsigned int D.30367;
  unsigned int table_size.217;
  unsigned int D.30369;
  int * D.30370;
  int D.30371;
  int D.30372;
  struct MonoMemPool * D.30373;
  void * * D.30374;
  void * * D.30375;
  struct HashEntry * D.30379;
  unsigned int D.30380;
  void * * D.30381;
  unsigned int D.30385;
  int D.30386;
  unsigned int D.30387;
  int D.30388;
  struct HashEntry * D.30389;
  unsigned int D.30392;
  int D.30393;
  int D.30395;
  unsigned int D.30396;
  int D.30397;
  unsigned int D.30398;
  int D.30399;
  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.30333 = acfg->extra_methods;
      D.30334 = D.30333->len;
      D.30335 = D.30334 * 4;
      info_offsets = monoeg_malloc0 (D.30335);
      nmethods = 0;
      i = 0;
      goto <D.25249>;
      <D.25248>:
      {
        struct MonoMethod * method;
        struct MonoCompile * cfg;

        D.30333 = acfg->extra_methods;
        D.30336 = D.30333->pdata;
        i.209 = (unsigned int) i;
        D.30338 = i.209 * 4;
        D.30339 = D.30336 + D.30338;
        method = *D.30339;
        D.30340 = acfg->method_to_cfg;
        cfg = monoeg_g_hash_table_lookup (D.30340, method);
        if (cfg == 0B) goto <D.30341>; else goto <D.30342>;
        <D.30341>:
        // predicted unlikely by continue predictor.
        goto <D.25247>;
        <D.30342>:
        buf_size = 10240;
        buf_size.210 = (unsigned int) buf_size;
        buf = monoeg_malloc (buf_size.210);
        p = buf;
        nmethods = nmethods + 1;
        method = cfg->method_to_register;
        p.211 = p;
        encode_method_ref (acfg, method, p.211, &p);
        p.211 = p;
        p.212 = (int) p.211;
        buf.213 = (int) buf;
        D.30347 = p.212 - buf.213;
        D.30348 = D.30347 >= buf_size;
        D.30349 = (long int) D.30348;
        D.30350 = __builtin_expect (D.30349, 0);
        if (D.30350 != 0) goto <D.30351>; else goto <D.30352>;
        <D.30351>:
        monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "aot-compiler.c", 7508, "(p - buf) < buf_size");
        <D.30352>:
        i.209 = (unsigned int) i;
        D.30338 = i.209 * 4;
        D.30353 = info_offsets + D.30338;
        p.211 = p;
        p.212 = (int) p.211;
        buf.213 = (int) buf;
        D.30347 = p.212 - buf.213;
        D.30354 = (unsigned int) D.30347;
        D.30355 = add_to_blob (acfg, buf, D.30354);
        *D.30353 = D.30355;
        monoeg_g_free (buf);
      }
      <D.25247>:
      i = i + 1;
      <D.25249>:
      i.214 = (unsigned int) i;
      D.30333 = acfg->extra_methods;
      D.30334 = D.30333->len;
      if (i.214 < D.30334) goto <D.25248>; else goto <D.25250>;
      <D.25250>:
      D.30357 = (double) nmethods;
      D.30358 = D.30357 * 1.5e+0;
      D.30359 = (int) D.30358;
      D.30360 = (unsigned int) D.30359;
      D.30361 = monoeg_g_spaced_primes_closest (D.30360);
      table_size = (int) D.30361;
      table_size.215 = (unsigned int) table_size;
      table = monoeg_g_ptr_array_sized_new (table_size.215);
      i = 0;
      goto <D.25252>;
      <D.25251>:
      monoeg_g_ptr_array_add (table, 0B);
      i = i + 1;
      <D.25252>:
      if (i < table_size) goto <D.25251>; else goto <D.25253>;
      <D.25253>:
      table_size.216 = (unsigned int) table_size;
      D.30364 = table_size.216 * 4;
      chain_lengths = monoeg_malloc0 (D.30364);
      max_chain_length = 0;
      i = 0;
      goto <D.25263>;
      <D.25262>:
      {
        struct MonoMethod * method;
        struct MonoCompile * cfg;
        guint32 key;
        guint32 value;

        D.30333 = acfg->extra_methods;
        D.30336 = D.30333->pdata;
        i.209 = (unsigned int) i;
        D.30338 = i.209 * 4;
        D.30339 = D.30336 + D.30338;
        method = *D.30339;
        D.30340 = acfg->method_to_cfg;
        cfg = monoeg_g_hash_table_lookup (D.30340, method);
        if (cfg == 0B) goto <D.30365>; else goto <D.30366>;
        <D.30365>:
        // predicted unlikely by continue predictor.
        goto <D.25258>;
        <D.30366>:
        i.209 = (unsigned int) i;
        D.30338 = i.209 * 4;
        D.30353 = info_offsets + D.30338;
        key = *D.30353;
        value = get_method_index (acfg, method);
        D.30367 = mono_aot_method_hash (method);
        table_size.217 = (unsigned int) table_size;
        hash = D.30367 % table_size.217;
        D.30369 = hash * 4;
        D.30370 = chain_lengths + D.30369;
        D.30371 = *D.30370;
        D.30372 = D.30371 + 1;
        *D.30370 = D.30372;
        D.30369 = hash * 4;
        D.30370 = chain_lengths + D.30369;
        D.30371 = *D.30370;
        max_chain_length = MAX_EXPR <D.30371, max_chain_length>;
        D.30373 = acfg->mempool;
        new_entry = mono_mempool_alloc0 (D.30373, 16);
        new_entry->key = key;
        new_entry->value = value;
        D.30374 = table->pdata;
        D.30369 = hash * 4;
        D.30375 = D.30374 + D.30369;
        entry = *D.30375;
        if (entry == 0B) goto <D.30376>; else goto <D.30377>;
        <D.30376>:
        new_entry->index = hash;
        D.30374 = table->pdata;
        D.30369 = hash * 4;
        D.30375 = D.30374 + D.30369;
        *D.30375 = new_entry;
        goto <D.30378>;
        <D.30377>:
        goto <D.25260>;
        <D.25259>:
        entry = entry->next;
        <D.25260>:
        D.30379 = entry->next;
        if (D.30379 != 0B) goto <D.25259>; else goto <D.25261>;
        <D.25261>:
        entry->next = new_entry;
        D.30380 = table->len;
        new_entry->index = D.30380;
        monoeg_g_ptr_array_add (table, new_entry);
        <D.30378>:
      }
      <D.25258>:
      i = i + 1;
      <D.25263>:
      i.214 = (unsigned int) i;
      D.30333 = acfg->extra_methods;
      D.30334 = D.30333->len;
      if (i.214 < D.30334) goto <D.25262>; else goto <D.25264>;
      <D.25264>:
      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.25267>;
      <D.25266>:
      {
        struct HashEntry * entry;

        D.30374 = table->pdata;
        i.209 = (unsigned int) i;
        D.30338 = i.209 * 4;
        D.30381 = D.30374 + D.30338;
        entry = *D.30381;
        if (entry == 0B) goto <D.30382>; else goto <D.30383>;
        <D.30382>:
        emit_int32 (acfg, 0);
        emit_int32 (acfg, 0);
        emit_int32 (acfg, 0);
        goto <D.30384>;
        <D.30383>:
        D.30385 = entry->key;
        D.30386 = (int) D.30385;
        emit_int32 (acfg, D.30386);
        D.30387 = entry->value;
        D.30388 = (int) D.30387;
        emit_int32 (acfg, D.30388);
        D.30389 = entry->next;
        if (D.30389 != 0B) goto <D.30390>; else goto <D.30391>;
        <D.30390>:
        D.30389 = entry->next;
        D.30392 = D.30389->index;
        D.30393 = (int) D.30392;
        emit_int32 (acfg, D.30393);
        goto <D.30394>;
        <D.30391>:
        emit_int32 (acfg, 0);
        <D.30394>:
        <D.30384>:
      }
      i = i + 1;
      <D.25267>:
      i.214 = (unsigned int) i;
      D.30380 = table->len;
      if (i.214 < D.30380) goto <D.25266>; else goto <D.25268>;
      <D.25268>:
      sprintf (&symbol, "extra_method_info_offsets");
      emit_section_change (acfg, ".rodata", 0);
      emit_alignment (acfg, 8);
      emit_label (acfg, &symbol);
      D.30333 = acfg->extra_methods;
      D.30334 = D.30333->len;
      D.30395 = (int) D.30334;
      emit_int32 (acfg, D.30395);
      i = 0;
      goto <D.25271>;
      <D.25270>:
      {
        struct MonoMethod * method;

        D.30333 = acfg->extra_methods;
        D.30336 = D.30333->pdata;
        i.209 = (unsigned int) i;
        D.30338 = i.209 * 4;
        D.30339 = D.30336 + D.30338;
        method = *D.30339;
        D.30396 = get_method_index (acfg, method);
        D.30397 = (int) D.30396;
        emit_int32 (acfg, D.30397);
        i.209 = (unsigned int) i;
        D.30338 = i.209 * 4;
        D.30353 = info_offsets + D.30338;
        D.30398 = *D.30353;
        D.30399 = (int) D.30398;
        emit_int32 (acfg, D.30399);
      }
      i = i + 1;
      <D.25271>:
      i.214 = (unsigned int) i;
      D.30333 = acfg->extra_methods;
      D.30334 = D.30333->len;
      if (i.214 < D.30334) goto <D.25270>; else goto <D.25272>;
      <D.25272>:
    }
  finally
    {
      symbol = {CLOBBER};
      p = {CLOBBER};
    }
}


emit_trampolines (struct MonoAotCompile * acfg)
{
  int D.30400;
  struct MonoImage * D.30403;
  struct MonoAssembly * D.30404;
  _Bool D.30405;
  long int D.30406;
  long int D.30407;
  int D.24779;
  int iftmp.218;
  int D.24778;
  const char[9] * D.30413;
  unsigned char D.30414;
  int D.30415;
  unsigned char D.30416;
  int D.30417;
  const unsigned char * D.30422;
  unsigned char D.30423;
  int D.30424;
  const unsigned char * D.30425;
  unsigned char D.30426;
  int D.30427;
  const unsigned char * D.30432;
  unsigned char D.30433;
  int D.30434;
  const unsigned char * D.30435;
  unsigned char D.30436;
  int D.30437;
  const unsigned char * D.30442;
  unsigned char D.30443;
  int D.30444;
  const unsigned char * D.30445;
  unsigned char D.30446;
  int D.30447;
  const char * D.30449;
  unsigned int D.30452;
  int D.30453;
  unsigned int tramp_got_offset.219;
  unsigned int D.30457;
  int tramp_size.220;
  _Bool D.30461;
  long int D.30462;
  long int D.30463;
  unsigned int tramp_size.221;
  unsigned int i.222;
  unsigned int D.30468;
  unsigned int D.30469;
  unsigned int D.30470;
  unsigned int D.30471;
  char symbol[256];
  char end_symbol[256];
  int i;
  int tramp_got_offset;
  MonoAotTrampoline ntype;

  try
    {
      D.30400 = acfg->aot_opts.full_aot;
      if (D.30400 == 0) goto <D.30401>; else goto <D.30402>;
      <D.30401>:
      return;
      <D.30402>:
      D.30403 = acfg->image;
      D.30404 = D.30403->assembly;
      D.30405 = D.30404 == 0B;
      D.30406 = (long int) D.30405;
      D.30407 = __builtin_expect (D.30406, 0);
      if (D.30407 != 0) goto <D.30408>; else goto <D.30409>;
      <D.30408>:
      monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "aot-compiler.c", 5896, "acfg->image->assembly");
      <D.30409>:
      {
        size_t __s1_len;
        size_t __s2_len;

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

          D.30403 = acfg->image;
          D.30404 = D.30403->assembly;
          __s2 = D.30404->aname.name;
          D.30413 = "mscorlib";
          D.30414 = MEM[(const unsigned char *)D.30413];
          D.30415 = (int) D.30414;
          D.30416 = *__s2;
          D.30417 = (int) D.30416;
          __result = D.30415 - D.30417;
          {
            if (__s2_len != 0) goto <D.30418>; else goto <D.30419>;
            <D.30418>:
            if (__result == 0) goto <D.30420>; else goto <D.30421>;
            <D.30420>:
            D.30422 = &MEM[(void *)"mscorlib" + 1B];
            D.30423 = *D.30422;
            D.30424 = (int) D.30423;
            D.30425 = __s2 + 1;
            D.30426 = *D.30425;
            D.30427 = (int) D.30426;
            __result = D.30424 - D.30427;
            if (__s2_len > 1) goto <D.30428>; else goto <D.30429>;
            <D.30428>:
            if (__result == 0) goto <D.30430>; else goto <D.30431>;
            <D.30430>:
            D.30432 = &MEM[(void *)"mscorlib" + 2B];
            D.30433 = *D.30432;
            D.30434 = (int) D.30433;
            D.30435 = __s2 + 2;
            D.30436 = *D.30435;
            D.30437 = (int) D.30436;
            __result = D.30434 - D.30437;
            if (__s2_len > 2) goto <D.30438>; else goto <D.30439>;
            <D.30438>:
            if (__result == 0) goto <D.30440>; else goto <D.30441>;
            <D.30440>:
            D.30442 = &MEM[(void *)"mscorlib" + 3B];
            D.30443 = *D.30442;
            D.30444 = (int) D.30443;
            D.30445 = __s2 + 3;
            D.30446 = *D.30445;
            D.30447 = (int) D.30446;
            __result = D.30444 - D.30447;
            <D.30441>:
            <D.30439>:
            <D.30431>:
            <D.30429>:
            <D.30421>:
            <D.30419>:
          }
          D.24778 = __result;
        }
        iftmp.218 = -D.24778;
        goto <D.30448>;
        <D.30412>:
        D.30403 = acfg->image;
        D.30404 = D.30403->assembly;
        D.30449 = D.30404->aname.name;
        iftmp.218 = __builtin_strcmp (D.30449, "mscorlib");
        <D.30448>:
        D.24779 = iftmp.218;
      }
      if (D.24779 == 0) goto <D.30450>; else goto <D.30451>;
      <D.30450>:
      emit_section_change (acfg, ".text", 0);
      D.30452 = acfg->got_offset;
      tramp_got_offset = (int) D.30452;
      ntype = 0;
      goto <D.24797>;
      <D.24796>:
      switch (ntype) <default: <D.24785>, case 0: <D.24780>, case 1: <D.24782>, case 2: <D.24783>, case 3: <D.24784>>
      <D.24780>:
      sprintf (&symbol, "specific_trampolines");
      goto <D.24781>;
      <D.24782>:
      sprintf (&symbol, "static_rgctx_trampolines");
      goto <D.24781>;
      <D.24783>:
      sprintf (&symbol, "imt_thunks");
      goto <D.24781>;
      <D.24784>:
      sprintf (&symbol, "gsharedvt_arg_trampolines");
      goto <D.24781>;
      <D.24785>:
      monoeg_assertion_message ("* Assertion: should not be reached at %s:%d\n", "aot-compiler.c", 6053);
      <D.24781>:
      sprintf (&end_symbol, "%s_e", &symbol);
      D.30453 = acfg->aot_opts.write_symbols;
      if (D.30453 != 0) goto <D.30454>; else goto <D.30455>;
      <D.30454>:
      emit_local_symbol (acfg, &symbol, &end_symbol, 1);
      <D.30455>:
      emit_alignment (acfg, 16);
      emit_label (acfg, &symbol);
      tramp_got_offset.219 = (unsigned int) tramp_got_offset;
      acfg->trampoline_got_offset_base[ntype] = tramp_got_offset.219;
      i = 0;
      goto <D.24794>;
      <D.24793>:
      {
        int tramp_size;

        try
          {
            tramp_size = 0;
            switch (ntype) <default: <D.24792>, case 0: <D.24787>, case 1: <D.24789>, case 2: <D.24790>, case 3: <D.24791>>
            <D.24787>:
            arch_emit_specific_trampoline (acfg, tramp_got_offset, &tramp_size);
            tramp_got_offset = tramp_got_offset + 2;
            goto <D.24788>;
            <D.24789>:
            arch_emit_static_rgctx_trampoline (acfg, tramp_got_offset, &tramp_size);
            tramp_got_offset = tramp_got_offset + 2;
            goto <D.24788>;
            <D.24790>:
            arch_emit_imt_thunk (acfg, tramp_got_offset, &tramp_size);
            tramp_got_offset = tramp_got_offset + 1;
            goto <D.24788>;
            <D.24791>:
            arch_emit_gsharedvt_arg_trampoline (acfg, tramp_got_offset, &tramp_size);
            tramp_got_offset = tramp_got_offset + 2;
            goto <D.24788>;
            <D.24792>:
            monoeg_assertion_message ("* Assertion: should not be reached at %s:%d\n", "aot-compiler.c", 6087);
            <D.24788>:
            D.30457 = acfg->trampoline_size[ntype];
            if (D.30457 == 0) goto <D.30458>; else goto <D.30459>;
            <D.30458>:
            tramp_size.220 = tramp_size;
            D.30461 = tramp_size.220 == 0;
            D.30462 = (long int) D.30461;
            D.30463 = __builtin_expect (D.30462, 0);
            if (D.30463 != 0) goto <D.30464>; else goto <D.30465>;
            <D.30464>:
            monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "aot-compiler.c", 6095, "tramp_size");
            <D.30465>:
            tramp_size.220 = tramp_size;
            tramp_size.221 = (unsigned int) tramp_size.220;
            acfg->trampoline_size[ntype] = tramp_size.221;
            <D.30459>:
          }
        finally
          {
            tramp_size = {CLOBBER};
          }
      }
      i = i + 1;
      <D.24794>:
      i.222 = (unsigned int) i;
      D.30468 = acfg->num_trampolines[ntype];
      if (i.222 < D.30468) goto <D.24793>; else goto <D.24795>;
      <D.24795>:
      emit_label (acfg, &end_symbol);
      emit_int32 (acfg, 0);
      ntype = ntype + 1;
      <D.24797>:
      if (ntype <= 3) goto <D.24796>; else goto <D.24798>;
      <D.24798>:
      arch_emit_specific_trampoline_pages (acfg);
      tramp_got_offset.219 = (unsigned int) tramp_got_offset;
      D.30452 = acfg->got_offset;
      D.30469 = tramp_got_offset.219 - D.30452;
      acfg->num_trampoline_got_entries = D.30469;
      <D.30451>:
      D.30452 = acfg->got_offset;
      D.30470 = acfg->num_trampoline_got_entries;
      D.30471 = D.30452 + D.30470;
      acfg->got_offset = D.30471;
    }
  finally
    {
      symbol = {CLOBBER};
      end_symbol = {CLOBBER};
    }
}


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


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


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


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


arch_emit_specific_trampoline_pages (struct MonoAotCompile * acfg)
{

}


emit_class_name_table (struct MonoAotCompile * acfg)
{
  struct MonoImage * D.30475;
  <unnamed-unsigned:24> D.30476;
  int D.30477;
  double D.30478;
  double D.30479;
  int D.30480;
  unsigned int D.30481;
  unsigned int D.30482;
  unsigned int table_size.223;
  int D.30484;
  int D.30485;
  struct MonoType * D.30488;
  unsigned int D.30489;
  void * * D.30490;
  unsigned int D.30491;
  void * * D.30492;
  struct ClassNameTableEntry * D.30496;
  unsigned int D.30497;
  _Bool D.30498;
  long int D.30499;
  long int D.30500;
  _Bool D.30503;
  long int D.30504;
  long int D.30505;
  unsigned int i.224;
  unsigned int D.30509;
  void * * D.30510;
  unsigned int D.30514;
  int D.30515;
  int D.30516;
  struct ClassNameTableEntry * D.30517;
  unsigned int D.30520;
  int D.30521;
  unsigned int i.225;
  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.30475 = acfg->image;
      D.30476 = D.30475->tables[2].rows;
      D.30477 = (int) D.30476;
      D.30478 = (double) D.30477;
      D.30479 = D.30478 * 1.5e+0;
      D.30480 = (int) D.30479;
      D.30481 = (unsigned int) D.30480;
      D.30482 = monoeg_g_spaced_primes_closest (D.30481);
      table_size = (int) D.30482;
      table_size.223 = (unsigned int) table_size;
      table = monoeg_g_ptr_array_sized_new (table_size.223);
      i = 0;
      goto <D.25323>;
      <D.25322>:
      monoeg_g_ptr_array_add (table, 0B);
      i = i + 1;
      <D.25323>:
      if (i < table_size) goto <D.25322>; else goto <D.25324>;
      <D.25324>:
      i = 0;
      goto <D.25330>;
      <D.25329>:
      D.30484 = i + 1;
      D.30485 = D.30484 | 33554432;
      token = (guint32) D.30485;
      D.30475 = acfg->image;
      klass = mono_class_get (D.30475, token);
      if (klass == 0B) goto <D.30486>; else goto <D.30487>;
      <D.30486>:
      mono_loader_clear_error ();
      // predicted unlikely by continue predictor.
      goto <D.25325>;
      <D.30487>:
      D.30488 = mono_class_get_type (klass);
      full_name = mono_type_get_name_full (D.30488, 2);
      D.30489 = mono_metadata_str_hash (full_name);
      table_size.223 = (unsigned int) table_size;
      hash = D.30489 % table_size.223;
      monoeg_g_free (full_name);
      new_entry = monoeg_malloc0 (12);
      new_entry->token = token;
      D.30490 = table->pdata;
      D.30491 = hash * 4;
      D.30492 = D.30490 + D.30491;
      entry = *D.30492;
      if (entry == 0B) goto <D.30493>; else goto <D.30494>;
      <D.30493>:
      new_entry->index = hash;
      D.30490 = table->pdata;
      D.30491 = hash * 4;
      D.30492 = D.30490 + D.30491;
      *D.30492 = new_entry;
      goto <D.30495>;
      <D.30494>:
      goto <D.25327>;
      <D.25326>:
      entry = entry->next;
      <D.25327>:
      D.30496 = entry->next;
      if (D.30496 != 0B) goto <D.25326>; else goto <D.25328>;
      <D.25328>:
      entry->next = new_entry;
      D.30497 = table->len;
      new_entry->index = D.30497;
      monoeg_g_ptr_array_add (table, new_entry);
      <D.30495>:
      <D.25325>:
      i = i + 1;
      <D.25330>:
      D.30475 = acfg->image;
      D.30476 = D.30475->tables[2].rows;
      D.30477 = (int) D.30476;
      if (D.30477 > i) goto <D.25329>; else goto <D.25331>;
      <D.25331>:
      sprintf (&symbol, "class_name_table");
      emit_section_change (acfg, ".rodata", 0);
      emit_alignment (acfg, 8);
      emit_label (acfg, &symbol);
      D.30498 = table_size > 64999;
      D.30499 = (long int) D.30498;
      D.30500 = __builtin_expect (D.30499, 0);
      if (D.30500 != 0) goto <D.30501>; else goto <D.30502>;
      <D.30501>:
      monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "aot-compiler.c", 7744, "table_size < 65000");
      <D.30502>:
      emit_int16 (acfg, table_size);
      D.30497 = table->len;
      D.30503 = D.30497 > 64999;
      D.30504 = (long int) D.30503;
      D.30505 = __builtin_expect (D.30504, 0);
      if (D.30505 != 0) goto <D.30506>; else goto <D.30507>;
      <D.30506>:
      monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "aot-compiler.c", 7746, "table->len < 65000");
      <D.30507>:
      i = 0;
      goto <D.25334>;
      <D.25333>:
      {
        struct ClassNameTableEntry * entry;

        D.30490 = table->pdata;
        i.224 = (unsigned int) i;
        D.30509 = i.224 * 4;
        D.30510 = D.30490 + D.30509;
        entry = *D.30510;
        if (entry == 0B) goto <D.30511>; else goto <D.30512>;
        <D.30511>:
        emit_int16 (acfg, 0);
        emit_int16 (acfg, 0);
        goto <D.30513>;
        <D.30512>:
        D.30514 = entry->token;
        D.30515 = (int) D.30514;
        D.30516 = D.30515 & 16777215;
        emit_int16 (acfg, D.30516);
        D.30517 = entry->next;
        if (D.30517 != 0B) goto <D.30518>; else goto <D.30519>;
        <D.30518>:
        D.30517 = entry->next;
        D.30520 = D.30517->index;
        D.30521 = (int) D.30520;
        emit_int16 (acfg, D.30521);
        goto <D.30522>;
        <D.30519>:
        emit_int16 (acfg, 0);
        <D.30522>:
        <D.30513>:
      }
      i = i + 1;
      <D.25334>:
      i.225 = (unsigned int) i;
      D.30497 = table->len;
      if (i.225 < D.30497) goto <D.25333>; else goto <D.25335>;
      <D.25335>:
    }
  finally
    {
      symbol = {CLOBBER};
    }
}


emit_got_info (struct MonoAotCompile * acfg)
{
  unsigned int D.30524;
  struct GPtrArray * D.30525;
  unsigned int D.30526;
  struct GHashTable * D.30527;
  const void * i.226;
  struct MonoJumpInfo * D.30529;
  <unnamed type> D.30530;
  int D.30531;
  int D.30532;
  unsigned int i.227;
  unsigned int D.30534;
  unsigned int D.30535;
  unsigned int D.30536;
  struct MonoMemPool * D.30537;
  unsigned int buf_size.228;
  unsigned int D.30539;
  unsigned int D.30540;
  void * D.30541;
  guint32 * D.30544;
  void * * D.30545;
  unsigned int i.229;
  unsigned int D.30547;
  void * * D.30548;
  <unnamed type> D.30549;
  int D.30550;
  guint8 * p.230;
  int D.30552;
  int p.231;
  int p2.232;
  int D.30555;
  int D.30556;
  int buf.233;
  int D.30558;
  _Bool D.30559;
  long int D.30560;
  long int D.30561;
  guint32 * D.30564;
  unsigned int D.30565;
  unsigned int D.30566;
  int D.30569;
  sizetype D.30570;
  sizetype D.30571;
  sizetype D.30572;
  guint32 * D.30573;
  unsigned int D.30574;
  int D.30575;
  int D.30576;
  unsigned int i.234;
  unsigned int D.30578;
  int D.30579;
  unsigned int D.30580;
  unsigned int D.30581;
  int D.30582;
  char symbol[256];
  int i;
  int first_plt_got_patch;
  int buf_size;
  guint8 * p;
  guint8 * buf;
  guint32 * got_info_offsets;

  try
    {
      D.30524 = acfg->got_offset;
      acfg->plt_got_offset_base = D.30524;
      D.30525 = acfg->got_patches;
      D.30526 = D.30525->len;
      first_plt_got_patch = (int) D.30526;
      i = 1;
      goto <D.25358>;
      <D.25357>:
      {
        struct MonoPltEntry * plt_entry;

        D.30527 = acfg->plt_offset_to_entry;
        i.226 = (const void *) i;
        plt_entry = monoeg_g_hash_table_lookup (D.30527, i.226);
        D.30525 = acfg->got_patches;
        D.30529 = plt_entry->ji;
        monoeg_g_ptr_array_add (D.30525, D.30529);
        D.30529 = plt_entry->ji;
        D.30530 = D.30529->type;
        D.30531 = acfg->stats.got_slot_types[D.30530];
        D.30532 = D.30531 + 1;
        acfg->stats.got_slot_types[D.30530] = D.30532;
      }
      i = i + 1;
      <D.25358>:
      i.227 = (unsigned int) i;
      D.30534 = acfg->plt_offset;
      if (i.227 < D.30534) goto <D.25357>; else goto <D.25359>;
      <D.25359>:
      D.30524 = acfg->got_offset;
      D.30534 = acfg->plt_offset;
      D.30535 = D.30524 + D.30534;
      acfg->got_offset = D.30535;
      D.30525 = acfg->got_patches;
      D.30526 = D.30525->len;
      D.30536 = D.30526 * 128;
      buf_size = (int) D.30536;
      D.30537 = acfg->mempool;
      buf_size.228 = (unsigned int) buf_size;
      buf = mono_mempool_alloc (D.30537, buf_size.228);
      p = buf;
      D.30537 = acfg->mempool;
      D.30525 = acfg->got_patches;
      D.30526 = D.30525->len;
      D.30539 = D.30526 * 4;
      got_info_offsets = mono_mempool_alloc (D.30537, D.30539);
      D.30537 = acfg->mempool;
      D.30534 = acfg->plt_offset;
      D.30540 = D.30534 * 4;
      D.30541 = mono_mempool_alloc (D.30537, D.30540);
      acfg->plt_got_info_offsets = D.30541;
      D.30534 = acfg->plt_offset;
      if (D.30534 != 0) goto <D.30542>; else goto <D.30543>;
      <D.30542>:
      D.30544 = acfg->plt_got_info_offsets;
      *D.30544 = 0;
      <D.30543>:
      i = 0;
      goto <D.25363>;
      <D.25362>:
      {
        struct MonoJumpInfo * ji;
        guint8 * p2;

        D.30525 = acfg->got_patches;
        D.30545 = D.30525->pdata;
        i.229 = (unsigned int) i;
        D.30547 = i.229 * 4;
        D.30548 = D.30545 + D.30547;
        ji = *D.30548;
        p = buf;
        D.30549 = ji->type;
        D.30550 = (int) D.30549;
        p.230 = p;
        encode_value (D.30550, p.230, &p);
        p2 = p;
        p.230 = p;
        encode_patch (acfg, ji, p.230, &p);
        D.30549 = ji->type;
        D.30549 = ji->type;
        D.30552 = acfg->stats.got_slot_info_sizes[D.30549];
        p.230 = p;
        p.231 = (int) p.230;
        p2.232 = (int) p2;
        D.30555 = p.231 - p2.232;
        D.30556 = D.30552 + D.30555;
        acfg->stats.got_slot_info_sizes[D.30549] = D.30556;
        p.230 = p;
        p.231 = (int) p.230;
        buf.233 = (int) buf;
        D.30558 = p.231 - buf.233;
        D.30559 = D.30558 > buf_size;
        D.30560 = (long int) D.30559;
        D.30561 = __builtin_expect (D.30560, 0);
        if (D.30561 != 0) goto <D.30562>; else goto <D.30563>;
        <D.30562>:
        monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "aot-compiler.c", 7851, "p - buf <= buf_size");
        <D.30563>:
        i.229 = (unsigned int) i;
        D.30547 = i.229 * 4;
        D.30564 = got_info_offsets + D.30547;
        p.230 = p;
        p.231 = (int) p.230;
        buf.233 = (int) buf;
        D.30558 = p.231 - buf.233;
        D.30565 = (unsigned int) D.30558;
        D.30566 = add_to_blob (acfg, buf, D.30565);
        *D.30564 = D.30566;
        if (i >= first_plt_got_patch) goto <D.30567>; else goto <D.30568>;
        <D.30567>:
        D.30544 = acfg->plt_got_info_offsets;
        D.30569 = i - first_plt_got_patch;
        D.30570 = (sizetype) D.30569;
        D.30571 = D.30570 + 1;
        D.30572 = D.30571 * 4;
        D.30573 = D.30544 + D.30572;
        i.229 = (unsigned int) i;
        D.30547 = i.229 * 4;
        D.30564 = got_info_offsets + D.30547;
        D.30574 = *D.30564;
        *D.30573 = D.30574;
        <D.30568>:
        D.30575 = acfg->stats.got_info_size;
        p.230 = p;
        p.231 = (int) p.230;
        buf.233 = (int) buf;
        D.30558 = p.231 - buf.233;
        D.30576 = D.30575 + D.30558;
        acfg->stats.got_info_size = D.30576;
      }
      i = i + 1;
      <D.25363>:
      i.234 = (unsigned int) i;
      D.30525 = acfg->got_patches;
      D.30526 = D.30525->len;
      if (i.234 < D.30526) goto <D.25362>; else goto <D.25364>;
      <D.25364>:
      sprintf (&symbol, "got_info_offsets");
      emit_section_change (acfg, ".rodata", 1);
      emit_alignment (acfg, 8);
      emit_label (acfg, &symbol);
      D.30578 = emit_offset_table (acfg, first_plt_got_patch, 10, got_info_offsets);
      D.30579 = acfg->stats.offsets_size;
      D.30580 = (unsigned int) D.30579;
      D.30581 = D.30580 + D.30578;
      D.30582 = (int) D.30581;
      acfg->stats.offsets_size = D.30582;
    }
  finally
    {
      symbol = {CLOBBER};
      p = {CLOBBER};
    }
}


encode_patch (struct MonoAotCompile * acfg, struct MonoJumpInfo * patch_info, guint8 * buf, guint8 * * endbuf)
{
  <unnamed type> D.30583;
  struct MonoImage * D.30584;
  unsigned int D.30585;
  int D.30586;
  guint8 * p.235;
  int D.30588;
  struct MonoJumpInfoBBTable * D.30589;
  int D.30590;
  unsigned int k.236;
  unsigned int D.30592;
  void * * D.30593;
  void * D.30594;
  int D.30595;
  struct MonoMethod * D.30596;
  const char * D.30597;
  int len.237;
  guint8 * p.238;
  guint8 * p.239;
  guint8 * p.240;
  struct MonoJumpInfoToken * D.30602;
  struct MonoImage * D.30603;
  unsigned int D.30604;
  _Bool D.30605;
  long int D.30606;
  long int D.30607;
  int image_index.241;
  unsigned int D.30611;
  unsigned int D.30612;
  int D.30613;
  unsigned int D.30614;
  int D.30615;
  int D.30616;
  int D.30617;
  struct MonoGenericContext * D.30620;
  struct MonoClass * D.30621;
  struct MonoImage * D.30622;
  const void * D.30623;
  _Bool D.30624;
  long int D.30625;
  long int D.30626;
  unsigned int D.30629;
  int D.30630;
  guint32 * D.30631;
  unsigned int D.30632;
  int D.30633;
  struct MonoClass * D.30634;
  struct MonoClassField * D.30635;
  struct GHashTable * D.30636;
  struct MonoMethod * D.30637;
  void * D.30638;
  guint8 * p2.242;
  int p2.243;
  int buf2.244;
  int D.30644;
  _Bool D.30645;
  long int D.30646;
  long int D.30647;
  unsigned int D.30650;
  unsigned int D.30651;
  void * D.30652;
  int offset.245;
  <unnamed type> D.30655;
  int D.30656;
  _Bool D.30657;
  long int D.30658;
  long int D.30659;
  struct MonoJumpInfo * D.30662;
  <unnamed type> D.30663;
  _Bool D.30664;
  long int D.30665;
  long int D.30666;
  unsigned int iftmp.246;
  int D.30670;
  unsigned int D.30674;
  unsigned int D.30675;
  unsigned int D.30676;
  unsigned int D.30677;
  int D.30678;
  struct MonoJumpInfoImtTramp * D.30679;
  struct MonoMethod * D.30680;
  int D.30681;
  int D.30682;
  struct MonoJumpInfoGSharedVtCall * D.30683;
  struct MonoMethodSignature * D.30684;
  struct MonoMethod * D.30685;
  struct MonoMethod * D.30686;
  struct GPtrArray * D.30687;
  unsigned int D.30688;
  int D.30689;
  void * * D.30690;
  unsigned int i.247;
  unsigned int D.30692;
  void * * D.30693;
  <unnamed type> D.30694;
  int D.30695;
  <unnamed type> D.30696;
  void * D.30697;
  struct MonoClass * D.30698;
  unsigned int i.248;
  guint8 * p;

  try
    {
      p = buf;
      D.30583 = patch_info->type;
      switch (D.30583) <default: <D.24541>, case 3: <D.24489>, case 4: <D.24490>, case 5: <D.24481>, case 6: <D.24488>, case 7: <D.24494>, case 8: <D.24482>, case 10: <D.24504>, case 11: <D.24509>, case 12: <D.24476>, case 13: <D.24514>, case 14: <D.24508>, case 15: <D.24512>, case 16: <D.24515>, case 17: <D.24497>, case 18: <D.24502>, case 19: <D.24503>, case 20: <D.24506>, case 21: <D.24507>, case 23: <D.24510>, case 24: <D.24511>, case 28: <D.24501>, case 29: <D.24500>, case 30: <D.24513>, case 31: <D.24491>, case 32: <D.24495>, case 33: <D.24516>, case 34: <D.24492>, case 35: <D.24517>, case 36: <D.24522>, case 37: <D.24523>, case 38: <D.24524>, case 39: <D.24477>, case 40: <D.24525>, case 41: <D.24526>, case 42: <D.24479>, case 43: <D.24480>, case 44: <D.24527>, case 45: <D.24529>, case 46: <D.24530>, case 47: <D.24478>, case 48: <D.24528>, case 50: <D.24493>, case 51: <D.24474>>
      <D.24474>:
      goto <D.24475>;
      <D.24476>:
      D.30584 = patch_info->data.image;
      D.30585 = get_image_index (acfg, D.30584);
      D.30586 = (int) D.30585;
      p.235 = p;
      encode_value (D.30586, p.235, &p);
      goto <D.24475>;
      <D.24477>:
      <D.24478>:
      <D.24479>:
      <D.24480>:
      goto <D.24475>;
      <D.24481>:
      D.30588 = patch_info->data.offset;
      p.235 = p;
      encode_value (D.30588, p.235, &p);
      goto <D.24475>;
      <D.24482>:
      {
        void * * table;
        int k;

        D.30589 = patch_info->data.table;
        table = D.30589->table;
        D.30589 = patch_info->data.table;
        D.30590 = D.30589->table_size;
        p.235 = p;
        encode_value (D.30590, p.235, &p);
        k = 0;
        goto <D.24486>;
        <D.24485>:
        k.236 = (unsigned int) k;
        D.30592 = k.236 * 4;
        D.30593 = table + D.30592;
        D.30594 = *D.30593;
        D.30595 = (int) D.30594;
        p.235 = p;
        encode_value (D.30595, p.235, &p);
        k = k + 1;
        <D.24486>:
        D.30589 = patch_info->data.table;
        D.30590 = D.30589->table_size;
        if (D.30590 > k) goto <D.24485>; else goto <D.24487>;
        <D.24487>:
        goto <D.24475>;
      }
      <D.24488>:
      <D.24489>:
      <D.24490>:
      <D.24491>:
      <D.24492>:
      <D.24493>:
      D.30596 = patch_info->data.method;
      p.235 = p;
      encode_method_ref (acfg, D.30596, p.235, &p);
      goto <D.24475>;
      <D.24494>:
      <D.24495>:
      {
        guint32 len;

        D.30597 = patch_info->data.name;
        len = strlen (D.30597);
        len.237 = (int) len;
        p.235 = p;
        encode_value (len.237, p.235, &p);
        p.235 = p;
        D.30597 = patch_info->data.name;
        memcpy (p.235, D.30597, len);
        p.235 = p;
        p.238 = p.235 + len;
        p = p.238;
        p.235 = p;
        p.239 = p.235;
        p.240 = p.239 + 1;
        p = p.240;
        *p.239 = 0;
        goto <D.24475>;
      }
      <D.24497>:
      {
        guint32 image_index;
        guint32 token;

        D.30602 = patch_info->data.token;
        D.30603 = D.30602->image;
        image_index = get_image_index (acfg, D.30603);
        D.30602 = patch_info->data.token;
        token = D.30602->token;
        D.30604 = token & 4278190080;
        D.30605 = D.30604 != 1879048192;
        D.30606 = (long int) D.30605;
        D.30607 = __builtin_expect (D.30606, 0);
        if (D.30607 != 0) goto <D.30608>; else goto <D.30609>;
        <D.30608>:
        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.30609>:
        image_index.241 = (int) image_index;
        p.235 = p;
        encode_value (image_index.241, p.235, &p);
        D.30602 = patch_info->data.token;
        D.30611 = D.30602->token;
        D.30612 = D.30611 + 2415919104;
        D.30613 = (int) D.30612;
        p.235 = p;
        encode_value (D.30613, p.235, &p);
        goto <D.24475>;
      }
      <D.24500>:
      <D.24501>:
      <D.24502>:
      <D.24503>:
      D.30602 = patch_info->data.token;
      D.30603 = D.30602->image;
      D.30614 = get_image_index (acfg, D.30603);
      D.30615 = (int) D.30614;
      p.235 = p;
      encode_value (D.30615, p.235, &p);
      D.30602 = patch_info->data.token;
      D.30611 = D.30602->token;
      D.30616 = (int) D.30611;
      p.235 = p;
      encode_value (D.30616, p.235, &p);
      D.30602 = patch_info->data.token;
      D.30617 = D.30602->has_context;
      p.235 = p;
      encode_value (D.30617, p.235, &p);
      D.30602 = patch_info->data.token;
      D.30617 = D.30602->has_context;
      if (D.30617 != 0) goto <D.30618>; else goto <D.30619>;
      <D.30618>:
      D.30602 = patch_info->data.token;
      D.30620 = &D.30602->context;
      p.235 = p;
      encode_generic_context (acfg, D.30620, p.235, &p);
      <D.30619>:
      goto <D.24475>;
      <D.24504>:
      {
        struct MonoClass * ex_class;

        D.30621 = mono_defaults.exception_class;
        D.30622 = D.30621->image;
        D.30623 = patch_info->data.target;
        ex_class = mono_class_from_name (D.30622, "System", D.30623);
        D.30624 = ex_class == 0B;
        D.30625 = (long int) D.30624;
        D.30626 = __builtin_expect (D.30625, 0);
        if (D.30626 != 0) goto <D.30627>; else goto <D.30628>;
        <D.30627>:
        monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "aot-compiler.c", 4948, "ex_class");
        <D.30628>:
        p.235 = p;
        encode_klass_ref (acfg, ex_class, p.235, &p);
        goto <D.24475>;
      }
      <D.24506>:
      D.30623 = patch_info->data.target;
      D.30629 = MEM[(guint32 *)D.30623];
      D.30630 = (int) D.30629;
      p.235 = p;
      encode_value (D.30630, p.235, &p);
      goto <D.24475>;
      <D.24507>:
      D.30623 = patch_info->data.target;
      D.30629 = MEM[(guint32 *)D.30623];
      D.30630 = (int) D.30629;
      p.235 = p;
      encode_value (D.30630, p.235, &p);
      D.30623 = patch_info->data.target;
      D.30631 = D.30623 + 4;
      D.30632 = *D.30631;
      D.30633 = (int) D.30632;
      p.235 = p;
      encode_value (D.30633, p.235, &p);
      goto <D.24475>;
      <D.24508>:
      <D.24509>:
      <D.24510>:
      <D.24511>:
      D.30634 = patch_info->data.klass;
      p.235 = p;
      encode_klass_ref (acfg, D.30634, p.235, &p);
      goto <D.24475>;
      <D.24512>:
      <D.24513>:
      D.30634 = patch_info->data.klass;
      p.235 = p;
      encode_klass_ref (acfg, D.30634, p.235, &p);
      goto <D.24475>;
      <D.24514>:
      <D.24515>:
      D.30635 = patch_info->data.field;
      p.235 = p;
      encode_field_info (acfg, D.30635, p.235, &p);
      goto <D.24475>;
      <D.24516>:
      goto <D.24475>;
      <D.24517>:
      {
        struct MonoJumpInfoRgctxEntry * entry;
        guint32 offset;
        guint8 * buf2;
        guint8 * p2;

        try
          {
            entry = patch_info->data.rgctx_entry;
            D.30636 = acfg->method_blob_hash;
            D.30637 = entry->method;
            D.30638 = monoeg_g_hash_table_lookup (D.30636, D.30637);
            offset = (guint32) D.30638;
            if (offset == 0) goto <D.30639>; else goto <D.30640>;
            <D.30639>:
            buf2 = monoeg_malloc (1024);
            p2 = buf2;
            D.30637 = entry->method;
            p2.242 = p2;
            encode_method_ref (acfg, D.30637, p2.242, &p2);
            p2.242 = p2;
            p2.243 = (int) p2.242;
            buf2.244 = (int) buf2;
            D.30644 = p2.243 - buf2.244;
            D.30645 = D.30644 > 1023;
            D.30646 = (long int) D.30645;
            D.30647 = __builtin_expect (D.30646, 0);
            if (D.30647 != 0) goto <D.30648>; else goto <D.30649>;
            <D.30648>:
            monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "aot-compiler.c", 4990, "p2 - buf2 < 1024");
            <D.30649>:
            p2.242 = p2;
            p2.243 = (int) p2.242;
            buf2.244 = (int) buf2;
            D.30644 = p2.243 - buf2.244;
            D.30650 = (unsigned int) D.30644;
            offset = add_to_blob (acfg, buf2, D.30650);
            monoeg_g_free (buf2);
            D.30636 = acfg->method_blob_hash;
            D.30637 = entry->method;
            D.30651 = offset + 1;
            D.30652 = (void *) D.30651;
            monoeg_g_hash_table_insert_replace (D.30636, D.30637, D.30652, 0);
            goto <D.30653>;
            <D.30640>:
            offset = offset + 4294967295;
            <D.30653>:
            offset.245 = (int) offset;
            p.235 = p;
            encode_value (offset.245, p.235, &p);
            D.30655 = entry->info_type;
            D.30656 = (int) D.30655;
            D.30657 = D.30656 > 255;
            D.30658 = (long int) D.30657;
            D.30659 = __builtin_expect (D.30658, 0);
            if (D.30659 != 0) goto <D.30660>; else goto <D.30661>;
            <D.30660>:
            monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "aot-compiler.c", 5001, "(int)entry->info_type < 256");
            <D.30661>:
            D.30662 = entry->data;
            D.30663 = D.30662->type;
            D.30664 = D.30663 > 255;
            D.30665 = (long int) D.30664;
            D.30666 = __builtin_expect (D.30665, 0);
            if (D.30666 != 0) goto <D.30667>; else goto <D.30668>;
            <D.30667>:
            monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "aot-compiler.c", 5002, "entry->data->type < 256");
            <D.30668>:
            D.30670 = entry->in_mrgctx;
            if (D.30670 != 0) goto <D.30671>; else goto <D.30672>;
            <D.30671>:
            iftmp.246 = 1;
            goto <D.30673>;
            <D.30672>:
            iftmp.246 = 0;
            <D.30673>:
            D.30655 = entry->info_type;
            D.30674 = D.30655 << 1;
            D.30675 = iftmp.246 | D.30674;
            D.30662 = entry->data;
            D.30663 = D.30662->type;
            D.30676 = D.30663 << 9;
            D.30677 = D.30675 | D.30676;
            D.30678 = (int) D.30677;
            p.235 = p;
            encode_value (D.30678, p.235, &p);
            D.30662 = entry->data;
            p.235 = p;
            encode_patch (acfg, D.30662, p.235, &p);
            goto <D.24475>;
          }
        finally
          {
            p2 = {CLOBBER};
          }
      }
      <D.24522>:
      <D.24523>:
      <D.24524>:
      <D.24525>:
      goto <D.24475>;
      <D.24526>:
      D.30679 = patch_info->data.imt_tramp;
      D.30680 = D.30679->method;
      p.235 = p;
      encode_method_ref (acfg, D.30680, p.235, &p);
      D.30679 = patch_info->data.imt_tramp;
      D.30681 = D.30679->vt_offset;
      p.235 = p;
      encode_value (D.30681, p.235, &p);
      goto <D.24475>;
      <D.24527>:
      D.30623 = patch_info->data.target;
      p.235 = p;
      encode_signature (acfg, D.30623, p.235, &p);
      goto <D.24475>;
      <D.24528>:
      D.30623 = patch_info->data.target;
      D.30682 = (int) D.30623;
      p.235 = p;
      encode_value (D.30682, p.235, &p);
      goto <D.24475>;
      <D.24529>:
      D.30683 = patch_info->data.gsharedvt;
      D.30684 = D.30683->sig;
      p.235 = p;
      encode_signature (acfg, D.30684, p.235, &p);
      D.30683 = patch_info->data.gsharedvt;
      D.30685 = D.30683->method;
      p.235 = p;
      encode_method_ref (acfg, D.30685, p.235, &p);
      goto <D.24475>;
      <D.24530>:
      {
        struct MonoGSharedVtMethodInfo * info;
        int i;

        info = patch_info->data.gsharedvt_method;
        D.30686 = info->method;
        p.235 = p;
        encode_method_ref (acfg, D.30686, p.235, &p);
        D.30687 = info->entries;
        D.30688 = D.30687->len;
        D.30689 = (int) D.30688;
        p.235 = p;
        encode_value (D.30689, p.235, &p);
        i = 0;
        goto <D.24539>;
        <D.24538>:
        {
          struct MonoRuntimeGenericContextInfoTemplate * template;

          D.30687 = info->entries;
          D.30690 = D.30687->pdata;
          i.247 = (unsigned int) i;
          D.30692 = i.247 * 4;
          D.30693 = D.30690 + D.30692;
          template = *D.30693;
          D.30694 = template->info_type;
          D.30695 = (int) D.30694;
          p.235 = p;
          encode_value (D.30695, p.235, &p);
          D.30694 = template->info_type;
          D.30696 = mini_rgctx_info_type_to_patch_info_type (D.30694);
          switch (D.30696) <default: <D.24537>, case 11: <D.24534>, case 13: <D.24536>>
          <D.24534>:
          D.30697 = template->data;
          D.30698 = mono_class_from_mono_type (D.30697);
          p.235 = p;
          encode_klass_ref (acfg, D.30698, p.235, &p);
          goto <D.24535>;
          <D.24536>:
          D.30697 = template->data;
          p.235 = p;
          encode_field_info (acfg, D.30697, p.235, &p);
          goto <D.24535>;
          <D.24537>:
          monoeg_assertion_message ("* Assertion: should not be reached at %s:%d\n", "aot-compiler.c", 5044);
          <D.24535>:
        }
        i = i + 1;
        <D.24539>:
        i.248 = (unsigned int) i;
        D.30687 = info->entries;
        D.30688 = D.30687->len;
        if (i.248 < D.30688) goto <D.24538>; else goto <D.24540>;
        <D.24540>:
        goto <D.24475>;
      }
      <D.24541>:
      D.30583 = patch_info->type;
      monoeg_g_log (0B, 16, "unable to handle jump info %d", D.30583);
      monoeg_assertion_message ("* Assertion: should not be reached at %s:%d\n", "aot-compiler.c", 5052);
      <D.24475>:
      p.235 = p;
      *endbuf = p.235;
    }
  finally
    {
      p = {CLOBBER};
    }
}


encode_field_info (struct MonoAotCompile * cfg, struct MonoClassField * field, guint8 * buf, guint8 * * endbuf)
{
  struct MonoClass * D.30702;
  guint8 * p.249;
  unsigned int D.30704;
  _Bool D.30705;
  long int D.30706;
  long int D.30707;
  unsigned int D.30710;
  int D.30711;
  guint32 token;
  guint8 * p;

  try
    {
      token = mono_get_field_token (field);
      p = buf;
      D.30702 = field->parent;
      p.249 = p;
      encode_klass_ref (cfg, D.30702, p.249, &p);
      D.30704 = token & 4278190080;
      D.30705 = D.30704 != 67108864;
      D.30706 = (long int) D.30705;
      D.30707 = __builtin_expect (D.30706, 0);
      if (D.30707 != 0) goto <D.30708>; else goto <D.30709>;
      <D.30708>:
      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.30709>:
      D.30710 = token + 4227858432;
      D.30711 = (int) D.30710;
      p.249 = p;
      encode_value (D.30711, p.249, &p);
      p.249 = p;
      *endbuf = p.249;
    }
  finally
    {
      p = {CLOBBER};
    }
}


mono_get_field_token (struct MonoClassField * field)
{
  struct MonoClassField * D.30712;
  unsigned int i.250;
  unsigned int D.30714;
  struct MonoClassField * D.30715;
  guint32 D.30718;
  unsigned int D.30719;
  unsigned int i.251;
  unsigned int D.30721;
  unsigned int D.30722;
  unsigned int D.30723;
  struct MonoClass * klass;
  int i;

  klass = field->parent;
  i = 0;
  goto <D.23353>;
  <D.23352>:
  D.30712 = klass->fields;
  i.250 = (unsigned int) i;
  D.30714 = i.250 * 16;
  D.30715 = D.30712 + D.30714;
  if (D.30715 == field) goto <D.30716>; else goto <D.30717>;
  <D.30716>:
  D.30719 = klass->field.first;
  i.251 = (unsigned int) i;
  D.30721 = D.30719 + i.251;
  D.30722 = D.30721 + 1;
  D.30718 = D.30722 | 67108864;
  return D.30718;
  <D.30717>:
  i = i + 1;
  <D.23353>:
  i.251 = (unsigned int) i;
  D.30723 = klass->field.count;
  if (i.251 < D.30723) goto <D.23352>; else goto <D.23354>;
  <D.23354>:
  monoeg_assertion_message ("* Assertion: should not be reached at %s:%d\n", "aot-compiler.c", 2035);
  D.30718 = 0;
  return D.30718;
}


emit_exception_info (struct MonoAotCompile * acfg)
{
  unsigned int D.30725;
  unsigned int D.30726;
  struct MonoCompile * * D.30727;
  unsigned int i.252;
  unsigned int D.30729;
  struct MonoCompile * * D.30730;
  struct MonoCompile * D.30731;
  gint32 * D.30734;
  unsigned int D.30735;
  int D.30736;
  unsigned int i.253;
  int D.30739;
  unsigned int D.30740;
  int D.30741;
  unsigned int D.30742;
  unsigned int D.30743;
  int D.30744;
  int i;
  char symbol[256];
  gint32 * offsets;

  try
    {
      D.30725 = acfg->nmethods;
      D.30726 = D.30725 * 4;
      offsets = monoeg_malloc0 (D.30726);
      i = 0;
      goto <D.25280>;
      <D.25279>:
      D.30727 = acfg->cfgs;
      i.252 = (unsigned int) i;
      D.30729 = i.252 * 4;
      D.30730 = D.30727 + D.30729;
      D.30731 = *D.30730;
      if (D.30731 != 0B) goto <D.30732>; else goto <D.30733>;
      <D.30732>:
      D.30727 = acfg->cfgs;
      i.252 = (unsigned int) i;
      D.30729 = i.252 * 4;
      D.30730 = D.30727 + D.30729;
      D.30731 = *D.30730;
      emit_exception_debug_info (acfg, D.30731);
      i.252 = (unsigned int) i;
      D.30729 = i.252 * 4;
      D.30734 = offsets + D.30729;
      D.30727 = acfg->cfgs;
      i.252 = (unsigned int) i;
      D.30729 = i.252 * 4;
      D.30730 = D.30727 + D.30729;
      D.30731 = *D.30730;
      D.30735 = D.30731->ex_info_offset;
      D.30736 = (int) D.30735;
      *D.30734 = D.30736;
      goto <D.30737>;
      <D.30733>:
      i.252 = (unsigned int) i;
      D.30729 = i.252 * 4;
      D.30734 = offsets + D.30729;
      *D.30734 = 0;
      <D.30737>:
      i = i + 1;
      <D.25280>:
      i.253 = (unsigned int) i;
      D.30725 = acfg->nmethods;
      if (i.253 < D.30725) goto <D.25279>; else goto <D.25281>;
      <D.25281>:
      sprintf (&symbol, "ex_info_offsets");
      emit_section_change (acfg, ".rodata", 1);
      emit_alignment (acfg, 8);
      emit_label (acfg, &symbol);
      D.30725 = acfg->nmethods;
      D.30739 = (int) D.30725;
      D.30740 = emit_offset_table (acfg, D.30739, 10, offsets);
      D.30741 = acfg->stats.offsets_size;
      D.30742 = (unsigned int) D.30741;
      D.30743 = D.30742 + D.30740;
      D.30744 = (int) D.30743;
      acfg->stats.offsets_size = D.30744;
      monoeg_g_free (offsets);
    }
  finally
    {
      symbol = {CLOBBER};
    }
}


emit_exception_debug_info (struct MonoAotCompile * acfg, struct MonoCompile * cfg)
{
  unsigned int D.30745;
  int D.30746;
  <unnamed-unsigned:15> D.30750;
  int D.30751;
  int D.30752;
  unsigned int D.30753;
  unsigned int debug_info_size.254;
  unsigned int D.30755;
  guint32 iftmp.255;
  int D.30759;
  int D.30760;
  unsigned int D.30762;
  unsigned int D.30763;
  unsigned int D.30764;
  unsigned int D.30765;
  unsigned int buf_size.256;
  struct GSList * D.30767;
  _Bool D.30768;
  unsigned int D.30769;
  unsigned int D.30770;
  _Bool D.30771;
  int D.30772;
  int iftmp.257;
  int D.30777;
  int iftmp.258;
  unsigned int D.30779;
  unsigned int D.30780;
  int D.30784;
  int iftmp.259;
  int D.30789;
  int iftmp.260;
  unsigned int D.30791;
  unsigned int D.30792;
  int D.30796;
  int iftmp.261;
  unsigned int D.30798;
  int D.30802;
  int iftmp.262;
  guint8 * D.30804;
  int D.30808;
  int iftmp.263;
  unsigned int D.30810;
  int D.30814;
  int flags.264;
  guint8 * p.265;
  unsigned int encoded_len.266;
  unsigned int D.30820;
  int D.30821;
  unsigned int D.30823;
  int D.30824;
  short unsigned int D.30827;
  int D.30828;
  int D.30833;
  struct MonoExceptionClause * D.30834;
  unsigned int k.267;
  unsigned int D.30836;
  unsigned int D.30837;
  int D.30838;
  struct MonoClass * D.30839;
  unsigned int cindex1.268;
  unsigned int D.30844;
  unsigned int cindex2.269;
  unsigned int D.30846;
  unsigned int D.30849;
  unsigned int D.30850;
  unsigned int D.30853;
  unsigned int D.30854;
  unsigned int D.30858;
  <unnamed-unsigned:15> D.30861;
  int D.30862;
  unsigned int D.30863;
  int D.30864;
  int D.30865;
  unsigned int D.30866;
  void * D.30869;
  int D.30870;
  int code.270;
  int D.30872;
  struct MonoClass * D.30874;
  guint8 * p2.271;
  int p2.272;
  int buf2.273;
  _Bool D.30880;
  long int D.30881;
  long int D.30882;
  unsigned int len.274;
  int D.30886;
  sizetype D.30887;
  guint8 * p.275;
  void * D.30890;
  int D.30891;
  int D.30892;
  void * D.30893;
  int D.30894;
  int D.30895;
  void * D.30896;
  int D.30897;
  int D.30898;
  int D.30899;
  short unsigned int D.30902;
  int D.30903;
  short unsigned int D.30904;
  int D.30905;
  unsigned int D.30906;
  int D.30907;
  short unsigned int D.30908;
  int D.30909;
  unsigned int D.30912;
  int D.30913;
  int D.30916;
  struct MonoDwarfLocListEntry * D.30919;
  unsigned int i.276;
  unsigned int D.30921;
  int D.30922;
  _Bool D.30923;
  int D.30924;
  int D.30925;
  int D.30928;
  int D.30931;
  _Bool D.30932;
  long int D.30933;
  long int D.30934;
  int D.30938;
  unsigned int D.30942;
  unsigned int D.30943;
  _Bool D.30944;
  int D.30945;
  unsigned char D.30946;
  int D.30947;
  int D.30948;
  struct MonoMethod * D.30949;
  guint8 * p2.277;
  int p2.278;
  int buf2.279;
  _Bool D.30953;
  long int D.30954;
  long int D.30955;
  unsigned int len.280;
  int D.30959;
  sizetype D.30960;
  guint8 * p.281;
  gboolean * D.30966;
  gboolean * D.30968;
  unsigned int D.30969;
  unsigned int D.30970;
  _Bool D.30971;
  long int D.30972;
  long int D.30973;
  struct MonoGenericInst * D.30976;
  <unnamed-unsigned:22> D.30979;
  int D.30980;
  unsigned int D.30981;
  gboolean * D.30982;
  int D.30983;
  int D.30984;
  struct MonoGenericInst * D.30986;
  gboolean * D.30989;
  int D.30990;
  int D.30994;
  int D.30995;
  int D.30996;
  int D.30997;
  int * D.30998;
  unsigned int j.282;
  unsigned int D.31000;
  int * D.31001;
  int D.31002;
  unsigned int buf_size.283;
  _Bool D.31004;
  long int D.31005;
  long int D.31006;
  int debug_info_size.284;
  guint8 * debug_info.285;
  guint8 * p.286;
  int D.31016;
  guint8 * p.287;
  unsigned int p.288;
  unsigned int D.31019;
  guint8 * p.289;
  int D.31021;
  int p.290;
  int buf.291;
  int D.31024;
  int D.31025;
  _Bool D.31026;
  long int D.31027;
  long int D.31028;
  unsigned int D.31031;
  guint32 iftmp.292;
  unsigned int D.31036;
  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.30745 = get_method_index (acfg, method);
      method_index = (int) D.30745;
      D.30746 = acfg->aot_opts.nodebug;
      if (D.30746 == 0) goto <D.30747>; else goto <D.30748>;
      <D.30747>:
      mono_debug_serialize_debug_info (cfg, &debug_info, &debug_info_size);
      goto <D.30749>;
      <D.30748>:
      debug_info = 0B;
      debug_info_size = 0;
      <D.30749>:
      seq_points = cfg->seq_point_info;
      D.30750 = header->num_clauses;
      D.30751 = (int) D.30750;
      D.30752 = D.30751 * 256;
      D.30753 = (unsigned int) D.30752;
      debug_info_size.254 = debug_info_size;
      D.30755 = D.30753 + debug_info_size.254;
      if (seq_points != 0B) goto <D.30757>; else goto <D.30758>;
      <D.30757>:
      D.30759 = seq_points->len;
      D.30760 = D.30759 * 128;
      iftmp.255 = (guint32) D.30760;
      goto <D.30761>;
      <D.30758>:
      iftmp.255 = 0;
      <D.30761>:
      D.30762 = D.30755 + iftmp.255;
      D.30763 = cfg->gc_map_size;
      D.30764 = D.30762 + D.30763;
      D.30765 = D.30764 + 2048;
      buf_size = (int) D.30765;
      buf_size.256 = (unsigned int) buf_size;
      buf = monoeg_malloc (buf_size.256);
      p = buf;
      D.30767 = cfg->unwind_ops;
      D.30768 = D.30767 != 0B;
      use_unwind_ops = (gboolean) D.30768;
      D.30769 = BIT_FIELD_REF <*jinfo, 32, 160>;
      D.30770 = D.30769 & 131072;
      D.30771 = D.30770 != 0;
      D.30772 = (int) D.30771;
      if (use_unwind_ops != 0) goto <D.30774>; else goto <D.30775>;
      <D.30774>:
      iftmp.257 = 2;
      goto <D.30776>;
      <D.30775>:
      iftmp.257 = 0;
      <D.30776>:
      D.30777 = D.30772 | iftmp.257;
      D.30779 = BIT_FIELD_REF <*header, 32, 64>;
      D.30780 = D.30779 & 2147418112;
      if (D.30780 != 0) goto <D.30781>; else goto <D.30782>;
      <D.30781>:
      iftmp.258 = 4;
      goto <D.30783>;
      <D.30782>:
      iftmp.258 = 0;
      <D.30783>:
      D.30784 = D.30777 | iftmp.258;
      if (seq_points != 0B) goto <D.30786>; else goto <D.30787>;
      <D.30786>:
      iftmp.259 = 8;
      goto <D.30788>;
      <D.30787>:
      iftmp.259 = 0;
      <D.30788>:
      D.30789 = D.30784 | iftmp.259;
      D.30791 = BIT_FIELD_REF <*cfg, 32, 3392>;
      D.30792 = D.30791 & 256;
      if (D.30792 != 0) goto <D.30793>; else goto <D.30794>;
      <D.30793>:
      iftmp.260 = 16;
      goto <D.30795>;
      <D.30794>:
      iftmp.260 = 0;
      <D.30795>:
      D.30796 = D.30789 | iftmp.260;
      D.30769 = BIT_FIELD_REF <*jinfo, 32, 160>;
      D.30798 = D.30769 & 262144;
      if (D.30798 != 0) goto <D.30799>; else goto <D.30800>;
      <D.30799>:
      iftmp.261 = 32;
      goto <D.30801>;
      <D.30800>:
      iftmp.261 = 0;
      <D.30801>:
      D.30802 = D.30796 | iftmp.261;
      D.30804 = cfg->gc_map;
      if (D.30804 != 0B) goto <D.30805>; else goto <D.30806>;
      <D.30805>:
      iftmp.262 = 64;
      goto <D.30807>;
      <D.30806>:
      iftmp.262 = 0;
      <D.30807>:
      D.30808 = D.30802 | iftmp.262;
      D.30769 = BIT_FIELD_REF <*jinfo, 32, 160>;
      D.30810 = D.30769 & 524288;
      if (D.30810 != 0) goto <D.30811>; else goto <D.30812>;
      <D.30811>:
      iftmp.263 = 128;
      goto <D.30813>;
      <D.30812>:
      iftmp.263 = 0;
      <D.30813>:
      D.30814 = D.30808 | iftmp.263;
      flags = (guint32) D.30814;
      flags.264 = (int) flags;
      p.265 = p;
      encode_value (flags.264, p.265, &p);
      if (use_unwind_ops != 0) goto <D.30817>; else goto <D.30818>;
      <D.30817>:
      {
        guint32 encoded_len;
        guint8 * encoded;

        try
          {
            D.30767 = cfg->unwind_ops;
            encoded = mono_unwind_ops_encode (D.30767, &encoded_len);
            encoded_len.266 = encoded_len;
            D.30820 = get_unwind_info_offset (acfg, encoded, encoded_len.266);
            D.30821 = (int) D.30820;
            p.265 = p;
            encode_value (D.30821, p.265, &p);
            monoeg_g_free (encoded);
          }
        finally
          {
            encoded_len = {CLOBBER};
          }
      }
      goto <D.30822>;
      <D.30818>:
      D.30823 = jinfo->used_regs;
      D.30824 = (int) D.30823;
      p.265 = p;
      encode_value (D.30824, p.265, &p);
      <D.30822>:
      D.30769 = BIT_FIELD_REF <*jinfo, 32, 160>;
      D.30798 = D.30769 & 262144;
      if (D.30798 != 0) goto <D.30825>; else goto <D.30826>;
      <D.30825>:
      {
        struct MonoTryBlockHoleTableJitInfo * table;

        table = mono_jit_info_get_try_block_hole_table_info (jinfo);
        D.30827 = table->num_holes;
        D.30828 = (int) D.30827;
        p.265 = p;
        encode_value (D.30828, p.265, &p);
      }
      <D.30826>:
      D.30791 = BIT_FIELD_REF <*cfg, 32, 3392>;
      D.30792 = D.30791 & 256;
      if (D.30792 != 0) goto <D.30829>; else goto <D.30830>;
      <D.30829>:
      D.30779 = BIT_FIELD_REF <*header, 32, 64>;
      D.30780 = D.30779 & 2147418112;
      if (D.30780 != 0) goto <D.30831>; else goto <D.30832>;
      <D.30831>:
      D.30750 = header->num_clauses;
      D.30833 = (int) D.30750;
      p.265 = p;
      encode_value (D.30833, p.265, &p);
      <D.30832>:
      k = 0;
      goto <D.24624>;
      <D.24623>:
      {
        struct MonoExceptionClause * clause;

        D.30834 = header->clauses;
        k.267 = (unsigned int) k;
        D.30836 = k.267 * 24;
        clause = D.30834 + D.30836;
        D.30837 = clause->flags;
        D.30838 = (int) D.30837;
        p.265 = p;
        encode_value (D.30838, p.265, &p);
        D.30839 = clause->data.catch_class;
        if (D.30839 != 0B) goto <D.30840>; else goto <D.30841>;
        <D.30840>:
        p.265 = p;
        encode_value (1, p.265, &p);
        D.30839 = clause->data.catch_class;
        p.265 = p;
        encode_klass_ref (acfg, D.30839, p.265, &p);
        goto <D.30842>;
        <D.30841>:
        p.265 = p;
        encode_value (0, p.265, &p);
        <D.30842>:
        i = 0;
        goto <D.24621>;
        <D.24620>:
        {
          gint32 cindex1;
          struct MonoExceptionClause * clause1;
          gint32 cindex2;
          struct MonoExceptionClause * clause2;

          cindex1 = k;
          D.30834 = header->clauses;
          cindex1.268 = (unsigned int) cindex1;
          D.30844 = cindex1.268 * 24;
          clause1 = D.30834 + D.30844;
          cindex2 = i;
          D.30834 = header->clauses;
          cindex2.269 = (unsigned int) cindex2;
          D.30846 = cindex2.269 * 24;
          clause2 = D.30834 + D.30846;
          if (cindex1 != cindex2) goto <D.30847>; else goto <D.30848>;
          <D.30847>:
          D.30849 = clause1->try_offset;
          D.30850 = clause2->try_offset;
          if (D.30849 >= D.30850) goto <D.30851>; else goto <D.30852>;
          <D.30851>:
          D.30853 = clause1->handler_offset;
          D.30854 = clause2->handler_offset;
          if (D.30853 <= D.30854) goto <D.30855>; else goto <D.30856>;
          <D.30855>:
          p.265 = p;
          encode_value (i, p.265, &p);
          <D.30856>:
          <D.30852>:
          <D.30848>:
        }
        i = i + 1;
        <D.24621>:
        D.30750 = header->num_clauses;
        D.30751 = (int) D.30750;
        if (D.30751 > i) goto <D.24620>; else goto <D.24622>;
        <D.24622>:
        p.265 = p;
        encode_value (-1, p.265, &p);
      }
      k = k + 1;
      <D.24624>:
      D.30750 = header->num_clauses;
      D.30751 = (int) D.30750;
      if (D.30751 > k) goto <D.24623>; else goto <D.24625>;
      <D.24625>:
      goto <D.30857>;
      <D.30830>:
      D.30769 = BIT_FIELD_REF <*jinfo, 32, 160>;
      D.30858 = D.30769 & 32767;
      if (D.30858 != 0) goto <D.30859>; else goto <D.30860>;
      <D.30859>:
      D.30861 = jinfo->num_clauses;
      D.30862 = (int) D.30861;
      p.265 = p;
      encode_value (D.30862, p.265, &p);
      <D.30860>:
      k = 0;
      goto <D.24631>;
      <D.24630>:
      {
        struct MonoJitExceptionInfo * ei;

        ei = &jinfo->clauses[k];
        D.30863 = ei->flags;
        D.30864 = (int) D.30863;
        p.265 = p;
        encode_value (D.30864, p.265, &p);
        D.30865 = ei->exvar_offset;
        p.265 = p;
        encode_value (D.30865, p.265, &p);
        D.30863 = ei->flags;
        D.30866 = D.30863 + 4294967295;
        if (D.30866 <= 1) goto <D.30867>; else goto <D.30868>;
        <D.30867>:
        D.30869 = ei->data.filter;
        D.30870 = (int) D.30869;
        code.270 = (int) code;
        D.30872 = D.30870 - code.270;
        p.265 = p;
        encode_value (D.30872, p.265, &p);
        goto <D.30873>;
        <D.30868>:
        D.30874 = ei->data.catch_class;
        if (D.30874 != 0B) goto <D.30875>; else goto <D.30876>;
        <D.30875>:
        {
          guint8 * buf2;
          guint8 * p2;
          int len;

          try
            {
              buf2 = monoeg_malloc (4096);
              p2 = buf2;
              D.30874 = ei->data.catch_class;
              p2.271 = p2;
              encode_klass_ref (acfg, D.30874, p2.271, &p2);
              p2.271 = p2;
              p2.272 = (int) p2.271;
              buf2.273 = (int) buf2;
              len = p2.272 - buf2.273;
              D.30880 = len > 4095;
              D.30881 = (long int) D.30880;
              D.30882 = __builtin_expect (D.30881, 0);
              if (D.30882 != 0) goto <D.30883>; else goto <D.30884>;
              <D.30883>:
              monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "aot-compiler.c", 5325, "len < 4096");
              <D.30884>:
              p.265 = p;
              encode_value (len, p.265, &p);
              p.265 = p;
              len.274 = (unsigned int) len;
              memcpy (p.265, buf2, len.274);
              p.265 = p;
              p2.271 = p2;
              p2.272 = (int) p2.271;
              buf2.273 = (int) buf2;
              D.30886 = p2.272 - buf2.273;
              D.30887 = (sizetype) D.30886;
              p.275 = p.265 + D.30887;
              p = p.275;
              monoeg_g_free (buf2);
            }
          finally
            {
              p2 = {CLOBBER};
            }
        }
        goto <D.30889>;
        <D.30876>:
        p.265 = p;
        encode_value (0, p.265, &p);
        <D.30889>:
        <D.30873>:
        D.30890 = ei->try_start;
        D.30891 = (int) D.30890;
        code.270 = (int) code;
        D.30892 = D.30891 - code.270;
        p.265 = p;
        encode_value (D.30892, p.265, &p);
        D.30893 = ei->try_end;
        D.30894 = (int) D.30893;
        code.270 = (int) code;
        D.30895 = D.30894 - code.270;
        p.265 = p;
        encode_value (D.30895, p.265, &p);
        D.30896 = ei->handler_start;
        D.30897 = (int) D.30896;
        code.270 = (int) code;
        D.30898 = D.30897 - code.270;
        p.265 = p;
        encode_value (D.30898, p.265, &p);
      }
      k = k + 1;
      <D.24631>:
      D.30861 = jinfo->num_clauses;
      D.30899 = (int) D.30861;
      if (D.30899 > k) goto <D.24630>; else goto <D.24632>;
      <D.24632>:
      <D.30857>:
      D.30769 = BIT_FIELD_REF <*jinfo, 32, 160>;
      D.30798 = D.30769 & 262144;
      if (D.30798 != 0) goto <D.30900>; else goto <D.30901>;
      <D.30900>:
      {
        struct MonoTryBlockHoleTableJitInfo * table;

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

          hole = &table->holes[i];
          D.30902 = hole->clause;
          D.30903 = (int) D.30902;
          p.265 = p;
          encode_value (D.30903, p.265, &p);
          D.30904 = hole->length;
          D.30905 = (int) D.30904;
          p.265 = p;
          encode_value (D.30905, p.265, &p);
          D.30906 = hole->offset;
          D.30907 = (int) D.30906;
          p.265 = p;
          encode_value (D.30907, p.265, &p);
        }
        i = i + 1;
        <D.24636>:
        D.30908 = table->num_holes;
        D.30909 = (int) D.30908;
        if (D.30909 > i) goto <D.24635>; else goto <D.24637>;
        <D.24637>:
      }
      <D.30901>:
      D.30769 = BIT_FIELD_REF <*jinfo, 32, 160>;
      D.30810 = D.30769 & 524288;
      if (D.30810 != 0) goto <D.30910>; else goto <D.30911>;
      <D.30910>:
      {
        struct MonoArchEHJitInfo * eh_info;

        eh_info = mono_jit_info_get_arch_eh_info (jinfo);
        D.30912 = eh_info->stack_size;
        D.30913 = (int) D.30912;
        p.265 = p;
        encode_value (D.30913, p.265, &p);
      }
      <D.30911>:
      D.30769 = BIT_FIELD_REF <*jinfo, 32, 160>;
      D.30770 = D.30769 & 131072;
      if (D.30770 != 0) goto <D.30914>; else goto <D.30915>;
      <D.30914>:
      {
        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.30916 = gi->nlocs;
            p.265 = p;
            encode_value (D.30916, p.265, &p);
            D.30916 = gi->nlocs;
            if (D.30916 != 0) goto <D.30917>; else goto <D.30918>;
            <D.30917>:
            i = 0;
            goto <D.24647>;
            <D.24646>:
            {
              struct MonoDwarfLocListEntry * entry;

              D.30919 = gi->locations;
              i.276 = (unsigned int) i;
              D.30921 = i.276 * 20;
              entry = D.30919 + D.30921;
              D.30922 = entry->is_reg;
              D.30923 = D.30922 != 0;
              D.30924 = (int) D.30923;
              p.265 = p;
              encode_value (D.30924, p.265, &p);
              D.30925 = entry->reg;
              p.265 = p;
              encode_value (D.30925, p.265, &p);
              D.30922 = entry->is_reg;
              if (D.30922 == 0) goto <D.30926>; else goto <D.30927>;
              <D.30926>:
              D.30928 = entry->offset;
              p.265 = p;
              encode_value (D.30928, p.265, &p);
              <D.30927>:
              if (i == 0) goto <D.30929>; else goto <D.30930>;
              <D.30929>:
              D.30931 = entry->from;
              D.30932 = D.30931 != 0;
              D.30933 = (long int) D.30932;
              D.30934 = __builtin_expect (D.30933, 0);
              if (D.30934 != 0) goto <D.30935>; else goto <D.30936>;
              <D.30935>:
              monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "aot-compiler.c", 5376, "entry->from == 0");
              <D.30936>:
              goto <D.30937>;
              <D.30930>:
              D.30931 = entry->from;
              p.265 = p;
              encode_value (D.30931, p.265, &p);
              <D.30937>:
              D.30938 = entry->to;
              p.265 = p;
              encode_value (D.30938, p.265, &p);
            }
            i = i + 1;
            <D.24647>:
            D.30916 = gi->nlocs;
            if (D.30916 > i) goto <D.24646>; else goto <D.24648>;
            <D.24648>:
            goto <D.30939>;
            <D.30918>:
            D.30791 = BIT_FIELD_REF <*cfg, 32, 3392>;
            D.30792 = D.30791 & 256;
            if (D.30792 == 0) goto <D.30940>; else goto <D.30941>;
            <D.30940>:
            D.30942 = BIT_FIELD_REF <*gi, 32, 128>;
            D.30943 = D.30942 & 256;
            D.30944 = D.30943 != 0;
            D.30945 = (int) D.30944;
            p.265 = p;
            encode_value (D.30945, p.265, &p);
            D.30946 = gi->this_reg;
            D.30947 = (int) D.30946;
            p.265 = p;
            encode_value (D.30947, p.265, &p);
            D.30948 = gi->this_offset;
            p.265 = p;
            encode_value (D.30948, p.265, &p);
            <D.30941>:
            <D.30939>:
            buf2 = monoeg_malloc (4096);
            p2 = buf2;
            D.30949 = jinfo->d.method;
            p2.277 = p2;
            encode_method_ref (acfg, D.30949, p2.277, &p2);
            p2.277 = p2;
            p2.278 = (int) p2.277;
            buf2.279 = (int) buf2;
            len = p2.278 - buf2.279;
            D.30953 = len > 4095;
            D.30954 = (long int) D.30953;
            D.30955 = __builtin_expect (D.30954, 0);
            if (D.30955 != 0) goto <D.30956>; else goto <D.30957>;
            <D.30956>:
            monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "aot-compiler.c", 5397, "len < 4096");
            <D.30957>:
            p.265 = p;
            encode_value (len, p.265, &p);
            p.265 = p;
            len.280 = (unsigned int) len;
            memcpy (p.265, buf2, len.280);
            p.265 = p;
            p2.277 = p2;
            p2.278 = (int) p2.277;
            buf2.279 = (int) buf2;
            D.30959 = p2.278 - buf2.279;
            D.30960 = (sizetype) D.30959;
            p.281 = p.265 + D.30960;
            p = p.281;
            monoeg_g_free (buf2);
            if (gsctx != 0B) goto <D.30965>; else goto <D.30962>;
            <D.30965>:
            D.30966 = gsctx->var_is_vt;
            if (D.30966 != 0B) goto <D.30963>; else goto <D.30967>;
            <D.30967>:
            D.30968 = gsctx->mvar_is_vt;
            if (D.30968 != 0B) goto <D.30963>; else goto <D.30962>;
            <D.30963>:
            {
              struct MonoMethodInflated * inflated;
              struct MonoGenericContext * context;
              struct MonoGenericInst * inst;

              D.30949 = jinfo->d.method;
              D.30969 = BIT_FIELD_REF <*D.30949, 32, 160>;
              D.30970 = D.30969 & 4096;
              D.30971 = D.30970 == 0;
              D.30972 = (long int) D.30971;
              D.30973 = __builtin_expect (D.30972, 0);
              if (D.30973 != 0) goto <D.30974>; else goto <D.30975>;
              <D.30974>:
              monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "aot-compiler.c", 5408, "jinfo->d.method->is_inflated");
              <D.30975>:
              inflated = jinfo->d.method;
              context = &inflated->context;
              p.265 = p;
              encode_value (1, p.265, &p);
              D.30976 = context->class_inst;
              if (D.30976 != 0B) goto <D.30977>; else goto <D.30978>;
              <D.30977>:
              inst = context->class_inst;
              D.30979 = inst->type_argc;
              D.30980 = (int) D.30979;
              p.265 = p;
              encode_value (D.30980, p.265, &p);
              i = 0;
              goto <D.24653>;
              <D.24652>:
              D.30966 = gsctx->var_is_vt;
              i.276 = (unsigned int) i;
              D.30981 = i.276 * 4;
              D.30982 = D.30966 + D.30981;
              D.30983 = *D.30982;
              p.265 = p;
              encode_value (D.30983, p.265, &p);
              i = i + 1;
              <D.24653>:
              D.30979 = inst->type_argc;
              D.30984 = (int) D.30979;
              if (D.30984 > i) goto <D.24652>; else goto <D.24654>;
              <D.24654>:
              goto <D.30985>;
              <D.30978>:
              p.265 = p;
              encode_value (0, p.265, &p);
              <D.30985>:
              D.30986 = context->method_inst;
              if (D.30986 != 0B) goto <D.30987>; else goto <D.30988>;
              <D.30987>:
              inst = context->method_inst;
              D.30979 = inst->type_argc;
              D.30980 = (int) D.30979;
              p.265 = p;
              encode_value (D.30980, p.265, &p);
              i = 0;
              goto <D.24656>;
              <D.24655>:
              D.30968 = gsctx->mvar_is_vt;
              i.276 = (unsigned int) i;
              D.30981 = i.276 * 4;
              D.30989 = D.30968 + D.30981;
              D.30990 = *D.30989;
              p.265 = p;
              encode_value (D.30990, p.265, &p);
              i = i + 1;
              <D.24656>:
              D.30979 = inst->type_argc;
              D.30984 = (int) D.30979;
              if (D.30984 > i) goto <D.24655>; else goto <D.24657>;
              <D.24657>:
              goto <D.30991>;
              <D.30988>:
              p.265 = p;
              encode_value (0, p.265, &p);
              <D.30991>:
            }
            goto <D.30964>;
            <D.30962>:
            p.265 = p;
            encode_value (0, p.265, &p);
            <D.30964>:
          }
        finally
          {
            p2 = {CLOBBER};
          }
      }
      <D.30915>:
      if (seq_points != 0B) goto <D.30992>; else goto <D.30993>;
      <D.30992>:
      {
        int il_offset;
        int native_offset;
        int last_il_offset;
        int last_native_offset;
        int j;

        D.30759 = seq_points->len;
        p.265 = p;
        encode_value (D.30759, p.265, &p);
        last_native_offset = 0;
        last_il_offset = last_native_offset;
        i = 0;
        goto <D.24668>;
        <D.24667>:
        {
          struct SeqPoint * sp;

          sp = &seq_points->seq_points[i];
          il_offset = sp->il_offset;
          native_offset = sp->native_offset;
          D.30994 = il_offset - last_il_offset;
          p.265 = p;
          encode_value (D.30994, p.265, &p);
          D.30995 = native_offset - last_native_offset;
          p.265 = p;
          encode_value (D.30995, p.265, &p);
          last_il_offset = il_offset;
          last_native_offset = native_offset;
          D.30996 = sp->flags;
          p.265 = p;
          encode_value (D.30996, p.265, &p);
          D.30997 = sp->next_len;
          p.265 = p;
          encode_value (D.30997, p.265, &p);
          j = 0;
          goto <D.24665>;
          <D.24664>:
          D.30998 = sp->next;
          j.282 = (unsigned int) j;
          D.31000 = j.282 * 4;
          D.31001 = D.30998 + D.31000;
          D.31002 = *D.31001;
          p.265 = p;
          encode_value (D.31002, p.265, &p);
          j = j + 1;
          <D.24665>:
          D.30997 = sp->next_len;
          if (D.30997 > j) goto <D.24664>; else goto <D.24666>;
          <D.24666>:
        }
        i = i + 1;
        <D.24668>:
        D.30759 = seq_points->len;
        if (D.30759 > i) goto <D.24667>; else goto <D.24669>;
        <D.24669>:
      }
      <D.30993>:
      buf_size.283 = (unsigned int) buf_size;
      debug_info_size.254 = debug_info_size;
      D.31004 = buf_size.283 <= debug_info_size.254;
      D.31005 = (long int) D.31004;
      D.31006 = __builtin_expect (D.31005, 0);
      if (D.31006 != 0) goto <D.31007>; else goto <D.31008>;
      <D.31007>:
      monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "aot-compiler.c", 5457, "debug_info_size < buf_size");
      <D.31008>:
      debug_info_size.254 = debug_info_size;
      debug_info_size.284 = (int) debug_info_size.254;
      p.265 = p;
      encode_value (debug_info_size.284, p.265, &p);
      debug_info_size.254 = debug_info_size;
      if (debug_info_size.254 != 0) goto <D.31010>; else goto <D.31011>;
      <D.31010>:
      p.265 = p;
      debug_info.285 = debug_info;
      debug_info_size.254 = debug_info_size;
      memcpy (p.265, debug_info.285, debug_info_size.254);
      p.265 = p;
      debug_info_size.254 = debug_info_size;
      p.286 = p.265 + debug_info_size.254;
      p = p.286;
      debug_info.285 = debug_info;
      monoeg_g_free (debug_info.285);
      <D.31011>:
      D.30804 = cfg->gc_map;
      if (D.30804 != 0B) goto <D.31014>; else goto <D.31015>;
      <D.31014>:
      D.30763 = cfg->gc_map_size;
      D.31016 = (int) D.30763;
      p.265 = p;
      encode_value (D.31016, p.265, &p);
      goto <D.24671>;
      <D.24670>:
      p.265 = p;
      p.287 = p.265 + 1;
      p = p.287;
      <D.24671>:
      p.265 = p;
      p.288 = (unsigned int) p.265;
      D.31019 = p.288 & 3;
      if (D.31019 != 0) goto <D.24670>; else goto <D.24672>;
      <D.24672>:
      p.265 = p;
      D.30804 = cfg->gc_map;
      D.30763 = cfg->gc_map_size;
      memcpy (p.265, D.30804, D.30763);
      p.265 = p;
      D.30763 = cfg->gc_map_size;
      p.289 = p.265 + D.30763;
      p = p.289;
      <D.31015>:
      D.31021 = acfg->stats.ex_info_size;
      p.265 = p;
      p.290 = (int) p.265;
      buf.291 = (int) buf;
      D.31024 = p.290 - buf.291;
      D.31025 = D.31021 + D.31024;
      acfg->stats.ex_info_size = D.31025;
      p.265 = p;
      p.290 = (int) p.265;
      buf.291 = (int) buf;
      D.31024 = p.290 - buf.291;
      D.31026 = D.31024 >= buf_size;
      D.31027 = (long int) D.31026;
      D.31028 = __builtin_expect (D.31027, 0);
      if (D.31028 != 0) goto <D.31029>; else goto <D.31030>;
      <D.31029>:
      monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "aot-compiler.c", 5478, "p - buf < buf_size");
      <D.31030>:
      p.265 = p;
      p.290 = (int) p.265;
      buf.291 = (int) buf;
      D.31024 = p.290 - buf.291;
      D.31031 = (unsigned int) D.31024;
      D.30804 = cfg->gc_map;
      if (D.30804 != 0B) goto <D.31033>; else goto <D.31034>;
      <D.31033>:
      iftmp.292 = 4;
      goto <D.31035>;
      <D.31034>:
      iftmp.292 = 1;
      <D.31035>:
      D.31036 = add_to_blob_aligned (acfg, buf, D.31031, iftmp.292);
      cfg->ex_info_offset = D.31036;
      monoeg_g_free (buf);
    }
  finally
    {
      debug_info_size = {CLOBBER};
      p = {CLOBBER};
      debug_info = {CLOBBER};
    }
}


get_unwind_info_offset (struct MonoAotCompile * acfg, guint8 * encoded, guint32 encoded_len)
{
  struct GHashTable * D.31037;
  unsigned int D.31038;
  const void * D.31039;
  void * D.31040;
  guint32 D.31043;
  void * D.31044;
  unsigned int D.31045;
  void * D.31046;
  struct GPtrArray * D.31047;
  void * cache_index.293;
  int encoded_len.294;
  guint8 * p.295;
  unsigned int D.31051;
  int p.296;
  int buf.297;
  int D.31054;
  unsigned int D.31055;
  unsigned int D.31056;
  unsigned int D.31057;
  guint32 cache_index;
  guint32 offset;

  cache_index = mono_cache_unwind_info (encoded, encoded_len);
  D.31037 = acfg->unwind_info_offsets;
  D.31038 = cache_index + 1;
  D.31039 = (const void *) D.31038;
  D.31040 = monoeg_g_hash_table_lookup (D.31037, D.31039);
  offset = (guint32) D.31040;
  if (offset != 0) goto <D.31041>; else goto <D.31042>;
  <D.31041>:
  D.31043 = offset + 4294967295;
  return D.31043;
  <D.31042>:
  {
    guint8 buf[16];
    guint8 * p;

    try
      {
        offset = acfg->unwind_info_offset;
        D.31037 = acfg->unwind_info_offsets;
        D.31038 = cache_index + 1;
        D.31044 = (void *) D.31038;
        D.31045 = offset + 1;
        D.31046 = (void *) D.31045;
        monoeg_g_hash_table_insert_replace (D.31037, D.31044, D.31046, 0);
        D.31047 = acfg->unwind_ops;
        cache_index.293 = (void *) cache_index;
        monoeg_g_ptr_array_add (D.31047, cache_index.293);
        p = &buf;
        encoded_len.294 = (int) encoded_len;
        p.295 = p;
        encode_value (encoded_len.294, p.295, &p);
        D.31051 = acfg->unwind_info_offset;
        p.295 = p;
        p.296 = (int) p.295;
        buf.297 = (int) &buf;
        D.31054 = p.296 - buf.297;
        D.31055 = (unsigned int) D.31054;
        D.31056 = D.31055 + encoded_len;
        D.31057 = D.31051 + D.31056;
        acfg->unwind_info_offset = D.31057;
        D.31043 = offset;
        return D.31043;
      }
    finally
      {
        buf = {CLOBBER};
        p = {CLOBBER};
      }
  }
}


add_to_blob_aligned (struct MonoAotCompile * acfg, const guint8 * data, guint32 data_len, guint32 align)
{
  unsigned int D.31060;
  struct MonoDynamicStream * D.31063;
  unsigned int D.31064;
  unsigned int D.31067;
  guint32 D.31068;
  char buf[4];
  guint32 count;

  try
    {
      buf = {};
      D.31060 = acfg->blob.alloc_size;
      if (D.31060 == 0) goto <D.31061>; else goto <D.31062>;
      <D.31061>:
      D.31063 = &acfg->blob;
      stream_init (D.31063);
      <D.31062>:
      D.31064 = acfg->blob.index;
      count = D.31064 % align;
      if (count != 0) goto <D.31065>; else goto <D.31066>;
      <D.31065>:
      D.31063 = &acfg->blob;
      D.31067 = 4 - count;
      add_stream_data (D.31063, &buf, D.31067);
      <D.31066>:
      D.31063 = &acfg->blob;
      D.31068 = add_stream_data (D.31063, data, data_len);
      return D.31068;
    }
  finally
    {
      buf = {CLOBBER};
    }
}


emit_unwind_info (struct MonoAotCompile * acfg)
{
  struct GPtrArray * D.31071;
  void * * D.31072;
  unsigned int i.298;
  unsigned int D.31074;
  void * * D.31075;
  void * D.31076;
  unsigned int unwind_info_len.299;
  int unwind_info_len.300;
  guint8 * p.301;
  int p.302;
  int buf.303;
  int D.31082;
  int unwind_info_len.304;
  int D.31084;
  unsigned int D.31085;
  unsigned int D.31086;
  unsigned int D.31087;
  unsigned int D.31088;
  int D.31089;
  unsigned int i.305;
  unsigned int D.31091;
  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.25293>;
      <D.25292>:
      {
        guint32 index;
        guint8 * unwind_info;
        guint32 unwind_info_len;
        guint8 buf[16];
        guint8 * p;

        try
          {
            D.31071 = acfg->unwind_ops;
            D.31072 = D.31071->pdata;
            i.298 = (unsigned int) i;
            D.31074 = i.298 * 4;
            D.31075 = D.31072 + D.31074;
            D.31076 = *D.31075;
            index = (guint32) D.31076;
            unwind_info = mono_get_cached_unwind_info (index, &unwind_info_len);
            p = &buf;
            unwind_info_len.299 = unwind_info_len;
            unwind_info_len.300 = (int) unwind_info_len.299;
            p.301 = p;
            encode_value (unwind_info_len.300, p.301, &p);
            p.301 = p;
            p.302 = (int) p.301;
            buf.303 = (int) &buf;
            D.31082 = p.302 - buf.303;
            emit_bytes (acfg, &buf, D.31082);
            unwind_info_len.299 = unwind_info_len;
            unwind_info_len.304 = (int) unwind_info_len.299;
            emit_bytes (acfg, unwind_info, unwind_info_len.304);
            D.31084 = acfg->stats.unwind_info_size;
            D.31085 = (unsigned int) D.31084;
            p.301 = p;
            p.302 = (int) p.301;
            buf.303 = (int) &buf;
            D.31082 = p.302 - buf.303;
            D.31086 = (unsigned int) D.31082;
            unwind_info_len.299 = unwind_info_len;
            D.31087 = D.31086 + unwind_info_len.299;
            D.31088 = D.31085 + D.31087;
            D.31089 = (int) D.31088;
            acfg->stats.unwind_info_size = D.31089;
          }
        finally
          {
            unwind_info_len = {CLOBBER};
            buf = {CLOBBER};
            p = {CLOBBER};
          }
      }
      i = i + 1;
      <D.25293>:
      i.305 = (unsigned int) i;
      D.31071 = acfg->unwind_ops;
      D.31091 = D.31071->len;
      if (i.305 < D.31091) goto <D.25292>; else goto <D.25294>;
      <D.25294>:
    }
  finally
    {
      symbol = {CLOBBER};
    }
}


emit_class_info (struct MonoAotCompile * acfg)
{
  struct MonoImage * D.31092;
  <unnamed-unsigned:24> D.31093;
  unsigned int D.31094;
  unsigned int D.31095;
  unsigned int i.306;
  unsigned int D.31097;
  gint32 * D.31098;
  int D.31099;
  int D.31100;
  unsigned int D.31101;
  unsigned int D.31102;
  int D.31103;
  int D.31104;
  unsigned int D.31105;
  int D.31106;
  unsigned int D.31107;
  unsigned int D.31108;
  int D.31109;
  int i;
  char symbol[256];
  gint32 * offsets;

  try
    {
      D.31092 = acfg->image;
      D.31093 = D.31092->tables[2].rows;
      D.31094 = (unsigned int) D.31093;
      D.31095 = D.31094 * 4;
      offsets = monoeg_malloc0 (D.31095);
      i = 0;
      goto <D.25302>;
      <D.25301>:
      i.306 = (unsigned int) i;
      D.31097 = i.306 * 4;
      D.31098 = offsets + D.31097;
      D.31099 = i + 1;
      D.31100 = D.31099 | 33554432;
      D.31101 = (unsigned int) D.31100;
      D.31102 = emit_klass_info (acfg, D.31101);
      D.31103 = (int) D.31102;
      *D.31098 = D.31103;
      i = i + 1;
      <D.25302>:
      D.31092 = acfg->image;
      D.31093 = D.31092->tables[2].rows;
      D.31104 = (int) D.31093;
      if (D.31104 > i) goto <D.25301>; else goto <D.25303>;
      <D.25303>:
      sprintf (&symbol, "class_info_offsets");
      emit_section_change (acfg, ".rodata", 1);
      emit_alignment (acfg, 8);
      emit_label (acfg, &symbol);
      D.31092 = acfg->image;
      D.31093 = D.31092->tables[2].rows;
      D.31104 = (int) D.31093;
      D.31105 = emit_offset_table (acfg, D.31104, 10, offsets);
      D.31106 = acfg->stats.offsets_size;
      D.31107 = (unsigned int) D.31106;
      D.31108 = D.31107 + D.31105;
      D.31109 = (int) D.31108;
      acfg->stats.offsets_size = D.31109;
      monoeg_g_free (offsets);
    }
  finally
    {
      symbol = {CLOBBER};
    }
}


emit_klass_info (struct MonoAotCompile * acfg, guint32 token)
{
  struct MonoImage * D.31110;
  unsigned int buf_size.307;
  guint8 * p.308;
  int p.309;
  int buf.310;
  int D.31117;
  unsigned int D.31118;
  unsigned int D.31119;
  guint32 D.31120;
  int D.31121;
  int D.31122;
  _Bool D.31123;
  long int D.31124;
  long int D.31125;
  unsigned int D.31128;
  signed int D.31129;
  _Bool D.31130;
  long int D.31131;
  long int D.31132;
  int D.31135;
  _Bool D.31136;
  struct MonoMethod * * D.31137;
  unsigned int i.311;
  unsigned int D.31139;
  struct MonoMethod * * D.31140;
  struct MonoMethodSignature * D.31143;
  unsigned int D.31144;
  unsigned int D.31145;
  struct GHashTable * D.31148;
  void * D.31149;
  struct MonoGenericContainer * D.31154;
  gboolean iftmp.312;
  int D.31160;
  int D.31161;
  <unnamed-unsigned:1> D.31162;
  int D.31163;
  int D.31164;
  int D.31165;
  <unnamed-unsigned:1> D.31166;
  int D.31167;
  int D.31168;
  int D.31169;
  <unnamed-unsigned:1> D.31170;
  int D.31171;
  int D.31172;
  int iftmp.313;
  struct MonoClassExt * D.31176;
  struct GList * D.31178;
  int D.31180;
  int D.31181;
  int D.31182;
  <unnamed-unsigned:1> D.31183;
  int D.31184;
  int D.31185;
  int D.31186;
  <unnamed-unsigned:1> D.31187;
  int D.31188;
  int D.31189;
  int D.31190;
  <unnamed-unsigned:1> D.31191;
  int D.31192;
  int D.31193;
  unsigned int D.31194;
  struct MonoMethod * D.31197;
  unsigned int D.31198;
  struct MonoMethod * D.31201;
  int D.31202;
  int D.31203;
  <unnamed-unsigned:4> D.31204;
  int D.31205;
  unsigned char D.31206;
  int D.31207;
  int D.31211;
  int D.31212;
  _Bool D.31213;
  long int D.31214;
  long int D.31215;
  unsigned int D.31218;
  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.31110 = acfg->image;
      klass = mono_class_get (D.31110, token);
      iter = 0B;
      if (klass == 0B) goto <D.31111>; else goto <D.31112>;
      <D.31111>:
      mono_loader_clear_error ();
      buf_size = 16;
      buf_size.307 = (unsigned int) buf_size;
      buf = monoeg_malloc (buf_size.307);
      p = buf;
      p.308 = p;
      encode_value (-1, p.308, &p);
      p.308 = p;
      p.309 = (int) p.308;
      buf.310 = (int) buf;
      D.31117 = p.309 - buf.310;
      D.31118 = (unsigned int) D.31117;
      D.31119 = add_to_blob (acfg, buf, D.31118);
      res = (int) D.31119;
      monoeg_g_free (buf);
      D.31120 = (guint32) res;
      return D.31120;
      <D.31112>:
      D.31121 = klass->vtable_size;
      D.31122 = D.31121 + 640;
      buf_size = D.31122 * 16;
      buf_size.307 = (unsigned int) buf_size;
      buf = monoeg_malloc (buf_size.307);
      p = buf;
      D.31123 = klass == 0B;
      D.31124 = (long int) D.31123;
      D.31125 = __builtin_expect (D.31124, 0);
      if (D.31125 != 0) goto <D.31126>; else goto <D.31127>;
      <D.31126>:
      monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "aot-compiler.c", 5514, "klass");
      <D.31127>:
      mono_class_init (klass);
      mono_class_get_nested_types (klass, &iter);
      D.31128 = BIT_FIELD_REF <*klass, 32, 160>;
      D.31129 = (signed int) D.31128;
      D.31130 = D.31129 >= 0;
      D.31131 = (long int) D.31130;
      D.31132 = __builtin_expect (D.31131, 0);
      if (D.31132 != 0) goto <D.31133>; else goto <D.31134>;
      <D.31133>:
      monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "aot-compiler.c", 5519, "klass->nested_classes_inited");
      <D.31134>:
      mono_class_setup_vtable (klass);
      D.31135 = mono_class_has_special_static_fields (klass);
      D.31136 = D.31135 == 0;
      no_special_static = (gboolean) D.31136;
      cant_encode = 0;
      i = 0;
      goto <D.24688>;
      <D.24687>:
      {
        struct MonoMethod * cm;

        D.31137 = klass->vtable;
        i.311 = (unsigned int) i;
        D.31139 = i.311 * 4;
        D.31140 = D.31137 + D.31139;
        cm = *D.31140;
        if (cm != 0B) goto <D.31141>; else goto <D.31142>;
        <D.31141>:
        D.31143 = mono_method_signature (cm);
        D.31144 = BIT_FIELD_REF <*D.31143, 32, 64>;
        D.31145 = D.31144 & 33554432;
        if (D.31145 != 0) goto <D.31146>; else goto <D.31147>;
        <D.31146>:
        D.31148 = acfg->token_info_hash;
        D.31149 = monoeg_g_hash_table_lookup (D.31148, cm);
        if (D.31149 == 0B) goto <D.31150>; else goto <D.31151>;
        <D.31150>:
        cant_encode = 1;
        <D.31151>:
        <D.31147>:
        <D.31142>:
      }
      i = i + 1;
      <D.24688>:
      D.31121 = klass->vtable_size;
      if (D.31121 > i) goto <D.24687>; else goto <D.24689>;
      <D.24689>:
      mono_class_has_finalizer (klass);
      D.31154 = klass->generic_container;
      if (D.31154 != 0B) goto <D.31152>; else goto <D.31155>;
      <D.31155>:
      if (cant_encode != 0) goto <D.31152>; else goto <D.31153>;
      <D.31152>:
      p.308 = p;
      encode_value (-1, p.308, &p);
      goto <D.24693>;
      <D.31153>:
      D.31121 = klass->vtable_size;
      p.308 = p;
      encode_value (D.31121, p.308, &p);
      D.31154 = klass->generic_container;
      if (D.31154 != 0B) goto <D.31157>; else goto <D.31158>;
      <D.31157>:
      iftmp.312 = 256;
      goto <D.31159>;
      <D.31158>:
      iftmp.312 = 0;
      <D.31159>:
      D.31160 = no_special_static << 7;
      D.31161 = iftmp.312 | D.31160;
      D.31162 = klass->has_static_refs;
      D.31163 = (int) D.31162;
      D.31164 = D.31163 << 6;
      D.31165 = D.31161 | D.31164;
      D.31166 = klass->has_references;
      D.31167 = (int) D.31166;
      D.31168 = D.31167 << 5;
      D.31169 = D.31165 | D.31168;
      D.31170 = klass->blittable;
      D.31171 = (int) D.31170;
      D.31172 = D.31171 << 4;
      D.31176 = klass->ext;
      if (D.31176 != 0B) goto <D.31177>; else goto <D.31174>;
      <D.31177>:
      D.31176 = klass->ext;
      D.31178 = D.31176->nested_classes;
      if (D.31178 != 0B) goto <D.31179>; else goto <D.31174>;
      <D.31179>:
      iftmp.313 = 1;
      goto <D.31175>;
      <D.31174>:
      iftmp.313 = 0;
      <D.31175>:
      D.31180 = iftmp.313 << 3;
      D.31181 = D.31172 | D.31180;
      D.31182 = D.31169 | D.31181;
      D.31183 = klass->has_cctor;
      D.31184 = (int) D.31183;
      D.31185 = D.31184 << 2;
      D.31186 = D.31182 | D.31185;
      D.31187 = klass->has_finalize;
      D.31188 = (int) D.31187;
      D.31189 = D.31188 << 1;
      D.31190 = D.31186 | D.31189;
      D.31191 = klass->ghcimpl;
      D.31192 = (int) D.31191;
      D.31193 = D.31190 | D.31192;
      p.308 = p;
      encode_value (D.31193, p.308, &p);
      D.31128 = BIT_FIELD_REF <*klass, 32, 160>;
      D.31194 = D.31128 & 67108864;
      if (D.31194 != 0) goto <D.31195>; else goto <D.31196>;
      <D.31195>:
      D.31197 = mono_class_get_cctor (klass);
      p.308 = p;
      encode_method_ref (acfg, D.31197, p.308, &p);
      <D.31196>:
      D.31128 = BIT_FIELD_REF <*klass, 32, 160>;
      D.31198 = D.31128 & 2097152;
      if (D.31198 != 0) goto <D.31199>; else goto <D.31200>;
      <D.31199>:
      D.31201 = mono_class_get_finalizer (klass);
      p.308 = p;
      encode_method_ref (acfg, D.31201, p.308, &p);
      <D.31200>:
      D.31202 = klass->instance_size;
      p.308 = p;
      encode_value (D.31202, p.308, &p);
      D.31203 = mono_class_data_size (klass);
      p.308 = p;
      encode_value (D.31203, p.308, &p);
      D.31204 = klass->packing_size;
      D.31205 = (int) D.31204;
      p.308 = p;
      encode_value (D.31205, p.308, &p);
      D.31206 = klass->min_align;
      D.31207 = (int) D.31206;
      p.308 = p;
      encode_value (D.31207, p.308, &p);
      i = 0;
      goto <D.24692>;
      <D.24691>:
      {
        struct MonoMethod * cm;

        D.31137 = klass->vtable;
        i.311 = (unsigned int) i;
        D.31139 = i.311 * 4;
        D.31140 = D.31137 + D.31139;
        cm = *D.31140;
        if (cm != 0B) goto <D.31208>; else goto <D.31209>;
        <D.31208>:
        p.308 = p;
        encode_method_ref (acfg, cm, p.308, &p);
        goto <D.31210>;
        <D.31209>:
        p.308 = p;
        encode_value (0, p.308, &p);
        <D.31210>:
      }
      i = i + 1;
      <D.24692>:
      D.31121 = klass->vtable_size;
      if (D.31121 > i) goto <D.24691>; else goto <D.24693>;
      <D.24693>:
      D.31211 = acfg->stats.class_info_size;
      p.308 = p;
      p.309 = (int) p.308;
      buf.310 = (int) buf;
      D.31117 = p.309 - buf.310;
      D.31212 = D.31211 + D.31117;
      acfg->stats.class_info_size = D.31212;
      p.308 = p;
      p.309 = (int) p.308;
      buf.310 = (int) buf;
      D.31117 = p.309 - buf.310;
      D.31213 = D.31117 >= buf_size;
      D.31214 = (long int) D.31213;
      D.31215 = __builtin_expect (D.31214, 0);
      if (D.31215 != 0) goto <D.31216>; else goto <D.31217>;
      <D.31216>:
      monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "aot-compiler.c", 5569, "p - buf < buf_size");
      <D.31217>:
      p.308 = p;
      p.309 = (int) p.308;
      buf.310 = (int) buf;
      D.31117 = p.309 - buf.310;
      D.31118 = (unsigned int) D.31117;
      D.31218 = add_to_blob (acfg, buf, D.31118);
      res = (int) D.31218;
      monoeg_g_free (buf);
      D.31120 = (guint32) res;
      return D.31120;
    }
  finally
    {
      p = {CLOBBER};
      iter = {CLOBBER};
    }
}


emit_plt (struct MonoAotCompile * acfg)
{
  char * D.31221;
  struct GHashTable * D.31224;
  const void * i.314;
  int D.31226;
  int D.31231;
  int D.31234;
  struct GHashTable * D.31237;
  struct MonoMethod * D.31238;
  int D.31243;
  unsigned int D.31245;
  unsigned int D.31246;
  struct FILE * D.31248;
  char * D.31249;
  char * D.31250;
  int D.31253;
  int D.31262;
  char * D.31265;
  unsigned int i.315;
  unsigned int D.31269;
  int D.31276;
  int D.31281;
  int D.31284;
  char * D.31287;
  char * D.31292;
  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.31221 = acfg->plt_symbol;
      emit_label (acfg, D.31221);
      i = 0;
      goto <D.24722>;
      <D.24721>:
      {
        char * debug_sym;
        struct MonoPltEntry * plt_entry;
        struct MonoJumpInfo * ji;

        debug_sym = 0B;
        plt_entry = 0B;
        if (i == 0) goto <D.31222>; else goto <D.31223>;
        <D.31222>:
        // predicted unlikely by continue predictor.
        goto <D.24719>;
        <D.31223>:
        D.31224 = acfg->plt_offset_to_entry;
        i.314 = (const void *) i;
        plt_entry = monoeg_g_hash_table_lookup (D.31224, i.314);
        ji = plt_entry->ji;
        D.31226 = acfg->llvm;
        if (D.31226 != 0) goto <D.31227>; else goto <D.31228>;
        <D.31227>:
        if (ji != 0B) goto <D.31229>; else goto <D.31230>;
        <D.31229>:
        D.31231 = is_direct_callable (acfg, 0B, ji);
        if (D.31231 != 0) goto <D.31232>; else goto <D.31233>;
        <D.31232>:
        D.31234 = acfg->use_bin_writer;
        if (D.31234 == 0) goto <D.31235>; else goto <D.31236>;
        <D.31235>:
        {
          struct MonoCompile * callee_cfg;

          D.31237 = acfg->method_to_cfg;
          D.31238 = ji->data.method;
          callee_cfg = monoeg_g_hash_table_lookup (D.31237, D.31238);
          if (callee_cfg != 0B) goto <D.31239>; else goto <D.31240>;
          <D.31239>:
          D.31243 = acfg->thumb_mixed;
          if (D.31243 != 0) goto <D.31244>; else goto <D.31241>;
          <D.31244>:
          D.31245 = BIT_FIELD_REF <*callee_cfg, 32, 3392>;
          D.31246 = D.31245 & 256;
          if (D.31246 == 0) goto <D.31247>; else goto <D.31241>;
          <D.31247>:
          emit_set_thumb_mode (acfg);
          D.31248 = acfg->fp;
          fprintf (D.31248, "\n.thumb_func\n");
          D.31249 = plt_entry->llvm_symbol;
          emit_label (acfg, D.31249);
          D.31248 = acfg->fp;
          fprintf (D.31248, "bx pc\n");
          D.31248 = acfg->fp;
          fprintf (D.31248, "nop\n");
          emit_set_arm_mode (acfg);
          D.31248 = acfg->fp;
          D.31250 = callee_cfg->asm_symbol;
          fprintf (D.31248, "b %s\n", D.31250);
          goto <D.31242>;
          <D.31241>:
          D.31248 = acfg->fp;
          D.31249 = plt_entry->llvm_symbol;
          D.31250 = callee_cfg->asm_symbol;
          fprintf (D.31248, "\n.set %s, %s\n", D.31249, D.31250);
          <D.31242>:
          // predicted unlikely by continue predictor.
          goto <D.24719>;
          <D.31240>:
        }
        <D.31236>:
        <D.31233>:
        <D.31230>:
        <D.31228>:
        debug_sym = plt_entry->debug_sym;
        D.31243 = acfg->thumb_mixed;
        if (D.31243 != 0) goto <D.31251>; else goto <D.31252>;
        <D.31251>:
        D.31253 = plt_entry->jit_used;
        if (D.31253 == 0) goto <D.31254>; else goto <D.31255>;
        <D.31254>:
        // predicted unlikely by continue predictor.
        goto <D.24719>;
        <D.31255>:
        <D.31252>:
        D.31226 = acfg->llvm;
        if (D.31226 != 0) goto <D.31256>; else goto <D.31257>;
        <D.31256>:
        D.31243 = acfg->thumb_mixed;
        if (D.31243 == 0) goto <D.31258>; else goto <D.31259>;
        <D.31258>:
        D.31249 = plt_entry->llvm_symbol;
        emit_label (acfg, D.31249);
        <D.31259>:
        <D.31257>:
        if (debug_sym != 0B) goto <D.31260>; else goto <D.31261>;
        <D.31260>:
        D.31262 = acfg->need_no_dead_strip;
        if (D.31262 != 0) goto <D.31263>; else goto <D.31264>;
        <D.31263>:
        emit_unset_mode (acfg);
        D.31248 = acfg->fp;
        fprintf (D.31248, "\t.no_dead_strip %s\n", debug_sym);
        <D.31264>:
        emit_local_symbol (acfg, debug_sym, 0B, 1);
        emit_label (acfg, debug_sym);
        <D.31261>:
        D.31265 = plt_entry->symbol;
        emit_label (acfg, D.31265);
        arch_emit_plt_entry (acfg, i);
        if (debug_sym != 0B) goto <D.31266>; else goto <D.31267>;
        <D.31266>:
        emit_symbol_size (acfg, debug_sym, ".");
        <D.31267>:
      }
      <D.24719>:
      i = i + 1;
      <D.24722>:
      i.315 = (unsigned int) i;
      D.31269 = acfg->plt_offset;
      if (i.315 < D.31269) goto <D.24721>; else goto <D.24723>;
      <D.24723>:
      D.31243 = acfg->thumb_mixed;
      if (D.31243 != 0) goto <D.31270>; else goto <D.31271>;
      <D.31270>:
      emit_zero_bytes (acfg, 16);
      i = 0;
      goto <D.24729>;
      <D.24728>:
      {
        char * debug_sym;
        struct MonoPltEntry * plt_entry;
        struct MonoJumpInfo * ji;

        debug_sym = 0B;
        plt_entry = 0B;
        if (i == 0) goto <D.31272>; else goto <D.31273>;
        <D.31272>:
        // predicted unlikely by continue predictor.
        goto <D.24727>;
        <D.31273>:
        D.31224 = acfg->plt_offset_to_entry;
        i.314 = (const void *) i;
        plt_entry = monoeg_g_hash_table_lookup (D.31224, i.314);
        ji = plt_entry->ji;
        if (ji != 0B) goto <D.31274>; else goto <D.31275>;
        <D.31274>:
        D.31276 = is_direct_callable (acfg, 0B, ji);
        if (D.31276 != 0) goto <D.31277>; else goto <D.31278>;
        <D.31277>:
        D.31234 = acfg->use_bin_writer;
        if (D.31234 == 0) goto <D.31279>; else goto <D.31280>;
        <D.31279>:
        // predicted unlikely by continue predictor.
        goto <D.24727>;
        <D.31280>:
        <D.31278>:
        <D.31275>:
        D.31281 = plt_entry->llvm_used;
        if (D.31281 == 0) goto <D.31282>; else goto <D.31283>;
        <D.31282>:
        // predicted unlikely by continue predictor.
        goto <D.24727>;
        <D.31283>:
        D.31284 = acfg->aot_opts.write_symbols;
        if (D.31284 != 0) goto <D.31285>; else goto <D.31286>;
        <D.31285>:
        D.31287 = plt_entry->debug_sym;
        if (D.31287 != 0B) goto <D.31288>; else goto <D.31289>;
        <D.31288>:
        D.31287 = plt_entry->debug_sym;
        debug_sym = monoeg_g_strdup_printf ("%s_thumb", D.31287);
        <D.31289>:
        <D.31286>:
        if (debug_sym != 0B) goto <D.31290>; else goto <D.31291>;
        <D.31290>:
        emit_local_symbol (acfg, debug_sym, 0B, 1);
        emit_label (acfg, debug_sym);
        <D.31291>:
        D.31248 = acfg->fp;
        fprintf (D.31248, "\n.thumb_func\n");
        D.31292 = plt_entry->llvm_symbol;
        emit_label (acfg, D.31292);
        arch_emit_llvm_plt_entry (acfg, i);
        if (debug_sym != 0B) goto <D.31293>; else goto <D.31294>;
        <D.31293>:
        emit_symbol_size (acfg, debug_sym, ".");
        monoeg_g_free (debug_sym);
        <D.31294>:
      }
      <D.24727>:
      i = i + 1;
      <D.24729>:
      i.315 = (unsigned int) i;
      D.31269 = acfg->plt_offset;
      if (i.315 < D.31269) goto <D.24728>; else goto <D.24730>;
      <D.24730>:
      <D.31271>:
      D.31221 = acfg->plt_symbol;
      emit_symbol_size (acfg, D.31221, ".");
      sprintf (&symbol, "plt_end");
      emit_label (acfg, &symbol);
    }
  finally
    {
      symbol = {CLOBBER};
    }
}


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


is_direct_callable (struct MonoAotCompile * acfg, struct MonoMethod * method, struct MonoJumpInfo * patch_info)
{
  <unnamed type> D.31297;
  struct MonoMethod * D.31299;
  struct MonoClass * D.31300;
  struct MonoImage * D.31301;
  struct MonoImage * D.31302;
  struct GHashTable * D.31304;
  unsigned int D.31311;
  unsigned int D.31312;
  struct MonoMethod * D.31314;
  struct MonoClass * D.31315;
  unsigned int D.31316;
  unsigned int D.31317;
  short unsigned int D.31320;
  int D.31321;
  int D.31322;
  unsigned int D.31326;
  unsigned int D.31327;
  int D.31330;
  int D.31332;
  unsigned int D.31333;
  unsigned int D.31334;
  gboolean D.31339;
  short unsigned int D.31343;
  int D.31344;
  int D.31345;
  int D.31347;
  int D.31352;

  D.31297 = patch_info->type;
  if (D.31297 == 3) goto <D.31298>; else goto <D.31295>;
  <D.31298>:
  D.31299 = patch_info->data.method;
  D.31300 = D.31299->klass;
  D.31301 = D.31300->image;
  D.31302 = acfg->image;
  if (D.31301 == D.31302) goto <D.31303>; else goto <D.31295>;
  <D.31303>:
  {
    struct MonoCompile * callee_cfg;

    D.31304 = acfg->method_to_cfg;
    D.31299 = patch_info->data.method;
    callee_cfg = monoeg_g_hash_table_lookup (D.31304, D.31299);
    if (callee_cfg != 0B) goto <D.31305>; else goto <D.31306>;
    <D.31305>:
    {
      gboolean direct_callable;

      direct_callable = 1;
      if (direct_callable != 0) goto <D.31309>; else goto <D.31310>;
      <D.31309>:
      D.31311 = BIT_FIELD_REF <*callee_cfg, 32, 3424>;
      D.31312 = D.31311 & 1;
      if (D.31312 != 0) goto <D.31307>; else goto <D.31313>;
      <D.31313>:
      D.31314 = callee_cfg->method;
      D.31315 = D.31314->klass;
      D.31316 = D.31315->flags;
      D.31317 = D.31316 & 1048576;
      if (D.31317 == 0) goto <D.31307>; else goto <D.31308>;
      <D.31307>:
      direct_callable = 0;
      <D.31308>:
      <D.31310>:
      D.31314 = callee_cfg->method;
      D.31320 = D.31314->iflags;
      D.31321 = (int) D.31320;
      D.31322 = D.31321 & 32;
      if (D.31322 != 0) goto <D.31323>; else goto <D.31324>;
      <D.31323>:
      if (method == 0B) goto <D.31318>; else goto <D.31325>;
      <D.31325>:
      D.31326 = BIT_FIELD_REF <*method, 32, 160>;
      D.31327 = D.31326 & 124;
      if (D.31327 != 64) goto <D.31318>; else goto <D.31319>;
      <D.31318>:
      direct_callable = 0;
      <D.31319>:
      <D.31324>:
      D.31330 = acfg->aot_opts.soft_debug;
      if (D.31330 != 0) goto <D.31328>; else goto <D.31331>;
      <D.31331>:
      D.31332 = acfg->aot_opts.no_direct_calls;
      if (D.31332 != 0) goto <D.31328>; else goto <D.31329>;
      <D.31328>:
      direct_callable = 0;
      <D.31329>:
      D.31314 = callee_cfg->method;
      D.31333 = BIT_FIELD_REF <*D.31314, 32, 160>;
      D.31334 = D.31333 & 124;
      if (D.31334 == 112) goto <D.31335>; else goto <D.31336>;
      <D.31335>:
      direct_callable = 0;
      <D.31336>:
      if (direct_callable != 0) goto <D.31337>; else goto <D.31338>;
      <D.31337>:
      D.31339 = 1;
      return D.31339;
      <D.31338>:
    }
    <D.31306>:
  }
  goto <D.31296>;
  <D.31295>:
  D.31297 = patch_info->type;
  if (D.31297 == 31) goto <D.31342>; else goto <D.31340>;
  <D.31342>:
  D.31299 = patch_info->data.method;
  D.31343 = D.31299->flags;
  D.31344 = (int) D.31343;
  D.31345 = D.31344 & 8192;
  if (D.31345 != 0) goto <D.31346>; else goto <D.31340>;
  <D.31346>:
  D.31347 = acfg->aot_opts.direct_pinvoke;
  if (D.31347 != 0) goto <D.31348>; else goto <D.31349>;
  <D.31348>:
  D.31339 = 1;
  return D.31339;
  <D.31349>:
  goto <D.31341>;
  <D.31340>:
  D.31297 = patch_info->type;
  if (D.31297 == 31) goto <D.31350>; else goto <D.31351>;
  <D.31350>:
  D.31352 = acfg->aot_opts.direct_icalls;
  if (D.31352 != 0) goto <D.31353>; else goto <D.31354>;
  <D.31353>:
  D.31339 = 1;
  return D.31339;
  <D.31354>:
  D.31339 = 0;
  return D.31339;
  <D.31351>:
  <D.31341>:
  <D.31296>:
  D.31339 = 0;
  return D.31339;
}


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


emit_image_table (struct MonoAotCompile * acfg)
{
  struct GPtrArray * D.31356;
  unsigned int D.31357;
  int D.31358;
  void * * D.31359;
  unsigned int i.316;
  unsigned int D.31361;
  void * * D.31362;
  struct MonoAssembly * D.31363;
  struct MonoImage * D.31364;
  _Bool D.31365;
  long int D.31366;
  long int D.31367;
  const char * D.31370;
  char * D.31371;
  const char * iftmp.317;
  const char * D.31373;
  mono_byte[17] * D.31377;
  unsigned int D.31378;
  int D.31379;
  short unsigned int D.31380;
  int D.31381;
  short unsigned int D.31382;
  int D.31383;
  short unsigned int D.31384;
  int D.31385;
  short unsigned int D.31386;
  int D.31387;
  unsigned int i.318;
  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.31356 = acfg->image_table;
      D.31357 = D.31356->len;
      D.31358 = (int) D.31357;
      emit_int32 (acfg, D.31358);
      i = 0;
      goto <D.25344>;
      <D.25343>:
      {
        struct MonoImage * image;
        struct MonoAssemblyName * aname;

        D.31356 = acfg->image_table;
        D.31359 = D.31356->pdata;
        i.316 = (unsigned int) i;
        D.31361 = i.316 * 4;
        D.31362 = D.31359 + D.31361;
        image = *D.31362;
        D.31363 = image->assembly;
        aname = &D.31363->aname;
        D.31363 = image->assembly;
        D.31364 = D.31363->image;
        D.31365 = D.31364 != image;
        D.31366 = (long int) D.31365;
        D.31367 = __builtin_expect (D.31366, 0);
        if (D.31367 != 0) goto <D.31368>; else goto <D.31369>;
        <D.31368>:
        monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "aot-compiler.c", 7785, "image->assembly->image == image");
        <D.31369>:
        D.31370 = image->assembly_name;
        emit_string (acfg, D.31370);
        D.31371 = image->guid;
        emit_string (acfg, D.31371);
        D.31373 = aname->culture;
        if (D.31373 != 0B) goto <D.31374>; else goto <D.31375>;
        <D.31374>:
        iftmp.317 = aname->culture;
        goto <D.31376>;
        <D.31375>:
        iftmp.317 = "";
        <D.31376>:
        emit_string (acfg, iftmp.317);
        D.31377 = &aname->public_key_token;
        emit_string (acfg, D.31377);
        emit_alignment (acfg, 8);
        D.31378 = aname->flags;
        D.31379 = (int) D.31378;
        emit_int32 (acfg, D.31379);
        D.31380 = aname->major;
        D.31381 = (int) D.31380;
        emit_int32 (acfg, D.31381);
        D.31382 = aname->minor;
        D.31383 = (int) D.31382;
        emit_int32 (acfg, D.31383);
        D.31384 = aname->build;
        D.31385 = (int) D.31384;
        emit_int32 (acfg, D.31385);
        D.31386 = aname->revision;
        D.31387 = (int) D.31386;
        emit_int32 (acfg, D.31387);
      }
      i = i + 1;
      <D.25344>:
      i.318 = (unsigned int) i;
      D.31356 = acfg->image_table;
      D.31357 = D.31356->len;
      if (i.318 < D.31357) goto <D.25343>; else goto <D.25345>;
      <D.25345>:
    }
  finally
    {
      symbol = {CLOBBER};
    }
}


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

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


emit_got (struct MonoAotCompile * acfg)
{
  int D.31390;
  char * D.31393;
  unsigned int D.31394;
  unsigned int D.31397;
  int D.31398;
  char symbol[256];

  try
    {
      D.31390 = acfg->llvm;
      if (D.31390 == 0) goto <D.31391>; else goto <D.31392>;
      <D.31391>:
      D.31393 = acfg->got_symbol;
      sprintf (&symbol, "%s", D.31393);
      emit_section_change (acfg, ".bss", 0);
      emit_alignment (acfg, 8);
      emit_local_symbol (acfg, &symbol, "got_end", 0);
      emit_label (acfg, &symbol);
      D.31394 = acfg->got_offset;
      if (D.31394 != 0) goto <D.31395>; else goto <D.31396>;
      <D.31395>:
      D.31394 = acfg->got_offset;
      D.31397 = D.31394 * 4;
      D.31398 = (int) D.31397;
      emit_zero_bytes (acfg, D.31398);
      <D.31396>:
      sprintf (&symbol, "got_end");
      emit_label (acfg, &symbol);
      <D.31392>:
    }
  finally
    {
      symbol = {CLOBBER};
    }
}


emit_file_info (struct MonoAotCompile * acfg)
{
  struct MonoImage * D.31399;
  char * D.31400;
  int D.31401;
  struct MonoAssembly * D.31405;
  const char * D.31406;
  unsigned int D.31407;
  unsigned int D.31408;
  unsigned int D.31409;
  const char * D.31410;
  int D.31411;
  char * D.31414;
  char * D.31415;
  int D.31416;
  int D.31420;
  unsigned int D.31424;
  int D.31428;
  unsigned int D.31435;
  int D.31436;
  unsigned int D.31437;
  unsigned int D.31438;
  int D.31439;
  unsigned int D.31440;
  int D.31441;
  unsigned int D.31442;
  int D.31443;
  <unnamed type> D.31444;
  int D.31445;
  unsigned int D.31446;
  int D.31447;
  unsigned int D.31448;
  int D.31449;
  unsigned int D.31450;
  int D.31451;
  unsigned int D.31452;
  int D.31453;
  unsigned int D.31454;
  int D.31455;
  int D.31456;
  unsigned int D.31457;
  int D.31458;
  unsigned int D.31459;
  int D.31460;
  const short unsigned int * * D.31463;
  const short unsigned int * D.31464;
  char D.31465;
  unsigned int D.31466;
  unsigned int D.31467;
  const short unsigned int * D.31468;
  short unsigned int D.31469;
  int D.31470;
  int D.31471;
  gchar * D.31476;
  char symbol[256];
  int i;
  int gc_name_offset;
  const char * gc_name;
  char * build_info;

  try
    {
      D.31399 = acfg->image;
      D.31400 = D.31399->guid;
      emit_string_symbol (acfg, "assembly_guid", D.31400);
      D.31401 = acfg->aot_opts.bind_to_runtime_version;
      if (D.31401 != 0) goto <D.31402>; else goto <D.31403>;
      <D.31402>:
      build_info = mono_get_runtime_build_info ();
      emit_string_symbol (acfg, "runtime_version", build_info);
      monoeg_g_free (build_info);
      goto <D.31404>;
      <D.31403>:
      emit_string_symbol (acfg, "runtime_version", "");
      <D.31404>:
      D.31399 = acfg->image;
      D.31405 = D.31399->assembly;
      D.31406 = D.31405->aname.name;
      emit_string_symbol (acfg, "assembly_name", D.31406);
      gc_name = mono_gc_get_gc_name ();
      D.31407 = strlen (gc_name);
      D.31408 = D.31407 + 1;
      D.31409 = add_to_blob (acfg, gc_name, D.31408);
      gc_name_offset = (int) D.31409;
      D.31410 = acfg->user_symbol_prefix;
      sprintf (&symbol, "%smono_aot_file_info", D.31410);
      emit_section_change (acfg, ".data", 0);
      emit_alignment (acfg, 8);
      emit_label (acfg, &symbol);
      D.31411 = acfg->aot_opts.static_link;
      if (D.31411 == 0) goto <D.31412>; else goto <D.31413>;
      <D.31412>:
      emit_global (acfg, &symbol, 0);
      <D.31413>:
      emit_int32 (acfg, 97);
      emit_int32 (acfg, 0);
      D.31414 = acfg->got_symbol;
      emit_pointer (acfg, D.31414);
      D.31415 = acfg->methods_symbol;
      emit_pointer (acfg, D.31415);
      D.31416 = acfg->llvm;
      if (D.31416 != 0) goto <D.31417>; else goto <D.31418>;
      <D.31417>:
      emit_pointer (acfg, "mono_eh_frame");
      goto <D.31419>;
      <D.31418>:
      emit_pointer (acfg, 0B);
      <D.31419>:
      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.31420 = acfg->direct_method_addresses;
      if (D.31420 != 0) goto <D.31421>; else goto <D.31422>;
      <D.31421>:
      emit_pointer (acfg, "method_addresses");
      goto <D.31423>;
      <D.31422>:
      emit_pointer (acfg, 0B);
      <D.31423>:
      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.31424 = acfg->num_trampoline_got_entries;
      if (D.31424 != 0) goto <D.31425>; else goto <D.31426>;
      <D.31425>:
      emit_pointer (acfg, "specific_trampolines");
      emit_pointer (acfg, "static_rgctx_trampolines");
      emit_pointer (acfg, "imt_thunks");
      emit_pointer (acfg, "gsharedvt_arg_trampolines");
      goto <D.31427>;
      <D.31426>:
      emit_pointer (acfg, 0B);
      emit_pointer (acfg, 0B);
      emit_pointer (acfg, 0B);
      emit_pointer (acfg, 0B);
      <D.31427>:
      D.31428 = acfg->thumb_mixed;
      if (D.31428 != 0) goto <D.31429>; else goto <D.31430>;
      <D.31429>:
      emit_pointer (acfg, "thumb_end");
      goto <D.31431>;
      <D.31430>:
      emit_pointer (acfg, 0B);
      <D.31431>:
      D.31411 = acfg->aot_opts.static_link;
      if (D.31411 != 0) goto <D.31432>; else goto <D.31433>;
      <D.31432>:
      emit_pointer (acfg, "globals");
      goto <D.31434>;
      <D.31433>:
      emit_pointer (acfg, 0B);
      <D.31434>:
      emit_pointer (acfg, "assembly_name");
      emit_pointer (acfg, "unbox_trampolines");
      emit_pointer (acfg, "unbox_trampolines_end");
      D.31435 = acfg->plt_got_offset_base;
      D.31436 = (int) D.31435;
      emit_int32 (acfg, D.31436);
      D.31437 = acfg->got_offset;
      D.31438 = D.31437 * 4;
      D.31439 = (int) D.31438;
      emit_int32 (acfg, D.31439);
      D.31440 = acfg->plt_offset;
      D.31441 = (int) D.31440;
      emit_int32 (acfg, D.31441);
      D.31442 = acfg->nmethods;
      D.31443 = (int) D.31442;
      emit_int32 (acfg, D.31443);
      D.31444 = acfg->flags;
      D.31445 = (int) D.31444;
      emit_int32 (acfg, D.31445);
      D.31446 = acfg->opts;
      D.31447 = (int) D.31446;
      emit_int32 (acfg, D.31447);
      D.31448 = acfg->simd_opts;
      D.31449 = (int) D.31448;
      emit_int32 (acfg, D.31449);
      emit_int32 (acfg, gc_name_offset);
      i = 0;
      goto <D.25423>;
      <D.25422>:
      D.31450 = acfg->num_trampolines[i];
      D.31451 = (int) D.31450;
      emit_int32 (acfg, D.31451);
      i = i + 1;
      <D.25423>:
      if (i <= 3) goto <D.25422>; else goto <D.25424>;
      <D.25424>:
      i = 0;
      goto <D.25426>;
      <D.25425>:
      D.31452 = acfg->trampoline_got_offset_base[i];
      D.31453 = (int) D.31452;
      emit_int32 (acfg, D.31453);
      i = i + 1;
      <D.25426>:
      if (i <= 3) goto <D.25425>; else goto <D.25427>;
      <D.25427>:
      i = 0;
      goto <D.25429>;
      <D.25428>:
      D.31454 = acfg->trampoline_size[i];
      D.31455 = (int) D.31454;
      emit_int32 (acfg, D.31455);
      i = i + 1;
      <D.25429>:
      if (i <= 3) goto <D.25428>; else goto <D.25430>;
      <D.25430>:
      D.31456 = acfg->aot_opts.nrgctx_fetch_trampolines;
      emit_int32 (acfg, D.31456);
      emit_int32 (acfg, 8);
      emit_int32 (acfg, 8);
      emit_int32 (acfg, 14);
      D.31457 = acfg->tramp_page_size;
      D.31458 = (int) D.31457;
      emit_int32 (acfg, D.31458);
      i = 0;
      goto <D.25432>;
      <D.25431>:
      D.31459 = acfg->tramp_page_code_offsets[i];
      D.31460 = (int) D.31459;
      emit_int32 (acfg, D.31460);
      i = i + 1;
      <D.25432>:
      if (i <= 3) goto <D.25431>; else goto <D.25433>;
      <D.25433>:
      D.31411 = acfg->aot_opts.static_link;
      if (D.31411 != 0) goto <D.31461>; else goto <D.31462>;
      <D.31461>:
      {
        char * p;

        D.31410 = acfg->user_symbol_prefix;
        D.31399 = acfg->image;
        D.31405 = D.31399->assembly;
        D.31406 = D.31405->aname.name;
        sprintf (&symbol, "%smono_aot_module_%s_info", D.31410, D.31406);
        p = &symbol;
        p = &symbol;
        goto <D.25436>;
        <D.25435>:
        D.31463 = __ctype_b_loc ();
        D.31464 = *D.31463;
        D.31465 = *p;
        D.31466 = (unsigned int) D.31465;
        D.31467 = D.31466 * 2;
        D.31468 = D.31464 + D.31467;
        D.31469 = *D.31468;
        D.31470 = (int) D.31469;
        D.31471 = D.31470 & 8;
        if (D.31471 == 0) goto <D.31472>; else goto <D.31473>;
        <D.31472>:
        D.31465 = *p;
        if (D.31465 != 95) goto <D.31474>; else goto <D.31475>;
        <D.31474>:
        *p = 95;
        <D.31475>:
        <D.31473>:
        p = p + 1;
        <D.25436>:
        D.31465 = *p;
        if (D.31465 != 0) goto <D.25435>; else goto <D.25437>;
        <D.25437>:
        D.31476 = monoeg_strdup (&symbol);
        acfg->static_linking_symbol = D.31476;
        emit_global_inner (acfg, &symbol, 0);
        emit_alignment (acfg, 4);
        emit_label (acfg, &symbol);
        D.31410 = acfg->user_symbol_prefix;
        emit_pointer_2 (acfg, D.31410, "mono_aot_file_info");
      }
      <D.31462>:
    }
  finally
    {
      symbol = {CLOBBER};
    }
}


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

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


emit_global (struct MonoAotCompile * acfg, const char * name, gboolean func)
{
  int D.31478;
  struct GPtrArray * D.31481;
  gchar * D.31482;
  struct MonoImageWriter * D.31483;

  D.31478 = acfg->aot_opts.no_dlsym;
  if (D.31478 != 0) goto <D.31479>; else goto <D.31480>;
  <D.31479>:
  D.31481 = acfg->globals;
  D.31482 = monoeg_strdup (name);
  monoeg_g_ptr_array_add (D.31481, D.31482);
  D.31483 = acfg->w;
  img_writer_emit_local_symbol (D.31483, name, 0B, func);
  goto <D.31484>;
  <D.31480>:
  D.31483 = acfg->w;
  img_writer_emit_global (D.31483, name, func);
  <D.31484>:
}


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

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


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

  D.31486 = *prefix;
  if (D.31486 != 0) goto <D.31487>; else goto <D.31488>;
  <D.31487>:
  {
    char * s;

    s = monoeg_g_strdup_printf ("%s%s", prefix, target);
    D.31489 = acfg->w;
    img_writer_emit_pointer (D.31489, s);
    monoeg_g_free (s);
  }
  goto <D.31490>;
  <D.31488>:
  D.31489 = acfg->w;
  img_writer_emit_pointer (D.31489, target);
  <D.31490>:
}


emit_blob (struct MonoAotCompile * acfg)
{
  char * D.31491;
  unsigned int D.31492;
  int D.31493;
  char symbol[128];

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


emit_objc_selectors (struct MonoAotCompile * acfg)
{
  struct GPtrArray * D.31496;
  unsigned int D.31498;
  struct MonoImageWriter * D.31499;
  struct FILE * D.31500;
  _Bool D.31501;
  long int D.31502;
  long int D.31503;
  unsigned int i.319;
  void * * D.31507;
  unsigned int i.320;
  unsigned int D.31509;
  void * * D.31510;
  void * D.31511;
  int i;

  D.31496 = acfg->objc_selectors;
  if (D.31496 == 0B) goto <D.31494>; else goto <D.31497>;
  <D.31497>:
  D.31496 = acfg->objc_selectors;
  D.31498 = D.31496->len;
  if (D.31498 == 0) goto <D.31494>; else goto <D.31495>;
  <D.31494>:
  return;
  <D.31495>:
  D.31499 = acfg->w;
  img_writer_emit_unset_mode (D.31499);
  D.31500 = acfg->fp;
  D.31501 = D.31500 == 0B;
  D.31502 = (long int) D.31501;
  D.31503 = __builtin_expect (D.31502, 0);
  if (D.31503 != 0) goto <D.31504>; else goto <D.31505>;
  <D.31504>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "aot-compiler.c", 8235, "acfg->fp");
  <D.31505>:
  D.31500 = acfg->fp;
  fprintf (D.31500, ".section\t__DATA,__objc_selrefs,literal_pointers,no_dead_strip\n");
  D.31500 = acfg->fp;
  fprintf (D.31500, ".align\t2\n");
  i = 0;
  goto <D.25447>;
  <D.25446>:
  D.31500 = acfg->fp;
  fprintf (D.31500, "L_OBJC_SELECTOR_REFERENCES_%d:\n", i);
  D.31500 = acfg->fp;
  fprintf (D.31500, ".long\tL_OBJC_METH_VAR_NAME_%d\n", i);
  i = i + 1;
  <D.25447>:
  i.319 = (unsigned int) i;
  D.31496 = acfg->objc_selectors;
  D.31498 = D.31496->len;
  if (i.319 < D.31498) goto <D.25446>; else goto <D.25448>;
  <D.25448>:
  D.31500 = acfg->fp;
  fprintf (D.31500, ".section\t__TEXT,__cstring,cstring_literals\n");
  i = 0;
  goto <D.25450>;
  <D.25449>:
  D.31500 = acfg->fp;
  fprintf (D.31500, "L_OBJC_METH_VAR_NAME_%d:\n", i);
  D.31500 = acfg->fp;
  D.31496 = acfg->objc_selectors;
  D.31507 = D.31496->pdata;
  i.320 = (unsigned int) i;
  D.31509 = i.320 * 4;
  D.31510 = D.31507 + D.31509;
  D.31511 = *D.31510;
  fprintf (D.31500, ".asciz \"%s\"\n", D.31511);
  i = i + 1;
  <D.25450>:
  i.319 = (unsigned int) i;
  D.31496 = acfg->objc_selectors;
  D.31498 = D.31496->len;
  if (i.319 < D.31498) goto <D.25449>; else goto <D.25451>;
  <D.25451>:
  D.31500 = acfg->fp;
  fprintf (D.31500, ".section\t__DATA,__objc_imageinfo,regular,no_dead_strip\n");
  D.31500 = acfg->fp;
  fprintf (D.31500, ".align\t2\n");
  D.31500 = acfg->fp;
  fprintf (D.31500, "L_OBJC_IMAGE_INFO:\n");
  D.31500 = acfg->fp;
  fprintf (D.31500, ".long\t0\n");
  D.31500 = acfg->fp;
  fprintf (D.31500, ".long\t16\n");
}


emit_globals (struct MonoAotCompile * acfg)
{
  int D.31513;
  struct GPtrArray * D.31516;
  unsigned int D.31517;
  double D.31518;
  double D.31519;
  int D.31520;
  unsigned int D.31521;
  unsigned int D.31522;
  unsigned int table_size.321;
  void * * D.31524;
  unsigned int i.322;
  unsigned int D.31526;
  void * * D.31527;
  unsigned int D.31528;
  unsigned int i.323;
  void * * D.31530;
  unsigned int D.31531;
  void * * D.31532;
  struct GlobalsTableEntry * D.31536;
  unsigned int D.31537;
  unsigned int i.324;
  _Bool D.31539;
  long int D.31540;
  long int D.31541;
  void * * D.31544;
  unsigned int D.31548;
  unsigned int D.31549;
  int D.31550;
  struct GlobalsTableEntry * D.31551;
  unsigned int D.31554;
  int D.31555;
  const char * D.31557;
  int i;
  int table_size;
  guint32 hash;
  struct GPtrArray * table;
  char symbol[256];
  struct GlobalsTableEntry * entry;
  struct GlobalsTableEntry * new_entry;

  try
    {
      D.31513 = acfg->aot_opts.static_link;
      if (D.31513 == 0) goto <D.31514>; else goto <D.31515>;
      <D.31514>:
      return;
      <D.31515>:
      D.31516 = acfg->globals;
      D.31517 = D.31516->len;
      D.31518 = (double) D.31517;
      D.31519 = D.31518 * 1.5e+0;
      D.31520 = (int) D.31519;
      D.31521 = (unsigned int) D.31520;
      D.31522 = monoeg_g_spaced_primes_closest (D.31521);
      table_size = (int) D.31522;
      table_size.321 = (unsigned int) table_size;
      table = monoeg_g_ptr_array_sized_new (table_size.321);
      i = 0;
      goto <D.25385>;
      <D.25384>:
      monoeg_g_ptr_array_add (table, 0B);
      i = i + 1;
      <D.25385>:
      if (i < table_size) goto <D.25384>; else goto <D.25386>;
      <D.25386>:
      i = 0;
      goto <D.25392>;
      <D.25391>:
      {
        char * name;

        D.31516 = acfg->globals;
        D.31524 = D.31516->pdata;
        i.322 = (unsigned int) i;
        D.31526 = i.322 * 4;
        D.31527 = D.31524 + D.31526;
        name = *D.31527;
        D.31528 = mono_metadata_str_hash (name);
        table_size.321 = (unsigned int) table_size;
        hash = D.31528 % table_size.321;
        new_entry = monoeg_malloc0 (12);
        i.323 = (unsigned int) i;
        new_entry->value = i.323;
        D.31530 = table->pdata;
        D.31531 = hash * 4;
        D.31532 = D.31530 + D.31531;
        entry = *D.31532;
        if (entry == 0B) goto <D.31533>; else goto <D.31534>;
        <D.31533>:
        new_entry->index = hash;
        D.31530 = table->pdata;
        D.31531 = hash * 4;
        D.31532 = D.31530 + D.31531;
        *D.31532 = new_entry;
        goto <D.31535>;
        <D.31534>:
        goto <D.25389>;
        <D.25388>:
        entry = entry->next;
        <D.25389>:
        D.31536 = entry->next;
        if (D.31536 != 0B) goto <D.25388>; else goto <D.25390>;
        <D.25390>:
        entry->next = new_entry;
        D.31537 = table->len;
        new_entry->index = D.31537;
        monoeg_g_ptr_array_add (table, new_entry);
        <D.31535>:
      }
      i = i + 1;
      <D.25392>:
      i.324 = (unsigned int) i;
      D.31516 = acfg->globals;
      D.31517 = D.31516->len;
      if (i.324 < D.31517) goto <D.25391>; else goto <D.25393>;
      <D.25393>:
      sprintf (&symbol, ".Lglobals_hash");
      emit_section_change (acfg, ".rodata", 0);
      emit_alignment (acfg, 8);
      emit_label (acfg, &symbol);
      D.31539 = table_size > 64999;
      D.31540 = (long int) D.31539;
      D.31541 = __builtin_expect (D.31540, 0);
      if (D.31541 != 0) goto <D.31542>; else goto <D.31543>;
      <D.31542>:
      monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "aot-compiler.c", 7948, "table_size < 65000");
      <D.31543>:
      emit_int16 (acfg, table_size);
      i = 0;
      goto <D.25396>;
      <D.25395>:
      {
        struct GlobalsTableEntry * entry;

        D.31530 = table->pdata;
        i.322 = (unsigned int) i;
        D.31526 = i.322 * 4;
        D.31544 = D.31530 + D.31526;
        entry = *D.31544;
        if (entry == 0B) goto <D.31545>; else goto <D.31546>;
        <D.31545>:
        emit_int16 (acfg, 0);
        emit_int16 (acfg, 0);
        goto <D.31547>;
        <D.31546>:
        D.31548 = entry->value;
        D.31549 = D.31548 + 1;
        D.31550 = (int) D.31549;
        emit_int16 (acfg, D.31550);
        D.31551 = entry->next;
        if (D.31551 != 0B) goto <D.31552>; else goto <D.31553>;
        <D.31552>:
        D.31551 = entry->next;
        D.31554 = D.31551->index;
        D.31555 = (int) D.31554;
        emit_int16 (acfg, D.31555);
        goto <D.31556>;
        <D.31553>:
        emit_int16 (acfg, 0);
        <D.31556>:
        <D.31547>:
      }
      i = i + 1;
      <D.25396>:
      i.324 = (unsigned int) i;
      D.31537 = table->len;
      if (i.324 < D.31537) goto <D.25395>; else goto <D.25397>;
      <D.25397>:
      i = 0;
      goto <D.25400>;
      <D.25399>:
      {
        char * name;

        D.31516 = acfg->globals;
        D.31524 = D.31516->pdata;
        i.322 = (unsigned int) i;
        D.31526 = i.322 * 4;
        D.31527 = D.31524 + D.31526;
        name = *D.31527;
        sprintf (&symbol, "name_%d", i);
        emit_section_change (acfg, ".rodata", 1);
        emit_label (acfg, &symbol);
        emit_string (acfg, name);
      }
      i = i + 1;
      <D.25400>:
      i.324 = (unsigned int) i;
      D.31516 = acfg->globals;
      D.31517 = D.31516->len;
      if (i.324 < D.31517) goto <D.25399>; else goto <D.25401>;
      <D.25401>:
      sprintf (&symbol, "globals");
      emit_section_change (acfg, ".data", 0);
      emit_alignment (acfg, 8);
      emit_label (acfg, &symbol);
      D.31557 = acfg->temp_prefix;
      sprintf (&symbol, "%sglobals_hash", D.31557);
      emit_pointer (acfg, &symbol);
      i = 0;
      goto <D.25404>;
      <D.25403>:
      {
        char * name;

        D.31516 = acfg->globals;
        D.31524 = D.31516->pdata;
        i.322 = (unsigned int) i;
        D.31526 = i.322 * 4;
        D.31527 = D.31524 + D.31526;
        name = *D.31527;
        sprintf (&symbol, "name_%d", i);
        emit_pointer (acfg, &symbol);
        sprintf (&symbol, "%s", name);
        emit_pointer (acfg, &symbol);
      }
      i = i + 1;
      <D.25404>:
      i.324 = (unsigned int) i;
      D.31516 = acfg->globals;
      D.31517 = D.31516->len;
      if (i.324 < D.31517) goto <D.25403>; else goto <D.25405>;
      <D.25405>:
      emit_int32 (acfg, 0);
      emit_int32 (acfg, 0);
    }
  finally
    {
      symbol = {CLOBBER};
    }
}


emit_autoreg (struct MonoAotCompile * acfg)
{
  int D.31563;
  int D.31565;
  int D.31567;
  char * D.31568;
  char * symbol;

  D.31563 = acfg->use_bin_writer;
  if (D.31563 != 0) goto <D.31561>; else goto <D.31564>;
  <D.31564>:
  D.31565 = acfg->aot_opts.static_link;
  if (D.31565 == 0) goto <D.31561>; else goto <D.31566>;
  <D.31566>:
  D.31567 = acfg->aot_opts.autoreg;
  if (D.31567 == 0) goto <D.31561>; else goto <D.31562>;
  <D.31561>:
  return;
  <D.31562>:
  D.31568 = acfg->static_linking_symbol;
  symbol = monoeg_g_strdup_printf ("_%s_autoreg", D.31568);
  arch_emit_autoreg (acfg, symbol);
  monoeg_g_free (symbol);
}


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

}


emit_dwarf_info (struct MonoAotCompile * acfg)
{

}


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

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


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

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


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

  D.31573 = __builtin_object_size (__dest, 1);
  D.31572 = __builtin___strcpy_chk (__dest, __src, D.31573);
  return D.31572;
}


compile_asm (struct MonoAotCompile * acfg)
{
  const char * iftmp.325;
  char * D.31576;
  int D.31580;
  char * D.31583;
  int D.31584;
  char * D.31587;
  int D.31588;
  char * D.31591;
  struct MonoImage * D.31595;
  char * D.31596;
  const char * iftmp.326;
  struct GString * D.31599;
  int D.31603;
  int D.31611;
  int D.31614;
  char * command;
  char * objfile;
  char * outfile_name;
  char * tmp_outfile_name;
  const char * tool_prefix;

  D.31576 = acfg->aot_opts.tool_prefix;
  if (D.31576 != 0B) goto <D.31577>; else goto <D.31578>;
  <D.31577>:
  iftmp.325 = acfg->aot_opts.tool_prefix;
  goto <D.31579>;
  <D.31578>:
  iftmp.325 = "";
  <D.31579>:
  tool_prefix = iftmp.325;
  D.31580 = acfg->aot_opts.asm_only;
  if (D.31580 != 0) goto <D.31581>; else goto <D.31582>;
  <D.31581>:
  D.31583 = acfg->tmpfname;
  printf ("Output file: \'%s\'.\n", D.31583);
  D.31584 = acfg->aot_opts.static_link;
  if (D.31584 != 0) goto <D.31585>; else goto <D.31586>;
  <D.31585>:
  D.31587 = acfg->static_linking_symbol;
  printf ("Linking symbol: \'%s\'.\n", D.31587);
  <D.31586>:
  D.31588 = 0;
  return D.31588;
  <D.31582>:
  D.31584 = acfg->aot_opts.static_link;
  if (D.31584 != 0) goto <D.31589>; else goto <D.31590>;
  <D.31589>:
  D.31591 = acfg->aot_opts.outfile;
  if (D.31591 != 0B) goto <D.31592>; else goto <D.31593>;
  <D.31592>:
  D.31591 = acfg->aot_opts.outfile;
  objfile = monoeg_g_strdup_printf ("%s", D.31591);
  goto <D.31594>;
  <D.31593>:
  D.31595 = acfg->image;
  D.31596 = D.31595->name;
  objfile = monoeg_g_strdup_printf ("%s.o", D.31596);
  <D.31594>:
  goto <D.31597>;
  <D.31590>:
  D.31583 = acfg->tmpfname;
  objfile = monoeg_g_strdup_printf ("%s.o", D.31583);
  <D.31597>:
  D.31599 = acfg->as_args;
  if (D.31599 != 0B) goto <D.31600>; else goto <D.31601>;
  <D.31600>:
  D.31599 = acfg->as_args;
  iftmp.326 = D.31599->str;
  goto <D.31602>;
  <D.31601>:
  iftmp.326 = "";
  <D.31602>:
  D.31583 = acfg->tmpfname;
  command = monoeg_g_strdup_printf ("%s%s %s %s -o %s %s", tool_prefix, "as", "", iftmp.326, objfile, D.31583);
  printf ("Executing the native assembler: %s\n", command);
  D.31603 = system (command);
  if (D.31603 != 0) goto <D.31604>; else goto <D.31605>;
  <D.31604>:
  monoeg_g_free (command);
  monoeg_g_free (objfile);
  D.31588 = 1;
  return D.31588;
  <D.31605>:
  monoeg_g_free (command);
  D.31584 = acfg->aot_opts.static_link;
  if (D.31584 != 0) goto <D.31606>; else goto <D.31607>;
  <D.31606>:
  printf ("Output file: \'%s\'.\n", objfile);
  D.31587 = acfg->static_linking_symbol;
  printf ("Linking symbol: \'%s\'.\n", D.31587);
  monoeg_g_free (objfile);
  D.31588 = 0;
  return D.31588;
  <D.31607>:
  D.31591 = acfg->aot_opts.outfile;
  if (D.31591 != 0B) goto <D.31608>; else goto <D.31609>;
  <D.31608>:
  D.31591 = acfg->aot_opts.outfile;
  outfile_name = monoeg_g_strdup_printf ("%s", D.31591);
  goto <D.31610>;
  <D.31609>:
  D.31595 = acfg->image;
  D.31596 = D.31595->name;
  outfile_name = monoeg_g_strdup_printf ("%s%s", D.31596, ".so");
  <D.31610>:
  tmp_outfile_name = monoeg_g_strdup_printf ("%s.tmp", outfile_name);
  D.31583 = acfg->tmpfname;
  command = monoeg_g_strdup_printf ("%sld %s -shared -o %s %s.o", tool_prefix, "", tmp_outfile_name, D.31583);
  printf ("Executing the native linker: %s\n", command);
  D.31611 = system (command);
  if (D.31611 != 0) goto <D.31612>; else goto <D.31613>;
  <D.31612>:
  monoeg_g_free (tmp_outfile_name);
  monoeg_g_free (outfile_name);
  monoeg_g_free (command);
  monoeg_g_free (objfile);
  D.31588 = 1;
  return D.31588;
  <D.31613>:
  monoeg_g_free (command);
  rename (tmp_outfile_name, outfile_name);
  D.31614 = acfg->aot_opts.save_temps;
  if (D.31614 == 0) goto <D.31615>; else goto <D.31616>;
  <D.31615>:
  unlink (objfile);
  <D.31616>:
  monoeg_g_free (tmp_outfile_name);
  monoeg_g_free (outfile_name);
  monoeg_g_free (objfile);
  D.31614 = acfg->aot_opts.save_temps;
  if (D.31614 != 0) goto <D.31617>; else goto <D.31618>;
  <D.31617>:
  printf ("Retained input file.\n");
  goto <D.31619>;
  <D.31618>:
  D.31583 = acfg->tmpfname;
  unlink (D.31583);
  <D.31619>:
  D.31588 = 0;
  return D.31588;
}


get_patch_name (int info)
{
  const char * D.31621;
  short int D.31622;
  sizetype D.31623;

  D.31622 = opidx[info];
  D.31623 = (sizetype) D.31622;
  D.31621 = &opstr + D.31623;
  return D.31621;
}


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

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


acfg_free (struct MonoAotCompile * acfg)
{
  struct MonoImageWriter * D.31627;
  struct MonoCompile * * D.31628;
  unsigned int i.327;
  unsigned int D.31630;
  struct MonoCompile * * D.31631;
  struct MonoCompile * D.31632;
  unsigned int i.328;
  unsigned int D.31636;
  char * D.31637;
  char * D.31638;
  char * D.31639;
  struct GPtrArray * D.31640;
  struct GPtrArray * D.31641;
  struct GPtrArray * D.31642;
  struct GPtrArray * D.31643;
  struct GPtrArray * D.31644;
  struct GHashTable * D.31645;
  struct GHashTable * D.31646;
  struct GHashTable * D.31647;
  struct GHashTable * * D.31648;
  struct GHashTable * * D.31649;
  struct GHashTable * D.31650;
  struct GHashTable * D.31653;
  struct GHashTable * D.31654;
  struct GHashTable * D.31655;
  struct GHashTable * D.31656;
  struct GHashTable * D.31657;
  struct GHashTable * D.31658;
  struct GHashTable * D.31659;
  struct GHashTable * D.31660;
  struct GHashTable * D.31661;
  struct GHashTable * D.31662;
  struct GHashTable * D.31663;
  struct GHashTable * * D.31664;
  struct GHashTable * * D.31665;
  struct GHashTable * D.31666;
  struct MonoMemPool * D.31667;
  int i;

  D.31627 = acfg->w;
  img_writer_destroy (D.31627);
  i = 0;
  goto <D.25524>;
  <D.25523>:
  D.31628 = acfg->cfgs;
  i.327 = (unsigned int) i;
  D.31630 = i.327 * 4;
  D.31631 = D.31628 + D.31630;
  D.31632 = *D.31631;
  if (D.31632 != 0B) goto <D.31633>; else goto <D.31634>;
  <D.31633>:
  D.31628 = acfg->cfgs;
  i.327 = (unsigned int) i;
  D.31630 = i.327 * 4;
  D.31631 = D.31628 + D.31630;
  D.31632 = *D.31631;
  monoeg_g_free (D.31632);
  <D.31634>:
  i = i + 1;
  <D.25524>:
  i.328 = (unsigned int) i;
  D.31636 = acfg->nmethods;
  if (i.328 < D.31636) goto <D.25523>; else goto <D.25525>;
  <D.25525>:
  D.31628 = acfg->cfgs;
  monoeg_g_free (D.31628);
  D.31637 = acfg->static_linking_symbol;
  monoeg_g_free (D.31637);
  D.31638 = acfg->got_symbol;
  monoeg_g_free (D.31638);
  D.31639 = acfg->plt_symbol;
  monoeg_g_free (D.31639);
  D.31640 = acfg->methods;
  monoeg_g_ptr_array_free (D.31640, 1);
  D.31641 = acfg->got_patches;
  monoeg_g_ptr_array_free (D.31641, 1);
  D.31642 = acfg->image_table;
  monoeg_g_ptr_array_free (D.31642, 1);
  D.31643 = acfg->globals;
  monoeg_g_ptr_array_free (D.31643, 1);
  D.31644 = acfg->unwind_ops;
  monoeg_g_ptr_array_free (D.31644, 1);
  D.31645 = acfg->method_indexes;
  monoeg_g_hash_table_destroy (D.31645);
  D.31646 = acfg->method_depth;
  monoeg_g_hash_table_destroy (D.31646);
  D.31647 = acfg->plt_offset_to_entry;
  monoeg_g_hash_table_destroy (D.31647);
  i = 0;
  goto <D.25527>;
  <D.25526>:
  D.31648 = acfg->patch_to_plt_entry;
  i.327 = (unsigned int) i;
  D.31630 = i.327 * 4;
  D.31649 = D.31648 + D.31630;
  D.31650 = *D.31649;
  if (D.31650 != 0B) goto <D.31651>; else goto <D.31652>;
  <D.31651>:
  D.31648 = acfg->patch_to_plt_entry;
  i.327 = (unsigned int) i;
  D.31630 = i.327 * 4;
  D.31649 = D.31648 + D.31630;
  D.31650 = *D.31649;
  monoeg_g_hash_table_destroy (D.31650);
  <D.31652>:
  i = i + 1;
  <D.25527>:
  if (i <= 51) goto <D.25526>; else goto <D.25528>;
  <D.25528>:
  D.31648 = acfg->patch_to_plt_entry;
  monoeg_g_free (D.31648);
  D.31653 = acfg->patch_to_got_offset;
  monoeg_g_hash_table_destroy (D.31653);
  D.31654 = acfg->method_to_cfg;
  monoeg_g_hash_table_destroy (D.31654);
  D.31655 = acfg->token_info_hash;
  monoeg_g_hash_table_destroy (D.31655);
  D.31656 = acfg->method_to_pinvoke_import;
  monoeg_g_hash_table_destroy (D.31656);
  D.31657 = acfg->image_hash;
  monoeg_g_hash_table_destroy (D.31657);
  D.31658 = acfg->unwind_info_offsets;
  monoeg_g_hash_table_destroy (D.31658);
  D.31659 = acfg->method_label_hash;
  monoeg_g_hash_table_destroy (D.31659);
  D.31660 = acfg->export_names;
  monoeg_g_hash_table_destroy (D.31660);
  D.31661 = acfg->plt_entry_debug_sym_cache;
  monoeg_g_hash_table_destroy (D.31661);
  D.31662 = acfg->klass_blob_hash;
  monoeg_g_hash_table_destroy (D.31662);
  D.31663 = acfg->method_blob_hash;
  monoeg_g_hash_table_destroy (D.31663);
  i = 0;
  goto <D.25530>;
  <D.25529>:
  D.31664 = acfg->patch_to_got_offset_by_type;
  i.327 = (unsigned int) i;
  D.31630 = i.327 * 4;
  D.31665 = D.31664 + D.31630;
  D.31666 = *D.31665;
  monoeg_g_hash_table_destroy (D.31666);
  i = i + 1;
  <D.25530>:
  if (i <= 51) goto <D.25529>; else goto <D.25531>;
  <D.25531>:
  D.31664 = acfg->patch_to_got_offset_by_type;
  monoeg_g_free (D.31664);
  D.31667 = acfg->mempool;
  mono_mempool_destroy (D.31667);
  monoeg_g_free (acfg);
}