mono_aot_readonly_field_override (struct MonoClassField * field)
{
  struct MonoClass * D.26504;
  const char * D.26505;
  long unsigned int D.26506;
  long unsigned int D.26507;
  int D.26508;
  sizetype D.26511;
  char * p.0;
  char D.26513;
  const char * D.26516;
  long unsigned int D.26517;
  int D.26518;
  char * p.1;
  char D.26522;
  int D.25772;
  const char * D.26525;
  int D.26528;
  void * D.26529;
  struct ReadOnlyValue * rdv;

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

    p = rdv->name;
    D.26504 = field->parent;
    D.26505 = D.26504->name_space;
    D.26506 = strlen (D.26505);
    len = (int) D.26506;
    D.26504 = field->parent;
    D.26505 = D.26504->name_space;
    D.26507 = (long unsigned int) len;
    D.26508 = strncmp (p, D.26505, D.26507);
    if (D.26508 != 0) goto <D.26509>; else goto <D.26510>;
    <D.26509>:
    // predicted unlikely by continue predictor.
    goto <D.25754>;
    <D.26510>:
    D.26511 = (sizetype) len;
    p = p + D.26511;
    p.0 = p;
    p = p.0 + 1;
    D.26513 = *p.0;
    if (D.26513 != 46) goto <D.26514>; else goto <D.26515>;
    <D.26514>:
    // predicted unlikely by continue predictor.
    goto <D.25754>;
    <D.26515>:
    D.26504 = field->parent;
    D.26516 = D.26504->name;
    D.26517 = strlen (D.26516);
    len = (int) D.26517;
    D.26504 = field->parent;
    D.26516 = D.26504->name;
    D.26507 = (long unsigned int) len;
    D.26518 = strncmp (p, D.26516, D.26507);
    if (D.26518 != 0) goto <D.26519>; else goto <D.26520>;
    <D.26519>:
    // predicted unlikely by continue predictor.
    goto <D.25754>;
    <D.26520>:
    D.26511 = (sizetype) len;
    p = p + D.26511;
    p.1 = p;
    p = p.1 + 1;
    D.26522 = *p.1;
    if (D.26522 != 46) goto <D.26523>; else goto <D.26524>;
    <D.26523>:
    // predicted unlikely by continue predictor.
    goto <D.25754>;
    <D.26524>:
    {
      size_t __s1_len;
      size_t __s2_len;

      D.26525 = field->name;
      D.25772 = __builtin_strcmp (p, D.26525);
    }
    if (D.25772 != 0) goto <D.26526>; else goto <D.26527>;
    <D.26526>:
    // predicted unlikely by continue predictor.
    goto <D.25754>;
    <D.26527>:
    D.26528 = rdv->type;
    switch (D.26528) <default: <D.25776>, case 4: <D.25773>, case 6: <D.25774>, case 8: <D.25775>>
    <D.25773>:
    D.26529 = &rdv->value.i1;
    return D.26529;
    <D.25774>:
    D.26529 = &rdv->value.i2;
    return D.26529;
    <D.25775>:
    D.26529 = &rdv->value.i4;
    return D.26529;
    <D.25776>:
    goto <D.25777>;
    <D.25777>:
  }
  <D.25754>:
  rdv = rdv->next;
  <D.25779>:
  if (rdv != 0B) goto <D.25778>; else goto <D.25780>;
  <D.25780>:
  D.26529 = 0B;
  return D.26529;
}


mono_aot_get_got_offset (struct MonoJumpInfo * ji)
{
  guint32 D.26532;
  struct MonoAotCompile * llvm_acfg.2;

  llvm_acfg.2 = llvm_acfg;
  D.26532 = get_got_offset (llvm_acfg.2, ji);
  return D.26532;
}


get_got_offset (struct MonoAotCompile * acfg, struct MonoJumpInfo * ji)
{
  struct GHashTable * * D.26535;
  <unnamed type> D.26536;
  long unsigned int D.26537;
  long unsigned int D.26538;
  struct GHashTable * * D.26539;
  struct GHashTable * D.26540;
  void * D.26541;
  long int D.26542;
  guint32 D.26545;
  unsigned int D.26546;
  unsigned int D.26547;
  unsigned int D.26548;
  _Bool D.26551;
  long int D.26552;
  long int D.26553;
  int D.26556;
  int D.26557;
  int D.26558;
  int D.26559;
  struct GHashTable * D.26560;
  unsigned int D.26561;
  long unsigned int D.26562;
  void * D.26563;
  struct GPtrArray * D.26564;
  guint32 got_offset;

  D.26535 = acfg->patch_to_got_offset_by_type;
  D.26536 = ji->type;
  D.26537 = (long unsigned int) D.26536;
  D.26538 = D.26537 * 8;
  D.26539 = D.26535 + D.26538;
  D.26540 = *D.26539;
  D.26541 = monoeg_g_hash_table_lookup (D.26540, ji);
  D.26542 = (long int) D.26541;
  got_offset = (guint32) D.26542;
  if (got_offset != 0) goto <D.26543>; else goto <D.26544>;
  <D.26543>:
  D.26545 = got_offset + 4294967295;
  return D.26545;
  <D.26544>:
  got_offset = acfg->got_offset;
  D.26546 = acfg->got_offset;
  D.26547 = D.26546 + 1;
  acfg->got_offset = D.26547;
  D.26548 = acfg->final_got_size;
  if (D.26548 != 0) goto <D.26549>; else goto <D.26550>;
  <D.26549>:
  D.26548 = acfg->final_got_size;
  D.26551 = D.26548 <= got_offset;
  D.26552 = (long int) D.26551;
  D.26553 = __builtin_expect (D.26552, 0);
  if (D.26553 != 0) goto <D.26554>; else goto <D.26555>;
  <D.26554>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "aot-compiler.c", 2978, "got_offset < acfg->final_got_size");
  <D.26555>:
  <D.26550>:
  D.26556 = acfg->stats.got_slots;
  D.26557 = D.26556 + 1;
  acfg->stats.got_slots = D.26557;
  D.26536 = ji->type;
  D.26558 = acfg->stats.got_slot_types[D.26536];
  D.26559 = D.26558 + 1;
  acfg->stats.got_slot_types[D.26536] = D.26559;
  D.26560 = acfg->patch_to_got_offset;
  D.26561 = got_offset + 1;
  D.26562 = (long unsigned int) D.26561;
  D.26563 = (void *) D.26562;
  monoeg_g_hash_table_insert_replace (D.26560, ji, D.26563, 0);
  D.26535 = acfg->patch_to_got_offset_by_type;
  D.26536 = ji->type;
  D.26537 = (long unsigned int) D.26536;
  D.26538 = D.26537 * 8;
  D.26539 = D.26535 + D.26538;
  D.26540 = *D.26539;
  D.26561 = got_offset + 1;
  D.26562 = (long unsigned int) D.26561;
  D.26563 = (void *) D.26562;
  monoeg_g_hash_table_insert_replace (D.26540, ji, D.26563, 0);
  D.26564 = acfg->got_patches;
  monoeg_g_ptr_array_add (D.26564, ji);
  D.26545 = got_offset;
  return D.26545;
}


mono_aot_get_method_name (struct MonoCompile * cfg)
{
  struct MonoAotCompile * llvm_acfg.3;
  int D.26567;
  char * D.26570;
  char * D.26571;
  struct MonoMethod * D.26572;
  struct GHashTable * D.26573;
  char * D.26574;

  llvm_acfg.3 = llvm_acfg;
  D.26567 = llvm_acfg.3->aot_opts.static_link;
  if (D.26567 != 0) goto <D.26568>; else goto <D.26569>;
  <D.26568>:
  llvm_acfg.3 = llvm_acfg;
  D.26571 = llvm_acfg.3->assembly_name_sym;
  D.26572 = cfg->orig_method;
  llvm_acfg.3 = llvm_acfg;
  D.26573 = llvm_acfg.3->method_label_hash;
  D.26574 = get_debug_sym (D.26572, "", D.26573);
  D.26570 = monoeg_g_strdup_printf ("%s_%s", D.26571, D.26574);
  return D.26570;
  <D.26569>:
  D.26572 = cfg->orig_method;
  llvm_acfg.3 = llvm_acfg;
  D.26573 = llvm_acfg.3->method_label_hash;
  D.26570 = get_debug_sym (D.26572, "", D.26573);
  return D.26570;
}


get_debug_sym (struct MonoMethod * method, const char * prefix, struct GHashTable * cache)
{
  long unsigned int D.26576;
  long unsigned int D.26577;
  long unsigned int D.26578;
  long unsigned int D.26579;
  long unsigned int D.26580;
  long unsigned int D.26581;
  long unsigned int D.26582;
  const short unsigned int * * D.26583;
  const short unsigned int * D.26584;
  sizetype D.26585;
  char * D.26586;
  char D.26587;
  long unsigned int D.26588;
  long unsigned int D.26589;
  const short unsigned int * D.26590;
  short unsigned int D.26591;
  int D.26592;
  int D.26593;
  int j.4;
  sizetype D.26597;
  char * D.26598;
  sizetype D.26603;
  char * D.26604;
  char D.26605;
  sizetype D.26607;
  char * D.26608;
  char D.26609;
  int j.5;
  sizetype D.26616;
  char * D.26617;
  char D.26618;
  int j.6;
  sizetype D.26625;
  char * D.26626;
  sizetype D.26627;
  char * D.26628;
  void * D.26629;
  char * D.26630;
  char * name1;
  char * name2;
  char * cached;
  int i;
  int j;
  int len;
  int count;

  name1 = mono_method_full_name (method, 1);
  D.26576 = strlen (name1);
  len = (int) D.26576;
  D.26577 = strlen (prefix);
  D.26578 = (long unsigned int) len;
  D.26579 = D.26577 + D.26578;
  D.26580 = D.26579 + 16;
  name2 = malloc (D.26580);
  D.26581 = strlen (prefix);
  memcpy (name2, prefix, D.26581);
  D.26582 = strlen (prefix);
  j = (int) D.26582;
  i = 0;
  goto <D.25361>;
  <D.25360>:
  D.26583 = __ctype_b_loc ();
  D.26584 = *D.26583;
  D.26585 = (sizetype) i;
  D.26586 = name1 + D.26585;
  D.26587 = *D.26586;
  D.26588 = (long unsigned int) D.26587;
  D.26589 = D.26588 * 2;
  D.26590 = D.26584 + D.26589;
  D.26591 = *D.26590;
  D.26592 = (int) D.26591;
  D.26593 = D.26592 & 8;
  if (D.26593 != 0) goto <D.26594>; else goto <D.26595>;
  <D.26594>:
  j.4 = j;
  j = j.4 + 1;
  D.26597 = (sizetype) j.4;
  D.26598 = name2 + D.26597;
  D.26585 = (sizetype) i;
  D.26586 = name1 + D.26585;
  D.26587 = *D.26586;
  *D.26598 = D.26587;
  goto <D.26599>;
  <D.26595>:
  D.26585 = (sizetype) i;
  D.26586 = name1 + D.26585;
  D.26587 = *D.26586;
  if (D.26587 == 32) goto <D.26602>; else goto <D.26600>;
  <D.26602>:
  D.26585 = (sizetype) i;
  D.26603 = D.26585 + 1;
  D.26604 = name1 + D.26603;
  D.26605 = *D.26604;
  if (D.26605 == 40) goto <D.26606>; else goto <D.26600>;
  <D.26606>:
  D.26585 = (sizetype) i;
  D.26607 = D.26585 + 2;
  D.26608 = name1 + D.26607;
  D.26609 = *D.26608;
  if (D.26609 == 41) goto <D.26610>; else goto <D.26600>;
  <D.26610>:
  i = i + 2;
  goto <D.26601>;
  <D.26600>:
  D.26585 = (sizetype) i;
  D.26586 = name1 + D.26585;
  D.26587 = *D.26586;
  if (D.26587 == 44) goto <D.26613>; else goto <D.26611>;
  <D.26613>:
  D.26585 = (sizetype) i;
  D.26603 = D.26585 + 1;
  D.26604 = name1 + D.26603;
  D.26605 = *D.26604;
  if (D.26605 == 32) goto <D.26614>; else goto <D.26611>;
  <D.26614>:
  j.5 = j;
  j = j.5 + 1;
  D.26616 = (sizetype) j.5;
  D.26617 = name2 + D.26616;
  *D.26617 = 95;
  i = i + 1;
  goto <D.26612>;
  <D.26611>:
  D.26585 = (sizetype) i;
  D.26586 = name1 + D.26585;
  D.26587 = *D.26586;
  D.26618 = D.26587 + 216;
  if (D.26618 <= 1) goto <D.26619>; else goto <D.26620>;
  <D.26620>:
  D.26585 = (sizetype) i;
  D.26586 = name1 + D.26585;
  D.26587 = *D.26586;
  if (D.26587 == 62) goto <D.26621>; else goto <D.26622>;
  <D.26621>:
  goto <D.26623>;
  <D.26622>:
  j.6 = j;
  j = j.6 + 1;
  D.26625 = (sizetype) j.6;
  D.26626 = name2 + D.26625;
  *D.26626 = 95;
  <D.26623>:
  <D.26619>:
  <D.26612>:
  <D.26601>:
  <D.26599>:
  i = i + 1;
  <D.25361>:
  if (i < len) goto <D.25360>; else goto <D.25362>;
  <D.25362>:
  D.26627 = (sizetype) j;
  D.26628 = name2 + D.26627;
  *D.26628 = 0;
  monoeg_g_free (name1);
  count = 0;
  goto <D.25364>;
  <D.25363>:
  D.26627 = (sizetype) j;
  D.26628 = name2 + D.26627;
  sprintf (D.26628, "_%d", count);
  count = count + 1;
  <D.25364>:
  D.26629 = monoeg_g_hash_table_lookup (cache, name2);
  if (D.26629 != 0B) goto <D.25363>; else goto <D.25365>;
  <D.25365>:
  cached = monoeg_strdup (name2);
  monoeg_g_hash_table_insert_replace (cache, cached, cached, 0);
  D.26630 = name2;
  return D.26630;
}


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

  D.26633 = __builtin_object_size (__dest, 0);
  D.26632 = __builtin___memcpy_chk (__dest, __src, __len, D.26633);
  return D.26632;
}


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

  D.26636 = __builtin_object_size (__s, 1);
  D.26635 = __builtin___sprintf_chk (__s, 1, D.26636, __fmt, __builtin_va_arg_pack ());
  return D.26635;
}


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

  if (str != 0B) goto <D.26638>; else goto <D.26639>;
  <D.26638>:
  D.26640 = __strdup (str);
  return D.26640;
  <D.26639>:
  D.26640 = 0B;
  return D.26640;
}


mono_aot_get_plt_symbol (MonoJumpInfoType type, const void * data)
{
  struct MonoAotCompile * llvm_acfg.7;
  struct MonoMemPool * D.26643;
  int D.26644;
  char * D.26647;
  char * D.26648;
  struct MonoJumpInfo * ji;
  struct MonoPltEntry * plt_entry;

  llvm_acfg.7 = llvm_acfg;
  D.26643 = llvm_acfg.7->mempool;
  ji = mono_mempool_alloc (D.26643, 40);
  ji->type = type;
  ji->data.target = data;
  llvm_acfg.7 = llvm_acfg;
  D.26644 = can_encode_patch (llvm_acfg.7, ji);
  if (D.26644 == 0) goto <D.26645>; else goto <D.26646>;
  <D.26645>:
  D.26647 = 0B;
  return D.26647;
  <D.26646>:
  llvm_acfg.7 = llvm_acfg;
  plt_entry = get_plt_entry (llvm_acfg.7, ji);
  plt_entry->llvm_used = 1;
  D.26648 = plt_entry->llvm_symbol;
  D.26647 = monoeg_g_strdup_printf (D.26648);
  return D.26647;
}


can_encode_patch (struct MonoAotCompile * acfg, struct MonoJumpInfo * patch_info)
{
  <unnamed type> D.26650;
  gboolean D.26651;
  struct MonoClass * D.26652;
  int D.26653;
  struct MonoMethod * D.26656;
  int D.26657;
  struct MonoJumpInfo * D.26660;
  int D.26661;

  D.26650 = patch_info->type;
  switch (D.26650) <default: <D.25883>, case 3: <D.25870>, case 6: <D.25871>, case 11: <D.25877>, case 14: <D.25874>, case 15: <D.25875>, case 23: <D.25878>, case 24: <D.25879>, case 30: <D.25876>, case 35: <D.25881>, case 50: <D.25872>>
  <D.25870>:
  <D.25871>:
  <D.25872>:
  {
    struct MonoMethod * method;

    method = patch_info->data.method;
    D.26651 = can_encode_method (acfg, method);
    return D.26651;
  }
  <D.25874>:
  <D.25875>:
  <D.25876>:
  <D.25877>:
  <D.25878>:
  <D.25879>:
  D.26652 = patch_info->data.klass;
  D.26653 = can_encode_class (acfg, D.26652);
  if (D.26653 == 0) goto <D.26654>; else goto <D.26655>;
  <D.26654>:
  D.26651 = 0;
  return D.26651;
  <D.26655>:
  goto <D.25880>;
  <D.25881>:
  {
    struct MonoJumpInfoRgctxEntry * entry;

    entry = patch_info->data.rgctx_entry;
    D.26656 = entry->method;
    D.26657 = can_encode_method (acfg, D.26656);
    if (D.26657 == 0) goto <D.26658>; else goto <D.26659>;
    <D.26658>:
    D.26651 = 0;
    return D.26651;
    <D.26659>:
    D.26660 = entry->data;
    D.26661 = can_encode_patch (acfg, D.26660);
    if (D.26661 == 0) goto <D.26662>; else goto <D.26663>;
    <D.26662>:
    D.26651 = 0;
    return D.26651;
    <D.26663>:
    goto <D.25880>;
  }
  <D.25883>:
  goto <D.25880>;
  <D.25880>:
  D.26651 = 1;
  return D.26651;
}


can_encode_class (struct MonoAotCompile * acfg, struct MonoClass * klass)
{
  unsigned int D.26666;
  gboolean D.26669;
  unsigned char D.26672;
  unsigned char D.26675;
  struct MonoClass * D.26678;

  D.26666 = klass->type_token;
  if (D.26666 != 0) goto <D.26667>; else goto <D.26668>;
  <D.26667>:
  D.26669 = 1;
  return D.26669;
  <D.26668>:
  D.26672 = klass->byval_arg.type;
  if (D.26672 == 19) goto <D.26670>; else goto <D.26673>;
  <D.26673>:
  D.26672 = klass->byval_arg.type;
  if (D.26672 == 30) goto <D.26670>; else goto <D.26674>;
  <D.26674>:
  D.26672 = klass->byval_arg.type;
  if (D.26672 == 15) goto <D.26670>; else goto <D.26671>;
  <D.26670>:
  D.26669 = 1;
  return D.26669;
  <D.26671>:
  D.26675 = klass->rank;
  if (D.26675 != 0) goto <D.26676>; else goto <D.26677>;
  <D.26676>:
  D.26678 = klass->element_class;
  D.26669 = can_encode_class (acfg, D.26678);
  return D.26669;
  <D.26677>:
  D.26669 = 0;
  return D.26669;
}


can_encode_method (struct MonoAotCompile * acfg, struct MonoMethod * method)
{
  long unsigned int D.26680;
  long unsigned int D.26681;
  <unnamed-unsigned:5> D.26684;
  int D.26685;
  gboolean D.26688;
  unsigned int D.26690;
  struct GHashTable * D.26693;
  void * D.26694;
  struct MonoClass * D.26697;
  unsigned char D.26698;

  D.26680 = BIT_FIELD_REF <*method, 64, 256>;
  D.26681 = D.26680 & 124;
  if (D.26681 != 0) goto <D.26682>; else goto <D.26683>;
  <D.26682>:
  D.26684 = method->wrapper_type;
  D.26685 = (int) D.26684;
  switch (D.26685) <default: <D.25865>, case 0: <D.25842>, case 1: <D.25857>, case 2: <D.25858>, case 3: <D.25859>, case 7: <D.25862>, case 8: <D.25854>, case 9: <D.25843>, case 10: <D.25844>, case 12: <D.25846>, case 13: <D.25845>, case 14: <D.25848>, case 15: <D.25849>, case 16: <D.25860>, case 18: <D.25851>, case 19: <D.25863>, case 20: <D.25852>, case 21: <D.25850>, case 23: <D.25847>, case 24: <D.25856>, case 25: <D.25855>, case 28: <D.25853>>
  <D.25842>:
  <D.25843>:
  <D.25844>:
  <D.25845>:
  <D.25846>:
  <D.25847>:
  <D.25848>:
  <D.25849>:
  <D.25850>:
  <D.25851>:
  <D.25852>:
  <D.25853>:
  <D.25854>:
  <D.25855>:
  <D.25856>:
  <D.25857>:
  <D.25858>:
  <D.25859>:
  <D.25860>:
  goto <D.25861>;
  <D.25862>:
  <D.25863>:
  {
    struct WrapperInfo * info;

    info = mono_marshal_get_wrapper_info (method);
    if (info != 0B) goto <D.26686>; else goto <D.26687>;
    <D.26686>:
    D.26688 = 1;
    return D.26688;
    <D.26687>:
    D.26688 = 0;
    return D.26688;
  }
  <D.25865>:
  D.26688 = 0;
  return D.26688;
  <D.25861>:
  goto <D.26689>;
  <D.26683>:
  D.26690 = method->token;
  if (D.26690 == 0) goto <D.26691>; else goto <D.26692>;
  <D.26691>:
  D.26693 = acfg->token_info_hash;
  D.26694 = monoeg_g_hash_table_lookup (D.26693, method);
  if (D.26694 == 0B) goto <D.26695>; else goto <D.26696>;
  <D.26695>:
  D.26697 = method->klass;
  D.26698 = D.26697->rank;
  if (D.26698 != 0) goto <D.26699>; else goto <D.26700>;
  <D.26699>:
  D.26688 = 1;
  return D.26688;
  <D.26700>:
  D.26688 = 0;
  return D.26688;
  <D.26696>:
  <D.26692>:
  <D.26689>:
  D.26688 = 1;
  return D.26688;
}


get_plt_entry (struct MonoAotCompile * acfg, struct MonoJumpInfo * patch_info)
{
  int D.26704;
  struct MonoPltEntry * D.26707;
  struct GHashTable * * D.26708;
  <unnamed type> D.26709;
  long unsigned int D.26710;
  long unsigned int D.26711;
  struct GHashTable * * D.26712;
  struct GHashTable * D.26713;
  struct GHashTable * D.26716;
  int D.26717;
  struct MonoMethod * D.26722;
  short unsigned int D.26723;
  int D.26724;
  int D.26725;
  unsigned int D.26730;
  _Bool D.26731;
  long int D.26732;
  long int D.26733;
  struct MonoMemPool * D.26736;
  unsigned int D.26737;
  int D.26738;
  int D.26739;
  char * D.26740;
  int D.26741;
  struct MonoJumpInfo * D.26744;
  struct GHashTable * D.26745;
  char * D.26746;
  char * D.26747;
  char * D.26750;
  gchar * D.26751;
  gchar * D.26753;
  <unnamed type> D.26754;
  long unsigned int D.26755;
  long unsigned int D.26756;
  struct GHashTable * * D.26757;
  struct GHashTable * D.26758;
  struct GHashTable * D.26759;
  long unsigned int D.26760;
  void * D.26761;
  unsigned int D.26762;
  struct MonoPltEntry * res;

  D.26704 = is_plt_patch (patch_info);
  if (D.26704 == 0) goto <D.26705>; else goto <D.26706>;
  <D.26705>:
  D.26707 = 0B;
  return D.26707;
  <D.26706>:
  D.26708 = acfg->patch_to_plt_entry;
  D.26709 = patch_info->type;
  D.26710 = (long unsigned int) D.26709;
  D.26711 = D.26710 * 8;
  D.26712 = D.26708 + D.26711;
  D.26713 = *D.26712;
  if (D.26713 == 0B) goto <D.26714>; else goto <D.26715>;
  <D.26714>:
  D.26708 = acfg->patch_to_plt_entry;
  D.26709 = patch_info->type;
  D.26710 = (long unsigned int) D.26709;
  D.26711 = D.26710 * 8;
  D.26712 = D.26708 + D.26711;
  D.26716 = monoeg_g_hash_table_new (mono_patch_info_hash, mono_patch_info_equal);
  *D.26712 = D.26716;
  <D.26715>:
  D.26708 = acfg->patch_to_plt_entry;
  D.26709 = patch_info->type;
  D.26710 = (long unsigned int) D.26709;
  D.26711 = D.26710 * 8;
  D.26712 = D.26708 + D.26711;
  D.26713 = *D.26712;
  res = monoeg_g_hash_table_lookup (D.26713, patch_info);
  D.26717 = acfg->llvm;
  if (D.26717 == 0) goto <D.26718>; else goto <D.26719>;
  <D.26718>:
  D.26709 = patch_info->type;
  if (D.26709 == 3) goto <D.26720>; else goto <D.26721>;
  <D.26720>:
  D.26722 = patch_info->data.method;
  D.26723 = D.26722->iflags;
  D.26724 = (int) D.26723;
  D.26725 = D.26724 & 32;
  if (D.26725 != 0) goto <D.26726>; else goto <D.26727>;
  <D.26726>:
  res = 0B;
  <D.26727>:
  <D.26721>:
  <D.26719>:
  if (res == 0B) goto <D.26728>; else goto <D.26729>;
  <D.26728>:
  {
    struct MonoJumpInfo * new_ji;

    D.26730 = acfg->final_got_size;
    D.26731 = D.26730 != 0;
    D.26732 = (long int) D.26731;
    D.26733 = __builtin_expect (D.26732, 0);
    if (D.26733 != 0) goto <D.26734>; else goto <D.26735>;
    <D.26734>:
    monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "aot-compiler.c", 2930, "!acfg->final_got_size");
    <D.26735>:
    D.26736 = acfg->mempool;
    new_ji = mono_patch_info_dup_mp (D.26736, patch_info);
    D.26736 = acfg->mempool;
    res = mono_mempool_alloc0 (D.26736, 48);
    D.26737 = acfg->plt_offset;
    D.26738 = (int) D.26737;
    res->plt_offset = D.26738;
    res->ji = new_ji;
    D.26739 = res->plt_offset;
    D.26740 = get_plt_symbol (acfg, D.26739, patch_info);
    res->symbol = D.26740;
    D.26741 = acfg->aot_opts.write_symbols;
    if (D.26741 != 0) goto <D.26742>; else goto <D.26743>;
    <D.26742>:
    D.26744 = res->ji;
    D.26745 = acfg->plt_entry_debug_sym_cache;
    D.26746 = get_plt_entry_debug_sym (acfg, D.26744, D.26745);
    res->debug_sym = D.26746;
    <D.26743>:
    D.26747 = res->debug_sym;
    if (D.26747 != 0B) goto <D.26748>; else goto <D.26749>;
    <D.26748>:
    D.26750 = res->symbol;
    D.26747 = res->debug_sym;
    D.26751 = monoeg_g_strdup_printf ("%s_%s_llvm", D.26750, D.26747);
    res->llvm_symbol = D.26751;
    goto <D.26752>;
    <D.26749>:
    D.26750 = res->symbol;
    D.26753 = monoeg_g_strdup_printf ("%s_llvm", D.26750);
    res->llvm_symbol = D.26753;
    <D.26752>:
    D.26708 = acfg->patch_to_plt_entry;
    D.26754 = new_ji->type;
    D.26755 = (long unsigned int) D.26754;
    D.26756 = D.26755 * 8;
    D.26757 = D.26708 + D.26756;
    D.26758 = *D.26757;
    monoeg_g_hash_table_insert_replace (D.26758, new_ji, res, 0);
    D.26759 = acfg->plt_offset_to_entry;
    D.26739 = res->plt_offset;
    D.26760 = (long unsigned int) D.26739;
    D.26761 = (void *) D.26760;
    monoeg_g_hash_table_insert_replace (D.26759, D.26761, res, 0);
    D.26737 = acfg->plt_offset;
    D.26762 = D.26737 + 1;
    acfg->plt_offset = D.26762;
  }
  <D.26729>:
  D.26707 = res;
  return D.26707;
}


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

  D.26764 = patch_info->type;
  switch (D.26764) <default: <D.24555>, case 3: <D.24545>, case 7: <D.24546>, case 15: <D.24549>, case 31: <D.24548>, case 32: <D.24547>, case 35: <D.24550>, case 36: <D.24551>, case 37: <D.24552>, case 38: <D.24553>, case 41: <D.24554>>
  <D.24545>:
  <D.24546>:
  <D.24547>:
  <D.24548>:
  <D.24549>:
  <D.24550>:
  <D.24551>:
  <D.24552>:
  <D.24553>:
  <D.24554>:
  D.26765 = 1;
  return D.26765;
  <D.24555>:
  D.26765 = 0;
  return D.26765;
}


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

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


get_plt_entry_debug_sym (struct MonoAotCompile * acfg, struct MonoJumpInfo * ji, struct GHashTable * cache)
{
  <unnamed type> D.26770;
  struct MonoMethod * D.26771;
  const char * D.26772;
  struct MonoClass * D.26773;
  struct MonoType * D.26774;
  unsigned int D.26775;
  unsigned int D.26776;
  unsigned int D.26777;
  char * D.26778;
  char * debug_sym;
  char * s;

  debug_sym = 0B;
  D.26770 = ji->type;
  switch (D.26770) <default: <D.25621>, case 3: <D.25612>, case 7: <D.25614>, case 15: <D.25615>, case 31: <D.25617>, case 32: <D.25619>, case 35: <D.25616>, case 36: <D.25620>>
  <D.25612>:
  D.26771 = ji->data.method;
  debug_sym = get_debug_sym (D.26771, "plt_", cache);
  goto <D.25613>;
  <D.25614>:
  D.26772 = ji->data.name;
  debug_sym = monoeg_g_strdup_printf ("plt__jit_icall_%s", D.26772);
  goto <D.25613>;
  <D.25615>:
  D.26773 = ji->data.klass;
  D.26774 = &D.26773->byval_arg;
  s = mono_type_get_name (D.26774);
  debug_sym = monoeg_g_strdup_printf ("plt__class_init_%s", s);
  monoeg_g_free (s);
  goto <D.25613>;
  <D.25616>:
  D.26775 = acfg->label_generator;
  D.26776 = D.26775;
  D.26777 = D.26776 + 1;
  acfg->label_generator = D.26777;
  debug_sym = monoeg_g_strdup_printf ("plt__rgctx_fetch_%d", D.26776);
  goto <D.25613>;
  <D.25617>:
  {
    char * s;

    D.26771 = ji->data.method;
    s = get_debug_sym (D.26771, "", cache);
    debug_sym = monoeg_g_strdup_printf ("plt__icall_native_%s", s);
    monoeg_g_free (s);
    goto <D.25613>;
  }
  <D.25619>:
  D.26772 = ji->data.name;
  debug_sym = monoeg_g_strdup_printf ("plt__jit_icall_native_%s", D.26772);
  goto <D.25613>;
  <D.25620>:
  debug_sym = monoeg_g_strdup_printf ("plt__generic_class_init");
  goto <D.25613>;
  <D.25621>:
  goto <D.25613>;
  <D.25613>:
  D.26778 = sanitize_symbol (acfg, debug_sym);
  return D.26778;
}


sanitize_symbol (struct MonoAotCompile * acfg, char * s)
{
  char * D.26783;
  long unsigned int D.26784;
  sizetype D.26787;
  char * D.26788;
  char D.26789;
  signed char D.26790;
  const short unsigned int * * D.26792;
  const short unsigned int * D.26793;
  long unsigned int D.26794;
  long unsigned int D.26795;
  const short unsigned int * D.26796;
  short unsigned int D.26797;
  int D.26798;
  int D.26799;
  long unsigned int D.26803;
  signed char c.8;
  long unsigned int D.26809;
  long unsigned int D.26810;
  const short unsigned int * D.26811;
  short unsigned int D.26812;
  int D.26813;
  int D.26814;
  int D.26818;
  unsigned char D.26819;
  struct MonoMemPool * D.26821;
  char * D.26822;
  gboolean process;
  int i;
  int len;
  struct GString * gs;
  char * res;

  process = 0;
  if (s == 0B) goto <D.26781>; else goto <D.26782>;
  <D.26781>:
  D.26783 = s;
  return D.26783;
  <D.26782>:
  D.26784 = strlen (s);
  len = (int) D.26784;
  i = 0;
  goto <D.25339>;
  <D.25338>:
  D.26787 = (sizetype) i;
  D.26788 = s + D.26787;
  D.26789 = *D.26788;
  D.26790 = (signed char) D.26789;
  if (D.26790 < 0) goto <D.26785>; else goto <D.26791>;
  <D.26791>:
  D.26792 = __ctype_b_loc ();
  D.26793 = *D.26792;
  D.26787 = (sizetype) i;
  D.26788 = s + D.26787;
  D.26789 = *D.26788;
  D.26794 = (long unsigned int) D.26789;
  D.26795 = D.26794 * 2;
  D.26796 = D.26793 + D.26795;
  D.26797 = *D.26796;
  D.26798 = (int) D.26797;
  D.26799 = D.26798 & 8;
  if (D.26799 == 0) goto <D.26800>; else goto <D.26786>;
  <D.26800>:
  D.26787 = (sizetype) i;
  D.26788 = s + D.26787;
  D.26789 = *D.26788;
  if (D.26789 != 95) goto <D.26785>; else goto <D.26786>;
  <D.26785>:
  process = 1;
  <D.26786>:
  i = i + 1;
  <D.25339>:
  if (i < len) goto <D.25338>; else goto <D.25340>;
  <D.25340>:
  if (process == 0) goto <D.26801>; else goto <D.26802>;
  <D.26801>:
  D.26783 = s;
  return D.26783;
  <D.26802>:
  D.26803 = (long unsigned int) len;
  gs = monoeg_g_string_sized_new (D.26803);
  i = 0;
  goto <D.25346>;
  <D.25345>:
  {
    guint8 c;

    D.26787 = (sizetype) i;
    D.26788 = s + D.26787;
    c = *D.26788;
    c.8 = (signed char) c;
    if (c.8 >= 0) goto <D.26808>; else goto <D.26804>;
    <D.26808>:
    D.26792 = __ctype_b_loc ();
    D.26793 = *D.26792;
    D.26809 = (long unsigned int) c;
    D.26810 = D.26809 * 2;
    D.26811 = D.26793 + D.26810;
    D.26812 = *D.26811;
    D.26813 = (int) D.26812;
    D.26814 = D.26813 & 8;
    if (D.26814 != 0) goto <D.26805>; else goto <D.26815>;
    <D.26815>:
    if (c == 95) goto <D.26805>; else goto <D.26804>;
    <D.26805>:
    monoeg_g_string_append_c (gs, c);
    goto <D.26806>;
    <D.26804>:
    c.8 = (signed char) c;
    if (c.8 < 0) goto <D.26816>; else goto <D.26817>;
    <D.26816>:
    D.26818 = (int) c;
    monoeg_g_string_append_printf (gs, "_0x%x", D.26818);
    i = i + 1;
    D.26787 = (sizetype) i;
    D.26788 = s + D.26787;
    c = *D.26788;
    goto <D.25343>;
    <D.25342>:
    D.26818 = (int) c;
    monoeg_g_string_append_printf (gs, "%x", D.26818);
    i = i + 1;
    D.26787 = (sizetype) i;
    D.26788 = s + D.26787;
    c = *D.26788;
    <D.25343>:
    D.26819 = c >> 6;
    if (D.26819 == 2) goto <D.25342>; else goto <D.25344>;
    <D.25344>:
    monoeg_g_string_append_printf (gs, "_");
    i = i + -1;
    goto <D.26820>;
    <D.26817>:
    monoeg_g_string_append_c (gs, 95);
    <D.26820>:
    <D.26806>:
  }
  i = i + 1;
  <D.25346>:
  if (i < len) goto <D.25345>; else goto <D.25347>;
  <D.25347>:
  D.26821 = acfg->mempool;
  D.26822 = gs->str;
  res = mono_mempool_strdup (D.26821, D.26822);
  monoeg_g_string_free (gs, 1);
  D.26783 = res;
  return D.26783;
}


mono_aot_get_method_index (struct MonoMethod * method)
{
  struct MonoAotCompile * llvm_acfg.9;
  _Bool D.26825;
  long int D.26826;
  long int D.26827;
  int D.26830;
  unsigned int D.26831;

  llvm_acfg.9 = llvm_acfg;
  D.26825 = llvm_acfg.9 == 0B;
  D.26826 = (long int) D.26825;
  D.26827 = __builtin_expect (D.26826, 0);
  if (D.26827 != 0) goto <D.26828>; else goto <D.26829>;
  <D.26828>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "aot-compiler.c", 6895, "llvm_acfg");
  <D.26829>:
  llvm_acfg.9 = llvm_acfg;
  D.26831 = get_method_index (llvm_acfg.9, method);
  D.26830 = (int) D.26831;
  return D.26830;
}


get_method_index (struct MonoAotCompile * acfg, struct MonoMethod * method)
{
  struct GHashTable * D.26833;
  void * D.26834;
  long int D.26835;
  _Bool D.26836;
  long int D.26837;
  long int D.26838;
  guint32 D.26841;
  int D.26842;
  int index;

  D.26833 = acfg->method_indexes;
  D.26834 = monoeg_g_hash_table_lookup (D.26833, method);
  D.26835 = (long int) D.26834;
  index = (int) D.26835;
  D.26836 = index == 0;
  D.26837 = (long int) D.26836;
  D.26838 = __builtin_expect (D.26837, 0);
  if (D.26838 != 0) goto <D.26839>; else goto <D.26840>;
  <D.26839>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "aot-compiler.c", 3010, "index");
  <D.26840>:
  D.26842 = index + -1;
  D.26841 = (guint32) D.26842;
  return D.26841;
}


mono_aot_patch_info_dup (struct MonoJumpInfo * ji)
{
  struct MonoAotCompile * llvm_acfg.10;
  union mono_mutex_t * D.26845;
  _Bool D.26848;
  long int D.26849;
  long int D.26850;
  struct MonoMemPool * D.26853;
  _Bool D.26856;
  long int D.26857;
  long int D.26858;
  struct MonoJumpInfo * D.26861;
  struct MonoJumpInfo * res;

  {
    int ret;

    llvm_acfg.10 = llvm_acfg;
    D.26845 = &llvm_acfg.10->mutex.mutex;
    ret = pthread_mutex_lock (D.26845);
    if (ret != 0) goto <D.26846>; else goto <D.26847>;
    <D.26846>:
    monoeg_g_log (0B, 16, "Bad call to mono_mutex_lock result %d", ret);
    <D.26847>:
    D.26848 = ret != 0;
    D.26849 = (long int) D.26848;
    D.26850 = __builtin_expect (D.26849, 0);
    if (D.26850 != 0) goto <D.26851>; else goto <D.26852>;
    <D.26851>:
    monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "aot-compiler.c", 6904, "ret == 0");
    <D.26852>:
  }
  llvm_acfg.10 = llvm_acfg;
  D.26853 = llvm_acfg.10->mempool;
  res = mono_patch_info_dup_mp (D.26853, ji);
  {
    int ret;

    llvm_acfg.10 = llvm_acfg;
    D.26845 = &llvm_acfg.10->mutex.mutex;
    ret = pthread_mutex_unlock (D.26845);
    if (ret != 0) goto <D.26854>; else goto <D.26855>;
    <D.26854>:
    monoeg_g_log (0B, 16, "Bad call to mono_mutex_unlock result %d", ret);
    <D.26855>:
    D.26856 = ret != 0;
    D.26857 = (long int) D.26856;
    D.26858 = __builtin_expect (D.26857, 0);
    if (D.26858 != 0) goto <D.26859>; else goto <D.26860>;
    <D.26859>:
    monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "aot-compiler.c", 6906, "ret == 0");
    <D.26860>:
  }
  D.26861 = res;
  return D.26861;
}


mono_aot_method_hash (struct MonoMethod * method)
{
  long unsigned int D.26863;
  long unsigned int D.26864;
  short unsigned int D.26867;
  int D.26868;
  int D.26869;
  int iftmp.11;
  <unnamed-unsigned:22> D.26873;
  long unsigned int D.26875;
  long unsigned int D.26876;
  long unsigned int D.26880;
  struct MonoType * D.26884;
  unsigned int D.26885;
  guint32 * D.26886;
  const char * D.26888;
  unsigned int D.26889;
  const char * D.26890;
  unsigned int D.26891;
  guint32 * D.26897;
  const char * D.26898;
  unsigned int D.26899;
  guint32 * D.26900;
  <unnamed-unsigned:5> D.26901;
  unsigned int D.26902;
  guint32 * D.26903;
  struct MonoType * D.26904;
  unsigned int D.26905;
  int hindex.12;
  long unsigned int D.26907;
  long unsigned int D.26908;
  guint32 * D.26909;
  struct MonoType * D.26910;
  unsigned int D.26911;
  int hindex.13;
  long unsigned int D.26915;
  long unsigned int D.26916;
  guint32 * D.26917;
  struct MonoType * D.26918;
  unsigned int D.26919;
  int D.26920;
  _Bool D.26921;
  long int D.26922;
  long int D.26923;
  unsigned int hashes_count.14;
  unsigned int D.26927;
  unsigned int D.26928;
  unsigned int D.26929;
  unsigned int D.26930;
  unsigned int D.26931;
  unsigned int D.26932;
  unsigned int D.26933;
  unsigned int D.26934;
  unsigned int D.26935;
  unsigned int D.26936;
  unsigned int D.26937;
  unsigned int D.26938;
  unsigned int D.26939;
  unsigned int D.26940;
  unsigned int D.26941;
  unsigned int D.26942;
  guint32 D.26944;
  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.26863 = BIT_FIELD_REF <*method, 64, 256>;
  D.26864 = D.26863 & 4096;
  if (D.26864 != 0) goto <D.26865>; else goto <D.26866>;
  <D.26865>:
  ginst = MEM[(struct MonoMethodInflated *)method].context.method_inst;
  <D.26866>:
  D.26867 = sig->param_count;
  D.26868 = (int) D.26867;
  D.26869 = D.26868 + 5;
  if (ginst != 0B) goto <D.26871>; else goto <D.26872>;
  <D.26871>:
  D.26873 = ginst->type_argc;
  iftmp.11 = (int) D.26873;
  goto <D.26874>;
  <D.26872>:
  iftmp.11 = 0;
  <D.26874>:
  hashes_count = D.26869 + iftmp.11;
  D.26875 = (long unsigned int) hashes_count;
  D.26876 = D.26875 * 4;
  hashes_start = monoeg_malloc0 (D.26876);
  hashes = hashes_start;
  D.26863 = BIT_FIELD_REF <*method, 64, 256>;
  D.26880 = D.26863 & 124;
  if (D.26880 == 0) goto <D.26877>; else goto <D.26881>;
  <D.26881>:
  D.26863 = BIT_FIELD_REF <*method, 64, 256>;
  D.26880 = D.26863 & 124;
  if (D.26880 == 36) goto <D.26877>; else goto <D.26878>;
  <D.26877>:
  klass = method->klass;
  goto <D.26879>;
  <D.26878>:
  klass = mono_defaults.object_class;
  <D.26879>:
  D.26863 = BIT_FIELD_REF <*method, 64, 256>;
  D.26880 = D.26863 & 124;
  if (D.26880 == 0) goto <D.26882>; else goto <D.26883>;
  <D.26882>:
  {
    char * full_name;

    D.26884 = &klass->byval_arg;
    full_name = mono_type_full_name (D.26884);
    D.26885 = mono_metadata_str_hash (full_name);
    *hashes = D.26885;
    D.26886 = hashes + 4;
    *D.26886 = 0;
    monoeg_g_free (full_name);
  }
  goto <D.26887>;
  <D.26883>:
  D.26888 = klass->name;
  D.26889 = mono_metadata_str_hash (D.26888);
  *hashes = D.26889;
  D.26886 = hashes + 4;
  D.26890 = klass->name_space;
  D.26891 = mono_metadata_str_hash (D.26890);
  *D.26886 = D.26891;
  <D.26887>:
  D.26863 = BIT_FIELD_REF <*method, 64, 256>;
  D.26880 = D.26863 & 124;
  if (D.26880 == 52) goto <D.26892>; else goto <D.26895>;
  <D.26895>:
  D.26863 = BIT_FIELD_REF <*method, 64, 256>;
  D.26880 = D.26863 & 124;
  if (D.26880 == 48) goto <D.26892>; else goto <D.26896>;
  <D.26896>:
  D.26863 = BIT_FIELD_REF <*method, 64, 256>;
  D.26880 = D.26863 & 124;
  if (D.26880 == 92) goto <D.26892>; else goto <D.26893>;
  <D.26892>:
  D.26897 = hashes + 8;
  *D.26897 = 0;
  goto <D.26894>;
  <D.26893>:
  D.26897 = hashes + 8;
  D.26898 = method->name;
  D.26899 = mono_metadata_str_hash (D.26898);
  *D.26897 = D.26899;
  <D.26894>:
  D.26900 = hashes + 12;
  D.26901 = method->wrapper_type;
  D.26902 = (unsigned int) D.26901;
  *D.26900 = D.26902;
  D.26903 = hashes + 16;
  D.26904 = sig->ret;
  D.26905 = mono_aot_type_hash (D.26904);
  *D.26903 = D.26905;
  hindex = 5;
  i = 0;
  goto <D.26114>;
  <D.26113>:
  hindex.12 = hindex;
  hindex = hindex.12 + 1;
  D.26907 = (long unsigned int) hindex.12;
  D.26908 = D.26907 * 4;
  D.26909 = hashes + D.26908;
  D.26910 = sig->params[i];
  D.26911 = mono_aot_type_hash (D.26910);
  *D.26909 = D.26911;
  i = i + 1;
  <D.26114>:
  D.26867 = sig->param_count;
  D.26868 = (int) D.26867;
  if (D.26868 > i) goto <D.26113>; else goto <D.26115>;
  <D.26115>:
  if (ginst != 0B) goto <D.26912>; else goto <D.26913>;
  <D.26912>:
  i = 0;
  goto <D.26117>;
  <D.26116>:
  hindex.13 = hindex;
  hindex = hindex.13 + 1;
  D.26915 = (long unsigned int) hindex.13;
  D.26916 = D.26915 * 4;
  D.26917 = hashes + D.26916;
  D.26918 = ginst->type_argv[i];
  D.26919 = mono_aot_type_hash (D.26918);
  *D.26917 = D.26919;
  i = i + 1;
  <D.26117>:
  D.26873 = ginst->type_argc;
  D.26920 = (int) D.26873;
  if (D.26920 > i) goto <D.26116>; else goto <D.26118>;
  <D.26118>:
  <D.26913>:
  D.26921 = hindex != hashes_count;
  D.26922 = (long int) D.26921;
  D.26923 = __builtin_expect (D.26922, 0);
  if (D.26923 != 0) goto <D.26924>; else goto <D.26925>;
  <D.26924>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "aot-compiler.c", 7387, "hindex == hashes_count");
  <D.26925>:
  hashes_count.14 = (unsigned int) hashes_count;
  D.26927 = hashes_count.14 << 2;
  c = D.26927 + 3735928559;
  b = c;
  a = b;
  goto <D.26120>;
  <D.26119>:
  D.26928 = *hashes;
  a = D.26928 + a;
  D.26886 = hashes + 4;
  D.26929 = *D.26886;
  b = D.26929 + b;
  D.26897 = hashes + 8;
  D.26930 = *D.26897;
  c = D.26930 + c;
  a = a - c;
  D.26931 = c r>> 28;
  a = D.26931 ^ a;
  c = c + b;
  b = b - a;
  D.26932 = a r>> 26;
  b = D.26932 ^ b;
  a = a + c;
  c = c - b;
  D.26933 = b r>> 24;
  c = D.26933 ^ c;
  b = b + a;
  a = a - c;
  D.26934 = c r>> 16;
  a = D.26934 ^ a;
  c = c + b;
  b = b - a;
  D.26935 = a r>> 13;
  b = D.26935 ^ b;
  a = a + c;
  c = c - b;
  D.26936 = b r>> 28;
  c = D.26936 ^ c;
  b = b + a;
  hashes_count = hashes_count + -3;
  hashes = hashes + 12;
  <D.26120>:
  if (hashes_count > 3) goto <D.26119>; else goto <D.26121>;
  <D.26121>:
  switch (hashes_count) <default: <D.26943>, case 0: <D.26125>, case 1: <D.26124>, case 2: <D.26123>, case 3: <D.26122>>
  <D.26122>:
  D.26897 = hashes + 8;
  D.26930 = *D.26897;
  c = D.26930 + c;
  <D.26123>:
  D.26886 = hashes + 4;
  D.26929 = *D.26886;
  b = D.26929 + b;
  <D.26124>:
  D.26928 = *hashes;
  a = D.26928 + a;
  c = c ^ b;
  D.26937 = b r>> 18;
  c = c - D.26937;
  a = a ^ c;
  D.26938 = c r>> 21;
  a = a - D.26938;
  b = b ^ a;
  D.26939 = a r>> 7;
  b = b - D.26939;
  c = c ^ b;
  D.26940 = b r>> 16;
  c = c - D.26940;
  a = a ^ c;
  D.26931 = c r>> 28;
  a = a - D.26931;
  b = b ^ a;
  D.26941 = a r>> 18;
  b = b - D.26941;
  c = c ^ b;
  D.26942 = b r>> 8;
  c = c - D.26942;
  <D.26125>:
  goto <D.26126>;
  <D.26943>:
  <D.26126>:
  free (hashes_start);
  D.26944 = c;
  return D.26944;
}


mono_aot_type_hash (struct MonoType * t1)
{
  unsigned char D.26946;
  <unnamed-unsigned:1> D.26947;
  int D.26948;
  int D.26949;
  unsigned int D.26950;
  int D.26951;
  guint D.26952;
  unsigned int D.26953;
  unsigned int D.26954;
  struct MonoClass * D.26955;
  const char * D.26956;
  unsigned int D.26957;
  struct MonoType * D.26958;
  unsigned int D.26959;
  struct MonoArrayType * D.26960;
  struct MonoClass * D.26961;
  struct MonoType * D.26962;
  unsigned int D.26963;
  guint hash;

  D.26946 = t1->type;
  hash = (guint) D.26946;
  D.26947 = t1->byref;
  D.26948 = (int) D.26947;
  D.26949 = D.26948 << 6;
  D.26950 = (unsigned int) D.26949;
  hash = D.26950 | hash;
  D.26946 = t1->type;
  D.26951 = (int) D.26946;
  switch (D.26951) <default: <D.26097>, case 15: <D.26094>, case 17: <D.26091>, case 18: <D.26092>, case 20: <D.26095>, case 21: <D.26096>, case 29: <D.26093>>
  <D.26091>:
  <D.26092>:
  <D.26093>:
  D.26953 = hash << 5;
  D.26954 = D.26953 - hash;
  D.26955 = t1->data.klass;
  D.26956 = D.26955->name;
  D.26957 = mono_metadata_str_hash (D.26956);
  D.26952 = D.26954 ^ D.26957;
  return D.26952;
  <D.26094>:
  D.26953 = hash << 5;
  D.26954 = D.26953 - hash;
  D.26958 = t1->data.type;
  D.26959 = mono_metadata_type_hash (D.26958);
  D.26952 = D.26954 ^ D.26959;
  return D.26952;
  <D.26095>:
  D.26953 = hash << 5;
  D.26954 = D.26953 - hash;
  D.26960 = t1->data.array;
  D.26961 = D.26960->eklass;
  D.26962 = &D.26961->byval_arg;
  D.26963 = mono_metadata_type_hash (D.26962);
  D.26952 = D.26954 ^ D.26963;
  return D.26952;
  <D.26096>:
  D.26953 = hash << 5;
  D.26952 = D.26953 - hash;
  return D.26952;
  <D.26097>:
  D.26952 = hash;
  return D.26952;
}


mono_aot_get_array_helper_from_wrapper (struct MonoMethod * method)
{
  const char * D.26965;
  long unsigned int D.26966;
  sizetype D.26967;
  const char * D.26968;
  _Bool D.26969;
  long int D.26970;
  long int D.26971;
  int D.26147;
  int iftmp.15;
  int D.26146;
  const char[6] * D.26977;
  unsigned char D.26978;
  int D.26979;
  unsigned char D.26980;
  int D.26981;
  const unsigned char * D.26986;
  unsigned char D.26987;
  int D.26988;
  const unsigned char * D.26989;
  unsigned char D.26990;
  int D.26991;
  const unsigned char * D.26996;
  unsigned char D.26997;
  int D.26998;
  const unsigned char * D.26999;
  unsigned char D.27000;
  int D.27001;
  const unsigned char * D.27006;
  unsigned char D.27007;
  int D.27008;
  const unsigned char * D.27009;
  unsigned char D.27010;
  int D.27011;
  struct MonoClass * D.27016;
  struct MonoMethodSignature * D.27017;
  short unsigned int D.27018;
  int D.27019;
  _Bool D.27020;
  long int D.27021;
  long int D.27022;
  long unsigned int D.27025;
  long unsigned int D.27026;
  struct MonoClass * D.27029;
  struct MonoClass * D.27030;
  struct MonoType * D.27031;
  struct MonoGenericInst * D.27032;
  struct MonoMethod * D.27033;
  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.26965 = method->name;
      D.26966 = strlen (prefix);
      D.26967 = D.26966 + 1;
      D.26968 = D.26965 + D.26967;
      s = monoeg_g_strdup_printf ("%s", D.26968);
      s2 = strstr (s, "`1.");
      D.26969 = s2 == 0B;
      D.26970 = (long int) D.26969;
      D.26971 = __builtin_expect (D.26970, 0);
      if (D.26971 != 0) goto <D.26972>; else goto <D.26973>;
      <D.26972>:
      monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "aot-compiler.c", 7437, "s2");
      <D.26973>:
      *s2 = 0;
      iname = s;
      mname = s2 + 3;
      {
        size_t __s1_len;
        size_t __s2_len;

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

          __s2 = iname;
          D.26977 = "IList";
          D.26978 = MEM[(const unsigned char *)D.26977];
          D.26979 = (int) D.26978;
          D.26980 = *__s2;
          D.26981 = (int) D.26980;
          __result = D.26979 - D.26981;
          {
            if (__s2_len != 0) goto <D.26982>; else goto <D.26983>;
            <D.26982>:
            if (__result == 0) goto <D.26984>; else goto <D.26985>;
            <D.26984>:
            D.26986 = &MEM[(void *)"IList" + 1B];
            D.26987 = *D.26986;
            D.26988 = (int) D.26987;
            D.26989 = __s2 + 1;
            D.26990 = *D.26989;
            D.26991 = (int) D.26990;
            __result = D.26988 - D.26991;
            if (__s2_len > 1) goto <D.26992>; else goto <D.26993>;
            <D.26992>:
            if (__result == 0) goto <D.26994>; else goto <D.26995>;
            <D.26994>:
            D.26996 = &MEM[(void *)"IList" + 2B];
            D.26997 = *D.26996;
            D.26998 = (int) D.26997;
            D.26999 = __s2 + 2;
            D.27000 = *D.26999;
            D.27001 = (int) D.27000;
            __result = D.26998 - D.27001;
            if (__s2_len > 2) goto <D.27002>; else goto <D.27003>;
            <D.27002>:
            if (__result == 0) goto <D.27004>; else goto <D.27005>;
            <D.27004>:
            D.27006 = &MEM[(void *)"IList" + 3B];
            D.27007 = *D.27006;
            D.27008 = (int) D.27007;
            D.27009 = __s2 + 3;
            D.27010 = *D.27009;
            D.27011 = (int) D.27010;
            __result = D.27008 - D.27011;
            <D.27005>:
            <D.27003>:
            <D.26995>:
            <D.26993>:
            <D.26985>:
            <D.26983>:
          }
          D.26146 = __result;
        }
        iftmp.15 = -D.26146;
        goto <D.27012>;
        <D.26976>:
        iftmp.15 = __builtin_strcmp (iname, "IList");
        <D.27012>:
        D.26147 = iftmp.15;
      }
      if (D.26147 == 0) goto <D.27013>; else goto <D.27014>;
      <D.27013>:
      helper_name = monoeg_g_strdup_printf ("InternalArray__%s", mname);
      goto <D.27015>;
      <D.27014>:
      helper_name = monoeg_g_strdup_printf ("InternalArray__%s_%s", iname, mname);
      <D.27015>:
      D.27016 = mono_defaults.array_class;
      D.27017 = mono_method_signature (method);
      D.27018 = D.27017->param_count;
      D.27019 = (int) D.27018;
      m = mono_class_get_method_from_name (D.27016, helper_name, D.27019);
      D.27020 = m == 0B;
      D.27021 = (long int) D.27020;
      D.27022 = __builtin_expect (D.27021, 0);
      if (D.27022 != 0) goto <D.27023>; else goto <D.27024>;
      <D.27023>:
      monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "aot-compiler.c", 7449, "m");
      <D.27024>:
      monoeg_g_free (helper_name);
      monoeg_g_free (s);
      D.27025 = BIT_FIELD_REF <*m, 64, 256>;
      D.27026 = D.27025 & 2048;
      if (D.27026 != 0) goto <D.27027>; else goto <D.27028>;
      <D.27027>:
      memset (&ctx, 0, 16);
      D.27029 = method->klass;
      D.27030 = D.27029->element_class;
      D.27031 = &D.27030->byval_arg;
      args[0] = D.27031;
      D.27032 = mono_metadata_get_generic_inst (1, &args);
      ctx.method_inst = D.27032;
      m = mono_class_inflate_generic_method (m, &ctx);
      <D.27028>:
      D.27033 = m;
      return D.27033;
    }
  finally
    {
      ctx = {CLOBBER};
      args = {CLOBBER};
    }
}


memset (void * __dest, int __ch, size_t __len)
{
  int D.27038;
  int D.27043;
  void * D.27045;
  long unsigned int D.27046;

  D.27038 = __builtin_constant_p (__len);
  if (D.27038 != 0) goto <D.27039>; else goto <D.27040>;
  <D.27039>:
  if (__len == 0) goto <D.27041>; else goto <D.27042>;
  <D.27041>:
  D.27043 = __builtin_constant_p (__ch);
  if (D.27043 == 0) goto <D.27036>; else goto <D.27044>;
  <D.27044>:
  if (__ch != 0) goto <D.27036>; else goto <D.27037>;
  <D.27036>:
  __warn_memset_zero_len ();
  D.27045 = __dest;
  return D.27045;
  <D.27037>:
  <D.27042>:
  <D.27040>:
  D.27046 = __builtin_object_size (__dest, 0);
  D.27045 = __builtin___memset_chk (__dest, __ch, __len, D.27046);
  return D.27045;
}


mono_compile_assembly (struct MonoAssembly * ass, guint32 opts, const char * aot_options)
{
  unsigned int D.27048;
  struct _IO_FILE * stderr.16;
  char * D.27052;
  struct MonoAotOptions * D.27053;
  gchar * D.27054;
  int D.27055;
  int D.27058;
  int D.27065;
  int D.27068;
  int D.27071;
  <unnamed type> D.27072;
  unsigned int D.27073;
  int mono_use_llvm.17;
  unsigned int D.27077;
  int D.27080;
  unsigned int D.27083;
  guint32 iftmp.18;
  int D.27087;
  guint32 iftmp.19;
  int D.27092;
  guint32 iftmp.20;
  int D.27097;
  const char * D.27099;
  struct MonoImage * D.27100;
  struct MonoAssembly * D.27101;
  const char * D.27102;
  gchar * D.27103;
  const char * D.27104;
  gchar * D.27105;
  gchar * D.27106;
  const short unsigned int * * D.27107;
  const short unsigned int * D.27108;
  char D.27109;
  long unsigned int D.27110;
  long unsigned int D.27111;
  const short unsigned int * D.27112;
  short unsigned int D.27113;
  int D.27114;
  int D.27115;
  struct GPtrArray * D.27128;
  unsigned int D.27129;
  unsigned int D.27130;
  int D.27131;
  int D.27132;
  long unsigned int D.27133;
  long unsigned int D.27134;
  void * D.27135;
  struct MonoMemPool * D.27136;
  long int D.27137;
  long int D.27138;
  int D.27139;
  int D.27142;
  int D.27144;
  int D.27146;
  char * D.27148;
  char * D.27152;
  struct FILE * D.27153;
  struct FILE * D.27154;
  int * D.27157;
  int D.27158;
  char * D.27159;
  struct MonoImageWriter * D.27160;
  int D.27161;
  char * D.27164;
  struct FILE * D.27165;
  gchar * D.27171;
  gchar * D.27173;
  struct FILE * D.27174;
  char * * D.27176;
  struct FILE * D.27177;
  char * D.27180;
  struct MonoImageWriter * D.27181;
  char * D.27182;
  gchar * D.27183;
  struct MonoCompile * * D.27184;
  long unsigned int D.27185;
  long unsigned int D.27186;
  struct MonoCompile * * D.27187;
  struct MonoCompile * D.27188;
  struct MonoMethod * D.27191;
  unsigned int D.27192;
  char * D.27195;
  gchar * D.27196;
  int D.27198;
  struct MonoMethod * D.27201;
  struct GHashTable * D.27202;
  char * D.27203;
  const char * D.27205;
  gchar * D.27206;
  unsigned int i.21;
  unsigned int D.27208;
  int D.27209;
  int D.27214;
  int D.27219;
  int D.27223;
  struct MonoImageWriter * D.27226;
  int D.27227;
  _Bool D.27228;
  int D.27229;
  struct MonoDwarfWriter * D.27230;
  struct MonoDwarfWriter * D.27231;
  gchar * D.27234;
  struct GSList * D.27235;
  int D.27236;
  int D.27241;
  int D.27244;
  unsigned int D.27249;
  unsigned int D.27250;
  _Bool D.27251;
  long int D.27252;
  long int D.27253;
  int D.27258;
  int iftmp.22;
  int D.27260;
  int D.27263;
  int D.27266;
  int D.27267;
  int D.27268;
  int D.27269;
  int D.27270;
  unsigned int D.27271;
  int D.27272;
  unsigned int D.27273;
  int D.27274;
  int D.27275;
  int D.27276;
  int iftmp.23;
  int D.27280;
  int D.27282;
  int iftmp.24;
  int D.27286;
  int D.27288;
  int iftmp.25;
  int D.27290;
  int D.27293;
  int D.27295;
  int iftmp.26;
  int D.27301;
  int D.27303;
  int iftmp.27;
  int D.27309;
  int D.27311;
  int iftmp.28;
  int D.27317;
  int D.27319;
  int iftmp.29;
  int D.27325;
  char * D.27333;
  int D.27337;
  int D.27340;
  const char * D.27343;
  int D.27344;
  int D.27345;
  int D.27346;
  int D.27347;
  int D.27348;
  int D.27349;
  int D.27350;
  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.27048 = opts & 16777216;
      if (D.27048 != 0) goto <D.27049>; else goto <D.27050>;
      <D.27049>:
      stderr.16 = stderr;
      fprintf (stderr.16, "-O=gsharedvt not supported on this platform.\n");
      exit (1);
      <D.27050>:
      D.27052 = image->name;
      printf ("Mono Ahead of Time compiler - compiling assembly %s\n", D.27052);
      acfg = acfg_create (ass, opts);
      D.27053 = &acfg->aot_opts;
      memset (D.27053, 0, 152);
      acfg->aot_opts.write_symbols = 1;
      acfg->aot_opts.ntrampolines = 1024;
      acfg->aot_opts.nrgctx_trampolines = 1024;
      acfg->aot_opts.nimt_trampolines = 128;
      acfg->aot_opts.nrgctx_fetch_trampolines = 128;
      acfg->aot_opts.ngsharedvt_arg_trampolines = 128;
      D.27054 = monoeg_strdup ("");
      acfg->aot_opts.llvm_path = D.27054;
      D.27053 = &acfg->aot_opts;
      mono_aot_parse_options (aot_options, D.27053);
      D.27055 = acfg->aot_opts.static_link;
      if (D.27055 != 0) goto <D.27056>; else goto <D.27057>;
      <D.27056>:
      acfg->aot_opts.autoreg = 1;
      <D.27057>:
      D.27058 = acfg->aot_opts.direct_pinvoke;
      if (D.27058 != 0) goto <D.27059>; else goto <D.27060>;
      <D.27059>:
      D.27055 = acfg->aot_opts.static_link;
      if (D.27055 == 0) goto <D.27061>; else goto <D.27062>;
      <D.27061>:
      stderr.16 = stderr;
      fprintf (stderr.16, "The \'direct-pinvoke\' AOT option also requires the \'static\' AOT option.\n");
      exit (1);
      <D.27062>:
      <D.27060>:
      D.27055 = acfg->aot_opts.static_link;
      if (D.27055 != 0) goto <D.27063>; else goto <D.27064>;
      <D.27063>:
      acfg->aot_opts.asm_writer = 1;
      <D.27064>:
      D.27065 = acfg->aot_opts.soft_debug;
      if (D.27065 != 0) goto <D.27066>; else goto <D.27067>;
      <D.27066>:
      {
        struct MonoDebugOptions * opt;

        opt = mini_get_debug_options ();
        opt->mdb_optimizations = 1;
        opt->gen_seq_points = 1;
        D.27068 = mono_debug_enabled ();
        if (D.27068 == 0) goto <D.27069>; else goto <D.27070>;
        <D.27069>:
        stderr.16 = stderr;
        fprintf (stderr.16, "The soft-debug AOT option requires the --debug option.\n");
        D.27071 = 1;
        return D.27071;
        <D.27070>:
        D.27072 = acfg->flags;
        D.27073 = D.27072 | 4;
        acfg->flags = D.27073;
      }
      <D.27067>:
      mono_use_llvm.17 = mono_use_llvm;
      if (mono_use_llvm.17 != 0) goto <D.27075>; else goto <D.27076>;
      <D.27075>:
      acfg->llvm = 1;
      acfg->aot_opts.asm_writer = 1;
      D.27072 = acfg->flags;
      D.27077 = D.27072 | 1;
      acfg->flags = D.27077;
      D.27065 = acfg->aot_opts.soft_debug;
      if (D.27065 != 0) goto <D.27078>; else goto <D.27079>;
      <D.27078>:
      stderr.16 = stderr;
      fprintf (stderr.16, "The \'soft-debug\' option is not supported when compiling with LLVM.\n");
      exit (1);
      <D.27079>:
      <D.27076>:
      D.27080 = acfg->aot_opts.full_aot;
      if (D.27080 != 0) goto <D.27081>; else goto <D.27082>;
      <D.27081>:
      D.27072 = acfg->flags;
      D.27083 = D.27072 | 2;
      acfg->flags = D.27083;
      <D.27082>:
      load_profile_files (acfg);
      D.27080 = acfg->aot_opts.full_aot;
      if (D.27080 != 0) goto <D.27085>; else goto <D.27086>;
      <D.27085>:
      D.27087 = acfg->aot_opts.ntrampolines;
      iftmp.18 = (guint32) D.27087;
      goto <D.27088>;
      <D.27086>:
      iftmp.18 = 0;
      <D.27088>:
      acfg->num_trampolines[0] = iftmp.18;
      D.27080 = acfg->aot_opts.full_aot;
      if (D.27080 != 0) goto <D.27090>; else goto <D.27091>;
      <D.27090>:
      D.27092 = acfg->aot_opts.nrgctx_trampolines;
      iftmp.19 = (guint32) D.27092;
      goto <D.27093>;
      <D.27091>:
      iftmp.19 = 0;
      <D.27093>:
      acfg->num_trampolines[1] = iftmp.19;
      D.27080 = acfg->aot_opts.full_aot;
      if (D.27080 != 0) goto <D.27095>; else goto <D.27096>;
      <D.27095>:
      D.27097 = acfg->aot_opts.nimt_trampolines;
      iftmp.20 = (guint32) D.27097;
      goto <D.27098>;
      <D.27096>:
      iftmp.20 = 0;
      <D.27098>:
      acfg->num_trampolines[2] = iftmp.20;
      D.27099 = img_writer_get_temp_label_prefix (0B);
      acfg->temp_prefix = D.27099;
      arch_init (acfg);
      D.27100 = acfg->image;
      D.27101 = D.27100->assembly;
      D.27102 = D.27101->aname.name;
      D.27103 = monoeg_g_strdup_printf ("mono_aot_%s_got", D.27102);
      acfg->got_symbol_base = D.27103;
      D.27104 = acfg->llvm_label_prefix;
      D.27100 = acfg->image;
      D.27101 = D.27100->assembly;
      D.27102 = D.27101->aname.name;
      D.27105 = monoeg_g_strdup_printf ("%smono_aot_%s_plt", D.27104, D.27102);
      acfg->plt_symbol = D.27105;
      D.27100 = acfg->image;
      D.27101 = D.27100->assembly;
      D.27102 = D.27101->aname.name;
      D.27106 = monoeg_strdup (D.27102);
      acfg->assembly_name_sym = D.27106;
      p = acfg->got_symbol_base;
      goto <D.26482>;
      <D.26481>:
      D.27107 = __ctype_b_loc ();
      D.27108 = *D.27107;
      D.27109 = *p;
      D.27110 = (long unsigned int) D.27109;
      D.27111 = D.27110 * 2;
      D.27112 = D.27108 + D.27111;
      D.27113 = *D.27112;
      D.27114 = (int) D.27113;
      D.27115 = D.27114 & 8;
      if (D.27115 == 0) goto <D.27116>; else goto <D.27117>;
      <D.27116>:
      D.27109 = *p;
      if (D.27109 != 95) goto <D.27118>; else goto <D.27119>;
      <D.27118>:
      *p = 95;
      <D.27119>:
      <D.27117>:
      p = p + 1;
      <D.26482>:
      D.27109 = *p;
      if (D.27109 != 0) goto <D.26481>; else goto <D.26483>;
      <D.26483>:
      p = acfg->plt_symbol;
      goto <D.26485>;
      <D.26484>:
      D.27107 = __ctype_b_loc ();
      D.27108 = *D.27107;
      D.27109 = *p;
      D.27110 = (long unsigned int) D.27109;
      D.27111 = D.27110 * 2;
      D.27112 = D.27108 + D.27111;
      D.27113 = *D.27112;
      D.27114 = (int) D.27113;
      D.27115 = D.27114 & 8;
      if (D.27115 == 0) goto <D.27120>; else goto <D.27121>;
      <D.27120>:
      D.27109 = *p;
      if (D.27109 != 95) goto <D.27122>; else goto <D.27123>;
      <D.27122>:
      *p = 95;
      <D.27123>:
      <D.27121>:
      p = p + 1;
      <D.26485>:
      D.27109 = *p;
      if (D.27109 != 0) goto <D.26484>; else goto <D.26486>;
      <D.26486>:
      p = acfg->assembly_name_sym;
      goto <D.26488>;
      <D.26487>:
      D.27107 = __ctype_b_loc ();
      D.27108 = *D.27107;
      D.27109 = *p;
      D.27110 = (long unsigned int) D.27109;
      D.27111 = D.27110 * 2;
      D.27112 = D.27108 + D.27111;
      D.27113 = *D.27112;
      D.27114 = (int) D.27113;
      D.27115 = D.27114 & 8;
      if (D.27115 == 0) goto <D.27124>; else goto <D.27125>;
      <D.27124>:
      D.27109 = *p;
      if (D.27109 != 95) goto <D.27126>; else goto <D.27127>;
      <D.27126>:
      *p = 95;
      <D.27127>:
      <D.27125>:
      p = p + 1;
      <D.26488>:
      D.27109 = *p;
      if (D.27109 != 0) goto <D.26487>; else goto <D.26489>;
      <D.26489>:
      acfg->method_index = 1;
      collect_methods (acfg);
      D.27128 = acfg->methods;
      D.27129 = D.27128->len;
      D.27130 = D.27129 + 32;
      D.27131 = (int) D.27130;
      acfg->cfgs_size = D.27131;
      D.27132 = acfg->cfgs_size;
      D.27133 = (long unsigned int) D.27132;
      D.27134 = D.27133 * 8;
      D.27135 = monoeg_malloc0 (D.27134);
      acfg->cfgs = D.27135;
      acfg->plt_offset = 1;
      {
        struct MonoJumpInfo * ji;

        D.27136 = acfg->mempool;
        ji = mono_mempool_alloc0 (D.27136, 1304);
        ji->type = 12;
        D.27100 = acfg->image;
        ji->data.image = D.27100;
        get_got_offset (acfg, ji);
        D.27136 = acfg->mempool;
        ji = mono_mempool_alloc0 (D.27136, 1304);
        ji->type = 39;
        get_got_offset (acfg, ji);
        D.27136 = acfg->mempool;
        ji = mono_mempool_alloc0 (D.27136, 1304);
        ji->type = 42;
        get_got_offset (acfg, ji);
        D.27136 = acfg->mempool;
        ji = mono_mempool_alloc0 (D.27136, 1304);
        ji->type = 47;
        get_got_offset (acfg, ji);
      }
      atv = mono_100ns_ticks ();
      compile_methods (acfg);
      btv = mono_100ns_ticks ();
      D.27137 = btv - atv;
      D.27138 = D.27137 / 10;
      D.27139 = (int) D.27138;
      acfg->stats.jit_time = D.27139;
      atv = mono_100ns_ticks ();
      D.27142 = acfg->aot_opts.asm_only;
      if (D.27142 == 0) goto <D.27143>; else goto <D.27140>;
      <D.27143>:
      D.27144 = acfg->aot_opts.asm_writer;
      if (D.27144 == 0) goto <D.27145>; else goto <D.27140>;
      <D.27145>:
      D.27146 = bin_writer_supported ();
      if (D.27146 != 0) goto <D.27147>; else goto <D.27140>;
      <D.27147>:
      D.27148 = acfg->aot_opts.outfile;
      if (D.27148 != 0B) goto <D.27149>; else goto <D.27150>;
      <D.27149>:
      D.27148 = acfg->aot_opts.outfile;
      outfile_name = monoeg_g_strdup_printf ("%s", D.27148);
      goto <D.27151>;
      <D.27150>:
      D.27100 = acfg->image;
      D.27152 = D.27100->name;
      outfile_name = monoeg_g_strdup_printf ("%s%s", D.27152, ".so");
      <D.27151>:
      tmp_outfile_name = monoeg_g_strdup_printf ("%s.tmp", outfile_name);
      D.27153 = fopen (tmp_outfile_name, "w");
      acfg->fp = D.27153;
      D.27154 = acfg->fp;
      if (D.27154 == 0B) goto <D.27155>; else goto <D.27156>;
      <D.27155>:
      D.27157 = __errno_location ();
      D.27158 = *D.27157;
      D.27159 = strerror (D.27158);
      printf ("Unable to create temporary file \'%s\': %s\n", tmp_outfile_name, D.27159);
      D.27071 = 1;
      return D.27071;
      <D.27156>:
      D.27154 = acfg->fp;
      D.27160 = img_writer_create (D.27154, 1);
      acfg->w = D.27160;
      acfg->use_bin_writer = 1;
      goto <D.27141>;
      <D.27140>:
      D.27161 = acfg->llvm;
      if (D.27161 != 0) goto <D.27162>; else goto <D.27163>;
      <D.27162>:
      D.27164 = acfg->tmpfname;
      D.27165 = fopen (D.27164, "a+");
      acfg->fp = D.27165;
      goto <D.27166>;
      <D.27163>:
      D.27142 = acfg->aot_opts.asm_only;
      if (D.27142 != 0) goto <D.27167>; else goto <D.27168>;
      <D.27167>:
      D.27148 = acfg->aot_opts.outfile;
      if (D.27148 != 0B) goto <D.27169>; else goto <D.27170>;
      <D.27169>:
      D.27148 = acfg->aot_opts.outfile;
      D.27171 = monoeg_g_strdup_printf ("%s", D.27148);
      acfg->tmpfname = D.27171;
      goto <D.27172>;
      <D.27170>:
      D.27100 = acfg->image;
      D.27152 = D.27100->name;
      D.27173 = monoeg_g_strdup_printf ("%s.s", D.27152);
      acfg->tmpfname = D.27173;
      <D.27172>:
      D.27164 = acfg->tmpfname;
      D.27174 = fopen (D.27164, "w+");
      acfg->fp = D.27174;
      goto <D.27175>;
      <D.27168>:
      {
        int i;

        D.27176 = &acfg->tmpfname;
        i = monoeg_g_file_open_tmp ("mono_aot_XXXXXX", D.27176, 0B);
        D.27177 = fdopen (i, "w+");
        acfg->fp = D.27177;
      }
      <D.27175>:
      <D.27166>:
      D.27154 = acfg->fp;
      if (D.27154 == 0B) goto <D.27178>; else goto <D.27179>;
      <D.27178>:
      stderr.16 = stderr;
      D.27164 = acfg->tmpfname;
      D.27157 = __errno_location ();
      D.27158 = *D.27157;
      D.27180 = strerror (D.27158);
      fprintf (stderr.16, "Unable to open file \'%s\': %s\n", D.27164, D.27180);
      D.27071 = 1;
      return D.27071;
      <D.27179>:
      D.27154 = acfg->fp;
      D.27181 = img_writer_create (D.27154, 0);
      acfg->w = D.27181;
      tmp_outfile_name = 0B;
      outfile_name = 0B;
      <D.27141>:
      D.27104 = acfg->llvm_label_prefix;
      D.27182 = acfg->got_symbol_base;
      D.27183 = monoeg_g_strdup_printf ("%s%s", D.27104, D.27182);
      acfg->got_symbol = D.27183;
      i = 0;
      goto <D.26495>;
      <D.26494>:
      D.27184 = acfg->cfgs;
      D.27185 = (long unsigned int) i;
      D.27186 = D.27185 * 8;
      D.27187 = D.27184 + D.27186;
      D.27188 = *D.27187;
      if (D.27188 != 0B) goto <D.27189>; else goto <D.27190>;
      <D.27189>:
      {
        struct MonoCompile * cfg;
        int method_index;

        D.27184 = acfg->cfgs;
        D.27185 = (long unsigned int) i;
        D.27186 = D.27185 * 8;
        D.27187 = D.27184 + D.27186;
        cfg = *D.27187;
        D.27191 = cfg->orig_method;
        D.27192 = get_method_index (acfg, D.27191);
        method_index = (int) D.27192;
        if (0 != 0) goto <D.27193>; else goto <D.27194>;
        <D.27193>:
        D.27104 = acfg->llvm_label_prefix;
        D.27195 = cfg->llvm_method_name;
        D.27196 = monoeg_g_strdup_printf ("%s%s", D.27104, D.27195);
        cfg->asm_symbol = D.27196;
        goto <D.27197>;
        <D.27194>:
        D.27198 = acfg->global_symbols;
        if (D.27198 != 0) goto <D.27199>; else goto <D.27200>;
        <D.27199>:
        D.27201 = cfg->method;
        D.27202 = acfg->method_label_hash;
        D.27203 = get_debug_sym (D.27201, "", D.27202);
        cfg->asm_symbol = D.27203;
        goto <D.27204>;
        <D.27200>:
        D.27205 = acfg->temp_prefix;
        D.27104 = acfg->llvm_label_prefix;
        D.27206 = monoeg_g_strdup_printf ("%s%sm_%x", D.27205, D.27104, method_index);
        cfg->asm_symbol = D.27206;
        <D.27204>:
        <D.27197>:
      }
      <D.27190>:
      i = i + 1;
      <D.26495>:
      i.21 = (unsigned int) i;
      D.27208 = acfg->nmethods;
      if (i.21 < D.27208) goto <D.26494>; else goto <D.26496>;
      <D.26496>:
      D.27209 = acfg->aot_opts.dwarf_debug;
      if (D.27209 != 0) goto <D.27210>; else goto <D.27211>;
      <D.27210>:
      D.27142 = acfg->aot_opts.asm_only;
      if (D.27142 != 0) goto <D.27212>; else goto <D.27213>;
      <D.27212>:
      D.27214 = acfg->aot_opts.gnu_asm;
      if (D.27214 != 0) goto <D.27215>; else goto <D.27216>;
      <D.27215>:
      acfg->gas_line_numbers = 1;
      <D.27216>:
      <D.27213>:
      <D.27211>:
      D.27219 = acfg->aot_opts.nodebug;
      if (D.27219 == 0) goto <D.27217>; else goto <D.27220>;
      <D.27220>:
      D.27209 = acfg->aot_opts.dwarf_debug;
      if (D.27209 != 0) goto <D.27217>; else goto <D.27218>;
      <D.27217>:
      D.27209 = acfg->aot_opts.dwarf_debug;
      if (D.27209 != 0) goto <D.27221>; else goto <D.27222>;
      <D.27221>:
      D.27223 = mono_debug_enabled ();
      if (D.27223 == 0) goto <D.27224>; else goto <D.27225>;
      <D.27224>:
      stderr.16 = stderr;
      fprintf (stderr.16, "The dwarf AOT option requires the --debug option.\n");
      D.27071 = 1;
      return D.27071;
      <D.27225>:
      <D.27222>:
      D.27226 = acfg->w;
      D.27227 = acfg->gas_line_numbers;
      D.27228 = D.27227 == 0;
      D.27229 = (int) D.27228;
      D.27230 = mono_dwarf_writer_create (D.27226, 0B, 0, 0, D.27229);
      acfg->dwarf = D.27230;
      <D.27218>:
      D.27226 = acfg->w;
      img_writer_emit_start (D.27226);
      D.27231 = acfg->dwarf;
      if (D.27231 != 0B) goto <D.27232>; else goto <D.27233>;
      <D.27232>:
      D.27231 = acfg->dwarf;
      D.27100 = acfg->image;
      D.27152 = D.27100->name;
      D.27234 = monoeg_g_path_get_basename (D.27152);
      D.27235 = mono_unwind_get_cie_program ();
      mono_dwarf_writer_emit_base_info (D.27231, D.27234, D.27235);
      <D.27233>:
      D.27236 = acfg->thumb_mixed;
      if (D.27236 != 0) goto <D.27237>; else goto <D.27238>;
      <D.27237>:
      {
        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.27154 = acfg->fp;
            fprintf (D.27154, ".arm\n");
          }
        finally
          {
            symbol = {CLOBBER};
          }
      }
      <D.27238>:
      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.27231 = acfg->dwarf;
      if (D.27231 != 0B) goto <D.27239>; else goto <D.27240>;
      <D.27239>:
      emit_dwarf_info (acfg);
      D.27231 = acfg->dwarf;
      mono_dwarf_writer_close (D.27231);
      <D.27240>:
      emit_mem_end (acfg);
      D.27241 = acfg->need_pt_gnu_stack;
      if (D.27241 != 0) goto <D.27242>; else goto <D.27243>;
      <D.27242>:
      D.27244 = acfg->use_bin_writer;
      if (D.27244 == 0) goto <D.27245>; else goto <D.27246>;
      <D.27245>:
      D.27154 = acfg->fp;
      fprintf (D.27154, "\n.section\t.note.GNU-stack,\"\",@progbits\n");
      <D.27246>:
      <D.27243>:
      btv = mono_100ns_ticks ();
      D.27137 = btv - atv;
      D.27138 = D.27137 / 10;
      D.27139 = (int) D.27138;
      acfg->stats.gen_time = D.27139;
      D.27161 = acfg->llvm;
      if (D.27161 != 0) goto <D.27247>; else goto <D.27248>;
      <D.27247>:
      D.27249 = acfg->got_offset;
      D.27250 = acfg->final_got_size;
      D.27251 = D.27249 > D.27250;
      D.27252 = (long int) D.27251;
      D.27253 = __builtin_expect (D.27252, 0);
      if (D.27253 != 0) goto <D.27254>; else goto <D.27255>;
      <D.27254>:
      monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "aot-compiler.c", 9004, "acfg->got_offset <= acfg->final_got_size");
      <D.27255>:
      <D.27248>:
      D.27161 = acfg->llvm;
      if (D.27161 != 0) goto <D.27256>; else goto <D.27257>;
      <D.27256>:
      D.27258 = acfg->stats.llvm_count;
      D.27260 = acfg->stats.mcount;
      if (D.27260 != 0) goto <D.27261>; else goto <D.27262>;
      <D.27261>:
      D.27258 = acfg->stats.llvm_count;
      D.27263 = D.27258 * 100;
      D.27260 = acfg->stats.mcount;
      iftmp.22 = D.27263 / D.27260;
      goto <D.27264>;
      <D.27262>:
      iftmp.22 = 100;
      <D.27264>:
      sprintf (&llvm_stats_msg, ", LLVM: %d (%d%%)", D.27258, iftmp.22);
      goto <D.27265>;
      <D.27257>:
      strcpy (&llvm_stats_msg, "");
      <D.27265>:
      D.27266 = acfg->stats.code_size;
      D.27267 = acfg->stats.info_size;
      D.27268 = acfg->stats.ex_info_size;
      D.27269 = acfg->stats.unwind_info_size;
      D.27270 = acfg->stats.class_info_size;
      D.27271 = acfg->plt_offset;
      D.27272 = acfg->stats.got_info_size;
      D.27249 = acfg->got_offset;
      D.27273 = D.27249 * 8;
      D.27274 = (int) D.27273;
      D.27275 = 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.27266, D.27267, D.27268, D.27269, D.27270, D.27271, D.27272, D.27274, D.27275);
      D.27276 = acfg->stats.ccount;
      D.27260 = acfg->stats.mcount;
      D.27260 = acfg->stats.mcount;
      if (D.27260 != 0) goto <D.27278>; else goto <D.27279>;
      <D.27278>:
      D.27276 = acfg->stats.ccount;
      D.27280 = D.27276 * 100;
      D.27260 = acfg->stats.mcount;
      iftmp.23 = D.27280 / D.27260;
      goto <D.27281>;
      <D.27279>:
      iftmp.23 = 100;
      <D.27281>:
      D.27282 = acfg->stats.methods_without_got_slots;
      D.27260 = acfg->stats.mcount;
      if (D.27260 != 0) goto <D.27284>; else goto <D.27285>;
      <D.27284>:
      D.27282 = acfg->stats.methods_without_got_slots;
      D.27286 = D.27282 * 100;
      D.27260 = acfg->stats.mcount;
      iftmp.24 = D.27286 / D.27260;
      goto <D.27287>;
      <D.27285>:
      iftmp.24 = 100;
      <D.27287>:
      D.27288 = acfg->stats.direct_calls;
      D.27290 = acfg->stats.all_calls;
      if (D.27290 != 0) goto <D.27291>; else goto <D.27292>;
      <D.27291>:
      D.27288 = acfg->stats.direct_calls;
      D.27293 = D.27288 * 100;
      D.27290 = acfg->stats.all_calls;
      iftmp.25 = D.27293 / D.27290;
      goto <D.27294>;
      <D.27292>:
      iftmp.25 = 100;
      <D.27294>:
      printf ("Compiled: %d/%d (%d%%)%s, No GOT slots: %d (%d%%), Direct calls: %d (%d%%)\n", D.27276, D.27260, iftmp.23, &llvm_stats_msg, D.27282, iftmp.24, D.27288, iftmp.25);
      D.27295 = acfg->stats.genericcount;
      if (D.27295 != 0) goto <D.27296>; else goto <D.27297>;
      <D.27296>:
      D.27295 = acfg->stats.genericcount;
      D.27260 = acfg->stats.mcount;
      if (D.27260 != 0) goto <D.27299>; else goto <D.27300>;
      <D.27299>:
      D.27295 = acfg->stats.genericcount;
      D.27301 = D.27295 * 100;
      D.27260 = acfg->stats.mcount;
      iftmp.26 = D.27301 / D.27260;
      goto <D.27302>;
      <D.27300>:
      iftmp.26 = 100;
      <D.27302>:
      printf ("%d methods are generic (%d%%)\n", D.27295, iftmp.26);
      <D.27297>:
      D.27303 = acfg->stats.abscount;
      if (D.27303 != 0) goto <D.27304>; else goto <D.27305>;
      <D.27304>:
      D.27303 = acfg->stats.abscount;
      D.27260 = acfg->stats.mcount;
      if (D.27260 != 0) goto <D.27307>; else goto <D.27308>;
      <D.27307>:
      D.27303 = acfg->stats.abscount;
      D.27309 = D.27303 * 100;
      D.27260 = acfg->stats.mcount;
      iftmp.27 = D.27309 / D.27260;
      goto <D.27310>;
      <D.27308>:
      iftmp.27 = 100;
      <D.27310>:
      printf ("%d methods contain absolute addresses (%d%%)\n", D.27303, iftmp.27);
      <D.27305>:
      D.27311 = acfg->stats.lmfcount;
      if (D.27311 != 0) goto <D.27312>; else goto <D.27313>;
      <D.27312>:
      D.27311 = acfg->stats.lmfcount;
      D.27260 = acfg->stats.mcount;
      if (D.27260 != 0) goto <D.27315>; else goto <D.27316>;
      <D.27315>:
      D.27311 = acfg->stats.lmfcount;
      D.27317 = D.27311 * 100;
      D.27260 = acfg->stats.mcount;
      iftmp.28 = D.27317 / D.27260;
      goto <D.27318>;
      <D.27316>:
      iftmp.28 = 100;
      <D.27318>:
      printf ("%d methods contain lmf pointers (%d%%)\n", D.27311, iftmp.28);
      <D.27313>:
      D.27319 = acfg->stats.ocount;
      if (D.27319 != 0) goto <D.27320>; else goto <D.27321>;
      <D.27320>:
      D.27319 = acfg->stats.ocount;
      D.27260 = acfg->stats.mcount;
      if (D.27260 != 0) goto <D.27323>; else goto <D.27324>;
      <D.27323>:
      D.27319 = acfg->stats.ocount;
      D.27325 = D.27319 * 100;
      D.27260 = acfg->stats.mcount;
      iftmp.29 = D.27325 / D.27260;
      goto <D.27326>;
      <D.27324>:
      iftmp.29 = 100;
      <D.27326>:
      printf ("%d methods have other problems (%d%%)\n", D.27319, iftmp.29);
      <D.27321>:
      atv = mono_100ns_ticks ();
      D.27226 = acfg->w;
      res = img_writer_emit_writeout (D.27226);
      if (res != 0) goto <D.27327>; else goto <D.27328>;
      <D.27327>:
      acfg_free (acfg);
      D.27071 = res;
      return D.27071;
      <D.27328>:
      D.27244 = acfg->use_bin_writer;
      if (D.27244 != 0) goto <D.27329>; else goto <D.27330>;
      <D.27329>:
      {
        int err;

        err = rename (tmp_outfile_name, outfile_name);
        if (err != 0) goto <D.27331>; else goto <D.27332>;
        <D.27331>:
        D.27157 = __errno_location ();
        D.27158 = *D.27157;
        D.27333 = strerror (D.27158);
        printf ("Unable to rename \'%s\' to \'%s\': %s\n", tmp_outfile_name, outfile_name, D.27333);
        D.27071 = 1;
        return D.27071;
        <D.27332>:
      }
      goto <D.27334>;
      <D.27330>:
      res = compile_asm (acfg);
      if (res != 0) goto <D.27335>; else goto <D.27336>;
      <D.27335>:
      acfg_free (acfg);
      D.27071 = res;
      return D.27071;
      <D.27336>:
      <D.27334>:
      btv = mono_100ns_ticks ();
      D.27137 = btv - atv;
      D.27138 = D.27137 / 10;
      D.27139 = (int) D.27138;
      acfg->stats.link_time = D.27139;
      D.27337 = acfg->aot_opts.stats;
      if (D.27337 != 0) goto <D.27338>; else goto <D.27339>;
      <D.27338>:
      {
        int i;

        printf ("GOT slot distribution:\n");
        i = 0;
        goto <D.26501>;
        <D.26500>:
        D.27340 = acfg->stats.got_slot_types[i];
        if (D.27340 != 0) goto <D.27341>; else goto <D.27342>;
        <D.27341>:
        D.27343 = get_patch_name (i);
        D.27340 = acfg->stats.got_slot_types[i];
        D.27344 = acfg->stats.got_slot_info_sizes[i];
        printf ("\t%s: %d (%d)\n", D.27343, D.27340, D.27344);
        <D.27342>:
        i = i + 1;
        <D.26501>:
        if (i <= 50) goto <D.26500>; else goto <D.26502>;
        <D.26502>:
      }
      <D.27339>:
      D.27345 = acfg->stats.jit_time;
      D.27346 = D.27345 / 1000;
      D.27347 = acfg->stats.gen_time;
      D.27348 = D.27347 / 1000;
      D.27349 = acfg->stats.link_time;
      D.27350 = D.27349 / 1000;
      printf ("JIT time: %d ms, Generation time: %d ms, Assembly+Link time: %d ms.\n", D.27346, D.27348, D.27350);
      acfg_free (acfg);
      D.27071 = 0;
      return D.27071;
    }
  finally
    {
      llvm_stats_msg = {CLOBBER};
    }
}


acfg_create (struct MonoAssembly * ass, guint32 opts)
{
  struct GPtrArray * D.27353;
  struct GHashTable * D.27354;
  struct GHashTable * D.27355;
  struct GHashTable * D.27356;
  void * D.27357;
  struct GHashTable * D.27358;
  void * D.27359;
  struct GHashTable * * D.27360;
  long unsigned int D.27361;
  long unsigned int D.27362;
  struct GHashTable * * D.27363;
  struct GHashTable * D.27364;
  struct GPtrArray * D.27365;
  struct GHashTable * D.27366;
  struct GHashTable * D.27367;
  struct GHashTable * D.27368;
  struct GHashTable * D.27369;
  struct GPtrArray * D.27370;
  struct GPtrArray * D.27371;
  unsigned int D.27372;
  struct MonoMemPool * D.27373;
  struct GPtrArray * D.27374;
  struct GHashTable * D.27375;
  struct GPtrArray * D.27376;
  struct GHashTable * D.27377;
  struct GPtrArray * D.27378;
  struct GHashTable * D.27379;
  struct GHashTable * D.27380;
  struct GHashTable * D.27381;
  struct GHashTable * D.27382;
  struct CRITICAL_SECTION * D.27383;
  struct MonoAotCompile * D.27384;
  struct MonoImage * image;
  struct MonoAotCompile * acfg;
  int i;

  image = ass->image;
  acfg = monoeg_malloc0 (1304);
  D.27353 = monoeg_g_ptr_array_new ();
  acfg->methods = D.27353;
  D.27354 = monoeg_g_hash_table_new (0B, 0B);
  acfg->method_indexes = D.27354;
  D.27355 = monoeg_g_hash_table_new (0B, 0B);
  acfg->method_depth = D.27355;
  D.27356 = monoeg_g_hash_table_new (0B, 0B);
  acfg->plt_offset_to_entry = D.27356;
  D.27357 = monoeg_malloc0 (416);
  acfg->patch_to_plt_entry = D.27357;
  D.27358 = monoeg_g_hash_table_new (mono_patch_info_hash, mono_patch_info_equal);
  acfg->patch_to_got_offset = D.27358;
  D.27359 = monoeg_malloc0 (416);
  acfg->patch_to_got_offset_by_type = D.27359;
  i = 0;
  goto <D.26450>;
  <D.26449>:
  D.27360 = acfg->patch_to_got_offset_by_type;
  D.27361 = (long unsigned int) i;
  D.27362 = D.27361 * 8;
  D.27363 = D.27360 + D.27362;
  D.27364 = monoeg_g_hash_table_new (mono_patch_info_hash, mono_patch_info_equal);
  *D.27363 = D.27364;
  i = i + 1;
  <D.26450>:
  if (i <= 51) goto <D.26449>; else goto <D.26451>;
  <D.26451>:
  D.27365 = monoeg_g_ptr_array_new ();
  acfg->got_patches = D.27365;
  D.27366 = monoeg_g_hash_table_new (0B, 0B);
  acfg->method_to_cfg = D.27366;
  D.27367 = monoeg_g_hash_table_new_full (0B, 0B, 0B, monoeg_g_free);
  acfg->token_info_hash = D.27367;
  D.27368 = monoeg_g_hash_table_new_full (0B, 0B, 0B, monoeg_g_free);
  acfg->method_to_pinvoke_import = D.27368;
  D.27369 = monoeg_g_hash_table_new (0B, 0B);
  acfg->image_hash = D.27369;
  D.27370 = monoeg_g_ptr_array_new ();
  acfg->image_table = D.27370;
  D.27371 = monoeg_g_ptr_array_new ();
  acfg->globals = D.27371;
  acfg->image = image;
  acfg->opts = opts;
  D.27372 = mono_arch_cpu_enumerate_simd_versions ();
  acfg->simd_opts = D.27372;
  D.27373 = mono_mempool_new ();
  acfg->mempool = D.27373;
  D.27374 = monoeg_g_ptr_array_new ();
  acfg->extra_methods = D.27374;
  D.27375 = monoeg_g_hash_table_new (0B, 0B);
  acfg->unwind_info_offsets = D.27375;
  D.27376 = monoeg_g_ptr_array_new ();
  acfg->unwind_ops = D.27376;
  D.27377 = monoeg_g_hash_table_new_full (monoeg_g_str_hash, monoeg_g_str_equal, monoeg_g_free, 0B);
  acfg->method_label_hash = D.27377;
  D.27378 = monoeg_g_ptr_array_new ();
  acfg->method_order = D.27378;
  D.27379 = monoeg_g_hash_table_new (0B, 0B);
  acfg->export_names = D.27379;
  D.27380 = monoeg_g_hash_table_new (0B, 0B);
  acfg->klass_blob_hash = D.27380;
  D.27381 = monoeg_g_hash_table_new (0B, 0B);
  acfg->method_blob_hash = D.27381;
  D.27382 = monoeg_g_hash_table_new (monoeg_g_str_hash, monoeg_g_str_equal);
  acfg->plt_entry_debug_sym_cache = D.27382;
  D.27383 = &acfg->mutex;
  InitializeCriticalSection (D.27383);
  D.27384 = acfg;
  return D.27384;
}


mono_aot_parse_options (const char * aot_options, struct MonoAotOptions * opts)
{
  const gchar * iftmp.30;
  int D.27390;
  const gchar * D.27393;
  gchar * D.27394;
  int D.27396;
  int D.27400;
  int D.27404;
  int D.27408;
  int D.27412;
  int D.27416;
  int D.27420;
  int D.27424;
  const char * D.27427;
  int D.27428;
  int D.27430;
  int D.27434;
  int D.27438;
  int D.27442;
  int D.27446;
  int D.27450;
  int D.27454;
  const char * D.27457;
  int D.27458;
  int D.27460;
  const char * D.27463;
  int D.27464;
  int D.27466;
  const char * D.27469;
  int D.27470;
  int D.27472;
  const char * D.27475;
  int D.27476;
  int D.27478;
  int D.27482;
  const gchar * D.27485;
  gchar * D.27486;
  int D.27488;
  int D.27492;
  int D.27496;
  int D.27500;
  int D.27504;
  int D.27508;
  int D.27512;
  int D.27516;
  int D.27520;
  gchar * D.27523;
  int D.27525;
  const gchar * D.27528;
  gchar * D.27529;
  int D.27531;
  const char * D.27534;
  int D.27536;
  int D.27539;
  int D.27545;
  int D.27547;
  struct _IO_FILE * stderr.31;
  gchar * D.27550;
  int D.27551;
  gchar * * args;
  gchar * * ptr;

  if (aot_options != 0B) goto <D.27387>; else goto <D.27388>;
  <D.27387>:
  iftmp.30 = aot_options;
  goto <D.27389>;
  <D.27388>:
  iftmp.30 = "";
  <D.27389>:
  args = monoeg_g_strsplit (iftmp.30, ",", -1);
  ptr = args;
  goto <D.25823>;
  <D.25822>:
  {
    const char * arg;

    arg = *ptr;
    D.27390 = str_begins_with (arg, "outfile=");
    if (D.27390 != 0) goto <D.27391>; else goto <D.27392>;
    <D.27391>:
    D.27393 = arg + 8;
    D.27394 = monoeg_strdup (D.27393);
    opts->outfile = D.27394;
    goto <D.27395>;
    <D.27392>:
    D.27396 = str_begins_with (arg, "save-temps");
    if (D.27396 != 0) goto <D.27397>; else goto <D.27398>;
    <D.27397>:
    opts->save_temps = 1;
    goto <D.27399>;
    <D.27398>:
    D.27400 = str_begins_with (arg, "keep-temps");
    if (D.27400 != 0) goto <D.27401>; else goto <D.27402>;
    <D.27401>:
    opts->save_temps = 1;
    goto <D.27403>;
    <D.27402>:
    D.27404 = str_begins_with (arg, "write-symbols");
    if (D.27404 != 0) goto <D.27405>; else goto <D.27406>;
    <D.27405>:
    opts->write_symbols = 1;
    goto <D.27407>;
    <D.27406>:
    D.27408 = str_begins_with (arg, "no-write-symbols");
    if (D.27408 != 0) goto <D.27409>; else goto <D.27410>;
    <D.27409>:
    opts->write_symbols = 0;
    goto <D.27411>;
    <D.27410>:
    D.27412 = str_begins_with (arg, "metadata-only");
    if (D.27412 != 0) goto <D.27413>; else goto <D.27414>;
    <D.27413>:
    opts->metadata_only = 1;
    goto <D.27415>;
    <D.27414>:
    D.27416 = str_begins_with (arg, "bind-to-runtime-version");
    if (D.27416 != 0) goto <D.27417>; else goto <D.27418>;
    <D.27417>:
    opts->bind_to_runtime_version = 1;
    goto <D.27419>;
    <D.27418>:
    D.27420 = str_begins_with (arg, "full");
    if (D.27420 != 0) goto <D.27421>; else goto <D.27422>;
    <D.27421>:
    opts->full_aot = 1;
    goto <D.27423>;
    <D.27422>:
    D.27424 = str_begins_with (arg, "threads=");
    if (D.27424 != 0) goto <D.27425>; else goto <D.27426>;
    <D.27425>:
    D.27427 = arg + 8;
    D.27428 = atoi (D.27427);
    opts->nthreads = D.27428;
    goto <D.27429>;
    <D.27426>:
    D.27430 = str_begins_with (arg, "static");
    if (D.27430 != 0) goto <D.27431>; else goto <D.27432>;
    <D.27431>:
    opts->static_link = 1;
    opts->no_dlsym = 1;
    goto <D.27433>;
    <D.27432>:
    D.27434 = str_begins_with (arg, "asmonly");
    if (D.27434 != 0) goto <D.27435>; else goto <D.27436>;
    <D.27435>:
    opts->asm_only = 1;
    goto <D.27437>;
    <D.27436>:
    D.27438 = str_begins_with (arg, "asmwriter");
    if (D.27438 != 0) goto <D.27439>; else goto <D.27440>;
    <D.27439>:
    opts->asm_writer = 1;
    goto <D.27441>;
    <D.27440>:
    D.27442 = str_begins_with (arg, "nodebug");
    if (D.27442 != 0) goto <D.27443>; else goto <D.27444>;
    <D.27443>:
    opts->nodebug = 1;
    goto <D.27445>;
    <D.27444>:
    D.27446 = str_begins_with (arg, "dwarfdebug");
    if (D.27446 != 0) goto <D.27447>; else goto <D.27448>;
    <D.27447>:
    opts->dwarf_debug = 1;
    goto <D.27449>;
    <D.27448>:
    D.27450 = str_begins_with (arg, "nopagetrampolines");
    if (D.27450 != 0) goto <D.27451>; else goto <D.27452>;
    <D.27451>:
    opts->use_trampolines_page = 0;
    goto <D.27453>;
    <D.27452>:
    D.27454 = str_begins_with (arg, "ntrampolines=");
    if (D.27454 != 0) goto <D.27455>; else goto <D.27456>;
    <D.27455>:
    D.27457 = arg + 13;
    D.27458 = atoi (D.27457);
    opts->ntrampolines = D.27458;
    goto <D.27459>;
    <D.27456>:
    D.27460 = str_begins_with (arg, "nrgctx-trampolines=");
    if (D.27460 != 0) goto <D.27461>; else goto <D.27462>;
    <D.27461>:
    D.27463 = arg + 19;
    D.27464 = atoi (D.27463);
    opts->nrgctx_trampolines = D.27464;
    goto <D.27465>;
    <D.27462>:
    D.27466 = str_begins_with (arg, "nimt-trampolines=");
    if (D.27466 != 0) goto <D.27467>; else goto <D.27468>;
    <D.27467>:
    D.27469 = arg + 17;
    D.27470 = atoi (D.27469);
    opts->nimt_trampolines = D.27470;
    goto <D.27471>;
    <D.27468>:
    D.27472 = str_begins_with (arg, "ngsharedvt-trampolines=");
    if (D.27472 != 0) goto <D.27473>; else goto <D.27474>;
    <D.27473>:
    D.27475 = arg + 23;
    D.27476 = atoi (D.27475);
    opts->ngsharedvt_arg_trampolines = D.27476;
    goto <D.27477>;
    <D.27474>:
    D.27478 = str_begins_with (arg, "autoreg");
    if (D.27478 != 0) goto <D.27479>; else goto <D.27480>;
    <D.27479>:
    opts->autoreg = 1;
    goto <D.27481>;
    <D.27480>:
    D.27482 = str_begins_with (arg, "tool-prefix=");
    if (D.27482 != 0) goto <D.27483>; else goto <D.27484>;
    <D.27483>:
    D.27485 = arg + 12;
    D.27486 = monoeg_strdup (D.27485);
    opts->tool_prefix = D.27486;
    goto <D.27487>;
    <D.27484>:
    D.27488 = str_begins_with (arg, "soft-debug");
    if (D.27488 != 0) goto <D.27489>; else goto <D.27490>;
    <D.27489>:
    opts->soft_debug = 1;
    goto <D.27491>;
    <D.27490>:
    D.27492 = str_begins_with (arg, "direct-pinvoke");
    if (D.27492 != 0) goto <D.27493>; else goto <D.27494>;
    <D.27493>:
    opts->direct_pinvoke = 1;
    goto <D.27495>;
    <D.27494>:
    D.27496 = str_begins_with (arg, "direct-icalls");
    if (D.27496 != 0) goto <D.27497>; else goto <D.27498>;
    <D.27497>:
    opts->direct_icalls = 1;
    goto <D.27499>;
    <D.27498>:
    D.27500 = str_begins_with (arg, "no-direct-calls");
    if (D.27500 != 0) goto <D.27501>; else goto <D.27502>;
    <D.27501>:
    opts->no_direct_calls = 1;
    goto <D.27503>;
    <D.27502>:
    D.27504 = str_begins_with (arg, "print-skipped");
    if (D.27504 != 0) goto <D.27505>; else goto <D.27506>;
    <D.27505>:
    opts->print_skipped_methods = 1;
    goto <D.27507>;
    <D.27506>:
    D.27508 = str_begins_with (arg, "stats");
    if (D.27508 != 0) goto <D.27509>; else goto <D.27510>;
    <D.27509>:
    opts->stats = 1;
    goto <D.27511>;
    <D.27510>:
    D.27512 = str_begins_with (arg, "no-instances");
    if (D.27512 != 0) goto <D.27513>; else goto <D.27514>;
    <D.27513>:
    opts->no_instances = 1;
    goto <D.27515>;
    <D.27514>:
    D.27516 = str_begins_with (arg, "log-generics");
    if (D.27516 != 0) goto <D.27517>; else goto <D.27518>;
    <D.27517>:
    opts->log_generics = 1;
    goto <D.27519>;
    <D.27518>:
    D.27520 = str_begins_with (arg, "mtriple=");
    if (D.27520 != 0) goto <D.27521>; else goto <D.27522>;
    <D.27521>:
    D.27393 = arg + 8;
    D.27523 = monoeg_strdup (D.27393);
    opts->mtriple = D.27523;
    goto <D.27524>;
    <D.27522>:
    D.27525 = str_begins_with (arg, "llvm-path=");
    if (D.27525 != 0) goto <D.27526>; else goto <D.27527>;
    <D.27526>:
    D.27528 = arg + 10;
    D.27529 = monoeg_strdup (D.27528);
    opts->llvm_path = D.27529;
    goto <D.27530>;
    <D.27527>:
    D.27531 = str_begins_with (arg, "readonly-value=");
    if (D.27531 != 0) goto <D.27532>; else goto <D.27533>;
    <D.27532>:
    D.27534 = arg + 15;
    add_readonly_value (opts, D.27534);
    goto <D.27535>;
    <D.27533>:
    D.27536 = str_begins_with (arg, "info");
    if (D.27536 != 0) goto <D.27537>; else goto <D.27538>;
    <D.27537>:
    printf ("AOT target setup: %s.\n", "POWERPC64 (!mono ilp32)");
    exit (0);
    <D.27538>:
    D.27539 = str_begins_with (arg, "gc-maps");
    if (D.27539 != 0) goto <D.27540>; else goto <D.27541>;
    <D.27540>:
    mini_gc_enable_gc_maps_for_aot ();
    goto <D.27542>;
    <D.27541>:
    D.27545 = str_begins_with (arg, "help");
    if (D.27545 != 0) goto <D.27543>; else goto <D.27546>;
    <D.27546>:
    D.27547 = str_begins_with (arg, "?");
    if (D.27547 != 0) goto <D.27543>; else goto <D.27544>;
    <D.27543>:
    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.27544>:
    stderr.31 = stderr;
    fprintf (stderr.31, "AOT : Unknown argument \'%s\'.\n", arg);
    exit (1);
    <D.27542>:
    <D.27535>:
    <D.27530>:
    <D.27524>:
    <D.27519>:
    <D.27515>:
    <D.27511>:
    <D.27507>:
    <D.27503>:
    <D.27499>:
    <D.27495>:
    <D.27491>:
    <D.27487>:
    <D.27481>:
    <D.27477>:
    <D.27471>:
    <D.27465>:
    <D.27459>:
    <D.27453>:
    <D.27449>:
    <D.27445>:
    <D.27441>:
    <D.27437>:
    <D.27433>:
    <D.27429>:
    <D.27423>:
    <D.27419>:
    <D.27415>:
    <D.27411>:
    <D.27407>:
    <D.27403>:
    <D.27399>:
    <D.27395>:
  }
  ptr = ptr + 8;
  <D.25823>:
  if (ptr != 0B) goto <D.27549>; else goto <D.25824>;
  <D.27549>:
  D.27550 = *ptr;
  if (D.27550 != 0B) goto <D.25822>; else goto <D.25824>;
  <D.25824>:
  D.27551 = opts->use_trampolines_page;
  if (D.27551 != 0) goto <D.27552>; else goto <D.27553>;
  <D.27552>:
  opts->ntrampolines = 0;
  opts->nrgctx_trampolines = 0;
  opts->nimt_trampolines = 0;
  opts->ngsharedvt_arg_trampolines = 0;
  <D.27553>:
  monoeg_g_strfreev (args);
}


atoi (const char * __nptr)
{
  int D.27554;
  long int D.27555;

  D.27555 = strtol (__nptr, 0B, 10);
  D.27554 = (int) D.27555;
  return D.27554;
}


add_readonly_value (struct MonoAotOptions * opts, const char * val)
{
  struct _IO_FILE * stderr.32;
  long int tval.33;
  long int val.34;
  long int D.27564;
  long int D.27565;
  long unsigned int D.27566;
  void * D.27567;
  char * D.27568;
  long unsigned int D.27569;
  int D.27570;
  int D.27573;
  unsigned char D.27574;
  int D.27576;
  int D.27579;
  short unsigned int D.27580;
  int D.27582;
  int D.27585;
  unsigned int D.27586;
  struct ReadOnlyValue * readonly_values.35;
  struct ReadOnlyValue * rdv;
  const char * fval;
  const char * tval;

  fval = strrchr (val, 47);
  if (fval == 0B) goto <D.27557>; else goto <D.27558>;
  <D.27557>:
  stderr.32 = stderr;
  fprintf (stderr.32, "AOT : invalid format for readonly field \'%s\', missing /.\n", val);
  exit (1);
  <D.27558>:
  tval = strrchr (val, 61);
  if (tval == 0B) goto <D.27560>; else goto <D.27561>;
  <D.27560>:
  stderr.32 = stderr;
  fprintf (stderr.32, "AOT : invalid format for readonly field \'%s\', missing =.\n", val);
  exit (1);
  <D.27561>:
  rdv = monoeg_malloc0 (32);
  tval.33 = (long int) tval;
  val.34 = (long int) val;
  D.27564 = tval.33 - val.34;
  D.27565 = D.27564 + 1;
  D.27566 = (long unsigned int) D.27565;
  D.27567 = monoeg_malloc0 (D.27566);
  rdv->name = D.27567;
  D.27568 = rdv->name;
  tval.33 = (long int) tval;
  val.34 = (long int) val;
  D.27564 = tval.33 - val.34;
  D.27569 = (long unsigned int) D.27564;
  memcpy (D.27568, val, D.27569);
  tval = tval + 1;
  fval = fval + 1;
  D.27570 = strncmp (tval, "i1", 2);
  if (D.27570 == 0) goto <D.27571>; else goto <D.27572>;
  <D.27571>:
  D.27573 = atoi (fval);
  D.27574 = (unsigned char) D.27573;
  rdv->value.i1 = D.27574;
  rdv->type = 4;
  goto <D.27575>;
  <D.27572>:
  D.27576 = strncmp (tval, "i2", 2);
  if (D.27576 == 0) goto <D.27577>; else goto <D.27578>;
  <D.27577>:
  D.27579 = atoi (fval);
  D.27580 = (short unsigned int) D.27579;
  rdv->value.i2 = D.27580;
  rdv->type = 6;
  goto <D.27581>;
  <D.27578>:
  D.27582 = strncmp (tval, "i4", 2);
  if (D.27582 == 0) goto <D.27583>; else goto <D.27584>;
  <D.27583>:
  D.27585 = atoi (fval);
  D.27586 = (unsigned int) D.27585;
  rdv->value.i4 = D.27586;
  rdv->type = 8;
  goto <D.27587>;
  <D.27584>:
  stderr.32 = stderr;
  fprintf (stderr.32, "AOT : unsupported type for readonly field \'%s\'.\n", tval);
  exit (1);
  <D.27587>:
  <D.27581>:
  <D.27575>:
  readonly_values.35 = readonly_values;
  rdv->next = readonly_values.35;
  readonly_values = rdv;
}


str_begins_with (const char * str1, const char * str2)
{
  long unsigned int D.27589;
  gboolean D.27590;
  long unsigned int D.27591;
  int D.27592;
  _Bool D.27593;
  int len;

  D.27589 = strlen (str2);
  len = (int) D.27589;
  D.27591 = (long unsigned int) len;
  D.27592 = strncmp (str1, str2, D.27591);
  D.27593 = D.27592 == 0;
  D.27590 = (gboolean) D.27593;
  return D.27590;
}


load_profile_files (struct MonoAotCompile * acfg)
{
  const gchar * D.27595;
  struct MonoImage * D.27596;
  const char * D.27597;
  int D.27598;
  _Bool D.27601;
  long int D.27602;
  long int D.27603;
  int D.26007;
  int iftmp.36;
  int D.26006;
  const char[7] * D.27612;
  unsigned char D.27613;
  int D.27614;
  unsigned char D.27615;
  int D.27616;
  const unsigned char * D.27621;
  unsigned char D.27622;
  int D.27623;
  const unsigned char * D.27624;
  unsigned char D.27625;
  int D.27626;
  const unsigned char * D.27631;
  unsigned char D.27632;
  int D.27633;
  const unsigned char * D.27634;
  unsigned char D.27635;
  int D.27636;
  const unsigned char * D.27641;
  unsigned char D.27642;
  int D.27643;
  const unsigned char * D.27644;
  unsigned char D.27645;
  int D.27646;
  char * D.27648;
  char[1024] * name.37;
  char D.27651;
  long unsigned int D.27654;
  long unsigned int D.27655;
  unsigned int D.27658;
  unsigned int D.27661;
  unsigned int D.27662;
  struct GPtrArray * D.27663;
  void * * D.27664;
  long unsigned int D.27665;
  long unsigned int D.27666;
  void * * D.27667;
  void * D.27668;
  long unsigned int D.27669;
  void * D.27670;
  unsigned int i.38;
  unsigned int D.27674;
  <unnamed-unsigned:24> D.27682;
  int D.27683;
  void * D.27684;
  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.26017>:
      D.27595 = monoeg_g_get_home_dir ();
      D.27596 = acfg->image;
      D.27597 = D.27596->assembly_name;
      tmp = monoeg_g_strdup_printf ("%s/.mono/aot-profile-data/%s-%d", D.27595, D.27597, file_index);
      D.27598 = monoeg_g_file_test (tmp, 1);
      if (D.27598 == 0) goto <D.27599>; else goto <D.27600>;
      <D.27599>:
      monoeg_g_free (tmp);
      goto <D.25998>;
      <D.27600>:
      infile = fopen (tmp, "r");
      D.27601 = infile == 0B;
      D.27602 = (long int) D.27601;
      D.27603 = __builtin_expect (D.27602, 0);
      if (D.27603 != 0) goto <D.27604>; else goto <D.27605>;
      <D.27604>:
      monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "aot-compiler.c", 6785, "infile");
      <D.27605>:
      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.27606>; else goto <D.27608>;
      <D.27608>:
      {
        size_t __s1_len;
        size_t __s2_len;

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

          __s2 = &ver;
          D.27612 = "#VER:2";
          D.27613 = MEM[(const unsigned char *)D.27612];
          D.27614 = (int) D.27613;
          D.27615 = *__s2;
          D.27616 = (int) D.27615;
          __result = D.27614 - D.27616;
          {
            if (__s2_len != 0) goto <D.27617>; else goto <D.27618>;
            <D.27617>:
            if (__result == 0) goto <D.27619>; else goto <D.27620>;
            <D.27619>:
            D.27621 = &MEM[(void *)"#VER:2" + 1B];
            D.27622 = *D.27621;
            D.27623 = (int) D.27622;
            D.27624 = __s2 + 1;
            D.27625 = *D.27624;
            D.27626 = (int) D.27625;
            __result = D.27623 - D.27626;
            if (__s2_len > 1) goto <D.27627>; else goto <D.27628>;
            <D.27627>:
            if (__result == 0) goto <D.27629>; else goto <D.27630>;
            <D.27629>:
            D.27631 = &MEM[(void *)"#VER:2" + 2B];
            D.27632 = *D.27631;
            D.27633 = (int) D.27632;
            D.27634 = __s2 + 2;
            D.27635 = *D.27634;
            D.27636 = (int) D.27635;
            __result = D.27633 - D.27636;
            if (__s2_len > 2) goto <D.27637>; else goto <D.27638>;
            <D.27637>:
            if (__result == 0) goto <D.27639>; else goto <D.27640>;
            <D.27639>:
            D.27641 = &MEM[(void *)"#VER:2" + 3B];
            D.27642 = *D.27641;
            D.27643 = (int) D.27642;
            D.27644 = __s2 + 3;
            D.27645 = *D.27644;
            D.27646 = (int) D.27645;
            __result = D.27643 - D.27646;
            <D.27640>:
            <D.27638>:
            <D.27630>:
            <D.27628>:
            <D.27620>:
            <D.27618>:
          }
          D.26006 = __result;
        }
        iftmp.36 = -D.26006;
        goto <D.27647>;
        <D.27611>:
        iftmp.36 = __builtin_strcmp (&ver, "#VER:2");
        <D.27647>:
        D.26007 = iftmp.36;
      }
      if (D.26007 != 0) goto <D.27606>; else goto <D.27607>;
      <D.27606>:
      printf ("Profile file has wrong version or invalid.\n");
      fclose (infile);
      // predicted unlikely by continue predictor.
      goto <D.26008>;
      <D.27607>:
      <D.26016>:
      {
        char name[1024];
        struct MonoMethodDesc * desc;
        struct MonoMethod * method;

        try
          {
            D.27648 = fgets (&name, 1023, infile);
            if (D.27648 == 0B) goto <D.26012>; else goto <D.27649>;
            <D.27649>:
            name.37 = &name;
            D.27651 = MEM[(const char *)name.37];
            if (D.27651 != 0) goto <D.27652>; else goto <D.27653>;
            <D.27652>:
            D.27654 = strlen (&name);
            D.27655 = D.27654 + 18446744073709551615;
            name[D.27655] = 0;
            <D.27653>:
            desc = mono_method_desc_new (&name, 1);
            D.27596 = acfg->image;
            method = mono_method_desc_search_in_image (desc, D.27596);
            if (method != 0B) goto <D.27656>; else goto <D.27657>;
            <D.27656>:
            D.27658 = mono_method_get_token (method);
            if (D.27658 != 0) goto <D.27659>; else goto <D.27660>;
            <D.27659>:
            token = mono_method_get_token (method);
            D.27661 = token & 16777215;
            D.27662 = D.27661 + 4294967295;
            method_index = (int) D.27662;
            found = 0;
            i = 0;
            goto <D.26015>;
            <D.26014>:
            D.27663 = acfg->method_order;
            D.27664 = D.27663->pdata;
            D.27665 = (long unsigned int) i;
            D.27666 = D.27665 * 8;
            D.27667 = D.27664 + D.27666;
            D.27668 = *D.27667;
            D.27669 = (long unsigned int) method_index;
            D.27670 = (void *) D.27669;
            if (D.27668 == D.27670) goto <D.27671>; else goto <D.27672>;
            <D.27671>:
            found = 1;
            goto <D.26013>;
            <D.27672>:
            i = i + 1;
            <D.26015>:
            i.38 = (unsigned int) i;
            D.27663 = acfg->method_order;
            D.27674 = D.27663->len;
            if (i.38 < D.27674) goto <D.26014>; else goto <D.26013>;
            <D.26013>:
            if (found == 0) goto <D.27675>; else goto <D.27676>;
            <D.27675>:
            D.27663 = acfg->method_order;
            D.27669 = (long unsigned int) method_index;
            D.27670 = (void *) D.27669;
            monoeg_g_ptr_array_add (D.27663, D.27670);
            <D.27676>:
            goto <D.27677>;
            <D.27660>:
            <D.27677>:
            <D.27657>:
          }
        finally
          {
            name = {CLOBBER};
          }
      }
      goto <D.26016>;
      <D.26012>:
      fclose (infile);
      <D.26008>:
      goto <D.26017>;
      <D.25998>:
      unordered = 0B;
      method_index = 0;
      goto <D.26022>;
      <D.26021>:
      found = 0;
      i = 0;
      goto <D.26020>;
      <D.26019>:
      D.27663 = acfg->method_order;
      D.27664 = D.27663->pdata;
      D.27665 = (long unsigned int) i;
      D.27666 = D.27665 * 8;
      D.27667 = D.27664 + D.27666;
      D.27668 = *D.27667;
      D.27669 = (long unsigned int) method_index;
      D.27670 = (void *) D.27669;
      if (D.27668 == D.27670) goto <D.27678>; else goto <D.27679>;
      <D.27678>:
      found = 1;
      goto <D.26018>;
      <D.27679>:
      i = i + 1;
      <D.26020>:
      i.38 = (unsigned int) i;
      D.27663 = acfg->method_order;
      D.27674 = D.27663->len;
      if (i.38 < D.27674) goto <D.26019>; else goto <D.26018>;
      <D.26018>:
      if (found == 0) goto <D.27680>; else goto <D.27681>;
      <D.27680>:
      D.27669 = (long unsigned int) method_index;
      D.27670 = (void *) D.27669;
      unordered = monoeg_g_list_prepend (unordered, D.27670);
      <D.27681>:
      method_index = method_index + 1;
      <D.26022>:
      D.27596 = acfg->image;
      D.27682 = D.27596->tables[6].rows;
      D.27683 = (int) D.27682;
      if (D.27683 > method_index) goto <D.26021>; else goto <D.26023>;
      <D.26023>:
      unordered = monoeg_g_list_reverse (unordered);
      l = unordered;
      goto <D.26025>;
      <D.26024>:
      D.27663 = acfg->method_order;
      D.27684 = l->data;
      monoeg_g_ptr_array_add (D.27663, D.27684);
      l = l->next;
      <D.26025>:
      if (l != 0B) goto <D.26024>; else goto <D.26026>;
      <D.26026>:
    }
  finally
    {
      ver = {CLOBBER};
    }
}


fgets (char * restrict __s, int __n, struct FILE * restrict __stream)
{
  long unsigned int D.27687;
  int D.27692;
  char * D.27694;
  long unsigned int D.27695;
  long unsigned int D.27696;
  long unsigned int D.27697;
  long unsigned int D.27700;

  D.27687 = __builtin_object_size (__s, 1);
  if (D.27687 != 18446744073709551615) goto <D.27688>; else goto <D.27689>;
  <D.27688>:
  D.27692 = __builtin_constant_p (__n);
  if (D.27692 == 0) goto <D.27690>; else goto <D.27693>;
  <D.27693>:
  if (__n <= 0) goto <D.27690>; else goto <D.27691>;
  <D.27690>:
  D.27695 = __builtin_object_size (__s, 1);
  D.27694 = __fgets_chk (__s, D.27695, __n, __stream);
  return D.27694;
  <D.27691>:
  D.27696 = (long unsigned int) __n;
  D.27697 = __builtin_object_size (__s, 1);
  if (D.27696 > D.27697) goto <D.27698>; else goto <D.27699>;
  <D.27698>:
  D.27700 = __builtin_object_size (__s, 1);
  D.27694 = __fgets_chk_warn (__s, D.27700, __n, __stream);
  return D.27694;
  <D.27699>:
  <D.27689>:
  D.27694 = __fgets_alias (__s, __n, __stream);
  return D.27694;
}


arch_init (struct MonoAotCompile * acfg)
{
  struct GString * D.27702;
  struct GString * D.27703;

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


collect_methods (struct MonoAotCompile * acfg)
{
  int D.27704;
  int D.27705;
  struct MonoImage * D.27706;
  char * D.27709;
  struct MonoClass * D.27710;
  int D.27711;
  short unsigned int D.27714;
  int D.27715;
  int D.27716;
  int check_for_pending_exc.39;
  int D.27720;
  int D.27721;
  <unnamed-unsigned:24> D.27722;
  int D.27723;
  int D.27724;
  int D.27725;
  unsigned int D.27726;
  unsigned int D.27727;
  long unsigned int D.27734;
  long unsigned int D.27735;
  struct MonoClass * D.27737;
  struct MonoGenericContainer * D.27738;
  int mindex;
  int i;
  struct MonoImage * image;

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

    D.27704 = i + 1;
    D.27705 = D.27704 | 100663296;
    token = (guint32) D.27705;
    D.27706 = acfg->image;
    method = mono_get_method (D.27706, token, 0B);
    if (method == 0B) goto <D.27707>; else goto <D.27708>;
    <D.27707>:
    D.27709 = image->name;
    printf ("Failed to load method 0x%x from \'%s\'.\n", token, D.27709);
    exit (1);
    <D.27708>:
    D.27710 = method->klass;
    mono_class_setup_methods (D.27710);
    D.27711 = acfg->aot_opts.full_aot;
    if (D.27711 != 0) goto <D.27712>; else goto <D.27713>;
    <D.27712>:
    D.27714 = method->iflags;
    D.27715 = (int) D.27714;
    D.27716 = D.27715 & 4096;
    if (D.27716 != 0) goto <D.27717>; else goto <D.27718>;
    <D.27717>:
    {
      struct MonoMethod * wrapper;

      check_for_pending_exc.39 = check_for_pending_exc;
      wrapper = mono_marshal_get_native_wrapper (method, check_for_pending_exc.39, 1);
      method = wrapper;
    }
    <D.27718>:
    <D.27713>:
    add_method_with_index (acfg, method, i, 0);
    D.27720 = acfg->method_index;
    D.27721 = D.27720 + 1;
    acfg->method_index = D.27721;
  }
  i = i + 1;
  <D.26398>:
  D.27722 = image->tables[6].rows;
  D.27723 = (int) D.27722;
  if (D.27723 > i) goto <D.26397>; else goto <D.26399>;
  <D.26399>:
  mindex = 0;
  goto <D.26405>;
  <D.26404>:
  {
    struct MonoMethod * method;
    guint32 token;

    D.27724 = mindex + 1;
    D.27725 = D.27724 | 100663296;
    token = (guint32) D.27725;
    D.27726 = acfg->opts;
    D.27727 = D.27726 & 16777216;
    if (D.27727 == 0) goto <D.27728>; else goto <D.27729>;
    <D.27728>:
    // predicted unlikely by continue predictor.
    goto <D.26402>;
    <D.27729>:
    D.27706 = acfg->image;
    method = mono_get_method (D.27706, token, 0B);
    if (method == 0B) goto <D.27730>; else goto <D.27731>;
    <D.27730>:
    // predicted unlikely by continue predictor.
    goto <D.26402>;
    <D.27731>:
    D.27734 = BIT_FIELD_REF <*method, 64, 256>;
    D.27735 = D.27734 & 2048;
    if (D.27735 != 0) goto <D.27732>; else goto <D.27736>;
    <D.27736>:
    D.27737 = method->klass;
    D.27738 = D.27737->generic_container;
    if (D.27738 != 0B) goto <D.27732>; else goto <D.27733>;
    <D.27732>:
    {
      struct MonoMethod * gshared;

      gshared = mini_get_shared_method_full (method, 1, 1);
      add_extra_method (acfg, gshared);
    }
    <D.27733>:
  }
  <D.26402>:
  mindex = mindex + 1;
  <D.26405>:
  D.27722 = image->tables[6].rows;
  D.27723 = (int) D.27722;
  if (D.27723 > mindex) goto <D.26404>; else goto <D.26406>;
  <D.26406>:
  add_generic_instances (acfg);
  D.27711 = acfg->aot_opts.full_aot;
  if (D.27711 != 0) goto <D.27739>; else goto <D.27740>;
  <D.27739>:
  add_wrappers (acfg);
  <D.27740>:
}


add_method_with_index (struct MonoAotCompile * acfg, struct MonoMethod * method, int index, gboolean extra)
{
  _Bool D.27741;
  long int D.27742;
  long int D.27743;
  struct GHashTable * D.27746;
  void * D.27747;
  struct GPtrArray * D.27750;
  int D.27751;
  long unsigned int D.27752;
  void * D.27753;
  unsigned int D.27754;
  unsigned int D.27755;
  long unsigned int D.27758;
  long unsigned int D.27759;
  struct GPtrArray * D.27761;

  D.27741 = method == 0B;
  D.27742 = (long int) D.27741;
  D.27743 = __builtin_expect (D.27742, 0);
  if (D.27743 != 0) goto <D.27744>; else goto <D.27745>;
  <D.27744>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "aot-compiler.c", 2994, "method");
  <D.27745>:
  D.27746 = acfg->method_indexes;
  D.27747 = monoeg_g_hash_table_lookup (D.27746, method);
  if (D.27747 == 0B) goto <D.27748>; else goto <D.27749>;
  <D.27748>:
  D.27750 = acfg->methods;
  monoeg_g_ptr_array_add (D.27750, method);
  D.27746 = acfg->method_indexes;
  D.27751 = index + 1;
  D.27752 = (long unsigned int) D.27751;
  D.27753 = (void *) D.27752;
  monoeg_g_hash_table_insert_replace (D.27746, method, D.27753, 0);
  D.27750 = acfg->methods;
  D.27754 = D.27750->len;
  D.27755 = D.27754 + 1;
  acfg->nmethods = D.27755;
  <D.27749>:
  D.27758 = BIT_FIELD_REF <*method, 64, 256>;
  D.27759 = D.27758 & 124;
  if (D.27759 != 0) goto <D.27756>; else goto <D.27760>;
  <D.27760>:
  if (extra != 0) goto <D.27756>; else goto <D.27757>;
  <D.27756>:
  D.27761 = acfg->extra_methods;
  monoeg_g_ptr_array_add (D.27761, method);
  <D.27757>:
}


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.27762;
  int D.27765;
  char * D.27768;

  D.27762 = mono_method_is_generic_sharable_full (method, 0, 1, 0);
  if (D.27762 != 0) goto <D.27763>; else goto <D.27764>;
  <D.27763>:
  method = mini_get_shared_method (method);
  <D.27764>:
  D.27765 = acfg->aot_opts.log_generics;
  if (D.27765 != 0) goto <D.27766>; else goto <D.27767>;
  <D.27766>:
  D.27768 = mono_method_full_name (method, 1);
  printf ("%*sAdding method %s.\n", depth, "", D.27768);
  <D.27767>:
  add_method_full (acfg, method, 1, depth);
}


add_method_full (struct MonoAotCompile * acfg, struct MonoMethod * method, gboolean extra, int depth)
{
  struct GHashTable * D.27769;
  void * D.27770;
  long int D.27771;
  int D.27774;
  struct GPtrArray * D.27775;
  long unsigned int D.27776;
  void * D.27777;
  struct GHashTable * D.27778;
  long unsigned int D.27779;
  void * D.27780;
  int D.27781;
  int D.27782;
  int index;

  D.27769 = acfg->method_indexes;
  D.27770 = monoeg_g_hash_table_lookup (D.27769, method);
  D.27771 = (long int) D.27770;
  index = (int) D.27771;
  if (index != 0) goto <D.27772>; else goto <D.27773>;
  <D.27772>:
  D.27774 = index + -1;
  return D.27774;
  <D.27773>:
  index = acfg->method_index;
  add_method_with_index (acfg, method, index, extra);
  D.27775 = acfg->method_order;
  D.27776 = (long unsigned int) index;
  D.27777 = (void *) D.27776;
  monoeg_g_ptr_array_add (D.27775, D.27777);
  D.27778 = acfg->method_depth;
  D.27779 = (long unsigned int) depth;
  D.27780 = (void *) D.27779;
  monoeg_g_hash_table_insert_replace (D.27778, method, D.27780, 0);
  D.27781 = acfg->method_index;
  D.27782 = D.27781 + 1;
  acfg->method_index = D.27782;
  D.27774 = index;
  return D.27774;
}


add_generic_instances (struct MonoAotCompile * acfg)
{
  int D.27784;
  int D.27787;
  int D.27788;
  struct MonoImage * D.27789;
  struct MonoClass * D.27792;
  struct MonoImage * D.27793;
  struct MonoGenericInst * D.27798;
  long unsigned int D.27801;
  long unsigned int D.27802;
  struct MonoGenericInst * D.27807;
  long unsigned int D.27810;
  long unsigned int D.27811;
  struct MonoType * D.27818;
  int D.27819;
  unsigned char D.27821;
  int D.27823;
  <unnamed-unsigned:22> D.27826;
  int D.27827;
  int D.27832;
  int D.27835;
  long unsigned int D.27842;
  long unsigned int D.27843;
  int D.27847;
  long unsigned int D.27850;
  long unsigned int D.27851;
  struct MonoType * * D.27852;
  struct MonoClass * D.27853;
  struct MonoType * D.27854;
  struct MonoGenericInst * D.27855;
  int D.27861;
  struct MonoGenericInst * D.27864;
  long unsigned int D.27868;
  long unsigned int D.27869;
  struct MonoGenericContainer * D.27871;
  int D.27872;
  <unnamed-unsigned:24> D.27875;
  int D.27876;
  int D.27877;
  unsigned char D.27881;
  <unnamed-unsigned:24> D.27882;
  int D.27883;
  struct GPtrArray * D.27884;
  void * * D.27885;
  long unsigned int D.27886;
  long unsigned int D.27887;
  void * * D.27888;
  unsigned int i.40;
  unsigned int D.27890;
  struct MonoImage * D.27891;
  int ninsts.41;
  struct MonoClass * D.27895;
  struct MonoType * D.27896;
  int ninsts.42;
  struct MonoClass * D.27898;
  struct MonoType * D.27899;
  int ninsts.43;
  struct MonoClass * D.27901;
  struct MonoType * D.27902;
  int ninsts.44;
  struct MonoClass * D.27904;
  struct MonoType * D.27905;
  int ninsts.45;
  struct MonoClass * D.27907;
  struct MonoType * D.27908;
  int ninsts.46;
  struct MonoClass * D.27910;
  struct MonoType * D.27911;
  int ninsts.47;
  struct MonoClass * D.27913;
  struct MonoType * D.27914;
  int ninsts.48;
  struct MonoClass * D.27916;
  struct MonoType * D.27917;
  int ninsts.49;
  struct MonoClass * D.27919;
  struct MonoType * D.27920;
  int ninsts.50;
  struct MonoClass * D.27922;
  struct MonoType * D.27923;
  int ninsts.51;
  struct MonoClass * D.27925;
  struct MonoType * D.27926;
  int ninsts.52;
  struct MonoClass * D.27928;
  struct MonoType * D.27929;
  struct MonoClass * D.27940;
  struct MonoGenericInst * D.27943;
  struct MonoMethod * D.27944;
  struct MonoMethod * D.27945;
  int D.25171;
  int iftmp.53;
  int D.25170;
  const char[16] * D.27951;
  unsigned char D.27952;
  int D.27953;
  unsigned char D.27954;
  int D.27955;
  const unsigned char * D.27960;
  unsigned char D.27961;
  int D.27962;
  const unsigned char * D.27963;
  unsigned char D.27964;
  int D.27965;
  const unsigned char * D.27970;
  unsigned char D.27971;
  int D.27972;
  const unsigned char * D.27973;
  unsigned char D.27974;
  int D.27975;
  const unsigned char * D.27980;
  unsigned char D.27981;
  int D.27982;
  const unsigned char * D.27983;
  unsigned char D.27984;
  int D.27985;
  const char * D.27987;
  int D.25180;
  int iftmp.54;
  int D.25179;
  const char[9] * D.27992;
  unsigned char D.27993;
  int D.27994;
  unsigned char D.27995;
  int D.27996;
  const unsigned char * D.28001;
  unsigned char D.28002;
  int D.28003;
  const unsigned char * D.28004;
  unsigned char D.28005;
  int D.28006;
  const unsigned char * D.28011;
  unsigned char D.28012;
  int D.28013;
  const unsigned char * D.28014;
  unsigned char D.28015;
  int D.28016;
  const unsigned char * D.28021;
  unsigned char D.28022;
  int D.28023;
  const unsigned char * D.28024;
  unsigned char D.28025;
  int D.28026;
  long unsigned int D.28028;
  long unsigned int D.28029;
  struct MonoGenericInst * D.28032;
  struct MonoMethod * D.28033;
  struct MonoMethod * D.28034;
  int D.25197;
  int iftmp.55;
  int D.25196;
  const char[5] * D.28042;
  unsigned char D.28043;
  int D.28044;
  unsigned char D.28045;
  int D.28046;
  const unsigned char * D.28051;
  unsigned char D.28052;
  int D.28053;
  const unsigned char * D.28054;
  unsigned char D.28055;
  int D.28056;
  const unsigned char * D.28061;
  unsigned char D.28062;
  int D.28063;
  const unsigned char * D.28064;
  unsigned char D.28065;
  int D.28066;
  const unsigned char * D.28071;
  unsigned char D.28072;
  int D.28073;
  const unsigned char * D.28074;
  unsigned char D.28075;
  int D.28076;
  const char * D.28078;
  int D.25206;
  int iftmp.56;
  int D.25205;
  const char[6] * D.28083;
  unsigned char D.28084;
  int D.28085;
  unsigned char D.28086;
  int D.28087;
  const unsigned char * D.28092;
  unsigned char D.28093;
  int D.28094;
  const unsigned char * D.28095;
  unsigned char D.28096;
  int D.28097;
  const unsigned char * D.28102;
  unsigned char D.28103;
  int D.28104;
  const unsigned char * D.28105;
  unsigned char D.28106;
  int D.28107;
  const unsigned char * D.28112;
  unsigned char D.28113;
  int D.28114;
  const unsigned char * D.28115;
  unsigned char D.28116;
  int D.28117;
  long unsigned int D.28119;
  long unsigned int D.28120;
  struct MonoGenericInst * D.28123;
  struct MonoMethod * D.28124;
  struct MonoMethod * D.28125;
  int i;
  guint32 token;
  struct MonoMethod * method;
  struct MonoGenericContext * context;

  D.27784 = acfg->aot_opts.no_instances;
  if (D.27784 != 0) goto <D.27785>; else goto <D.27786>;
  <D.27785>:
  return;
  <D.27786>:
  i = 0;
  goto <D.25141>;
  <D.25140>:
  D.27787 = i + 1;
  D.27788 = D.27787 | 721420288;
  token = (guint32) D.27788;
  D.27789 = acfg->image;
  method = mono_get_method (D.27789, token, 0B);
  if (method == 0B) goto <D.27790>; else goto <D.27791>;
  <D.27790>:
  // predicted unlikely by continue predictor.
  goto <D.25119>;
  <D.27791>:
  D.27792 = method->klass;
  D.27793 = D.27792->image;
  D.27789 = acfg->image;
  if (D.27793 != D.27789) goto <D.27794>; else goto <D.27795>;
  <D.27794>:
  // predicted unlikely by continue predictor.
  goto <D.25119>;
  <D.27795>:
  context = mono_method_get_context (method);
  if (context != 0B) goto <D.27796>; else goto <D.27797>;
  <D.27796>:
  D.27798 = context->class_inst;
  if (D.27798 != 0B) goto <D.27799>; else goto <D.27800>;
  <D.27799>:
  D.27798 = context->class_inst;
  D.27801 = BIT_FIELD_REF <*D.27798, 64, 0>;
  D.27802 = D.27801 & 18014398509481984;
  if (D.27802 != 0) goto <D.27803>; else goto <D.27804>;
  <D.27803>:
  // predicted unlikely by continue predictor.
  goto <D.25119>;
  <D.27804>:
  <D.27800>:
  <D.27797>:
  if (context != 0B) goto <D.27805>; else goto <D.27806>;
  <D.27805>:
  D.27807 = context->method_inst;
  if (D.27807 != 0B) goto <D.27808>; else goto <D.27809>;
  <D.27808>:
  D.27807 = context->method_inst;
  D.27810 = BIT_FIELD_REF <*D.27807, 64, 0>;
  D.27811 = D.27810 & 18014398509481984;
  if (D.27811 != 0) goto <D.27812>; else goto <D.27813>;
  <D.27812>:
  {
    struct MonoGenericContext shared_context;
    struct MonoGenericInst * inst;
    struct MonoType * * type_argv;
    int i;
    struct MonoMethod * declaring_method;
    gboolean supported;

    try
      {
        supported = 1;
        D.27798 = context->class_inst;
        if (D.27798 != 0B) goto <D.27814>; else goto <D.27815>;
        <D.27814>:
        inst = context->class_inst;
        i = 0;
        goto <D.25128>;
        <D.25127>:
        D.27818 = inst->type_argv[i];
        D.27819 = mono_type_is_reference (D.27818);
        if (D.27819 != 0) goto <D.27816>; else goto <D.27820>;
        <D.27820>:
        D.27818 = inst->type_argv[i];
        D.27821 = D.27818->type;
        if (D.27821 == 19) goto <D.27816>; else goto <D.27822>;
        <D.27822>:
        D.27818 = inst->type_argv[i];
        D.27821 = D.27818->type;
        if (D.27821 == 30) goto <D.27816>; else goto <D.27817>;
        <D.27816>:
        // predicted unlikely by continue predictor.
        goto <D.25126>;
        <D.27817>:
        D.27818 = inst->type_argv[i];
        D.27823 = mono_class_is_open_constructed_type (D.27818);
        if (D.27823 != 0) goto <D.27824>; else goto <D.27825>;
        <D.27824>:
        supported = 0;
        <D.27825>:
        <D.25126>:
        i = i + 1;
        <D.25128>:
        D.27826 = inst->type_argc;
        D.27827 = (int) D.27826;
        if (D.27827 > i) goto <D.25127>; else goto <D.25129>;
        <D.25129>:
        <D.27815>:
        D.27807 = context->method_inst;
        if (D.27807 != 0B) goto <D.27828>; else goto <D.27829>;
        <D.27828>:
        inst = context->method_inst;
        i = 0;
        goto <D.25132>;
        <D.25131>:
        D.27818 = inst->type_argv[i];
        D.27832 = mono_type_is_reference (D.27818);
        if (D.27832 != 0) goto <D.27830>; else goto <D.27833>;
        <D.27833>:
        D.27818 = inst->type_argv[i];
        D.27821 = D.27818->type;
        if (D.27821 == 19) goto <D.27830>; else goto <D.27834>;
        <D.27834>:
        D.27818 = inst->type_argv[i];
        D.27821 = D.27818->type;
        if (D.27821 == 30) goto <D.27830>; else goto <D.27831>;
        <D.27830>:
        // predicted unlikely by continue predictor.
        goto <D.25130>;
        <D.27831>:
        D.27818 = inst->type_argv[i];
        D.27835 = mono_class_is_open_constructed_type (D.27818);
        if (D.27835 != 0) goto <D.27836>; else goto <D.27837>;
        <D.27836>:
        supported = 0;
        <D.27837>:
        <D.25130>:
        i = i + 1;
        <D.25132>:
        D.27826 = inst->type_argc;
        D.27827 = (int) D.27826;
        if (D.27827 > i) goto <D.25131>; else goto <D.25133>;
        <D.25133>:
        <D.27829>:
        if (supported == 0) goto <D.27838>; else goto <D.27839>;
        <D.27838>:
        // predicted unlikely by continue predictor.
        goto <D.25119>;
        <D.27839>:
        memset (&shared_context, 0, 16);
        inst = context->class_inst;
        if (inst != 0B) goto <D.27840>; else goto <D.27841>;
        <D.27840>:
        D.27826 = inst->type_argc;
        D.27842 = (long unsigned int) D.27826;
        D.27843 = D.27842 * 8;
        type_argv = monoeg_malloc0 (D.27843);
        i = 0;
        goto <D.25135>;
        <D.25134>:
        D.27818 = inst->type_argv[i];
        D.27847 = mono_type_is_reference (D.27818);
        if (D.27847 != 0) goto <D.27844>; else goto <D.27848>;
        <D.27848>:
        D.27818 = inst->type_argv[i];
        D.27821 = D.27818->type;
        if (D.27821 == 19) goto <D.27844>; else goto <D.27849>;
        <D.27849>:
        D.27818 = inst->type_argv[i];
        D.27821 = D.27818->type;
        if (D.27821 == 30) goto <D.27844>; else goto <D.27845>;
        <D.27844>:
        D.27850 = (long unsigned int) i;
        D.27851 = D.27850 * 8;
        D.27852 = type_argv + D.27851;
        D.27853 = mono_defaults.object_class;
        D.27854 = &D.27853->byval_arg;
        *D.27852 = D.27854;
        goto <D.27846>;
        <D.27845>:
        D.27850 = (long unsigned int) i;
        D.27851 = D.27850 * 8;
        D.27852 = type_argv + D.27851;
        D.27818 = inst->type_argv[i];
        *D.27852 = D.27818;
        <D.27846>:
        i = i + 1;
        <D.25135>:
        D.27826 = inst->type_argc;
        D.27827 = (int) D.27826;
        if (D.27827 > i) goto <D.25134>; else goto <D.25136>;
        <D.25136>:
        D.27826 = inst->type_argc;
        D.27827 = (int) D.27826;
        D.27855 = mono_metadata_get_generic_inst (D.27827, type_argv);
        shared_context.class_inst = D.27855;
        monoeg_g_free (type_argv);
        <D.27841>:
        inst = context->method_inst;
        if (inst != 0B) goto <D.27856>; else goto <D.27857>;
        <D.27856>:
        D.27826 = inst->type_argc;
        D.27842 = (long unsigned int) D.27826;
        D.27843 = D.27842 * 8;
        type_argv = monoeg_malloc0 (D.27843);
        i = 0;
        goto <D.25138>;
        <D.25137>:
        D.27818 = inst->type_argv[i];
        D.27861 = mono_type_is_reference (D.27818);
        if (D.27861 != 0) goto <D.27858>; else goto <D.27862>;
        <D.27862>:
        D.27818 = inst->type_argv[i];
        D.27821 = D.27818->type;
        if (D.27821 == 19) goto <D.27858>; else goto <D.27863>;
        <D.27863>:
        D.27818 = inst->type_argv[i];
        D.27821 = D.27818->type;
        if (D.27821 == 30) goto <D.27858>; else goto <D.27859>;
        <D.27858>:
        D.27850 = (long unsigned int) i;
        D.27851 = D.27850 * 8;
        D.27852 = type_argv + D.27851;
        D.27853 = mono_defaults.object_class;
        D.27854 = &D.27853->byval_arg;
        *D.27852 = D.27854;
        goto <D.27860>;
        <D.27859>:
        D.27850 = (long unsigned int) i;
        D.27851 = D.27850 * 8;
        D.27852 = type_argv + D.27851;
        D.27818 = inst->type_argv[i];
        *D.27852 = D.27818;
        <D.27860>:
        i = i + 1;
        <D.25138>:
        D.27826 = inst->type_argc;
        D.27827 = (int) D.27826;
        if (D.27827 > i) goto <D.25137>; else goto <D.25139>;
        <D.25139>:
        D.27826 = inst->type_argc;
        D.27827 = (int) D.27826;
        D.27864 = mono_metadata_get_generic_inst (D.27827, type_argv);
        shared_context.method_inst = D.27864;
        monoeg_g_free (type_argv);
        <D.27857>:
        D.27868 = BIT_FIELD_REF <*method, 64, 256>;
        D.27869 = D.27868 & 2048;
        if (D.27869 != 0) goto <D.27865>; else goto <D.27870>;
        <D.27870>:
        D.27792 = method->klass;
        D.27871 = D.27792->generic_container;
        if (D.27871 != 0B) goto <D.27865>; else goto <D.27866>;
        <D.27865>:
        declaring_method = method;
        goto <D.27867>;
        <D.27866>:
        declaring_method = mono_method_get_declaring_generic_method (method);
        <D.27867>:
        method = mono_class_inflate_generic_method (declaring_method, &shared_context);
      }
    finally
      {
        shared_context = {CLOBBER};
      }
  }
  <D.27813>:
  <D.27809>:
  <D.27806>:
  D.27872 = mono_method_is_generic_sharable_full (method, 0, 0, 0);
  if (D.27872 != 0) goto <D.27873>; else goto <D.27874>;
  <D.27873>:
  // predicted unlikely by continue predictor.
  goto <D.25119>;
  <D.27874>:
  add_extra_method (acfg, method);
  <D.25119>:
  i = i + 1;
  <D.25141>:
  D.27789 = acfg->image;
  D.27875 = D.27789->tables[43].rows;
  D.27876 = (int) D.27875;
  if (D.27876 > i) goto <D.25140>; else goto <D.25142>;
  <D.25142>:
  i = 0;
  goto <D.25146>;
  <D.25145>:
  {
    struct MonoClass * klass;

    D.27787 = i + 1;
    D.27877 = D.27787 | 452984832;
    token = (guint32) D.27877;
    D.27789 = acfg->image;
    klass = mono_class_get (D.27789, token);
    if (klass == 0B) goto <D.27878>; else goto <D.27880>;
    <D.27880>:
    D.27881 = klass->rank;
    if (D.27881 != 0) goto <D.27878>; else goto <D.27879>;
    <D.27878>:
    mono_loader_clear_error ();
    // predicted unlikely by continue predictor.
    goto <D.25144>;
    <D.27879>:
    add_generic_class (acfg, klass, 0, "typespec");
  }
  <D.25144>:
  i = i + 1;
  <D.25146>:
  D.27789 = acfg->image;
  D.27882 = D.27789->tables[27].rows;
  D.27883 = (int) D.27882;
  if (D.27883 > i) goto <D.25145>; else goto <D.25147>;
  <D.25147>:
  i = 0;
  goto <D.25149>;
  <D.25148>:
  D.27884 = acfg->methods;
  D.27885 = D.27884->pdata;
  D.27886 = (long unsigned int) i;
  D.27887 = D.27886 * 8;
  D.27888 = D.27885 + D.27887;
  method = *D.27888;
  add_types_from_method_header (acfg, method);
  i = i + 1;
  <D.25149>:
  i.40 = (unsigned int) i;
  D.27884 = acfg->methods;
  D.27890 = D.27884->len;
  if (i.40 < D.27890) goto <D.25148>; else goto <D.25150>;
  <D.25150>:
  D.27789 = acfg->image;
  D.27891 = mono_defaults.corlib;
  if (D.27789 == D.27891) goto <D.27892>; else goto <D.27893>;
  <D.27892>:
  {
    struct MonoClass * klass;
    struct MonoType * insts[256];
    int ninsts;

    try
      {
        ninsts = 0;
        ninsts.41 = ninsts;
        ninsts = ninsts.41 + 1;
        D.27895 = mono_defaults.byte_class;
        D.27896 = &D.27895->byval_arg;
        insts[ninsts.41] = D.27896;
        ninsts.42 = ninsts;
        ninsts = ninsts.42 + 1;
        D.27898 = mono_defaults.sbyte_class;
        D.27899 = &D.27898->byval_arg;
        insts[ninsts.42] = D.27899;
        ninsts.43 = ninsts;
        ninsts = ninsts.43 + 1;
        D.27901 = mono_defaults.int16_class;
        D.27902 = &D.27901->byval_arg;
        insts[ninsts.43] = D.27902;
        ninsts.44 = ninsts;
        ninsts = ninsts.44 + 1;
        D.27904 = mono_defaults.uint16_class;
        D.27905 = &D.27904->byval_arg;
        insts[ninsts.44] = D.27905;
        ninsts.45 = ninsts;
        ninsts = ninsts.45 + 1;
        D.27907 = mono_defaults.int32_class;
        D.27908 = &D.27907->byval_arg;
        insts[ninsts.45] = D.27908;
        ninsts.46 = ninsts;
        ninsts = ninsts.46 + 1;
        D.27910 = mono_defaults.uint32_class;
        D.27911 = &D.27910->byval_arg;
        insts[ninsts.46] = D.27911;
        ninsts.47 = ninsts;
        ninsts = ninsts.47 + 1;
        D.27913 = mono_defaults.int64_class;
        D.27914 = &D.27913->byval_arg;
        insts[ninsts.47] = D.27914;
        ninsts.48 = ninsts;
        ninsts = ninsts.48 + 1;
        D.27916 = mono_defaults.uint64_class;
        D.27917 = &D.27916->byval_arg;
        insts[ninsts.48] = D.27917;
        ninsts.49 = ninsts;
        ninsts = ninsts.49 + 1;
        D.27919 = mono_defaults.single_class;
        D.27920 = &D.27919->byval_arg;
        insts[ninsts.49] = D.27920;
        ninsts.50 = ninsts;
        ninsts = ninsts.50 + 1;
        D.27922 = mono_defaults.double_class;
        D.27923 = &D.27922->byval_arg;
        insts[ninsts.50] = D.27923;
        ninsts.51 = ninsts;
        ninsts = ninsts.51 + 1;
        D.27925 = mono_defaults.char_class;
        D.27926 = &D.27925->byval_arg;
        insts[ninsts.51] = D.27926;
        ninsts.52 = ninsts;
        ninsts = ninsts.52 + 1;
        D.27928 = mono_defaults.boolean_class;
        D.27929 = &D.27928->byval_arg;
        insts[ninsts.52] = D.27929;
        D.27789 = acfg->image;
        klass = mono_class_from_name (D.27789, "System.Collections.Generic", "GenericComparer`1");
        if (klass != 0B) goto <D.27930>; else goto <D.27931>;
        <D.27930>:
        add_instances_of (acfg, klass, &insts, ninsts, 1);
        <D.27931>:
        D.27789 = acfg->image;
        klass = mono_class_from_name (D.27789, "System.Collections.Generic", "GenericEqualityComparer`1");
        if (klass != 0B) goto <D.27932>; else goto <D.27933>;
        <D.27932>:
        add_instances_of (acfg, klass, &insts, ninsts, 1);
        <D.27933>:
        D.27789 = acfg->image;
        klass = mono_class_from_name (D.27789, "System.Collections.Generic", "ICollection`1");
        if (klass != 0B) goto <D.27934>; else goto <D.27935>;
        <D.27934>:
        add_instances_of (acfg, klass, &insts, ninsts, 1);
        <D.27935>:
        D.27789 = acfg->image;
        klass = mono_class_from_name (D.27789, "System.Collections.Generic", "IList`1");
        if (klass != 0B) goto <D.27936>; else goto <D.27937>;
        <D.27936>:
        add_instances_of (acfg, klass, &insts, ninsts, 1);
        <D.27937>:
        D.27789 = acfg->image;
        klass = mono_class_from_name (D.27789, "System.Collections.Generic", "IEnumerable`1");
        if (klass != 0B) goto <D.27938>; else goto <D.27939>;
        <D.27938>:
        add_instances_of (acfg, klass, &insts, ninsts, 1);
        <D.27939>:
        {
          struct MonoGenericContext ctx;
          struct MonoType * args[16];
          struct MonoMethod * get_method;
          struct MonoClass * array_klass;

          try
            {
              D.27853 = mono_defaults.object_class;
              D.27940 = mono_array_class_get (D.27853, 1);
              array_klass = D.27940->parent;
              get_method = mono_class_get_method_from_name (array_klass, "GetGenericValueImpl", 2);
              if (get_method != 0B) goto <D.27941>; else goto <D.27942>;
              <D.27941>:
              memset (&ctx, 0, 16);
              D.27853 = mono_defaults.object_class;
              D.27854 = &D.27853->byval_arg;
              args[0] = D.27854;
              D.27943 = mono_metadata_get_generic_inst (1, &args);
              ctx.method_inst = D.27943;
              D.27944 = mono_class_inflate_generic_method (get_method, &ctx);
              D.27945 = mono_marshal_get_native_wrapper (D.27944, 1, 1);
              add_extra_method (acfg, D.27945);
              <D.27942>:
            }
          finally
            {
              ctx = {CLOBBER};
              args = {CLOBBER};
            }
        }
        {
          struct MonoGenericContext ctx;
          struct MonoType * args[16];
          struct MonoMethod * m;
          struct MonoClass * interlocked_klass;
          void * iter;

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

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

                  __s2 = m->name;
                  D.27951 = "CompareExchange";
                  D.27952 = MEM[(const unsigned char *)D.27951];
                  D.27953 = (int) D.27952;
                  D.27954 = *__s2;
                  D.27955 = (int) D.27954;
                  __result = D.27953 - D.27955;
                  {
                    if (__s2_len != 0) goto <D.27956>; else goto <D.27957>;
                    <D.27956>:
                    if (__result == 0) goto <D.27958>; else goto <D.27959>;
                    <D.27958>:
                    D.27960 = &MEM[(void *)"CompareExchange" + 1B];
                    D.27961 = *D.27960;
                    D.27962 = (int) D.27961;
                    D.27963 = __s2 + 1;
                    D.27964 = *D.27963;
                    D.27965 = (int) D.27964;
                    __result = D.27962 - D.27965;
                    if (__s2_len > 1) goto <D.27966>; else goto <D.27967>;
                    <D.27966>:
                    if (__result == 0) goto <D.27968>; else goto <D.27969>;
                    <D.27968>:
                    D.27970 = &MEM[(void *)"CompareExchange" + 2B];
                    D.27971 = *D.27970;
                    D.27972 = (int) D.27971;
                    D.27973 = __s2 + 2;
                    D.27974 = *D.27973;
                    D.27975 = (int) D.27974;
                    __result = D.27972 - D.27975;
                    if (__s2_len > 2) goto <D.27976>; else goto <D.27977>;
                    <D.27976>:
                    if (__result == 0) goto <D.27978>; else goto <D.27979>;
                    <D.27978>:
                    D.27980 = &MEM[(void *)"CompareExchange" + 3B];
                    D.27981 = *D.27980;
                    D.27982 = (int) D.27981;
                    D.27983 = __s2 + 3;
                    D.27984 = *D.27983;
                    D.27985 = (int) D.27984;
                    __result = D.27982 - D.27985;
                    <D.27979>:
                    <D.27977>:
                    <D.27969>:
                    <D.27967>:
                    <D.27959>:
                    <D.27957>:
                  }
                  D.25170 = __result;
                }
                iftmp.53 = -D.25170;
                goto <D.27986>;
                <D.27950>:
                D.27987 = m->name;
                iftmp.53 = __builtin_strcmp (D.27987, "CompareExchange");
                <D.27986>:
                D.25171 = iftmp.53;
              }
              if (D.25171 == 0) goto <D.27946>; else goto <D.27988>;
              <D.27988>:
              {
                size_t __s1_len;
                size_t __s2_len;

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

                  __s2 = m->name;
                  D.27992 = "Exchange";
                  D.27993 = MEM[(const unsigned char *)D.27992];
                  D.27994 = (int) D.27993;
                  D.27995 = *__s2;
                  D.27996 = (int) D.27995;
                  __result = D.27994 - D.27996;
                  {
                    if (__s2_len != 0) goto <D.27997>; else goto <D.27998>;
                    <D.27997>:
                    if (__result == 0) goto <D.27999>; else goto <D.28000>;
                    <D.27999>:
                    D.28001 = &MEM[(void *)"Exchange" + 1B];
                    D.28002 = *D.28001;
                    D.28003 = (int) D.28002;
                    D.28004 = __s2 + 1;
                    D.28005 = *D.28004;
                    D.28006 = (int) D.28005;
                    __result = D.28003 - D.28006;
                    if (__s2_len > 1) goto <D.28007>; else goto <D.28008>;
                    <D.28007>:
                    if (__result == 0) goto <D.28009>; else goto <D.28010>;
                    <D.28009>:
                    D.28011 = &MEM[(void *)"Exchange" + 2B];
                    D.28012 = *D.28011;
                    D.28013 = (int) D.28012;
                    D.28014 = __s2 + 2;
                    D.28015 = *D.28014;
                    D.28016 = (int) D.28015;
                    __result = D.28013 - D.28016;
                    if (__s2_len > 2) goto <D.28017>; else goto <D.28018>;
                    <D.28017>:
                    if (__result == 0) goto <D.28019>; else goto <D.28020>;
                    <D.28019>:
                    D.28021 = &MEM[(void *)"Exchange" + 3B];
                    D.28022 = *D.28021;
                    D.28023 = (int) D.28022;
                    D.28024 = __s2 + 3;
                    D.28025 = *D.28024;
                    D.28026 = (int) D.28025;
                    __result = D.28023 - D.28026;
                    <D.28020>:
                    <D.28018>:
                    <D.28010>:
                    <D.28008>:
                    <D.28000>:
                    <D.27998>:
                  }
                  D.25179 = __result;
                }
                iftmp.54 = -D.25179;
                goto <D.28027>;
                <D.27991>:
                D.27987 = m->name;
                iftmp.54 = __builtin_strcmp (D.27987, "Exchange");
                <D.28027>:
                D.25180 = iftmp.54;
              }
              if (D.25180 == 0) goto <D.27946>; else goto <D.27947>;
              <D.27946>:
              D.28028 = BIT_FIELD_REF <*m, 64, 256>;
              D.28029 = D.28028 & 2048;
              if (D.28029 != 0) goto <D.28030>; else goto <D.28031>;
              <D.28030>:
              memset (&ctx, 0, 16);
              D.27853 = mono_defaults.object_class;
              D.27854 = &D.27853->byval_arg;
              args[0] = D.27854;
              D.28032 = mono_metadata_get_generic_inst (1, &args);
              ctx.method_inst = D.28032;
              D.28033 = mono_class_inflate_generic_method (m, &ctx);
              D.28034 = mono_marshal_get_native_wrapper (D.28033, 1, 1);
              add_extra_method (acfg, D.28034);
              <D.28031>:
              <D.27947>:
              <D.25182>:
              m = mono_class_get_methods (interlocked_klass, &iter);
              if (m != 0B) goto <D.25181>; else goto <D.25183>;
              <D.25183>:
            }
          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.27891 = mono_defaults.corlib;
              volatile_klass = mono_class_from_name (D.27891, "System.Threading", "Volatile");
              iter = 0B;
              if (volatile_klass != 0B) goto <D.28035>; else goto <D.28036>;
              <D.28035>:
              goto <D.25208>;
              <D.25207>:
              {
                size_t __s1_len;
                size_t __s2_len;

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

                  __s2 = m->name;
                  D.28042 = "Read";
                  D.28043 = MEM[(const unsigned char *)D.28042];
                  D.28044 = (int) D.28043;
                  D.28045 = *__s2;
                  D.28046 = (int) D.28045;
                  __result = D.28044 - D.28046;
                  {
                    if (__s2_len != 0) goto <D.28047>; else goto <D.28048>;
                    <D.28047>:
                    if (__result == 0) goto <D.28049>; else goto <D.28050>;
                    <D.28049>:
                    D.28051 = &MEM[(void *)"Read" + 1B];
                    D.28052 = *D.28051;
                    D.28053 = (int) D.28052;
                    D.28054 = __s2 + 1;
                    D.28055 = *D.28054;
                    D.28056 = (int) D.28055;
                    __result = D.28053 - D.28056;
                    if (__s2_len > 1) goto <D.28057>; else goto <D.28058>;
                    <D.28057>:
                    if (__result == 0) goto <D.28059>; else goto <D.28060>;
                    <D.28059>:
                    D.28061 = &MEM[(void *)"Read" + 2B];
                    D.28062 = *D.28061;
                    D.28063 = (int) D.28062;
                    D.28064 = __s2 + 2;
                    D.28065 = *D.28064;
                    D.28066 = (int) D.28065;
                    __result = D.28063 - D.28066;
                    if (__s2_len > 2) goto <D.28067>; else goto <D.28068>;
                    <D.28067>:
                    if (__result == 0) goto <D.28069>; else goto <D.28070>;
                    <D.28069>:
                    D.28071 = &MEM[(void *)"Read" + 3B];
                    D.28072 = *D.28071;
                    D.28073 = (int) D.28072;
                    D.28074 = __s2 + 3;
                    D.28075 = *D.28074;
                    D.28076 = (int) D.28075;
                    __result = D.28073 - D.28076;
                    <D.28070>:
                    <D.28068>:
                    <D.28060>:
                    <D.28058>:
                    <D.28050>:
                    <D.28048>:
                  }
                  D.25196 = __result;
                }
                iftmp.55 = -D.25196;
                goto <D.28077>;
                <D.28041>:
                D.28078 = m->name;
                iftmp.55 = __builtin_strcmp (D.28078, "Read");
                <D.28077>:
                D.25197 = iftmp.55;
              }
              if (D.25197 == 0) goto <D.28037>; else goto <D.28079>;
              <D.28079>:
              {
                size_t __s1_len;
                size_t __s2_len;

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

                  __s2 = m->name;
                  D.28083 = "Write";
                  D.28084 = MEM[(const unsigned char *)D.28083];
                  D.28085 = (int) D.28084;
                  D.28086 = *__s2;
                  D.28087 = (int) D.28086;
                  __result = D.28085 - D.28087;
                  {
                    if (__s2_len != 0) goto <D.28088>; else goto <D.28089>;
                    <D.28088>:
                    if (__result == 0) goto <D.28090>; else goto <D.28091>;
                    <D.28090>:
                    D.28092 = &MEM[(void *)"Write" + 1B];
                    D.28093 = *D.28092;
                    D.28094 = (int) D.28093;
                    D.28095 = __s2 + 1;
                    D.28096 = *D.28095;
                    D.28097 = (int) D.28096;
                    __result = D.28094 - D.28097;
                    if (__s2_len > 1) goto <D.28098>; else goto <D.28099>;
                    <D.28098>:
                    if (__result == 0) goto <D.28100>; else goto <D.28101>;
                    <D.28100>:
                    D.28102 = &MEM[(void *)"Write" + 2B];
                    D.28103 = *D.28102;
                    D.28104 = (int) D.28103;
                    D.28105 = __s2 + 2;
                    D.28106 = *D.28105;
                    D.28107 = (int) D.28106;
                    __result = D.28104 - D.28107;
                    if (__s2_len > 2) goto <D.28108>; else goto <D.28109>;
                    <D.28108>:
                    if (__result == 0) goto <D.28110>; else goto <D.28111>;
                    <D.28110>:
                    D.28112 = &MEM[(void *)"Write" + 3B];
                    D.28113 = *D.28112;
                    D.28114 = (int) D.28113;
                    D.28115 = __s2 + 3;
                    D.28116 = *D.28115;
                    D.28117 = (int) D.28116;
                    __result = D.28114 - D.28117;
                    <D.28111>:
                    <D.28109>:
                    <D.28101>:
                    <D.28099>:
                    <D.28091>:
                    <D.28089>:
                  }
                  D.25205 = __result;
                }
                iftmp.56 = -D.25205;
                goto <D.28118>;
                <D.28082>:
                D.28078 = m->name;
                iftmp.56 = __builtin_strcmp (D.28078, "Write");
                <D.28118>:
                D.25206 = iftmp.56;
              }
              if (D.25206 == 0) goto <D.28037>; else goto <D.28038>;
              <D.28037>:
              D.28119 = BIT_FIELD_REF <*m, 64, 256>;
              D.28120 = D.28119 & 2048;
              if (D.28120 != 0) goto <D.28121>; else goto <D.28122>;
              <D.28121>:
              memset (&ctx, 0, 16);
              D.27853 = mono_defaults.object_class;
              D.27854 = &D.27853->byval_arg;
              args[0] = D.27854;
              D.28123 = mono_metadata_get_generic_inst (1, &args);
              ctx.method_inst = D.28123;
              D.28124 = mono_class_inflate_generic_method (m, &ctx);
              D.28125 = mono_marshal_get_native_wrapper (D.28124, 1, 1);
              add_extra_method (acfg, D.28125);
              <D.28122>:
              <D.28038>:
              <D.25208>:
              m = mono_class_get_methods (volatile_klass, &iter);
              if (m != 0B) goto <D.25207>; else goto <D.25209>;
              <D.25209>:
              <D.28036>:
            }
          finally
            {
              ctx = {CLOBBER};
              args = {CLOBBER};
              iter = {CLOBBER};
            }
        }
      }
    finally
      {
        insts = {CLOBBER};
      }
  }
  <D.27893>:
}


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

  D.28129 = acfg->aot_opts.full_aot;
  D.28130 = D.28129 | force;
  if (D.28130 == 0) goto <D.28131>; else goto <D.28132>;
  <D.28131>:
  return;
  <D.28132>:
  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.28134;
  struct GHashTable * D.28137;
  struct MonoGenericClass * D.28138;
  struct MonoGenericInst * D.28141;
  long unsigned int D.28142;
  long unsigned int D.28143;
  int D.28146;
  unsigned char D.28151;
  unsigned char D.28154;
  struct GHashTable * D.28159;
  void * D.28160;
  struct MonoType * D.28163;
  int D.28164;
  int D.28167;
  char * D.28170;
  unsigned int D.28173;
  unsigned int D.28174;
  struct MonoImage * D.28177;
  struct MonoImage * D.28178;
  int D.28185;
  int D.24921;
  int iftmp.57;
  int D.24920;
  const char[13] * D.28191;
  unsigned char D.28192;
  int D.28193;
  unsigned char D.28194;
  int D.28195;
  const unsigned char * D.28200;
  unsigned char D.28201;
  int D.28202;
  const unsigned char * D.28203;
  unsigned char D.28204;
  int D.28205;
  const unsigned char * D.28210;
  unsigned char D.28211;
  int D.28212;
  const unsigned char * D.28213;
  unsigned char D.28214;
  int D.28215;
  const unsigned char * D.28220;
  unsigned char D.28221;
  int D.28222;
  const unsigned char * D.28223;
  unsigned char D.28224;
  int D.28225;
  const char * D.28227;
  int D.24930;
  int iftmp.58;
  int D.24929;
  const char[7] * D.28232;
  unsigned char D.28233;
  int D.28234;
  unsigned char D.28235;
  int D.28236;
  const unsigned char * D.28241;
  unsigned char D.28242;
  int D.28243;
  const unsigned char * D.28244;
  unsigned char D.28245;
  int D.28246;
  const unsigned char * D.28251;
  unsigned char D.28252;
  int D.28253;
  const unsigned char * D.28254;
  unsigned char D.28255;
  int D.28256;
  const unsigned char * D.28261;
  unsigned char D.28262;
  int D.28263;
  const unsigned char * D.28264;
  unsigned char D.28265;
  int D.28266;
  long unsigned int D.28270;
  long unsigned int D.28271;
  struct MonoGenericContext * D.28274;
  struct MonoGenericInst * D.28275;
  int D.28278;
  long unsigned int D.28281;
  int D.28284;
  struct MonoType * D.28285;
  unsigned char D.28286;
  struct MonoClass * D.28289;
  long unsigned int D.28290;
  long unsigned int D.28291;
  char * D.28296;
  struct MonoClass * D.28297;
  int D.24945;
  int iftmp.59;
  int D.24944;
  const char[27] * D.28307;
  unsigned char D.28308;
  int D.28309;
  unsigned char D.28310;
  int D.28311;
  const unsigned char * D.28316;
  unsigned char D.28317;
  int D.28318;
  const unsigned char * D.28319;
  unsigned char D.28320;
  int D.28321;
  const unsigned char * D.28326;
  unsigned char D.28327;
  int D.28328;
  const unsigned char * D.28329;
  unsigned char D.28330;
  int D.28331;
  const unsigned char * D.28336;
  unsigned char D.28337;
  int D.28338;
  const unsigned char * D.28339;
  unsigned char D.28340;
  int D.28341;
  const char * D.28343;
  int D.24954;
  int iftmp.60;
  int D.24953;
  const char[14] * D.28349;
  unsigned char D.28350;
  int D.28351;
  unsigned char D.28352;
  int D.28353;
  const unsigned char * D.28358;
  unsigned char D.28359;
  int D.28360;
  const unsigned char * D.28361;
  unsigned char D.28362;
  int D.28363;
  const unsigned char * D.28368;
  unsigned char D.28369;
  int D.28370;
  const unsigned char * D.28371;
  unsigned char D.28372;
  int D.28373;
  const unsigned char * D.28378;
  unsigned char D.28379;
  int D.28380;
  const unsigned char * D.28381;
  unsigned char D.28382;
  int D.28383;
  int D.24963;
  int iftmp.61;
  int D.24962;
  const char[14] * D.28389;
  unsigned char D.28390;
  int D.28391;
  unsigned char D.28392;
  int D.28393;
  const unsigned char * D.28398;
  unsigned char D.28399;
  int D.28400;
  const unsigned char * D.28401;
  unsigned char D.28402;
  int D.28403;
  const unsigned char * D.28408;
  unsigned char D.28409;
  int D.28410;
  const unsigned char * D.28411;
  unsigned char D.28412;
  int D.28413;
  const unsigned char * D.28418;
  unsigned char D.28419;
  int D.28420;
  const unsigned char * D.28421;
  unsigned char D.28422;
  int D.28423;
  int D.24972;
  int iftmp.62;
  int D.24971;
  const char[8] * D.28429;
  unsigned char D.28430;
  int D.28431;
  unsigned char D.28432;
  int D.28433;
  const unsigned char * D.28438;
  unsigned char D.28439;
  int D.28440;
  const unsigned char * D.28441;
  unsigned char D.28442;
  int D.28443;
  const unsigned char * D.28448;
  unsigned char D.28449;
  int D.28450;
  const unsigned char * D.28451;
  unsigned char D.28452;
  int D.28453;
  const unsigned char * D.28458;
  unsigned char D.28459;
  int D.28460;
  const unsigned char * D.28461;
  unsigned char D.28462;
  int D.28463;
  int D.24981;
  int iftmp.63;
  int D.24980;
  const char[14] * D.28469;
  unsigned char D.28470;
  int D.28471;
  unsigned char D.28472;
  int D.28473;
  const unsigned char * D.28478;
  unsigned char D.28479;
  int D.28480;
  const unsigned char * D.28481;
  unsigned char D.28482;
  int D.28483;
  const unsigned char * D.28488;
  unsigned char D.28489;
  int D.28490;
  const unsigned char * D.28491;
  unsigned char D.28492;
  int D.28493;
  const unsigned char * D.28498;
  unsigned char D.28499;
  int D.28500;
  const unsigned char * D.28501;
  unsigned char D.28502;
  int D.28503;
  int D.24990;
  int iftmp.64;
  int D.24989;
  const char[16] * D.28509;
  unsigned char D.28510;
  int D.28511;
  unsigned char D.28512;
  int D.28513;
  const unsigned char * D.28518;
  unsigned char D.28519;
  int D.28520;
  const unsigned char * D.28521;
  unsigned char D.28522;
  int D.28523;
  const unsigned char * D.28528;
  unsigned char D.28529;
  int D.28530;
  const unsigned char * D.28531;
  unsigned char D.28532;
  int D.28533;
  const unsigned char * D.28538;
  unsigned char D.28539;
  int D.28540;
  const unsigned char * D.28541;
  unsigned char D.28542;
  int D.28543;
  struct MonoType * D.28545;
  int D.25003;
  int iftmp.65;
  int D.25002;
  unsigned char D.28549;
  int D.28550;
  const unsigned char * D.28555;
  unsigned char D.28556;
  int D.28557;
  const unsigned char * D.28562;
  unsigned char D.28563;
  int D.28564;
  const unsigned char * D.28569;
  unsigned char D.28570;
  int D.28571;
  int D.25012;
  int iftmp.66;
  int D.25011;
  unsigned char D.28581;
  int D.28582;
  const unsigned char * D.28587;
  unsigned char D.28588;
  int D.28589;
  const unsigned char * D.28594;
  unsigned char D.28595;
  int D.28596;
  const unsigned char * D.28601;
  unsigned char D.28602;
  int D.28603;
  int D.25021;
  int iftmp.67;
  int D.25020;
  unsigned char D.28609;
  int D.28610;
  const unsigned char * D.28615;
  unsigned char D.28616;
  int D.28617;
  const unsigned char * D.28622;
  unsigned char D.28623;
  int D.28624;
  const unsigned char * D.28629;
  unsigned char D.28630;
  int D.28631;
  int D.25031;
  int iftmp.68;
  int D.25030;
  const char[21] * D.28636;
  unsigned char D.28637;
  int D.28638;
  unsigned char D.28639;
  int D.28640;
  const unsigned char * D.28645;
  unsigned char D.28646;
  int D.28647;
  const unsigned char * D.28648;
  unsigned char D.28649;
  int D.28650;
  const unsigned char * D.28655;
  unsigned char D.28656;
  int D.28657;
  const unsigned char * D.28658;
  unsigned char D.28659;
  int D.28660;
  const unsigned char * D.28665;
  unsigned char D.28666;
  int D.28667;
  const unsigned char * D.28668;
  unsigned char D.28669;
  int D.28670;
  const char * D.28672;
  struct MonoClass * D.28674;
  _Bool D.28675;
  long int D.28676;
  long int D.28677;
  struct MonoGenericContext * D.28680;
  const char * D.28681;
  char * D.28682;
  int D.25047;
  int iftmp.69;
  int D.25046;
  unsigned char D.28690;
  int D.28691;
  const unsigned char * D.28696;
  unsigned char D.28697;
  int D.28698;
  const unsigned char * D.28703;
  unsigned char D.28704;
  int D.28705;
  const unsigned char * D.28710;
  unsigned char D.28711;
  int D.28712;
  int D.25056;
  int iftmp.70;
  int D.25055;
  const char[11] * D.28719;
  unsigned char D.28720;
  int D.28721;
  unsigned char D.28722;
  int D.28723;
  const unsigned char * D.28728;
  unsigned char D.28729;
  int D.28730;
  const unsigned char * D.28731;
  unsigned char D.28732;
  int D.28733;
  const unsigned char * D.28738;
  unsigned char D.28739;
  int D.28740;
  const unsigned char * D.28741;
  unsigned char D.28742;
  int D.28743;
  const unsigned char * D.28748;
  unsigned char D.28749;
  int D.28750;
  const unsigned char * D.28751;
  unsigned char D.28752;
  int D.28753;
  _Bool D.28757;
  long int D.28758;
  long int D.28759;
  struct MonoType * D.28762;
  struct MonoGenericInst * D.28763;
  struct MonoClass * D.28764;
  int D.28765;
  _Bool D.28768;
  long int D.28769;
  long int D.28770;
  struct MonoClass * D.28773;
  int D.25070;
  int iftmp.71;
  int D.25069;
  unsigned char D.28779;
  int D.28780;
  const unsigned char * D.28785;
  unsigned char D.28786;
  int D.28787;
  const unsigned char * D.28792;
  unsigned char D.28793;
  int D.28794;
  const unsigned char * D.28799;
  unsigned char D.28800;
  int D.28801;
  int D.25079;
  int iftmp.72;
  int D.25078;
  const char[19] * D.28808;
  unsigned char D.28809;
  int D.28810;
  unsigned char D.28811;
  int D.28812;
  const unsigned char * D.28817;
  unsigned char D.28818;
  int D.28819;
  const unsigned char * D.28820;
  unsigned char D.28821;
  int D.28822;
  const unsigned char * D.28827;
  unsigned char D.28828;
  int D.28829;
  const unsigned char * D.28830;
  unsigned char D.28831;
  int D.28832;
  const unsigned char * D.28837;
  unsigned char D.28838;
  int D.28839;
  const unsigned char * D.28840;
  unsigned char D.28841;
  int D.28842;
  _Bool D.28846;
  long int D.28847;
  long int D.28848;
  struct MonoType * D.28851;
  struct MonoGenericInst * D.28852;
  struct MonoClass * D.28853;
  int D.28854;
  _Bool D.28857;
  long int D.28858;
  long int D.28859;
  struct MonoClass * D.28862;
  struct MonoMethod * method;
  struct MonoClassField * field;
  void * iter;
  gboolean use_gsharedvt;

  try
    {
      use_gsharedvt = 0;
      D.28134 = acfg->ginst_hash;
      if (D.28134 == 0B) goto <D.28135>; else goto <D.28136>;
      <D.28135>:
      D.28137 = monoeg_g_hash_table_new (0B, 0B);
      acfg->ginst_hash = D.28137;
      <D.28136>:
      mono_class_init (klass);
      D.28138 = klass->generic_class;
      if (D.28138 != 0B) goto <D.28139>; else goto <D.28140>;
      <D.28139>:
      D.28138 = klass->generic_class;
      D.28141 = D.28138->context.class_inst;
      D.28142 = BIT_FIELD_REF <*D.28141, 64, 0>;
      D.28143 = D.28142 & 18014398509481984;
      if (D.28143 != 0) goto <D.28144>; else goto <D.28145>;
      <D.28144>:
      return;
      <D.28145>:
      <D.28140>:
      D.28146 = has_type_vars (klass);
      if (D.28146 != 0) goto <D.28147>; else goto <D.28148>;
      <D.28147>:
      return;
      <D.28148>:
      D.28138 = klass->generic_class;
      if (D.28138 == 0B) goto <D.28149>; else goto <D.28150>;
      <D.28149>:
      D.28151 = klass->rank;
      if (D.28151 == 0) goto <D.28152>; else goto <D.28153>;
      <D.28152>:
      return;
      <D.28153>:
      <D.28150>:
      D.28154 = klass->exception_type;
      if (D.28154 != 0) goto <D.28155>; else goto <D.28156>;
      <D.28155>:
      return;
      <D.28156>:
      D.28134 = acfg->ginst_hash;
      if (D.28134 == 0B) goto <D.28157>; else goto <D.28158>;
      <D.28157>:
      D.28159 = monoeg_g_hash_table_new (0B, 0B);
      acfg->ginst_hash = D.28159;
      <D.28158>:
      D.28134 = acfg->ginst_hash;
      D.28160 = monoeg_g_hash_table_lookup (D.28134, klass);
      if (D.28160 != 0B) goto <D.28161>; else goto <D.28162>;
      <D.28161>:
      return;
      <D.28162>:
      D.28163 = &klass->byval_arg;
      D.28164 = check_type_depth (D.28163, 0);
      if (D.28164 != 0) goto <D.28165>; else goto <D.28166>;
      <D.28165>:
      return;
      <D.28166>:
      D.28167 = acfg->aot_opts.log_generics;
      if (D.28167 != 0) goto <D.28168>; else goto <D.28169>;
      <D.28168>:
      D.28163 = &klass->byval_arg;
      D.28170 = mono_type_full_name (D.28163);
      printf ("%*sAdding generic instance %s [%s].\n", depth, "", D.28170, ref);
      <D.28169>:
      D.28134 = acfg->ginst_hash;
      monoeg_g_hash_table_insert_replace (D.28134, klass, klass, 0);
      D.28173 = acfg->opts;
      D.28174 = D.28173 & 16777216;
      if (D.28174 != 0) goto <D.28175>; else goto <D.28176>;
      <D.28175>:
      D.28177 = klass->image;
      D.28178 = mono_defaults.corlib;
      if (D.28177 == D.28178) goto <D.28179>; else goto <D.28180>;
      <D.28179>:
      D.28138 = klass->generic_class;
      if (D.28138 != 0B) goto <D.28181>; else goto <D.28182>;
      <D.28181>:
      D.28138 = klass->generic_class;
      D.28141 = D.28138->context.class_inst;
      if (D.28141 != 0B) goto <D.28183>; else goto <D.28184>;
      <D.28183>:
      D.28138 = klass->generic_class;
      D.28141 = D.28138->context.class_inst;
      D.28185 = is_vt_inst (D.28141);
      if (D.28185 != 0) goto <D.28186>; else goto <D.28187>;
      <D.28186>:
      {
        size_t __s1_len;
        size_t __s2_len;

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

          __s2 = klass->name;
          D.28191 = "Dictionary`2";
          D.28192 = MEM[(const unsigned char *)D.28191];
          D.28193 = (int) D.28192;
          D.28194 = *__s2;
          D.28195 = (int) D.28194;
          __result = D.28193 - D.28195;
          {
            if (__s2_len != 0) goto <D.28196>; else goto <D.28197>;
            <D.28196>:
            if (__result == 0) goto <D.28198>; else goto <D.28199>;
            <D.28198>:
            D.28200 = &MEM[(void *)"Dictionary`2" + 1B];
            D.28201 = *D.28200;
            D.28202 = (int) D.28201;
            D.28203 = __s2 + 1;
            D.28204 = *D.28203;
            D.28205 = (int) D.28204;
            __result = D.28202 - D.28205;
            if (__s2_len > 1) goto <D.28206>; else goto <D.28207>;
            <D.28206>:
            if (__result == 0) goto <D.28208>; else goto <D.28209>;
            <D.28208>:
            D.28210 = &MEM[(void *)"Dictionary`2" + 2B];
            D.28211 = *D.28210;
            D.28212 = (int) D.28211;
            D.28213 = __s2 + 2;
            D.28214 = *D.28213;
            D.28215 = (int) D.28214;
            __result = D.28212 - D.28215;
            if (__s2_len > 2) goto <D.28216>; else goto <D.28217>;
            <D.28216>:
            if (__result == 0) goto <D.28218>; else goto <D.28219>;
            <D.28218>:
            D.28220 = &MEM[(void *)"Dictionary`2" + 3B];
            D.28221 = *D.28220;
            D.28222 = (int) D.28221;
            D.28223 = __s2 + 3;
            D.28224 = *D.28223;
            D.28225 = (int) D.28224;
            __result = D.28222 - D.28225;
            <D.28219>:
            <D.28217>:
            <D.28209>:
            <D.28207>:
            <D.28199>:
            <D.28197>:
          }
          D.24920 = __result;
        }
        iftmp.57 = -D.24920;
        goto <D.28226>;
        <D.28190>:
        D.28227 = klass->name;
        iftmp.57 = __builtin_strcmp (D.28227, "Dictionary`2");
        <D.28226>:
        D.24921 = iftmp.57;
      }
      if (D.24921 == 0) goto <D.28171>; else goto <D.28228>;
      <D.28228>:
      {
        size_t __s1_len;
        size_t __s2_len;

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

          __s2 = klass->name;
          D.28232 = "List`1";
          D.28233 = MEM[(const unsigned char *)D.28232];
          D.28234 = (int) D.28233;
          D.28235 = *__s2;
          D.28236 = (int) D.28235;
          __result = D.28234 - D.28236;
          {
            if (__s2_len != 0) goto <D.28237>; else goto <D.28238>;
            <D.28237>:
            if (__result == 0) goto <D.28239>; else goto <D.28240>;
            <D.28239>:
            D.28241 = &MEM[(void *)"List`1" + 1B];
            D.28242 = *D.28241;
            D.28243 = (int) D.28242;
            D.28244 = __s2 + 1;
            D.28245 = *D.28244;
            D.28246 = (int) D.28245;
            __result = D.28243 - D.28246;
            if (__s2_len > 1) goto <D.28247>; else goto <D.28248>;
            <D.28247>:
            if (__result == 0) goto <D.28249>; else goto <D.28250>;
            <D.28249>:
            D.28251 = &MEM[(void *)"List`1" + 2B];
            D.28252 = *D.28251;
            D.28253 = (int) D.28252;
            D.28254 = __s2 + 2;
            D.28255 = *D.28254;
            D.28256 = (int) D.28255;
            __result = D.28253 - D.28256;
            if (__s2_len > 2) goto <D.28257>; else goto <D.28258>;
            <D.28257>:
            if (__result == 0) goto <D.28259>; else goto <D.28260>;
            <D.28259>:
            D.28261 = &MEM[(void *)"List`1" + 3B];
            D.28262 = *D.28261;
            D.28263 = (int) D.28262;
            D.28264 = __s2 + 3;
            D.28265 = *D.28264;
            D.28266 = (int) D.28265;
            __result = D.28263 - D.28266;
            <D.28260>:
            <D.28258>:
            <D.28250>:
            <D.28248>:
            <D.28240>:
            <D.28238>:
          }
          D.24929 = __result;
        }
        iftmp.58 = -D.24929;
        goto <D.28267>;
        <D.28231>:
        D.28227 = klass->name;
        iftmp.58 = __builtin_strcmp (D.28227, "List`1");
        <D.28267>:
        D.24930 = iftmp.58;
      }
      if (D.24930 == 0) goto <D.28171>; else goto <D.28172>;
      <D.28171>:
      use_gsharedvt = 1;
      <D.28172>:
      <D.28187>:
      <D.28184>:
      <D.28182>:
      <D.28180>:
      <D.28176>:
      iter = 0B;
      goto <D.24931>;
      <D.24932>:
      D.28173 = acfg->opts;
      D.28174 = D.28173 & 16777216;
      if (D.28174 != 0) goto <D.28268>; else goto <D.28269>;
      <D.28268>:
      D.28270 = BIT_FIELD_REF <*method, 64, 256>;
      D.28271 = D.28270 & 4096;
      if (D.28271 != 0) goto <D.28272>; else goto <D.28273>;
      <D.28272>:
      D.28274 = mono_method_get_context (method);
      D.28275 = D.28274->method_inst;
      if (D.28275 != 0B) goto <D.28276>; else goto <D.28277>;
      <D.28276>:
      // predicted unlikely by continue predictor.
      goto <D.24931>;
      <D.28277>:
      <D.28273>:
      <D.28269>:
      D.28278 = mono_method_is_generic_sharable_full (method, 0, 0, use_gsharedvt);
      if (D.28278 != 0) goto <D.28279>; else goto <D.28280>;
      <D.28279>:
      add_types_from_method_header (acfg, method);
      // predicted unlikely by continue predictor.
      goto <D.24931>;
      <D.28280>:
      D.28270 = BIT_FIELD_REF <*method, 64, 256>;
      D.28281 = D.28270 & 2048;
      if (D.28281 != 0) goto <D.28282>; else goto <D.28283>;
      <D.28282>:
      // predicted unlikely by continue predictor.
      goto <D.24931>;
      <D.28283>:
      D.28284 = depth + 1;
      add_extra_method_with_depth (acfg, method, D.28284);
      <D.24931>:
      method = mono_class_get_methods (klass, &iter);
      if (method != 0B) goto <D.24932>; else goto <D.24933>;
      <D.24933>:
      iter = 0B;
      goto <D.24935>;
      <D.24934>:
      D.28285 = field->type;
      D.28286 = D.28285->type;
      if (D.28286 == 21) goto <D.28287>; else goto <D.28288>;
      <D.28287>:
      D.28285 = field->type;
      D.28289 = mono_class_from_mono_type (D.28285);
      D.28284 = depth + 1;
      add_generic_class_with_depth (acfg, D.28289, D.28284, "field");
      <D.28288>:
      <D.24935>:
      field = mono_class_get_fields (klass, &iter);
      if (field != 0B) goto <D.24934>; else goto <D.24936>;
      <D.24936>:
      D.28290 = BIT_FIELD_REF <*klass, 64, 256>;
      D.28291 = D.28290 & 16777216;
      if (D.28291 != 0) goto <D.28292>; else goto <D.28293>;
      <D.28292>:
      method = mono_get_delegate_invoke (klass);
      method = mono_marshal_get_delegate_invoke (method, 0B);
      D.28167 = acfg->aot_opts.log_generics;
      if (D.28167 != 0) goto <D.28294>; else goto <D.28295>;
      <D.28294>:
      D.28296 = mono_method_full_name (method, 1);
      printf ("%*sAdding method %s.\n", depth, "", D.28296);
      <D.28295>:
      add_method (acfg, method);
      <D.28293>:
      D.28297 = klass->parent;
      if (D.28297 != 0B) goto <D.28298>; else goto <D.28299>;
      <D.28298>:
      D.28297 = klass->parent;
      add_generic_class_with_depth (acfg, D.28297, depth, "parent");
      <D.28299>:
      D.28177 = klass->image;
      D.28178 = mono_defaults.corlib;
      if (D.28177 == D.28178) goto <D.28302>; else goto <D.28303>;
      <D.28302>:
      {
        size_t __s1_len;
        size_t __s2_len;

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

          __s2 = klass->name_space;
          D.28307 = "System.Collections.Generic";
          D.28308 = MEM[(const unsigned char *)D.28307];
          D.28309 = (int) D.28308;
          D.28310 = *__s2;
          D.28311 = (int) D.28310;
          __result = D.28309 - D.28311;
          {
            if (__s2_len != 0) goto <D.28312>; else goto <D.28313>;
            <D.28312>:
            if (__result == 0) goto <D.28314>; else goto <D.28315>;
            <D.28314>:
            D.28316 = &MEM[(void *)"System.Collections.Generic" + 1B];
            D.28317 = *D.28316;
            D.28318 = (int) D.28317;
            D.28319 = __s2 + 1;
            D.28320 = *D.28319;
            D.28321 = (int) D.28320;
            __result = D.28318 - D.28321;
            if (__s2_len > 1) goto <D.28322>; else goto <D.28323>;
            <D.28322>:
            if (__result == 0) goto <D.28324>; else goto <D.28325>;
            <D.28324>:
            D.28326 = &MEM[(void *)"System.Collections.Generic" + 2B];
            D.28327 = *D.28326;
            D.28328 = (int) D.28327;
            D.28329 = __s2 + 2;
            D.28330 = *D.28329;
            D.28331 = (int) D.28330;
            __result = D.28328 - D.28331;
            if (__s2_len > 2) goto <D.28332>; else goto <D.28333>;
            <D.28332>:
            if (__result == 0) goto <D.28334>; else goto <D.28335>;
            <D.28334>:
            D.28336 = &MEM[(void *)"System.Collections.Generic" + 3B];
            D.28337 = *D.28336;
            D.28338 = (int) D.28337;
            D.28339 = __s2 + 3;
            D.28340 = *D.28339;
            D.28341 = (int) D.28340;
            __result = D.28338 - D.28341;
            <D.28335>:
            <D.28333>:
            <D.28325>:
            <D.28323>:
            <D.28315>:
            <D.28313>:
          }
          D.24944 = __result;
        }
        iftmp.59 = -D.24944;
        goto <D.28342>;
        <D.28306>:
        D.28343 = klass->name_space;
        iftmp.59 = __builtin_strcmp (D.28343, "System.Collections.Generic");
        <D.28342>:
        D.24945 = iftmp.59;
      }
      if (D.24945 == 0) goto <D.28344>; else goto <D.28345>;
      <D.28344>:
      {
        size_t __s1_len;
        size_t __s2_len;

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

          __s2 = klass->name;
          D.28349 = "ICollection`1";
          D.28350 = MEM[(const unsigned char *)D.28349];
          D.28351 = (int) D.28350;
          D.28352 = *__s2;
          D.28353 = (int) D.28352;
          __result = D.28351 - D.28353;
          {
            if (__s2_len != 0) goto <D.28354>; else goto <D.28355>;
            <D.28354>:
            if (__result == 0) goto <D.28356>; else goto <D.28357>;
            <D.28356>:
            D.28358 = &MEM[(void *)"ICollection`1" + 1B];
            D.28359 = *D.28358;
            D.28360 = (int) D.28359;
            D.28361 = __s2 + 1;
            D.28362 = *D.28361;
            D.28363 = (int) D.28362;
            __result = D.28360 - D.28363;
            if (__s2_len > 1) goto <D.28364>; else goto <D.28365>;
            <D.28364>:
            if (__result == 0) goto <D.28366>; else goto <D.28367>;
            <D.28366>:
            D.28368 = &MEM[(void *)"ICollection`1" + 2B];
            D.28369 = *D.28368;
            D.28370 = (int) D.28369;
            D.28371 = __s2 + 2;
            D.28372 = *D.28371;
            D.28373 = (int) D.28372;
            __result = D.28370 - D.28373;
            if (__s2_len > 2) goto <D.28374>; else goto <D.28375>;
            <D.28374>:
            if (__result == 0) goto <D.28376>; else goto <D.28377>;
            <D.28376>:
            D.28378 = &MEM[(void *)"ICollection`1" + 3B];
            D.28379 = *D.28378;
            D.28380 = (int) D.28379;
            D.28381 = __s2 + 3;
            D.28382 = *D.28381;
            D.28383 = (int) D.28382;
            __result = D.28380 - D.28383;
            <D.28377>:
            <D.28375>:
            <D.28367>:
            <D.28365>:
            <D.28357>:
            <D.28355>:
          }
          D.24953 = __result;
        }
        iftmp.60 = -D.24953;
        goto <D.28384>;
        <D.28348>:
        D.28227 = klass->name;
        iftmp.60 = __builtin_strcmp (D.28227, "ICollection`1");
        <D.28384>:
        D.24954 = iftmp.60;
      }
      if (D.24954 == 0) goto <D.28300>; else goto <D.28385>;
      <D.28385>:
      {
        size_t __s1_len;
        size_t __s2_len;

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

          __s2 = klass->name;
          D.28389 = "IEnumerable`1";
          D.28390 = MEM[(const unsigned char *)D.28389];
          D.28391 = (int) D.28390;
          D.28392 = *__s2;
          D.28393 = (int) D.28392;
          __result = D.28391 - D.28393;
          {
            if (__s2_len != 0) goto <D.28394>; else goto <D.28395>;
            <D.28394>:
            if (__result == 0) goto <D.28396>; else goto <D.28397>;
            <D.28396>:
            D.28398 = &MEM[(void *)"IEnumerable`1" + 1B];
            D.28399 = *D.28398;
            D.28400 = (int) D.28399;
            D.28401 = __s2 + 1;
            D.28402 = *D.28401;
            D.28403 = (int) D.28402;
            __result = D.28400 - D.28403;
            if (__s2_len > 1) goto <D.28404>; else goto <D.28405>;
            <D.28404>:
            if (__result == 0) goto <D.28406>; else goto <D.28407>;
            <D.28406>:
            D.28408 = &MEM[(void *)"IEnumerable`1" + 2B];
            D.28409 = *D.28408;
            D.28410 = (int) D.28409;
            D.28411 = __s2 + 2;
            D.28412 = *D.28411;
            D.28413 = (int) D.28412;
            __result = D.28410 - D.28413;
            if (__s2_len > 2) goto <D.28414>; else goto <D.28415>;
            <D.28414>:
            if (__result == 0) goto <D.28416>; else goto <D.28417>;
            <D.28416>:
            D.28418 = &MEM[(void *)"IEnumerable`1" + 3B];
            D.28419 = *D.28418;
            D.28420 = (int) D.28419;
            D.28421 = __s2 + 3;
            D.28422 = *D.28421;
            D.28423 = (int) D.28422;
            __result = D.28420 - D.28423;
            <D.28417>:
            <D.28415>:
            <D.28407>:
            <D.28405>:
            <D.28397>:
            <D.28395>:
          }
          D.24962 = __result;
        }
        iftmp.61 = -D.24962;
        goto <D.28424>;
        <D.28388>:
        D.28227 = klass->name;
        iftmp.61 = __builtin_strcmp (D.28227, "IEnumerable`1");
        <D.28424>:
        D.24963 = iftmp.61;
      }
      if (D.24963 == 0) goto <D.28300>; else goto <D.28425>;
      <D.28425>:
      {
        size_t __s1_len;
        size_t __s2_len;

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

          __s2 = klass->name;
          D.28429 = "IList`1";
          D.28430 = MEM[(const unsigned char *)D.28429];
          D.28431 = (int) D.28430;
          D.28432 = *__s2;
          D.28433 = (int) D.28432;
          __result = D.28431 - D.28433;
          {
            if (__s2_len != 0) goto <D.28434>; else goto <D.28435>;
            <D.28434>:
            if (__result == 0) goto <D.28436>; else goto <D.28437>;
            <D.28436>:
            D.28438 = &MEM[(void *)"IList`1" + 1B];
            D.28439 = *D.28438;
            D.28440 = (int) D.28439;
            D.28441 = __s2 + 1;
            D.28442 = *D.28441;
            D.28443 = (int) D.28442;
            __result = D.28440 - D.28443;
            if (__s2_len > 1) goto <D.28444>; else goto <D.28445>;
            <D.28444>:
            if (__result == 0) goto <D.28446>; else goto <D.28447>;
            <D.28446>:
            D.28448 = &MEM[(void *)"IList`1" + 2B];
            D.28449 = *D.28448;
            D.28450 = (int) D.28449;
            D.28451 = __s2 + 2;
            D.28452 = *D.28451;
            D.28453 = (int) D.28452;
            __result = D.28450 - D.28453;
            if (__s2_len > 2) goto <D.28454>; else goto <D.28455>;
            <D.28454>:
            if (__result == 0) goto <D.28456>; else goto <D.28457>;
            <D.28456>:
            D.28458 = &MEM[(void *)"IList`1" + 3B];
            D.28459 = *D.28458;
            D.28460 = (int) D.28459;
            D.28461 = __s2 + 3;
            D.28462 = *D.28461;
            D.28463 = (int) D.28462;
            __result = D.28460 - D.28463;
            <D.28457>:
            <D.28455>:
            <D.28447>:
            <D.28445>:
            <D.28437>:
            <D.28435>:
          }
          D.24971 = __result;
        }
        iftmp.62 = -D.24971;
        goto <D.28464>;
        <D.28428>:
        D.28227 = klass->name;
        iftmp.62 = __builtin_strcmp (D.28227, "IList`1");
        <D.28464>:
        D.24972 = iftmp.62;
      }
      if (D.24972 == 0) goto <D.28300>; else goto <D.28465>;
      <D.28465>:
      {
        size_t __s1_len;
        size_t __s2_len;

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

          __s2 = klass->name;
          D.28469 = "IEnumerator`1";
          D.28470 = MEM[(const unsigned char *)D.28469];
          D.28471 = (int) D.28470;
          D.28472 = *__s2;
          D.28473 = (int) D.28472;
          __result = D.28471 - D.28473;
          {
            if (__s2_len != 0) goto <D.28474>; else goto <D.28475>;
            <D.28474>:
            if (__result == 0) goto <D.28476>; else goto <D.28477>;
            <D.28476>:
            D.28478 = &MEM[(void *)"IEnumerator`1" + 1B];
            D.28479 = *D.28478;
            D.28480 = (int) D.28479;
            D.28481 = __s2 + 1;
            D.28482 = *D.28481;
            D.28483 = (int) D.28482;
            __result = D.28480 - D.28483;
            if (__s2_len > 1) goto <D.28484>; else goto <D.28485>;
            <D.28484>:
            if (__result == 0) goto <D.28486>; else goto <D.28487>;
            <D.28486>:
            D.28488 = &MEM[(void *)"IEnumerator`1" + 2B];
            D.28489 = *D.28488;
            D.28490 = (int) D.28489;
            D.28491 = __s2 + 2;
            D.28492 = *D.28491;
            D.28493 = (int) D.28492;
            __result = D.28490 - D.28493;
            if (__s2_len > 2) goto <D.28494>; else goto <D.28495>;
            <D.28494>:
            if (__result == 0) goto <D.28496>; else goto <D.28497>;
            <D.28496>:
            D.28498 = &MEM[(void *)"IEnumerator`1" + 3B];
            D.28499 = *D.28498;
            D.28500 = (int) D.28499;
            D.28501 = __s2 + 3;
            D.28502 = *D.28501;
            D.28503 = (int) D.28502;
            __result = D.28500 - D.28503;
            <D.28497>:
            <D.28495>:
            <D.28487>:
            <D.28485>:
            <D.28477>:
            <D.28475>:
          }
          D.24980 = __result;
        }
        iftmp.63 = -D.24980;
        goto <D.28504>;
        <D.28468>:
        D.28227 = klass->name;
        iftmp.63 = __builtin_strcmp (D.28227, "IEnumerator`1");
        <D.28504>:
        D.24981 = iftmp.63;
      }
      if (D.24981 == 0) goto <D.28300>; else goto <D.28505>;
      <D.28505>:
      {
        size_t __s1_len;
        size_t __s2_len;

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

          __s2 = klass->name;
          D.28509 = "IReadOnlyList`1";
          D.28510 = MEM[(const unsigned char *)D.28509];
          D.28511 = (int) D.28510;
          D.28512 = *__s2;
          D.28513 = (int) D.28512;
          __result = D.28511 - D.28513;
          {
            if (__s2_len != 0) goto <D.28514>; else goto <D.28515>;
            <D.28514>:
            if (__result == 0) goto <D.28516>; else goto <D.28517>;
            <D.28516>:
            D.28518 = &MEM[(void *)"IReadOnlyList`1" + 1B];
            D.28519 = *D.28518;
            D.28520 = (int) D.28519;
            D.28521 = __s2 + 1;
            D.28522 = *D.28521;
            D.28523 = (int) D.28522;
            __result = D.28520 - D.28523;
            if (__s2_len > 1) goto <D.28524>; else goto <D.28525>;
            <D.28524>:
            if (__result == 0) goto <D.28526>; else goto <D.28527>;
            <D.28526>:
            D.28528 = &MEM[(void *)"IReadOnlyList`1" + 2B];
            D.28529 = *D.28528;
            D.28530 = (int) D.28529;
            D.28531 = __s2 + 2;
            D.28532 = *D.28531;
            D.28533 = (int) D.28532;
            __result = D.28530 - D.28533;
            if (__s2_len > 2) goto <D.28534>; else goto <D.28535>;
            <D.28534>:
            if (__result == 0) goto <D.28536>; else goto <D.28537>;
            <D.28536>:
            D.28538 = &MEM[(void *)"IReadOnlyList`1" + 3B];
            D.28539 = *D.28538;
            D.28540 = (int) D.28539;
            D.28541 = __s2 + 3;
            D.28542 = *D.28541;
            D.28543 = (int) D.28542;
            __result = D.28540 - D.28543;
            <D.28537>:
            <D.28535>:
            <D.28527>:
            <D.28525>:
            <D.28517>:
            <D.28515>:
          }
          D.24989 = __result;
        }
        iftmp.64 = -D.24989;
        goto <D.28544>;
        <D.28508>:
        D.28227 = klass->name;
        iftmp.64 = __builtin_strcmp (D.28227, "IReadOnlyList`1");
        <D.28544>:
        D.24990 = iftmp.64;
      }
      if (D.24990 == 0) goto <D.28300>; else goto <D.28301>;
      <D.28300>:
      {
        struct MonoClass * tclass;
        struct MonoClass * array_class;
        void * iter;
        char * name_prefix;

        try
          {
            D.28138 = klass->generic_class;
            D.28141 = D.28138->context.class_inst;
            D.28545 = D.28141->type_argv[0];
            tclass = mono_class_from_mono_type (D.28545);
            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.28547>; else goto <D.28548>;
              <D.28547>:
              {
                const unsigned char * __s2;
                int __result;

                __s2 = klass->name;
                D.28469 = "IEnumerator`1";
                D.28470 = MEM[(const unsigned char *)D.28469];
                D.28471 = (int) D.28470;
                D.28549 = *__s2;
                D.28550 = (int) D.28549;
                __result = D.28471 - D.28550;
                {
                  if (__s2_len != 0) goto <D.28551>; else goto <D.28552>;
                  <D.28551>:
                  if (__result == 0) goto <D.28553>; else goto <D.28554>;
                  <D.28553>:
                  D.28478 = &MEM[(void *)"IEnumerator`1" + 1B];
                  D.28479 = *D.28478;
                  D.28480 = (int) D.28479;
                  D.28555 = __s2 + 1;
                  D.28556 = *D.28555;
                  D.28557 = (int) D.28556;
                  __result = D.28480 - D.28557;
                  if (__s2_len > 1) goto <D.28558>; else goto <D.28559>;
                  <D.28558>:
                  if (__result == 0) goto <D.28560>; else goto <D.28561>;
                  <D.28560>:
                  D.28488 = &MEM[(void *)"IEnumerator`1" + 2B];
                  D.28489 = *D.28488;
                  D.28490 = (int) D.28489;
                  D.28562 = __s2 + 2;
                  D.28563 = *D.28562;
                  D.28564 = (int) D.28563;
                  __result = D.28490 - D.28564;
                  if (__s2_len > 2) goto <D.28565>; else goto <D.28566>;
                  <D.28565>:
                  if (__result == 0) goto <D.28567>; else goto <D.28568>;
                  <D.28567>:
                  D.28498 = &MEM[(void *)"IEnumerator`1" + 3B];
                  D.28499 = *D.28498;
                  D.28500 = (int) D.28499;
                  D.28569 = __s2 + 3;
                  D.28570 = *D.28569;
                  D.28571 = (int) D.28570;
                  __result = D.28500 - D.28571;
                  <D.28568>:
                  <D.28566>:
                  <D.28561>:
                  <D.28559>:
                  <D.28554>:
                  <D.28552>:
                }
                D.25002 = __result;
              }
              iftmp.65 = -D.25002;
              goto <D.28572>;
              <D.28548>:
              D.28227 = klass->name;
              iftmp.65 = __builtin_strcmp (D.28227, "IEnumerator`1");
              <D.28572>:
              D.25003 = iftmp.65;
            }
            if (D.25003 == 0) goto <D.28573>; else goto <D.28574>;
            <D.28573>:
            D.28343 = klass->name_space;
            name_prefix = monoeg_g_strdup_printf ("%s.%s", D.28343, "IEnumerable`1");
            goto <D.28575>;
            <D.28574>:
            D.28343 = klass->name_space;
            D.28227 = klass->name;
            name_prefix = monoeg_g_strdup_printf ("%s.%s", D.28343, D.28227);
            <D.28575>:
            {
              size_t __s1_len;
              size_t __s2_len;

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

                __s2 = klass->name;
                D.28389 = "IEnumerable`1";
                D.28390 = MEM[(const unsigned char *)D.28389];
                D.28391 = (int) D.28390;
                D.28581 = *__s2;
                D.28582 = (int) D.28581;
                __result = D.28391 - D.28582;
                {
                  if (__s2_len != 0) goto <D.28583>; else goto <D.28584>;
                  <D.28583>:
                  if (__result == 0) goto <D.28585>; else goto <D.28586>;
                  <D.28585>:
                  D.28398 = &MEM[(void *)"IEnumerable`1" + 1B];
                  D.28399 = *D.28398;
                  D.28400 = (int) D.28399;
                  D.28587 = __s2 + 1;
                  D.28588 = *D.28587;
                  D.28589 = (int) D.28588;
                  __result = D.28400 - D.28589;
                  if (__s2_len > 1) goto <D.28590>; else goto <D.28591>;
                  <D.28590>:
                  if (__result == 0) goto <D.28592>; else goto <D.28593>;
                  <D.28592>:
                  D.28408 = &MEM[(void *)"IEnumerable`1" + 2B];
                  D.28409 = *D.28408;
                  D.28410 = (int) D.28409;
                  D.28594 = __s2 + 2;
                  D.28595 = *D.28594;
                  D.28596 = (int) D.28595;
                  __result = D.28410 - D.28596;
                  if (__s2_len > 2) goto <D.28597>; else goto <D.28598>;
                  <D.28597>:
                  if (__result == 0) goto <D.28599>; else goto <D.28600>;
                  <D.28599>:
                  D.28418 = &MEM[(void *)"IEnumerable`1" + 3B];
                  D.28419 = *D.28418;
                  D.28420 = (int) D.28419;
                  D.28601 = __s2 + 3;
                  D.28602 = *D.28601;
                  D.28603 = (int) D.28602;
                  __result = D.28420 - D.28603;
                  <D.28600>:
                  <D.28598>:
                  <D.28593>:
                  <D.28591>:
                  <D.28586>:
                  <D.28584>:
                }
                D.25011 = __result;
              }
              iftmp.66 = -D.25011;
              goto <D.28604>;
              <D.28580>:
              D.28227 = klass->name;
              iftmp.66 = __builtin_strcmp (D.28227, "IEnumerable`1");
              <D.28604>:
              D.25012 = iftmp.66;
            }
            if (D.25012 == 0) goto <D.28576>; else goto <D.28605>;
            <D.28605>:
            {
              size_t __s1_len;
              size_t __s2_len;

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

                __s2 = klass->name;
                D.28469 = "IEnumerator`1";
                D.28470 = MEM[(const unsigned char *)D.28469];
                D.28471 = (int) D.28470;
                D.28609 = *__s2;
                D.28610 = (int) D.28609;
                __result = D.28471 - D.28610;
                {
                  if (__s2_len != 0) goto <D.28611>; else goto <D.28612>;
                  <D.28611>:
                  if (__result == 0) goto <D.28613>; else goto <D.28614>;
                  <D.28613>:
                  D.28478 = &MEM[(void *)"IEnumerator`1" + 1B];
                  D.28479 = *D.28478;
                  D.28480 = (int) D.28479;
                  D.28615 = __s2 + 1;
                  D.28616 = *D.28615;
                  D.28617 = (int) D.28616;
                  __result = D.28480 - D.28617;
                  if (__s2_len > 1) goto <D.28618>; else goto <D.28619>;
                  <D.28618>:
                  if (__result == 0) goto <D.28620>; else goto <D.28621>;
                  <D.28620>:
                  D.28488 = &MEM[(void *)"IEnumerator`1" + 2B];
                  D.28489 = *D.28488;
                  D.28490 = (int) D.28489;
                  D.28622 = __s2 + 2;
                  D.28623 = *D.28622;
                  D.28624 = (int) D.28623;
                  __result = D.28490 - D.28624;
                  if (__s2_len > 2) goto <D.28625>; else goto <D.28626>;
                  <D.28625>:
                  if (__result == 0) goto <D.28627>; else goto <D.28628>;
                  <D.28627>:
                  D.28498 = &MEM[(void *)"IEnumerator`1" + 3B];
                  D.28499 = *D.28498;
                  D.28500 = (int) D.28499;
                  D.28629 = __s2 + 3;
                  D.28630 = *D.28629;
                  D.28631 = (int) D.28630;
                  __result = D.28500 - D.28631;
                  <D.28628>:
                  <D.28626>:
                  <D.28621>:
                  <D.28619>:
                  <D.28614>:
                  <D.28612>:
                }
                D.25020 = __result;
              }
              iftmp.67 = -D.25020;
              goto <D.28632>;
              <D.28608>:
              D.28227 = klass->name;
              iftmp.67 = __builtin_strcmp (D.28227, "IEnumerator`1");
              <D.28632>:
              D.25021 = iftmp.67;
            }
            if (D.25021 == 0) goto <D.28576>; else goto <D.28577>;
            <D.28576>:
            {
              struct MonoClass * nclass;

              iter = 0B;
              goto <D.25034>;
              <D.25033>:
              {
                size_t __s1_len;
                size_t __s2_len;

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

                  __s2 = nclass->name;
                  D.28636 = "InternalEnumerator`1";
                  D.28637 = MEM[(const unsigned char *)D.28636];
                  D.28638 = (int) D.28637;
                  D.28639 = *__s2;
                  D.28640 = (int) D.28639;
                  __result = D.28638 - D.28640;
                  {
                    if (__s2_len != 0) goto <D.28641>; else goto <D.28642>;
                    <D.28641>:
                    if (__result == 0) goto <D.28643>; else goto <D.28644>;
                    <D.28643>:
                    D.28645 = &MEM[(void *)"InternalEnumerator`1" + 1B];
                    D.28646 = *D.28645;
                    D.28647 = (int) D.28646;
                    D.28648 = __s2 + 1;
                    D.28649 = *D.28648;
                    D.28650 = (int) D.28649;
                    __result = D.28647 - D.28650;
                    if (__s2_len > 1) goto <D.28651>; else goto <D.28652>;
                    <D.28651>:
                    if (__result == 0) goto <D.28653>; else goto <D.28654>;
                    <D.28653>:
                    D.28655 = &MEM[(void *)"InternalEnumerator`1" + 2B];
                    D.28656 = *D.28655;
                    D.28657 = (int) D.28656;
                    D.28658 = __s2 + 2;
                    D.28659 = *D.28658;
                    D.28660 = (int) D.28659;
                    __result = D.28657 - D.28660;
                    if (__s2_len > 2) goto <D.28661>; else goto <D.28662>;
                    <D.28661>:
                    if (__result == 0) goto <D.28663>; else goto <D.28664>;
                    <D.28663>:
                    D.28665 = &MEM[(void *)"InternalEnumerator`1" + 3B];
                    D.28666 = *D.28665;
                    D.28667 = (int) D.28666;
                    D.28668 = __s2 + 3;
                    D.28669 = *D.28668;
                    D.28670 = (int) D.28669;
                    __result = D.28667 - D.28670;
                    <D.28664>:
                    <D.28662>:
                    <D.28654>:
                    <D.28652>:
                    <D.28644>:
                    <D.28642>:
                  }
                  D.25030 = __result;
                }
                iftmp.68 = -D.25030;
                goto <D.28671>;
                <D.28635>:
                D.28672 = nclass->name;
                iftmp.68 = __builtin_strcmp (D.28672, "InternalEnumerator`1");
                <D.28671>:
                D.25031 = iftmp.68;
              }
              if (D.25031 == 0) goto <D.25032>; else goto <D.28673>;
              <D.28673>:
              <D.25034>:
              D.28674 = array_class->parent;
              nclass = mono_class_get_nested_types (D.28674, &iter);
              if (nclass != 0B) goto <D.25033>; else goto <D.25032>;
              <D.25032>:
              D.28675 = nclass == 0B;
              D.28676 = (long int) D.28675;
              D.28677 = __builtin_expect (D.28676, 0);
              if (D.28677 != 0) goto <D.28678>; else goto <D.28679>;
              <D.28678>:
              monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "aot-compiler.c", 3948, "nclass");
              <D.28679>:
              D.28138 = klass->generic_class;
              D.28680 = mono_generic_class_get_context (D.28138);
              nclass = mono_class_inflate_generic_class (nclass, D.28680);
              add_generic_class (acfg, nclass, 0, "ICollection<T>");
            }
            <D.28577>:
            iter = 0B;
            goto <D.25037>;
            <D.25036>:
            D.28681 = method->name;
            D.28682 = strstr (D.28681, name_prefix);
            if (D.28682 != 0B) goto <D.28683>; else goto <D.28684>;
            <D.28683>:
            {
              struct MonoMethod * m;

              m = mono_aot_get_array_helper_from_wrapper (method);
              add_extra_method_with_depth (acfg, m, depth);
            }
            <D.28684>:
            <D.25037>:
            method = mono_class_get_methods (array_class, &iter);
            if (method != 0B) goto <D.25036>; else goto <D.25038>;
            <D.25038>:
            monoeg_g_free (name_prefix);
          }
        finally
          {
            iter = {CLOBBER};
          }
      }
      <D.28301>:
      <D.28345>:
      <D.28303>:
      D.28177 = klass->image;
      D.28178 = mono_defaults.corlib;
      if (D.28177 == D.28178) goto <D.28685>; else goto <D.28686>;
      <D.28685>:
      {
        size_t __s1_len;
        size_t __s2_len;

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

          __s2 = klass->name_space;
          D.28307 = "System.Collections.Generic";
          D.28308 = MEM[(const unsigned char *)D.28307];
          D.28309 = (int) D.28308;
          D.28690 = *__s2;
          D.28691 = (int) D.28690;
          __result = D.28309 - D.28691;
          {
            if (__s2_len != 0) goto <D.28692>; else goto <D.28693>;
            <D.28692>:
            if (__result == 0) goto <D.28694>; else goto <D.28695>;
            <D.28694>:
            D.28316 = &MEM[(void *)"System.Collections.Generic" + 1B];
            D.28317 = *D.28316;
            D.28318 = (int) D.28317;
            D.28696 = __s2 + 1;
            D.28697 = *D.28696;
            D.28698 = (int) D.28697;
            __result = D.28318 - D.28698;
            if (__s2_len > 1) goto <D.28699>; else goto <D.28700>;
            <D.28699>:
            if (__result == 0) goto <D.28701>; else goto <D.28702>;
            <D.28701>:
            D.28326 = &MEM[(void *)"System.Collections.Generic" + 2B];
            D.28327 = *D.28326;
            D.28328 = (int) D.28327;
            D.28703 = __s2 + 2;
            D.28704 = *D.28703;
            D.28705 = (int) D.28704;
            __result = D.28328 - D.28705;
            if (__s2_len > 2) goto <D.28706>; else goto <D.28707>;
            <D.28706>:
            if (__result == 0) goto <D.28708>; else goto <D.28709>;
            <D.28708>:
            D.28336 = &MEM[(void *)"System.Collections.Generic" + 3B];
            D.28337 = *D.28336;
            D.28338 = (int) D.28337;
            D.28710 = __s2 + 3;
            D.28711 = *D.28710;
            D.28712 = (int) D.28711;
            __result = D.28338 - D.28712;
            <D.28709>:
            <D.28707>:
            <D.28702>:
            <D.28700>:
            <D.28695>:
            <D.28693>:
          }
          D.25046 = __result;
        }
        iftmp.69 = -D.25046;
        goto <D.28713>;
        <D.28689>:
        D.28343 = klass->name_space;
        iftmp.69 = __builtin_strcmp (D.28343, "System.Collections.Generic");
        <D.28713>:
        D.25047 = iftmp.69;
      }
      if (D.25047 == 0) goto <D.28714>; else goto <D.28715>;
      <D.28714>:
      {
        size_t __s1_len;
        size_t __s2_len;

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

          __s2 = klass->name;
          D.28719 = "Comparer`1";
          D.28720 = MEM[(const unsigned char *)D.28719];
          D.28721 = (int) D.28720;
          D.28722 = *__s2;
          D.28723 = (int) D.28722;
          __result = D.28721 - D.28723;
          {
            if (__s2_len != 0) goto <D.28724>; else goto <D.28725>;
            <D.28724>:
            if (__result == 0) goto <D.28726>; else goto <D.28727>;
            <D.28726>:
            D.28728 = &MEM[(void *)"Comparer`1" + 1B];
            D.28729 = *D.28728;
            D.28730 = (int) D.28729;
            D.28731 = __s2 + 1;
            D.28732 = *D.28731;
            D.28733 = (int) D.28732;
            __result = D.28730 - D.28733;
            if (__s2_len > 1) goto <D.28734>; else goto <D.28735>;
            <D.28734>:
            if (__result == 0) goto <D.28736>; else goto <D.28737>;
            <D.28736>:
            D.28738 = &MEM[(void *)"Comparer`1" + 2B];
            D.28739 = *D.28738;
            D.28740 = (int) D.28739;
            D.28741 = __s2 + 2;
            D.28742 = *D.28741;
            D.28743 = (int) D.28742;
            __result = D.28740 - D.28743;
            if (__s2_len > 2) goto <D.28744>; else goto <D.28745>;
            <D.28744>:
            if (__result == 0) goto <D.28746>; else goto <D.28747>;
            <D.28746>:
            D.28748 = &MEM[(void *)"Comparer`1" + 3B];
            D.28749 = *D.28748;
            D.28750 = (int) D.28749;
            D.28751 = __s2 + 3;
            D.28752 = *D.28751;
            D.28753 = (int) D.28752;
            __result = D.28750 - D.28753;
            <D.28747>:
            <D.28745>:
            <D.28737>:
            <D.28735>:
            <D.28727>:
            <D.28725>:
          }
          D.25055 = __result;
        }
        iftmp.70 = -D.25055;
        goto <D.28754>;
        <D.28718>:
        D.28227 = klass->name;
        iftmp.70 = __builtin_strcmp (D.28227, "Comparer`1");
        <D.28754>:
        D.25056 = iftmp.70;
      }
      if (D.25056 == 0) goto <D.28755>; else goto <D.28756>;
      <D.28755>:
      {
        struct MonoClass * tclass;
        struct MonoClass * icomparable;
        struct MonoClass * gcomparer;
        struct MonoGenericContext ctx;
        struct MonoType * args[16];

        try
          {
            D.28138 = klass->generic_class;
            D.28141 = D.28138->context.class_inst;
            D.28545 = D.28141->type_argv[0];
            tclass = mono_class_from_mono_type (D.28545);
            memset (&ctx, 0, 16);
            D.28178 = mono_defaults.corlib;
            icomparable = mono_class_from_name (D.28178, "System", "IComparable`1");
            D.28757 = icomparable == 0B;
            D.28758 = (long int) D.28757;
            D.28759 = __builtin_expect (D.28758, 0);
            if (D.28759 != 0) goto <D.28760>; else goto <D.28761>;
            <D.28760>:
            monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "aot-compiler.c", 3975, "icomparable");
            <D.28761>:
            D.28762 = &tclass->byval_arg;
            args[0] = D.28762;
            D.28763 = mono_metadata_get_generic_inst (1, &args);
            ctx.class_inst = D.28763;
            D.28764 = mono_class_inflate_generic_class (icomparable, &ctx);
            D.28765 = mono_class_is_assignable_from (D.28764, tclass);
            if (D.28765 != 0) goto <D.28766>; else goto <D.28767>;
            <D.28766>:
            D.28178 = mono_defaults.corlib;
            gcomparer = mono_class_from_name (D.28178, "System.Collections.Generic", "GenericComparer`1");
            D.28768 = gcomparer == 0B;
            D.28769 = (long int) D.28768;
            D.28770 = __builtin_expect (D.28769, 0);
            if (D.28770 != 0) goto <D.28771>; else goto <D.28772>;
            <D.28771>:
            monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "aot-compiler.c", 3981, "gcomparer");
            <D.28772>:
            D.28773 = mono_class_inflate_generic_class (gcomparer, &ctx);
            add_generic_class (acfg, D.28773, 0, "Comparer<T>");
            <D.28767>:
          }
        finally
          {
            ctx = {CLOBBER};
            args = {CLOBBER};
          }
      }
      <D.28756>:
      <D.28715>:
      <D.28686>:
      D.28177 = klass->image;
      D.28178 = mono_defaults.corlib;
      if (D.28177 == D.28178) goto <D.28774>; else goto <D.28775>;
      <D.28774>:
      {
        size_t __s1_len;
        size_t __s2_len;

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

          __s2 = klass->name_space;
          D.28307 = "System.Collections.Generic";
          D.28308 = MEM[(const unsigned char *)D.28307];
          D.28309 = (int) D.28308;
          D.28779 = *__s2;
          D.28780 = (int) D.28779;
          __result = D.28309 - D.28780;
          {
            if (__s2_len != 0) goto <D.28781>; else goto <D.28782>;
            <D.28781>:
            if (__result == 0) goto <D.28783>; else goto <D.28784>;
            <D.28783>:
            D.28316 = &MEM[(void *)"System.Collections.Generic" + 1B];
            D.28317 = *D.28316;
            D.28318 = (int) D.28317;
            D.28785 = __s2 + 1;
            D.28786 = *D.28785;
            D.28787 = (int) D.28786;
            __result = D.28318 - D.28787;
            if (__s2_len > 1) goto <D.28788>; else goto <D.28789>;
            <D.28788>:
            if (__result == 0) goto <D.28790>; else goto <D.28791>;
            <D.28790>:
            D.28326 = &MEM[(void *)"System.Collections.Generic" + 2B];
            D.28327 = *D.28326;
            D.28328 = (int) D.28327;
            D.28792 = __s2 + 2;
            D.28793 = *D.28792;
            D.28794 = (int) D.28793;
            __result = D.28328 - D.28794;
            if (__s2_len > 2) goto <D.28795>; else goto <D.28796>;
            <D.28795>:
            if (__result == 0) goto <D.28797>; else goto <D.28798>;
            <D.28797>:
            D.28336 = &MEM[(void *)"System.Collections.Generic" + 3B];
            D.28337 = *D.28336;
            D.28338 = (int) D.28337;
            D.28799 = __s2 + 3;
            D.28800 = *D.28799;
            D.28801 = (int) D.28800;
            __result = D.28338 - D.28801;
            <D.28798>:
            <D.28796>:
            <D.28791>:
            <D.28789>:
            <D.28784>:
            <D.28782>:
          }
          D.25069 = __result;
        }
        iftmp.71 = -D.25069;
        goto <D.28802>;
        <D.28778>:
        D.28343 = klass->name_space;
        iftmp.71 = __builtin_strcmp (D.28343, "System.Collections.Generic");
        <D.28802>:
        D.25070 = iftmp.71;
      }
      if (D.25070 == 0) goto <D.28803>; else goto <D.28804>;
      <D.28803>:
      {
        size_t __s1_len;
        size_t __s2_len;

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

          __s2 = klass->name;
          D.28808 = "EqualityComparer`1";
          D.28809 = MEM[(const unsigned char *)D.28808];
          D.28810 = (int) D.28809;
          D.28811 = *__s2;
          D.28812 = (int) D.28811;
          __result = D.28810 - D.28812;
          {
            if (__s2_len != 0) goto <D.28813>; else goto <D.28814>;
            <D.28813>:
            if (__result == 0) goto <D.28815>; else goto <D.28816>;
            <D.28815>:
            D.28817 = &MEM[(void *)"EqualityComparer`1" + 1B];
            D.28818 = *D.28817;
            D.28819 = (int) D.28818;
            D.28820 = __s2 + 1;
            D.28821 = *D.28820;
            D.28822 = (int) D.28821;
            __result = D.28819 - D.28822;
            if (__s2_len > 1) goto <D.28823>; else goto <D.28824>;
            <D.28823>:
            if (__result == 0) goto <D.28825>; else goto <D.28826>;
            <D.28825>:
            D.28827 = &MEM[(void *)"EqualityComparer`1" + 2B];
            D.28828 = *D.28827;
            D.28829 = (int) D.28828;
            D.28830 = __s2 + 2;
            D.28831 = *D.28830;
            D.28832 = (int) D.28831;
            __result = D.28829 - D.28832;
            if (__s2_len > 2) goto <D.28833>; else goto <D.28834>;
            <D.28833>:
            if (__result == 0) goto <D.28835>; else goto <D.28836>;
            <D.28835>:
            D.28837 = &MEM[(void *)"EqualityComparer`1" + 3B];
            D.28838 = *D.28837;
            D.28839 = (int) D.28838;
            D.28840 = __s2 + 3;
            D.28841 = *D.28840;
            D.28842 = (int) D.28841;
            __result = D.28839 - D.28842;
            <D.28836>:
            <D.28834>:
            <D.28826>:
            <D.28824>:
            <D.28816>:
            <D.28814>:
          }
          D.25078 = __result;
        }
        iftmp.72 = -D.25078;
        goto <D.28843>;
        <D.28807>:
        D.28227 = klass->name;
        iftmp.72 = __builtin_strcmp (D.28227, "EqualityComparer`1");
        <D.28843>:
        D.25079 = iftmp.72;
      }
      if (D.25079 == 0) goto <D.28844>; else goto <D.28845>;
      <D.28844>:
      {
        struct MonoClass * tclass;
        struct MonoClass * iface;
        struct MonoClass * gcomparer;
        struct MonoGenericContext ctx;
        struct MonoType * args[16];

        try
          {
            D.28138 = klass->generic_class;
            D.28141 = D.28138->context.class_inst;
            D.28545 = D.28141->type_argv[0];
            tclass = mono_class_from_mono_type (D.28545);
            memset (&ctx, 0, 16);
            D.28178 = mono_defaults.corlib;
            iface = mono_class_from_name (D.28178, "System", "IEquatable`1");
            D.28846 = iface == 0B;
            D.28847 = (long int) D.28846;
            D.28848 = __builtin_expect (D.28847, 0);
            if (D.28848 != 0) goto <D.28849>; else goto <D.28850>;
            <D.28849>:
            monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "aot-compiler.c", 3996, "iface");
            <D.28850>:
            D.28851 = &tclass->byval_arg;
            args[0] = D.28851;
            D.28852 = mono_metadata_get_generic_inst (1, &args);
            ctx.class_inst = D.28852;
            D.28853 = mono_class_inflate_generic_class (iface, &ctx);
            D.28854 = mono_class_is_assignable_from (D.28853, tclass);
            if (D.28854 != 0) goto <D.28855>; else goto <D.28856>;
            <D.28855>:
            D.28178 = mono_defaults.corlib;
            gcomparer = mono_class_from_name (D.28178, "System.Collections.Generic", "GenericEqualityComparer`1");
            D.28857 = gcomparer == 0B;
            D.28858 = (long int) D.28857;
            D.28859 = __builtin_expect (D.28858, 0);
            if (D.28859 != 0) goto <D.28860>; else goto <D.28861>;
            <D.28860>:
            monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "aot-compiler.c", 4002, "gcomparer");
            <D.28861>:
            D.28862 = mono_class_inflate_generic_class (gcomparer, &ctx);
            add_generic_class (acfg, D.28862, 0, "EqualityComparer<T>");
            <D.28856>:
          }
        finally
          {
            ctx = {CLOBBER};
            args = {CLOBBER};
          }
      }
      <D.28845>:
      <D.28804>:
      <D.28775>:
    }
  finally
    {
      iter = {CLOBBER};
    }
}


has_type_vars (struct MonoClass * klass)
{
  unsigned char D.28868;
  gboolean D.28870;
  unsigned char D.28871;
  struct MonoClass * D.28874;
  struct MonoGenericClass * D.28875;
  struct MonoGenericInst * D.28878;
  struct MonoType * D.28881;
  struct MonoClass * D.28882;
  int D.28883;
  <unnamed-unsigned:22> D.28886;
  int D.28887;
  struct MonoGenericContainer * D.28888;

  D.28868 = klass->byval_arg.type;
  if (D.28868 == 19) goto <D.28866>; else goto <D.28869>;
  <D.28869>:
  D.28868 = klass->byval_arg.type;
  if (D.28868 == 30) goto <D.28866>; else goto <D.28867>;
  <D.28866>:
  D.28870 = 1;
  return D.28870;
  <D.28867>:
  D.28871 = klass->rank;
  if (D.28871 != 0) goto <D.28872>; else goto <D.28873>;
  <D.28872>:
  D.28874 = klass->element_class;
  D.28870 = has_type_vars (D.28874);
  return D.28870;
  <D.28873>:
  D.28875 = klass->generic_class;
  if (D.28875 != 0B) goto <D.28876>; else goto <D.28877>;
  <D.28876>:
  {
    struct MonoGenericContext * context;

    D.28875 = klass->generic_class;
    context = &D.28875->context;
    D.28878 = context->class_inst;
    if (D.28878 != 0B) goto <D.28879>; else goto <D.28880>;
    <D.28879>:
    {
      int i;

      i = 0;
      goto <D.24858>;
      <D.24857>:
      D.28878 = context->class_inst;
      D.28881 = D.28878->type_argv[i];
      D.28882 = mono_class_from_mono_type (D.28881);
      D.28883 = has_type_vars (D.28882);
      if (D.28883 != 0) goto <D.28884>; else goto <D.28885>;
      <D.28884>:
      D.28870 = 1;
      return D.28870;
      <D.28885>:
      i = i + 1;
      <D.24858>:
      D.28878 = context->class_inst;
      D.28886 = D.28878->type_argc;
      D.28887 = (int) D.28886;
      if (D.28887 > i) goto <D.24857>; else goto <D.24859>;
      <D.24859>:
    }
    <D.28880>:
  }
  <D.28877>:
  D.28888 = klass->generic_container;
  if (D.28888 != 0B) goto <D.28889>; else goto <D.28890>;
  <D.28889>:
  D.28870 = 1;
  return D.28870;
  <D.28890>:
  D.28870 = 0;
  return D.28870;
}


check_type_depth (struct MonoType * t, int depth)
{
  gboolean D.28894;
  unsigned char D.28895;
  int D.28896;
  struct MonoType * D.28899;
  int D.28900;
  int D.28901;
  <unnamed-unsigned:22> D.28904;
  int D.28905;
  int i;

  if (depth > 8) goto <D.28892>; else goto <D.28893>;
  <D.28892>:
  D.28894 = 1;
  return D.28894;
  <D.28893>:
  D.28895 = t->type;
  D.28896 = (int) D.28895;
  switch (D.28896) <default: <D.24899>, case 21: <D.24892>>
  <D.24892>:
  {
    struct MonoGenericClass * gklass;
    struct MonoGenericInst * ginst;

    gklass = t->data.generic_class;
    ginst = gklass->context.class_inst;
    if (ginst != 0B) goto <D.28897>; else goto <D.28898>;
    <D.28897>:
    i = 0;
    goto <D.24896>;
    <D.24895>:
    D.28899 = ginst->type_argv[i];
    D.28900 = depth + 1;
    D.28901 = check_type_depth (D.28899, D.28900);
    if (D.28901 != 0) goto <D.28902>; else goto <D.28903>;
    <D.28902>:
    D.28894 = 1;
    return D.28894;
    <D.28903>:
    i = i + 1;
    <D.24896>:
    D.28904 = ginst->type_argc;
    D.28905 = (int) D.28904;
    if (D.28905 > i) goto <D.24895>; else goto <D.24897>;
    <D.24897>:
    <D.28898>:
    goto <D.24898>;
  }
  <D.24899>:
  goto <D.24898>;
  <D.24898>:
  D.28894 = 0;
  return D.28894;
}


is_vt_inst (struct MonoGenericInst * inst)
{
  unsigned char D.28908;
  gboolean D.28911;
  <unnamed-unsigned:22> D.28912;
  int D.28913;
  int i;

  i = 0;
  goto <D.24866>;
  <D.24865>:
  {
    struct MonoType * t;

    t = inst->type_argv[i];
    D.28908 = t->type;
    if (D.28908 == 17) goto <D.28909>; else goto <D.28910>;
    <D.28909>:
    D.28911 = 1;
    return D.28911;
    <D.28910>:
  }
  i = i + 1;
  <D.24866>:
  D.28912 = inst->type_argc;
  D.28913 = (int) D.28912;
  if (D.28913 > i) goto <D.24865>; else goto <D.24867>;
  <D.24867>:
  D.28911 = 0;
  return D.28911;
}


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

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


add_types_from_method_header (struct MonoAotCompile * acfg, struct MonoMethod * method)
{
  struct GHashTable * D.28917;
  void * D.28918;
  long int D.28919;
  struct MonoType * D.28922;
  unsigned char D.28923;
  struct MonoClass * D.28926;
  int D.28927;
  short unsigned int D.28928;
  int D.28929;
  struct MonoType * D.28932;
  unsigned char D.28933;
  struct MonoClass * D.28936;
  short unsigned int D.28937;
  int D.28938;
  struct MonoMethodHeader * header;
  struct MonoMethodSignature * sig;
  int j;
  int depth;

  D.28917 = acfg->method_depth;
  D.28918 = monoeg_g_hash_table_lookup (D.28917, method);
  D.28919 = (long int) D.28918;
  depth = (int) D.28919;
  sig = mono_method_signature (method);
  if (sig != 0B) goto <D.28920>; else goto <D.28921>;
  <D.28920>:
  j = 0;
  goto <D.25107>;
  <D.25106>:
  D.28922 = sig->params[j];
  D.28923 = D.28922->type;
  if (D.28923 == 21) goto <D.28924>; else goto <D.28925>;
  <D.28924>:
  D.28922 = sig->params[j];
  D.28926 = mono_class_from_mono_type (D.28922);
  D.28927 = depth + 1;
  add_generic_class_with_depth (acfg, D.28926, D.28927, "arg");
  <D.28925>:
  j = j + 1;
  <D.25107>:
  D.28928 = sig->param_count;
  D.28929 = (int) D.28928;
  if (D.28929 > j) goto <D.25106>; else goto <D.25108>;
  <D.25108>:
  <D.28921>:
  header = mono_method_get_header (method);
  if (header != 0B) goto <D.28930>; else goto <D.28931>;
  <D.28930>:
  j = 0;
  goto <D.25110>;
  <D.25109>:
  D.28932 = header->locals[j];
  D.28933 = D.28932->type;
  if (D.28933 == 21) goto <D.28934>; else goto <D.28935>;
  <D.28934>:
  D.28932 = header->locals[j];
  D.28936 = mono_class_from_mono_type (D.28932);
  D.28927 = depth + 1;
  add_generic_class_with_depth (acfg, D.28936, D.28927, "local");
  <D.28935>:
  j = j + 1;
  <D.25110>:
  D.28937 = header->num_locals;
  D.28938 = (int) D.28937;
  if (D.28938 > j) goto <D.25109>; else goto <D.25111>;
  <D.25111>:
  goto <D.28939>;
  <D.28931>:
  mono_loader_clear_error ();
  <D.28939>:
}


add_instances_of (struct MonoAotCompile * acfg, struct MonoClass * klass, struct MonoType * * insts, int ninsts, gboolean force)
{
  int D.28940;
  long unsigned int D.28943;
  long unsigned int D.28944;
  struct MonoType * * D.28945;
  struct MonoType * D.28946;
  struct MonoGenericInst * D.28947;
  struct MonoClass * D.28948;
  int i;
  struct MonoGenericContext ctx;
  struct MonoType * args[16];

  try
    {
      D.28940 = acfg->aot_opts.no_instances;
      if (D.28940 != 0) goto <D.28941>; else goto <D.28942>;
      <D.28941>:
      return;
      <D.28942>:
      memset (&ctx, 0, 16);
      i = 0;
      goto <D.25096>;
      <D.25095>:
      D.28943 = (long unsigned int) i;
      D.28944 = D.28943 * 8;
      D.28945 = insts + D.28944;
      D.28946 = *D.28945;
      args[0] = D.28946;
      D.28947 = mono_metadata_get_generic_inst (1, &args);
      ctx.class_inst = D.28947;
      D.28948 = mono_class_inflate_generic_class (klass, &ctx);
      add_generic_class (acfg, D.28948, force, "");
      i = i + 1;
      <D.25096>:
      if (i < ninsts) goto <D.25095>; else goto <D.25097>;
      <D.25097>:
    }
  finally
    {
      ctx = {CLOBBER};
      args = {CLOBBER};
    }
}


add_wrappers (struct MonoAotCompile * acfg)
{
  int D.28952;
  int D.28953;
  struct MonoImage * D.28954;
  short unsigned int D.28957;
  int D.28958;
  int D.28959;
  short unsigned int D.28961;
  int D.28962;
  int D.28963;
  int D.28965;
  struct MonoType * D.28970;
  unsigned char D.28971;
  int D.28973;
  struct MonoType * D.28976;
  unsigned char D.28977;
  int D.28980;
  short unsigned int D.28983;
  int D.28984;
  struct MonoMethod * D.28987;
  <unnamed-unsigned:24> D.28988;
  int D.28989;
  int D.24730;
  int iftmp.73;
  int D.24729;
  struct MonoAssembly * D.28993;
  const char[9] * D.28994;
  unsigned char D.28995;
  int D.28996;
  unsigned char D.28997;
  int D.28998;
  const unsigned char * D.29003;
  unsigned char D.29004;
  int D.29005;
  const unsigned char * D.29006;
  unsigned char D.29007;
  int D.29008;
  const unsigned char * D.29013;
  unsigned char D.29014;
  int D.29015;
  const unsigned char * D.29016;
  unsigned char D.29017;
  int D.29018;
  const unsigned char * D.29023;
  unsigned char D.29024;
  int D.29025;
  const unsigned char * D.29026;
  unsigned char D.29027;
  int D.29028;
  const char * D.29030;
  struct MonoImage * D.29033;
  struct MonoClass * D.29034;
  struct MonoType * D.29035;
  struct MonoMethod * D.29036;
  struct MonoMethod * D.29037;
  struct MonoClass * D.29038;
  struct MonoType * D.29039;
  struct MonoMethod * D.29040;
  struct MonoMethod * D.29041;
  struct MonoMethod * D.29042;
  struct MonoClass * D.29043;
  struct MonoType * D.29044;
  struct MonoMethod * D.29045;
  struct MonoClass * D.29046;
  struct MonoType * D.29047;
  struct MonoClass * D.29048;
  struct MonoType * D.29049;
  struct MonoMethod * D.29050;
  struct MonoClass * D.29051;
  struct MonoMethod * D.29052;
  struct MonoMethod * D.29053;
  struct MonoMethod * D.29056;
  struct MonoMethod * D.29057;
  unsigned int D.29060;
  struct MonoClass * D.29063;
  _Bool D.29068;
  long int D.29069;
  long int D.29070;
  long unsigned int D.29075;
  long unsigned int D.29076;
  struct MonoMethod * * D.29077;
  struct MonoMethod * D.29078;
  int nwrappers.74;
  struct MonoMethod * D.29080;
  struct MonoMethod * D.29081;
  struct GHashTable * D.29086;
  int D.29087;
  long unsigned int D.29092;
  long unsigned int D.29093;
  struct MonoClass * D.29095;
  struct MonoClass * D.29097;
  struct MonoGenericContainer * D.29098;
  struct MonoMethod * D.29103;
  struct MonoMethod * D.29106;
  struct MonoMethod * D.29109;
  int D.24756;
  int iftmp.75;
  int D.24755;
  struct MonoClass * D.29115;
  const char[35] * D.29116;
  unsigned char D.29117;
  int D.29118;
  unsigned char D.29119;
  int D.29120;
  const unsigned char * D.29125;
  unsigned char D.29126;
  int D.29127;
  const unsigned char * D.29128;
  unsigned char D.29129;
  int D.29130;
  const unsigned char * D.29135;
  unsigned char D.29136;
  int D.29137;
  const unsigned char * D.29138;
  unsigned char D.29139;
  int D.29140;
  const unsigned char * D.29145;
  unsigned char D.29146;
  int D.29147;
  const unsigned char * D.29148;
  unsigned char D.29149;
  int D.29150;
  const char * D.29152;
  int D.24765;
  int iftmp.76;
  int D.24764;
  const char[34] * D.29157;
  unsigned char D.29158;
  int D.29159;
  unsigned char D.29160;
  int D.29161;
  const unsigned char * D.29166;
  unsigned char D.29167;
  int D.29168;
  const unsigned char * D.29169;
  unsigned char D.29170;
  int D.29171;
  const unsigned char * D.29176;
  unsigned char D.29177;
  int D.29178;
  const unsigned char * D.29179;
  unsigned char D.29180;
  int D.29181;
  const unsigned char * D.29186;
  unsigned char D.29187;
  int D.29188;
  const unsigned char * D.29189;
  unsigned char D.29190;
  int D.29191;
  int D.29194;
  struct MonoMethod * D.29197;
  unsigned int D.29199;
  unsigned int D.29200;
  long unsigned int D.29205;
  long unsigned int D.29206;
  _Bool D.29207;
  long int D.29208;
  long int D.29209;
  <unnamed-unsigned:24> D.29216;
  int D.29217;
  int D.29218;
  unsigned char D.29223;
  struct MonoClass * D.29226;
  long unsigned int D.29227;
  long unsigned int D.29228;
  unsigned char D.29231;
  unsigned char D.29232;
  unsigned char D.29234;
  _Bool D.29235;
  long int D.29236;
  long int D.29237;
  struct MonoMethod * D.29240;
  struct MonoMethod * D.29243;
  <unnamed-unsigned:24> D.29244;
  int D.29245;
  short unsigned int D.29246;
  int D.29247;
  int D.29248;
  long unsigned int D.29251;
  long unsigned int D.29252;
  struct MonoClass * D.29256;
  struct MonoGenericContainer * D.29257;
  long unsigned int D.29260;
  long unsigned int D.29261;
  _Bool D.29262;
  long int D.29263;
  long int D.29264;
  struct MonoMethod * D.29268;
  short unsigned int D.29271;
  int D.29272;
  int D.29273;
  short unsigned int D.29275;
  int D.29276;
  int D.29277;
  struct MonoMethod * D.29278;
  struct MonoMethod * D.29281;
  int D.24806;
  int iftmp.77;
  int D.24805;
  struct MonoClass * D.29287;
  const char[29] * D.29288;
  unsigned char D.29289;
  int D.29290;
  unsigned char D.29291;
  int D.29292;
  const unsigned char * D.29297;
  unsigned char D.29298;
  int D.29299;
  const unsigned char * D.29300;
  unsigned char D.29301;
  int D.29302;
  const unsigned char * D.29307;
  unsigned char D.29308;
  int D.29309;
  const unsigned char * D.29310;
  unsigned char D.29311;
  int D.29312;
  const unsigned char * D.29317;
  unsigned char D.29318;
  int D.29319;
  const unsigned char * D.29320;
  unsigned char D.29321;
  int D.29322;
  const char * D.29324;
  int D.29326;
  struct MonoMethod * D.29329;
  const mono_byte * p.78;
  short unsigned int D.29331;
  int D.29332;
  int D.29333;
  char * D.29336;
  short unsigned int D.29337;
  _Bool D.29338;
  long int D.29339;
  long int D.29340;
  int iftmp.79;
  struct MonoType * D.29347;
  unsigned char D.29348;
  int D.24831;
  int iftmp.80;
  int D.24830;
  struct MonoClass * D.29353;
  const char[5] * D.29354;
  unsigned char D.29355;
  int D.29356;
  unsigned char D.29357;
  int D.29358;
  const unsigned char * D.29363;
  unsigned char D.29364;
  int D.29365;
  const unsigned char * D.29366;
  unsigned char D.29367;
  int D.29368;
  const unsigned char * D.29373;
  unsigned char D.29374;
  int D.29375;
  const unsigned char * D.29376;
  unsigned char D.29377;
  int D.29378;
  const unsigned char * D.29383;
  unsigned char D.29384;
  int D.29385;
  const unsigned char * D.29386;
  unsigned char D.29387;
  int D.29388;
  struct MonoClass * D.29390;
  const char * D.29391;
  _Bool D.29392;
  long int D.29393;
  long int D.29394;
  const char * p.81;
  const char * p.82;
  unsigned int D.29399;
  int D.29400;
  unsigned int D.29401;
  sizetype D.29402;
  char * D.29403;
  _Bool D.29404;
  long int D.29405;
  long int D.29406;
  struct MonoClass * D.29409;
  _Bool D.29410;
  long int D.29411;
  long int D.29412;
  const char * p.83;
  short unsigned int D.29416;
  _Bool D.29417;
  long int D.29418;
  long int D.29419;
  const char * named.84;
  char D.29425;
  const char * named.85;
  unsigned int D.29427;
  int D.29428;
  long unsigned int D.29429;
  long unsigned int D.29430;
  sizetype D.29431;
  char * D.29432;
  const char * named.86;
  _Bool D.29434;
  long int D.29435;
  long int D.29436;
  int D.24843;
  int iftmp.87;
  int D.24842;
  const char[13] * D.29442;
  unsigned char D.29443;
  int D.29444;
  unsigned char D.29445;
  int D.29446;
  const unsigned char * D.29451;
  unsigned char D.29452;
  int D.29453;
  const unsigned char * D.29454;
  unsigned char D.29455;
  int D.29456;
  const unsigned char * D.29461;
  unsigned char D.29462;
  int D.29463;
  const unsigned char * D.29464;
  unsigned char D.29465;
  int D.29466;
  const unsigned char * D.29471;
  unsigned char D.29472;
  int D.29473;
  const unsigned char * D.29474;
  unsigned char D.29475;
  int D.29476;
  _Bool D.29478;
  long int D.29479;
  long int D.29480;
  _Bool D.29483;
  long int D.29484;
  long int D.29485;
  unsigned int D.29488;
  long unsigned int D.29489;
  long unsigned int D.29490;
  char * D.29491;
  const char * named.88;
  struct GHashTable * D.29495;
  int D.29498;
  short unsigned int D.29500;
  int D.29501;
  int D.29502;
  struct MonoMethod * D.29503;
  long unsigned int D.29508;
  long unsigned int D.29509;
  struct MonoGenericContainer * D.29512;
  int D.29515;
  struct MonoClass * D.29518;
  const char * D.29520;
  char * D.29521;
  struct MonoMethod * D.29522;
  struct MonoMethod * D.29523;
  struct MonoMethod * method;
  struct MonoMethod * m;
  int i;
  int j;
  struct MonoMethodSignature * sig;
  struct MonoMethodSignature * csig;
  guint32 token;

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

    D.28952 = i + 1;
    D.28953 = D.28952 | 100663296;
    token = (guint32) D.28953;
    skip = 0;
    D.28954 = acfg->image;
    method = mono_get_method (D.28954, token, 0B);
    D.28957 = method->flags;
    D.28958 = (int) D.28957;
    D.28959 = D.28958 & 8192;
    if (D.28959 != 0) goto <D.28955>; else goto <D.28960>;
    <D.28960>:
    D.28961 = method->iflags;
    D.28962 = (int) D.28961;
    D.28963 = D.28962 & 3;
    if (D.28963 != 0) goto <D.28955>; else goto <D.28964>;
    <D.28964>:
    D.28957 = method->flags;
    D.28958 = (int) D.28957;
    D.28965 = D.28958 & 1024;
    if (D.28965 != 0) goto <D.28955>; else goto <D.28956>;
    <D.28955>:
    skip = 1;
    <D.28956>:
    sig = mono_method_signature (method);
    if (sig == 0B) goto <D.28966>; else goto <D.28967>;
    <D.28966>:
    // predicted unlikely by continue predictor.
    goto <D.24715>;
    <D.28967>:
    D.28970 = sig->ret;
    D.28971 = D.28970->type;
    if (D.28971 == 15) goto <D.28968>; else goto <D.28972>;
    <D.28972>:
    D.28970 = sig->ret;
    D.28971 = D.28970->type;
    if (D.28971 == 22) goto <D.28968>; else goto <D.28969>;
    <D.28968>:
    skip = 1;
    <D.28969>:
    D.28970 = sig->ret;
    D.28973 = mono_class_is_open_constructed_type (D.28970);
    if (D.28973 != 0) goto <D.28974>; else goto <D.28975>;
    <D.28974>:
    skip = 1;
    <D.28975>:
    j = 0;
    goto <D.24717>;
    <D.24716>:
    D.28976 = sig->params[j];
    D.28977 = D.28976->type;
    if (D.28977 == 22) goto <D.28978>; else goto <D.28979>;
    <D.28978>:
    skip = 1;
    <D.28979>:
    D.28976 = sig->params[j];
    D.28980 = mono_class_is_open_constructed_type (D.28976);
    if (D.28980 != 0) goto <D.28981>; else goto <D.28982>;
    <D.28981>:
    skip = 1;
    <D.28982>:
    j = j + 1;
    <D.24717>:
    D.28983 = sig->param_count;
    D.28984 = (int) D.28983;
    if (D.28984 > j) goto <D.24716>; else goto <D.24718>;
    <D.24718>:
    if (skip == 0) goto <D.28985>; else goto <D.28986>;
    <D.28985>:
    D.28987 = mono_marshal_get_runtime_invoke (method, 0);
    add_method (acfg, D.28987);
    <D.28986>:
  }
  <D.24715>:
  i = i + 1;
  <D.24720>:
  D.28954 = acfg->image;
  D.28988 = D.28954->tables[6].rows;
  D.28989 = (int) D.28988;
  if (D.28989 > i) goto <D.24719>; else goto <D.24721>;
  <D.24721>:
  {
    size_t __s1_len;
    size_t __s2_len;

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

      D.28954 = acfg->image;
      D.28993 = D.28954->assembly;
      __s2 = D.28993->aname.name;
      D.28994 = "mscorlib";
      D.28995 = MEM[(const unsigned char *)D.28994];
      D.28996 = (int) D.28995;
      D.28997 = *__s2;
      D.28998 = (int) D.28997;
      __result = D.28996 - D.28998;
      {
        if (__s2_len != 0) goto <D.28999>; else goto <D.29000>;
        <D.28999>:
        if (__result == 0) goto <D.29001>; else goto <D.29002>;
        <D.29001>:
        D.29003 = &MEM[(void *)"mscorlib" + 1B];
        D.29004 = *D.29003;
        D.29005 = (int) D.29004;
        D.29006 = __s2 + 1;
        D.29007 = *D.29006;
        D.29008 = (int) D.29007;
        __result = D.29005 - D.29008;
        if (__s2_len > 1) goto <D.29009>; else goto <D.29010>;
        <D.29009>:
        if (__result == 0) goto <D.29011>; else goto <D.29012>;
        <D.29011>:
        D.29013 = &MEM[(void *)"mscorlib" + 2B];
        D.29014 = *D.29013;
        D.29015 = (int) D.29014;
        D.29016 = __s2 + 2;
        D.29017 = *D.29016;
        D.29018 = (int) D.29017;
        __result = D.29015 - D.29018;
        if (__s2_len > 2) goto <D.29019>; else goto <D.29020>;
        <D.29019>:
        if (__result == 0) goto <D.29021>; else goto <D.29022>;
        <D.29021>:
        D.29023 = &MEM[(void *)"mscorlib" + 3B];
        D.29024 = *D.29023;
        D.29025 = (int) D.29024;
        D.29026 = __s2 + 3;
        D.29027 = *D.29026;
        D.29028 = (int) D.29027;
        __result = D.29025 - D.29028;
        <D.29022>:
        <D.29020>:
        <D.29012>:
        <D.29010>:
        <D.29002>:
        <D.29000>:
      }
      D.24729 = __result;
    }
    iftmp.73 = -D.24729;
    goto <D.29029>;
    <D.28992>:
    D.28954 = acfg->image;
    D.28993 = D.28954->assembly;
    D.29030 = D.28993->aname.name;
    iftmp.73 = __builtin_strcmp (D.29030, "mscorlib");
    <D.29029>:
    D.24730 = iftmp.73;
  }
  if (D.24730 == 0) goto <D.29031>; else goto <D.29032>;
  <D.29031>:
  {
    struct MonoMethodDesc * desc;
    struct MonoMethod * orig_method;
    int nallocators;

    D.29033 = mono_defaults.corlib;
    csig = mono_metadata_signature_alloc (D.29033, 0);
    D.29034 = mono_defaults.void_class;
    D.29035 = &D.29034->byval_arg;
    csig->ret = D.29035;
    D.29036 = get_runtime_invoke_sig (csig);
    add_method (acfg, D.29036);
    D.29033 = mono_defaults.corlib;
    csig = mono_metadata_signature_alloc (D.29033, 0);
    csig->hasthis = 1;
    D.29034 = mono_defaults.void_class;
    D.29035 = &D.29034->byval_arg;
    csig->ret = D.29035;
    D.29037 = get_runtime_invoke_sig (csig);
    add_method (acfg, D.29037);
    D.29033 = mono_defaults.corlib;
    csig = mono_metadata_signature_alloc (D.29033, 1);
    csig->hasthis = 1;
    D.29034 = mono_defaults.void_class;
    D.29035 = &D.29034->byval_arg;
    csig->ret = D.29035;
    D.29038 = mono_defaults.string_class;
    D.29039 = &D.29038->byval_arg;
    csig->params[0] = D.29039;
    D.29040 = get_runtime_invoke_sig (csig);
    add_method (acfg, D.29040);
    D.29033 = mono_defaults.corlib;
    csig = mono_metadata_signature_alloc (D.29033, 2);
    csig->hasthis = 1;
    D.29034 = mono_defaults.void_class;
    D.29035 = &D.29034->byval_arg;
    csig->ret = D.29035;
    D.29038 = mono_defaults.string_class;
    D.29039 = &D.29038->byval_arg;
    csig->params[0] = D.29039;
    D.29038 = mono_defaults.string_class;
    D.29039 = &D.29038->byval_arg;
    csig->params[1] = D.29039;
    D.29041 = get_runtime_invoke_sig (csig);
    add_method (acfg, D.29041);
    D.29033 = mono_defaults.corlib;
    csig = mono_metadata_signature_alloc (D.29033, 0);
    csig->hasthis = 1;
    D.29038 = mono_defaults.string_class;
    D.29039 = &D.29038->byval_arg;
    csig->ret = D.29039;
    D.29042 = get_runtime_invoke_sig (csig);
    add_method (acfg, D.29042);
    D.29033 = mono_defaults.corlib;
    csig = mono_metadata_signature_alloc (D.29033, 2);
    csig->hasthis = 1;
    D.29034 = mono_defaults.void_class;
    D.29035 = &D.29034->byval_arg;
    csig->ret = D.29035;
    D.29038 = mono_defaults.string_class;
    D.29039 = &D.29038->byval_arg;
    csig->params[0] = D.29039;
    D.29043 = mono_defaults.exception_class;
    D.29044 = &D.29043->byval_arg;
    csig->params[1] = D.29044;
    D.29045 = get_runtime_invoke_sig (csig);
    add_method (acfg, D.29045);
    D.29033 = mono_defaults.corlib;
    csig = mono_metadata_signature_alloc (D.29033, 2);
    csig->hasthis = 1;
    D.29033 = mono_defaults.corlib;
    D.29046 = mono_class_from_name (D.29033, "System.Reflection", "Assembly");
    D.29047 = &D.29046->byval_arg;
    csig->ret = D.29047;
    D.29038 = mono_defaults.string_class;
    D.29039 = &D.29038->byval_arg;
    csig->params[0] = D.29039;
    D.29048 = mono_defaults.boolean_class;
    D.29049 = &D.29048->byval_arg;
    csig->params[1] = D.29049;
    D.29050 = get_runtime_invoke_sig (csig);
    add_method (acfg, D.29050);
    D.29051 = mono_defaults.object_class;
    D.29052 = mono_class_get_method_from_name_flags (D.29051, "Finalize", 0, 0);
    D.29053 = mono_marshal_get_runtime_invoke (D.29052, 1);
    add_method (acfg, D.29053);
    method = mono_get_context_capture_method ();
    if (method != 0B) goto <D.29054>; else goto <D.29055>;
    <D.29054>:
    D.29056 = mono_marshal_get_runtime_invoke (method, 0);
    add_method (acfg, D.29056);
    <D.29055>:
    D.29057 = mono_marshal_get_stelemref ();
    add_method (acfg, D.29057);
    if (1 != 0) goto <D.29058>; else goto <D.29059>;
    <D.29058>:
    D.29060 = mono_gc_get_managed_allocator_types ();
    nallocators = (int) D.29060;
    i = 0;
    goto <D.24735>;
    <D.24734>:
    m = mono_gc_get_managed_allocator_by_type (i);
    if (m != 0B) goto <D.29061>; else goto <D.29062>;
    <D.29061>:
    add_method (acfg, m);
    <D.29062>:
    i = i + 1;
    <D.24735>:
    if (i < nallocators) goto <D.24734>; else goto <D.24736>;
    <D.24736>:
    desc = mono_method_desc_new ("Monitor:Enter(object,bool&)", 0);
    D.29063 = mono_defaults.monitor_class;
    orig_method = mono_method_desc_search_in_class (desc, D.29063);
    if (orig_method != 0B) goto <D.29064>; else goto <D.29065>;
    <D.29064>:
    method = mono_monitor_get_fast_path (orig_method);
    if (method != 0B) goto <D.29066>; else goto <D.29067>;
    <D.29066>:
    add_method (acfg, method);
    <D.29067>:
    <D.29065>:
    mono_method_desc_free (desc);
    desc = mono_method_desc_new ("Monitor:Exit(object)", 0);
    D.29063 = mono_defaults.monitor_class;
    orig_method = mono_method_desc_search_in_class (desc, D.29063);
    D.29068 = orig_method == 0B;
    D.29069 = (long int) D.29068;
    D.29070 = __builtin_expect (D.29069, 0);
    if (D.29070 != 0) goto <D.29071>; else goto <D.29072>;
    <D.29071>:
    monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "aot-compiler.c", 3370, "orig_method");
    <D.29072>:
    mono_method_desc_free (desc);
    method = mono_monitor_get_fast_path (orig_method);
    if (method != 0B) goto <D.29073>; else goto <D.29074>;
    <D.29073>:
    add_method (acfg, method);
    <D.29074>:
    <D.29059>:
    {
      struct MonoMethod * * wrappers;
      int nwrappers;

      try
        {
          wrappers = mono_marshal_get_virtual_stelemref_wrappers (&nwrappers);
          i = 0;
          goto <D.24740>;
          <D.24739>:
          D.29075 = (long unsigned int) i;
          D.29076 = D.29075 * 8;
          D.29077 = wrappers + D.29076;
          D.29078 = *D.29077;
          add_method (acfg, D.29078);
          i = i + 1;
          <D.24740>:
          nwrappers.74 = nwrappers;
          if (i < nwrappers.74) goto <D.24739>; else goto <D.24741>;
          <D.24741>:
          monoeg_g_free (wrappers);
        }
      finally
        {
          nwrappers = {CLOBBER};
        }
    }
    D.29080 = mono_marshal_get_castclass_with_cache ();
    add_method (acfg, D.29080);
    D.29081 = mono_marshal_get_isinst_with_cache ();
    add_method (acfg, D.29081);
    {
      struct MonoMethodDesc * desc;
      struct MonoMethod * m;

      desc = mono_method_desc_new ("Monitor:Enter(object,bool&)", 0);
      D.29063 = mono_defaults.monitor_class;
      m = mono_method_desc_search_in_class (desc, D.29063);
      mono_method_desc_free (desc);
      if (m != 0B) goto <D.29082>; else goto <D.29083>;
      <D.29082>:
      m = mono_monitor_get_fast_path (m);
      if (m != 0B) goto <D.29084>; else goto <D.29085>;
      <D.29084>:
      add_method (acfg, m);
      <D.29085>:
      <D.29083>:
    }
    D.29086 = mono_get_jit_icall_info ();
    monoeg_g_hash_table_foreach (D.29086, add_jit_icall_wrapper, acfg);
  }
  <D.29032>:
  i = 0;
  goto <D.24773>;
  <D.24772>:
  {
    struct MonoClass * klass;
    struct MonoCustomAttrInfo * cattr;

    D.28952 = i + 1;
    D.29087 = D.28952 | 33554432;
    token = (guint32) D.29087;
    D.28954 = acfg->image;
    klass = mono_class_get (D.28954, token);
    if (klass == 0B) goto <D.29088>; else goto <D.29089>;
    <D.29088>:
    mono_loader_clear_error ();
    // predicted unlikely by continue predictor.
    goto <D.24746>;
    <D.29089>:
    D.29092 = BIT_FIELD_REF <*klass, 64, 256>;
    D.29093 = D.29092 & 16777216;
    if (D.29093 == 0) goto <D.29090>; else goto <D.29094>;
    <D.29094>:
    D.29095 = mono_defaults.delegate_class;
    if (D.29095 == klass) goto <D.29090>; else goto <D.29096>;
    <D.29096>:
    D.29097 = mono_defaults.multicastdelegate_class;
    if (D.29097 == klass) goto <D.29090>; else goto <D.29091>;
    <D.29090>:
    // predicted unlikely by continue predictor.
    goto <D.24746>;
    <D.29091>:
    D.29098 = klass->generic_container;
    if (D.29098 == 0B) goto <D.29099>; else goto <D.29100>;
    <D.29099>:
    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.29101>; else goto <D.29102>;
    <D.29101>:
    D.29103 = mono_marshal_get_delegate_begin_invoke (method);
    add_method (acfg, D.29103);
    <D.29102>:
    method = mono_class_get_method_from_name_flags (klass, "EndInvoke", -1, 0);
    if (method != 0B) goto <D.29104>; else goto <D.29105>;
    <D.29104>:
    D.29106 = mono_marshal_get_delegate_end_invoke (method);
    add_method (acfg, D.29106);
    <D.29105>:
    cattr = mono_custom_attrs_from_class (klass);
    if (cattr != 0B) goto <D.29107>; else goto <D.29108>;
    <D.29107>:
    {
      int j;

      j = 0;
      goto <D.24768>;
      <D.24767>:
      D.29109 = cattr->attrs[j].ctor;
      if (D.29109 != 0B) goto <D.29110>; else goto <D.29111>;
      <D.29110>:
      {
        size_t __s1_len;
        size_t __s2_len;

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

          D.29109 = cattr->attrs[j].ctor;
          D.29115 = D.29109->klass;
          __s2 = D.29115->name;
          D.29116 = "MonoNativeFunctionWrapperAttribute";
          D.29117 = MEM[(const unsigned char *)D.29116];
          D.29118 = (int) D.29117;
          D.29119 = *__s2;
          D.29120 = (int) D.29119;
          __result = D.29118 - D.29120;
          {
            if (__s2_len != 0) goto <D.29121>; else goto <D.29122>;
            <D.29121>:
            if (__result == 0) goto <D.29123>; else goto <D.29124>;
            <D.29123>:
            D.29125 = &MEM[(void *)"MonoNativeFunctionWrapperAttribute" + 1B];
            D.29126 = *D.29125;
            D.29127 = (int) D.29126;
            D.29128 = __s2 + 1;
            D.29129 = *D.29128;
            D.29130 = (int) D.29129;
            __result = D.29127 - D.29130;
            if (__s2_len > 1) goto <D.29131>; else goto <D.29132>;
            <D.29131>:
            if (__result == 0) goto <D.29133>; else goto <D.29134>;
            <D.29133>:
            D.29135 = &MEM[(void *)"MonoNativeFunctionWrapperAttribute" + 2B];
            D.29136 = *D.29135;
            D.29137 = (int) D.29136;
            D.29138 = __s2 + 2;
            D.29139 = *D.29138;
            D.29140 = (int) D.29139;
            __result = D.29137 - D.29140;
            if (__s2_len > 2) goto <D.29141>; else goto <D.29142>;
            <D.29141>:
            if (__result == 0) goto <D.29143>; else goto <D.29144>;
            <D.29143>:
            D.29145 = &MEM[(void *)"MonoNativeFunctionWrapperAttribute" + 3B];
            D.29146 = *D.29145;
            D.29147 = (int) D.29146;
            D.29148 = __s2 + 3;
            D.29149 = *D.29148;
            D.29150 = (int) D.29149;
            __result = D.29147 - D.29150;
            <D.29144>:
            <D.29142>:
            <D.29134>:
            <D.29132>:
            <D.29124>:
            <D.29122>:
          }
          D.24755 = __result;
        }
        iftmp.75 = -D.24755;
        goto <D.29151>;
        <D.29114>:
        D.29109 = cattr->attrs[j].ctor;
        D.29115 = D.29109->klass;
        D.29152 = D.29115->name;
        iftmp.75 = __builtin_strcmp (D.29152, "MonoNativeFunctionWrapperAttribute");
        <D.29151>:
        D.24756 = iftmp.75;
      }
      if (D.24756 == 0) goto <D.24766>; else goto <D.29153>;
      <D.29153>:
      {
        size_t __s1_len;
        size_t __s2_len;

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

          D.29109 = cattr->attrs[j].ctor;
          D.29115 = D.29109->klass;
          __s2 = D.29115->name;
          D.29157 = "UnmanagedFunctionPointerAttribute";
          D.29158 = MEM[(const unsigned char *)D.29157];
          D.29159 = (int) D.29158;
          D.29160 = *__s2;
          D.29161 = (int) D.29160;
          __result = D.29159 - D.29161;
          {
            if (__s2_len != 0) goto <D.29162>; else goto <D.29163>;
            <D.29162>:
            if (__result == 0) goto <D.29164>; else goto <D.29165>;
            <D.29164>:
            D.29166 = &MEM[(void *)"UnmanagedFunctionPointerAttribute" + 1B];
            D.29167 = *D.29166;
            D.29168 = (int) D.29167;
            D.29169 = __s2 + 1;
            D.29170 = *D.29169;
            D.29171 = (int) D.29170;
            __result = D.29168 - D.29171;
            if (__s2_len > 1) goto <D.29172>; else goto <D.29173>;
            <D.29172>:
            if (__result == 0) goto <D.29174>; else goto <D.29175>;
            <D.29174>:
            D.29176 = &MEM[(void *)"UnmanagedFunctionPointerAttribute" + 2B];
            D.29177 = *D.29176;
            D.29178 = (int) D.29177;
            D.29179 = __s2 + 2;
            D.29180 = *D.29179;
            D.29181 = (int) D.29180;
            __result = D.29178 - D.29181;
            if (__s2_len > 2) goto <D.29182>; else goto <D.29183>;
            <D.29182>:
            if (__result == 0) goto <D.29184>; else goto <D.29185>;
            <D.29184>:
            D.29186 = &MEM[(void *)"UnmanagedFunctionPointerAttribute" + 3B];
            D.29187 = *D.29186;
            D.29188 = (int) D.29187;
            D.29189 = __s2 + 3;
            D.29190 = *D.29189;
            D.29191 = (int) D.29190;
            __result = D.29188 - D.29191;
            <D.29185>:
            <D.29183>:
            <D.29175>:
            <D.29173>:
            <D.29165>:
            <D.29163>:
          }
          D.24764 = __result;
        }
        iftmp.76 = -D.24764;
        goto <D.29192>;
        <D.29156>:
        D.29109 = cattr->attrs[j].ctor;
        D.29115 = D.29109->klass;
        D.29152 = D.29115->name;
        iftmp.76 = __builtin_strcmp (D.29152, "UnmanagedFunctionPointerAttribute");
        <D.29192>:
        D.24765 = iftmp.76;
      }
      if (D.24765 == 0) goto <D.24766>; else goto <D.29193>;
      <D.29193>:
      <D.29111>:
      j = j + 1;
      <D.24768>:
      D.29194 = cattr->num_attrs;
      if (D.29194 > j) goto <D.24767>; else goto <D.24766>;
      <D.24766>:
      D.29194 = cattr->num_attrs;
      if (D.29194 > j) goto <D.29195>; else goto <D.29196>;
      <D.29195>:
      D.29197 = mono_marshal_get_native_func_wrapper_aot (klass);
      add_method (acfg, D.29197);
      <D.29196>:
    }
    <D.29108>:
    goto <D.29198>;
    <D.29100>:
    D.29199 = acfg->opts;
    D.29200 = D.29199 & 16777216;
    if (D.29200 != 0) goto <D.29201>; else goto <D.29202>;
    <D.29201>:
    D.29098 = klass->generic_container;
    if (D.29098 != 0B) goto <D.29203>; else goto <D.29204>;
    <D.29203>:
    {
      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.29205 = BIT_FIELD_REF <*m, 64, 256>;
          D.29206 = D.29205 & 4096;
          D.29207 = D.29206 == 0;
          D.29208 = (long int) D.29207;
          D.29209 = __builtin_expect (D.29208, 0);
          if (D.29209 != 0) goto <D.29210>; else goto <D.29211>;
          <D.29210>:
          monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "aot-compiler.c", 3493, "m->is_inflated");
          <D.29211>:
          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.29205 = BIT_FIELD_REF <*m, 64, 256>;
          D.29206 = D.29205 & 4096;
          D.29207 = D.29206 == 0;
          D.29208 = (long int) D.29207;
          D.29209 = __builtin_expect (D.29208, 0);
          if (D.29209 != 0) goto <D.29212>; else goto <D.29213>;
          <D.29212>:
          monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "aot-compiler.c", 3505, "m->is_inflated");
          <D.29213>:
          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.29205 = BIT_FIELD_REF <*m, 64, 256>;
          D.29206 = D.29205 & 4096;
          D.29207 = D.29206 == 0;
          D.29208 = (long int) D.29207;
          D.29209 = __builtin_expect (D.29208, 0);
          if (D.29209 != 0) goto <D.29214>; else goto <D.29215>;
          <D.29214>:
          monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "aot-compiler.c", 3517, "m->is_inflated");
          <D.29215>:
          gshared = mini_get_shared_method_full (m, 0, 1);
          add_extra_method (acfg, gshared);
        }
      finally
        {
          ctx = {CLOBBER};
        }
    }
    <D.29204>:
    <D.29202>:
    <D.29198>:
  }
  <D.24746>:
  i = i + 1;
  <D.24773>:
  D.28954 = acfg->image;
  D.29216 = D.28954->tables[2].rows;
  D.29217 = (int) D.29216;
  if (D.29217 > i) goto <D.24772>; else goto <D.24774>;
  <D.24774>:
  i = 0;
  goto <D.24780>;
  <D.24779>:
  {
    struct MonoClass * klass;

    D.28952 = i + 1;
    D.29218 = D.28952 | 452984832;
    token = (guint32) D.29218;
    D.28954 = acfg->image;
    klass = mono_class_get (D.28954, token);
    if (klass == 0B) goto <D.29219>; else goto <D.29220>;
    <D.29219>:
    mono_loader_clear_error ();
    // predicted unlikely by continue predictor.
    goto <D.24776>;
    <D.29220>:
    D.29223 = klass->rank;
    if (D.29223 != 0) goto <D.29224>; else goto <D.29225>;
    <D.29224>:
    D.29226 = klass->element_class;
    D.29227 = BIT_FIELD_REF <*D.29226, 64, 1664>;
    D.29228 = D.29227 & 1073741824;
    if (D.29228 == 0) goto <D.29229>; else goto <D.29230>;
    <D.29229>:
    D.29226 = klass->element_class;
    D.29231 = D.29226->byval_arg.type;
    D.29232 = D.29231 + 254;
    if (D.29232 <= 11) goto <D.29221>; else goto <D.29233>;
    <D.29233>:
    D.29226 = klass->element_class;
    D.29231 = D.29226->byval_arg.type;
    D.29234 = D.29231 + 232;
    if (D.29234 <= 1) goto <D.29221>; else goto <D.29222>;
    <D.29221>:
    {
      struct MonoMethod * m;
      struct MonoMethod * wrapper;

      m = mono_class_get_method_from_name (klass, "Get", -1);
      D.29235 = m == 0B;
      D.29236 = (long int) D.29235;
      D.29237 = __builtin_expect (D.29236, 0);
      if (D.29237 != 0) goto <D.29238>; else goto <D.29239>;
      <D.29238>:
      monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "aot-compiler.c", 3543, "m");
      <D.29239>:
      wrapper = mono_marshal_get_array_accessor_wrapper (m);
      add_extra_method (acfg, wrapper);
      D.29240 = mono_marshal_get_runtime_invoke (wrapper, 0);
      add_extra_method (acfg, D.29240);
      m = mono_class_get_method_from_name (klass, "Set", -1);
      D.29235 = m == 0B;
      D.29236 = (long int) D.29235;
      D.29237 = __builtin_expect (D.29236, 0);
      if (D.29237 != 0) goto <D.29241>; else goto <D.29242>;
      <D.29241>:
      monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "aot-compiler.c", 3549, "m");
      <D.29242>:
      wrapper = mono_marshal_get_array_accessor_wrapper (m);
      add_extra_method (acfg, wrapper);
      D.29243 = mono_marshal_get_runtime_invoke (wrapper, 0);
      add_extra_method (acfg, D.29243);
    }
    <D.29222>:
    <D.29230>:
    <D.29225>:
  }
  <D.24776>:
  i = i + 1;
  <D.24780>:
  D.28954 = acfg->image;
  D.29244 = D.28954->tables[27].rows;
  D.29245 = (int) D.29244;
  if (D.29245 > i) goto <D.24779>; else goto <D.24781>;
  <D.24781>:
  i = 0;
  goto <D.24787>;
  <D.24786>:
  D.28952 = i + 1;
  D.28953 = D.28952 | 100663296;
  token = (guint32) D.28953;
  D.28954 = acfg->image;
  method = mono_get_method (D.28954, token, 0B);
  D.29246 = method->iflags;
  D.29247 = (int) D.29246;
  D.29248 = D.29247 & 32;
  if (D.29248 != 0) goto <D.29249>; else goto <D.29250>;
  <D.29249>:
  D.29251 = BIT_FIELD_REF <*method, 64, 256>;
  D.29252 = D.29251 & 2048;
  if (D.29252 != 0) goto <D.29253>; else goto <D.29254>;
  <D.29253>:
  goto <D.29255>;
  <D.29254>:
  D.29256 = method->klass;
  D.29257 = D.29256->generic_container;
  if (D.29257 != 0B) goto <D.29258>; else goto <D.29259>;
  <D.29258>:
  {
    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.29260 = BIT_FIELD_REF <*m, 64, 256>;
        D.29261 = D.29260 & 4096;
        D.29262 = D.29261 == 0;
        D.29263 = (long int) D.29262;
        D.29264 = __builtin_expect (D.29263, 0);
        if (D.29264 != 0) goto <D.29265>; else goto <D.29266>;
        <D.29265>:
        monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "aot-compiler.c", 3574, "m->is_inflated");
        <D.29266>:
        gshared = mini_get_shared_method_full (m, 0, 1);
        add_method (acfg, gshared);
      }
    finally
      {
        ctx = {CLOBBER};
      }
  }
  goto <D.29267>;
  <D.29259>:
  D.29268 = mono_marshal_get_synchronized_wrapper (method);
  add_method (acfg, D.29268);
  <D.29267>:
  <D.29255>:
  <D.29250>:
  i = i + 1;
  <D.24787>:
  D.28954 = acfg->image;
  D.28988 = D.28954->tables[6].rows;
  D.28989 = (int) D.28988;
  if (D.28989 > i) goto <D.24786>; else goto <D.24788>;
  <D.24788>:
  i = 0;
  goto <D.24792>;
  <D.24791>:
  {
    struct MonoMethod * method;
    guint32 token;

    D.28952 = i + 1;
    D.28953 = D.28952 | 100663296;
    token = (guint32) D.28953;
    D.28954 = acfg->image;
    method = mono_get_method (D.28954, token, 0B);
    D.29271 = method->flags;
    D.29272 = (int) D.29271;
    D.29273 = D.29272 & 8192;
    if (D.29273 != 0) goto <D.29269>; else goto <D.29274>;
    <D.29274>:
    D.29275 = method->iflags;
    D.29276 = (int) D.29275;
    D.29277 = D.29276 & 4096;
    if (D.29277 != 0) goto <D.29269>; else goto <D.29270>;
    <D.29269>:
    D.29278 = mono_marshal_get_native_wrapper (method, 1, 1);
    add_method (acfg, D.29278);
    <D.29270>:
  }
  i = i + 1;
  <D.24792>:
  D.28954 = acfg->image;
  D.28988 = D.28954->tables[6].rows;
  D.28989 = (int) D.28988;
  if (D.28989 > i) goto <D.24791>; else goto <D.24793>;
  <D.24793>:
  i = 0;
  goto <D.24845>;
  <D.24844>:
  {
    struct MonoMethod * method;
    guint32 token;
    struct MonoCustomAttrInfo * cattr;
    int j;

    D.28952 = i + 1;
    D.28953 = D.28952 | 100663296;
    token = (guint32) D.28953;
    D.28954 = acfg->image;
    method = mono_get_method (D.28954, token, 0B);
    cattr = mono_custom_attrs_from_method (method);
    if (cattr != 0B) goto <D.29279>; else goto <D.29280>;
    <D.29279>:
    j = 0;
    goto <D.24809>;
    <D.24808>:
    D.29281 = cattr->attrs[j].ctor;
    if (D.29281 != 0B) goto <D.29282>; else goto <D.29283>;
    <D.29282>:
    {
      size_t __s1_len;
      size_t __s2_len;

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

        D.29281 = cattr->attrs[j].ctor;
        D.29287 = D.29281->klass;
        __s2 = D.29287->name;
        D.29288 = "MonoPInvokeCallbackAttribute";
        D.29289 = MEM[(const unsigned char *)D.29288];
        D.29290 = (int) D.29289;
        D.29291 = *__s2;
        D.29292 = (int) D.29291;
        __result = D.29290 - D.29292;
        {
          if (__s2_len != 0) goto <D.29293>; else goto <D.29294>;
          <D.29293>:
          if (__result == 0) goto <D.29295>; else goto <D.29296>;
          <D.29295>:
          D.29297 = &MEM[(void *)"MonoPInvokeCallbackAttribute" + 1B];
          D.29298 = *D.29297;
          D.29299 = (int) D.29298;
          D.29300 = __s2 + 1;
          D.29301 = *D.29300;
          D.29302 = (int) D.29301;
          __result = D.29299 - D.29302;
          if (__s2_len > 1) goto <D.29303>; else goto <D.29304>;
          <D.29303>:
          if (__result == 0) goto <D.29305>; else goto <D.29306>;
          <D.29305>:
          D.29307 = &MEM[(void *)"MonoPInvokeCallbackAttribute" + 2B];
          D.29308 = *D.29307;
          D.29309 = (int) D.29308;
          D.29310 = __s2 + 2;
          D.29311 = *D.29310;
          D.29312 = (int) D.29311;
          __result = D.29309 - D.29312;
          if (__s2_len > 2) goto <D.29313>; else goto <D.29314>;
          <D.29313>:
          if (__result == 0) goto <D.29315>; else goto <D.29316>;
          <D.29315>:
          D.29317 = &MEM[(void *)"MonoPInvokeCallbackAttribute" + 3B];
          D.29318 = *D.29317;
          D.29319 = (int) D.29318;
          D.29320 = __s2 + 3;
          D.29321 = *D.29320;
          D.29322 = (int) D.29321;
          __result = D.29319 - D.29322;
          <D.29316>:
          <D.29314>:
          <D.29306>:
          <D.29304>:
          <D.29296>:
          <D.29294>:
        }
        D.24805 = __result;
      }
      iftmp.77 = -D.24805;
      goto <D.29323>;
      <D.29286>:
      D.29281 = cattr->attrs[j].ctor;
      D.29287 = D.29281->klass;
      D.29324 = D.29287->name;
      iftmp.77 = __builtin_strcmp (D.29324, "MonoPInvokeCallbackAttribute");
      <D.29323>:
      D.24806 = iftmp.77;
    }
    if (D.24806 == 0) goto <D.24807>; else goto <D.29325>;
    <D.29325>:
    <D.29283>:
    j = j + 1;
    <D.24809>:
    D.29326 = cattr->num_attrs;
    if (D.29326 > j) goto <D.24808>; else goto <D.24807>;
    <D.24807>:
    D.29326 = cattr->num_attrs;
    if (D.29326 > j) goto <D.29327>; else goto <D.29328>;
    <D.29327>:
    {
      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.29329 = e->ctor;
          sig = mono_method_signature (D.29329);
          p.78 = e->data;
          p = p.78;
          export_name = 0B;
          D.29331 = method->flags;
          D.29332 = (int) D.29331;
          D.29333 = D.29332 & 16;
          if (D.29333 == 0) goto <D.29334>; else goto <D.29335>;
          <D.29334>:
          D.29336 = 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.29336);
          exit (1);
          <D.29335>:
          D.29337 = sig->param_count;
          D.29338 = D.29337 != 1;
          D.29339 = (long int) D.29338;
          D.29340 = __builtin_expect (D.29339, 0);
          if (D.29340 != 0) goto <D.29341>; else goto <D.29342>;
          <D.29341>:
          monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "aot-compiler.c", 3635, "sig->param_count == 1");
          <D.29342>:
          D.29347 = sig->params[0];
          D.29348 = D.29347->type;
          if (D.29348 != 18) goto <D.29344>; else goto <D.29349>;
          <D.29349>:
          {
            size_t __s1_len;
            size_t __s2_len;

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

              D.29347 = sig->params[0];
              D.29353 = mono_class_from_mono_type (D.29347);
              __s2 = D.29353->name;
              D.29354 = "Type";
              D.29355 = MEM[(const unsigned char *)D.29354];
              D.29356 = (int) D.29355;
              D.29357 = *__s2;
              D.29358 = (int) D.29357;
              __result = D.29356 - D.29358;
              {
                if (__s2_len != 0) goto <D.29359>; else goto <D.29360>;
                <D.29359>:
                if (__result == 0) goto <D.29361>; else goto <D.29362>;
                <D.29361>:
                D.29363 = &MEM[(void *)"Type" + 1B];
                D.29364 = *D.29363;
                D.29365 = (int) D.29364;
                D.29366 = __s2 + 1;
                D.29367 = *D.29366;
                D.29368 = (int) D.29367;
                __result = D.29365 - D.29368;
                if (__s2_len > 1) goto <D.29369>; else goto <D.29370>;
                <D.29369>:
                if (__result == 0) goto <D.29371>; else goto <D.29372>;
                <D.29371>:
                D.29373 = &MEM[(void *)"Type" + 2B];
                D.29374 = *D.29373;
                D.29375 = (int) D.29374;
                D.29376 = __s2 + 2;
                D.29377 = *D.29376;
                D.29378 = (int) D.29377;
                __result = D.29375 - D.29378;
                if (__s2_len > 2) goto <D.29379>; else goto <D.29380>;
                <D.29379>:
                if (__result == 0) goto <D.29381>; else goto <D.29382>;
                <D.29381>:
                D.29383 = &MEM[(void *)"Type" + 3B];
                D.29384 = *D.29383;
                D.29385 = (int) D.29384;
                D.29386 = __s2 + 3;
                D.29387 = *D.29386;
                D.29388 = (int) D.29387;
                __result = D.29385 - D.29388;
                <D.29382>:
                <D.29380>:
                <D.29372>:
                <D.29370>:
                <D.29362>:
                <D.29360>:
              }
              D.24830 = __result;
            }
            iftmp.80 = -D.24830;
            goto <D.29389>;
            <D.29352>:
            D.29347 = sig->params[0];
            D.29390 = mono_class_from_mono_type (D.29347);
            D.29391 = D.29390->name;
            iftmp.80 = __builtin_strcmp (D.29391, "Type");
            <D.29389>:
            D.24831 = iftmp.80;
          }
          if (D.24831 != 0) goto <D.29344>; else goto <D.29345>;
          <D.29344>:
          iftmp.79 = 1;
          goto <D.29346>;
          <D.29345>:
          iftmp.79 = 0;
          <D.29346>:
          D.29392 = iftmp.79 != 0;
          D.29393 = (long int) D.29392;
          D.29394 = __builtin_expect (D.29393, 0);
          if (D.29394 != 0) goto <D.29395>; else goto <D.29396>;
          <D.29395>:
          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.29396>:
          p.81 = p;
          p.82 = p.81 + 2;
          p = p.82;
          p.81 = p;
          D.29399 = mono_metadata_decode_value (p.81, &p);
          slen = (int) D.29399;
          p.81 = p;
          D.29400 = slen + 1;
          D.29401 = (unsigned int) D.29400;
          n = monoeg_g_memdup (p.81, D.29401);
          D.29402 = (sizetype) slen;
          D.29403 = n + D.29402;
          *D.29403 = 0;
          D.28954 = acfg->image;
          t = mono_reflection_type_from_name (n, D.28954);
          D.29404 = t == 0B;
          D.29405 = (long int) D.29404;
          D.29406 = __builtin_expect (D.29405, 0);
          if (D.29406 != 0) goto <D.29407>; else goto <D.29408>;
          <D.29407>:
          monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "aot-compiler.c", 3651, "t");
          <D.29408>:
          monoeg_g_free (n);
          klass = mono_class_from_mono_type (t);
          D.29409 = klass->parent;
          D.29097 = mono_defaults.multicastdelegate_class;
          D.29410 = D.29409 != D.29097;
          D.29411 = (long int) D.29410;
          D.29412 = __builtin_expect (D.29411, 0);
          if (D.29412 != 0) goto <D.29413>; else goto <D.29414>;
          <D.29413>:
          monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "aot-compiler.c", 3655, "klass->parent == mono_defaults.multicastdelegate_class");
          <D.29414>:
          p.81 = p;
          D.29402 = (sizetype) slen;
          p.83 = p.81 + D.29402;
          p = p.83;
          p.81 = p;
          D.29416 = MEM[(const guint16 *)p.81];
          num_named = (int) D.29416;
          p.81 = p;
          p.82 = p.81 + 2;
          p = p.82;
          D.29417 = num_named > 1;
          D.29418 = (long int) D.29417;
          D.29419 = __builtin_expect (D.29418, 0);
          if (D.29419 != 0) goto <D.29420>; else goto <D.29421>;
          <D.29420>:
          monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "aot-compiler.c", 3662, "num_named < 2");
          <D.29421>:
          if (num_named == 1) goto <D.29422>; else goto <D.29423>;
          <D.29422>:
          {
            int name_len;
            char * name;
            struct MonoType * prop_type;

            p.81 = p;
            named = p.81;
            named.84 = named;
            D.29425 = *named.84;
            named_type = (int) D.29425;
            named.84 = named;
            named.85 = named.84 + 1;
            named = named.85;
            named.84 = named;
            D.29425 = *named.84;
            data_type = (int) D.29425;
            named.84 = named;
            named.85 = named.84 + 1;
            named = named.85;
            named.84 = named;
            D.29427 = mono_metadata_decode_blob_size (named.84, &named);
            name_len = (int) D.29427;
            D.29428 = name_len + 1;
            D.29429 = (long unsigned int) D.29428;
            name = monoeg_malloc (D.29429);
            named.84 = named;
            D.29430 = (long unsigned int) name_len;
            memcpy (name, named.84, D.29430);
            D.29431 = (sizetype) name_len;
            D.29432 = name + D.29431;
            *D.29432 = 0;
            named.84 = named;
            D.29431 = (sizetype) name_len;
            named.86 = named.84 + D.29431;
            named = named.86;
            D.29434 = named_type != 84;
            D.29435 = (long int) D.29434;
            D.29436 = __builtin_expect (D.29435, 0);
            if (D.29436 != 0) goto <D.29437>; else goto <D.29438>;
            <D.29437>:
            monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "aot-compiler.c", 3681, "named_type == 0x54");
            <D.29438>:
            {
              size_t __s1_len;
              size_t __s2_len;

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

                __s2 = name;
                D.29442 = "ExportSymbol";
                D.29443 = MEM[(const unsigned char *)D.29442];
                D.29444 = (int) D.29443;
                D.29445 = *__s2;
                D.29446 = (int) D.29445;
                __result = D.29444 - D.29446;
                {
                  if (__s2_len != 0) goto <D.29447>; else goto <D.29448>;
                  <D.29447>:
                  if (__result == 0) goto <D.29449>; else goto <D.29450>;
                  <D.29449>:
                  D.29451 = &MEM[(void *)"ExportSymbol" + 1B];
                  D.29452 = *D.29451;
                  D.29453 = (int) D.29452;
                  D.29454 = __s2 + 1;
                  D.29455 = *D.29454;
                  D.29456 = (int) D.29455;
                  __result = D.29453 - D.29456;
                  if (__s2_len > 1) goto <D.29457>; else goto <D.29458>;
                  <D.29457>:
                  if (__result == 0) goto <D.29459>; else goto <D.29460>;
                  <D.29459>:
                  D.29461 = &MEM[(void *)"ExportSymbol" + 2B];
                  D.29462 = *D.29461;
                  D.29463 = (int) D.29462;
                  D.29464 = __s2 + 2;
                  D.29465 = *D.29464;
                  D.29466 = (int) D.29465;
                  __result = D.29463 - D.29466;
                  if (__s2_len > 2) goto <D.29467>; else goto <D.29468>;
                  <D.29467>:
                  if (__result == 0) goto <D.29469>; else goto <D.29470>;
                  <D.29469>:
                  D.29471 = &MEM[(void *)"ExportSymbol" + 3B];
                  D.29472 = *D.29471;
                  D.29473 = (int) D.29472;
                  D.29474 = __s2 + 3;
                  D.29475 = *D.29474;
                  D.29476 = (int) D.29475;
                  __result = D.29473 - D.29476;
                  <D.29470>:
                  <D.29468>:
                  <D.29460>:
                  <D.29458>:
                  <D.29450>:
                  <D.29448>:
                }
                D.24842 = __result;
              }
              iftmp.87 = -D.24842;
              goto <D.29477>;
              <D.29441>:
              iftmp.87 = __builtin_strcmp (name, "ExportSymbol");
              <D.29477>:
              D.24843 = iftmp.87;
            }
            D.29478 = D.24843 != 0;
            D.29479 = (long int) D.29478;
            D.29480 = __builtin_expect (D.29479, 0);
            if (D.29480 != 0) goto <D.29481>; else goto <D.29482>;
            <D.29481>:
            monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "aot-compiler.c", 3682, "!strcmp (name, \"ExportSymbol\")");
            <D.29482>:
            D.29038 = mono_defaults.string_class;
            prop_type = &D.29038->byval_arg;
            named.84 = named;
            D.29425 = *named.84;
            D.29483 = D.29425 == 255;
            D.29484 = (long int) D.29483;
            D.29485 = __builtin_expect (D.29484, 0);
            if (D.29485 != 0) goto <D.29486>; else goto <D.29487>;
            <D.29486>:
            monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "aot-compiler.c", 3687, "*named != (char)0xff");
            <D.29487>:
            named.84 = named;
            D.29488 = mono_metadata_decode_value (named.84, &named);
            slen = (int) D.29488;
            D.29400 = slen + 1;
            D.29489 = (long unsigned int) D.29400;
            export_name = monoeg_malloc (D.29489);
            named.84 = named;
            D.29490 = (long unsigned int) slen;
            memcpy (export_name, named.84, D.29490);
            D.29402 = (sizetype) slen;
            D.29491 = export_name + D.29402;
            *D.29491 = 0;
            named.84 = named;
            D.29402 = (sizetype) slen;
            named.88 = named.84 + D.29402;
            named = named.88;
          }
          <D.29423>:
          wrapper = mono_marshal_get_managed_wrapper (method, klass, 0);
          add_method (acfg, wrapper);
          if (export_name != 0B) goto <D.29493>; else goto <D.29494>;
          <D.29493>:
          D.29495 = acfg->export_names;
          monoeg_g_hash_table_insert_replace (D.29495, wrapper, export_name, 0);
          <D.29494>:
        }
      finally
        {
          p = {CLOBBER};
          named = {CLOBBER};
        }
    }
    <D.29328>:
    <D.29280>:
    D.29331 = method->flags;
    D.29332 = (int) D.29331;
    D.29498 = D.29332 & 8192;
    if (D.29498 != 0) goto <D.29496>; else goto <D.29499>;
    <D.29499>:
    D.29500 = method->iflags;
    D.29501 = (int) D.29500;
    D.29502 = D.29501 & 4096;
    if (D.29502 != 0) goto <D.29496>; else goto <D.29497>;
    <D.29496>:
    D.29503 = mono_marshal_get_native_wrapper (method, 1, 1);
    add_method (acfg, D.29503);
    <D.29497>:
  }
  i = i + 1;
  <D.24845>:
  D.28954 = acfg->image;
  D.28988 = D.28954->tables[6].rows;
  D.28989 = (int) D.28988;
  if (D.28989 > i) goto <D.24844>; else goto <D.24846>;
  <D.24846>:
  i = 0;
  goto <D.24850>;
  <D.24849>:
  {
    struct MonoClass * klass;

    D.28952 = i + 1;
    D.29087 = D.28952 | 33554432;
    token = (guint32) D.29087;
    D.28954 = acfg->image;
    klass = mono_class_get (D.28954, token);
    if (klass == 0B) goto <D.29504>; else goto <D.29505>;
    <D.29504>:
    mono_loader_clear_error ();
    // predicted unlikely by continue predictor.
    goto <D.24848>;
    <D.29505>:
    D.29508 = BIT_FIELD_REF <*klass, 64, 256>;
    D.29509 = D.29508 & 8;
    if (D.29509 != 0) goto <D.29510>; else goto <D.29511>;
    <D.29510>:
    D.29512 = klass->generic_container;
    if (D.29512 == 0B) goto <D.29513>; else goto <D.29514>;
    <D.29513>:
    D.29515 = can_marshal_struct (klass);
    if (D.29515 != 0) goto <D.29516>; else goto <D.29517>;
    <D.29516>:
    D.29518 = klass->nested_in;
    if (D.29518 == 0B) goto <D.29506>; else goto <D.29519>;
    <D.29519>:
    D.29518 = klass->nested_in;
    D.29520 = D.29518->name;
    D.29521 = strstr (D.29520, "<PrivateImplementationDetails>");
    D.29518 = klass->nested_in;
    D.29520 = D.29518->name;
    if (D.29521 != D.29520) goto <D.29506>; else goto <D.29507>;
    <D.29506>:
    D.29522 = mono_marshal_get_struct_to_ptr (klass);
    add_method (acfg, D.29522);
    D.29523 = mono_marshal_get_ptr_to_struct (klass);
    add_method (acfg, D.29523);
    <D.29507>:
    <D.29517>:
    <D.29514>:
    <D.29511>:
  }
  <D.24848>:
  i = i + 1;
  <D.24850>:
  D.28954 = acfg->image;
  D.29216 = D.28954->tables[2].rows;
  D.29217 = (int) D.29216;
  if (D.29217 > i) goto <D.24849>; else goto <D.24851>;
  <D.24851>:
}


add_jit_icall_wrapper (void * key, void * value, void * user_data)
{
  struct MonoMethodSignature * D.29524;
  const char * D.29527;
  const void * D.29528;
  int check_for_pending_exc.89;
  struct MonoAotCompile * acfg;
  struct MonoJitICallInfo * callinfo;
  struct MonoMethod * wrapper;
  char * name;

  acfg = user_data;
  callinfo = value;
  D.29524 = callinfo->sig;
  if (D.29524 == 0B) goto <D.29525>; else goto <D.29526>;
  <D.29525>:
  return;
  <D.29526>:
  D.29527 = callinfo->name;
  name = monoeg_g_strdup_printf ("__icall_wrapper_%s", D.29527);
  D.29524 = callinfo->sig;
  D.29528 = callinfo->func;
  check_for_pending_exc.89 = check_for_pending_exc;
  wrapper = mono_marshal_get_icall_wrapper (D.29524, name, D.29528, check_for_pending_exc.89);
  monoeg_g_free (name);
  add_method (acfg, wrapper);
}


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

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


create_gsharedvt_inst (struct MonoAotCompile * acfg, struct MonoMethod * method, struct MonoGenericContext * ctx)
{
  struct MonoClass * D.29534;
  struct MonoGenericContainer * D.29535;
  <unnamed-unsigned:22> D.29538;
  long unsigned int D.29539;
  long unsigned int D.29540;
  long unsigned int D.29541;
  long unsigned int D.29542;
  struct MonoType * * D.29543;
  struct MonoClass * D.29544;
  struct MonoType * D.29545;
  int D.29546;
  struct MonoGenericInst * D.29547;
  long unsigned int D.29548;
  long unsigned int D.29549;
  struct MonoGenericParamFull * D.29552;
  long unsigned int D.29553;
  struct MonoGenericParamFull * D.29554;
  struct MonoClass * * D.29557;
  struct MonoClass * D.29562;
  struct MonoImage * D.29565;
  struct MonoImage * D.29566;
  int D.24695;
  int iftmp.90;
  int D.24694;
  const char[10] * D.29571;
  unsigned char D.29572;
  int D.29573;
  unsigned char D.29574;
  int D.29575;
  const unsigned char * D.29580;
  unsigned char D.29581;
  int D.29582;
  const unsigned char * D.29583;
  unsigned char D.29584;
  int D.29585;
  const unsigned char * D.29590;
  unsigned char D.29591;
  int D.29592;
  const unsigned char * D.29593;
  unsigned char D.29594;
  int D.29595;
  const unsigned char * D.29600;
  unsigned char D.29601;
  int D.29602;
  const unsigned char * D.29603;
  unsigned char D.29604;
  int D.29605;
  const char * D.29607;
  struct MonoClass * D.29608;
  struct MonoType * D.29611;
  <unnamed-signed:31> D.29613;
  int D.29614;
  struct MonoGenericInst * D.29615;
  struct MonoGenericContext shared_context;
  struct MonoType * * args;
  struct MonoGenericInst * inst;
  struct MonoGenericContainer * container;
  struct MonoClass * * constraints;
  int i;

  try
    {
      memset (ctx, 0, 16);
      D.29534 = method->klass;
      D.29535 = D.29534->generic_container;
      if (D.29535 != 0B) goto <D.29536>; else goto <D.29537>;
      <D.29536>:
      D.29534 = method->klass;
      D.29535 = D.29534->generic_container;
      shared_context = D.29535->context;
      inst = shared_context.class_inst;
      D.29538 = inst->type_argc;
      D.29539 = (long unsigned int) D.29538;
      D.29540 = D.29539 * 8;
      args = monoeg_malloc0 (D.29540);
      i = 0;
      goto <D.24682>;
      <D.24681>:
      D.29541 = (long unsigned int) i;
      D.29542 = D.29541 * 8;
      D.29543 = args + D.29542;
      D.29544 = mono_defaults.int_class;
      D.29545 = &D.29544->byval_arg;
      *D.29543 = D.29545;
      i = i + 1;
      <D.24682>:
      D.29538 = inst->type_argc;
      D.29546 = (int) D.29538;
      if (D.29546 > i) goto <D.24681>; else goto <D.24683>;
      <D.24683>:
      D.29538 = inst->type_argc;
      D.29546 = (int) D.29538;
      D.29547 = mono_metadata_get_generic_inst (D.29546, args);
      ctx->class_inst = D.29547;
      <D.29537>:
      D.29548 = BIT_FIELD_REF <*method, 64, 256>;
      D.29549 = D.29548 & 2048;
      if (D.29549 != 0) goto <D.29550>; else goto <D.29551>;
      <D.29550>:
      container = mono_method_get_generic_container (method);
      shared_context = container->context;
      inst = shared_context.method_inst;
      D.29538 = inst->type_argc;
      D.29539 = (long unsigned int) D.29538;
      D.29540 = D.29539 * 8;
      args = monoeg_malloc0 (D.29540);
      i = 0;
      goto <D.24700>;
      <D.24699>:
      {
        struct MonoGenericParamInfo * info;
        gboolean ref_only;

        D.29552 = container->type_params;
        D.29541 = (long unsigned int) i;
        D.29553 = D.29541 * 56;
        D.29554 = D.29552 + D.29553;
        info = &D.29554->info;
        ref_only = 0;
        if (info != 0B) goto <D.29555>; else goto <D.29556>;
        <D.29555>:
        D.29557 = info->constraints;
        if (D.29557 != 0B) goto <D.29558>; else goto <D.29559>;
        <D.29558>:
        constraints = info->constraints;
        goto <D.24697>;
        <D.24696>:
        {
          struct MonoClass * cklass;

          cklass = *constraints;
          D.29562 = mono_defaults.object_class;
          if (D.29562 != cklass) goto <D.29563>; else goto <D.29564>;
          <D.29563>:
          D.29565 = cklass->image;
          D.29566 = mono_defaults.corlib;
          if (D.29565 != D.29566) goto <D.29560>; else goto <D.29567>;
          <D.29567>:
          {
            size_t __s1_len;
            size_t __s2_len;

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

              __s2 = cklass->name;
              D.29571 = "ValueType";
              D.29572 = MEM[(const unsigned char *)D.29571];
              D.29573 = (int) D.29572;
              D.29574 = *__s2;
              D.29575 = (int) D.29574;
              __result = D.29573 - D.29575;
              {
                if (__s2_len != 0) goto <D.29576>; else goto <D.29577>;
                <D.29576>:
                if (__result == 0) goto <D.29578>; else goto <D.29579>;
                <D.29578>:
                D.29580 = &MEM[(void *)"ValueType" + 1B];
                D.29581 = *D.29580;
                D.29582 = (int) D.29581;
                D.29583 = __s2 + 1;
                D.29584 = *D.29583;
                D.29585 = (int) D.29584;
                __result = D.29582 - D.29585;
                if (__s2_len > 1) goto <D.29586>; else goto <D.29587>;
                <D.29586>:
                if (__result == 0) goto <D.29588>; else goto <D.29589>;
                <D.29588>:
                D.29590 = &MEM[(void *)"ValueType" + 2B];
                D.29591 = *D.29590;
                D.29592 = (int) D.29591;
                D.29593 = __s2 + 2;
                D.29594 = *D.29593;
                D.29595 = (int) D.29594;
                __result = D.29592 - D.29595;
                if (__s2_len > 2) goto <D.29596>; else goto <D.29597>;
                <D.29596>:
                if (__result == 0) goto <D.29598>; else goto <D.29599>;
                <D.29598>:
                D.29600 = &MEM[(void *)"ValueType" + 3B];
                D.29601 = *D.29600;
                D.29602 = (int) D.29601;
                D.29603 = __s2 + 3;
                D.29604 = *D.29603;
                D.29605 = (int) D.29604;
                __result = D.29602 - D.29605;
                <D.29599>:
                <D.29597>:
                <D.29589>:
                <D.29587>:
                <D.29579>:
                <D.29577>:
              }
              D.24694 = __result;
            }
            iftmp.90 = -D.24694;
            goto <D.29606>;
            <D.29570>:
            D.29607 = cklass->name;
            iftmp.90 = __builtin_strcmp (D.29607, "ValueType");
            <D.29606>:
            D.24695 = iftmp.90;
          }
          if (D.24695 != 0) goto <D.29560>; else goto <D.29561>;
          <D.29560>:
          ref_only = 1;
          <D.29561>:
          <D.29564>:
          constraints = constraints + 8;
        }
        <D.24697>:
        D.29608 = *constraints;
        if (D.29608 != 0B) goto <D.24696>; else goto <D.24698>;
        <D.24698>:
        <D.29559>:
        <D.29556>:
        if (ref_only != 0) goto <D.29609>; else goto <D.29610>;
        <D.29609>:
        D.29541 = (long unsigned int) i;
        D.29542 = D.29541 * 8;
        D.29543 = args + D.29542;
        D.29562 = mono_defaults.object_class;
        D.29611 = &D.29562->byval_arg;
        *D.29543 = D.29611;
        goto <D.29612>;
        <D.29610>:
        D.29541 = (long unsigned int) i;
        D.29542 = D.29541 * 8;
        D.29543 = args + D.29542;
        D.29544 = mono_defaults.int_class;
        D.29545 = &D.29544->byval_arg;
        *D.29543 = D.29545;
        <D.29612>:
      }
      i = i + 1;
      <D.24700>:
      D.29613 = container->type_argc;
      D.29614 = (int) D.29613;
      if (D.29614 > i) goto <D.24699>; else goto <D.24701>;
      <D.24701>:
      D.29538 = inst->type_argc;
      D.29546 = (int) D.29538;
      D.29615 = mono_metadata_get_generic_inst (D.29546, args);
      ctx->method_inst = D.29615;
      <D.29551>:
    }
  finally
    {
      shared_context = {CLOBBER};
    }
}


can_marshal_struct (struct MonoClass * klass)
{
  unsigned int D.29616;
  unsigned int D.29617;
  gboolean D.29620;
  struct MonoType * D.29621;
  short unsigned int D.29622;
  int D.29623;
  int D.29624;
  unsigned char D.29627;
  int D.29628;
  struct MonoClass * D.29629;
  long unsigned int D.29630;
  long unsigned int D.29631;
  struct MonoClass * D.29634;
  int D.29635;
  struct MonoClassField * D.29640;
  struct MonoMarshalSpec * D.29643;
  unsigned int i.91;
  unsigned int D.29647;
  int D.24660;
  int iftmp.92;
  int D.24659;
  const char[43] * D.29653;
  unsigned char D.29654;
  int D.29655;
  unsigned char D.29656;
  int D.29657;
  const unsigned char * D.29662;
  unsigned char D.29663;
  int D.29664;
  const unsigned char * D.29665;
  unsigned char D.29666;
  int D.29667;
  const unsigned char * D.29672;
  unsigned char D.29673;
  int D.29674;
  const unsigned char * D.29675;
  unsigned char D.29676;
  int D.29677;
  const unsigned char * D.29682;
  unsigned char D.29683;
  int D.29684;
  const unsigned char * D.29685;
  unsigned char D.29686;
  int D.29687;
  const char * D.29689;
  int D.24669;
  int iftmp.93;
  int D.24668;
  const char[12] * D.29695;
  unsigned char D.29696;
  int D.29697;
  unsigned char D.29698;
  int D.29699;
  const unsigned char * D.29704;
  unsigned char D.29705;
  int D.29706;
  const unsigned char * D.29707;
  unsigned char D.29708;
  int D.29709;
  const unsigned char * D.29714;
  unsigned char D.29715;
  int D.29716;
  const unsigned char * D.29717;
  unsigned char D.29718;
  int D.29719;
  const unsigned char * D.29724;
  unsigned char D.29725;
  int D.29726;
  const unsigned char * D.29727;
  unsigned char D.29728;
  int D.29729;
  const char * D.29731;
  struct MonoClassField * field;
  gboolean can_marshal;
  void * iter;
  struct MonoMarshalType * info;
  int i;

  try
    {
      can_marshal = 1;
      iter = 0B;
      D.29616 = klass->flags;
      D.29617 = D.29616 & 24;
      if (D.29617 == 0) goto <D.29618>; else goto <D.29619>;
      <D.29618>:
      D.29620 = 0;
      return D.29620;
      <D.29619>:
      info = mono_marshal_load_type_info (klass);
      goto <D.24625>;
      <D.24650>:
      D.29621 = field->type;
      D.29622 = D.29621->attrs;
      D.29623 = (int) D.29622;
      D.29624 = D.29623 & 16;
      if (D.29624 != 0) goto <D.29625>; else goto <D.29626>;
      <D.29625>:
      // predicted unlikely by continue predictor.
      goto <D.24625>;
      <D.29626>:
      D.29621 = field->type;
      D.29627 = D.29621->type;
      D.29628 = (int) D.29627;
      switch (D.29628) <default: <D.24649>, case 2: <D.24630>, case 3: <D.24633>, case 4: <D.24628>, case 5: <D.24629>, case 6: <D.24631>, case 7: <D.24632>, case 8: <D.24626>, case 9: <D.24627>, case 10: <D.24634>, case 11: <D.24635>, case 12: <D.24639>, case 13: <D.24640>, case 14: <D.24641>, case 15: <D.24638>, case 17: <D.24643>, case 24: <D.24636>, case 25: <D.24637>, case 29: <D.24644>>
      <D.24626>:
      <D.24627>:
      <D.24628>:
      <D.24629>:
      <D.24630>:
      <D.24631>:
      <D.24632>:
      <D.24633>:
      <D.24634>:
      <D.24635>:
      <D.24636>:
      <D.24637>:
      <D.24638>:
      <D.24639>:
      <D.24640>:
      <D.24641>:
      goto <D.24642>;
      <D.24643>:
      D.29621 = field->type;
      D.29629 = mono_class_from_mono_type (D.29621);
      D.29630 = BIT_FIELD_REF <*D.29629, 64, 256>;
      D.29631 = D.29630 & 16;
      if (D.29631 == 0) goto <D.29632>; else goto <D.29633>;
      <D.29632>:
      D.29621 = field->type;
      D.29634 = mono_class_from_mono_type (D.29621);
      D.29635 = can_marshal_struct (D.29634);
      if (D.29635 == 0) goto <D.29636>; else goto <D.29637>;
      <D.29636>:
      can_marshal = 0;
      <D.29637>:
      <D.29633>:
      goto <D.24642>;
      <D.24644>:
      {
        gboolean has_mspec;

        has_mspec = 0;
        if (info != 0B) goto <D.29638>; else goto <D.29639>;
        <D.29638>:
        i = 0;
        goto <D.24647>;
        <D.24646>:
        D.29640 = info->fields[i].field;
        if (D.29640 == field) goto <D.29641>; else goto <D.29642>;
        <D.29641>:
        D.29643 = info->fields[i].mspec;
        if (D.29643 != 0B) goto <D.29644>; else goto <D.29645>;
        <D.29644>:
        has_mspec = 1;
        <D.29645>:
        <D.29642>:
        i = i + 1;
        <D.24647>:
        i.91 = (unsigned int) i;
        D.29647 = info->num_fields;
        if (i.91 < D.29647) goto <D.24646>; else goto <D.24648>;
        <D.24648>:
        <D.29639>:
        if (has_mspec == 0) goto <D.29648>; else goto <D.29649>;
        <D.29648>:
        can_marshal = 0;
        <D.29649>:
        goto <D.24642>;
      }
      <D.24649>:
      can_marshal = 0;
      goto <D.24642>;
      <D.24642>:
      <D.24625>:
      field = mono_class_get_fields (klass, &iter);
      if (field != 0B) goto <D.24650>; else goto <D.24651>;
      <D.24651>:
      {
        size_t __s1_len;
        size_t __s2_len;

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

          __s2 = klass->name_space;
          D.29653 = "System.Net.NetworkInformation.MacOsStructs";
          D.29654 = MEM[(const unsigned char *)D.29653];
          D.29655 = (int) D.29654;
          D.29656 = *__s2;
          D.29657 = (int) D.29656;
          __result = D.29655 - D.29657;
          {
            if (__s2_len != 0) goto <D.29658>; else goto <D.29659>;
            <D.29658>:
            if (__result == 0) goto <D.29660>; else goto <D.29661>;
            <D.29660>:
            D.29662 = &MEM[(void *)"System.Net.NetworkInformation.MacOsStructs" + 1B];
            D.29663 = *D.29662;
            D.29664 = (int) D.29663;
            D.29665 = __s2 + 1;
            D.29666 = *D.29665;
            D.29667 = (int) D.29666;
            __result = D.29664 - D.29667;
            if (__s2_len > 1) goto <D.29668>; else goto <D.29669>;
            <D.29668>:
            if (__result == 0) goto <D.29670>; else goto <D.29671>;
            <D.29670>:
            D.29672 = &MEM[(void *)"System.Net.NetworkInformation.MacOsStructs" + 2B];
            D.29673 = *D.29672;
            D.29674 = (int) D.29673;
            D.29675 = __s2 + 2;
            D.29676 = *D.29675;
            D.29677 = (int) D.29676;
            __result = D.29674 - D.29677;
            if (__s2_len > 2) goto <D.29678>; else goto <D.29679>;
            <D.29678>:
            if (__result == 0) goto <D.29680>; else goto <D.29681>;
            <D.29680>:
            D.29682 = &MEM[(void *)"System.Net.NetworkInformation.MacOsStructs" + 3B];
            D.29683 = *D.29682;
            D.29684 = (int) D.29683;
            D.29685 = __s2 + 3;
            D.29686 = *D.29685;
            D.29687 = (int) D.29686;
            __result = D.29684 - D.29687;
            <D.29681>:
            <D.29679>:
            <D.29671>:
            <D.29669>:
            <D.29661>:
            <D.29659>:
          }
          D.24659 = __result;
        }
        iftmp.92 = -D.24659;
        goto <D.29688>;
        <D.29652>:
        D.29689 = klass->name_space;
        iftmp.92 = __builtin_strcmp (D.29689, "System.Net.NetworkInformation.MacOsStructs");
        <D.29688>:
        D.24660 = iftmp.92;
      }
      if (D.24660 == 0) goto <D.29690>; else goto <D.29691>;
      <D.29690>:
      {
        size_t __s1_len;
        size_t __s2_len;

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

          __s2 = klass->name;
          D.29695 = "sockaddr_dl";
          D.29696 = MEM[(const unsigned char *)D.29695];
          D.29697 = (int) D.29696;
          D.29698 = *__s2;
          D.29699 = (int) D.29698;
          __result = D.29697 - D.29699;
          {
            if (__s2_len != 0) goto <D.29700>; else goto <D.29701>;
            <D.29700>:
            if (__result == 0) goto <D.29702>; else goto <D.29703>;
            <D.29702>:
            D.29704 = &MEM[(void *)"sockaddr_dl" + 1B];
            D.29705 = *D.29704;
            D.29706 = (int) D.29705;
            D.29707 = __s2 + 1;
            D.29708 = *D.29707;
            D.29709 = (int) D.29708;
            __result = D.29706 - D.29709;
            if (__s2_len > 1) goto <D.29710>; else goto <D.29711>;
            <D.29710>:
            if (__result == 0) goto <D.29712>; else goto <D.29713>;
            <D.29712>:
            D.29714 = &MEM[(void *)"sockaddr_dl" + 2B];
            D.29715 = *D.29714;
            D.29716 = (int) D.29715;
            D.29717 = __s2 + 2;
            D.29718 = *D.29717;
            D.29719 = (int) D.29718;
            __result = D.29716 - D.29719;
            if (__s2_len > 2) goto <D.29720>; else goto <D.29721>;
            <D.29720>:
            if (__result == 0) goto <D.29722>; else goto <D.29723>;
            <D.29722>:
            D.29724 = &MEM[(void *)"sockaddr_dl" + 3B];
            D.29725 = *D.29724;
            D.29726 = (int) D.29725;
            D.29727 = __s2 + 3;
            D.29728 = *D.29727;
            D.29729 = (int) D.29728;
            __result = D.29726 - D.29729;
            <D.29723>:
            <D.29721>:
            <D.29713>:
            <D.29711>:
            <D.29703>:
            <D.29701>:
          }
          D.24668 = __result;
        }
        iftmp.93 = -D.24668;
        goto <D.29730>;
        <D.29694>:
        D.29731 = klass->name;
        iftmp.93 = __builtin_strcmp (D.29731, "sockaddr_dl");
        <D.29730>:
        D.24669 = iftmp.93;
      }
      if (D.24669 != 0) goto <D.29732>; else goto <D.29733>;
      <D.29732>:
      D.29620 = 1;
      return D.29620;
      <D.29733>:
      <D.29691>:
      D.29620 = can_marshal;
      return D.29620;
    }
  finally
    {
      iter = {CLOBBER};
    }
}


compile_methods (struct MonoAotCompile * acfg)
{
  int D.29737;
  struct GPtrArray * D.29740;
  unsigned int D.29741;
  unsigned int D.29742;
  unsigned int D.29743;
  _Bool D.29744;
  long int D.29745;
  long int D.29746;
  long unsigned int D.29749;
  long unsigned int D.29750;
  long unsigned int D.29751;
  long unsigned int D.29752;
  struct MonoMethod * * D.29753;
  void * * D.29754;
  void * * D.29755;
  void * D.29756;
  struct MonoMethod * D.29759;
  struct MonoDomain * D.29760;
  void * * D.29761;
  void * * D.29762;
  void * * D.29763;
  void * * D.29764;
  void * D.29765;
  unsigned int i.94;
  unsigned int D.29767;
  int i;
  int methods_len;

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

    D.29740 = acfg->methods;
    D.29741 = D.29740->len;
    methods_len = (int) D.29741;
    D.29740 = acfg->methods;
    D.29741 = D.29740->len;
    D.29737 = acfg->aot_opts.nthreads;
    D.29742 = (unsigned int) D.29737;
    D.29743 = D.29741 / D.29742;
    len = (int) D.29743;
    D.29744 = len <= 0;
    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", 8377, "len > 0");
    <D.29748>:
    threads = monoeg_g_ptr_array_new ();
    D.29749 = (long unsigned int) methods_len;
    D.29750 = D.29749 * 8;
    methods = monoeg_malloc0 (D.29750);
    i = 0;
    goto <D.26420>;
    <D.26419>:
    D.29751 = (long unsigned int) i;
    D.29752 = D.29751 * 8;
    D.29753 = methods + D.29752;
    D.29740 = acfg->methods;
    D.29754 = D.29740->pdata;
    D.29751 = (long unsigned int) i;
    D.29752 = D.29751 * 8;
    D.29755 = D.29754 + D.29752;
    D.29756 = *D.29755;
    *D.29753 = D.29756;
    i = i + 1;
    <D.26420>:
    if (i < methods_len) goto <D.26419>; else goto <D.26421>;
    <D.26421>:
    i = 0;
    goto <D.26426>;
    <D.26425>:
    frag = monoeg_g_ptr_array_new ();
    j = 0;
    goto <D.26423>;
    <D.26422>:
    if (i < methods_len) goto <D.29757>; else goto <D.29758>;
    <D.29757>:
    D.29751 = (long unsigned int) i;
    D.29752 = D.29751 * 8;
    D.29753 = methods + D.29752;
    D.29759 = *D.29753;
    monoeg_g_ptr_array_add (frag, D.29759);
    i = i + 1;
    <D.29758>:
    j = j + 1;
    <D.26423>:
    if (j < len) goto <D.26422>; else goto <D.26424>;
    <D.26424>:
    user_data = monoeg_malloc0 (24);
    D.29760 = mono_domain_get ();
    *user_data = D.29760;
    D.29761 = user_data + 8;
    *D.29761 = acfg;
    D.29762 = user_data + 16;
    *D.29762 = frag;
    handle = mono_threads_create_thread (compile_thread_main, user_data, 0, 0, 0B);
    monoeg_g_ptr_array_add (threads, handle);
    <D.26426>:
    if (i < methods_len) goto <D.26425>; else goto <D.26427>;
    <D.26427>:
    monoeg_g_free (methods);
    i = 0;
    goto <D.26429>;
    <D.26428>:
    D.29763 = threads->pdata;
    D.29751 = (long unsigned int) i;
    D.29752 = D.29751 * 8;
    D.29764 = D.29763 + D.29752;
    D.29765 = *D.29764;
    WaitForSingleObjectEx (D.29765, 4294967295, 0);
    i = i + 1;
    <D.26429>:
    i.94 = (unsigned int) i;
    D.29767 = threads->len;
    if (i.94 < D.29767) goto <D.26428>; else goto <D.26430>;
    <D.26430>:
  }
  goto <D.29768>;
  <D.29739>:
  methods_len = 0;
  <D.29768>:
  i = methods_len;
  goto <D.26432>;
  <D.26431>:
  D.29740 = acfg->methods;
  D.29754 = D.29740->pdata;
  D.29751 = (long unsigned int) i;
  D.29752 = D.29751 * 8;
  D.29755 = D.29754 + D.29752;
  D.29756 = *D.29755;
  compile_method (acfg, D.29756);
  i = i + 1;
  <D.26432>:
  i.94 = (unsigned int) i;
  D.29740 = acfg->methods;
  D.29741 = D.29740->len;
  if (i.94 < D.29741) goto <D.26431>; else goto <D.26433>;
  <D.26433>:
}


compile_thread_main (void * * user_data)
{
  void * * D.29769;
  long unsigned int D.29770;
  long unsigned int D.29771;
  void * * D.29772;
  void * D.29773;
  unsigned int i.95;
  unsigned int D.29775;
  struct MonoDomain * domain;
  struct MonoAotCompile * acfg;
  struct GPtrArray * methods;
  int i;

  domain = *user_data;
  acfg = MEM[(void * *)user_data + 8B];
  methods = MEM[(void * *)user_data + 16B];
  mono_thread_attach (domain);
  i = 0;
  goto <D.25982>;
  <D.25981>:
  D.29769 = methods->pdata;
  D.29770 = (long unsigned int) i;
  D.29771 = D.29770 * 8;
  D.29772 = D.29769 + D.29771;
  D.29773 = *D.29772;
  compile_method (acfg, D.29773);
  i = i + 1;
  <D.25982>:
  i.95 = (unsigned int) i;
  D.29775 = methods->len;
  if (i.95 < D.29775) goto <D.25981>; else goto <D.25983>;
  <D.25983>:
}


compile_method (struct MonoAotCompile * acfg, struct MonoMethod * method)
{
  int D.29776;
  union mono_mutex_t * D.29779;
  _Bool D.29782;
  long int D.29783;
  long int D.29784;
  unsigned int D.29787;
  _Bool D.29790;
  long int D.29791;
  long int D.29792;
  short unsigned int D.29797;
  int D.29798;
  int D.29799;
  short unsigned int D.29801;
  int D.29802;
  int D.29803;
  int D.29805;
  int D.29806;
  short unsigned int D.29811;
  int D.29812;
  int D.29813;
  long unsigned int D.29816;
  long unsigned int D.29817;
  long unsigned int D.29820;
  long unsigned int D.29821;
  int * D.29824;
  unsigned int D.29825;
  struct MonoDomain * D.29826;
  JitFlags iftmp.96;
  int D.29828;
  unsigned int D.29832;
  int D.29835;
  char * D.29838;
  char * D.29839;
  int * D.29840;
  char * D.29845;
  long unsigned int D.29846;
  long unsigned int D.29847;
  char * D.29852;
  int * D.29853;
  unsigned int index.97;
  <unnamed type> D.29855;
  _Bool D.29858;
  long int D.29859;
  long int D.29860;
  struct GHashTable * D.29863;
  _Bool D.29866;
  long int D.29867;
  long int D.29868;
  char * D.29875;
  int * D.29876;
  _Bool D.29879;
  long int D.29880;
  long int D.29881;
  int D.29884;
  char * D.29891;
  int D.29892;
  int D.29893;
  _Bool D.29896;
  long int D.29897;
  long int D.29898;
  struct GHashTable * D.29901;
  void * D.29902;
  long int D.29903;
  int D.29904;
  long unsigned int D.29909;
  long unsigned int D.29910;
  struct MonoClass * D.29915;
  int D.29916;
  int D.29918;
  int D.29919;
  short unsigned int D.29922;
  int D.29923;
  int D.29924;
  struct MonoMethod * D.29929;
  int D.29930;
  int D.29932;
  long unsigned int D.29933;
  int D.25926;
  int iftmp.98;
  int D.25925;
  const char[12] * D.29939;
  unsigned char D.29940;
  int 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;
  const unsigned char * D.29958;
  unsigned char D.29959;
  int D.29960;
  const unsigned char * D.29961;
  unsigned char D.29962;
  int D.29963;
  const unsigned char * D.29968;
  unsigned char D.29969;
  int D.29970;
  const unsigned char * D.29971;
  unsigned char D.29972;
  int D.29973;
  const char * D.29975;
  struct MonoGenericClass * D.29978;
  int D.29981;
  struct MonoClassField * D.29984;
  struct MonoGenericClass * D.29985;
  struct MonoGenericContext * D.29988;
  int D.29989;
  struct MonoMethod * D.29992;
  struct MonoMethod * D.29995;
  struct MonoImage * D.29996;
  struct MonoImage * D.29997;
  int D.30000;
  long unsigned int D.30003;
  long unsigned int D.30004;
  int * D.30007;
  struct MonoMemPool * D.30008;
  void * D.30012;
  struct GSList * D.30013;
  short unsigned int D.30014;
  int D.30015;
  <unnamed-unsigned:1> D.30016;
  int D.30017;
  int D.30018;
  long unsigned int D.30019;
  unsigned int D.30020;
  unsigned int D.30021;
  long unsigned int D.30022;
  long unsigned int D.30023;
  struct MonoInst * * D.30024;
  void * D.30025;
  struct MonoInst * D.30026;
  struct MonoInst * * D.30027;
  struct MonoInst * * D.30028;
  struct MonoInst * D.30029;
  short unsigned int D.30030;
  unsigned int D.30031;
  unsigned int D.30032;
  struct MonoInst * * D.30033;
  void * D.30034;
  struct MonoInst * D.30035;
  struct MonoInst * * D.30036;
  struct MonoInst * * D.30037;
  struct MonoInst * D.30038;
  int D.30039;
  struct MonoMemPool * D.30040;
  struct MonoInst * * D.30041;
  struct MonoMethodVar * D.30042;
  struct MonoRegState * D.30043;
  int D.30046;
  long unsigned int D.30047;
  long unsigned int D.30048;
  struct MonoCompile * * D.30049;
  long unsigned int D.30050;
  long unsigned int D.30051;
  long unsigned int D.30052;
  long unsigned int D.30053;
  struct MonoCompile * * D.30054;
  struct GHashTable * D.30055;
  struct MonoMethod * D.30056;
  _Bool D.30059;
  long int D.30060;
  long int D.30061;
  int * D.30064;
  struct MonoCompile * cfg;
  struct MonoJumpInfo * patch_info;
  gboolean skip;
  int index;
  int depth;
  struct MonoMethod * wrapped;

  D.29776 = acfg->aot_opts.metadata_only;
  if (D.29776 != 0) goto <D.29777>; else goto <D.29778>;
  <D.29777>:
  return;
  <D.29778>:
  {
    int ret;

    D.29779 = &acfg->mutex.mutex;
    ret = pthread_mutex_lock (D.29779);
    if (ret != 0) goto <D.29780>; else goto <D.29781>;
    <D.29780>:
    monoeg_g_log (0B, 16, "Bad call to mono_mutex_lock result %d", ret);
    <D.29781>:
    D.29782 = ret != 0;
    D.29783 = (long int) D.29782;
    D.29784 = __builtin_expect (D.29783, 0);
    if (D.29784 != 0) goto <D.29785>; else goto <D.29786>;
    <D.29785>:
    monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "aot-compiler.c", 6458, "ret == 0");
    <D.29786>:
  }
  D.29787 = get_method_index (acfg, method);
  index = (int) D.29787;
  {
    int ret;

    D.29779 = &acfg->mutex.mutex;
    ret = pthread_mutex_unlock (D.29779);
    if (ret != 0) goto <D.29788>; else goto <D.29789>;
    <D.29788>:
    monoeg_g_log (0B, 16, "Bad call to mono_mutex_unlock result %d", ret);
    <D.29789>:
    D.29790 = ret != 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", 6460, "ret == 0");
    <D.29794>:
  }
  D.29797 = method->flags;
  D.29798 = (int) D.29797;
  D.29799 = D.29798 & 8192;
  if (D.29799 != 0) goto <D.29795>; else goto <D.29800>;
  <D.29800>:
  D.29801 = method->iflags;
  D.29802 = (int) D.29801;
  D.29803 = D.29802 & 3;
  if (D.29803 != 0) goto <D.29795>; else goto <D.29804>;
  <D.29804>:
  D.29797 = method->flags;
  D.29798 = (int) D.29797;
  D.29805 = D.29798 & 1024;
  if (D.29805 != 0) goto <D.29795>; else goto <D.29796>;
  <D.29795>:
  return;
  <D.29796>:
  D.29801 = method->iflags;
  D.29802 = (int) D.29801;
  D.29806 = D.29802 & 4096;
  if (D.29806 != 0) goto <D.29807>; else goto <D.29808>;
  <D.29807>:
  return;
  <D.29808>:
  wrapped = mono_marshal_method_from_wrapper (method);
  if (wrapped != 0B) goto <D.29809>; else goto <D.29810>;
  <D.29809>:
  D.29811 = wrapped->iflags;
  D.29812 = (int) D.29811;
  D.29813 = D.29812 & 4096;
  if (D.29813 != 0) goto <D.29814>; else goto <D.29815>;
  <D.29814>:
  D.29816 = BIT_FIELD_REF <*wrapped, 64, 256>;
  D.29817 = D.29816 & 2048;
  if (D.29817 != 0) goto <D.29818>; else goto <D.29819>;
  <D.29818>:
  return;
  <D.29819>:
  <D.29815>:
  <D.29810>:
  D.29820 = BIT_FIELD_REF <*method, 64, 256>;
  D.29821 = D.29820 & 124;
  if (D.29821 == 108) goto <D.29822>; else goto <D.29823>;
  <D.29822>:
  return;
  <D.29823>:
  D.29824 = &acfg->stats.mcount;
  InterlockedIncrement (D.29824);
  D.29825 = acfg->opts;
  D.29826 = mono_get_root_domain ();
  D.29828 = acfg->aot_opts.full_aot;
  if (D.29828 != 0) goto <D.29829>; else goto <D.29830>;
  <D.29829>:
  iftmp.96 = 6;
  goto <D.29831>;
  <D.29830>:
  iftmp.96 = 2;
  <D.29831>:
  cfg = mini_method_compile (method, D.29825, D.29826, iftmp.96, 0);
  mono_loader_clear_error ();
  D.29832 = cfg->exception_type;
  if (D.29832 == 11) goto <D.29833>; else goto <D.29834>;
  <D.29833>:
  D.29835 = acfg->aot_opts.print_skipped_methods;
  if (D.29835 != 0) goto <D.29836>; else goto <D.29837>;
  <D.29836>:
  D.29838 = mono_method_full_name (method, 1);
  D.29839 = cfg->exception_message;
  printf ("Skip (gshared failure): %s (%s)\n", D.29838, D.29839);
  <D.29837>:
  D.29840 = &acfg->stats.genericcount;
  InterlockedIncrement (D.29840);
  return;
  <D.29834>:
  D.29832 = cfg->exception_type;
  if (D.29832 != 0) goto <D.29841>; else goto <D.29842>;
  <D.29841>:
  D.29835 = acfg->aot_opts.print_skipped_methods;
  if (D.29835 != 0) goto <D.29843>; else goto <D.29844>;
  <D.29843>:
  D.29845 = mono_method_full_name (method, 1);
  printf ("Skip (JIT failure): %s\n", D.29845);
  <D.29844>:
  return;
  <D.29842>:
  D.29846 = BIT_FIELD_REF <*cfg, 64, 5568>;
  D.29847 = D.29846 & 4294967296;
  if (D.29847 != 0) goto <D.29848>; else goto <D.29849>;
  <D.29848>:
  D.29835 = acfg->aot_opts.print_skipped_methods;
  if (D.29835 != 0) goto <D.29850>; else goto <D.29851>;
  <D.29850>:
  D.29852 = mono_method_full_name (method, 1);
  printf ("Skip (disabled): %s\n", D.29852);
  <D.29851>:
  D.29853 = &acfg->stats.ocount;
  InterlockedIncrement (D.29853);
  mono_destroy_compile (cfg);
  return;
  <D.29849>:
  index.97 = (unsigned int) index;
  cfg->method_index = index.97;
  patch_info = cfg->patch_info;
  goto <D.25901>;
  <D.25900>:
  D.29855 = patch_info->type;
  switch (D.29855) <default: <D.25899>, case 0: <D.25897>, case 2: <D.25896>>
  <D.25896>:
  <D.25897>:
  patch_info->type = 51;
  goto <D.25898>;
  <D.25899>:
  goto <D.25898>;
  <D.25898>:
  patch_info = patch_info->next;
  <D.25901>:
  if (patch_info != 0B) goto <D.25900>; else goto <D.25902>;
  <D.25902>:
  {
    int ret;

    D.29779 = &acfg->mutex.mutex;
    ret = pthread_mutex_lock (D.29779);
    if (ret != 0) goto <D.29856>; else goto <D.29857>;
    <D.29856>:
    monoeg_g_log (0B, 16, "Bad call to mono_mutex_lock result %d", ret);
    <D.29857>:
    D.29858 = ret != 0;
    D.29859 = (long int) D.29858;
    D.29860 = __builtin_expect (D.29859, 0);
    if (D.29860 != 0) goto <D.29861>; else goto <D.29862>;
    <D.29861>:
    monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "aot-compiler.c", 6536, "ret == 0");
    <D.29862>:
  }
  D.29863 = cfg->token_info_hash;
  monoeg_g_hash_table_foreach (D.29863, add_token_info_hash, acfg);
  {
    int ret;

    D.29779 = &acfg->mutex.mutex;
    ret = pthread_mutex_unlock (D.29779);
    if (ret != 0) goto <D.29864>; else goto <D.29865>;
    <D.29864>:
    monoeg_g_log (0B, 16, "Bad call to mono_mutex_unlock result %d", ret);
    <D.29865>:
    D.29866 = ret != 0;
    D.29867 = (long int) D.29866;
    D.29868 = __builtin_expect (D.29867, 0);
    if (D.29868 != 0) goto <D.29869>; else goto <D.29870>;
    <D.29869>:
    monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "aot-compiler.c", 6538, "ret == 0");
    <D.29870>:
  }
  skip = 0;
  patch_info = cfg->patch_info;
  goto <D.25909>;
  <D.25908>:
  D.29855 = patch_info->type;
  switch (D.29855) <default: <D.25907>, case 1: <D.25905>>
  <D.25905>:
  skip = 1;
  goto <D.25906>;
  <D.25907>:
  goto <D.25906>;
  <D.25906>:
  patch_info = patch_info->next;
  <D.25909>:
  if (patch_info != 0B) goto <D.25908>; else goto <D.25910>;
  <D.25910>:
  if (skip != 0) goto <D.29871>; else goto <D.29872>;
  <D.29871>:
  D.29835 = acfg->aot_opts.print_skipped_methods;
  if (D.29835 != 0) goto <D.29873>; else goto <D.29874>;
  <D.29873>:
  D.29875 = mono_method_full_name (method, 1);
  printf ("Skip (abs call): %s\n", D.29875);
  <D.29874>:
  D.29876 = &acfg->stats.abscount;
  InterlockedIncrement (D.29876);
  mono_destroy_compile (cfg);
  return;
  <D.29872>:
  {
    int ret;

    D.29779 = &acfg->mutex.mutex;
    ret = pthread_mutex_lock (D.29779);
    if (ret != 0) goto <D.29877>; else goto <D.29878>;
    <D.29877>:
    monoeg_g_log (0B, 16, "Bad call to mono_mutex_lock result %d", ret);
    <D.29878>:
    D.29879 = ret != 0;
    D.29880 = (long int) D.29879;
    D.29881 = __builtin_expect (D.29880, 0);
    if (D.29881 != 0) goto <D.29882>; else goto <D.29883>;
    <D.29882>:
    monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "aot-compiler.c", 6564, "ret == 0");
    <D.29883>:
  }
  skip = 0;
  patch_info = cfg->patch_info;
  goto <D.25913>;
  <D.25912>:
  D.29884 = can_encode_patch (acfg, patch_info);
  if (D.29884 == 0) goto <D.29885>; else goto <D.29886>;
  <D.29885>:
  skip = 1;
  <D.29886>:
  patch_info = patch_info->next;
  <D.25913>:
  if (patch_info != 0B) goto <D.25912>; else goto <D.25914>;
  <D.25914>:
  if (skip != 0) goto <D.29887>; else goto <D.29888>;
  <D.29887>:
  D.29835 = acfg->aot_opts.print_skipped_methods;
  if (D.29835 != 0) goto <D.29889>; else goto <D.29890>;
  <D.29889>:
  D.29891 = mono_method_full_name (method, 1);
  printf ("Skip (patches): %s\n", D.29891);
  <D.29890>:
  D.29892 = acfg->stats.ocount;
  D.29893 = D.29892 + 1;
  acfg->stats.ocount = D.29893;
  mono_destroy_compile (cfg);
  {
    int ret;

    D.29779 = &acfg->mutex.mutex;
    ret = pthread_mutex_unlock (D.29779);
    if (ret != 0) goto <D.29894>; else goto <D.29895>;
    <D.29894>:
    monoeg_g_log (0B, 16, "Bad call to mono_mutex_unlock result %d", ret);
    <D.29895>:
    D.29896 = ret != 0;
    D.29897 = (long int) D.29896;
    D.29898 = __builtin_expect (D.29897, 0);
    if (D.29898 != 0) goto <D.29899>; else goto <D.29900>;
    <D.29899>:
    monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "aot-compiler.c", 6580, "ret == 0");
    <D.29900>:
  }
  return;
  <D.29888>:
  D.29901 = acfg->method_depth;
  D.29902 = monoeg_g_hash_table_lookup (D.29901, method);
  D.29903 = (long int) D.29902;
  depth = (int) D.29903;
  D.29904 = acfg->aot_opts.no_instances;
  if (D.29904 == 0) goto <D.29905>; else goto <D.29906>;
  <D.29905>:
  if (depth <= 31) goto <D.29907>; else goto <D.29908>;
  <D.29907>:
  patch_info = cfg->patch_info;
  goto <D.25934>;
  <D.25933>:
  D.29855 = patch_info->type;
  switch (D.29855) <default: <D.25932>, case 3: <D.25916>, case 14: <D.25928>, case 16: <D.25930>>
  <D.25916>:
  {
    struct MonoMethod * m;

    m = patch_info->data.method;
    D.29909 = BIT_FIELD_REF <*m, 64, 256>;
    D.29910 = D.29909 & 4096;
    if (D.29910 != 0) goto <D.29911>; else goto <D.29912>;
    <D.29911>:
    D.29915 = m->klass;
    D.29916 = mono_class_generic_sharing_enabled (D.29915);
    if (D.29916 == 0) goto <D.29913>; else goto <D.29917>;
    <D.29917>:
    D.29918 = mono_method_is_generic_sharable_full (m, 0, 0, 0);
    if (D.29918 == 0) goto <D.29913>; else goto <D.29914>;
    <D.29913>:
    D.29919 = method_has_type_vars (m);
    if (D.29919 == 0) goto <D.29920>; else goto <D.29921>;
    <D.29920>:
    D.29922 = m->iflags;
    D.29923 = (int) D.29922;
    D.29924 = D.29923 & 4096;
    if (D.29924 != 0) goto <D.29925>; else goto <D.29926>;
    <D.29925>:
    D.29828 = acfg->aot_opts.full_aot;
    if (D.29828 != 0) goto <D.29927>; else goto <D.29928>;
    <D.29927>:
    D.29929 = mono_marshal_get_native_wrapper (m, 1, 1);
    D.29930 = depth + 1;
    add_extra_method_with_depth (acfg, D.29929, D.29930);
    <D.29928>:
    goto <D.29931>;
    <D.29926>:
    D.29930 = depth + 1;
    add_extra_method_with_depth (acfg, m, D.29930);
    add_types_from_method_header (acfg, m);
    <D.29931>:
    <D.29921>:
    <D.29914>:
    D.29915 = m->klass;
    D.29932 = depth + 5;
    add_generic_class_with_depth (acfg, D.29915, D.29932, "method");
    <D.29912>:
    D.29909 = BIT_FIELD_REF <*m, 64, 256>;
    D.29933 = D.29909 & 124;
    if (D.29933 == 28) goto <D.29934>; else goto <D.29935>;
    <D.29934>:
    {
      size_t __s1_len;
      size_t __s2_len;

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

        __s2 = m->name;
        D.29939 = "ElementAddr";
        D.29940 = MEM[(const unsigned char *)D.29939];
        D.29941 = (int) D.29940;
        D.29942 = *__s2;
        D.29943 = (int) D.29942;
        __result = D.29941 - D.29943;
        {
          if (__s2_len != 0) 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 *)"ElementAddr" + 1B];
          D.29949 = *D.29948;
          D.29950 = (int) D.29949;
          D.29951 = __s2 + 1;
          D.29952 = *D.29951;
          D.29953 = (int) D.29952;
          __result = D.29950 - D.29953;
          if (__s2_len > 1) goto <D.29954>; else goto <D.29955>;
          <D.29954>:
          if (__result == 0) goto <D.29956>; else goto <D.29957>;
          <D.29956>:
          D.29958 = &MEM[(void *)"ElementAddr" + 2B];
          D.29959 = *D.29958;
          D.29960 = (int) D.29959;
          D.29961 = __s2 + 2;
          D.29962 = *D.29961;
          D.29963 = (int) D.29962;
          __result = D.29960 - D.29963;
          if (__s2_len > 2) goto <D.29964>; else goto <D.29965>;
          <D.29964>:
          if (__result == 0) goto <D.29966>; else goto <D.29967>;
          <D.29966>:
          D.29968 = &MEM[(void *)"ElementAddr" + 3B];
          D.29969 = *D.29968;
          D.29970 = (int) D.29969;
          D.29971 = __s2 + 3;
          D.29972 = *D.29971;
          D.29973 = (int) D.29972;
          __result = D.29970 - D.29973;
          <D.29967>:
          <D.29965>:
          <D.29957>:
          <D.29955>:
          <D.29947>:
          <D.29945>:
        }
        D.25925 = __result;
      }
      iftmp.98 = -D.25925;
      goto <D.29974>;
      <D.29938>:
      D.29975 = m->name;
      iftmp.98 = __builtin_strcmp (D.29975, "ElementAddr");
      <D.29974>:
      D.25926 = iftmp.98;
    }
    if (D.25926 == 0) goto <D.29976>; else goto <D.29977>;
    <D.29976>:
    D.29930 = depth + 1;
    add_extra_method_with_depth (acfg, m, D.29930);
    <D.29977>:
    <D.29935>:
    goto <D.25927>;
  }
  <D.25928>:
  {
    struct MonoClass * klass;

    klass = patch_info->data.klass;
    D.29978 = klass->generic_class;
    if (D.29978 != 0B) goto <D.29979>; else goto <D.29980>;
    <D.29979>:
    D.29981 = mini_class_is_generic_sharable (klass);
    if (D.29981 == 0) goto <D.29982>; else goto <D.29983>;
    <D.29982>:
    D.29932 = depth + 5;
    add_generic_class_with_depth (acfg, klass, D.29932, "vtable");
    <D.29983>:
    <D.29980>:
    goto <D.25927>;
  }
  <D.25930>:
  {
    struct MonoClass * klass;

    D.29984 = patch_info->data.field;
    klass = D.29984->parent;
    D.29985 = klass->generic_class;
    if (D.29985 != 0B) goto <D.29986>; else goto <D.29987>;
    <D.29986>:
    D.29985 = klass->generic_class;
    D.29988 = &D.29985->context;
    D.29989 = mono_generic_context_is_sharable (D.29988, 0);
    if (D.29989 == 0) goto <D.29990>; else goto <D.29991>;
    <D.29990>:
    D.29992 = mono_class_get_cctor (klass);
    if (D.29992 != 0B) goto <D.29993>; else goto <D.29994>;
    <D.29993>:
    D.29995 = mono_class_get_cctor (klass);
    D.29930 = depth + 1;
    add_extra_method_with_depth (acfg, D.29995, D.29930);
    <D.29994>:
    <D.29991>:
    <D.29987>:
    goto <D.25927>;
  }
  <D.25932>:
  goto <D.25927>;
  <D.25927>:
  patch_info = patch_info->next;
  <D.25934>:
  if (patch_info != 0B) goto <D.25933>; else goto <D.25935>;
  <D.25935>:
  <D.29908>:
  <D.29906>:
  patch_info = cfg->patch_info;
  goto <D.25943>;
  <D.25942>:
  D.29855 = patch_info->type;
  switch (D.29855) <default: <D.25941>, case 12: <D.25940>, case 27: <D.25936>, case 42: <D.25938>, case 51: <D.25937>>
  <D.25936>:
  <D.25937>:
  <D.25938>:
  goto <D.25939>;
  <D.25940>:
  D.29996 = patch_info->data.image;
  D.29997 = acfg->image;
  if (D.29996 != D.29997) goto <D.29998>; else goto <D.29999>;
  <D.29998>:
  cfg->has_got_slots = 1;
  <D.29999>:
  goto <D.25939>;
  <D.25941>:
  D.30000 = is_plt_patch (patch_info);
  if (D.30000 == 0) goto <D.30001>; else goto <D.30002>;
  <D.30001>:
  cfg->has_got_slots = 1;
  <D.30002>:
  goto <D.25939>;
  <D.25939>:
  patch_info = patch_info->next;
  <D.25943>:
  if (patch_info != 0B) goto <D.25942>; else goto <D.25944>;
  <D.25944>:
  D.30003 = BIT_FIELD_REF <*cfg, 64, 5632>;
  D.30004 = D.30003 & 1;
  if (D.30004 == 0) goto <D.30005>; else goto <D.30006>;
  <D.30005>:
  D.30007 = &acfg->stats.methods_without_got_slots;
  InterlockedIncrement (D.30007);
  <D.30006>:
  {
    struct MonoJumpInfo * patches;
    struct MonoJumpInfo * patches_end;

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

      D.30008 = acfg->mempool;
      new_patch_info = mono_patch_info_dup_mp (D.30008, patch_info);
      if (patches == 0B) goto <D.30009>; else goto <D.30010>;
      <D.30009>:
      patches = new_patch_info;
      goto <D.30011>;
      <D.30010>:
      patches_end->next = new_patch_info;
      <D.30011>:
      patches_end = new_patch_info;
    }
    patch_info = patch_info->next;
    <D.25949>:
    if (patch_info != 0B) goto <D.25948>; else goto <D.25950>;
    <D.25950>:
    cfg->patch_info = patches;
  }
  {
    struct GSList * l;
    struct GSList * unwind_ops;
    struct MonoUnwindOp * op;

    unwind_ops = 0B;
    l = cfg->unwind_ops;
    goto <D.25955>;
    <D.25954>:
    D.30008 = acfg->mempool;
    op = mono_mempool_alloc (D.30008, 12);
    D.30012 = l->data;
    memcpy (op, D.30012, 12);
    D.30008 = acfg->mempool;
    unwind_ops = g_slist_prepend_mempool (D.30008, unwind_ops, op);
    l = l->next;
    <D.25955>:
    if (l != 0B) goto <D.25954>; else goto <D.25956>;
    <D.25956>:
    D.30013 = monoeg_g_slist_reverse (unwind_ops);
    cfg->unwind_ops = D.30013;
  }
  {
    struct MonoInst * * args;
    struct MonoInst * * locals;
    struct MonoMethodSignature * sig;
    struct MonoMethodHeader * header;
    int i;

    sig = mono_method_signature (method);
    D.30008 = acfg->mempool;
    D.30014 = sig->param_count;
    D.30015 = (int) D.30014;
    D.30016 = sig->hasthis;
    D.30017 = (int) D.30016;
    D.30018 = D.30015 + D.30017;
    D.30019 = (long unsigned int) D.30018;
    D.30020 = (unsigned int) D.30019;
    D.30021 = D.30020 * 8;
    args = mono_mempool_alloc (D.30008, D.30021);
    i = 0;
    goto <D.25963>;
    <D.25962>:
    D.30022 = (long unsigned int) i;
    D.30023 = D.30022 * 8;
    D.30024 = args + D.30023;
    D.30008 = acfg->mempool;
    D.30025 = mono_mempool_alloc (D.30008, 80);
    *D.30024 = D.30025;
    D.30022 = (long unsigned int) i;
    D.30023 = D.30022 * 8;
    D.30024 = args + D.30023;
    D.30026 = *D.30024;
    D.30027 = cfg->args;
    D.30022 = (long unsigned int) i;
    D.30023 = D.30022 * 8;
    D.30028 = D.30027 + D.30023;
    D.30029 = *D.30028;
    memcpy (D.30026, D.30029, 80);
    i = i + 1;
    <D.25963>:
    D.30014 = sig->param_count;
    D.30015 = (int) D.30014;
    D.30016 = sig->hasthis;
    D.30017 = (int) D.30016;
    D.30018 = D.30015 + D.30017;
    if (D.30018 > i) goto <D.25962>; else goto <D.25964>;
    <D.25964>:
    cfg->args = args;
    header = mono_method_get_header (method);
    D.30008 = acfg->mempool;
    D.30030 = header->num_locals;
    D.30031 = (unsigned int) D.30030;
    D.30032 = D.30031 * 8;
    locals = mono_mempool_alloc (D.30008, D.30032);
    i = 0;
    goto <D.25966>;
    <D.25965>:
    D.30022 = (long unsigned int) i;
    D.30023 = D.30022 * 8;
    D.30033 = locals + D.30023;
    D.30008 = acfg->mempool;
    D.30034 = mono_mempool_alloc (D.30008, 80);
    *D.30033 = D.30034;
    D.30022 = (long unsigned int) i;
    D.30023 = D.30022 * 8;
    D.30033 = locals + D.30023;
    D.30035 = *D.30033;
    D.30036 = cfg->locals;
    D.30022 = (long unsigned int) i;
    D.30023 = D.30022 * 8;
    D.30037 = D.30036 + D.30023;
    D.30038 = *D.30037;
    memcpy (D.30035, D.30038, 80);
    i = i + 1;
    <D.25966>:
    D.30030 = header->num_locals;
    D.30039 = (int) D.30030;
    if (D.30039 > i) goto <D.25965>; else goto <D.25967>;
    <D.25967>:
    cfg->locals = locals;
  }
  D.30040 = cfg->mempool;
  mono_mempool_destroy (D.30040);
  cfg->mempool = 0B;
  D.30041 = cfg->varinfo;
  monoeg_g_free (D.30041);
  cfg->varinfo = 0B;
  D.30042 = cfg->vars;
  monoeg_g_free (D.30042);
  cfg->vars = 0B;
  D.30043 = cfg->rs;
  if (D.30043 != 0B) goto <D.30044>; else goto <D.30045>;
  <D.30044>:
  D.30043 = cfg->rs;
  mono_regstate_free (D.30043);
  cfg->rs = 0B;
  <D.30045>:
  goto <D.25971>;
  <D.25970>:
  {
    struct MonoCompile * * new_cfgs;
    int new_size;

    D.30046 = acfg->cfgs_size;
    new_size = D.30046 * 2;
    D.30047 = (long unsigned int) new_size;
    D.30048 = D.30047 * 8;
    new_cfgs = monoeg_malloc0 (D.30048);
    D.30049 = acfg->cfgs;
    D.30046 = acfg->cfgs_size;
    D.30050 = (long unsigned int) D.30046;
    D.30051 = D.30050 * 8;
    memcpy (new_cfgs, D.30049, D.30051);
    D.30049 = acfg->cfgs;
    monoeg_g_free (D.30049);
    acfg->cfgs = new_cfgs;
    acfg->cfgs_size = new_size;
  }
  <D.25971>:
  D.30046 = acfg->cfgs_size;
  if (D.30046 <= index) goto <D.25970>; else goto <D.25972>;
  <D.25972>:
  D.30049 = acfg->cfgs;
  D.30052 = (long unsigned int) index;
  D.30053 = D.30052 * 8;
  D.30054 = D.30049 + D.30053;
  *D.30054 = cfg;
  D.30055 = acfg->method_to_cfg;
  D.30056 = cfg->orig_method;
  monoeg_g_hash_table_insert_replace (D.30055, D.30056, cfg, 0);
  {
    int ret;

    D.29779 = &acfg->mutex.mutex;
    ret = pthread_mutex_unlock (D.29779);
    if (ret != 0) goto <D.30057>; else goto <D.30058>;
    <D.30057>:
    monoeg_g_log (0B, 16, "Bad call to mono_mutex_unlock result %d", ret);
    <D.30058>:
    D.30059 = ret != 0;
    D.30060 = (long int) D.30059;
    D.30061 = __builtin_expect (D.30060, 0);
    if (D.30061 != 0) goto <D.30062>; else goto <D.30063>;
    <D.30062>:
    monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "aot-compiler.c", 6745, "ret == 0");
    <D.30063>:
  }
  D.30064 = &acfg->stats.ccount;
  InterlockedIncrement (D.30064);
}


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

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


method_has_type_vars (struct MonoMethod * method)
{
  struct MonoClass * D.30073;
  int D.30074;
  gboolean D.30077;
  long unsigned int D.30078;
  long unsigned int D.30079;
  struct MonoGenericInst * D.30082;
  struct MonoType * D.30085;
  struct MonoClass * D.30086;
  int D.30087;
  <unnamed-unsigned:22> D.30090;
  int D.30091;

  D.30073 = method->klass;
  D.30074 = has_type_vars (D.30073);
  if (D.30074 != 0) goto <D.30075>; else goto <D.30076>;
  <D.30075>:
  D.30077 = 1;
  return D.30077;
  <D.30076>:
  D.30078 = BIT_FIELD_REF <*method, 64, 256>;
  D.30079 = D.30078 & 4096;
  if (D.30079 != 0) goto <D.30080>; else goto <D.30081>;
  <D.30080>:
  {
    struct MonoGenericContext * context;

    context = mono_method_get_context (method);
    D.30082 = context->method_inst;
    if (D.30082 != 0B) goto <D.30083>; else goto <D.30084>;
    <D.30083>:
    {
      int i;

      i = 0;
      goto <D.24874>;
      <D.24873>:
      D.30082 = context->method_inst;
      D.30085 = D.30082->type_argv[i];
      D.30086 = mono_class_from_mono_type (D.30085);
      D.30087 = has_type_vars (D.30086);
      if (D.30087 != 0) goto <D.30088>; else goto <D.30089>;
      <D.30088>:
      D.30077 = 1;
      return D.30077;
      <D.30089>:
      i = i + 1;
      <D.24874>:
      D.30082 = context->method_inst;
      D.30090 = D.30082->type_argc;
      D.30091 = (int) D.30090;
      if (D.30091 > i) goto <D.24873>; else goto <D.24875>;
      <D.24875>:
    }
    <D.30084>:
  }
  <D.30081>:
  D.30077 = 0;
  return D.30077;
}


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

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


InterlockedIncrement (volatile gint32 * val)
{
  gint32 D.30095;
  unsigned int D.30096;

  D.30096 = __sync_add_and_fetch_4 (val, 1);
  D.30095 = (gint32) D.30096;
  return D.30095;
}


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

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


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

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


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

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


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

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


emit_code (struct MonoAotCompile * acfg)
{
  char * D.30102;
  int D.30103;
  struct MonoCompile * * D.30106;
  long unsigned int D.30107;
  long unsigned int D.30108;
  struct MonoCompile * * D.30109;
  struct MonoCompile * D.30110;
  long unsigned int D.30113;
  long unsigned int D.30114;
  char * D.30117;
  gchar * D.30118;
  unsigned int i.99;
  unsigned int D.30120;
  char * D.30121;
  gchar * D.30124;
  struct GPtrArray * D.30125;
  void * * D.30126;
  long unsigned int D.30127;
  long unsigned int D.30128;
  void * * D.30129;
  void * D.30130;
  long int D.30131;
  int D.30134;
  struct MonoMethod * D.30137;
  struct MonoClass * D.30138;
  long unsigned int D.30139;
  long unsigned int D.30140;
  unsigned int D.30143;
  int D.30144;
  long unsigned int D.30147;
  long unsigned int D.30148;
  struct FILE * D.30151;
  char * D.30152;
  int D.30159;
  int D.30160;
  unsigned int oindex.100;
  unsigned int D.30163;
  int D.30166;
  int D.30173;
  unsigned int D.30174;
  unsigned int D.30175;
  unsigned int D.30176;
  int D.30177;
  int D.30181;
  struct MonoMethod * D.30189;
  struct MonoClass * D.30190;
  long unsigned int D.30191;
  long unsigned int D.30192;
  unsigned int D.30195;
  long unsigned int D.30201;
  long unsigned int D.30202;
  _Bool D.30205;
  long int D.30206;
  long int D.30207;
  int oindex;
  int i;
  int prev_index;
  char symbol[256];

  try
    {
      sprintf (&symbol, ".Lgot_addr");
      emit_section_change (acfg, ".text", 0);
      emit_alignment (acfg, 8);
      emit_label (acfg, &symbol);
      D.30102 = acfg->got_symbol;
      emit_pointer (acfg, D.30102);
      emit_section_change (acfg, ".text", 0);
      emit_alignment (acfg, 8);
      D.30103 = acfg->llvm;
      if (D.30103 != 0) goto <D.30104>; else goto <D.30105>;
      <D.30104>:
      i = 0;
      goto <D.26057>;
      <D.26056>:
      D.30106 = acfg->cfgs;
      D.30107 = (long unsigned int) i;
      D.30108 = D.30107 * 8;
      D.30109 = D.30106 + D.30108;
      D.30110 = *D.30109;
      if (D.30110 != 0B) goto <D.30111>; else goto <D.30112>;
      <D.30111>:
      D.30106 = acfg->cfgs;
      D.30107 = (long unsigned int) i;
      D.30108 = D.30107 * 8;
      D.30109 = D.30106 + D.30108;
      D.30110 = *D.30109;
      D.30113 = BIT_FIELD_REF <*D.30110, 64, 5568>;
      D.30114 = D.30113 & 1099511627776;
      if (D.30114 != 0) goto <D.30115>; else goto <D.30116>;
      <D.30115>:
      D.30106 = acfg->cfgs;
      D.30107 = (long unsigned int) i;
      D.30108 = D.30107 * 8;
      D.30109 = D.30106 + D.30108;
      D.30110 = *D.30109;
      D.30117 = D.30110->asm_symbol;
      D.30118 = monoeg_strdup (D.30117);
      acfg->methods_symbol = D.30118;
      goto <D.26055>;
      <D.30116>:
      <D.30112>:
      i = i + 1;
      <D.26057>:
      i.99 = (unsigned int) i;
      D.30120 = acfg->nmethods;
      if (i.99 < D.30120) goto <D.26056>; else goto <D.26055>;
      <D.26055>:
      <D.30105>:
      D.30121 = acfg->methods_symbol;
      if (D.30121 == 0B) goto <D.30122>; else goto <D.30123>;
      <D.30122>:
      sprintf (&symbol, "methods");
      emit_label (acfg, &symbol);
      D.30124 = monoeg_strdup (&symbol);
      acfg->methods_symbol = D.30124;
      <D.30123>:
      emit_zero_bytes (acfg, 16);
      oindex = 0;
      goto <D.26062>;
      <D.26061>:
      {
        struct MonoCompile * cfg;
        struct MonoMethod * method;

        D.30125 = acfg->method_order;
        D.30126 = D.30125->pdata;
        D.30127 = (long unsigned int) oindex;
        D.30128 = D.30127 * 8;
        D.30129 = D.30126 + D.30128;
        D.30130 = *D.30129;
        D.30131 = (long int) D.30130;
        i = (int) D.30131;
        D.30106 = acfg->cfgs;
        D.30107 = (long unsigned int) i;
        D.30108 = D.30107 * 8;
        D.30109 = D.30106 + D.30108;
        cfg = *D.30109;
        if (cfg == 0B) goto <D.30132>; else goto <D.30133>;
        <D.30132>:
        // predicted unlikely by continue predictor.
        goto <D.26060>;
        <D.30133>:
        method = cfg->orig_method;
        D.30134 = acfg->aot_opts.full_aot;
        if (D.30134 != 0) goto <D.30135>; else goto <D.30136>;
        <D.30135>:
        D.30137 = cfg->orig_method;
        D.30138 = D.30137->klass;
        D.30139 = BIT_FIELD_REF <*D.30138, 64, 256>;
        D.30140 = D.30139 & 8;
        if (D.30140 != 0) goto <D.30141>; else goto <D.30142>;
        <D.30141>:
        D.30143 = get_method_index (acfg, method);
        sprintf (&symbol, "ut_%d", D.30143);
        emit_section_change (acfg, ".text", 0);
        D.30144 = acfg->thumb_mixed;
        if (D.30144 != 0) goto <D.30145>; else goto <D.30146>;
        <D.30145>:
        D.30147 = BIT_FIELD_REF <*cfg, 64, 5568>;
        D.30148 = D.30147 & 1099511627776;
        if (D.30148 != 0) goto <D.30149>; else goto <D.30150>;
        <D.30149>:
        emit_set_thumb_mode (acfg);
        D.30151 = acfg->fp;
        fprintf (D.30151, "\n.thumb_func\n");
        <D.30150>:
        <D.30146>:
        emit_label (acfg, &symbol);
        D.30137 = cfg->orig_method;
        D.30152 = cfg->asm_symbol;
        arch_emit_unbox_trampoline (acfg, cfg, D.30137, D.30152);
        D.30144 = acfg->thumb_mixed;
        if (D.30144 != 0) goto <D.30153>; else goto <D.30154>;
        <D.30153>:
        D.30147 = BIT_FIELD_REF <*cfg, 64, 5568>;
        D.30148 = D.30147 & 1099511627776;
        if (D.30148 != 0) goto <D.30155>; else goto <D.30156>;
        <D.30155>:
        emit_set_arm_mode (acfg);
        <D.30156>:
        <D.30154>:
        <D.30142>:
        <D.30136>:
        D.30147 = BIT_FIELD_REF <*cfg, 64, 5568>;
        D.30148 = D.30147 & 1099511627776;
        if (D.30148 != 0) goto <D.30157>; else goto <D.30158>;
        <D.30157>:
        D.30159 = acfg->stats.llvm_count;
        D.30160 = D.30159 + 1;
        acfg->stats.llvm_count = D.30160;
        goto <D.30161>;
        <D.30158>:
        emit_method_code (acfg, cfg);
        <D.30161>:
      }
      <D.26060>:
      oindex = oindex + 1;
      <D.26062>:
      oindex.100 = (unsigned int) oindex;
      D.30125 = acfg->method_order;
      D.30163 = D.30125->len;
      if (oindex.100 < D.30163) goto <D.26061>; else goto <D.26063>;
      <D.26063>:
      sprintf (&symbol, "methods_end");
      emit_section_change (acfg, ".text", 0);
      emit_alignment (acfg, 8);
      emit_label (acfg, &symbol);
      emit_int32 (acfg, 0);
      D.30103 = acfg->llvm;
      if (D.30103 != 0) goto <D.30164>; else goto <D.30165>;
      <D.30164>:
      D.30166 = acfg->need_no_dead_strip;
      if (D.30166 != 0) goto <D.30167>; else goto <D.30168>;
      <D.30167>:
      D.30151 = acfg->fp;
      fprintf (D.30151, "\n");
      i = 0;
      goto <D.26065>;
      <D.26064>:
      D.30106 = acfg->cfgs;
      D.30107 = (long unsigned int) i;
      D.30108 = D.30107 * 8;
      D.30109 = D.30106 + D.30108;
      D.30110 = *D.30109;
      if (D.30110 != 0B) goto <D.30169>; else goto <D.30170>;
      <D.30169>:
      D.30106 = acfg->cfgs;
      D.30107 = (long unsigned int) i;
      D.30108 = D.30107 * 8;
      D.30109 = D.30106 + D.30108;
      D.30110 = *D.30109;
      D.30113 = BIT_FIELD_REF <*D.30110, 64, 5568>;
      D.30114 = D.30113 & 1099511627776;
      if (D.30114 != 0) goto <D.30171>; else goto <D.30172>;
      <D.30171>:
      D.30151 = acfg->fp;
      D.30106 = acfg->cfgs;
      D.30107 = (long unsigned int) i;
      D.30108 = D.30107 * 8;
      D.30109 = D.30106 + D.30108;
      D.30110 = *D.30109;
      D.30117 = D.30110->asm_symbol;
      fprintf (D.30151, ".no_dead_strip %s\n", D.30117);
      <D.30172>:
      <D.30170>:
      i = i + 1;
      <D.26065>:
      i.99 = (unsigned int) i;
      D.30120 = acfg->nmethods;
      if (i.99 < D.30120) goto <D.26064>; else goto <D.26066>;
      <D.26066>:
      <D.30168>:
      <D.30165>:
      sprintf (&symbol, "code_offsets");
      emit_section_change (acfg, ".rodata", 1);
      emit_alignment (acfg, 8);
      emit_label (acfg, &symbol);
      D.30173 = acfg->stats.offsets_size;
      D.30174 = (unsigned int) D.30173;
      D.30120 = acfg->nmethods;
      D.30175 = D.30120 * 4;
      D.30176 = D.30174 + D.30175;
      D.30177 = (int) D.30176;
      acfg->stats.offsets_size = D.30177;
      i = 0;
      goto <D.26068>;
      <D.26067>:
      D.30106 = acfg->cfgs;
      D.30107 = (long unsigned int) i;
      D.30108 = D.30107 * 8;
      D.30109 = D.30106 + D.30108;
      D.30110 = *D.30109;
      if (D.30110 != 0B) goto <D.30178>; else goto <D.30179>;
      <D.30178>:
      D.30106 = acfg->cfgs;
      D.30107 = (long unsigned int) i;
      D.30108 = D.30107 * 8;
      D.30109 = D.30106 + D.30108;
      D.30110 = *D.30109;
      D.30117 = D.30110->asm_symbol;
      D.30121 = acfg->methods_symbol;
      emit_symbol_diff (acfg, D.30117, D.30121, 0);
      goto <D.30180>;
      <D.30179>:
      emit_int32 (acfg, -1);
      <D.30180>:
      i = i + 1;
      <D.26068>:
      i.99 = (unsigned int) i;
      D.30120 = acfg->nmethods;
      if (i.99 < D.30120) goto <D.26067>; else goto <D.26069>;
      <D.26069>:
      emit_line (acfg);
      sprintf (&symbol, "unbox_trampolines");
      D.30181 = acfg->direct_method_addresses;
      if (D.30181 != 0) goto <D.30182>; else goto <D.30183>;
      <D.30182>:
      emit_section_change (acfg, ".text", 0);
      goto <D.30184>;
      <D.30183>:
      emit_section_change (acfg, ".rodata", 0);
      <D.30184>:
      emit_alignment (acfg, 8);
      emit_label (acfg, &symbol);
      prev_index = -1;
      i = 0;
      goto <D.26075>;
      <D.26074>:
      {
        struct MonoCompile * cfg;
        struct MonoMethod * method;
        int index;

        D.30106 = acfg->cfgs;
        D.30107 = (long unsigned int) i;
        D.30108 = D.30107 * 8;
        D.30109 = D.30106 + D.30108;
        cfg = *D.30109;
        if (cfg == 0B) goto <D.30185>; else goto <D.30186>;
        <D.30185>:
        // predicted unlikely by continue predictor.
        goto <D.26073>;
        <D.30186>:
        method = cfg->orig_method;
        D.30134 = acfg->aot_opts.full_aot;
        if (D.30134 != 0) goto <D.30187>; else goto <D.30188>;
        <D.30187>:
        D.30189 = cfg->orig_method;
        D.30190 = D.30189->klass;
        D.30191 = BIT_FIELD_REF <*D.30190, 64, 256>;
        D.30192 = D.30191 & 8;
        if (D.30192 != 0) goto <D.30193>; else goto <D.30194>;
        <D.30193>:
        D.30195 = get_method_index (acfg, method);
        index = (int) D.30195;
        sprintf (&symbol, "ut_%d", index);
        emit_int32 (acfg, index);
        D.30181 = acfg->direct_method_addresses;
        if (D.30181 != 0) goto <D.30196>; else goto <D.30197>;
        <D.30196>:
        emit_unset_mode (acfg);
        D.30144 = acfg->thumb_mixed;
        if (D.30144 != 0) goto <D.30200>; else goto <D.30198>;
        <D.30200>:
        D.30201 = BIT_FIELD_REF <*cfg, 64, 5568>;
        D.30202 = D.30201 & 1099511627776;
        if (D.30202 != 0) goto <D.30203>; else goto <D.30198>;
        <D.30203>:
        D.30151 = acfg->fp;
        fprintf (D.30151, "\n\tblx %s\n", &symbol);
        goto <D.30199>;
        <D.30198>:
        D.30151 = acfg->fp;
        fprintf (D.30151, "\n\tbl %s\n", &symbol);
        <D.30199>:
        goto <D.30204>;
        <D.30197>:
        D.30121 = acfg->methods_symbol;
        emit_symbol_diff (acfg, &symbol, D.30121, 0);
        <D.30204>:
        D.30205 = index <= prev_index;
        D.30206 = (long int) D.30205;
        D.30207 = __builtin_expect (D.30206, 0);
        if (D.30207 != 0) goto <D.30208>; else goto <D.30209>;
        <D.30208>:
        monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "aot-compiler.c", 7246, "index > prev_index");
        <D.30209>:
        prev_index = index;
        <D.30194>:
        <D.30188>:
      }
      <D.26073>:
      i = i + 1;
      <D.26075>:
      i.99 = (unsigned int) i;
      D.30120 = acfg->nmethods;
      if (i.99 < D.30120) goto <D.26074>; else goto <D.26076>;
      <D.26076>:
      sprintf (&symbol, "unbox_trampolines_end");
      emit_label (acfg, &symbol);
      emit_int32 (acfg, 0);
    }
  finally
    {
      symbol = {CLOBBER};
    }
}


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

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


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

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


arch_emit_unbox_trampoline (struct MonoAotCompile * acfg, struct MonoCompile * cfg, struct MonoMethod * method, const char * call_target)
{
  int D.30212;
  _Bool D.30213;
  long int D.30214;
  long int D.30215;
  struct FILE * D.30218;
  int this_pos;

  this_pos = 3;
  D.30212 = acfg->use_bin_writer;
  D.30213 = D.30212 != 0;
  D.30214 = (long int) D.30213;
  D.30215 = __builtin_expect (D.30214, 0);
  if (D.30215 != 0) goto <D.30216>; else goto <D.30217>;
  <D.30216>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "aot-compiler.c", 1449, "!acfg->use_bin_writer");
  <D.30217>:
  D.30218 = acfg->fp;
  fprintf (D.30218, "\n\taddi %d, %d, %d\n", this_pos, this_pos, 16);
  D.30218 = acfg->fp;
  fprintf (D.30218, "\n\tb %s\n", call_target);
}


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

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


emit_method_code (struct MonoAotCompile * acfg, struct MonoCompile * cfg)
{
  unsigned int D.30220;
  const char * D.30221;
  int D.30222;
  int D.30225;
  struct FILE * D.30228;
  char * D.30229;
  int D.30230;
  struct GHashTable * D.30235;
  struct GHashTable * D.30238;
  unsigned int D.30241;
  char * D.30244;
  int D.30245;
  unsigned int D.30246;
  unsigned int D.30247;
  unsigned int D.30248;
  int D.30249;
  struct MonoCompile * * D.30250;
  long unsigned int D.30251;
  long unsigned int D.30252;
  struct MonoCompile * * D.30253;
  struct MonoCompile * D.30254;
  unsigned int D.30255;
  struct MonoJumpInfo * D.30256;
  struct MonoJitInfo * D.30257;
  struct MonoMethod * D.30258;
  struct MonoDomain * D.30259;
  struct MonoDebugMethodJitInfo * D.30260;
  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.30220 = get_method_index (acfg, method);
  method_index = (int) D.30220;
  D.30221 = acfg->temp_prefix;
  symbol = monoeg_g_strdup_printf ("%sme_%x", D.30221, method_index);
  emit_section_change (acfg, ".text", 0);
  emit_alignment (acfg, func_alignment);
  D.30222 = acfg->global_symbols;
  if (D.30222 != 0) goto <D.30223>; else goto <D.30224>;
  <D.30223>:
  D.30225 = acfg->need_no_dead_strip;
  if (D.30225 != 0) goto <D.30226>; else goto <D.30227>;
  <D.30226>:
  D.30228 = acfg->fp;
  D.30229 = cfg->asm_symbol;
  fprintf (D.30228, "\t.no_dead_strip %s\n", D.30229);
  <D.30227>:
  <D.30224>:
  D.30229 = cfg->asm_symbol;
  emit_label (acfg, D.30229);
  D.30230 = acfg->aot_opts.write_symbols;
  if (D.30230 != 0) goto <D.30231>; else goto <D.30232>;
  <D.30231>:
  D.30222 = acfg->global_symbols;
  if (D.30222 == 0) goto <D.30233>; else goto <D.30234>;
  <D.30233>:
  D.30235 = acfg->method_label_hash;
  debug_sym = get_debug_sym (method, "", D.30235);
  D.30225 = acfg->need_no_dead_strip;
  if (D.30225 != 0) goto <D.30236>; else goto <D.30237>;
  <D.30236>:
  D.30228 = acfg->fp;
  fprintf (D.30228, "\t.no_dead_strip %s\n", debug_sym);
  <D.30237>:
  emit_local_symbol (acfg, debug_sym, symbol, 1);
  emit_label (acfg, debug_sym);
  <D.30234>:
  <D.30232>:
  D.30238 = acfg->export_names;
  export_name = monoeg_g_hash_table_lookup (D.30238, method);
  if (export_name != 0B) goto <D.30239>; else goto <D.30240>;
  <D.30239>:
  emit_global_inner (acfg, export_name, 1);
  emit_label (acfg, export_name);
  <D.30240>:
  D.30241 = cfg->verbose_level;
  if (D.30241 != 0) goto <D.30242>; else goto <D.30243>;
  <D.30242>:
  D.30244 = mono_method_full_name (method, 1);
  D.30229 = cfg->asm_symbol;
  monoeg_g_print ("Method %s emitted as %s\n", D.30244, D.30229);
  <D.30243>:
  D.30245 = acfg->stats.code_size;
  D.30246 = (unsigned int) D.30245;
  D.30247 = cfg->code_len;
  D.30248 = D.30246 + D.30247;
  D.30249 = (int) D.30248;
  acfg->stats.code_size = D.30249;
  D.30250 = acfg->cfgs;
  D.30251 = (long unsigned int) method_index;
  D.30252 = D.30251 * 8;
  D.30253 = D.30250 + D.30252;
  D.30254 = *D.30253;
  D.30255 = acfg->got_offset;
  D.30254->got_offset = D.30255;
  D.30247 = cfg->code_len;
  D.30256 = cfg->patch_info;
  D.30257 = cfg->jit_info;
  D.30258 = D.30257->d.method;
  D.30259 = mono_domain_get ();
  D.30260 = mono_debug_find_method (D.30258, D.30259);
  emit_and_reloc_code (acfg, method, code, D.30247, D.30256, 0, D.30260);
  emit_line (acfg);
  D.30230 = acfg->aot_opts.write_symbols;
  if (D.30230 != 0) goto <D.30261>; else goto <D.30262>;
  <D.30261>:
  emit_symbol_size (acfg, debug_sym, ".");
  monoeg_g_free (debug_sym);
  <D.30262>:
  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.30263;

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


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

  D.30264 = acfg->w;
  img_writer_emit_global (D.30264, 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.30267;
  int D.30268;
  int code_len.101;
  struct FILE * D.30278;
  void * * D.30279;
  long unsigned int D.30280;
  long unsigned int D.30281;
  void * * D.30282;
  int D.30283;
  unsigned int pindex.102;
  unsigned int D.30286;
  long unsigned int D.30289;
  long unsigned int D.30290;
  struct MonoDebugSourceLocation * * D.30291;
  struct MonoDebugSourceLocation * D.30292;
  char * D.30295;
  unsigned int D.30296;
  <unnamed type> D.30303;
  sizetype D.30304;
  guint8 * D.30305;
  int code_size.103;
  int D.30307;
  struct GHashTable * D.30308;
  struct GHashTable * D.30311;
  struct GPtrArray * D.30312;
  struct GPtrArray * D.30315;
  void * D.30316;
  long int D.30317;
  const void * D.30321;
  int D.30322;
  long unsigned int D.30323;
  void * D.30324;
  int D.30325;
  int D.30326;
  int code_size.104;
  int D.30328;
  struct MonoMethod * D.30332;
  struct MonoClass * D.30333;
  struct MonoImage * D.30334;
  struct MonoImage * D.30335;
  int D.30339;
  struct GHashTable * D.30342;
  int D.30343;
  int D.30344;
  int D.30345;
  int D.30346;
  int D.30351;
  short unsigned int D.30354;
  int D.30355;
  int D.30356;
  long unsigned int D.30362;
  _Bool D.30363;
  long int D.30364;
  long int D.30365;
  const char * D.30368;
  const char * D.30372;
  int D.30377;
  long unsigned int D.30380;
  _Bool D.30381;
  long int D.30382;
  long int D.30383;
  const void * D.30395;
  const void * D.30396;
  long unsigned int D.30399;
  _Bool D.30400;
  long int D.30401;
  long int D.30402;
  int D.30407;
  int call_size.105;
  int D.30415;
  int got_slot.106;
  int code_size.107;
  int D.30419;
  long unsigned int D.30429;
  long unsigned int D.30430;
  struct MonoDebugSourceLocation * * D.30431;
  struct MonoDebugSourceLocation * D.30432;
  const guint8 * D.30434;
  int D.30435;
  unsigned int i.108;
  int i;
  int pindex;
  int start_index;
  int method_index;
  struct GPtrArray * patches;
  struct MonoJumpInfo * patch_info;
  struct MonoMethodHeader * header;
  struct MonoDebugSourceLocation * * locs;
  gboolean skip;
  gboolean direct_call;
  gboolean external_call;
  guint32 got_slot;
  const char * direct_call_target;
  const char * direct_pinvoke;

  locs = 0B;
  direct_call_target = 0B;
  if (method != 0B) goto <D.30265>; else goto <D.30266>;
  <D.30265>:
  header = mono_method_get_header (method);
  D.30267 = get_method_index (acfg, method);
  method_index = (int) D.30267;
  <D.30266>:
  D.30268 = acfg->gas_line_numbers;
  if (D.30268 != 0) goto <D.30269>; else goto <D.30270>;
  <D.30269>:
  if (method != 0B) goto <D.30271>; else goto <D.30272>;
  <D.30271>:
  if (debug_info != 0B) goto <D.30273>; else goto <D.30274>;
  <D.30273>:
  code_len.101 = (int) code_len;
  locs = compute_line_numbers (method, code_len.101, debug_info);
  if (locs == 0B) goto <D.30276>; else goto <D.30277>;
  <D.30276>:
  {
    int findex;

    findex = get_file_index (acfg, "<unknown>");
    emit_unset_mode (acfg);
    D.30278 = acfg->fp;
    fprintf (D.30278, ".loc %d %d 0\n", findex, 1);
  }
  <D.30277>:
  <D.30274>:
  <D.30272>:
  <D.30270>:
  patches = monoeg_g_ptr_array_new ();
  patch_info = relocs;
  goto <D.25296>;
  <D.25295>:
  monoeg_g_ptr_array_add (patches, patch_info);
  patch_info = patch_info->next;
  <D.25296>:
  if (patch_info != 0B) goto <D.25295>; else goto <D.25297>;
  <D.25297>:
  monoeg_g_ptr_array_sort (patches, compare_patches);
  start_index = 0;
  i = 0;
  goto <D.25327>;
  <D.25326>:
  patch_info = 0B;
  pindex = start_index;
  goto <D.25300>;
  <D.25299>:
  D.30279 = patches->pdata;
  D.30280 = (long unsigned int) pindex;
  D.30281 = D.30280 * 8;
  D.30282 = D.30279 + D.30281;
  patch_info = *D.30282;
  D.30283 = patch_info->ip.i;
  if (D.30283 >= i) goto <D.25298>; else goto <D.30284>;
  <D.30284>:
  pindex = pindex + 1;
  <D.25300>:
  pindex.102 = (unsigned int) pindex;
  D.30286 = patches->len;
  if (pindex.102 < D.30286) goto <D.25299>; else goto <D.25298>;
  <D.25298>:
  if (locs != 0B) goto <D.30287>; else goto <D.30288>;
  <D.30287>:
  D.30289 = (long unsigned int) i;
  D.30290 = D.30289 * 8;
  D.30291 = locs + D.30290;
  D.30292 = *D.30291;
  if (D.30292 != 0B) goto <D.30293>; else goto <D.30294>;
  <D.30293>:
  {
    struct MonoDebugSourceLocation * loc;
    int findex;

    D.30289 = (long unsigned int) i;
    D.30290 = D.30289 * 8;
    D.30291 = locs + D.30290;
    loc = *D.30291;
    D.30295 = loc->source_file;
    findex = get_file_index (acfg, D.30295);
    emit_unset_mode (acfg);
    D.30278 = acfg->fp;
    D.30296 = loc->row;
    fprintf (D.30278, ".loc %d %d 0\n", findex, D.30296);
    mono_debug_symfile_free_location (loc);
  }
  <D.30294>:
  <D.30288>:
  skip = 0;
  if (patch_info != 0B) goto <D.30297>; else goto <D.30298>;
  <D.30297>:
  D.30283 = patch_info->ip.i;
  if (D.30283 == i) goto <D.30299>; else goto <D.30300>;
  <D.30299>:
  pindex.102 = (unsigned int) pindex;
  D.30286 = patches->len;
  if (pindex.102 < D.30286) goto <D.30301>; else goto <D.30302>;
  <D.30301>:
  start_index = pindex;
  D.30303 = patch_info->type;
  switch (D.30303) <default: <D.25311>, case 27: <D.25305>, case 49: <D.25307>, case 51: <D.25303>>
  <D.25303>:
  goto <D.25304>;
  <D.25305>:
  {
    int code_size;

    try
      {
        D.30304 = (sizetype) i;
        D.30305 = code + D.30304;
        arch_emit_got_offset (acfg, D.30305, &code_size);
        code_size.103 = code_size;
        D.30307 = code_size.103 + -1;
        i = D.30307 + i;
        skip = 1;
        patch_info->type = 51;
        goto <D.25304>;
      }
    finally
      {
        code_size = {CLOBBER};
      }
  }
  <D.25307>:
  {
    int code_size;
    int index;
    char * selector;

    try
      {
        selector = patch_info->data.target;
        D.30308 = acfg->objc_selector_to_index;
        if (D.30308 == 0B) goto <D.30309>; else goto <D.30310>;
        <D.30309>:
        D.30311 = monoeg_g_hash_table_new (monoeg_g_str_hash, monoeg_g_str_equal);
        acfg->objc_selector_to_index = D.30311;
        <D.30310>:
        D.30312 = acfg->objc_selectors;
        if (D.30312 == 0B) goto <D.30313>; else goto <D.30314>;
        <D.30313>:
        D.30315 = monoeg_g_ptr_array_new ();
        acfg->objc_selectors = D.30315;
        <D.30314>:
        D.30308 = acfg->objc_selector_to_index;
        D.30316 = monoeg_g_hash_table_lookup (D.30308, selector);
        D.30317 = (long int) D.30316;
        index = (int) D.30317;
        if (index != 0) goto <D.30318>; else goto <D.30319>;
        <D.30318>:
        index = index + -1;
        goto <D.30320>;
        <D.30319>:
        index = acfg->objc_selector_index;
        D.30312 = acfg->objc_selectors;
        D.30321 = patch_info->data.target;
        monoeg_g_ptr_array_add (D.30312, D.30321);
        D.30308 = acfg->objc_selector_to_index;
        D.30322 = index + 1;
        D.30323 = (long unsigned int) D.30322;
        D.30324 = (void *) D.30323;
        monoeg_g_hash_table_insert_replace (D.30308, selector, D.30324, 0);
        D.30325 = acfg->objc_selector_index;
        D.30326 = D.30325 + 1;
        acfg->objc_selector_index = D.30326;
        <D.30320>:
        D.30304 = (sizetype) i;
        D.30305 = code + D.30304;
        arch_emit_objc_selector_ref (acfg, D.30305, index, &code_size);
        code_size.104 = code_size;
        D.30328 = code_size.104 + -1;
        i = D.30328 + i;
        skip = 1;
        patch_info->type = 51;
        goto <D.25304>;
      }
    finally
      {
        code_size = {CLOBBER};
      }
  }
  <D.25311>:
  direct_call = 0;
  external_call = 0;
  D.30303 = patch_info->type;
  if (D.30303 == 3) goto <D.30331>; else goto <D.30329>;
  <D.30331>:
  D.30332 = patch_info->data.method;
  D.30333 = D.30332->klass;
  D.30334 = D.30333->image;
  D.30335 = acfg->image;
  if (D.30334 == D.30335) goto <D.30336>; else goto <D.30329>;
  <D.30336>:
  if (got_only == 0) goto <D.30337>; else goto <D.30338>;
  <D.30337>:
  D.30339 = is_direct_callable (acfg, method, patch_info);
  if (D.30339 != 0) goto <D.30340>; else goto <D.30341>;
  <D.30340>:
  {
    struct MonoCompile * callee_cfg;

    D.30342 = acfg->method_to_cfg;
    D.30332 = patch_info->data.method;
    callee_cfg = monoeg_g_hash_table_lookup (D.30342, D.30332);
    direct_call = 1;
    direct_call_target = callee_cfg->asm_symbol;
    patch_info->type = 51;
    D.30343 = acfg->stats.direct_calls;
    D.30344 = D.30343 + 1;
    acfg->stats.direct_calls = D.30344;
  }
  <D.30341>:
  <D.30338>:
  D.30345 = acfg->stats.all_calls;
  D.30346 = D.30345 + 1;
  acfg->stats.all_calls = D.30346;
  goto <D.30330>;
  <D.30329>:
  D.30303 = patch_info->type;
  if (D.30303 == 31) goto <D.30347>; else goto <D.30348>;
  <D.30347>:
  if (got_only == 0) goto <D.30349>; else goto <D.30350>;
  <D.30349>:
  D.30351 = is_direct_callable (acfg, method, patch_info);
  if (D.30351 != 0) goto <D.30352>; else goto <D.30353>;
  <D.30352>:
  D.30332 = patch_info->data.method;
  D.30354 = D.30332->flags;
  D.30355 = (int) D.30354;
  D.30356 = D.30355 & 8192;
  if (D.30356 == 0) goto <D.30357>; else goto <D.30358>;
  <D.30357>:
  D.30332 = patch_info->data.method;
  direct_pinvoke = mono_lookup_icall_symbol (D.30332);
  goto <D.30359>;
  <D.30358>:
  D.30332 = patch_info->data.method;
  direct_pinvoke = get_pinvoke_import (acfg, D.30332);
  <D.30359>:
  if (direct_pinvoke != 0B) goto <D.30360>; else goto <D.30361>;
  <D.30360>:
  direct_call = 1;
  D.30362 = strlen (direct_pinvoke);
  D.30363 = D.30362 > 999;
  D.30364 = (long int) D.30363;
  D.30365 = __builtin_expect (D.30364, 0);
  if (D.30365 != 0) goto <D.30366>; else goto <D.30367>;
  <D.30366>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "aot-compiler.c", 4615, "strlen (direct_pinvoke) < 1000");
  <D.30367>:
  D.30368 = acfg->user_symbol_prefix;
  direct_call_target = monoeg_g_strdup_printf ("%s%s", D.30368, direct_pinvoke);
  <D.30361>:
  <D.30353>:
  <D.30350>:
  goto <D.30369>;
  <D.30348>:
  D.30303 = patch_info->type;
  if (D.30303 == 32) goto <D.30370>; else goto <D.30371>;
  <D.30370>:
  {
    const char * sym;

    D.30372 = patch_info->data.name;
    sym = mono_lookup_jit_icall_symbol (D.30372);
    if (got_only == 0) goto <D.30373>; else goto <D.30374>;
    <D.30373>:
    if (sym != 0B) goto <D.30375>; else goto <D.30376>;
    <D.30375>:
    D.30377 = acfg->aot_opts.direct_icalls;
    if (D.30377 != 0) goto <D.30378>; else goto <D.30379>;
    <D.30378>:
    direct_call = 1;
    external_call = 1;
    D.30380 = strlen (sym);
    D.30381 = D.30380 > 999;
    D.30382 = (long int) D.30381;
    D.30383 = __builtin_expect (D.30382, 0);
    if (D.30383 != 0) goto <D.30384>; else goto <D.30385>;
    <D.30384>:
    monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "aot-compiler.c", 4625, "strlen (sym) < 1000");
    <D.30385>:
    D.30368 = acfg->user_symbol_prefix;
    direct_call_target = monoeg_g_strdup_printf ("%s%s", D.30368, sym);
    <D.30379>:
    <D.30376>:
    <D.30374>:
  }
  goto <D.30386>;
  <D.30371>:
  D.30303 = patch_info->type;
  if (D.30303 == 7) goto <D.30387>; else goto <D.30388>;
  <D.30387>:
  {
    struct MonoJitICallInfo * info;
    const char * sym;

    D.30372 = patch_info->data.name;
    info = mono_find_jit_icall_by_name (D.30372);
    D.30372 = patch_info->data.name;
    sym = mono_lookup_jit_icall_symbol (D.30372);
    if (got_only == 0) goto <D.30389>; else goto <D.30390>;
    <D.30389>:
    if (sym != 0B) goto <D.30391>; else goto <D.30392>;
    <D.30391>:
    D.30377 = acfg->aot_opts.direct_icalls;
    if (D.30377 != 0) goto <D.30393>; else goto <D.30394>;
    <D.30393>:
    D.30395 = info->func;
    D.30396 = info->wrapper;
    if (D.30395 == D.30396) goto <D.30397>; else goto <D.30398>;
    <D.30397>:
    direct_call = 1;
    external_call = 1;
    D.30399 = strlen (sym);
    D.30400 = D.30399 > 999;
    D.30401 = (long int) D.30400;
    D.30402 = __builtin_expect (D.30401, 0);
    if (D.30402 != 0) goto <D.30403>; else goto <D.30404>;
    <D.30403>:
    monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "aot-compiler.c", 4635, "strlen (sym) < 1000");
    <D.30404>:
    D.30368 = acfg->user_symbol_prefix;
    direct_call_target = monoeg_g_strdup_printf ("%s%s", D.30368, sym);
    <D.30398>:
    <D.30394>:
    <D.30392>:
    <D.30390>:
  }
  <D.30388>:
  <D.30386>:
  <D.30369>:
  <D.30330>:
  if (direct_call != 0) goto <D.30405>; else goto <D.30406>;
  <D.30405>:
  patch_info->type = 51;
  D.30343 = acfg->stats.direct_calls;
  D.30344 = D.30343 + 1;
  acfg->stats.direct_calls = D.30344;
  <D.30406>:
  D.30407 = got_only | direct_call;
  if (D.30407 == 0) goto <D.30408>; else goto <D.30409>;
  <D.30408>:
  {
    struct MonoPltEntry * plt_entry;

    plt_entry = get_plt_entry (acfg, patch_info);
    if (plt_entry != 0B) goto <D.30410>; else goto <D.30411>;
    <D.30410>:
    direct_call = 1;
    direct_call_target = plt_entry->symbol;
    patch_info->type = 51;
    plt_entry->jit_used = 1;
    <D.30411>:
  }
  <D.30409>:
  if (direct_call != 0) goto <D.30412>; else goto <D.30413>;
  <D.30412>:
  {
    int call_size;

    try
      {
        arch_emit_direct_call (acfg, direct_call_target, external_call, patch_info, &call_size);
        call_size.105 = call_size;
        D.30415 = call_size.105 + -1;
        i = D.30415 + i;
      }
    finally
      {
        call_size = {CLOBBER};
      }
  }
  goto <D.30416>;
  <D.30413>:
  {
    int code_size;

    try
      {
        got_slot = get_got_offset (acfg, patch_info);
        D.30304 = (sizetype) i;
        D.30305 = code + D.30304;
        got_slot.106 = (int) got_slot;
        arch_emit_got_access (acfg, D.30305, got_slot.106, &code_size);
        code_size.107 = code_size;
        D.30419 = code_size.107 + -1;
        i = D.30419 + i;
      }
    finally
      {
        code_size = {CLOBBER};
      }
  }
  <D.30416>:
  skip = 1;
  <D.25304>:
  <D.30302>:
  <D.30300>:
  <D.30298>:
  if (skip == 0) goto <D.30420>; else goto <D.30421>;
  <D.30420>:
  patch_info = 0B;
  pindex = start_index;
  goto <D.25321>;
  <D.25320>:
  D.30279 = patches->pdata;
  D.30280 = (long unsigned int) pindex;
  D.30281 = D.30280 * 8;
  D.30282 = D.30279 + D.30281;
  patch_info = *D.30282;
  D.30283 = patch_info->ip.i;
  if (D.30283 >= i) goto <D.25319>; else goto <D.30422>;
  <D.30422>:
  pindex = pindex + 1;
  <D.25321>:
  pindex.102 = (unsigned int) pindex;
  D.30286 = patches->len;
  if (pindex.102 < D.30286) goto <D.25320>; else goto <D.25319>;
  <D.25319>:
  pindex.102 = (unsigned int) pindex;
  D.30286 = patches->len;
  if (pindex.102 < D.30286) goto <D.30425>; else goto <D.30423>;
  <D.30425>:
  D.30283 = patch_info->ip.i;
  if (D.30283 > i) goto <D.30426>; else goto <D.30423>;
  <D.30426>:
  {
    int limit;

    limit = i + 1;
    goto <D.25325>;
    <D.25324>:
    if (locs != 0B) goto <D.30427>; else goto <D.30428>;
    <D.30427>:
    D.30429 = (long unsigned int) limit;
    D.30430 = D.30429 * 8;
    D.30431 = locs + D.30430;
    D.30432 = *D.30431;
    if (D.30432 != 0B) goto <D.25323>; else goto <D.30433>;
    <D.30433>:
    <D.30428>:
    limit = limit + 1;
    <D.25325>:
    D.30283 = patch_info->ip.i;
    if (D.30283 > limit) goto <D.25324>; else goto <D.25323>;
    <D.25323>:
    D.30304 = (sizetype) i;
    D.30434 = code + D.30304;
    D.30435 = limit - i;
    emit_bytes (acfg, D.30434, D.30435);
    i = limit + -1;
  }
  goto <D.30424>;
  <D.30423>:
  D.30304 = (sizetype) i;
  D.30434 = code + D.30304;
  emit_bytes (acfg, D.30434, 1);
  <D.30424>:
  <D.30421>:
  i = i + 1;
  <D.25327>:
  i.108 = (unsigned int) i;
  if (i.108 < code_len) goto <D.25326>; else goto <D.25328>;
  <D.25328>:
  monoeg_g_free (locs);
}


compare_patches (const void * a, const void * b)
{
  struct MonoJumpInfo * D.30440;
  struct MonoJumpInfo * D.30441;
  gint D.30444;
  int i;
  int j;

  D.30440 = MEM[(struct MonoJumpInfo * *)a];
  i = D.30440->ip.i;
  D.30441 = MEM[(struct MonoJumpInfo * *)b];
  j = D.30441->ip.i;
  if (i < j) goto <D.30442>; else goto <D.30443>;
  <D.30442>:
  D.30444 = -1;
  return D.30444;
  <D.30443>:
  if (i > j) goto <D.30445>; else goto <D.30446>;
  <D.30445>:
  D.30444 = 1;
  return D.30444;
  <D.30446>:
  D.30444 = 0;
  return D.30444;
}


compute_line_numbers (struct MonoMethod * method, int code_size, struct MonoDebugMethodJitInfo * debug_info)
{
  struct MonoDebugSourceLocation * * D.30450;
  unsigned int D.30451;
  unsigned int code_size.109;
  _Bool D.30455;
  long int D.30456;
  long int D.30457;
  unsigned int D.30460;
  long unsigned int D.30461;
  long unsigned int D.30462;
  struct MonoDebugLineNumberEntry * D.30463;
  long unsigned int D.30464;
  int D.30465;
  long unsigned int D.30466;
  long unsigned int D.30467;
  long unsigned int D.30468;
  long unsigned int D.30469;
  long unsigned int D.30472;
  long unsigned int D.30473;
  int * D.30474;
  unsigned int j.110;
  unsigned int D.30476;
  unsigned int i.111;
  unsigned int D.30478;
  sizetype D.30481;
  sizetype D.30482;
  sizetype D.30483;
  unsigned int D.30484;
  int D.30485;
  unsigned int D.30486;
  long unsigned int D.30488;
  long unsigned int D.30489;
  long unsigned int D.30490;
  int * D.30491;
  unsigned int il_offset.112;
  char * D.30499;
  unsigned int D.30500;
  unsigned int prev_line.113;
  struct MonoDebugSourceLocation * * D.30507;
  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.30448>; else goto <D.30449>;
  <D.30448>:
  D.30450 = 0B;
  return D.30450;
  <D.30449>:
  D.30451 = debug_info->code_size;
  code_size.109 = (unsigned int) code_size;
  if (D.30451 != code_size.109) goto <D.30453>; else goto <D.30454>;
  <D.30453>:
  D.30450 = 0B;
  return D.30450;
  <D.30454>:
  D.30455 = code_size == 0;
  D.30456 = (long int) D.30455;
  D.30457 = __builtin_expect (D.30456, 0);
  if (D.30457 != 0) goto <D.30458>; else goto <D.30459>;
  <D.30458>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "aot-compiler.c", 4403, "code_size");
  <D.30459>:
  D.30460 = debug_info->num_line_numbers;
  D.30461 = (long unsigned int) D.30460;
  D.30462 = D.30461 * 8;
  ln_array = monoeg_malloc0 (D.30462);
  D.30463 = debug_info->line_numbers;
  D.30460 = debug_info->num_line_numbers;
  D.30461 = (long unsigned int) D.30460;
  D.30462 = D.30461 * 8;
  memcpy (ln_array, D.30463, D.30462);
  D.30460 = debug_info->num_line_numbers;
  D.30464 = (long unsigned int) D.30460;
  qsort (ln_array, D.30464, 8, compare_lne);
  D.30465 = code_size + 1;
  D.30466 = (long unsigned int) D.30465;
  D.30467 = D.30466 * 4;
  native_to_il_offset = monoeg_malloc0 (D.30467);
  i = 0;
  goto <D.25259>;
  <D.25258>:
  {
    int j;
    struct MonoDebugLineNumberEntry * lne;

    D.30468 = (long unsigned int) i;
    D.30469 = D.30468 * 8;
    lne = ln_array + D.30469;
    if (i == 0) goto <D.30470>; else goto <D.30471>;
    <D.30470>:
    j = 0;
    goto <D.25249>;
    <D.25248>:
    D.30472 = (long unsigned int) j;
    D.30473 = D.30472 * 4;
    D.30474 = native_to_il_offset + D.30473;
    *D.30474 = -1;
    j = j + 1;
    <D.25249>:
    j.110 = (unsigned int) j;
    D.30476 = lne->native_offset;
    if (j.110 < D.30476) goto <D.25248>; else goto <D.25250>;
    <D.25250>:
    <D.30471>:
    i.111 = (unsigned int) i;
    D.30460 = debug_info->num_line_numbers;
    D.30478 = D.30460 + 4294967295;
    if (i.111 < D.30478) goto <D.30479>; else goto <D.30480>;
    <D.30479>:
    {
      struct MonoDebugLineNumberEntry * lne_next;

      D.30481 = (sizetype) i;
      D.30482 = D.30481 + 1;
      D.30483 = D.30482 * 8;
      lne_next = ln_array + D.30483;
      D.30476 = lne->native_offset;
      j = (int) D.30476;
      goto <D.25253>;
      <D.25252>:
      D.30472 = (long unsigned int) j;
      D.30473 = D.30472 * 4;
      D.30474 = native_to_il_offset + D.30473;
      D.30484 = lne->il_offset;
      D.30485 = (int) D.30484;
      *D.30474 = D.30485;
      j = j + 1;
      <D.25253>:
      j.110 = (unsigned int) j;
      D.30486 = lne_next->native_offset;
      if (j.110 < D.30486) goto <D.25252>; else goto <D.25254>;
      <D.25254>:
    }
    goto <D.30487>;
    <D.30480>:
    D.30476 = lne->native_offset;
    j = (int) D.30476;
    goto <D.25256>;
    <D.25255>:
    D.30472 = (long unsigned int) j;
    D.30473 = D.30472 * 4;
    D.30474 = native_to_il_offset + D.30473;
    D.30484 = lne->il_offset;
    D.30485 = (int) D.30484;
    *D.30474 = D.30485;
    j = j + 1;
    <D.25256>:
    if (j < code_size) goto <D.25255>; else goto <D.25257>;
    <D.25257>:
    <D.30487>:
  }
  i = i + 1;
  <D.25259>:
  i.111 = (unsigned int) i;
  D.30460 = debug_info->num_line_numbers;
  if (i.111 < D.30460) goto <D.25258>; else goto <D.25260>;
  <D.25260>:
  monoeg_g_free (ln_array);
  D.30488 = (long unsigned int) code_size;
  D.30489 = D.30488 * 8;
  res = monoeg_malloc0 (D.30489);
  prev_il_offset = -1;
  prev_line = -1;
  first = 1;
  i = 0;
  goto <D.25264>;
  <D.25263>:
  {
    int il_offset;

    D.30468 = (long unsigned int) i;
    D.30490 = D.30468 * 4;
    D.30491 = native_to_il_offset + D.30490;
    il_offset = *D.30491;
    if (il_offset == -1) goto <D.30492>; else goto <D.30494>;
    <D.30494>:
    if (il_offset == prev_il_offset) goto <D.30492>; else goto <D.30493>;
    <D.30492>:
    // predicted unlikely by continue predictor.
    goto <D.25262>;
    <D.30493>:
    prev_il_offset = il_offset;
    il_offset.112 = (unsigned int) il_offset;
    loc = mono_debug_symfile_lookup_location (minfo, il_offset.112);
    if (loc == 0B) goto <D.30496>; else goto <D.30498>;
    <D.30498>:
    D.30499 = loc->source_file;
    if (D.30499 == 0B) goto <D.30496>; else goto <D.30497>;
    <D.30496>:
    // predicted unlikely by continue predictor.
    goto <D.25262>;
    <D.30497>:
    D.30500 = loc->row;
    prev_line.113 = (unsigned int) prev_line;
    if (D.30500 == prev_line.113) goto <D.30502>; else goto <D.30503>;
    <D.30502>:
    mono_debug_symfile_free_location (loc);
    // predicted unlikely by continue predictor.
    goto <D.25262>;
    <D.30503>:
    D.30500 = loc->row;
    prev_line = (int) D.30500;
    if (first != 0) goto <D.30504>; else goto <D.30505>;
    <D.30504>:
    *res = loc;
    goto <D.30506>;
    <D.30505>:
    D.30468 = (long unsigned int) i;
    D.30469 = D.30468 * 8;
    D.30507 = res + D.30469;
    *D.30507 = loc;
    <D.30506>:
    first = 0;
  }
  <D.25262>:
  i = i + 1;
  <D.25264>:
  if (i < code_size) goto <D.25263>; else goto <D.25265>;
  <D.25265>:
  D.30450 = res;
  return D.30450;
}


compare_lne (struct MonoDebugLineNumberEntry * a, struct MonoDebugLineNumberEntry * b)
{
  unsigned int D.30509;
  unsigned int D.30510;
  gint D.30513;
  unsigned int D.30514;
  unsigned int D.30515;
  unsigned int D.30516;
  unsigned int D.30517;

  D.30509 = a->native_offset;
  D.30510 = b->native_offset;
  if (D.30509 == D.30510) goto <D.30511>; else goto <D.30512>;
  <D.30511>:
  D.30514 = a->il_offset;
  D.30515 = b->il_offset;
  D.30516 = D.30514 - D.30515;
  D.30513 = (gint) D.30516;
  return D.30513;
  <D.30512>:
  D.30509 = a->native_offset;
  D.30510 = b->native_offset;
  D.30517 = D.30509 - D.30510;
  D.30513 = (gint) D.30517;
  return D.30513;
}


get_file_index (struct MonoAotCompile * acfg, const char * source_file)
{
  struct GHashTable * D.30519;
  struct GHashTable * D.30522;
  void * D.30523;
  long int D.30524;
  unsigned int D.30527;
  unsigned int D.30528;
  gchar * D.30529;
  long int D.30530;
  void * D.30531;
  struct FILE * D.30532;
  char * D.30533;
  int D.30534;
  int findex;

  D.30519 = acfg->dwarf_ln_filenames;
  if (D.30519 == 0B) goto <D.30520>; else goto <D.30521>;
  <D.30520>:
  D.30522 = monoeg_g_hash_table_new (monoeg_g_str_hash, monoeg_g_str_equal);
  acfg->dwarf_ln_filenames = D.30522;
  <D.30521>:
  D.30519 = acfg->dwarf_ln_filenames;
  D.30523 = monoeg_g_hash_table_lookup (D.30519, source_file);
  D.30524 = (long int) D.30523;
  findex = (int) D.30524;
  if (findex == 0) goto <D.30525>; else goto <D.30526>;
  <D.30525>:
  D.30519 = acfg->dwarf_ln_filenames;
  D.30527 = monoeg_g_hash_table_size (D.30519);
  D.30528 = D.30527 + 1;
  findex = (int) D.30528;
  D.30519 = acfg->dwarf_ln_filenames;
  D.30529 = monoeg_strdup (source_file);
  D.30530 = (long int) findex;
  D.30531 = (void *) D.30530;
  monoeg_g_hash_table_insert_replace (D.30519, D.30529, D.30531, 0);
  emit_unset_mode (acfg);
  D.30532 = acfg->fp;
  D.30533 = mono_dwarf_escape_path (source_file);
  fprintf (D.30532, ".file %d \"%s\"\n", findex, D.30533);
  <D.30526>:
  D.30534 = findex;
  return D.30534;
}


arch_emit_got_offset (struct MonoAotCompile * acfg, guint8 * code, int * code_size)
{
  int D.30536;
  _Bool D.30537;
  long int D.30538;
  long int D.30539;
  struct FILE * D.30542;
  unsigned int D.30543;
  unsigned int D.30544;

  D.30536 = acfg->use_bin_writer;
  D.30537 = D.30536 != 0;
  D.30538 = (long int) D.30537;
  D.30539 = __builtin_expect (D.30538, 0);
  if (D.30539 != 0) goto <D.30540>; else goto <D.30541>;
  <D.30540>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "aot-compiler.c", 773, "!acfg->use_bin_writer");
  <D.30541>:
  emit_unset_mode (acfg);
  D.30542 = acfg->fp;
  D.30543 = acfg->label_generator;
  fprintf (D.30542, ".L%d:\n", D.30543);
  D.30542 = acfg->fp;
  D.30543 = acfg->label_generator;
  fprintf (D.30542, "lis 0, (.Lgot_addr + 4 - .L%d)@h\n", D.30543);
  D.30542 = acfg->fp;
  D.30543 = acfg->label_generator;
  fprintf (D.30542, "ori 0, 0, (.Lgot_addr + 4 - .L%d)@l\n", D.30543);
  D.30542 = acfg->fp;
  fprintf (D.30542, "add 30, 30, 0\n");
  D.30542 = acfg->fp;
  fprintf (D.30542, "%s 30, 0(30)\n", "ld");
  D.30543 = acfg->label_generator;
  D.30544 = D.30543 + 1;
  acfg->label_generator = D.30544;
  *code_size = 16;
}


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


is_direct_callable (struct MonoAotCompile * acfg, struct MonoMethod * method, struct MonoJumpInfo * patch_info)
{
  <unnamed type> D.30547;
  struct MonoMethod * D.30549;
  struct MonoClass * D.30550;
  struct MonoImage * D.30551;
  struct MonoImage * D.30552;
  struct GHashTable * D.30554;
  long unsigned int D.30561;
  long unsigned int D.30562;
  struct MonoMethod * D.30564;
  struct MonoClass * D.30565;
  unsigned int D.30566;
  unsigned int D.30567;
  short unsigned int D.30570;
  int D.30571;
  int D.30572;
  long unsigned int D.30576;
  long unsigned int D.30577;
  int D.30580;
  int D.30582;
  long unsigned int D.30583;
  long unsigned int D.30584;
  gboolean D.30589;
  short unsigned int D.30593;
  int D.30594;
  int D.30595;
  int D.30597;
  int D.30602;

  D.30547 = patch_info->type;
  if (D.30547 == 3) goto <D.30548>; else goto <D.30545>;
  <D.30548>:
  D.30549 = patch_info->data.method;
  D.30550 = D.30549->klass;
  D.30551 = D.30550->image;
  D.30552 = acfg->image;
  if (D.30551 == D.30552) goto <D.30553>; else goto <D.30545>;
  <D.30553>:
  {
    struct MonoCompile * callee_cfg;

    D.30554 = acfg->method_to_cfg;
    D.30549 = patch_info->data.method;
    callee_cfg = monoeg_g_hash_table_lookup (D.30554, D.30549);
    if (callee_cfg != 0B) goto <D.30555>; else goto <D.30556>;
    <D.30555>:
    {
      gboolean direct_callable;

      direct_callable = 1;
      if (direct_callable != 0) goto <D.30559>; else goto <D.30560>;
      <D.30559>:
      D.30561 = BIT_FIELD_REF <*callee_cfg, 64, 5632>;
      D.30562 = D.30561 & 1;
      if (D.30562 != 0) goto <D.30557>; else goto <D.30563>;
      <D.30563>:
      D.30564 = callee_cfg->method;
      D.30565 = D.30564->klass;
      D.30566 = D.30565->flags;
      D.30567 = D.30566 & 1048576;
      if (D.30567 == 0) goto <D.30557>; else goto <D.30558>;
      <D.30557>:
      direct_callable = 0;
      <D.30558>:
      <D.30560>:
      D.30564 = callee_cfg->method;
      D.30570 = D.30564->iflags;
      D.30571 = (int) D.30570;
      D.30572 = D.30571 & 32;
      if (D.30572 != 0) goto <D.30573>; else goto <D.30574>;
      <D.30573>:
      if (method == 0B) goto <D.30568>; else goto <D.30575>;
      <D.30575>:
      D.30576 = BIT_FIELD_REF <*method, 64, 256>;
      D.30577 = D.30576 & 124;
      if (D.30577 != 64) goto <D.30568>; else goto <D.30569>;
      <D.30568>:
      direct_callable = 0;
      <D.30569>:
      <D.30574>:
      D.30580 = acfg->aot_opts.soft_debug;
      if (D.30580 != 0) goto <D.30578>; else goto <D.30581>;
      <D.30581>:
      D.30582 = acfg->aot_opts.no_direct_calls;
      if (D.30582 != 0) goto <D.30578>; else goto <D.30579>;
      <D.30578>:
      direct_callable = 0;
      <D.30579>:
      D.30564 = callee_cfg->method;
      D.30583 = BIT_FIELD_REF <*D.30564, 64, 256>;
      D.30584 = D.30583 & 124;
      if (D.30584 == 112) goto <D.30585>; else goto <D.30586>;
      <D.30585>:
      direct_callable = 0;
      <D.30586>:
      if (direct_callable != 0) goto <D.30587>; else goto <D.30588>;
      <D.30587>:
      D.30589 = 1;
      return D.30589;
      <D.30588>:
    }
    <D.30556>:
  }
  goto <D.30546>;
  <D.30545>:
  D.30547 = patch_info->type;
  if (D.30547 == 31) goto <D.30592>; else goto <D.30590>;
  <D.30592>:
  D.30549 = patch_info->data.method;
  D.30593 = D.30549->flags;
  D.30594 = (int) D.30593;
  D.30595 = D.30594 & 8192;
  if (D.30595 != 0) goto <D.30596>; else goto <D.30590>;
  <D.30596>:
  D.30597 = acfg->aot_opts.direct_pinvoke;
  if (D.30597 != 0) goto <D.30598>; else goto <D.30599>;
  <D.30598>:
  D.30589 = 1;
  return D.30589;
  <D.30599>:
  goto <D.30591>;
  <D.30590>:
  D.30547 = patch_info->type;
  if (D.30547 == 31) goto <D.30600>; else goto <D.30601>;
  <D.30600>:
  D.30602 = acfg->aot_opts.direct_icalls;
  if (D.30602 != 0) goto <D.30603>; else goto <D.30604>;
  <D.30603>:
  D.30589 = 1;
  return D.30589;
  <D.30604>:
  D.30589 = 0;
  return D.30589;
  <D.30601>:
  <D.30591>:
  <D.30546>:
  D.30589 = 0;
  return D.30589;
}


get_pinvoke_import (struct MonoAotCompile * acfg, struct MonoMethod * method)
{
  struct MonoClass * D.30606;
  struct GHashTable * D.30607;
  const char * D.30610;
  short unsigned int D.30613;
  int D.30615;
  <unnamed-unsigned:24> D.30616;
  int D.30617;
  int D.30618;
  unsigned int D.30621;
  <unnamed-unsigned:24> D.30623;
  unsigned int D.30624;
  unsigned int D.30625;
  const char * D.30626;
  struct MonoImage * image;
  struct MonoMethodPInvoke * piinfo;
  struct MonoTableInfo * tables;
  struct MonoTableInfo * im;
  struct MonoTableInfo * mr;
  guint32 im_cols[4];
  char * import;

  try
    {
      D.30606 = method->klass;
      image = D.30606->image;
      piinfo = method;
      tables = &image->tables;
      im = tables + 448;
      mr = tables + 416;
      D.30607 = acfg->method_to_pinvoke_import;
      import = monoeg_g_hash_table_lookup (D.30607, method);
      if (import != 0B) goto <D.30608>; else goto <D.30609>;
      <D.30608>:
      D.30610 = import;
      return D.30610;
      <D.30609>:
      D.30613 = piinfo->implmap_idx;
      if (D.30613 == 0) goto <D.30611>; else goto <D.30614>;
      <D.30614>:
      D.30613 = piinfo->implmap_idx;
      D.30615 = (int) D.30613;
      D.30616 = im->rows;
      D.30617 = (int) D.30616;
      if (D.30615 > D.30617) goto <D.30611>; else goto <D.30612>;
      <D.30611>:
      D.30610 = 0B;
      return D.30610;
      <D.30612>:
      D.30613 = piinfo->implmap_idx;
      D.30615 = (int) D.30613;
      D.30618 = D.30615 + -1;
      mono_metadata_decode_row (im, D.30618, &im_cols, 4);
      D.30621 = im_cols[3];
      if (D.30621 == 0) goto <D.30619>; else goto <D.30622>;
      <D.30622>:
      D.30621 = im_cols[3];
      D.30623 = mr->rows;
      D.30624 = (unsigned int) D.30623;
      if (D.30621 > D.30624) goto <D.30619>; else goto <D.30620>;
      <D.30619>:
      D.30610 = 0B;
      return D.30610;
      <D.30620>:
      D.30625 = im_cols[2];
      D.30626 = mono_metadata_string_heap (image, D.30625);
      import = monoeg_g_strdup_printf ("%s", D.30626);
      D.30607 = acfg->method_to_pinvoke_import;
      monoeg_g_hash_table_insert_replace (D.30607, method, import, 0);
      D.30610 = import;
      return D.30610;
    }
  finally
    {
      im_cols = {CLOBBER};
    }
}


arch_emit_direct_call (struct MonoAotCompile * acfg, const char * target, gboolean external, struct MonoJumpInfo * ji, int * call_size)
{
  int D.30629;
  struct FILE * D.30632;

  D.30629 = acfg->use_bin_writer;
  if (D.30629 != 0) goto <D.30630>; else goto <D.30631>;
  <D.30630>:
  monoeg_assertion_message ("* Assertion: should not be reached at %s:%d\n", "aot-compiler.c", 718);
  <D.30631>:
  emit_unset_mode (acfg);
  D.30632 = acfg->fp;
  fprintf (D.30632, "bl %s\n", target);
  *call_size = 4;
}


arch_emit_got_access (struct MonoAotCompile * acfg, guint8 * code, int got_slot, int * code_size)
{
  unsigned int D.30633;
  int D.30634;
  long unsigned int D.30635;
  unsigned int D.30636;
  unsigned int D.30637;
  unsigned int D.30638;
  short unsigned int D.30639;
  int D.30640;
  int D.30641;
  unsigned int D.30642;
  unsigned int D.30643;
  unsigned int D.30644;
  unsigned int D.30645;
  unsigned int D.30646;
  unsigned int D.30647;
  unsigned int D.30648;
  unsigned int D.30649;
  short unsigned int D.30650;
  short unsigned int D.30651;
  int D.30652;
  int D.30653;
  unsigned int D.30654;
  unsigned int D.30655;
  unsigned int D.30656;
  unsigned int D.30657;
  unsigned int D.30658;
  unsigned int D.30659;
  unsigned int D.30660;
  unsigned int D.30661;
  long int code.114;
  long int buf.115;
  long int D.30664;
  _Bool D.30665;
  long int D.30666;
  long int D.30667;
  int D.30670;

  D.30633 = mono_arch_get_patch_offset (code);
  D.30634 = (int) D.30633;
  emit_bytes (acfg, code, D.30634);
  {
    guint8 buf[32];
    guint8 * code;

    try
      {
        code = &buf;
        D.30635 = (long unsigned int) got_slot;
        D.30636 = (unsigned int) D.30635;
        D.30637 = D.30636 * 8;
        D.30638 = D.30637 >> 16;
        D.30639 = (short unsigned int) D.30638;
        D.30640 = (int) D.30639;
        D.30641 = D.30640 | 1006632960;
        D.30642 = (unsigned int) D.30641;
        D.30643 = D.30642 << 24;
        D.30635 = (long unsigned int) got_slot;
        D.30636 = (unsigned int) D.30635;
        D.30637 = D.30636 * 8;
        D.30638 = D.30637 >> 16;
        D.30639 = (short unsigned int) D.30638;
        D.30644 = (unsigned int) D.30639;
        D.30645 = D.30644 & 65280;
        D.30646 = D.30645 << 8;
        D.30647 = D.30643 | D.30646;
        D.30635 = (long unsigned int) got_slot;
        D.30636 = (unsigned int) D.30635;
        D.30637 = D.30636 * 8;
        D.30638 = D.30637 >> 16;
        D.30639 = (short unsigned int) D.30638;
        D.30640 = (int) D.30639;
        D.30641 = D.30640 | 1006632960;
        D.30642 = (unsigned int) D.30641;
        D.30648 = D.30642 >> 24;
        D.30649 = D.30647 | D.30648;
        MEM[(guint32 *)code] = D.30649;
        code = code + 4;
        D.30635 = (long unsigned int) got_slot;
        D.30650 = (short unsigned int) D.30635;
        D.30651 = D.30650 * 8;
        D.30652 = (int) D.30651;
        D.30653 = D.30652 | 1610612736;
        D.30654 = (unsigned int) D.30653;
        D.30655 = D.30654 << 24;
        D.30635 = (long unsigned int) got_slot;
        D.30650 = (short unsigned int) D.30635;
        D.30651 = D.30650 * 8;
        D.30656 = (unsigned int) D.30651;
        D.30657 = D.30656 & 65280;
        D.30658 = D.30657 << 8;
        D.30659 = D.30655 | D.30658;
        D.30635 = (long unsigned int) got_slot;
        D.30650 = (short unsigned int) D.30635;
        D.30651 = D.30650 * 8;
        D.30652 = (int) D.30651;
        D.30653 = D.30652 | 1610612736;
        D.30654 = (unsigned int) D.30653;
        D.30660 = D.30654 >> 24;
        D.30661 = D.30659 | D.30660;
        MEM[(guint32 *)code] = D.30661;
        code = code + 4;
        code.114 = (long int) code;
        buf.115 = (long int) &buf;
        D.30664 = code.114 - buf.115;
        D.30665 = D.30664 != 8;
        D.30666 = (long int) D.30665;
        D.30667 = __builtin_expect (D.30666, 0);
        if (D.30667 != 0) goto <D.30668>; else goto <D.30669>;
        <D.30668>:
        monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "aot-compiler.c", 834, "code - buf == 8");
        <D.30669>:
        code.114 = (long int) code;
        buf.115 = (long int) &buf;
        D.30664 = code.114 - buf.115;
        D.30670 = (int) D.30664;
        emit_bytes (acfg, &buf, D.30670);
        code.114 = (long int) code;
        buf.115 = (long int) &buf;
        D.30664 = code.114 - buf.115;
        D.30670 = (int) D.30664;
        *code_size = D.30670;
      }
    finally
      {
        buf = {CLOBBER};
      }
  }
}


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

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


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

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


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

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


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

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


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

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


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

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


emit_info (struct MonoAotCompile * acfg)
{
  unsigned int D.30677;
  long unsigned int D.30678;
  long unsigned int D.30679;
  struct GPtrArray * D.30680;
  void * * D.30681;
  long unsigned int D.30682;
  long unsigned int D.30683;
  void * * D.30684;
  void * D.30685;
  long int D.30686;
  struct MonoCompile * * D.30687;
  long unsigned int D.30688;
  long unsigned int D.30689;
  struct MonoCompile * * D.30690;
  struct MonoCompile * D.30691;
  long unsigned int D.30694;
  gint32 * D.30695;
  unsigned int D.30696;
  int D.30697;
  unsigned int oindex.116;
  unsigned int D.30700;
  int D.30701;
  unsigned int D.30702;
  int D.30703;
  unsigned int D.30704;
  unsigned int D.30705;
  int D.30706;
  int oindex;
  int i;
  char symbol[256];
  gint32 * offsets;

  try
    {
      D.30677 = acfg->nmethods;
      D.30678 = (long unsigned int) D.30677;
      D.30679 = D.30678 * 4;
      offsets = monoeg_malloc0 (D.30679);
      oindex = 0;
      goto <D.26085>;
      <D.26084>:
      D.30680 = acfg->method_order;
      D.30681 = D.30680->pdata;
      D.30682 = (long unsigned int) oindex;
      D.30683 = D.30682 * 8;
      D.30684 = D.30681 + D.30683;
      D.30685 = *D.30684;
      D.30686 = (long int) D.30685;
      i = (int) D.30686;
      D.30687 = acfg->cfgs;
      D.30688 = (long unsigned int) i;
      D.30689 = D.30688 * 8;
      D.30690 = D.30687 + D.30689;
      D.30691 = *D.30690;
      if (D.30691 != 0B) goto <D.30692>; else goto <D.30693>;
      <D.30692>:
      D.30687 = acfg->cfgs;
      D.30688 = (long unsigned int) i;
      D.30689 = D.30688 * 8;
      D.30690 = D.30687 + D.30689;
      D.30691 = *D.30690;
      emit_method_info (acfg, D.30691);
      D.30688 = (long unsigned int) i;
      D.30694 = D.30688 * 4;
      D.30695 = offsets + D.30694;
      D.30687 = acfg->cfgs;
      D.30688 = (long unsigned int) i;
      D.30689 = D.30688 * 8;
      D.30690 = D.30687 + D.30689;
      D.30691 = *D.30690;
      D.30696 = D.30691->method_info_offset;
      D.30697 = (int) D.30696;
      *D.30695 = D.30697;
      goto <D.30698>;
      <D.30693>:
      D.30688 = (long unsigned int) i;
      D.30694 = D.30688 * 4;
      D.30695 = offsets + D.30694;
      *D.30695 = 0;
      <D.30698>:
      oindex = oindex + 1;
      <D.26085>:
      oindex.116 = (unsigned int) oindex;
      D.30680 = acfg->method_order;
      D.30700 = D.30680->len;
      if (oindex.116 < D.30700) goto <D.26084>; else goto <D.26086>;
      <D.26086>:
      sprintf (&symbol, "method_info_offsets");
      emit_section_change (acfg, ".rodata", 1);
      emit_alignment (acfg, 8);
      emit_label (acfg, &symbol);
      D.30677 = acfg->nmethods;
      D.30701 = (int) D.30677;
      D.30702 = emit_offset_table (acfg, D.30701, 10, offsets);
      D.30703 = acfg->stats.offsets_size;
      D.30704 = (unsigned int) D.30703;
      D.30705 = D.30704 + D.30702;
      D.30706 = (int) D.30705;
      acfg->stats.offsets_size = D.30706;
      monoeg_g_free (offsets);
    }
  finally
    {
      symbol = {CLOBBER};
    }
}


emit_method_info (struct MonoAotCompile * acfg, struct MonoCompile * cfg)
{
  struct MonoCompile * * D.30707;
  long unsigned int D.30708;
  long unsigned int D.30709;
  struct MonoCompile * * D.30710;
  struct MonoCompile * D.30711;
  int iftmp.117;
  unsigned int D.30713;
  unsigned int D.30716;
  unsigned int D.30717;
  long unsigned int D.30719;
  struct MonoClass * D.30720;
  struct MonoMethod * D.30721;
  guint8 * p.118;
  unsigned int D.30726;
  unsigned int D.30727;
  struct GList * D.30730;
  unsigned int D.30731;
  int D.30732;
  void * D.30733;
  long int D.30734;
  int D.30735;
  _Bool D.30737;
  long int D.30738;
  long int D.30739;
  void * * D.30742;
  long unsigned int D.30743;
  long unsigned int D.30744;
  void * * D.30745;
  <unnamed type> D.30748;
  struct MonoImage * D.30752;
  struct MonoImage * D.30753;
  int D.30758;
  unsigned int pindex.119;
  long unsigned int D.30764;
  long unsigned int D.30765;
  _Bool D.30766;
  long int D.30767;
  long int D.30768;
  int first_got_offset.120;
  int D.30772;
  unsigned int D.30773;
  long int p.121;
  long int buf.122;
  long int D.30776;
  unsigned int D.30777;
  unsigned int D.30778;
  int D.30779;
  long int D.30780;
  _Bool D.30781;
  long int D.30782;
  long int D.30783;
  unsigned int D.30786;
  unsigned int D.30787;
  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.25486>;
      <D.25485>:
      monoeg_g_ptr_array_add (patches, patch_info);
      patch_info = patch_info->next;
      <D.25486>:
      if (patch_info != 0B) goto <D.25485>; else goto <D.25487>;
      <D.25487>:
      monoeg_g_ptr_array_sort (patches, compare_patches);
      D.30707 = acfg->cfgs;
      D.30708 = (long unsigned int) method_index;
      D.30709 = D.30708 * 8;
      D.30710 = D.30707 + D.30709;
      D.30711 = *D.30710;
      first_got_offset = D.30711->got_offset;
      D.30713 = patches->len;
      if (D.30713 > 999) goto <D.30714>; else goto <D.30715>;
      <D.30714>:
      D.30713 = patches->len;
      D.30716 = D.30713 + 640;
      D.30717 = D.30716 * 64;
      iftmp.117 = (int) D.30717;
      goto <D.30718>;
      <D.30715>:
      iftmp.117 = 40960;
      <D.30718>:
      buf_size = iftmp.117;
      D.30719 = (long unsigned int) buf_size;
      buf = monoeg_malloc (D.30719);
      p = buf;
      D.30720 = method->klass;
      D.30721 = mono_class_get_cctor (D.30720);
      if (D.30721 != 0B) goto <D.30722>; else goto <D.30723>;
      <D.30722>:
      D.30720 = method->klass;
      p.118 = p;
      encode_klass_ref (acfg, D.30720, p.118, &p);
      goto <D.30725>;
      <D.30723>:
      p.118 = p;
      encode_value (0, p.118, &p);
      <D.30725>:
      D.30726 = cfg->opt;
      D.30727 = D.30726 & 512;
      if (D.30727 != 0) goto <D.30728>; else goto <D.30729>;
      <D.30728>:
      D.30730 = cfg->ldstr_list;
      D.30731 = monoeg_g_list_length (D.30730);
      D.30732 = (int) D.30731;
      p.118 = p;
      encode_value (D.30732, p.118, &p);
      l = cfg->ldstr_list;
      goto <D.25489>;
      <D.25488>:
      D.30733 = l->data;
      D.30734 = (long int) D.30733;
      D.30735 = (int) D.30734;
      p.118 = p;
      encode_value (D.30735, p.118, &p);
      l = l->next;
      <D.25489>:
      if (l != 0B) goto <D.25488>; else goto <D.25490>;
      <D.25490>:
      goto <D.30736>;
      <D.30729>:
      D.30730 = cfg->ldstr_list;
      D.30737 = D.30730 != 0B;
      D.30738 = (long int) D.30737;
      D.30739 = __builtin_expect (D.30738, 0);
      if (D.30739 != 0) goto <D.30740>; else goto <D.30741>;
      <D.30740>:
      monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "aot-compiler.c", 5129, "!cfg->ldstr_list");
      <D.30741>:
      <D.30736>:
      n_patches = 0;
      pindex = 0;
      goto <D.25493>;
      <D.25492>:
      D.30742 = patches->pdata;
      D.30743 = (long unsigned int) pindex;
      D.30744 = D.30743 * 8;
      D.30745 = D.30742 + D.30744;
      patch_info = *D.30745;
      D.30748 = patch_info->type;
      if (D.30748 == 27) goto <D.30746>; else goto <D.30749>;
      <D.30749>:
      D.30748 = patch_info->type;
      if (D.30748 == 51) goto <D.30746>; else goto <D.30747>;
      <D.30746>:
      patch_info->type = 51;
      // predicted unlikely by continue predictor.
      goto <D.25491>;
      <D.30747>:
      D.30748 = patch_info->type;
      if (D.30748 == 12) goto <D.30750>; else goto <D.30751>;
      <D.30750>:
      D.30752 = patch_info->data.image;
      D.30753 = acfg->image;
      if (D.30752 == D.30753) goto <D.30754>; else goto <D.30755>;
      <D.30754>:
      patch_info->type = 51;
      // predicted unlikely by continue predictor.
      goto <D.25491>;
      <D.30755>:
      <D.30751>:
      D.30748 = patch_info->type;
      if (D.30748 == 42) goto <D.30756>; else goto <D.30757>;
      <D.30756>:
      patch_info->type = 51;
      // predicted unlikely by continue predictor.
      goto <D.25491>;
      <D.30757>:
      D.30758 = is_plt_patch (patch_info);
      if (D.30758 != 0) goto <D.30759>; else goto <D.30760>;
      <D.30759>:
      patch_info->type = 51;
      // predicted unlikely by continue predictor.
      goto <D.25491>;
      <D.30760>:
      n_patches = n_patches + 1;
      <D.25491>:
      pindex = pindex + 1;
      <D.25493>:
      pindex.119 = (unsigned int) pindex;
      D.30713 = patches->len;
      if (pindex.119 < D.30713) goto <D.25492>; else goto <D.25494>;
      <D.25494>:
      if (n_patches != 0) goto <D.30762>; else goto <D.30763>;
      <D.30762>:
      D.30764 = BIT_FIELD_REF <*cfg, 64, 5632>;
      D.30765 = D.30764 & 1;
      D.30766 = D.30765 == 0;
      D.30767 = (long int) D.30766;
      D.30768 = __builtin_expect (D.30767, 0);
      if (D.30768 != 0) goto <D.30769>; else goto <D.30770>;
      <D.30769>:
      monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "aot-compiler.c", 5164, "cfg->has_got_slots");
      <D.30770>:
      <D.30763>:
      first_got_offset.120 = (int) first_got_offset;
      p.118 = p;
      encode_patch_list (acfg, patches, n_patches, first_got_offset.120, p.118, &p);
      D.30772 = acfg->stats.info_size;
      D.30773 = (unsigned int) D.30772;
      p.118 = p;
      p.121 = (long int) p.118;
      buf.122 = (long int) buf;
      D.30776 = p.121 - buf.122;
      D.30777 = (unsigned int) D.30776;
      D.30778 = D.30773 + D.30777;
      D.30779 = (int) D.30778;
      acfg->stats.info_size = D.30779;
      p.118 = p;
      p.121 = (long int) p.118;
      buf.122 = (long int) buf;
      D.30776 = p.121 - buf.122;
      D.30780 = (long int) buf_size;
      D.30781 = D.30776 >= D.30780;
      D.30782 = (long int) D.30781;
      D.30783 = __builtin_expect (D.30782, 0);
      if (D.30783 != 0) goto <D.30784>; else goto <D.30785>;
      <D.30784>:
      monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "aot-compiler.c", 5170, "p - buf < buf_size");
      <D.30785>:
      p.118 = p;
      p.121 = (long int) p.118;
      buf.122 = (long int) buf;
      D.30776 = p.121 - buf.122;
      D.30786 = (unsigned int) D.30776;
      D.30787 = add_to_blob (acfg, buf, D.30786);
      cfg->method_info_offset = D.30787;
      monoeg_g_free (buf);
    }
  finally
    {
      p = {CLOBBER};
    }
}


encode_klass_ref (struct MonoAotCompile * acfg, struct MonoClass * klass, guint8 * buf, guint8 * * endbuf)
{
  struct MonoGenericClass * D.30788;
  unsigned int D.30791;
  _Bool D.30792;
  long int D.30793;
  long int D.30794;
  unsigned char D.30802;
  struct GHashTable * D.30806;
  void * D.30807;
  long int D.30808;
  guint8 * p.123;
  long int p.124;
  long int buf2.125;
  long int D.30814;
  _Bool D.30815;
  long int D.30816;
  long int D.30817;
  unsigned int D.30820;
  unsigned int D.30821;
  long unsigned int D.30822;
  void * D.30823;
  int offset.126;
  gboolean shared;

  shared = 0;
  D.30788 = klass->generic_class;
  if (D.30788 != 0B) goto <D.30789>; else goto <D.30790>;
  <D.30789>:
  {
    guint32 token;

    D.30791 = klass->type_token;
    D.30792 = D.30791 == 0;
    D.30793 = (long int) D.30792;
    D.30794 = __builtin_expect (D.30793, 0);
    if (D.30794 != 0) goto <D.30795>; else goto <D.30796>;
    <D.30795>:
    monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "aot-compiler.c", 2354, "klass->type_token");
    <D.30796>:
    token = find_typespec_for_class (acfg, klass);
    if (token == 0) goto <D.30797>; else goto <D.30798>;
    <D.30797>:
    shared = 1;
    <D.30798>:
  }
  goto <D.30799>;
  <D.30790>:
  D.30802 = klass->byval_arg.type;
  if (D.30802 == 19) goto <D.30800>; else goto <D.30803>;
  <D.30803>:
  D.30802 = klass->byval_arg.type;
  if (D.30802 == 30) goto <D.30800>; else goto <D.30801>;
  <D.30800>:
  shared = 1;
  <D.30801>:
  <D.30799>:
  if (shared != 0) goto <D.30804>; else goto <D.30805>;
  <D.30804>:
  {
    guint offset;
    guint8 * buf2;
    guint8 * p;

    try
      {
        D.30806 = acfg->klass_blob_hash;
        D.30807 = monoeg_g_hash_table_lookup (D.30806, klass);
        D.30808 = (long int) D.30807;
        offset = (guint) D.30808;
        if (offset == 0) goto <D.30809>; else goto <D.30810>;
        <D.30809>:
        buf2 = monoeg_malloc (1024);
        p = buf2;
        p.123 = p;
        encode_klass_ref_inner (acfg, klass, p.123, &p);
        p.123 = p;
        p.124 = (long int) p.123;
        buf2.125 = (long int) buf2;
        D.30814 = p.124 - buf2.125;
        D.30815 = D.30814 > 1023;
        D.30816 = (long int) D.30815;
        D.30817 = __builtin_expect (D.30816, 0);
        if (D.30817 != 0) goto <D.30818>; else goto <D.30819>;
        <D.30818>:
        monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "aot-compiler.c", 2373, "p - buf2 < 1024");
        <D.30819>:
        p.123 = p;
        p.124 = (long int) p.123;
        buf2.125 = (long int) buf2;
        D.30814 = p.124 - buf2.125;
        D.30820 = (unsigned int) D.30814;
        offset = add_to_blob (acfg, buf2, D.30820);
        monoeg_g_free (buf2);
        D.30806 = acfg->klass_blob_hash;
        D.30821 = offset + 1;
        D.30822 = (long unsigned int) D.30821;
        D.30823 = (void *) D.30822;
        monoeg_g_hash_table_insert_replace (D.30806, klass, D.30823, 0);
        goto <D.30824>;
        <D.30810>:
        offset = offset + 4294967295;
        <D.30824>:
        p = buf;
        p.123 = p;
        encode_value (7, p.123, &p);
        offset.126 = (int) offset;
        p.123 = p;
        encode_value (offset.126, p.123, &p);
        p.123 = p;
        *endbuf = p.123;
        return;
      }
    finally
      {
        p = {CLOBBER};
      }
  }
  <D.30805>:
  encode_klass_ref_inner (acfg, klass, buf, endbuf);
}


find_typespec_for_class (struct MonoAotCompile * acfg, struct MonoClass * klass)
{
  struct MonoImage * D.30828;
  <unnamed-unsigned:24> D.30829;
  struct MonoClass * * D.30830;
  struct MonoMemPool * D.30833;
  long unsigned int D.30834;
  unsigned int D.30835;
  unsigned int D.30836;
  void * D.30837;
  long unsigned int D.30838;
  long unsigned int D.30839;
  struct MonoClass * * D.30840;
  int D.30841;
  int D.30842;
  unsigned int D.30843;
  struct MonoClass * D.30844;
  struct MonoClass * D.30845;
  guint32 D.30849;
  int i;
  int len;

  D.30828 = acfg->image;
  D.30829 = D.30828->tables[27].rows;
  len = (int) D.30829;
  D.30830 = acfg->typespec_classes;
  if (D.30830 == 0B) goto <D.30831>; else goto <D.30832>;
  <D.30831>:
  D.30833 = acfg->mempool;
  D.30834 = (long unsigned int) len;
  D.30835 = (unsigned int) D.30834;
  D.30836 = D.30835 * 8;
  D.30837 = mono_mempool_alloc0 (D.30833, D.30836);
  acfg->typespec_classes = D.30837;
  i = 0;
  goto <D.24299>;
  <D.24298>:
  D.30830 = acfg->typespec_classes;
  D.30838 = (long unsigned int) i;
  D.30839 = D.30838 * 8;
  D.30840 = D.30830 + D.30839;
  D.30828 = acfg->image;
  D.30841 = i + 1;
  D.30842 = D.30841 | 452984832;
  D.30843 = (unsigned int) D.30842;
  D.30844 = mono_class_get_full (D.30828, D.30843, 0B);
  *D.30840 = D.30844;
  i = i + 1;
  <D.24299>:
  if (i < len) goto <D.24298>; else goto <D.24300>;
  <D.24300>:
  <D.30832>:
  i = 0;
  goto <D.24303>;
  <D.24302>:
  D.30830 = acfg->typespec_classes;
  D.30838 = (long unsigned int) i;
  D.30839 = D.30838 * 8;
  D.30840 = D.30830 + D.30839;
  D.30845 = *D.30840;
  if (D.30845 == klass) goto <D.24301>; else goto <D.30846>;
  <D.30846>:
  i = i + 1;
  <D.24303>:
  if (i < len) goto <D.24302>; else goto <D.24301>;
  <D.24301>:
  if (i < len) goto <D.30847>; else goto <D.30848>;
  <D.30847>:
  D.30841 = i + 1;
  D.30842 = D.30841 | 452984832;
  D.30849 = (guint32) D.30842;
  return D.30849;
  <D.30848>:
  D.30849 = 0;
  return D.30849;
}


encode_klass_ref_inner (struct MonoAotCompile * acfg, struct MonoClass * klass, guint8 * buf, guint8 * * endbuf)
{
  struct MonoGenericClass * D.30851;
  unsigned int D.30854;
  _Bool D.30855;
  long int D.30856;
  long int D.30857;
  guint8 * p.127;
  int token.128;
  long int p.129;
  long int p1.130;
  long int D.30867;
  unsigned int D.30868;
  int count.131;
  unsigned int count.132;
  unsigned int D.30871;
  int count.133;
  struct MonoImage * D.30876;
  unsigned int D.30877;
  unsigned int D.30878;
  _Bool D.30879;
  long int D.30880;
  long int D.30881;
  unsigned int D.30886;
  int D.30887;
  unsigned int D.30889;
  int D.30890;
  unsigned char D.30895;
  struct MonoGenericParam * D.30897;
  int D.30898;
  short unsigned int D.30899;
  int D.30900;
  _Bool D.30901;
  int D.30902;
  <unnamed-signed:1> D.30905;
  int D.30906;
  short unsigned int D.30907;
  _Bool D.30908;
  long int D.30909;
  long int D.30910;
  long unsigned int D.30913;
  long unsigned int D.30914;
  struct MonoMethod * D.30917;
  struct MonoClass * D.30919;
  int D.30921;
  struct MonoType * D.30924;
  unsigned char D.30926;
  _Bool D.30927;
  long int D.30928;
  long int D.30929;
  int D.30932;
  struct MonoClass * D.30933;
  guint8 * p;

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

        D.30854 = klass->type_token;
        D.30855 = D.30854 == 0;
        D.30856 = (long int) D.30855;
        D.30857 = __builtin_expect (D.30856, 0);
        if (D.30857 != 0) goto <D.30858>; else goto <D.30859>;
        <D.30858>:
        monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "aot-compiler.c", 2275, "klass->type_token");
        <D.30859>:
        token = find_typespec_for_class (acfg, klass);
        if (token != 0) goto <D.30860>; else goto <D.30861>;
        <D.30860>:
        p.127 = p;
        encode_value (3, p.127, &p);
        token.128 = (int) token;
        p.127 = p;
        encode_value (token.128, p.127, &p);
        goto <D.30864>;
        <D.30861>:
        {
          struct MonoClass * gclass;
          struct MonoGenericInst * inst;
          static int count = 0;
          guint8 * p1;

          D.30851 = klass->generic_class;
          gclass = D.30851->container_class;
          D.30851 = klass->generic_class;
          inst = D.30851->context.class_inst;
          p1 = p;
          p.127 = p;
          encode_value (4, p.127, &p);
          p.127 = p;
          encode_klass_ref (acfg, gclass, p.127, &p);
          p.127 = p;
          encode_ginst (acfg, inst, p.127, &p);
          p.127 = p;
          p.129 = (long int) p.127;
          p1.130 = (long int) p1;
          D.30867 = p.129 - p1.130;
          D.30868 = (unsigned int) D.30867;
          count.131 = count;
          count.132 = (unsigned int) count.131;
          D.30871 = D.30868 + count.132;
          count.133 = (int) D.30871;
          count = count.133;
        }
        <D.30864>:
      }
      goto <D.30873>;
      <D.30853>:
      D.30854 = klass->type_token;
      if (D.30854 != 0) goto <D.30874>; else goto <D.30875>;
      <D.30874>:
      {
        int iindex;

        D.30876 = klass->image;
        D.30877 = get_image_index (acfg, D.30876);
        iindex = (int) D.30877;
        D.30854 = klass->type_token;
        D.30878 = D.30854 & 4278190080;
        D.30879 = D.30878 != 33554432;
        D.30880 = (long int) D.30879;
        D.30881 = __builtin_expect (D.30880, 0);
        if (D.30881 != 0) goto <D.30882>; else goto <D.30883>;
        <D.30882>:
        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.30883>:
        if (iindex == 0) goto <D.30884>; else goto <D.30885>;
        <D.30884>:
        p.127 = p;
        encode_value (1, p.127, &p);
        D.30854 = klass->type_token;
        D.30886 = D.30854 + 4261412864;
        D.30887 = (int) D.30886;
        p.127 = p;
        encode_value (D.30887, p.127, &p);
        goto <D.30888>;
        <D.30885>:
        p.127 = p;
        encode_value (2, p.127, &p);
        D.30854 = klass->type_token;
        D.30886 = D.30854 + 4261412864;
        D.30887 = (int) D.30886;
        p.127 = p;
        encode_value (D.30887, p.127, &p);
        D.30876 = klass->image;
        D.30889 = get_image_index (acfg, D.30876);
        D.30890 = (int) D.30889;
        p.127 = p;
        encode_value (D.30890, p.127, &p);
        <D.30888>:
      }
      goto <D.30891>;
      <D.30875>:
      D.30895 = klass->byval_arg.type;
      if (D.30895 == 19) goto <D.30892>; else goto <D.30896>;
      <D.30896>:
      D.30895 = klass->byval_arg.type;
      if (D.30895 == 30) goto <D.30892>; else goto <D.30893>;
      <D.30892>:
      {
        struct MonoGenericContainer * container;
        struct MonoGenericParam * par;

        D.30897 = klass->byval_arg.data.generic_param;
        container = D.30897->owner;
        par = klass->byval_arg.data.generic_param;
        p.127 = p;
        encode_value (5, p.127, &p);
        D.30895 = klass->byval_arg.type;
        D.30898 = (int) D.30895;
        p.127 = p;
        encode_value (D.30898, p.127, &p);
        D.30897 = klass->byval_arg.data.generic_param;
        D.30899 = D.30897->num;
        D.30900 = (int) D.30899;
        p.127 = p;
        encode_value (D.30900, p.127, &p);
        D.30901 = container != 0B;
        D.30902 = (int) D.30901;
        p.127 = p;
        encode_value (D.30902, p.127, &p);
        if (container != 0B) goto <D.30903>; else goto <D.30904>;
        <D.30903>:
        D.30905 = container->is_method;
        D.30906 = (int) D.30905;
        p.127 = p;
        encode_value (D.30906, p.127, &p);
        D.30907 = par->serial;
        D.30908 = D.30907 != 0;
        D.30909 = (long int) D.30908;
        D.30910 = __builtin_expect (D.30909, 0);
        if (D.30910 != 0) goto <D.30911>; else goto <D.30912>;
        <D.30911>:
        monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "aot-compiler.c", 2317, "par->serial == 0");
        <D.30912>:
        D.30913 = BIT_FIELD_REF <*container, 64, 256>;
        D.30914 = D.30913 & 2147483648;
        if (D.30914 != 0) goto <D.30915>; else goto <D.30916>;
        <D.30915>:
        D.30917 = container->owner.method;
        p.127 = p;
        encode_method_ref (acfg, D.30917, p.127, &p);
        goto <D.30918>;
        <D.30916>:
        D.30919 = container->owner.klass;
        p.127 = p;
        encode_klass_ref (acfg, D.30919, p.127, &p);
        <D.30918>:
        goto <D.30920>;
        <D.30904>:
        D.30907 = par->serial;
        D.30921 = (int) D.30907;
        p.127 = p;
        encode_value (D.30921, p.127, &p);
        <D.30920>:
      }
      goto <D.30894>;
      <D.30893>:
      D.30895 = klass->byval_arg.type;
      if (D.30895 == 15) goto <D.30922>; else goto <D.30923>;
      <D.30922>:
      p.127 = p;
      encode_value (8, p.127, &p);
      D.30924 = &klass->byval_arg;
      p.127 = p;
      encode_type (acfg, D.30924, p.127, &p);
      goto <D.30925>;
      <D.30923>:
      D.30926 = klass->rank;
      D.30927 = D.30926 == 0;
      D.30928 = (long int) D.30927;
      D.30929 = __builtin_expect (D.30928, 0);
      if (D.30929 != 0) goto <D.30930>; else goto <D.30931>;
      <D.30930>:
      monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "aot-compiler.c", 2330, "klass->rank > 0");
      <D.30931>:
      p.127 = p;
      encode_value (6, p.127, &p);
      D.30926 = klass->rank;
      D.30932 = (int) D.30926;
      p.127 = p;
      encode_value (D.30932, p.127, &p);
      D.30933 = klass->element_class;
      p.127 = p;
      encode_klass_ref (acfg, D.30933, p.127, &p);
      <D.30925>:
      <D.30894>:
      <D.30891>:
      <D.30873>:
      p.127 = p;
      *endbuf = p.127;
    }
  finally
    {
      p = {CLOBBER};
    }
}


encode_ginst (struct MonoAotCompile * acfg, struct MonoGenericInst * inst, guint8 * buf, guint8 * * endbuf)
{
  <unnamed-unsigned:22> D.30934;
  int D.30935;
  guint8 * p.134;
  struct MonoType * D.30937;
  struct MonoClass * D.30938;
  int D.30939;
  guint8 * p;
  int i;

  try
    {
      p = buf;
      D.30934 = inst->type_argc;
      D.30935 = (int) D.30934;
      p.134 = p;
      encode_value (D.30935, p.134, &p);
      i = 0;
      goto <D.24367>;
      <D.24366>:
      D.30937 = inst->type_argv[i];
      D.30938 = mono_class_from_mono_type (D.30937);
      p.134 = p;
      encode_klass_ref (acfg, D.30938, p.134, &p);
      i = i + 1;
      <D.24367>:
      D.30934 = inst->type_argc;
      D.30939 = (int) D.30934;
      if (D.30939 > i) goto <D.24366>; else goto <D.24368>;
      <D.24368>:
      p.134 = p;
      *endbuf = p.134;
    }
  finally
    {
      p = {CLOBBER};
    }
}


get_image_index (struct MonoAotCompile * cfg, struct MonoImage * image)
{
  struct GHashTable * D.30940;
  void * D.30941;
  long int D.30942;
  guint32 D.30945;
  unsigned int D.30946;
  long unsigned int D.30947;
  void * D.30948;
  struct GPtrArray * D.30949;
  guint32 index;

  D.30940 = cfg->image_hash;
  D.30941 = monoeg_g_hash_table_lookup (D.30940, image);
  D.30942 = (long int) D.30941;
  index = (guint32) D.30942;
  if (index != 0) goto <D.30943>; else goto <D.30944>;
  <D.30943>:
  D.30945 = index + 4294967295;
  return D.30945;
  <D.30944>:
  D.30940 = cfg->image_hash;
  index = monoeg_g_hash_table_size (D.30940);
  D.30940 = cfg->image_hash;
  D.30946 = index + 1;
  D.30947 = (long unsigned int) D.30946;
  D.30948 = (void *) D.30947;
  monoeg_g_hash_table_insert_replace (D.30940, image, D.30948, 0);
  D.30949 = cfg->image_table;
  monoeg_g_ptr_array_add (D.30949, image);
  D.30945 = index;
  return D.30945;
}


encode_method_ref (struct MonoAotCompile * acfg, struct MonoMethod * method, guint8 * buf, guint8 * * endbuf)
{
  struct MonoClass * D.30951;
  struct MonoImage * D.30952;
  long unsigned int D.30956;
  long unsigned int D.30957;
  short unsigned int D.30959;
  int D.30960;
  int D.30961;
  short unsigned int D.30962;
  int D.30963;
  int D.30964;
  guint8 * p.135;
  long unsigned int D.30966;
  <unnamed-unsigned:5> D.30969;
  int D.30970;
  int D.30971;
  _Bool D.30972;
  long int D.30973;
  long int D.30974;
  int D.30977;
  _Bool D.30978;
  long int D.30979;
  long int D.30980;
  _Bool D.30983;
  long int D.30984;
  long int D.30985;
  <unnamed type> D.30988;
  int D.30989;
  int D.30992;
  _Bool D.30993;
  long int D.30994;
  long int D.30995;
  <unnamed type> D.30998;
  int D.30999;
  unsigned int D.31000;
  struct MonoMethod * D.31006;
  struct MonoMethod * D.31010;
  _Bool D.31011;
  long int D.31012;
  long int D.31013;
  <unnamed type> D.31016;
  int D.31017;
  const char * D.31020;
  long unsigned int D.31021;
  sizetype D.31022;
  guint8 * p.136;
  struct MonoMethod * D.31027;
  _Bool D.31029;
  long int D.31030;
  long int D.31031;
  _Bool D.31034;
  long int D.31035;
  long int D.31036;
  _Bool D.31039;
  long int D.31040;
  long int D.31041;
  _Bool D.31044;
  long int D.31045;
  long int D.31046;
  <unnamed type> D.31049;
  int D.31050;
  unsigned int D.31053;
  int D.31054;
  unsigned int D.31055;
  int D.31056;
  struct MonoMethod * D.31060;
  _Bool D.31062;
  long int D.31063;
  long int D.31064;
  <unnamed type> D.31067;
  int D.31068;
  _Bool D.31069;
  long int D.31070;
  long int D.31071;
  <unnamed type> D.31074;
  int D.31075;
  unsigned int D.31076;
  struct MonoMethod * D.31079;
  struct MonoMethodSignature * D.31083;
  long unsigned int D.31084;
  gint32 iftmp.137;
  <unnamed type> D.31093;
  _Bool D.31095;
  long int D.31096;
  long int D.31097;
  struct MonoMethod * D.31100;
  struct MonoClass * D.31101;
  struct MonoMethodSignature * D.31103;
  long unsigned int D.31104;
  long unsigned int D.31105;
  struct GHashTable * D.31108;
  struct MonoImage * D.31111;
  _Bool D.31112;
  long int D.31113;
  long int D.31114;
  int image_index.138;
  int token.139;
  _Bool D.31120;
  long int D.31121;
  long int D.31122;
  unsigned int D.31127;
  _Bool D.31128;
  long int D.31129;
  long int D.31130;
  unsigned int D.31133;
  _Bool D.31134;
  long int D.31135;
  long int D.31136;
  unsigned char D.31147;
  _Bool D.31148;
  long int D.31149;
  long int D.31150;
  int D.24492;
  int iftmp.140;
  int D.24491;
  const char[6] * D.31158;
  unsigned char D.31159;
  int D.31160;
  unsigned char D.31161;
  int D.31162;
  const unsigned char * D.31167;
  unsigned char D.31168;
  int D.31169;
  const unsigned char * D.31170;
  unsigned char D.31171;
  int D.31172;
  const unsigned char * D.31177;
  unsigned char D.31178;
  int D.31179;
  const unsigned char * D.31180;
  unsigned char D.31181;
  int D.31182;
  const unsigned char * D.31187;
  unsigned char D.31188;
  int D.31189;
  const unsigned char * D.31190;
  unsigned char D.31191;
  int D.31192;
  struct MonoMethodSignature * D.31195;
  short unsigned int D.31196;
  short unsigned int D.31197;
  int D.24501;
  int iftmp.141;
  int D.24500;
  unsigned char D.31204;
  int D.31205;
  const unsigned char * D.31210;
  unsigned char D.31211;
  int D.31212;
  const unsigned char * D.31217;
  unsigned char D.31218;
  int D.31219;
  const unsigned char * D.31224;
  unsigned char D.31225;
  int D.31226;
  struct MonoMethodSignature * D.31229;
  short unsigned int D.31230;
  int D.31231;
  int D.31232;
  int D.31233;
  int D.24510;
  int iftmp.142;
  int D.24509;
  const char[4] * D.31238;
  unsigned char D.31239;
  int D.31240;
  unsigned char D.31241;
  int D.31242;
  const unsigned char * D.31247;
  unsigned char D.31248;
  int D.31249;
  const unsigned char * D.31250;
  unsigned char D.31251;
  int D.31252;
  const unsigned char * D.31257;
  unsigned char D.31258;
  int D.31259;
  const unsigned char * D.31260;
  unsigned char D.31261;
  int D.31262;
  const unsigned char * D.31267;
  unsigned char D.31268;
  int D.31269;
  const unsigned char * D.31270;
  unsigned char D.31271;
  int D.31272;
  int D.24519;
  int iftmp.143;
  int D.24518;
  const char[8] * D.31280;
  unsigned char D.31281;
  int D.31282;
  unsigned char D.31283;
  int D.31284;
  const unsigned char * D.31289;
  unsigned char D.31290;
  int D.31291;
  const unsigned char * D.31292;
  unsigned char D.31293;
  int D.31294;
  const unsigned char * D.31299;
  unsigned char D.31300;
  int D.31301;
  const unsigned char * D.31302;
  unsigned char D.31303;
  int D.31304;
  const unsigned char * D.31309;
  unsigned char D.31310;
  int D.31311;
  const unsigned char * D.31312;
  unsigned char D.31313;
  int D.31314;
  int D.24528;
  int iftmp.144;
  int D.24527;
  const char[4] * D.31322;
  unsigned char D.31323;
  int D.31324;
  unsigned char D.31325;
  int D.31326;
  const unsigned char * D.31331;
  unsigned char D.31332;
  int D.31333;
  const unsigned char * D.31334;
  unsigned char D.31335;
  int D.31336;
  const unsigned char * D.31341;
  unsigned char D.31342;
  int D.31343;
  const unsigned char * D.31344;
  unsigned char D.31345;
  int D.31346;
  const unsigned char * D.31351;
  unsigned char D.31352;
  int D.31353;
  const unsigned char * D.31354;
  unsigned char D.31355;
  int D.31356;
  int D.31366;
  unsigned int D.31368;
  unsigned int D.31369;
  unsigned int D.31370;
  int D.31371;
  guint32 image_index;
  guint32 token;
  struct MonoJumpInfoToken * ji;
  guint8 * p;

  try
    {
      D.30951 = method->klass;
      D.30952 = D.30951->image;
      image_index = get_image_index (acfg, D.30952);
      token = method->token;
      p = buf;
      D.30956 = BIT_FIELD_REF <*method, 64, 256>;
      D.30957 = D.30956 & 2048;
      if (D.30957 != 0) goto <D.30958>; else goto <D.30953>;
      <D.30958>:
      D.30959 = method->flags;
      D.30960 = (int) D.30959;
      D.30961 = D.30960 & 64;
      if (D.30961 != 0) goto <D.30954>; else goto <D.30953>;
      <D.30953>:
      D.30962 = method->iflags;
      D.30963 = (int) D.30962;
      D.30964 = D.30963 & 32;
      if (D.30964 != 0) goto <D.30954>; else goto <D.30955>;
      <D.30954>:
      p.135 = p;
      encode_value (-83886080, p.135, &p);
      <D.30955>:
      D.30956 = BIT_FIELD_REF <*method, 64, 256>;
      D.30966 = D.30956 & 124;
      if (D.30966 != 0) goto <D.30967>; else goto <D.30968>;
      <D.30967>:
      p.135 = p;
      encode_value (-67108864, p.135, &p);
      D.30969 = method->wrapper_type;
      D.30970 = (int) D.30969;
      p.135 = p;
      encode_value (D.30970, p.135, &p);
      D.30969 = method->wrapper_type;
      D.30971 = (int) D.30969;
      switch (D.30971) <default: <D.24481>, case 1: <D.24474>, case 2: <D.24475>, case 3: <D.24476>, case 4: <D.24472>, case 5: <D.24479>, case 6: <D.24464>, case 7: <D.24468>, case 8: <D.24444>, case 9: <D.24445>, case 10: <D.24446>, case 12: <D.24450>, case 13: <D.24452>, case 14: <D.24455>, case 15: <D.24456>, case 16: <D.24466>, case 18: <D.24453>, case 19: <D.24470>, case 20: <D.24449>, case 21: <D.24460>, case 23: <D.24451>, case 24: <D.24459>, case 25: <D.24462>, case 28: <D.24457>>
      <D.24444>:
      <D.24445>:
      <D.24446>:
      {
        struct MonoMethod * m;

        m = mono_marshal_method_from_wrapper (method);
        D.30972 = m == 0B;
        D.30973 = (long int) D.30972;
        D.30974 = __builtin_expect (D.30973, 0);
        if (D.30974 != 0) goto <D.30975>; else goto <D.30976>;
        <D.30975>:
        monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "aot-compiler.c", 2595, "m");
        <D.30976>:
        p.135 = p;
        encode_method_ref (acfg, m, p.135, &p);
        goto <D.24448>;
      }
      <D.24449>:
      <D.24450>:
      <D.24451>:
      <D.24452>:
      <D.24453>:
      {
        struct MonoClass * proxy_class;

        proxy_class = mono_marshal_get_wrapper_info (method);
        p.135 = p;
        encode_klass_ref (acfg, proxy_class, p.135, &p);
        goto <D.24448>;
      }
      <D.24455>:
      <D.24456>:
      goto <D.24448>;
      <D.24457>:
      {
        struct AllocatorWrapperInfo * info;

        info = mono_marshal_get_wrapper_info (method);
        D.30977 = info->alloc_type;
        D.30978 = D.30977 == -1;
        D.30979 = (long int) D.30978;
        D.30980 = __builtin_expect (D.30979, 0);
        if (D.30980 != 0) goto <D.30981>; else goto <D.30982>;
        <D.30981>:
        monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "aot-compiler.c", 2615, "info->alloc_type != -1");
        <D.30982>:
        D.30977 = info->alloc_type;
        p.135 = p;
        encode_value (D.30977, p.135, &p);
        goto <D.24448>;
      }
      <D.24459>:
      goto <D.24448>;
      <D.24460>:
      {
        struct WrapperInfo * info;

        info = mono_marshal_get_wrapper_info (method);
        D.30983 = info == 0B;
        D.30984 = (long int) D.30983;
        D.30985 = __builtin_expect (D.30984, 0);
        if (D.30985 != 0) goto <D.30986>; else goto <D.30987>;
        <D.30986>:
        monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "aot-compiler.c", 2624, "info");
        <D.30987>:
        D.30988 = info->subtype;
        D.30989 = (int) D.30988;
        p.135 = p;
        encode_value (D.30989, p.135, &p);
        D.30988 = info->subtype;
        if (D.30988 == 3) goto <D.30990>; else goto <D.30991>;
        <D.30990>:
        D.30992 = info->d.virtual_stelemref.kind;
        p.135 = p;
        encode_value (D.30992, p.135, &p);
        <D.30991>:
        goto <D.24448>;
      }
      <D.24462>:
      {
        struct WrapperInfo * info;

        info = mono_marshal_get_wrapper_info (method);
        D.30993 = info == 0B;
        D.30994 = (long int) D.30993;
        D.30995 = __builtin_expect (D.30994, 0);
        if (D.30995 != 0) goto <D.30996>; else goto <D.30997>;
        <D.30996>:
        monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "aot-compiler.c", 2633, "info");
        <D.30997>:
        D.30998 = info->subtype;
        D.30999 = (int) D.30998;
        p.135 = p;
        encode_value (D.30999, p.135, &p);
        D.30998 = info->subtype;
        D.31000 = D.30998 + 4294967289;
        if (D.31000 <= 1) goto <D.31001>; else goto <D.31002>;
        <D.31001>:
        D.30951 = method->klass;
        p.135 = p;
        encode_klass_ref (acfg, D.30951, p.135, &p);
        goto <D.31003>;
        <D.31002>:
        D.30998 = info->subtype;
        if (D.30998 == 17) goto <D.31004>; else goto <D.31005>;
        <D.31004>:
        D.31006 = info->d.synchronized_inner.method;
        p.135 = p;
        encode_method_ref (acfg, D.31006, p.135, &p);
        goto <D.31007>;
        <D.31005>:
        D.30998 = info->subtype;
        if (D.30998 == 20) goto <D.31008>; else goto <D.31009>;
        <D.31008>:
        D.31010 = info->d.array_accessor.method;
        p.135 = p;
        encode_method_ref (acfg, D.31010, p.135, &p);
        <D.31009>:
        <D.31007>:
        <D.31003>:
        goto <D.24448>;
      }
      <D.24464>:
      {
        struct WrapperInfo * info;

        info = mono_marshal_get_wrapper_info (method);
        D.31011 = info == 0B;
        D.31012 = (long int) D.31011;
        D.31013 = __builtin_expect (D.31012, 0);
        if (D.31013 != 0) goto <D.31014>; else goto <D.31015>;
        <D.31014>:
        monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "aot-compiler.c", 2647, "info");
        <D.31015>:
        D.31016 = info->subtype;
        D.31017 = (int) D.31016;
        p.135 = p;
        encode_value (D.31017, p.135, &p);
        D.31016 = info->subtype;
        if (D.31016 == 15) goto <D.31018>; else goto <D.31019>;
        <D.31018>:
        p.135 = p;
        D.31020 = method->name;
        strcpy (p.135, D.31020);
        p.135 = p;
        D.31020 = method->name;
        D.31021 = strlen (D.31020);
        D.31022 = D.31021 + 1;
        p.136 = p.135 + D.31022;
        p = p.136;
        goto <D.31024>;
        <D.31019>:
        D.31016 = info->subtype;
        if (D.31016 == 16) goto <D.31025>; else goto <D.31026>;
        <D.31025>:
        D.31027 = info->d.managed_to_native.method;
        p.135 = p;
        encode_method_ref (acfg, D.31027, p.135, &p);
        goto <D.31028>;
        <D.31026>:
        D.31016 = info->subtype;
        D.31029 = D.31016 != 0;
        D.31030 = (long int) D.31029;
        D.31031 = __builtin_expect (D.31030, 0);
        if (D.31031 != 0) goto <D.31032>; else goto <D.31033>;
        <D.31032>:
        monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "aot-compiler.c", 2655, "info->subtype == WRAPPER_SUBTYPE_NONE");
        <D.31033>:
        D.31027 = info->d.managed_to_native.method;
        p.135 = p;
        encode_method_ref (acfg, D.31027, p.135, &p);
        <D.31028>:
        <D.31024>:
        goto <D.24448>;
      }
      <D.24466>:
      {
        struct MonoMethod * m;

        m = mono_marshal_method_from_wrapper (method);
        D.31034 = m == 0B;
        D.31035 = (long int) D.31034;
        D.31036 = __builtin_expect (D.31035, 0);
        if (D.31036 != 0) goto <D.31037>; else goto <D.31038>;
        <D.31037>:
        monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "aot-compiler.c", 2664, "m");
        <D.31038>:
        D.31039 = m == method;
        D.31040 = (long int) D.31039;
        D.31041 = __builtin_expect (D.31040, 0);
        if (D.31041 != 0) goto <D.31042>; else goto <D.31043>;
        <D.31042>:
        monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "aot-compiler.c", 2665, "m != method");
        <D.31043>:
        p.135 = p;
        encode_method_ref (acfg, m, p.135, &p);
        goto <D.24448>;
      }
      <D.24468>:
      {
        struct WrapperInfo * info;

        info = mono_marshal_get_wrapper_info (method);
        D.31044 = info == 0B;
        D.31045 = (long int) D.31044;
        D.31046 = __builtin_expect (D.31045, 0);
        if (D.31046 != 0) goto <D.31047>; else goto <D.31048>;
        <D.31047>:
        monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "aot-compiler.c", 2672, "info");
        <D.31048>:
        D.31049 = info->subtype;
        D.31050 = (int) D.31049;
        p.135 = p;
        encode_value (D.31050, p.135, &p);
        D.31049 = info->subtype;
        if (D.31049 == 1) goto <D.31051>; else goto <D.31052>;
        <D.31051>:
        D.31053 = info->d.element_addr.rank;
        D.31054 = (int) D.31053;
        p.135 = p;
        encode_value (D.31054, p.135, &p);
        D.31055 = info->d.element_addr.elem_size;
        D.31056 = (int) D.31055;
        p.135 = p;
        encode_value (D.31056, p.135, &p);
        goto <D.31057>;
        <D.31052>:
        D.31049 = info->subtype;
        if (D.31049 == 2) goto <D.31058>; else goto <D.31059>;
        <D.31058>:
        D.31060 = info->d.string_ctor.method;
        p.135 = p;
        encode_method_ref (acfg, D.31060, p.135, &p);
        goto <D.31061>;
        <D.31059>:
        monoeg_assertion_message ("* Assertion: should not be reached at %s:%d\n", "aot-compiler.c", 2681);
        <D.31061>:
        <D.31057>:
        goto <D.24448>;
      }
      <D.24470>:
      {
        struct WrapperInfo * info;

        info = mono_marshal_get_wrapper_info (method);
        D.31062 = info == 0B;
        D.31063 = (long int) D.31062;
        D.31064 = __builtin_expect (D.31063, 0);
        if (D.31064 != 0) goto <D.31065>; else goto <D.31066>;
        <D.31065>:
        monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "aot-compiler.c", 2688, "info");
        <D.31066>:
        D.31067 = info->subtype;
        D.31068 = (int) D.31067;
        p.135 = p;
        encode_value (D.31068, p.135, &p);
        goto <D.24448>;
      }
      <D.24472>:
      {
        struct WrapperInfo * info;

        info = mono_marshal_get_wrapper_info (method);
        D.31069 = info == 0B;
        D.31070 = (long int) D.31069;
        D.31071 = __builtin_expect (D.31070, 0);
        if (D.31071 != 0) goto <D.31072>; else goto <D.31073>;
        <D.31072>:
        monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "aot-compiler.c", 2695, "info");
        <D.31073>:
        D.31074 = info->subtype;
        D.31075 = (int) D.31074;
        p.135 = p;
        encode_value (D.31075, p.135, &p);
        D.31074 = info->subtype;
        D.31076 = D.31074 + 4294967283;
        if (D.31076 <= 1) goto <D.31077>; else goto <D.31078>;
        <D.31077>:
        D.31079 = info->d.runtime_invoke.method;
        p.135 = p;
        encode_method_ref (acfg, D.31079, p.135, &p);
        goto <D.31080>;
        <D.31078>:
        D.31074 = info->subtype;
        if (D.31074 == 11) goto <D.31081>; else goto <D.31082>;
        <D.31081>:
        D.31083 = info->d.runtime_invoke.sig;
        p.135 = p;
        encode_signature (acfg, D.31083, p.135, &p);
        <D.31082>:
        <D.31080>:
        goto <D.24448>;
      }
      <D.24474>:
      <D.24475>:
      <D.24476>:
      D.30956 = BIT_FIELD_REF <*method, 64, 256>;
      D.31084 = D.30956 & 4096;
      if (D.31084 != 0) goto <D.31085>; else goto <D.31086>;
      <D.31085>:
      p.135 = p;
      encode_value (1, p.135, &p);
      D.30951 = method->klass;
      p.135 = p;
      encode_klass_ref (acfg, D.30951, p.135, &p);
      goto <D.31087>;
      <D.31086>:
      {
        struct MonoMethodSignature * sig;
        struct WrapperInfo * info;

        sig = mono_method_signature (method);
        info = mono_marshal_get_wrapper_info (method);
        p.135 = p;
        encode_value (0, p.135, &p);
        D.30956 = BIT_FIELD_REF <*method, 64, 256>;
        D.30966 = D.30956 & 124;
        if (D.30966 == 4) goto <D.31088>; else goto <D.31089>;
        <D.31088>:
        if (info != 0B) goto <D.31091>; else goto <D.31092>;
        <D.31091>:
        D.31093 = info->subtype;
        iftmp.137 = (gint32) D.31093;
        goto <D.31094>;
        <D.31092>:
        iftmp.137 = 0;
        <D.31094>:
        p.135 = p;
        encode_value (iftmp.137, p.135, &p);
        <D.31089>:
        p.135 = p;
        encode_signature (acfg, sig, p.135, &p);
      }
      <D.31087>:
      goto <D.24448>;
      <D.24479>:
      {
        struct WrapperInfo * info;

        info = mono_marshal_get_wrapper_info (method);
        D.31095 = info == 0B;
        D.31096 = (long int) D.31095;
        D.31097 = __builtin_expect (D.31096, 0);
        if (D.31097 != 0) goto <D.31098>; else goto <D.31099>;
        <D.31098>:
        monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "aot-compiler.c", 2724, "info");
        <D.31099>:
        D.31100 = info->d.native_to_managed.method;
        p.135 = p;
        encode_method_ref (acfg, D.31100, p.135, &p);
        D.31101 = info->d.native_to_managed.klass;
        p.135 = p;
        encode_klass_ref (acfg, D.31101, p.135, &p);
        goto <D.24448>;
      }
      <D.24481>:
      monoeg_assertion_message ("* Assertion: should not be reached at %s:%d\n", "aot-compiler.c", 2730);
      <D.24448>:
      goto <D.31102>;
      <D.30968>:
      D.31103 = mono_method_signature (method);
      D.31104 = BIT_FIELD_REF <*D.31103, 64, 64>;
      D.31105 = D.31104 & 144115188075855872;
      if (D.31105 != 0) goto <D.31106>; else goto <D.31107>;
      <D.31106>:
      D.31108 = acfg->token_info_hash;
      ji = monoeg_g_hash_table_lookup (D.31108, method);
      if (ji != 0B) goto <D.31109>; else goto <D.31110>;
      <D.31109>:
      D.31111 = ji->image;
      image_index = get_image_index (acfg, D.31111);
      D.31112 = image_index > 249;
      D.31113 = (long int) D.31112;
      D.31114 = __builtin_expect (D.31113, 0);
      if (D.31114 != 0) goto <D.31115>; else goto <D.31116>;
      <D.31115>:
      monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "aot-compiler.c", 2741, "image_index < MAX_IMAGE_INDEX");
      <D.31116>:
      token = ji->token;
      p.135 = p;
      encode_value (-33554432, p.135, &p);
      image_index.138 = (int) image_index;
      p.135 = p;
      encode_value (image_index.138, p.135, &p);
      token.139 = (int) token;
      p.135 = p;
      encode_value (token.139, p.135, &p);
      goto <D.31119>;
      <D.31110>:
      {
        struct MonoMethod * declaring;
        struct MonoGenericContext * context;

        context = mono_method_get_context (method);
        D.30956 = BIT_FIELD_REF <*method, 64, 256>;
        D.31084 = D.30956 & 4096;
        D.31120 = D.31084 == 0;
        D.31121 = (long int) D.31120;
        D.31122 = __builtin_expect (D.31121, 0);
        if (D.31122 != 0) goto <D.31123>; else goto <D.31124>;
        <D.31123>:
        monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "aot-compiler.c", 2751, "method->is_inflated");
        <D.31124>:
        declaring = MEM[(struct MonoMethodInflated *)method].declaring;
        p.135 = p;
        encode_value (-50331648, p.135, &p);
        D.30951 = method->klass;
        p.135 = p;
        encode_klass_ref (acfg, D.30951, p.135, &p);
        D.30951 = method->klass;
        D.30952 = D.30951->image;
        image_index = get_image_index (acfg, D.30952);
        D.31112 = image_index > 249;
        D.31113 = (long int) D.31112;
        D.31114 = __builtin_expect (D.31113, 0);
        if (D.31114 != 0) goto <D.31125>; else goto <D.31126>;
        <D.31125>:
        monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "aot-compiler.c", 2764, "image_index < MAX_IMAGE_INDEX");
        <D.31126>:
        D.31127 = declaring->token;
        D.31128 = D.31127 == 0;
        D.31129 = (long int) D.31128;
        D.31130 = __builtin_expect (D.31129, 0);
        if (D.31130 != 0) goto <D.31131>; else goto <D.31132>;
        <D.31131>:
        monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "aot-compiler.c", 2765, "declaring->token");
        <D.31132>:
        token = declaring->token;
        D.31133 = token >> 24;
        D.31134 = D.31133 != 6;
        D.31135 = (long int) D.31134;
        D.31136 = __builtin_expect (D.31135, 0);
        if (D.31136 != 0) goto <D.31137>; else goto <D.31138>;
        <D.31137>:
        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.31138>:
        image_index.138 = (int) image_index;
        p.135 = p;
        encode_value (image_index.138, p.135, &p);
        token.139 = (int) token;
        p.135 = p;
        encode_value (token.139, p.135, &p);
        p.135 = p;
        encode_generic_context (acfg, context, p.135, &p);
      }
      <D.31119>:
      goto <D.31139>;
      <D.31107>:
      if (token == 0) goto <D.31140>; else goto <D.31141>;
      <D.31140>:
      D.31108 = acfg->token_info_hash;
      ji = monoeg_g_hash_table_lookup (D.31108, method);
      if (ji != 0B) goto <D.31142>; else goto <D.31143>;
      <D.31142>:
      D.31111 = ji->image;
      image_index = get_image_index (acfg, D.31111);
      D.31112 = image_index > 249;
      D.31113 = (long int) D.31112;
      D.31114 = __builtin_expect (D.31113, 0);
      if (D.31114 != 0) goto <D.31144>; else goto <D.31145>;
      <D.31144>:
      monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "aot-compiler.c", 2778, "image_index < MAX_IMAGE_INDEX");
      <D.31145>:
      token = ji->token;
      p.135 = p;
      encode_value (-33554432, p.135, &p);
      image_index.138 = (int) image_index;
      p.135 = p;
      encode_value (image_index.138, p.135, &p);
      token.139 = (int) token;
      p.135 = p;
      encode_value (token.139, p.135, &p);
      goto <D.31146>;
      <D.31143>:
      D.30951 = method->klass;
      D.31147 = D.30951->rank;
      D.31148 = D.31147 == 0;
      D.31149 = (long int) D.31148;
      D.31150 = __builtin_expect (D.31149, 0);
      if (D.31150 != 0) goto <D.31151>; else goto <D.31152>;
      <D.31151>:
      monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "aot-compiler.c", 2786, "method->klass->rank");
      <D.31152>:
      p.135 = p;
      encode_value (-100663296, p.135, &p);
      D.30951 = method->klass;
      p.135 = p;
      encode_klass_ref (acfg, D.30951, p.135, &p);
      {
        size_t __s1_len;
        size_t __s2_len;

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

          __s2 = method->name;
          D.31158 = ".ctor";
          D.31159 = MEM[(const unsigned char *)D.31158];
          D.31160 = (int) D.31159;
          D.31161 = *__s2;
          D.31162 = (int) D.31161;
          __result = D.31160 - D.31162;
          {
            if (__s2_len != 0) goto <D.31163>; else goto <D.31164>;
            <D.31163>:
            if (__result == 0) goto <D.31165>; else goto <D.31166>;
            <D.31165>:
            D.31167 = &MEM[(void *)".ctor" + 1B];
            D.31168 = *D.31167;
            D.31169 = (int) D.31168;
            D.31170 = __s2 + 1;
            D.31171 = *D.31170;
            D.31172 = (int) D.31171;
            __result = D.31169 - D.31172;
            if (__s2_len > 1) goto <D.31173>; else goto <D.31174>;
            <D.31173>:
            if (__result == 0) goto <D.31175>; else goto <D.31176>;
            <D.31175>:
            D.31177 = &MEM[(void *)".ctor" + 2B];
            D.31178 = *D.31177;
            D.31179 = (int) D.31178;
            D.31180 = __s2 + 2;
            D.31181 = *D.31180;
            D.31182 = (int) D.31181;
            __result = D.31179 - D.31182;
            if (__s2_len > 2) goto <D.31183>; else goto <D.31184>;
            <D.31183>:
            if (__result == 0) goto <D.31185>; else goto <D.31186>;
            <D.31185>:
            D.31187 = &MEM[(void *)".ctor" + 3B];
            D.31188 = *D.31187;
            D.31189 = (int) D.31188;
            D.31190 = __s2 + 3;
            D.31191 = *D.31190;
            D.31192 = (int) D.31191;
            __result = D.31189 - D.31192;
            <D.31186>:
            <D.31184>:
            <D.31176>:
            <D.31174>:
            <D.31166>:
            <D.31164>:
          }
          D.24491 = __result;
        }
        iftmp.140 = -D.24491;
        goto <D.31193>;
        <D.31157>:
        D.31020 = method->name;
        iftmp.140 = __builtin_strcmp (D.31020, ".ctor");
        <D.31193>:
        D.24492 = iftmp.140;
      }
      if (D.24492 == 0) goto <D.31194>; else goto <D.31153>;
      <D.31194>:
      D.31195 = mono_method_signature (method);
      D.31196 = D.31195->param_count;
      D.30951 = method->klass;
      D.31147 = D.30951->rank;
      D.31197 = (short unsigned int) D.31147;
      if (D.31196 == D.31197) goto <D.31198>; else goto <D.31153>;
      <D.31198>:
      p.135 = p;
      encode_value (0, p.135, &p);
      goto <D.31154>;
      <D.31153>:
      {
        size_t __s1_len;
        size_t __s2_len;

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

          __s2 = method->name;
          D.31158 = ".ctor";
          D.31159 = MEM[(const unsigned char *)D.31158];
          D.31160 = (int) D.31159;
          D.31204 = *__s2;
          D.31205 = (int) D.31204;
          __result = D.31160 - D.31205;
          {
            if (__s2_len != 0) goto <D.31206>; else goto <D.31207>;
            <D.31206>:
            if (__result == 0) goto <D.31208>; else goto <D.31209>;
            <D.31208>:
            D.31167 = &MEM[(void *)".ctor" + 1B];
            D.31168 = *D.31167;
            D.31169 = (int) D.31168;
            D.31210 = __s2 + 1;
            D.31211 = *D.31210;
            D.31212 = (int) D.31211;
            __result = D.31169 - D.31212;
            if (__s2_len > 1) goto <D.31213>; else goto <D.31214>;
            <D.31213>:
            if (__result == 0) goto <D.31215>; else goto <D.31216>;
            <D.31215>:
            D.31177 = &MEM[(void *)".ctor" + 2B];
            D.31178 = *D.31177;
            D.31179 = (int) D.31178;
            D.31217 = __s2 + 2;
            D.31218 = *D.31217;
            D.31219 = (int) D.31218;
            __result = D.31179 - D.31219;
            if (__s2_len > 2) goto <D.31220>; else goto <D.31221>;
            <D.31220>:
            if (__result == 0) goto <D.31222>; else goto <D.31223>;
            <D.31222>:
            D.31187 = &MEM[(void *)".ctor" + 3B];
            D.31188 = *D.31187;
            D.31189 = (int) D.31188;
            D.31224 = __s2 + 3;
            D.31225 = *D.31224;
            D.31226 = (int) D.31225;
            __result = D.31189 - D.31226;
            <D.31223>:
            <D.31221>:
            <D.31216>:
            <D.31214>:
            <D.31209>:
            <D.31207>:
          }
          D.24500 = __result;
        }
        iftmp.141 = -D.24500;
        goto <D.31227>;
        <D.31203>:
        D.31020 = method->name;
        iftmp.141 = __builtin_strcmp (D.31020, ".ctor");
        <D.31227>:
        D.24501 = iftmp.141;
      }
      if (D.24501 == 0) goto <D.31228>; else goto <D.31199>;
      <D.31228>:
      D.31229 = mono_method_signature (method);
      D.31230 = D.31229->param_count;
      D.31231 = (int) D.31230;
      D.30951 = method->klass;
      D.31147 = D.30951->rank;
      D.31232 = (int) D.31147;
      D.31233 = D.31232 * 2;
      if (D.31231 == D.31233) goto <D.31234>; else goto <D.31199>;
      <D.31234>:
      p.135 = p;
      encode_value (1, p.135, &p);
      goto <D.31200>;
      <D.31199>:
      {
        size_t __s1_len;
        size_t __s2_len;

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

          __s2 = method->name;
          D.31238 = "Get";
          D.31239 = MEM[(const unsigned char *)D.31238];
          D.31240 = (int) D.31239;
          D.31241 = *__s2;
          D.31242 = (int) D.31241;
          __result = D.31240 - D.31242;
          {
            if (__s2_len != 0) goto <D.31243>; else goto <D.31244>;
            <D.31243>:
            if (__result == 0) goto <D.31245>; else goto <D.31246>;
            <D.31245>:
            D.31247 = &MEM[(void *)"Get" + 1B];
            D.31248 = *D.31247;
            D.31249 = (int) D.31248;
            D.31250 = __s2 + 1;
            D.31251 = *D.31250;
            D.31252 = (int) D.31251;
            __result = D.31249 - D.31252;
            if (__s2_len > 1) goto <D.31253>; else goto <D.31254>;
            <D.31253>:
            if (__result == 0) goto <D.31255>; else goto <D.31256>;
            <D.31255>:
            D.31257 = &MEM[(void *)"Get" + 2B];
            D.31258 = *D.31257;
            D.31259 = (int) D.31258;
            D.31260 = __s2 + 2;
            D.31261 = *D.31260;
            D.31262 = (int) D.31261;
            __result = D.31259 - D.31262;
            if (__s2_len > 2) goto <D.31263>; else goto <D.31264>;
            <D.31263>:
            if (__result == 0) goto <D.31265>; else goto <D.31266>;
            <D.31265>:
            D.31267 = &MEM[(void *)"Get" + 3B];
            D.31268 = *D.31267;
            D.31269 = (int) D.31268;
            D.31270 = __s2 + 3;
            D.31271 = *D.31270;
            D.31272 = (int) D.31271;
            __result = D.31269 - D.31272;
            <D.31266>:
            <D.31264>:
            <D.31256>:
            <D.31254>:
            <D.31246>:
            <D.31244>:
          }
          D.24509 = __result;
        }
        iftmp.142 = -D.24509;
        goto <D.31273>;
        <D.31237>:
        D.31020 = method->name;
        iftmp.142 = __builtin_strcmp (D.31020, "Get");
        <D.31273>:
        D.24510 = iftmp.142;
      }
      if (D.24510 == 0) goto <D.31274>; else goto <D.31275>;
      <D.31274>:
      p.135 = p;
      encode_value (2, p.135, &p);
      goto <D.31276>;
      <D.31275>:
      {
        size_t __s1_len;
        size_t __s2_len;

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

          __s2 = method->name;
          D.31280 = "Address";
          D.31281 = MEM[(const unsigned char *)D.31280];
          D.31282 = (int) D.31281;
          D.31283 = *__s2;
          D.31284 = (int) D.31283;
          __result = D.31282 - D.31284;
          {
            if (__s2_len != 0) goto <D.31285>; else goto <D.31286>;
            <D.31285>:
            if (__result == 0) goto <D.31287>; else goto <D.31288>;
            <D.31287>:
            D.31289 = &MEM[(void *)"Address" + 1B];
            D.31290 = *D.31289;
            D.31291 = (int) D.31290;
            D.31292 = __s2 + 1;
            D.31293 = *D.31292;
            D.31294 = (int) D.31293;
            __result = D.31291 - D.31294;
            if (__s2_len > 1) goto <D.31295>; else goto <D.31296>;
            <D.31295>:
            if (__result == 0) goto <D.31297>; else goto <D.31298>;
            <D.31297>:
            D.31299 = &MEM[(void *)"Address" + 2B];
            D.31300 = *D.31299;
            D.31301 = (int) D.31300;
            D.31302 = __s2 + 2;
            D.31303 = *D.31302;
            D.31304 = (int) D.31303;
            __result = D.31301 - D.31304;
            if (__s2_len > 2) goto <D.31305>; else goto <D.31306>;
            <D.31305>:
            if (__result == 0) goto <D.31307>; else goto <D.31308>;
            <D.31307>:
            D.31309 = &MEM[(void *)"Address" + 3B];
            D.31310 = *D.31309;
            D.31311 = (int) D.31310;
            D.31312 = __s2 + 3;
            D.31313 = *D.31312;
            D.31314 = (int) D.31313;
            __result = D.31311 - D.31314;
            <D.31308>:
            <D.31306>:
            <D.31298>:
            <D.31296>:
            <D.31288>:
            <D.31286>:
          }
          D.24518 = __result;
        }
        iftmp.143 = -D.24518;
        goto <D.31315>;
        <D.31279>:
        D.31020 = method->name;
        iftmp.143 = __builtin_strcmp (D.31020, "Address");
        <D.31315>:
        D.24519 = iftmp.143;
      }
      if (D.24519 == 0) goto <D.31316>; else goto <D.31317>;
      <D.31316>:
      p.135 = p;
      encode_value (3, p.135, &p);
      goto <D.31318>;
      <D.31317>:
      {
        size_t __s1_len;
        size_t __s2_len;

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

          __s2 = method->name;
          D.31322 = "Set";
          D.31323 = MEM[(const unsigned char *)D.31322];
          D.31324 = (int) D.31323;
          D.31325 = *__s2;
          D.31326 = (int) D.31325;
          __result = D.31324 - D.31326;
          {
            if (__s2_len != 0) goto <D.31327>; else goto <D.31328>;
            <D.31327>:
            if (__result == 0) goto <D.31329>; else goto <D.31330>;
            <D.31329>:
            D.31331 = &MEM[(void *)"Set" + 1B];
            D.31332 = *D.31331;
            D.31333 = (int) D.31332;
            D.31334 = __s2 + 1;
            D.31335 = *D.31334;
            D.31336 = (int) D.31335;
            __result = D.31333 - D.31336;
            if (__s2_len > 1) goto <D.31337>; else goto <D.31338>;
            <D.31337>:
            if (__result == 0) goto <D.31339>; else goto <D.31340>;
            <D.31339>:
            D.31341 = &MEM[(void *)"Set" + 2B];
            D.31342 = *D.31341;
            D.31343 = (int) D.31342;
            D.31344 = __s2 + 2;
            D.31345 = *D.31344;
            D.31346 = (int) D.31345;
            __result = D.31343 - D.31346;
            if (__s2_len > 2) goto <D.31347>; else goto <D.31348>;
            <D.31347>:
            if (__result == 0) goto <D.31349>; else goto <D.31350>;
            <D.31349>:
            D.31351 = &MEM[(void *)"Set" + 3B];
            D.31352 = *D.31351;
            D.31353 = (int) D.31352;
            D.31354 = __s2 + 3;
            D.31355 = *D.31354;
            D.31356 = (int) D.31355;
            __result = D.31353 - D.31356;
            <D.31350>:
            <D.31348>:
            <D.31340>:
            <D.31338>:
            <D.31330>:
            <D.31328>:
          }
          D.24527 = __result;
        }
        iftmp.144 = -D.24527;
        goto <D.31357>;
        <D.31321>:
        D.31020 = method->name;
        iftmp.144 = __builtin_strcmp (D.31020, "Set");
        <D.31357>:
        D.24528 = iftmp.144;
      }
      if (D.24528 == 0) goto <D.31358>; else goto <D.31359>;
      <D.31358>:
      p.135 = p;
      encode_value (4, p.135, &p);
      goto <D.31360>;
      <D.31359>:
      monoeg_assertion_message ("* Assertion: should not be reached at %s:%d\n", "aot-compiler.c", 2802);
      <D.31360>:
      <D.31318>:
      <D.31276>:
      <D.31200>:
      <D.31154>:
      <D.31146>:
      goto <D.31361>;
      <D.31141>:
      D.31133 = token >> 24;
      D.31134 = D.31133 != 6;
      D.31135 = (long int) D.31134;
      D.31136 = __builtin_expect (D.31135, 0);
      if (D.31136 != 0) goto <D.31362>; else goto <D.31363>;
      <D.31362>:
      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.31363>:
      if (image_index > 239) goto <D.31364>; else goto <D.31365>;
      <D.31364>:
      p.135 = p;
      encode_value (-117440512, p.135, &p);
      image_index.138 = (int) image_index;
      p.135 = p;
      encode_value (image_index.138, p.135, &p);
      token.139 = (int) token;
      D.31366 = token.139 & 16777215;
      p.135 = p;
      encode_value (D.31366, p.135, &p);
      goto <D.31367>;
      <D.31365>:
      D.31368 = image_index << 24;
      D.31369 = token & 16777215;
      D.31370 = D.31368 | D.31369;
      D.31371 = (int) D.31370;
      p.135 = p;
      encode_value (D.31371, p.135, &p);
      <D.31367>:
      <D.31361>:
      <D.31139>:
      <D.31102>:
      p.135 = p;
      *endbuf = p.135;
    }
  finally
    {
      p = {CLOBBER};
    }
}


encode_signature (struct MonoAotCompile * acfg, struct MonoMethodSignature * sig, guint8 * buf, guint8 * * endbuf)
{
  short unsigned int D.31374;
  long unsigned int D.31377;
  long unsigned int D.31378;
  long unsigned int D.31381;
  <unnamed-unsigned:6> D.31384;
  unsigned int D.31385;
  unsigned int D.31386;
  guint8 * p.145;
  unsigned char D.31388;
  guint8 * p.146;
  int D.31392;
  short unsigned int D.31393;
  int D.31394;
  struct MonoType * D.31395;
  short int D.31396;
  int D.31397;
  struct MonoType * D.31400;
  int D.31401;
  guint8 * p;
  guint32 flags;
  int i;

  try
    {
      p = buf;
      flags = 0;
      D.31374 = sig->generic_param_count;
      if (D.31374 != 0) goto <D.31375>; else goto <D.31376>;
      <D.31375>:
      flags = flags | 16;
      <D.31376>:
      D.31377 = BIT_FIELD_REF <*sig, 64, 64>;
      D.31378 = D.31377 & 18014398509481984;
      if (D.31378 != 0) goto <D.31379>; else goto <D.31380>;
      <D.31379>:
      flags = flags | 32;
      <D.31380>:
      D.31377 = BIT_FIELD_REF <*sig, 64, 64>;
      D.31381 = D.31377 & 36028797018963968;
      if (D.31381 != 0) goto <D.31382>; else goto <D.31383>;
      <D.31382>:
      flags = flags | 64;
      <D.31383>:
      D.31384 = sig->call_convention;
      D.31385 = (unsigned int) D.31384;
      D.31386 = D.31385 & 15;
      flags = D.31386 | flags;
      p.145 = p;
      D.31388 = (unsigned char) flags;
      *p.145 = D.31388;
      p.145 = p;
      p.146 = p.145 + 1;
      p = p.146;
      D.31374 = sig->generic_param_count;
      if (D.31374 != 0) goto <D.31390>; else goto <D.31391>;
      <D.31390>:
      D.31374 = sig->generic_param_count;
      D.31392 = (int) D.31374;
      p.145 = p;
      encode_value (D.31392, p.145, &p);
      <D.31391>:
      D.31393 = sig->param_count;
      D.31394 = (int) D.31393;
      p.145 = p;
      encode_value (D.31394, p.145, &p);
      D.31395 = sig->ret;
      p.145 = p;
      encode_type (acfg, D.31395, p.145, &p);
      i = 0;
      goto <D.24432>;
      <D.24431>:
      D.31396 = sig->sentinelpos;
      D.31397 = (int) D.31396;
      if (D.31397 == i) goto <D.31398>; else goto <D.31399>;
      <D.31398>:
      p.145 = p;
      *p.145 = 65;
      p.145 = p;
      p.146 = p.145 + 1;
      p = p.146;
      <D.31399>:
      D.31400 = sig->params[i];
      p.145 = p;
      encode_type (acfg, D.31400, p.145, &p);
      i = i + 1;
      <D.24432>:
      D.31393 = sig->param_count;
      D.31401 = (int) D.31393;
      if (D.31401 > i) goto <D.24431>; else goto <D.24433>;
      <D.24433>:
      p.145 = p;
      *endbuf = p.145;
    }
  finally
    {
      p = {CLOBBER};
    }
}


encode_generic_context (struct MonoAotCompile * acfg, struct MonoGenericContext * context, guint8 * buf, guint8 * * endbuf)
{
  long unsigned int D.31404;
  long unsigned int D.31405;
  _Bool D.31406;
  long int D.31407;
  long int D.31408;
  guint8 * p.147;
  guint8 * p;
  struct MonoGenericInst * inst;

  try
    {
      p = buf;
      inst = context->class_inst;
      if (inst != 0B) goto <D.31402>; else goto <D.31403>;
      <D.31402>:
      D.31404 = BIT_FIELD_REF <*inst, 64, 0>;
      D.31405 = D.31404 & 18014394214514688;
      D.31406 = D.31405 == 0;
      D.31407 = (long int) D.31406;
      D.31408 = __builtin_expect (D.31407, 0);
      if (D.31408 != 0) goto <D.31409>; else goto <D.31410>;
      <D.31409>:
      monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "aot-compiler.c", 2425, "inst->type_argc");
      <D.31410>:
      p.147 = p;
      encode_ginst (acfg, inst, p.147, &p);
      goto <D.31412>;
      <D.31403>:
      p.147 = p;
      encode_value (0, p.147, &p);
      <D.31412>:
      inst = context->method_inst;
      if (inst != 0B) goto <D.31413>; else goto <D.31414>;
      <D.31413>:
      D.31404 = BIT_FIELD_REF <*inst, 64, 0>;
      D.31405 = D.31404 & 18014394214514688;
      D.31406 = D.31405 == 0;
      D.31407 = (long int) D.31406;
      D.31408 = __builtin_expect (D.31407, 0);
      if (D.31408 != 0) goto <D.31415>; else goto <D.31416>;
      <D.31415>:
      monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "aot-compiler.c", 2432, "inst->type_argc");
      <D.31416>:
      p.147 = p;
      encode_ginst (acfg, inst, p.147, &p);
      goto <D.31417>;
      <D.31414>:
      p.147 = p;
      encode_value (0, p.147, &p);
      <D.31417>:
      p.147 = p;
      *endbuf = p.147;
    }
  finally
    {
      p = {CLOBBER};
    }
}


encode_type (struct MonoAotCompile * acfg, struct MonoType * t, guint8 * buf, guint8 * * endbuf)
{
  long unsigned int D.31418;
  long unsigned int D.31419;
  _Bool D.31420;
  long int D.31421;
  long int D.31422;
  long unsigned int D.31425;
  guint8 * p.148;
  guint8 * p.149;
  long unsigned int D.31430;
  unsigned char D.31433;
  int D.31434;
  struct MonoClass * D.31435;
  struct MonoClass * D.31436;
  struct MonoType * D.31437;
  struct MonoGenericClass * D.31438;
  struct MonoClass * D.31439;
  unsigned char D.31440;
  int D.31441;
  unsigned char D.31442;
  int D.31443;
  int * D.31444;
  long unsigned int D.31445;
  long unsigned int D.31446;
  int * D.31447;
  int D.31448;
  int D.31449;
  unsigned char D.31450;
  int D.31451;
  int * D.31452;
  int * D.31453;
  int D.31454;
  int D.31455;
  struct MonoClass * D.31456;
  guint8 * p;

  try
    {
      p = buf;
      D.31418 = BIT_FIELD_REF <*t, 64, 64>;
      D.31419 = D.31418 & 1056964608;
      D.31420 = D.31419 != 0;
      D.31421 = (long int) D.31420;
      D.31422 = __builtin_expect (D.31421, 0);
      if (D.31422 != 0) goto <D.31423>; else goto <D.31424>;
      <D.31423>:
      monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "aot-compiler.c", 2445, "t->num_mods == 0");
      <D.31424>:
      D.31418 = BIT_FIELD_REF <*t, 64, 64>;
      D.31425 = D.31418 & 2147483648;
      if (D.31425 != 0) goto <D.31426>; else goto <D.31427>;
      <D.31426>:
      p.148 = p;
      *p.148 = 69;
      p.148 = p;
      p.149 = p.148 + 1;
      p = p.149;
      <D.31427>:
      D.31418 = BIT_FIELD_REF <*t, 64, 64>;
      D.31430 = D.31418 & 1073741824;
      if (D.31430 != 0) goto <D.31431>; else goto <D.31432>;
      <D.31431>:
      p.148 = p;
      *p.148 = 16;
      p.148 = p;
      p.149 = p.148 + 1;
      p = p.149;
      <D.31432>:
      p.148 = p;
      D.31433 = t->type;
      *p.148 = D.31433;
      p.148 = p;
      p.149 = p.148 + 1;
      p = p.149;
      D.31433 = t->type;
      D.31434 = (int) D.31433;
      switch (D.31434) <default: <D.24421>, case 1: <D.24384>, case 2: <D.24385>, case 3: <D.24386>, case 4: <D.24387>, case 5: <D.24388>, case 6: <D.24389>, case 7: <D.24390>, case 8: <D.24391>, case 9: <D.24392>, case 10: <D.24393>, case 11: <D.24394>, case 12: <D.24395>, case 13: <D.24396>, case 14: <D.24399>, case 15: <D.24406>, case 17: <D.24403>, case 18: <D.24404>, case 19: <D.24419>, case 20: <D.24410>, case 21: <D.24407>, case 22: <D.24401>, case 24: <D.24397>, case 25: <D.24398>, case 28: <D.24400>, case 29: <D.24405>, case 30: <D.24420>>
      <D.24384>:
      <D.24385>:
      <D.24386>:
      <D.24387>:
      <D.24388>:
      <D.24389>:
      <D.24390>:
      <D.24391>:
      <D.24392>:
      <D.24393>:
      <D.24394>:
      <D.24395>:
      <D.24396>:
      <D.24397>:
      <D.24398>:
      <D.24399>:
      <D.24400>:
      <D.24401>:
      goto <D.24402>;
      <D.24403>:
      <D.24404>:
      D.31435 = mono_class_from_mono_type (t);
      p.148 = p;
      encode_klass_ref (acfg, D.31435, p.148, &p);
      goto <D.24402>;
      <D.24405>:
      D.31436 = t->data.klass;
      p.148 = p;
      encode_klass_ref (acfg, D.31436, p.148, &p);
      goto <D.24402>;
      <D.24406>:
      D.31437 = t->data.type;
      p.148 = p;
      encode_type (acfg, D.31437, p.148, &p);
      goto <D.24402>;
      <D.24407>:
      {
        struct MonoClass * gclass;
        struct MonoGenericInst * inst;

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

        array = t->data.array;
        D.31439 = array->eklass;
        p.148 = p;
        encode_klass_ref (acfg, D.31439, p.148, &p);
        D.31440 = array->rank;
        D.31441 = (int) D.31440;
        p.148 = p;
        encode_value (D.31441, p.148, &p);
        D.31442 = array->numsizes;
        D.31443 = (int) D.31442;
        p.148 = p;
        encode_value (D.31443, p.148, &p);
        i = 0;
        goto <D.24414>;
        <D.24413>:
        D.31444 = array->sizes;
        D.31445 = (long unsigned int) i;
        D.31446 = D.31445 * 4;
        D.31447 = D.31444 + D.31446;
        D.31448 = *D.31447;
        p.148 = p;
        encode_value (D.31448, p.148, &p);
        i = i + 1;
        <D.24414>:
        D.31442 = array->numsizes;
        D.31449 = (int) D.31442;
        if (D.31449 > i) goto <D.24413>; else goto <D.24415>;
        <D.24415>:
        D.31450 = array->numlobounds;
        D.31451 = (int) D.31450;
        p.148 = p;
        encode_value (D.31451, p.148, &p);
        i = 0;
        goto <D.24417>;
        <D.24416>:
        D.31452 = array->lobounds;
        D.31445 = (long unsigned int) i;
        D.31446 = D.31445 * 4;
        D.31453 = D.31452 + D.31446;
        D.31454 = *D.31453;
        p.148 = p;
        encode_value (D.31454, p.148, &p);
        i = i + 1;
        <D.24417>:
        D.31450 = array->numlobounds;
        D.31455 = (int) D.31450;
        if (D.31455 > i) goto <D.24416>; else goto <D.24418>;
        <D.24418>:
        goto <D.24402>;
      }
      <D.24419>:
      <D.24420>:
      D.31456 = mono_class_from_mono_type (t);
      p.148 = p;
      encode_klass_ref (acfg, D.31456, p.148, &p);
      goto <D.24402>;
      <D.24421>:
      monoeg_assertion_message ("* Assertion: should not be reached at %s:%d\n", "aot-compiler.c", 2518);
      <D.24402>:
      p.148 = p;
      *endbuf = p.148;
    }
  finally
    {
      p = {CLOBBER};
    }
}


encode_value (gint32 value, guint8 * buf, guint8 * * endbuf)
{
  unsigned int value.150;
  guint8 * p.151;
  unsigned char D.31462;
  int D.31466;
  signed char D.31467;
  signed char D.31468;
  unsigned char D.31469;
  guint8 * D.31470;
  unsigned char D.31471;
  int D.31475;
  signed char D.31476;
  signed char D.31477;
  unsigned char D.31478;
  int D.31479;
  unsigned char D.31480;
  guint8 * D.31481;
  unsigned char D.31482;
  guint8 * D.31483;
  unsigned int D.31485;
  unsigned char D.31486;
  guint8 * D.31487;
  guint8 * p;

  p = buf;
  value.150 = (unsigned int) value;
  if (value.150 <= 127) goto <D.31459>; else goto <D.31460>;
  <D.31459>:
  p.151 = p;
  p = p.151 + 1;
  D.31462 = (unsigned char) value;
  *p.151 = D.31462;
  goto <D.31463>;
  <D.31460>:
  value.150 = (unsigned int) value;
  if (value.150 <= 16383) goto <D.31464>; else goto <D.31465>;
  <D.31464>:
  D.31466 = value >> 8;
  D.31467 = (signed char) D.31466;
  D.31468 = D.31467 | -128;
  D.31469 = (unsigned char) D.31468;
  *p = D.31469;
  D.31470 = p + 1;
  D.31471 = (unsigned char) value;
  *D.31470 = D.31471;
  p = p + 2;
  goto <D.31472>;
  <D.31465>:
  value.150 = (unsigned int) value;
  if (value.150 <= 536870911) goto <D.31473>; else goto <D.31474>;
  <D.31473>:
  D.31475 = value >> 24;
  D.31476 = (signed char) D.31475;
  D.31477 = D.31476 | -64;
  D.31478 = (unsigned char) D.31477;
  *p = D.31478;
  D.31470 = p + 1;
  D.31479 = value >> 16;
  D.31480 = (unsigned char) D.31479;
  *D.31470 = D.31480;
  D.31481 = p + 2;
  D.31466 = value >> 8;
  D.31482 = (unsigned char) D.31466;
  *D.31481 = D.31482;
  D.31483 = p + 3;
  D.31471 = (unsigned char) value;
  *D.31483 = D.31471;
  p = p + 4;
  goto <D.31484>;
  <D.31474>:
  *p = 255;
  D.31470 = p + 1;
  value.150 = (unsigned int) value;
  D.31485 = value.150 >> 24;
  D.31486 = (unsigned char) D.31485;
  *D.31470 = D.31486;
  D.31481 = p + 2;
  D.31479 = value >> 16;
  D.31480 = (unsigned char) D.31479;
  *D.31481 = D.31480;
  D.31483 = p + 3;
  D.31466 = value >> 8;
  D.31482 = (unsigned char) D.31466;
  *D.31483 = D.31482;
  D.31487 = p + 4;
  D.31471 = (unsigned char) value;
  *D.31487 = D.31471;
  p = p + 5;
  <D.31484>:
  <D.31472>:
  <D.31463>:
  if (endbuf != 0B) goto <D.31488>; else goto <D.31489>;
  <D.31488>:
  *endbuf = p;
  <D.31489>:
}


encode_patch_list (struct MonoAotCompile * acfg, struct GPtrArray * patches, int n_patches, int first_got_offset, guint8 * buf, guint8 * * endbuf)
{
  guint8 * p.152;
  void * * D.31491;
  long unsigned int D.31492;
  long unsigned int D.31493;
  void * * D.31494;
  <unnamed type> D.31497;
  int offset.153;
  unsigned int D.31500;
  guint8 * p;
  guint32 pindex;
  guint32 offset;
  struct MonoJumpInfo * patch_info;

  try
    {
      p = buf;
      p.152 = p;
      encode_value (n_patches, p.152, &p);
      pindex = 0;
      goto <D.25467>;
      <D.25466>:
      D.31491 = patches->pdata;
      D.31492 = (long unsigned int) pindex;
      D.31493 = D.31492 * 8;
      D.31494 = D.31491 + D.31493;
      patch_info = *D.31494;
      D.31497 = patch_info->type;
      if (D.31497 == 51) goto <D.31495>; else goto <D.31498>;
      <D.31498>:
      D.31497 = patch_info->type;
      if (D.31497 == 0) goto <D.31495>; else goto <D.31496>;
      <D.31495>:
      // predicted unlikely by continue predictor.
      goto <D.25465>;
      <D.31496>:
      offset = get_got_offset (acfg, patch_info);
      offset.153 = (int) offset;
      p.152 = p;
      encode_value (offset.153, p.152, &p);
      <D.25465>:
      pindex = pindex + 1;
      <D.25467>:
      D.31500 = patches->len;
      if (D.31500 > pindex) goto <D.25466>; else goto <D.25468>;
      <D.25468>:
      p.152 = p;
      *endbuf = p.152;
    }
  finally
    {
      p = {CLOBBER};
    }
}


add_to_blob (struct MonoAotCompile * acfg, const guint8 * data, guint32 data_len)
{
  unsigned int D.31501;
  struct MonoDynamicStream * D.31504;
  guint32 D.31505;

  D.31501 = acfg->blob.alloc_size;
  if (D.31501 == 0) goto <D.31502>; else goto <D.31503>;
  <D.31502>:
  D.31504 = &acfg->blob;
  stream_init (D.31504);
  <D.31503>:
  D.31504 = &acfg->blob;
  D.31505 = add_stream_data (D.31504, data, data_len);
  return D.31505;
}


stream_init (struct MonoDynamicStream * sh)
{
  void * D.31507;
  char * D.31508;
  unsigned int D.31509;
  unsigned int D.31510;

  sh->index = 0;
  sh->alloc_size = 4096;
  D.31507 = monoeg_malloc (4096);
  sh->data = D.31507;
  D.31508 = sh->data;
  *D.31508 = 0;
  D.31509 = sh->index;
  D.31510 = D.31509 + 1;
  sh->index = D.31510;
}


add_stream_data (struct MonoDynamicStream * stream, const char * data, guint32 len)
{
  unsigned int D.31511;
  unsigned int D.31512;
  int D.31513;
  char * D.31514;
  sizetype D.31515;
  char * D.31516;
  long unsigned int D.31517;
  guint32 D.31518;
  guint32 idx;

  D.31511 = stream->index;
  D.31512 = D.31511 + len;
  D.31513 = (int) D.31512;
  make_room_in_stream (stream, D.31513);
  D.31514 = stream->data;
  D.31511 = stream->index;
  D.31515 = (sizetype) D.31511;
  D.31516 = D.31514 + D.31515;
  D.31517 = (long unsigned int) len;
  memcpy (D.31516, data, D.31517);
  idx = stream->index;
  D.31511 = stream->index;
  D.31512 = D.31511 + len;
  stream->index = D.31512;
  D.31518 = idx;
  return D.31518;
}


make_room_in_stream (struct MonoDynamicStream * stream, int size)
{
  unsigned int size.154;
  unsigned int D.31521;
  unsigned int D.31527;
  char * D.31528;
  long unsigned int D.31529;
  void * D.31530;

  size.154 = (unsigned int) size;
  D.31521 = stream->alloc_size;
  if (size.154 <= D.31521) goto <D.31522>; else goto <D.31523>;
  <D.31522>:
  return;
  <D.31523>:
  goto <D.24246>;
  <D.24245>:
  D.31521 = stream->alloc_size;
  if (D.31521 <= 4095) goto <D.31524>; else goto <D.31525>;
  <D.31524>:
  stream->alloc_size = 4096;
  goto <D.31526>;
  <D.31525>:
  D.31521 = stream->alloc_size;
  D.31527 = D.31521 * 2;
  stream->alloc_size = D.31527;
  <D.31526>:
  <D.24246>:
  D.31521 = stream->alloc_size;
  size.154 = (unsigned int) size;
  if (D.31521 <= size.154) goto <D.24245>; else goto <D.24247>;
  <D.24247>:
  D.31528 = stream->data;
  D.31521 = stream->alloc_size;
  D.31529 = (long unsigned int) D.31521;
  D.31530 = monoeg_realloc (D.31528, D.31529);
  stream->data = D.31530;
}


emit_offset_table (struct MonoAotCompile * acfg, int noffsets, int group_size, gint32 * offsets)
{
  int D.31532;
  int D.31533;
  long unsigned int D.31534;
  long unsigned int D.31535;
  long unsigned int D.31536;
  int D.31537;
  int D.31540;
  long unsigned int D.31541;
  long unsigned int D.31542;
  guint32 * D.31543;
  guint8 * p.155;
  long int p.156;
  long int buf.157;
  long int D.31547;
  unsigned int D.31548;
  long unsigned int D.31549;
  long unsigned int D.31550;
  gint32 * D.31551;
  int D.31552;
  int D.31554;
  sizetype D.31558;
  guint32 * D.31559;
  unsigned int D.31560;
  guint32 * D.31564;
  unsigned int D.31565;
  int D.31566;
  int D.31568;
  guint32 D.31569;
  int D.31570;
  int D.31571;
  gint32 current_offset;
  int i;
  int buf_size;
  int ngroups;
  int index_entry_size;
  guint8 * p;
  guint8 * buf;
  guint32 * index_offsets;

  try
    {
      D.31532 = group_size + -1;
      D.31533 = D.31532 + noffsets;
      ngroups = D.31533 / group_size;
      D.31534 = (long unsigned int) ngroups;
      D.31535 = D.31534 * 4;
      index_offsets = monoeg_malloc0 (D.31535);
      buf_size = noffsets * 4;
      D.31536 = (long unsigned int) buf_size;
      buf = monoeg_malloc0 (D.31536);
      p = buf;
      current_offset = 0;
      i = 0;
      goto <D.24282>;
      <D.24281>:
      D.31537 = i % group_size;
      if (D.31537 == 0) goto <D.31538>; else goto <D.31539>;
      <D.31538>:
      D.31540 = i / group_size;
      D.31541 = (long unsigned int) D.31540;
      D.31542 = D.31541 * 4;
      D.31543 = index_offsets + D.31542;
      p.155 = p;
      p.156 = (long int) p.155;
      buf.157 = (long int) buf;
      D.31547 = p.156 - buf.157;
      D.31548 = (unsigned int) D.31547;
      *D.31543 = D.31548;
      D.31549 = (long unsigned int) i;
      D.31550 = D.31549 * 4;
      D.31551 = offsets + D.31550;
      D.31552 = *D.31551;
      p.155 = p;
      encode_value (D.31552, p.155, &p);
      goto <D.31553>;
      <D.31539>:
      D.31549 = (long unsigned int) i;
      D.31550 = D.31549 * 4;
      D.31551 = offsets + D.31550;
      D.31552 = *D.31551;
      D.31554 = D.31552 - current_offset;
      p.155 = p;
      encode_value (D.31554, p.155, &p);
      <D.31553>:
      D.31549 = (long unsigned int) i;
      D.31550 = D.31549 * 4;
      D.31551 = offsets + D.31550;
      current_offset = *D.31551;
      i = i + 1;
      <D.24282>:
      if (i < noffsets) goto <D.24281>; else goto <D.24283>;
      <D.24283>:
      if (ngroups != 0) goto <D.31557>; else goto <D.31555>;
      <D.31557>:
      D.31534 = (long unsigned int) ngroups;
      D.31535 = D.31534 * 4;
      D.31558 = D.31535 + 18446744073709551612;
      D.31559 = index_offsets + D.31558;
      D.31560 = *D.31559;
      if (D.31560 <= 64999) goto <D.31561>; else goto <D.31555>;
      <D.31561>:
      index_entry_size = 2;
      goto <D.31556>;
      <D.31555>:
      index_entry_size = 4;
      <D.31556>:
      emit_int32 (acfg, noffsets);
      emit_int32 (acfg, group_size);
      emit_int32 (acfg, ngroups);
      emit_int32 (acfg, index_entry_size);
      i = 0;
      goto <D.24285>;
      <D.24284>:
      if (index_entry_size == 2) goto <D.31562>; else goto <D.31563>;
      <D.31562>:
      D.31549 = (long unsigned int) i;
      D.31550 = D.31549 * 4;
      D.31564 = index_offsets + D.31550;
      D.31565 = *D.31564;
      D.31566 = (int) D.31565;
      emit_int16 (acfg, D.31566);
      goto <D.31567>;
      <D.31563>:
      D.31549 = (long unsigned int) i;
      D.31550 = D.31549 * 4;
      D.31564 = index_offsets + D.31550;
      D.31565 = *D.31564;
      D.31566 = (int) D.31565;
      emit_int32 (acfg, D.31566);
      <D.31567>:
      i = i + 1;
      <D.24285>:
      if (i < ngroups) goto <D.24284>; else goto <D.24286>;
      <D.24286>:
      p.155 = p;
      p.156 = (long int) p.155;
      buf.157 = (long int) buf;
      D.31547 = p.156 - buf.157;
      D.31568 = (int) D.31547;
      emit_bytes (acfg, buf, D.31568);
      p.155 = p;
      p.156 = (long int) p.155;
      buf.157 = (long int) buf;
      D.31547 = p.156 - buf.157;
      D.31568 = (int) D.31547;
      D.31570 = ngroups * 4;
      D.31571 = D.31568 + D.31570;
      D.31569 = (guint32) D.31571;
      return D.31569;
    }
  finally
    {
      p = {CLOBBER};
    }
}


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

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


emit_extra_methods (struct MonoAotCompile * acfg)
{
  struct GPtrArray * D.31575;
  unsigned int D.31576;
  long unsigned int D.31577;
  long unsigned int D.31578;
  void * * D.31579;
  long unsigned int D.31580;
  long unsigned int D.31581;
  void * * D.31582;
  struct GHashTable * D.31583;
  long unsigned int D.31586;
  guint8 * p.158;
  long int p.159;
  long int buf.160;
  long int D.31590;
  long int D.31591;
  _Bool D.31592;
  long int D.31593;
  long int D.31594;
  long unsigned int D.31597;
  guint32 * D.31598;
  unsigned int D.31599;
  unsigned int D.31600;
  unsigned int i.161;
  double D.31602;
  double D.31603;
  int D.31604;
  unsigned int D.31605;
  unsigned int D.31606;
  unsigned int table_size.162;
  long unsigned int D.31608;
  long unsigned int D.31609;
  unsigned int D.31612;
  unsigned int table_size.163;
  long unsigned int D.31614;
  long unsigned int D.31615;
  int * D.31616;
  int D.31617;
  int D.31618;
  struct MonoMemPool * D.31619;
  void * * D.31620;
  long unsigned int D.31621;
  void * * D.31622;
  struct HashEntry * D.31626;
  unsigned int D.31627;
  void * * D.31628;
  unsigned int D.31632;
  int D.31633;
  unsigned int D.31634;
  int D.31635;
  struct HashEntry * D.31636;
  unsigned int D.31639;
  int D.31640;
  int D.31642;
  unsigned int D.31643;
  int D.31644;
  unsigned int D.31645;
  int D.31646;
  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.31575 = acfg->extra_methods;
      D.31576 = D.31575->len;
      D.31577 = (long unsigned int) D.31576;
      D.31578 = D.31577 * 4;
      info_offsets = monoeg_malloc0 (D.31578);
      nmethods = 0;
      i = 0;
      goto <D.26175>;
      <D.26174>:
      {
        struct MonoMethod * method;
        struct MonoCompile * cfg;

        D.31575 = acfg->extra_methods;
        D.31579 = D.31575->pdata;
        D.31580 = (long unsigned int) i;
        D.31581 = D.31580 * 8;
        D.31582 = D.31579 + D.31581;
        method = *D.31582;
        D.31583 = acfg->method_to_cfg;
        cfg = monoeg_g_hash_table_lookup (D.31583, method);
        if (cfg == 0B) goto <D.31584>; else goto <D.31585>;
        <D.31584>:
        // predicted unlikely by continue predictor.
        goto <D.26173>;
        <D.31585>:
        buf_size = 10240;
        D.31586 = (long unsigned int) buf_size;
        buf = monoeg_malloc (D.31586);
        p = buf;
        nmethods = nmethods + 1;
        method = cfg->method_to_register;
        p.158 = p;
        encode_method_ref (acfg, method, p.158, &p);
        p.158 = p;
        p.159 = (long int) p.158;
        buf.160 = (long int) buf;
        D.31590 = p.159 - buf.160;
        D.31591 = (long int) buf_size;
        D.31592 = D.31590 >= D.31591;
        D.31593 = (long int) D.31592;
        D.31594 = __builtin_expect (D.31593, 0);
        if (D.31594 != 0) goto <D.31595>; else goto <D.31596>;
        <D.31595>:
        monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "aot-compiler.c", 7508, "(p - buf) < buf_size");
        <D.31596>:
        D.31580 = (long unsigned int) i;
        D.31597 = D.31580 * 4;
        D.31598 = info_offsets + D.31597;
        p.158 = p;
        p.159 = (long int) p.158;
        buf.160 = (long int) buf;
        D.31590 = p.159 - buf.160;
        D.31599 = (unsigned int) D.31590;
        D.31600 = add_to_blob (acfg, buf, D.31599);
        *D.31598 = D.31600;
        monoeg_g_free (buf);
      }
      <D.26173>:
      i = i + 1;
      <D.26175>:
      i.161 = (unsigned int) i;
      D.31575 = acfg->extra_methods;
      D.31576 = D.31575->len;
      if (i.161 < D.31576) goto <D.26174>; else goto <D.26176>;
      <D.26176>:
      D.31602 = (double) nmethods;
      D.31603 = D.31602 * 1.5e+0;
      D.31604 = (int) D.31603;
      D.31605 = (unsigned int) D.31604;
      D.31606 = monoeg_g_spaced_primes_closest (D.31605);
      table_size = (int) D.31606;
      table_size.162 = (unsigned int) table_size;
      table = monoeg_g_ptr_array_sized_new (table_size.162);
      i = 0;
      goto <D.26178>;
      <D.26177>:
      monoeg_g_ptr_array_add (table, 0B);
      i = i + 1;
      <D.26178>:
      if (i < table_size) goto <D.26177>; else goto <D.26179>;
      <D.26179>:
      D.31608 = (long unsigned int) table_size;
      D.31609 = D.31608 * 4;
      chain_lengths = monoeg_malloc0 (D.31609);
      max_chain_length = 0;
      i = 0;
      goto <D.26189>;
      <D.26188>:
      {
        struct MonoMethod * method;
        struct MonoCompile * cfg;
        guint32 key;
        guint32 value;

        D.31575 = acfg->extra_methods;
        D.31579 = D.31575->pdata;
        D.31580 = (long unsigned int) i;
        D.31581 = D.31580 * 8;
        D.31582 = D.31579 + D.31581;
        method = *D.31582;
        D.31583 = acfg->method_to_cfg;
        cfg = monoeg_g_hash_table_lookup (D.31583, method);
        if (cfg == 0B) goto <D.31610>; else goto <D.31611>;
        <D.31610>:
        // predicted unlikely by continue predictor.
        goto <D.26184>;
        <D.31611>:
        D.31580 = (long unsigned int) i;
        D.31597 = D.31580 * 4;
        D.31598 = info_offsets + D.31597;
        key = *D.31598;
        value = get_method_index (acfg, method);
        D.31612 = mono_aot_method_hash (method);
        table_size.163 = (unsigned int) table_size;
        hash = D.31612 % table_size.163;
        D.31614 = (long unsigned int) hash;
        D.31615 = D.31614 * 4;
        D.31616 = chain_lengths + D.31615;
        D.31617 = *D.31616;
        D.31618 = D.31617 + 1;
        *D.31616 = D.31618;
        D.31614 = (long unsigned int) hash;
        D.31615 = D.31614 * 4;
        D.31616 = chain_lengths + D.31615;
        D.31617 = *D.31616;
        max_chain_length = MAX_EXPR <D.31617, max_chain_length>;
        D.31619 = acfg->mempool;
        new_entry = mono_mempool_alloc0 (D.31619, 24);
        new_entry->key = key;
        new_entry->value = value;
        D.31620 = table->pdata;
        D.31614 = (long unsigned int) hash;
        D.31621 = D.31614 * 8;
        D.31622 = D.31620 + D.31621;
        entry = *D.31622;
        if (entry == 0B) goto <D.31623>; else goto <D.31624>;
        <D.31623>:
        new_entry->index = hash;
        D.31620 = table->pdata;
        D.31614 = (long unsigned int) hash;
        D.31621 = D.31614 * 8;
        D.31622 = D.31620 + D.31621;
        *D.31622 = new_entry;
        goto <D.31625>;
        <D.31624>:
        goto <D.26186>;
        <D.26185>:
        entry = entry->next;
        <D.26186>:
        D.31626 = entry->next;
        if (D.31626 != 0B) goto <D.26185>; else goto <D.26187>;
        <D.26187>:
        entry->next = new_entry;
        D.31627 = table->len;
        new_entry->index = D.31627;
        monoeg_g_ptr_array_add (table, new_entry);
        <D.31625>:
      }
      <D.26184>:
      i = i + 1;
      <D.26189>:
      i.161 = (unsigned int) i;
      D.31575 = acfg->extra_methods;
      D.31576 = D.31575->len;
      if (i.161 < D.31576) goto <D.26188>; else goto <D.26190>;
      <D.26190>:
      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.26193>;
      <D.26192>:
      {
        struct HashEntry * entry;

        D.31620 = table->pdata;
        D.31580 = (long unsigned int) i;
        D.31581 = D.31580 * 8;
        D.31628 = D.31620 + D.31581;
        entry = *D.31628;
        if (entry == 0B) goto <D.31629>; else goto <D.31630>;
        <D.31629>:
        emit_int32 (acfg, 0);
        emit_int32 (acfg, 0);
        emit_int32 (acfg, 0);
        goto <D.31631>;
        <D.31630>:
        D.31632 = entry->key;
        D.31633 = (int) D.31632;
        emit_int32 (acfg, D.31633);
        D.31634 = entry->value;
        D.31635 = (int) D.31634;
        emit_int32 (acfg, D.31635);
        D.31636 = entry->next;
        if (D.31636 != 0B) goto <D.31637>; else goto <D.31638>;
        <D.31637>:
        D.31636 = entry->next;
        D.31639 = D.31636->index;
        D.31640 = (int) D.31639;
        emit_int32 (acfg, D.31640);
        goto <D.31641>;
        <D.31638>:
        emit_int32 (acfg, 0);
        <D.31641>:
        <D.31631>:
      }
      i = i + 1;
      <D.26193>:
      i.161 = (unsigned int) i;
      D.31627 = table->len;
      if (i.161 < D.31627) goto <D.26192>; else goto <D.26194>;
      <D.26194>:
      sprintf (&symbol, "extra_method_info_offsets");
      emit_section_change (acfg, ".rodata", 0);
      emit_alignment (acfg, 8);
      emit_label (acfg, &symbol);
      D.31575 = acfg->extra_methods;
      D.31576 = D.31575->len;
      D.31642 = (int) D.31576;
      emit_int32 (acfg, D.31642);
      i = 0;
      goto <D.26197>;
      <D.26196>:
      {
        struct MonoMethod * method;

        D.31575 = acfg->extra_methods;
        D.31579 = D.31575->pdata;
        D.31580 = (long unsigned int) i;
        D.31581 = D.31580 * 8;
        D.31582 = D.31579 + D.31581;
        method = *D.31582;
        D.31643 = get_method_index (acfg, method);
        D.31644 = (int) D.31643;
        emit_int32 (acfg, D.31644);
        D.31580 = (long unsigned int) i;
        D.31597 = D.31580 * 4;
        D.31598 = info_offsets + D.31597;
        D.31645 = *D.31598;
        D.31646 = (int) D.31645;
        emit_int32 (acfg, D.31646);
      }
      i = i + 1;
      <D.26197>:
      i.161 = (unsigned int) i;
      D.31575 = acfg->extra_methods;
      D.31576 = D.31575->len;
      if (i.161 < D.31576) goto <D.26196>; else goto <D.26198>;
      <D.26198>:
    }
  finally
    {
      symbol = {CLOBBER};
      p = {CLOBBER};
    }
}


emit_trampolines (struct MonoAotCompile * acfg)
{
  int D.31647;
  struct MonoImage * D.31650;
  struct MonoAssembly * D.31651;
  _Bool D.31652;
  long int D.31653;
  long int D.31654;
  int D.25691;
  int iftmp.164;
  int D.25690;
  const char[9] * D.31660;
  unsigned char D.31661;
  int D.31662;
  unsigned char D.31663;
  int D.31664;
  const unsigned char * D.31669;
  unsigned char D.31670;
  int D.31671;
  const unsigned char * D.31672;
  unsigned char D.31673;
  int D.31674;
  const unsigned char * D.31679;
  unsigned char D.31680;
  int D.31681;
  const unsigned char * D.31682;
  unsigned char D.31683;
  int D.31684;
  const unsigned char * D.31689;
  unsigned char D.31690;
  int D.31691;
  const unsigned char * D.31692;
  unsigned char D.31693;
  int D.31694;
  const char * D.31696;
  <unnamed type> tramp_type.165;
  int iftmp.166;
  int D.31703;
  unsigned int D.31707;
  int D.31708;
  struct MonoTrampInfo * info.167;
  unsigned int offset.168;
  unsigned int i.169;
  unsigned int D.31712;
  int D.31713;
  int D.31714;
  unsigned int tramp_got_offset.170;
  unsigned int D.31718;
  int tramp_size.171;
  _Bool D.31722;
  long int D.31723;
  long int D.31724;
  unsigned int tramp_size.172;
  unsigned int i.173;
  unsigned int D.31729;
  unsigned int D.31730;
  unsigned int D.31731;
  unsigned int D.31732;
  char symbol[256];
  char end_symbol[256];
  int i;
  int tramp_got_offset;
  MonoAotTrampoline ntype;
  int tramp_type;

  try
    {
      D.31647 = acfg->aot_opts.full_aot;
      if (D.31647 == 0) goto <D.31648>; else goto <D.31649>;
      <D.31648>:
      return;
      <D.31649>:
      D.31650 = acfg->image;
      D.31651 = D.31650->assembly;
      D.31652 = D.31651 == 0B;
      D.31653 = (long int) D.31652;
      D.31654 = __builtin_expect (D.31653, 0);
      if (D.31654 != 0) goto <D.31655>; else goto <D.31656>;
      <D.31655>:
      monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "aot-compiler.c", 5896, "acfg->image->assembly");
      <D.31656>:
      {
        size_t __s1_len;
        size_t __s2_len;

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

          D.31650 = acfg->image;
          D.31651 = D.31650->assembly;
          __s2 = D.31651->aname.name;
          D.31660 = "mscorlib";
          D.31661 = MEM[(const unsigned char *)D.31660];
          D.31662 = (int) D.31661;
          D.31663 = *__s2;
          D.31664 = (int) D.31663;
          __result = D.31662 - D.31664;
          {
            if (__s2_len != 0) goto <D.31665>; else goto <D.31666>;
            <D.31665>:
            if (__result == 0) goto <D.31667>; else goto <D.31668>;
            <D.31667>:
            D.31669 = &MEM[(void *)"mscorlib" + 1B];
            D.31670 = *D.31669;
            D.31671 = (int) D.31670;
            D.31672 = __s2 + 1;
            D.31673 = *D.31672;
            D.31674 = (int) D.31673;
            __result = D.31671 - D.31674;
            if (__s2_len > 1) goto <D.31675>; else goto <D.31676>;
            <D.31675>:
            if (__result == 0) goto <D.31677>; else goto <D.31678>;
            <D.31677>:
            D.31679 = &MEM[(void *)"mscorlib" + 2B];
            D.31680 = *D.31679;
            D.31681 = (int) D.31680;
            D.31682 = __s2 + 2;
            D.31683 = *D.31682;
            D.31684 = (int) D.31683;
            __result = D.31681 - D.31684;
            if (__s2_len > 2) goto <D.31685>; else goto <D.31686>;
            <D.31685>:
            if (__result == 0) goto <D.31687>; else goto <D.31688>;
            <D.31687>:
            D.31689 = &MEM[(void *)"mscorlib" + 3B];
            D.31690 = *D.31689;
            D.31691 = (int) D.31690;
            D.31692 = __s2 + 3;
            D.31693 = *D.31692;
            D.31694 = (int) D.31693;
            __result = D.31691 - D.31694;
            <D.31688>:
            <D.31686>:
            <D.31678>:
            <D.31676>:
            <D.31668>:
            <D.31666>:
          }
          D.25690 = __result;
        }
        iftmp.164 = -D.25690;
        goto <D.31695>;
        <D.31659>:
        D.31650 = acfg->image;
        D.31651 = D.31650->assembly;
        D.31696 = D.31651->aname.name;
        iftmp.164 = __builtin_strcmp (D.31696, "mscorlib");
        <D.31695>:
        D.25691 = iftmp.164;
      }
      if (D.25691 == 0) goto <D.31697>; else goto <D.31698>;
      <D.31697>:
      {
        struct MonoTrampInfo * info;

        try
          {
            tramp_type = 0;
            goto <D.25695>;
            <D.25694>:
            if (tramp_type == 13) goto <D.31699>; else goto <D.31700>;
            <D.31699>:
            // predicted unlikely by continue predictor.
            goto <D.25693>;
            <D.31700>:
            tramp_type.165 = (<unnamed type>) tramp_type;
            D.31703 = acfg->aot_opts.use_trampolines_page;
            if (D.31703 != 0) goto <D.31704>; else goto <D.31705>;
            <D.31704>:
            iftmp.166 = 2;
            goto <D.31706>;
            <D.31705>:
            iftmp.166 = 1;
            <D.31706>:
            mono_arch_create_generic_trampoline (tramp_type.165, &info, iftmp.166);
            D.31707 = acfg->got_offset;
            D.31708 = (int) D.31707;
            info.167 = info;
            emit_trampoline (acfg, D.31708, info.167);
            <D.25693>:
            tramp_type = tramp_type + 1;
            <D.25695>:
            if (tramp_type <= 13) goto <D.25694>; else goto <D.25696>;
            <D.25696>:
            mono_arch_get_nullified_class_init_trampoline (&info);
            D.31707 = acfg->got_offset;
            D.31708 = (int) D.31707;
            info.167 = info;
            emit_trampoline (acfg, D.31708, info.167);
            mono_arch_create_generic_class_init_trampoline (&info, 1);
            D.31707 = acfg->got_offset;
            D.31708 = (int) D.31707;
            info.167 = info;
            emit_trampoline (acfg, D.31708, info.167);
            mono_arch_get_restore_context (&info, 1);
            D.31707 = acfg->got_offset;
            D.31708 = (int) D.31707;
            info.167 = info;
            emit_trampoline (acfg, D.31708, info.167);
            mono_arch_get_call_filter (&info, 1);
            D.31707 = acfg->got_offset;
            D.31708 = (int) D.31707;
            info.167 = info;
            emit_trampoline (acfg, D.31708, info.167);
            mono_arch_get_throw_exception (&info, 1);
            D.31707 = acfg->got_offset;
            D.31708 = (int) D.31707;
            info.167 = info;
            emit_trampoline (acfg, D.31708, info.167);
            mono_arch_get_rethrow_exception (&info, 1);
            D.31707 = acfg->got_offset;
            D.31708 = (int) D.31707;
            info.167 = info;
            emit_trampoline (acfg, D.31708, info.167);
            mono_arch_get_throw_corlib_exception (&info, 1);
            D.31707 = acfg->got_offset;
            D.31708 = (int) D.31707;
            info.167 = info;
            emit_trampoline (acfg, D.31708, info.167);
            i = 0;
            goto <D.25699>;
            <D.25698>:
            {
              int offset;

              offset = i;
              offset.168 = (unsigned int) offset;
              mono_arch_create_rgctx_lazy_fetch_trampoline (offset.168, &info, 1);
              D.31707 = acfg->got_offset;
              D.31708 = (int) D.31707;
              info.167 = info;
              emit_trampoline (acfg, D.31708, info.167);
              i.169 = (unsigned int) i;
              D.31712 = i.169 | 2147483648;
              offset = (int) D.31712;
              offset.168 = (unsigned int) offset;
              mono_arch_create_rgctx_lazy_fetch_trampoline (offset.168, &info, 1);
              D.31707 = acfg->got_offset;
              D.31708 = (int) D.31707;
              info.167 = info;
              emit_trampoline (acfg, D.31708, info.167);
            }
            i = i + 1;
            <D.25699>:
            D.31713 = acfg->aot_opts.nrgctx_fetch_trampolines;
            if (D.31713 > i) goto <D.25698>; else goto <D.25700>;
            <D.25700>:
            {
              struct GSList * l;

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

                info = l->data;
                D.31707 = acfg->got_offset;
                D.31708 = (int) D.31707;
                emit_trampoline (acfg, D.31708, info);
                l = l->next;
              }
              <D.25704>:
              if (l != 0B) goto <D.25703>; else goto <D.25705>;
              <D.25705>:
            }
            emit_section_change (acfg, ".text", 0);
            D.31707 = acfg->got_offset;
            tramp_got_offset = (int) D.31707;
            ntype = 0;
            goto <D.25723>;
            <D.25722>:
            switch (ntype) <default: <D.25711>, case 0: <D.25706>, case 1: <D.25708>, case 2: <D.25709>, case 3: <D.25710>>
            <D.25706>:
            sprintf (&symbol, "specific_trampolines");
            goto <D.25707>;
            <D.25708>:
            sprintf (&symbol, "static_rgctx_trampolines");
            goto <D.25707>;
            <D.25709>:
            sprintf (&symbol, "imt_thunks");
            goto <D.25707>;
            <D.25710>:
            sprintf (&symbol, "gsharedvt_arg_trampolines");
            goto <D.25707>;
            <D.25711>:
            monoeg_assertion_message ("* Assertion: should not be reached at %s:%d\n", "aot-compiler.c", 6053);
            <D.25707>:
            sprintf (&end_symbol, "%s_e", &symbol);
            D.31714 = acfg->aot_opts.write_symbols;
            if (D.31714 != 0) goto <D.31715>; else goto <D.31716>;
            <D.31715>:
            emit_local_symbol (acfg, &symbol, &end_symbol, 1);
            <D.31716>:
            emit_alignment (acfg, 16);
            emit_label (acfg, &symbol);
            tramp_got_offset.170 = (unsigned int) tramp_got_offset;
            acfg->trampoline_got_offset_base[ntype] = tramp_got_offset.170;
            i = 0;
            goto <D.25720>;
            <D.25719>:
            {
              int tramp_size;

              try
                {
                  tramp_size = 0;
                  switch (ntype) <default: <D.25718>, case 0: <D.25713>, case 1: <D.25715>, case 2: <D.25716>, case 3: <D.25717>>
                  <D.25713>:
                  arch_emit_specific_trampoline (acfg, tramp_got_offset, &tramp_size);
                  tramp_got_offset = tramp_got_offset + 2;
                  goto <D.25714>;
                  <D.25715>:
                  arch_emit_static_rgctx_trampoline (acfg, tramp_got_offset, &tramp_size);
                  tramp_got_offset = tramp_got_offset + 2;
                  goto <D.25714>;
                  <D.25716>:
                  arch_emit_imt_thunk (acfg, tramp_got_offset, &tramp_size);
                  tramp_got_offset = tramp_got_offset + 1;
                  goto <D.25714>;
                  <D.25717>:
                  arch_emit_gsharedvt_arg_trampoline (acfg, tramp_got_offset, &tramp_size);
                  tramp_got_offset = tramp_got_offset + 2;
                  goto <D.25714>;
                  <D.25718>:
                  monoeg_assertion_message ("* Assertion: should not be reached at %s:%d\n", "aot-compiler.c", 6087);
                  <D.25714>:
                  D.31718 = acfg->trampoline_size[ntype];
                  if (D.31718 == 0) goto <D.31719>; else goto <D.31720>;
                  <D.31719>:
                  tramp_size.171 = tramp_size;
                  D.31722 = tramp_size.171 == 0;
                  D.31723 = (long int) D.31722;
                  D.31724 = __builtin_expect (D.31723, 0);
                  if (D.31724 != 0) goto <D.31725>; else goto <D.31726>;
                  <D.31725>:
                  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "aot-compiler.c", 6095, "tramp_size");
                  <D.31726>:
                  tramp_size.171 = tramp_size;
                  tramp_size.172 = (unsigned int) tramp_size.171;
                  acfg->trampoline_size[ntype] = tramp_size.172;
                  <D.31720>:
                }
              finally
                {
                  tramp_size = {CLOBBER};
                }
            }
            i = i + 1;
            <D.25720>:
            i.173 = (unsigned int) i;
            D.31729 = acfg->num_trampolines[ntype];
            if (i.173 < D.31729) goto <D.25719>; else goto <D.25721>;
            <D.25721>:
            emit_label (acfg, &end_symbol);
            emit_int32 (acfg, 0);
            ntype = ntype + 1;
            <D.25723>:
            if (ntype <= 3) goto <D.25722>; else goto <D.25724>;
            <D.25724>:
            arch_emit_specific_trampoline_pages (acfg);
            tramp_got_offset.170 = (unsigned int) tramp_got_offset;
            D.31707 = acfg->got_offset;
            D.31730 = tramp_got_offset.170 - D.31707;
            acfg->num_trampoline_got_entries = D.31730;
          }
        finally
          {
            info = {CLOBBER};
          }
      }
      <D.31698>:
      D.31707 = acfg->got_offset;
      D.31731 = acfg->num_trampoline_got_entries;
      D.31732 = D.31707 + D.31731;
      acfg->got_offset = D.31732;
    }
  finally
    {
      symbol = {CLOBBER};
      end_symbol = {CLOBBER};
    }
}


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


emit_trampoline_full (struct MonoAotCompile * acfg, int got_offset, struct MonoTrampInfo * info, gboolean emit_tinfo)
{
  _Bool D.31736;
  long int D.31737;
  long int D.31738;
  const char * D.31741;
  const char * D.31742;
  <unnamed type> D.31745;
  unsigned int D.31748;
  unsigned int D.31749;
  long unsigned int D.31750;
  int D.31751;
  guint8 * p.174;
  long int p.175;
  long int buf.176;
  long int D.31755;
  long int D.31756;
  _Bool D.31757;
  long int D.31758;
  long int D.31759;
  unsigned int D.31762;
  int info_offset.177;
  struct GSList * D.31766;
  unsigned int encoded_len.178;
  int uw_offset.179;
  struct MonoDwarfWriter * D.31771;
  char start_symbol[256];
  char end_symbol[256];
  char symbol[256];
  guint32 buf_size;
  guint32 info_offset;
  struct MonoJumpInfo * patch_info;
  guint8 * buf;
  guint8 * p;
  struct GPtrArray * patches;
  char * name;
  guint8 * code;
  guint32 code_size;
  struct MonoJumpInfo * ji;
  struct GSList * unwind_ops;

  try
    {
      D.31736 = info == 0B;
      D.31737 = (long int) D.31736;
      D.31738 = __builtin_expect (D.31737, 0);
      if (D.31738 != 0) goto <D.31739>; else goto <D.31740>;
      <D.31739>:
      monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "aot-compiler.c", 5785, "info");
      <D.31740>:
      name = info->name;
      code = info->code;
      code_size = info->code_size;
      ji = info->ji;
      unwind_ops = info->unwind_ops;
      D.31741 = acfg->user_symbol_prefix;
      sprintf (&start_symbol, "%s%s", D.31741, name);
      emit_section_change (acfg, ".text", 0);
      emit_global (acfg, &start_symbol, 1);
      emit_alignment (acfg, 16);
      emit_label (acfg, &start_symbol);
      D.31742 = acfg->temp_prefix;
      sprintf (&symbol, "%snamed_%s", D.31742, name);
      emit_label (acfg, &symbol);
      emit_and_reloc_code (acfg, 0B, code, code_size, ji, 1, 0B);
      emit_symbol_size (acfg, &start_symbol, ".");
      if (emit_tinfo != 0) goto <D.31743>; else goto <D.31744>;
      <D.31743>:
      D.31742 = acfg->temp_prefix;
      sprintf (&end_symbol, "%snamede_%s", D.31742, name);
      emit_label (acfg, &end_symbol);
      <D.31744>:
      patches = monoeg_g_ptr_array_new ();
      patch_info = ji;
      goto <D.25663>;
      <D.25662>:
      D.31745 = patch_info->type;
      if (D.31745 != 51) goto <D.31746>; else goto <D.31747>;
      <D.31746>:
      monoeg_g_ptr_array_add (patches, patch_info);
      <D.31747>:
      patch_info = patch_info->next;
      <D.25663>:
      if (patch_info != 0B) goto <D.25662>; else goto <D.25664>;
      <D.25664>:
      monoeg_g_ptr_array_sort (patches, compare_patches);
      D.31748 = patches->len;
      D.31749 = D.31748 + 1;
      buf_size = D.31749 * 128;
      D.31750 = (long unsigned int) buf_size;
      buf = monoeg_malloc (D.31750);
      p = buf;
      D.31748 = patches->len;
      D.31751 = (int) D.31748;
      p.174 = p;
      encode_patch_list (acfg, patches, D.31751, got_offset, p.174, &p);
      p.174 = p;
      p.175 = (long int) p.174;
      buf.176 = (long int) buf;
      D.31755 = p.175 - buf.176;
      D.31756 = (long int) buf_size;
      D.31757 = D.31755 >= D.31756;
      D.31758 = (long int) D.31757;
      D.31759 = __builtin_expect (D.31758, 0);
      if (D.31759 != 0) goto <D.31760>; else goto <D.31761>;
      <D.31760>:
      monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "aot-compiler.c", 5836, "p - buf < buf_size");
      <D.31761>:
      D.31741 = acfg->user_symbol_prefix;
      sprintf (&symbol, "%s%s_p", D.31741, name);
      p.174 = p;
      p.175 = (long int) p.174;
      buf.176 = (long int) buf;
      D.31755 = p.175 - buf.176;
      D.31762 = (unsigned int) D.31755;
      info_offset = add_to_blob (acfg, buf, D.31762);
      emit_section_change (acfg, ".rodata", 0);
      emit_global (acfg, &symbol, 0);
      emit_label (acfg, &symbol);
      info_offset.177 = (int) info_offset;
      emit_int32 (acfg, info_offset.177);
      if (emit_tinfo != 0) goto <D.31764>; else goto <D.31765>;
      <D.31764>:
      {
        guint8 * encoded;
        guint32 encoded_len;
        guint32 uw_offset;

        try
          {
            D.31766 = info->unwind_ops;
            encoded = mono_unwind_ops_encode (D.31766, &encoded_len);
            encoded_len.178 = encoded_len;
            uw_offset = get_unwind_info_offset (acfg, encoded, encoded_len.178);
            monoeg_g_free (encoded);
            emit_symbol_diff (acfg, &end_symbol, &start_symbol, 0);
            uw_offset.179 = (int) uw_offset;
            emit_int32 (acfg, uw_offset.179);
          }
        finally
          {
            encoded_len = {CLOBBER};
          }
      }
      <D.31765>:
      if (unwind_ops != 0B) goto <D.31769>; else goto <D.31770>;
      <D.31769>:
      {
        char symbol2[256];

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


emit_global (struct MonoAotCompile * acfg, const char * name, gboolean func)
{
  int D.31774;
  struct GPtrArray * D.31777;
  gchar * D.31778;
  struct MonoImageWriter * D.31779;

  D.31774 = acfg->aot_opts.no_dlsym;
  if (D.31774 != 0) goto <D.31775>; else goto <D.31776>;
  <D.31775>:
  D.31777 = acfg->globals;
  D.31778 = monoeg_strdup (name);
  monoeg_g_ptr_array_add (D.31777, D.31778);
  D.31779 = acfg->w;
  img_writer_emit_local_symbol (D.31779, name, 0B, func);
  goto <D.31780>;
  <D.31776>:
  D.31779 = acfg->w;
  img_writer_emit_global (D.31779, name, func);
  <D.31780>:
}


get_unwind_info_offset (struct MonoAotCompile * acfg, guint8 * encoded, guint32 encoded_len)
{
  struct GHashTable * D.31781;
  unsigned int D.31782;
  long unsigned int D.31783;
  const void * D.31784;
  void * D.31785;
  long int D.31786;
  guint32 D.31789;
  void * D.31790;
  unsigned int D.31791;
  long unsigned int D.31792;
  void * D.31793;
  struct GPtrArray * D.31794;
  long unsigned int D.31795;
  void * D.31796;
  int encoded_len.180;
  guint8 * p.181;
  unsigned int D.31799;
  long int p.182;
  long int buf.183;
  long int D.31802;
  unsigned int D.31803;
  unsigned int D.31804;
  unsigned int D.31805;
  guint32 cache_index;
  guint32 offset;

  cache_index = mono_cache_unwind_info (encoded, encoded_len);
  D.31781 = acfg->unwind_info_offsets;
  D.31782 = cache_index + 1;
  D.31783 = (long unsigned int) D.31782;
  D.31784 = (const void *) D.31783;
  D.31785 = monoeg_g_hash_table_lookup (D.31781, D.31784);
  D.31786 = (long int) D.31785;
  offset = (guint32) D.31786;
  if (offset != 0) goto <D.31787>; else goto <D.31788>;
  <D.31787>:
  D.31789 = offset + 4294967295;
  return D.31789;
  <D.31788>:
  {
    guint8 buf[16];
    guint8 * p;

    try
      {
        offset = acfg->unwind_info_offset;
        D.31781 = acfg->unwind_info_offsets;
        D.31782 = cache_index + 1;
        D.31783 = (long unsigned int) D.31782;
        D.31790 = (void *) D.31783;
        D.31791 = offset + 1;
        D.31792 = (long unsigned int) D.31791;
        D.31793 = (void *) D.31792;
        monoeg_g_hash_table_insert_replace (D.31781, D.31790, D.31793, 0);
        D.31794 = acfg->unwind_ops;
        D.31795 = (long unsigned int) cache_index;
        D.31796 = (void *) D.31795;
        monoeg_g_ptr_array_add (D.31794, D.31796);
        p = &buf;
        encoded_len.180 = (int) encoded_len;
        p.181 = p;
        encode_value (encoded_len.180, p.181, &p);
        D.31799 = acfg->unwind_info_offset;
        p.181 = p;
        p.182 = (long int) p.181;
        buf.183 = (long int) &buf;
        D.31802 = p.182 - buf.183;
        D.31803 = (unsigned int) D.31802;
        D.31804 = D.31803 + encoded_len;
        D.31805 = D.31799 + D.31804;
        acfg->unwind_info_offset = D.31805;
        D.31789 = offset;
        return D.31789;
      }
    finally
      {
        buf = {CLOBBER};
        p = {CLOBBER};
      }
  }
}


arch_emit_specific_trampoline (struct MonoAotCompile * acfg, int offset, int * tramp_size)
{
  int D.31808;
  _Bool D.31809;
  long int D.31810;
  long int D.31811;
  struct FILE * D.31814;
  unsigned int offset.184;
  unsigned int D.31816;
  int D.31817;
  int D.31818;
  unsigned int D.31819;
  unsigned int D.31820;
  int D.31821;
  guint8 buf[128];
  guint8 * code;

  try
    {
      *tramp_size = 4;
      code = &buf;
      D.31808 = acfg->use_bin_writer;
      D.31809 = D.31808 != 0;
      D.31810 = (long int) D.31809;
      D.31811 = __builtin_expect (D.31810, 0);
      if (D.31811 != 0) goto <D.31812>; else goto <D.31813>;
      <D.31812>:
      monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "aot-compiler.c", 1306, "!acfg->use_bin_writer");
      <D.31813>:
      emit_unset_mode (acfg);
      D.31814 = acfg->fp;
      fprintf (D.31814, "%s 0, %d(30)\n", "ld", 8);
      D.31814 = acfg->fp;
      offset.184 = (unsigned int) offset;
      D.31816 = offset.184 * 8;
      D.31817 = (int) D.31816;
      fprintf (D.31814, "lis 11, %d@h\n", D.31817);
      D.31814 = acfg->fp;
      offset.184 = (unsigned int) offset;
      D.31816 = offset.184 * 8;
      D.31817 = (int) D.31816;
      fprintf (D.31814, "ori 11, 11, %d@l\n", D.31817);
      D.31814 = acfg->fp;
      fprintf (D.31814, "%s 11, 11, 0\n", "ldx");
      D.31814 = acfg->fp;
      fprintf (D.31814, "%s 11, 0(11)\n", "ld");
      D.31814 = acfg->fp;
      fprintf (D.31814, "mtctr 11\n");
      D.31814 = acfg->fp;
      D.31818 = offset + 1;
      D.31819 = (unsigned int) D.31818;
      D.31820 = D.31819 * 8;
      D.31821 = (int) D.31820;
      fprintf (D.31814, "lis 11, %d@h\n", D.31821);
      D.31814 = acfg->fp;
      D.31818 = offset + 1;
      D.31819 = (unsigned int) D.31818;
      D.31820 = D.31819 * 8;
      D.31821 = (int) D.31820;
      fprintf (D.31814, "ori 11, 11, %d@l\n", D.31821);
      D.31814 = acfg->fp;
      fprintf (D.31814, "%s 0, 11, 0\n", "ldx");
      D.31814 = acfg->fp;
      fprintf (D.31814, "bctr\n");
      *tramp_size = 40;
    }
  finally
    {
      buf = {CLOBBER};
    }
}


arch_emit_static_rgctx_trampoline (struct MonoAotCompile * acfg, int offset, int * tramp_size)
{
  int D.31822;
  _Bool D.31823;
  long int D.31824;
  long int D.31825;
  struct FILE * D.31828;
  unsigned int offset.185;
  unsigned int D.31830;
  int D.31831;
  int D.31832;
  unsigned int D.31833;
  unsigned int D.31834;
  int D.31835;
  guint8 buf[128];
  guint8 * code;

  try
    {
      *tramp_size = 4;
      code = &buf;
      D.31822 = acfg->use_bin_writer;
      D.31823 = D.31822 != 0;
      D.31824 = (long int) D.31823;
      D.31825 = __builtin_expect (D.31824, 0);
      if (D.31825 != 0) goto <D.31826>; else goto <D.31827>;
      <D.31826>:
      monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "aot-compiler.c", 1538, "!acfg->use_bin_writer");
      <D.31827>:
      emit_unset_mode (acfg);
      D.31828 = acfg->fp;
      fprintf (D.31828, "%s 0, %d(30)\n", "ld", 8);
      D.31828 = acfg->fp;
      offset.185 = (unsigned int) offset;
      D.31830 = offset.185 * 8;
      D.31831 = (int) D.31830;
      fprintf (D.31828, "lis 11, %d@h\n", D.31831);
      D.31828 = acfg->fp;
      offset.185 = (unsigned int) offset;
      D.31830 = offset.185 * 8;
      D.31831 = (int) D.31830;
      fprintf (D.31828, "ori 11, 11, %d@l\n", D.31831);
      D.31828 = acfg->fp;
      fprintf (D.31828, "%s %d, 11, 0\n", "ldx", 12);
      D.31828 = acfg->fp;
      D.31832 = offset + 1;
      D.31833 = (unsigned int) D.31832;
      D.31834 = D.31833 * 8;
      D.31835 = (int) D.31834;
      fprintf (D.31828, "lis 11, %d@h\n", D.31835);
      D.31828 = acfg->fp;
      D.31832 = offset + 1;
      D.31833 = (unsigned int) D.31832;
      D.31834 = D.31833 * 8;
      D.31835 = (int) D.31834;
      fprintf (D.31828, "ori 11, 11, %d@l\n", D.31835);
      D.31828 = acfg->fp;
      fprintf (D.31828, "%s 11, 11, 0\n", "ldx");
      D.31828 = acfg->fp;
      fprintf (D.31828, "%s 2, %d(11)\n", "ld", 8);
      D.31828 = acfg->fp;
      fprintf (D.31828, "%s 11, 0(11)\n", "ld");
      D.31828 = acfg->fp;
      fprintf (D.31828, "mtctr 11\n");
      D.31828 = acfg->fp;
      fprintf (D.31828, "bctr\n");
      *tramp_size = 44;
    }
  finally
    {
      buf = {CLOBBER};
    }
}


arch_emit_imt_thunk (struct MonoAotCompile * acfg, int offset, int * tramp_size)
{
  long unsigned int D.31836;
  long unsigned int D.31837;
  long unsigned int D.31838;
  long unsigned int D.31839;
  short unsigned int D.31842;
  short unsigned int D.31843;
  int D.31844;
  int D.31845;
  unsigned int D.31846;
  unsigned int D.31847;
  unsigned int D.31848;
  unsigned int D.31849;
  unsigned int D.31850;
  unsigned int D.31851;
  unsigned int D.31852;
  unsigned int D.31853;
  long int D.31855;
  long int D.31856;
  unsigned long D.31857;
  unsigned long D.31858;
  unsigned int D.31861;
  unsigned int D.31862;
  unsigned int D.31863;
  short unsigned int D.31864;
  int D.31865;
  int D.31866;
  unsigned int D.31867;
  unsigned int D.31868;
  unsigned int D.31869;
  unsigned int D.31870;
  unsigned int D.31871;
  unsigned int D.31872;
  unsigned int D.31873;
  unsigned int D.31874;
  int D.31875;
  unsigned int D.31876;
  unsigned int D.31877;
  unsigned int D.31878;
  unsigned int D.31879;
  unsigned int D.31880;
  long int D.31882;
  unsigned long D.31883;
  unsigned long D.31884;
  long int D.31887;
  short unsigned int D.31888;
  int D.31889;
  int D.31890;
  unsigned int D.31891;
  unsigned int D.31892;
  unsigned int D.31893;
  unsigned int D.31894;
  unsigned int D.31895;
  unsigned int D.31896;
  unsigned int D.31897;
  unsigned int D.31898;
  long unsigned int D.31899;
  short unsigned int D.31900;
  int D.31901;
  int D.31902;
  unsigned int D.31903;
  unsigned int D.31904;
  unsigned int D.31905;
  unsigned int D.31906;
  unsigned int D.31907;
  unsigned int D.31908;
  unsigned int D.31909;
  unsigned int D.31910;
  long unsigned int D.31912;
  short unsigned int D.31913;
  int D.31914;
  int D.31915;
  unsigned int D.31916;
  unsigned int D.31917;
  unsigned int D.31918;
  unsigned int D.31919;
  unsigned int D.31920;
  unsigned int D.31921;
  unsigned int D.31922;
  unsigned int D.31923;
  long unsigned int D.31924;
  short unsigned int D.31925;
  int D.31926;
  int D.31927;
  unsigned int D.31928;
  unsigned int D.31929;
  unsigned int D.31930;
  unsigned int D.31931;
  unsigned int D.31932;
  unsigned int D.31933;
  unsigned int D.31934;
  unsigned int D.31935;
  guint8 * D.31936;
  guint8 * D.31937;
  guint8 * D.31938;
  guint8 * D.31939;
  long int code.186;
  long int buf.187;
  long int D.31942;
  int D.31943;
  guint8 buf[128];
  guint8 * code;
  guint8 * labels[16];

  try
    {
      code = &buf;
      MEM[(guint32 *)code] = 134250217;
      code = code + 4;
      D.31836 = (long unsigned int) offset;
      D.31837 = D.31836 * 8;
      D.31838 = D.31837 >> 15;
      D.31839 = D.31838 + 18446744073709551615;
      if (D.31839 > 18446744073709551613) goto <D.31840>; else goto <D.31841>;
      <D.31840>:
      D.31836 = (long unsigned int) offset;
      D.31842 = (short unsigned int) D.31836;
      D.31843 = D.31842 * 8;
      D.31844 = (int) D.31843;
      D.31845 = D.31844 | 939524096;
      D.31846 = (unsigned int) D.31845;
      D.31847 = D.31846 << 24;
      D.31836 = (long unsigned int) offset;
      D.31842 = (short unsigned int) D.31836;
      D.31843 = D.31842 * 8;
      D.31848 = (unsigned int) D.31843;
      D.31849 = D.31848 & 65280;
      D.31850 = D.31849 << 8;
      D.31851 = D.31847 | D.31850;
      D.31836 = (long unsigned int) offset;
      D.31842 = (short unsigned int) D.31836;
      D.31843 = D.31842 * 8;
      D.31844 = (int) D.31843;
      D.31845 = D.31844 | 939524096;
      D.31846 = (unsigned int) D.31845;
      D.31852 = D.31846 >> 24;
      D.31853 = D.31851 | D.31852;
      MEM[(guint32 *)code] = D.31853;
      code = code + 4;
      goto <D.31854>;
      <D.31841>:
      D.31836 = (long unsigned int) offset;
      D.31837 = D.31836 * 8;
      D.31855 = (long int) D.31837;
      D.31856 = D.31855 >> 31;
      D.31857 = (unsigned long) D.31856;
      D.31858 = D.31857 + 1;
      if (D.31858 <= 1) goto <D.31859>; else goto <D.31860>;
      <D.31859>:
      D.31836 = (long unsigned int) offset;
      D.31861 = (unsigned int) D.31836;
      D.31862 = D.31861 * 8;
      D.31863 = D.31862 >> 16;
      D.31864 = (short unsigned int) D.31863;
      D.31865 = (int) D.31864;
      D.31866 = D.31865 | 1006632960;
      D.31867 = (unsigned int) D.31866;
      D.31868 = D.31867 << 24;
      D.31836 = (long unsigned int) offset;
      D.31861 = (unsigned int) D.31836;
      D.31862 = D.31861 * 8;
      D.31863 = D.31862 >> 16;
      D.31864 = (short unsigned int) D.31863;
      D.31869 = (unsigned int) D.31864;
      D.31870 = D.31869 & 65280;
      D.31871 = D.31870 << 8;
      D.31872 = D.31868 | D.31871;
      D.31836 = (long unsigned int) offset;
      D.31861 = (unsigned int) D.31836;
      D.31862 = D.31861 * 8;
      D.31863 = D.31862 >> 16;
      D.31864 = (short unsigned int) D.31863;
      D.31865 = (int) D.31864;
      D.31866 = D.31865 | 1006632960;
      D.31867 = (unsigned int) D.31866;
      D.31873 = D.31867 >> 24;
      D.31874 = D.31872 | D.31873;
      MEM[(guint32 *)code] = D.31874;
      code = code + 4;
      D.31836 = (long unsigned int) offset;
      D.31842 = (short unsigned int) D.31836;
      D.31843 = D.31842 * 8;
      D.31844 = (int) D.31843;
      D.31875 = D.31844 | 1610612736;
      D.31876 = (unsigned int) D.31875;
      D.31877 = D.31876 << 24;
      D.31836 = (long unsigned int) offset;
      D.31842 = (short unsigned int) D.31836;
      D.31843 = D.31842 * 8;
      D.31848 = (unsigned int) D.31843;
      D.31849 = D.31848 & 65280;
      D.31850 = D.31849 << 8;
      D.31878 = D.31877 | D.31850;
      D.31836 = (long unsigned int) offset;
      D.31842 = (short unsigned int) D.31836;
      D.31843 = D.31842 * 8;
      D.31844 = (int) D.31843;
      D.31875 = D.31844 | 1610612736;
      D.31876 = (unsigned int) D.31875;
      D.31879 = D.31876 >> 24;
      D.31880 = D.31878 | D.31879;
      MEM[(guint32 *)code] = D.31880;
      code = code + 4;
      goto <D.31881>;
      <D.31860>:
      D.31836 = (long unsigned int) offset;
      D.31837 = D.31836 * 8;
      D.31855 = (long int) D.31837;
      D.31882 = D.31855 >> 47;
      D.31883 = (unsigned long) D.31882;
      D.31884 = D.31883 + 1;
      if (D.31884 <= 1) goto <D.31885>; else goto <D.31886>;
      <D.31885>:
      D.31836 = (long unsigned int) offset;
      D.31837 = D.31836 * 8;
      D.31855 = (long int) D.31837;
      D.31887 = D.31855 >> 32;
      D.31888 = (short unsigned int) D.31887;
      D.31889 = (int) D.31888;
      D.31890 = D.31889 | 939524096;
      D.31891 = (unsigned int) D.31890;
      D.31892 = D.31891 << 24;
      D.31836 = (long unsigned int) offset;
      D.31837 = D.31836 * 8;
      D.31855 = (long int) D.31837;
      D.31887 = D.31855 >> 32;
      D.31888 = (short unsigned int) D.31887;
      D.31893 = (unsigned int) D.31888;
      D.31894 = D.31893 & 65280;
      D.31895 = D.31894 << 8;
      D.31896 = D.31892 | D.31895;
      D.31836 = (long unsigned int) offset;
      D.31837 = D.31836 * 8;
      D.31855 = (long int) D.31837;
      D.31887 = D.31855 >> 32;
      D.31888 = (short unsigned int) D.31887;
      D.31889 = (int) D.31888;
      D.31890 = D.31889 | 939524096;
      D.31891 = (unsigned int) D.31890;
      D.31897 = D.31891 >> 24;
      D.31898 = D.31896 | D.31897;
      MEM[(guint32 *)code] = D.31898;
      code = code + 4;
      MEM[(guint32 *)code] = 3322347640;
      code = code + 4;
      D.31836 = (long unsigned int) offset;
      D.31837 = D.31836 * 8;
      D.31899 = D.31837 >> 16;
      D.31900 = (short unsigned int) D.31899;
      D.31901 = (int) D.31900;
      D.31902 = D.31901 | 1677721600;
      D.31903 = (unsigned int) D.31902;
      D.31904 = D.31903 << 24;
      D.31836 = (long unsigned int) offset;
      D.31837 = D.31836 * 8;
      D.31899 = D.31837 >> 16;
      D.31900 = (short unsigned int) D.31899;
      D.31905 = (unsigned int) D.31900;
      D.31906 = D.31905 & 65280;
      D.31907 = D.31906 << 8;
      D.31908 = D.31904 | D.31907;
      D.31836 = (long unsigned int) offset;
      D.31837 = D.31836 * 8;
      D.31899 = D.31837 >> 16;
      D.31900 = (short unsigned int) D.31899;
      D.31901 = (int) D.31900;
      D.31902 = D.31901 | 1677721600;
      D.31903 = (unsigned int) D.31902;
      D.31909 = D.31903 >> 24;
      D.31910 = D.31908 | D.31909;
      MEM[(guint32 *)code] = D.31910;
      code = code + 4;
      D.31836 = (long unsigned int) offset;
      D.31842 = (short unsigned int) D.31836;
      D.31843 = D.31842 * 8;
      D.31844 = (int) D.31843;
      D.31875 = D.31844 | 1610612736;
      D.31876 = (unsigned int) D.31875;
      D.31877 = D.31876 << 24;
      D.31836 = (long unsigned int) offset;
      D.31842 = (short unsigned int) D.31836;
      D.31843 = D.31842 * 8;
      D.31848 = (unsigned int) D.31843;
      D.31849 = D.31848 & 65280;
      D.31850 = D.31849 << 8;
      D.31878 = D.31877 | D.31850;
      D.31836 = (long unsigned int) offset;
      D.31842 = (short unsigned int) D.31836;
      D.31843 = D.31842 * 8;
      D.31844 = (int) D.31843;
      D.31875 = D.31844 | 1610612736;
      D.31876 = (unsigned int) D.31875;
      D.31879 = D.31876 >> 24;
      D.31880 = D.31878 | D.31879;
      MEM[(guint32 *)code] = D.31880;
      code = code + 4;
      goto <D.31911>;
      <D.31886>:
      D.31836 = (long unsigned int) offset;
      D.31837 = D.31836 * 8;
      D.31912 = D.31837 >> 48;
      D.31913 = (short unsigned int) D.31912;
      D.31914 = (int) D.31913;
      D.31915 = D.31914 | 1006632960;
      D.31916 = (unsigned int) D.31915;
      D.31917 = D.31916 << 24;
      D.31836 = (long unsigned int) offset;
      D.31837 = D.31836 * 8;
      D.31912 = D.31837 >> 48;
      D.31913 = (short unsigned int) D.31912;
      D.31918 = (unsigned int) D.31913;
      D.31919 = D.31918 & 65280;
      D.31920 = D.31919 << 8;
      D.31921 = D.31917 | D.31920;
      D.31836 = (long unsigned int) offset;
      D.31837 = D.31836 * 8;
      D.31912 = D.31837 >> 48;
      D.31913 = (short unsigned int) D.31912;
      D.31914 = (int) D.31913;
      D.31915 = D.31914 | 1006632960;
      D.31916 = (unsigned int) D.31915;
      D.31922 = D.31916 >> 24;
      D.31923 = D.31921 | D.31922;
      MEM[(guint32 *)code] = D.31923;
      code = code + 4;
      D.31836 = (long unsigned int) offset;
      D.31837 = D.31836 * 8;
      D.31924 = D.31837 >> 32;
      D.31925 = (short unsigned int) D.31924;
      D.31926 = (int) D.31925;
      D.31927 = D.31926 | 1610612736;
      D.31928 = (unsigned int) D.31927;
      D.31929 = D.31928 << 24;
      D.31836 = (long unsigned int) offset;
      D.31837 = D.31836 * 8;
      D.31924 = D.31837 >> 32;
      D.31925 = (short unsigned int) D.31924;
      D.31930 = (unsigned int) D.31925;
      D.31931 = D.31930 & 65280;
      D.31932 = D.31931 << 8;
      D.31933 = D.31929 | D.31932;
      D.31836 = (long unsigned int) offset;
      D.31837 = D.31836 * 8;
      D.31924 = D.31837 >> 32;
      D.31925 = (short unsigned int) D.31924;
      D.31926 = (int) D.31925;
      D.31927 = D.31926 | 1610612736;
      D.31928 = (unsigned int) D.31927;
      D.31934 = D.31928 >> 24;
      D.31935 = D.31933 | D.31934;
      MEM[(guint32 *)code] = D.31935;
      code = code + 4;
      MEM[(guint32 *)code] = 3322347640;
      code = code + 4;
      D.31836 = (long unsigned int) offset;
      D.31837 = D.31836 * 8;
      D.31899 = D.31837 >> 16;
      D.31900 = (short unsigned int) D.31899;
      D.31901 = (int) D.31900;
      D.31902 = D.31901 | 1677721600;
      D.31903 = (unsigned int) D.31902;
      D.31904 = D.31903 << 24;
      D.31836 = (long unsigned int) offset;
      D.31837 = D.31836 * 8;
      D.31899 = D.31837 >> 16;
      D.31900 = (short unsigned int) D.31899;
      D.31905 = (unsigned int) D.31900;
      D.31906 = D.31905 & 65280;
      D.31907 = D.31906 << 8;
      D.31908 = D.31904 | D.31907;
      D.31836 = (long unsigned int) offset;
      D.31837 = D.31836 * 8;
      D.31899 = D.31837 >> 16;
      D.31900 = (short unsigned int) D.31899;
      D.31901 = (int) D.31900;
      D.31902 = D.31901 | 1677721600;
      D.31903 = (unsigned int) D.31902;
      D.31909 = D.31903 >> 24;
      D.31910 = D.31908 | D.31909;
      MEM[(guint32 *)code] = D.31910;
      code = code + 4;
      D.31836 = (long unsigned int) offset;
      D.31842 = (short unsigned int) D.31836;
      D.31843 = D.31842 * 8;
      D.31844 = (int) D.31843;
      D.31875 = D.31844 | 1610612736;
      D.31876 = (unsigned int) D.31875;
      D.31877 = D.31876 << 24;
      D.31836 = (long unsigned int) offset;
      D.31842 = (short unsigned int) D.31836;
      D.31843 = D.31842 * 8;
      D.31848 = (unsigned int) D.31843;
      D.31849 = D.31848 & 65280;
      D.31850 = D.31849 << 8;
      D.31878 = D.31877 | D.31850;
      D.31836 = (long unsigned int) offset;
      D.31842 = (short unsigned int) D.31836;
      D.31843 = D.31842 * 8;
      D.31844 = (int) D.31843;
      D.31875 = D.31844 | 1610612736;
      D.31876 = (unsigned int) D.31875;
      D.31879 = D.31876 >> 24;
      D.31880 = D.31878 | D.31879;
      MEM[(guint32 *)code] = D.31880;
      code = code + 4;
      <D.31911>:
      <D.31881>:
      <D.31854>:
      MEM[(guint32 *)code] = 704670589;
      code = code + 4;
      labels[1] = code;
      MEM[(guint32 *)code] = 3048;
      code = code + 4;
      MEM[(guint32 *)code] = 6299772;
      code = code + 4;
      labels[2] = code;
      MEM[(guint32 *)code] = 33345;
      code = code + 4;
      MEM[(guint32 *)code] = 16777260;
      code = code + 4;
      labels[3] = code;
      MEM[(guint32 *)code] = 33345;
      code = code + 4;
      MEM[(guint32 *)code] = 268462905;
      code = code + 4;
      labels[4] = code;
      MEM[(guint32 *)code] = 72;
      code = code + 4;
      D.31936 = labels[4];
      D.31937 = labels[1];
      mono_ppc_patch (D.31936, D.31937);
      D.31938 = labels[2];
      mono_ppc_patch (D.31938, code);
      MEM[(guint32 *)code] = 134245353;
      code = code + 4;
      MEM[(guint32 *)code] = 27625;
      code = code + 4;
      MEM[(guint32 *)code] = 2785241469;
      code = code + 4;
      MEM[(guint32 *)code] = 537165902;
      code = code + 4;
      D.31939 = labels[3];
      mono_ppc_patch (D.31939, code);
      MEM[(guint32 *)code] = 134275199;
      code = code + 4;
      code.186 = (long int) code;
      buf.187 = (long int) &buf;
      D.31942 = code.186 - buf.187;
      D.31943 = (int) D.31942;
      *tramp_size = D.31943;
      code.186 = (long int) code;
      buf.187 = (long int) &buf;
      D.31942 = code.186 - buf.187;
      D.31943 = (int) D.31942;
      emit_bytes (acfg, &buf, D.31943);
    }
  finally
    {
      buf = {CLOBBER};
      labels = {CLOBBER};
    }
}


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.31944;
  <unnamed-unsigned:24> D.31945;
  int D.31946;
  double D.31947;
  double D.31948;
  int D.31949;
  unsigned int D.31950;
  unsigned int D.31951;
  unsigned int table_size.188;
  int D.31953;
  int D.31954;
  struct MonoType * D.31957;
  unsigned int D.31958;
  void * * D.31959;
  long unsigned int D.31960;
  long unsigned int D.31961;
  void * * D.31962;
  struct ClassNameTableEntry * D.31966;
  unsigned int D.31967;
  _Bool D.31968;
  long int D.31969;
  long int D.31970;
  _Bool D.31973;
  long int D.31974;
  long int D.31975;
  long unsigned int D.31978;
  long unsigned int D.31979;
  void * * D.31980;
  unsigned int D.31984;
  int D.31985;
  int D.31986;
  struct ClassNameTableEntry * D.31987;
  unsigned int D.31990;
  int D.31991;
  unsigned int i.189;
  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.31944 = acfg->image;
      D.31945 = D.31944->tables[2].rows;
      D.31946 = (int) D.31945;
      D.31947 = (double) D.31946;
      D.31948 = D.31947 * 1.5e+0;
      D.31949 = (int) D.31948;
      D.31950 = (unsigned int) D.31949;
      D.31951 = monoeg_g_spaced_primes_closest (D.31950);
      table_size = (int) D.31951;
      table_size.188 = (unsigned int) table_size;
      table = monoeg_g_ptr_array_sized_new (table_size.188);
      i = 0;
      goto <D.26249>;
      <D.26248>:
      monoeg_g_ptr_array_add (table, 0B);
      i = i + 1;
      <D.26249>:
      if (i < table_size) goto <D.26248>; else goto <D.26250>;
      <D.26250>:
      i = 0;
      goto <D.26256>;
      <D.26255>:
      D.31953 = i + 1;
      D.31954 = D.31953 | 33554432;
      token = (guint32) D.31954;
      D.31944 = acfg->image;
      klass = mono_class_get (D.31944, token);
      if (klass == 0B) goto <D.31955>; else goto <D.31956>;
      <D.31955>:
      mono_loader_clear_error ();
      // predicted unlikely by continue predictor.
      goto <D.26251>;
      <D.31956>:
      D.31957 = mono_class_get_type (klass);
      full_name = mono_type_get_name_full (D.31957, 2);
      D.31958 = mono_metadata_str_hash (full_name);
      table_size.188 = (unsigned int) table_size;
      hash = D.31958 % table_size.188;
      monoeg_g_free (full_name);
      new_entry = monoeg_malloc0 (16);
      new_entry->token = token;
      D.31959 = table->pdata;
      D.31960 = (long unsigned int) hash;
      D.31961 = D.31960 * 8;
      D.31962 = D.31959 + D.31961;
      entry = *D.31962;
      if (entry == 0B) goto <D.31963>; else goto <D.31964>;
      <D.31963>:
      new_entry->index = hash;
      D.31959 = table->pdata;
      D.31960 = (long unsigned int) hash;
      D.31961 = D.31960 * 8;
      D.31962 = D.31959 + D.31961;
      *D.31962 = new_entry;
      goto <D.31965>;
      <D.31964>:
      goto <D.26253>;
      <D.26252>:
      entry = entry->next;
      <D.26253>:
      D.31966 = entry->next;
      if (D.31966 != 0B) goto <D.26252>; else goto <D.26254>;
      <D.26254>:
      entry->next = new_entry;
      D.31967 = table->len;
      new_entry->index = D.31967;
      monoeg_g_ptr_array_add (table, new_entry);
      <D.31965>:
      <D.26251>:
      i = i + 1;
      <D.26256>:
      D.31944 = acfg->image;
      D.31945 = D.31944->tables[2].rows;
      D.31946 = (int) D.31945;
      if (D.31946 > i) goto <D.26255>; else goto <D.26257>;
      <D.26257>:
      sprintf (&symbol, "class_name_table");
      emit_section_change (acfg, ".rodata", 0);
      emit_alignment (acfg, 8);
      emit_label (acfg, &symbol);
      D.31968 = table_size > 64999;
      D.31969 = (long int) D.31968;
      D.31970 = __builtin_expect (D.31969, 0);
      if (D.31970 != 0) goto <D.31971>; else goto <D.31972>;
      <D.31971>:
      monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "aot-compiler.c", 7744, "table_size < 65000");
      <D.31972>:
      emit_int16 (acfg, table_size);
      D.31967 = table->len;
      D.31973 = D.31967 > 64999;
      D.31974 = (long int) D.31973;
      D.31975 = __builtin_expect (D.31974, 0);
      if (D.31975 != 0) goto <D.31976>; else goto <D.31977>;
      <D.31976>:
      monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "aot-compiler.c", 7746, "table->len < 65000");
      <D.31977>:
      i = 0;
      goto <D.26260>;
      <D.26259>:
      {
        struct ClassNameTableEntry * entry;

        D.31959 = table->pdata;
        D.31978 = (long unsigned int) i;
        D.31979 = D.31978 * 8;
        D.31980 = D.31959 + D.31979;
        entry = *D.31980;
        if (entry == 0B) goto <D.31981>; else goto <D.31982>;
        <D.31981>:
        emit_int16 (acfg, 0);
        emit_int16 (acfg, 0);
        goto <D.31983>;
        <D.31982>:
        D.31984 = entry->token;
        D.31985 = (int) D.31984;
        D.31986 = D.31985 & 16777215;
        emit_int16 (acfg, D.31986);
        D.31987 = entry->next;
        if (D.31987 != 0B) goto <D.31988>; else goto <D.31989>;
        <D.31988>:
        D.31987 = entry->next;
        D.31990 = D.31987->index;
        D.31991 = (int) D.31990;
        emit_int16 (acfg, D.31991);
        goto <D.31992>;
        <D.31989>:
        emit_int16 (acfg, 0);
        <D.31992>:
        <D.31983>:
      }
      i = i + 1;
      <D.26260>:
      i.189 = (unsigned int) i;
      D.31967 = table->len;
      if (i.189 < D.31967) goto <D.26259>; else goto <D.26261>;
      <D.26261>:
    }
  finally
    {
      symbol = {CLOBBER};
    }
}


emit_got_info (struct MonoAotCompile * acfg)
{
  unsigned int D.31994;
  struct GPtrArray * D.31995;
  unsigned int D.31996;
  struct GHashTable * D.31997;
  long unsigned int D.31998;
  const void * D.31999;
  struct MonoJumpInfo * D.32000;
  <unnamed type> D.32001;
  int D.32002;
  int D.32003;
  unsigned int i.190;
  unsigned int D.32005;
  unsigned int D.32006;
  unsigned int D.32007;
  struct MonoMemPool * D.32008;
  unsigned int buf_size.191;
  unsigned int D.32010;
  unsigned int D.32011;
  void * D.32012;
  guint32 * D.32015;
  void * * D.32016;
  long unsigned int D.32017;
  void * * D.32018;
  <unnamed type> D.32019;
  int D.32020;
  guint8 * p.192;
  int D.32022;
  unsigned int D.32023;
  long int p.193;
  long int p2.194;
  long int D.32026;
  unsigned int D.32027;
  unsigned int D.32028;
  int D.32029;
  long int buf.195;
  long int D.32031;
  long int D.32032;
  _Bool D.32033;
  long int D.32034;
  long int D.32035;
  long unsigned int D.32038;
  guint32 * D.32039;
  unsigned int D.32040;
  unsigned int D.32041;
  int D.32044;
  sizetype D.32045;
  sizetype D.32046;
  sizetype D.32047;
  guint32 * D.32048;
  unsigned int D.32049;
  int D.32050;
  unsigned int D.32051;
  unsigned int D.32052;
  unsigned int D.32053;
  int D.32054;
  unsigned int i.196;
  unsigned int D.32056;
  int D.32057;
  unsigned int D.32058;
  unsigned int D.32059;
  int D.32060;
  char symbol[256];
  int i;
  int first_plt_got_patch;
  int buf_size;
  guint8 * p;
  guint8 * buf;
  guint32 * got_info_offsets;

  try
    {
      D.31994 = acfg->got_offset;
      acfg->plt_got_offset_base = D.31994;
      D.31995 = acfg->got_patches;
      D.31996 = D.31995->len;
      first_plt_got_patch = (int) D.31996;
      i = 1;
      goto <D.26284>;
      <D.26283>:
      {
        struct MonoPltEntry * plt_entry;

        D.31997 = acfg->plt_offset_to_entry;
        D.31998 = (long unsigned int) i;
        D.31999 = (const void *) D.31998;
        plt_entry = monoeg_g_hash_table_lookup (D.31997, D.31999);
        D.31995 = acfg->got_patches;
        D.32000 = plt_entry->ji;
        monoeg_g_ptr_array_add (D.31995, D.32000);
        D.32000 = plt_entry->ji;
        D.32001 = D.32000->type;
        D.32002 = acfg->stats.got_slot_types[D.32001];
        D.32003 = D.32002 + 1;
        acfg->stats.got_slot_types[D.32001] = D.32003;
      }
      i = i + 1;
      <D.26284>:
      i.190 = (unsigned int) i;
      D.32005 = acfg->plt_offset;
      if (i.190 < D.32005) goto <D.26283>; else goto <D.26285>;
      <D.26285>:
      D.31994 = acfg->got_offset;
      D.32005 = acfg->plt_offset;
      D.32006 = D.31994 + D.32005;
      acfg->got_offset = D.32006;
      D.31995 = acfg->got_patches;
      D.31996 = D.31995->len;
      D.32007 = D.31996 * 128;
      buf_size = (int) D.32007;
      D.32008 = acfg->mempool;
      buf_size.191 = (unsigned int) buf_size;
      buf = mono_mempool_alloc (D.32008, buf_size.191);
      p = buf;
      D.32008 = acfg->mempool;
      D.31995 = acfg->got_patches;
      D.31996 = D.31995->len;
      D.32010 = D.31996 * 4;
      got_info_offsets = mono_mempool_alloc (D.32008, D.32010);
      D.32008 = acfg->mempool;
      D.32005 = acfg->plt_offset;
      D.32011 = D.32005 * 4;
      D.32012 = mono_mempool_alloc (D.32008, D.32011);
      acfg->plt_got_info_offsets = D.32012;
      D.32005 = acfg->plt_offset;
      if (D.32005 != 0) goto <D.32013>; else goto <D.32014>;
      <D.32013>:
      D.32015 = acfg->plt_got_info_offsets;
      *D.32015 = 0;
      <D.32014>:
      i = 0;
      goto <D.26289>;
      <D.26288>:
      {
        struct MonoJumpInfo * ji;
        guint8 * p2;

        D.31995 = acfg->got_patches;
        D.32016 = D.31995->pdata;
        D.31998 = (long unsigned int) i;
        D.32017 = D.31998 * 8;
        D.32018 = D.32016 + D.32017;
        ji = *D.32018;
        p = buf;
        D.32019 = ji->type;
        D.32020 = (int) D.32019;
        p.192 = p;
        encode_value (D.32020, p.192, &p);
        p2 = p;
        p.192 = p;
        encode_patch (acfg, ji, p.192, &p);
        D.32019 = ji->type;
        D.32019 = ji->type;
        D.32022 = acfg->stats.got_slot_info_sizes[D.32019];
        D.32023 = (unsigned int) D.32022;
        p.192 = p;
        p.193 = (long int) p.192;
        p2.194 = (long int) p2;
        D.32026 = p.193 - p2.194;
        D.32027 = (unsigned int) D.32026;
        D.32028 = D.32023 + D.32027;
        D.32029 = (int) D.32028;
        acfg->stats.got_slot_info_sizes[D.32019] = D.32029;
        p.192 = p;
        p.193 = (long int) p.192;
        buf.195 = (long int) buf;
        D.32031 = p.193 - buf.195;
        D.32032 = (long int) buf_size;
        D.32033 = D.32031 > D.32032;
        D.32034 = (long int) D.32033;
        D.32035 = __builtin_expect (D.32034, 0);
        if (D.32035 != 0) goto <D.32036>; else goto <D.32037>;
        <D.32036>:
        monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "aot-compiler.c", 7851, "p - buf <= buf_size");
        <D.32037>:
        D.31998 = (long unsigned int) i;
        D.32038 = D.31998 * 4;
        D.32039 = got_info_offsets + D.32038;
        p.192 = p;
        p.193 = (long int) p.192;
        buf.195 = (long int) buf;
        D.32031 = p.193 - buf.195;
        D.32040 = (unsigned int) D.32031;
        D.32041 = add_to_blob (acfg, buf, D.32040);
        *D.32039 = D.32041;
        if (i >= first_plt_got_patch) goto <D.32042>; else goto <D.32043>;
        <D.32042>:
        D.32015 = acfg->plt_got_info_offsets;
        D.32044 = i - first_plt_got_patch;
        D.32045 = (sizetype) D.32044;
        D.32046 = D.32045 + 1;
        D.32047 = D.32046 * 4;
        D.32048 = D.32015 + D.32047;
        D.31998 = (long unsigned int) i;
        D.32038 = D.31998 * 4;
        D.32039 = got_info_offsets + D.32038;
        D.32049 = *D.32039;
        *D.32048 = D.32049;
        <D.32043>:
        D.32050 = acfg->stats.got_info_size;
        D.32051 = (unsigned int) D.32050;
        p.192 = p;
        p.193 = (long int) p.192;
        buf.195 = (long int) buf;
        D.32031 = p.193 - buf.195;
        D.32052 = (unsigned int) D.32031;
        D.32053 = D.32051 + D.32052;
        D.32054 = (int) D.32053;
        acfg->stats.got_info_size = D.32054;
      }
      i = i + 1;
      <D.26289>:
      i.196 = (unsigned int) i;
      D.31995 = acfg->got_patches;
      D.31996 = D.31995->len;
      if (i.196 < D.31996) goto <D.26288>; else goto <D.26290>;
      <D.26290>:
      sprintf (&symbol, "got_info_offsets");
      emit_section_change (acfg, ".rodata", 1);
      emit_alignment (acfg, 8);
      emit_label (acfg, &symbol);
      D.32056 = emit_offset_table (acfg, first_plt_got_patch, 10, got_info_offsets);
      D.32057 = acfg->stats.offsets_size;
      D.32058 = (unsigned int) D.32057;
      D.32059 = D.32058 + D.32056;
      D.32060 = (int) D.32059;
      acfg->stats.offsets_size = D.32060;
    }
  finally
    {
      symbol = {CLOBBER};
      p = {CLOBBER};
    }
}


encode_patch (struct MonoAotCompile * acfg, struct MonoJumpInfo * patch_info, guint8 * buf, guint8 * * endbuf)
{
  <unnamed type> D.32061;
  struct MonoImage * D.32062;
  unsigned int D.32063;
  int D.32064;
  guint8 * p.197;
  long int D.32066;
  int D.32067;
  struct MonoJumpInfoBBTable * D.32068;
  int D.32069;
  long unsigned int D.32070;
  long unsigned int D.32071;
  void * * D.32072;
  void * D.32073;
  long int D.32074;
  int D.32075;
  struct MonoMethod * D.32076;
  const char * D.32077;
  long unsigned int D.32078;
  int len.198;
  long unsigned int D.32080;
  sizetype D.32081;
  guint8 * p.199;
  guint8 * p.200;
  guint8 * p.201;
  struct MonoJumpInfoToken * D.32085;
  struct MonoImage * D.32086;
  unsigned int D.32087;
  _Bool D.32088;
  long int D.32089;
  long int D.32090;
  int image_index.202;
  unsigned int D.32094;
  unsigned int D.32095;
  int D.32096;
  unsigned int D.32097;
  int D.32098;
  int D.32099;
  int D.32100;
  struct MonoGenericContext * D.32103;
  struct MonoClass * D.32104;
  struct MonoImage * D.32105;
  const void * D.32106;
  _Bool D.32107;
  long int D.32108;
  long int D.32109;
  unsigned int D.32112;
  int D.32113;
  guint32 * D.32114;
  unsigned int D.32115;
  int D.32116;
  struct MonoClass * D.32117;
  struct MonoClassField * D.32118;
  struct GHashTable * D.32119;
  struct MonoMethod * D.32120;
  void * D.32121;
  long int D.32122;
  guint8 * p2.203;
  long int p2.204;
  long int buf2.205;
  long int D.32128;
  _Bool D.32129;
  long int D.32130;
  long int D.32131;
  unsigned int D.32134;
  unsigned int D.32135;
  long unsigned int D.32136;
  void * D.32137;
  int offset.206;
  <unnamed type> D.32140;
  int D.32141;
  _Bool D.32142;
  long int D.32143;
  long int D.32144;
  struct MonoJumpInfo * D.32147;
  <unnamed type> D.32148;
  _Bool D.32149;
  long int D.32150;
  long int D.32151;
  unsigned int iftmp.207;
  int D.32155;
  unsigned int D.32159;
  unsigned int D.32160;
  unsigned int D.32161;
  unsigned int D.32162;
  int D.32163;
  struct MonoJumpInfoImtTramp * D.32164;
  struct MonoMethod * D.32165;
  int D.32166;
  long int D.32167;
  int D.32168;
  struct MonoJumpInfoGSharedVtCall * D.32169;
  struct MonoMethodSignature * D.32170;
  struct MonoMethod * D.32171;
  struct MonoMethod * D.32172;
  struct GPtrArray * D.32173;
  unsigned int D.32174;
  int D.32175;
  void * * D.32176;
  long unsigned int D.32177;
  long unsigned int D.32178;
  void * * D.32179;
  <unnamed type> D.32180;
  int D.32181;
  <unnamed type> D.32182;
  void * D.32183;
  struct MonoClass * D.32184;
  unsigned int i.208;
  guint8 * p;

  try
    {
      p = buf;
      D.32061 = patch_info->type;
      switch (D.32061) <default: <D.25452>, case 3: <D.25400>, case 4: <D.25401>, case 5: <D.25392>, case 6: <D.25399>, case 7: <D.25405>, case 8: <D.25393>, case 10: <D.25415>, case 11: <D.25420>, case 12: <D.25387>, case 13: <D.25425>, case 14: <D.25419>, case 15: <D.25423>, case 16: <D.25426>, case 17: <D.25408>, case 18: <D.25413>, case 19: <D.25414>, case 20: <D.25417>, case 21: <D.25418>, case 23: <D.25421>, case 24: <D.25422>, case 28: <D.25412>, case 29: <D.25411>, case 30: <D.25424>, case 31: <D.25402>, case 32: <D.25406>, case 33: <D.25427>, case 34: <D.25403>, case 35: <D.25428>, case 36: <D.25433>, case 37: <D.25434>, case 38: <D.25435>, case 39: <D.25388>, case 40: <D.25436>, case 41: <D.25437>, case 42: <D.25390>, case 43: <D.25391>, case 44: <D.25438>, case 45: <D.25440>, case 46: <D.25441>, case 47: <D.25389>, case 48: <D.25439>, case 50: <D.25404>, case 51: <D.25385>>
      <D.25385>:
      goto <D.25386>;
      <D.25387>:
      D.32062 = patch_info->data.image;
      D.32063 = get_image_index (acfg, D.32062);
      D.32064 = (int) D.32063;
      p.197 = p;
      encode_value (D.32064, p.197, &p);
      goto <D.25386>;
      <D.25388>:
      <D.25389>:
      <D.25390>:
      <D.25391>:
      goto <D.25386>;
      <D.25392>:
      D.32066 = patch_info->data.offset;
      D.32067 = (int) D.32066;
      p.197 = p;
      encode_value (D.32067, p.197, &p);
      goto <D.25386>;
      <D.25393>:
      {
        void * * table;
        int k;

        D.32068 = patch_info->data.table;
        table = D.32068->table;
        D.32068 = patch_info->data.table;
        D.32069 = D.32068->table_size;
        p.197 = p;
        encode_value (D.32069, p.197, &p);
        k = 0;
        goto <D.25397>;
        <D.25396>:
        D.32070 = (long unsigned int) k;
        D.32071 = D.32070 * 8;
        D.32072 = table + D.32071;
        D.32073 = *D.32072;
        D.32074 = (long int) D.32073;
        D.32075 = (int) D.32074;
        p.197 = p;
        encode_value (D.32075, p.197, &p);
        k = k + 1;
        <D.25397>:
        D.32068 = patch_info->data.table;
        D.32069 = D.32068->table_size;
        if (D.32069 > k) goto <D.25396>; else goto <D.25398>;
        <D.25398>:
        goto <D.25386>;
      }
      <D.25399>:
      <D.25400>:
      <D.25401>:
      <D.25402>:
      <D.25403>:
      <D.25404>:
      D.32076 = patch_info->data.method;
      p.197 = p;
      encode_method_ref (acfg, D.32076, p.197, &p);
      goto <D.25386>;
      <D.25405>:
      <D.25406>:
      {
        guint32 len;

        D.32077 = patch_info->data.name;
        D.32078 = strlen (D.32077);
        len = (guint32) D.32078;
        len.198 = (int) len;
        p.197 = p;
        encode_value (len.198, p.197, &p);
        p.197 = p;
        D.32077 = patch_info->data.name;
        D.32080 = (long unsigned int) len;
        memcpy (p.197, D.32077, D.32080);
        p.197 = p;
        D.32081 = (sizetype) len;
        p.199 = p.197 + D.32081;
        p = p.199;
        p.197 = p;
        p.200 = p.197;
        p.201 = p.200 + 1;
        p = p.201;
        *p.200 = 0;
        goto <D.25386>;
      }
      <D.25408>:
      {
        guint32 image_index;
        guint32 token;

        D.32085 = patch_info->data.token;
        D.32086 = D.32085->image;
        image_index = get_image_index (acfg, D.32086);
        D.32085 = patch_info->data.token;
        token = D.32085->token;
        D.32087 = token & 4278190080;
        D.32088 = D.32087 != 1879048192;
        D.32089 = (long int) D.32088;
        D.32090 = __builtin_expect (D.32089, 0);
        if (D.32090 != 0) goto <D.32091>; else goto <D.32092>;
        <D.32091>:
        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.32092>:
        image_index.202 = (int) image_index;
        p.197 = p;
        encode_value (image_index.202, p.197, &p);
        D.32085 = patch_info->data.token;
        D.32094 = D.32085->token;
        D.32095 = D.32094 + 2415919104;
        D.32096 = (int) D.32095;
        p.197 = p;
        encode_value (D.32096, p.197, &p);
        goto <D.25386>;
      }
      <D.25411>:
      <D.25412>:
      <D.25413>:
      <D.25414>:
      D.32085 = patch_info->data.token;
      D.32086 = D.32085->image;
      D.32097 = get_image_index (acfg, D.32086);
      D.32098 = (int) D.32097;
      p.197 = p;
      encode_value (D.32098, p.197, &p);
      D.32085 = patch_info->data.token;
      D.32094 = D.32085->token;
      D.32099 = (int) D.32094;
      p.197 = p;
      encode_value (D.32099, p.197, &p);
      D.32085 = patch_info->data.token;
      D.32100 = D.32085->has_context;
      p.197 = p;
      encode_value (D.32100, p.197, &p);
      D.32085 = patch_info->data.token;
      D.32100 = D.32085->has_context;
      if (D.32100 != 0) goto <D.32101>; else goto <D.32102>;
      <D.32101>:
      D.32085 = patch_info->data.token;
      D.32103 = &D.32085->context;
      p.197 = p;
      encode_generic_context (acfg, D.32103, p.197, &p);
      <D.32102>:
      goto <D.25386>;
      <D.25415>:
      {
        struct MonoClass * ex_class;

        D.32104 = mono_defaults.exception_class;
        D.32105 = D.32104->image;
        D.32106 = patch_info->data.target;
        ex_class = mono_class_from_name (D.32105, "System", D.32106);
        D.32107 = ex_class == 0B;
        D.32108 = (long int) D.32107;
        D.32109 = __builtin_expect (D.32108, 0);
        if (D.32109 != 0) goto <D.32110>; else goto <D.32111>;
        <D.32110>:
        monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "aot-compiler.c", 4948, "ex_class");
        <D.32111>:
        p.197 = p;
        encode_klass_ref (acfg, ex_class, p.197, &p);
        goto <D.25386>;
      }
      <D.25417>:
      D.32106 = patch_info->data.target;
      D.32112 = MEM[(guint32 *)D.32106];
      D.32113 = (int) D.32112;
      p.197 = p;
      encode_value (D.32113, p.197, &p);
      goto <D.25386>;
      <D.25418>:
      D.32106 = patch_info->data.target;
      D.32112 = MEM[(guint32 *)D.32106];
      D.32113 = (int) D.32112;
      p.197 = p;
      encode_value (D.32113, p.197, &p);
      D.32106 = patch_info->data.target;
      D.32114 = D.32106 + 4;
      D.32115 = *D.32114;
      D.32116 = (int) D.32115;
      p.197 = p;
      encode_value (D.32116, p.197, &p);
      goto <D.25386>;
      <D.25419>:
      <D.25420>:
      <D.25421>:
      <D.25422>:
      D.32117 = patch_info->data.klass;
      p.197 = p;
      encode_klass_ref (acfg, D.32117, p.197, &p);
      goto <D.25386>;
      <D.25423>:
      <D.25424>:
      D.32117 = patch_info->data.klass;
      p.197 = p;
      encode_klass_ref (acfg, D.32117, p.197, &p);
      goto <D.25386>;
      <D.25425>:
      <D.25426>:
      D.32118 = patch_info->data.field;
      p.197 = p;
      encode_field_info (acfg, D.32118, p.197, &p);
      goto <D.25386>;
      <D.25427>:
      goto <D.25386>;
      <D.25428>:
      {
        struct MonoJumpInfoRgctxEntry * entry;
        guint32 offset;
        guint8 * buf2;
        guint8 * p2;

        try
          {
            entry = patch_info->data.rgctx_entry;
            D.32119 = acfg->method_blob_hash;
            D.32120 = entry->method;
            D.32121 = monoeg_g_hash_table_lookup (D.32119, D.32120);
            D.32122 = (long int) D.32121;
            offset = (guint32) D.32122;
            if (offset == 0) goto <D.32123>; else goto <D.32124>;
            <D.32123>:
            buf2 = monoeg_malloc (1024);
            p2 = buf2;
            D.32120 = entry->method;
            p2.203 = p2;
            encode_method_ref (acfg, D.32120, p2.203, &p2);
            p2.203 = p2;
            p2.204 = (long int) p2.203;
            buf2.205 = (long int) buf2;
            D.32128 = p2.204 - buf2.205;
            D.32129 = D.32128 > 1023;
            D.32130 = (long int) D.32129;
            D.32131 = __builtin_expect (D.32130, 0);
            if (D.32131 != 0) goto <D.32132>; else goto <D.32133>;
            <D.32132>:
            monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "aot-compiler.c", 4990, "p2 - buf2 < 1024");
            <D.32133>:
            p2.203 = p2;
            p2.204 = (long int) p2.203;
            buf2.205 = (long int) buf2;
            D.32128 = p2.204 - buf2.205;
            D.32134 = (unsigned int) D.32128;
            offset = add_to_blob (acfg, buf2, D.32134);
            monoeg_g_free (buf2);
            D.32119 = acfg->method_blob_hash;
            D.32120 = entry->method;
            D.32135 = offset + 1;
            D.32136 = (long unsigned int) D.32135;
            D.32137 = (void *) D.32136;
            monoeg_g_hash_table_insert_replace (D.32119, D.32120, D.32137, 0);
            goto <D.32138>;
            <D.32124>:
            offset = offset + 4294967295;
            <D.32138>:
            offset.206 = (int) offset;
            p.197 = p;
            encode_value (offset.206, p.197, &p);
            D.32140 = entry->info_type;
            D.32141 = (int) D.32140;
            D.32142 = D.32141 > 255;
            D.32143 = (long int) D.32142;
            D.32144 = __builtin_expect (D.32143, 0);
            if (D.32144 != 0) goto <D.32145>; else goto <D.32146>;
            <D.32145>:
            monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "aot-compiler.c", 5001, "(int)entry->info_type < 256");
            <D.32146>:
            D.32147 = entry->data;
            D.32148 = D.32147->type;
            D.32149 = D.32148 > 255;
            D.32150 = (long int) D.32149;
            D.32151 = __builtin_expect (D.32150, 0);
            if (D.32151 != 0) goto <D.32152>; else goto <D.32153>;
            <D.32152>:
            monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "aot-compiler.c", 5002, "entry->data->type < 256");
            <D.32153>:
            D.32155 = entry->in_mrgctx;
            if (D.32155 != 0) goto <D.32156>; else goto <D.32157>;
            <D.32156>:
            iftmp.207 = 1;
            goto <D.32158>;
            <D.32157>:
            iftmp.207 = 0;
            <D.32158>:
            D.32140 = entry->info_type;
            D.32159 = D.32140 << 1;
            D.32160 = iftmp.207 | D.32159;
            D.32147 = entry->data;
            D.32148 = D.32147->type;
            D.32161 = D.32148 << 9;
            D.32162 = D.32160 | D.32161;
            D.32163 = (int) D.32162;
            p.197 = p;
            encode_value (D.32163, p.197, &p);
            D.32147 = entry->data;
            p.197 = p;
            encode_patch (acfg, D.32147, p.197, &p);
            goto <D.25386>;
          }
        finally
          {
            p2 = {CLOBBER};
          }
      }
      <D.25433>:
      <D.25434>:
      <D.25435>:
      <D.25436>:
      goto <D.25386>;
      <D.25437>:
      D.32164 = patch_info->data.imt_tramp;
      D.32165 = D.32164->method;
      p.197 = p;
      encode_method_ref (acfg, D.32165, p.197, &p);
      D.32164 = patch_info->data.imt_tramp;
      D.32166 = D.32164->vt_offset;
      p.197 = p;
      encode_value (D.32166, p.197, &p);
      goto <D.25386>;
      <D.25438>:
      D.32106 = patch_info->data.target;
      p.197 = p;
      encode_signature (acfg, D.32106, p.197, &p);
      goto <D.25386>;
      <D.25439>:
      D.32106 = patch_info->data.target;
      D.32167 = (long int) D.32106;
      D.32168 = (int) D.32167;
      p.197 = p;
      encode_value (D.32168, p.197, &p);
      goto <D.25386>;
      <D.25440>:
      D.32169 = patch_info->data.gsharedvt;
      D.32170 = D.32169->sig;
      p.197 = p;
      encode_signature (acfg, D.32170, p.197, &p);
      D.32169 = patch_info->data.gsharedvt;
      D.32171 = D.32169->method;
      p.197 = p;
      encode_method_ref (acfg, D.32171, p.197, &p);
      goto <D.25386>;
      <D.25441>:
      {
        struct MonoGSharedVtMethodInfo * info;
        int i;

        info = patch_info->data.gsharedvt_method;
        D.32172 = info->method;
        p.197 = p;
        encode_method_ref (acfg, D.32172, p.197, &p);
        D.32173 = info->entries;
        D.32174 = D.32173->len;
        D.32175 = (int) D.32174;
        p.197 = p;
        encode_value (D.32175, p.197, &p);
        i = 0;
        goto <D.25450>;
        <D.25449>:
        {
          struct MonoRuntimeGenericContextInfoTemplate * template;

          D.32173 = info->entries;
          D.32176 = D.32173->pdata;
          D.32177 = (long unsigned int) i;
          D.32178 = D.32177 * 8;
          D.32179 = D.32176 + D.32178;
          template = *D.32179;
          D.32180 = template->info_type;
          D.32181 = (int) D.32180;
          p.197 = p;
          encode_value (D.32181, p.197, &p);
          D.32180 = template->info_type;
          D.32182 = mini_rgctx_info_type_to_patch_info_type (D.32180);
          switch (D.32182) <default: <D.25448>, case 11: <D.25445>, case 13: <D.25447>>
          <D.25445>:
          D.32183 = template->data;
          D.32184 = mono_class_from_mono_type (D.32183);
          p.197 = p;
          encode_klass_ref (acfg, D.32184, p.197, &p);
          goto <D.25446>;
          <D.25447>:
          D.32183 = template->data;
          p.197 = p;
          encode_field_info (acfg, D.32183, p.197, &p);
          goto <D.25446>;
          <D.25448>:
          monoeg_assertion_message ("* Assertion: should not be reached at %s:%d\n", "aot-compiler.c", 5044);
          <D.25446>:
        }
        i = i + 1;
        <D.25450>:
        i.208 = (unsigned int) i;
        D.32173 = info->entries;
        D.32174 = D.32173->len;
        if (i.208 < D.32174) goto <D.25449>; else goto <D.25451>;
        <D.25451>:
        goto <D.25386>;
      }
      <D.25452>:
      D.32061 = patch_info->type;
      monoeg_g_log (0B, 16, "unable to handle jump info %d", D.32061);
      monoeg_assertion_message ("* Assertion: should not be reached at %s:%d\n", "aot-compiler.c", 5052);
      <D.25386>:
      p.197 = p;
      *endbuf = p.197;
    }
  finally
    {
      p = {CLOBBER};
    }
}


encode_field_info (struct MonoAotCompile * cfg, struct MonoClassField * field, guint8 * buf, guint8 * * endbuf)
{
  struct MonoClass * D.32188;
  guint8 * p.209;
  unsigned int D.32190;
  _Bool D.32191;
  long int D.32192;
  long int D.32193;
  unsigned int D.32196;
  int D.32197;
  guint32 token;
  guint8 * p;

  try
    {
      token = mono_get_field_token (field);
      p = buf;
      D.32188 = field->parent;
      p.209 = p;
      encode_klass_ref (cfg, D.32188, p.209, &p);
      D.32190 = token & 4278190080;
      D.32191 = D.32190 != 67108864;
      D.32192 = (long int) D.32191;
      D.32193 = __builtin_expect (D.32192, 0);
      if (D.32193 != 0) goto <D.32194>; else goto <D.32195>;
      <D.32194>:
      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.32195>:
      D.32196 = token + 4227858432;
      D.32197 = (int) D.32196;
      p.209 = p;
      encode_value (D.32197, p.209, &p);
      p.209 = p;
      *endbuf = p.209;
    }
  finally
    {
      p = {CLOBBER};
    }
}


mono_get_field_token (struct MonoClassField * field)
{
  struct MonoClassField * D.32198;
  long unsigned int D.32199;
  long unsigned int D.32200;
  struct MonoClassField * D.32201;
  guint32 D.32204;
  unsigned int D.32205;
  unsigned int i.210;
  unsigned int D.32207;
  unsigned int D.32208;
  unsigned int D.32209;
  struct MonoClass * klass;
  int i;

  klass = field->parent;
  i = 0;
  goto <D.24230>;
  <D.24229>:
  D.32198 = klass->fields;
  D.32199 = (long unsigned int) i;
  D.32200 = D.32199 * 32;
  D.32201 = D.32198 + D.32200;
  if (D.32201 == field) goto <D.32202>; else goto <D.32203>;
  <D.32202>:
  D.32205 = klass->field.first;
  i.210 = (unsigned int) i;
  D.32207 = D.32205 + i.210;
  D.32208 = D.32207 + 1;
  D.32204 = D.32208 | 67108864;
  return D.32204;
  <D.32203>:
  i = i + 1;
  <D.24230>:
  i.210 = (unsigned int) i;
  D.32209 = klass->field.count;
  if (i.210 < D.32209) goto <D.24229>; else goto <D.24231>;
  <D.24231>:
  monoeg_assertion_message ("* Assertion: should not be reached at %s:%d\n", "aot-compiler.c", 2035);
  D.32204 = 0;
  return D.32204;
}


emit_exception_info (struct MonoAotCompile * acfg)
{
  unsigned int D.32211;
  long unsigned int D.32212;
  long unsigned int D.32213;
  struct MonoCompile * * D.32214;
  long unsigned int D.32215;
  long unsigned int D.32216;
  struct MonoCompile * * D.32217;
  struct MonoCompile * D.32218;
  long unsigned int D.32221;
  gint32 * D.32222;
  unsigned int D.32223;
  int D.32224;
  unsigned int i.211;
  int D.32227;
  unsigned int D.32228;
  int D.32229;
  unsigned int D.32230;
  unsigned int D.32231;
  int D.32232;
  int i;
  char symbol[256];
  gint32 * offsets;

  try
    {
      D.32211 = acfg->nmethods;
      D.32212 = (long unsigned int) D.32211;
      D.32213 = D.32212 * 4;
      offsets = monoeg_malloc0 (D.32213);
      i = 0;
      goto <D.26206>;
      <D.26205>:
      D.32214 = acfg->cfgs;
      D.32215 = (long unsigned int) i;
      D.32216 = D.32215 * 8;
      D.32217 = D.32214 + D.32216;
      D.32218 = *D.32217;
      if (D.32218 != 0B) goto <D.32219>; else goto <D.32220>;
      <D.32219>:
      D.32214 = acfg->cfgs;
      D.32215 = (long unsigned int) i;
      D.32216 = D.32215 * 8;
      D.32217 = D.32214 + D.32216;
      D.32218 = *D.32217;
      emit_exception_debug_info (acfg, D.32218);
      D.32215 = (long unsigned int) i;
      D.32221 = D.32215 * 4;
      D.32222 = offsets + D.32221;
      D.32214 = acfg->cfgs;
      D.32215 = (long unsigned int) i;
      D.32216 = D.32215 * 8;
      D.32217 = D.32214 + D.32216;
      D.32218 = *D.32217;
      D.32223 = D.32218->ex_info_offset;
      D.32224 = (int) D.32223;
      *D.32222 = D.32224;
      goto <D.32225>;
      <D.32220>:
      D.32215 = (long unsigned int) i;
      D.32221 = D.32215 * 4;
      D.32222 = offsets + D.32221;
      *D.32222 = 0;
      <D.32225>:
      i = i + 1;
      <D.26206>:
      i.211 = (unsigned int) i;
      D.32211 = acfg->nmethods;
      if (i.211 < D.32211) goto <D.26205>; else goto <D.26207>;
      <D.26207>:
      sprintf (&symbol, "ex_info_offsets");
      emit_section_change (acfg, ".rodata", 1);
      emit_alignment (acfg, 8);
      emit_label (acfg, &symbol);
      D.32211 = acfg->nmethods;
      D.32227 = (int) D.32211;
      D.32228 = emit_offset_table (acfg, D.32227, 10, offsets);
      D.32229 = acfg->stats.offsets_size;
      D.32230 = (unsigned int) D.32229;
      D.32231 = D.32230 + D.32228;
      D.32232 = (int) D.32231;
      acfg->stats.offsets_size = D.32232;
      monoeg_g_free (offsets);
    }
  finally
    {
      symbol = {CLOBBER};
    }
}


emit_exception_debug_info (struct MonoAotCompile * acfg, struct MonoCompile * cfg)
{
  unsigned int D.32233;
  int D.32234;
  <unnamed-unsigned:15> D.32238;
  int D.32239;
  int D.32240;
  unsigned int D.32241;
  unsigned int debug_info_size.212;
  unsigned int D.32243;
  guint32 iftmp.213;
  int D.32247;
  int D.32248;
  unsigned int D.32250;
  unsigned int D.32251;
  unsigned int D.32252;
  unsigned int D.32253;
  long unsigned int D.32254;
  struct GSList * D.32255;
  _Bool D.32256;
  long unsigned int D.32257;
  long unsigned int D.32258;
  _Bool D.32259;
  int D.32260;
  int iftmp.214;
  int D.32265;
  int iftmp.215;
  long unsigned int D.32267;
  long unsigned int D.32268;
  int D.32272;
  int iftmp.216;
  int D.32277;
  int iftmp.217;
  long unsigned int D.32279;
  long unsigned int D.32280;
  int D.32284;
  int iftmp.218;
  long unsigned int D.32286;
  int D.32290;
  int iftmp.219;
  guint8 * D.32292;
  int D.32296;
  int iftmp.220;
  long unsigned int D.32298;
  int D.32302;
  int flags.221;
  guint8 * p.222;
  unsigned int encoded_len.223;
  unsigned int D.32308;
  int D.32309;
  unsigned int D.32311;
  int D.32312;
  short unsigned int D.32315;
  int D.32316;
  int D.32321;
  struct MonoExceptionClause * D.32322;
  long unsigned int D.32323;
  long unsigned int D.32324;
  unsigned int D.32325;
  int D.32326;
  struct MonoClass * D.32327;
  long unsigned int D.32331;
  long unsigned int D.32332;
  long unsigned int D.32333;
  long unsigned int D.32334;
  unsigned int D.32337;
  unsigned int D.32338;
  unsigned int D.32341;
  unsigned int D.32342;
  long unsigned int D.32346;
  <unnamed-unsigned:15> D.32349;
  int D.32350;
  unsigned int D.32351;
  int D.32352;
  int D.32353;
  unsigned int D.32354;
  void * D.32357;
  long int D.32358;
  long int code.224;
  long int D.32360;
  int D.32361;
  struct MonoClass * D.32363;
  guint8 * p2.225;
  long int p2.226;
  long int buf2.227;
  long int D.32369;
  _Bool D.32370;
  long int D.32371;
  long int D.32372;
  long unsigned int D.32375;
  sizetype D.32376;
  guint8 * p.228;
  void * D.32379;
  long int D.32380;
  long int D.32381;
  int D.32382;
  void * D.32383;
  long int D.32384;
  long int D.32385;
  int D.32386;
  void * D.32387;
  long int D.32388;
  long int D.32389;
  int D.32390;
  int D.32391;
  short unsigned int D.32394;
  int D.32395;
  short unsigned int D.32396;
  int D.32397;
  unsigned int D.32398;
  int D.32399;
  short unsigned int D.32400;
  int D.32401;
  unsigned int D.32404;
  int D.32405;
  int D.32408;
  struct MonoDwarfLocListEntry * D.32411;
  long unsigned int D.32412;
  long unsigned int D.32413;
  int D.32414;
  _Bool D.32415;
  int D.32416;
  int D.32417;
  int D.32420;
  int D.32423;
  _Bool D.32424;
  long int D.32425;
  long int D.32426;
  int D.32430;
  long unsigned int D.32434;
  long unsigned int D.32435;
  _Bool D.32436;
  int D.32437;
  unsigned char D.32438;
  int D.32439;
  int D.32440;
  struct MonoMethod * D.32441;
  guint8 * p2.229;
  long int p2.230;
  long int buf2.231;
  long int D.32445;
  _Bool D.32446;
  long int D.32447;
  long int D.32448;
  long unsigned int D.32451;
  sizetype D.32452;
  guint8 * p.232;
  gboolean * D.32458;
  gboolean * D.32460;
  long unsigned int D.32461;
  long unsigned int D.32462;
  _Bool D.32463;
  long int D.32464;
  long int D.32465;
  struct MonoGenericInst * D.32468;
  <unnamed-unsigned:22> D.32471;
  int D.32472;
  long unsigned int D.32473;
  gboolean * D.32474;
  int D.32475;
  int D.32476;
  struct MonoGenericInst * D.32478;
  gboolean * D.32481;
  int D.32482;
  int D.32486;
  int D.32487;
  int D.32488;
  int D.32489;
  int * D.32490;
  long unsigned int D.32491;
  long unsigned int D.32492;
  int * D.32493;
  int D.32494;
  unsigned int buf_size.233;
  _Bool D.32496;
  long int D.32497;
  long int D.32498;
  int debug_info_size.234;
  guint8 * debug_info.235;
  long unsigned int D.32505;
  sizetype D.32506;
  guint8 * p.236;
  int D.32510;
  guint8 * p.237;
  long unsigned int p.238;
  long unsigned int D.32513;
  long unsigned int D.32514;
  sizetype D.32515;
  guint8 * p.239;
  int D.32517;
  unsigned int D.32518;
  long int p.240;
  long int buf.241;
  long int D.32521;
  unsigned int D.32522;
  unsigned int D.32523;
  int D.32524;
  long int D.32525;
  _Bool D.32526;
  long int D.32527;
  long int D.32528;
  unsigned int D.32531;
  guint32 iftmp.242;
  unsigned int D.32536;
  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.32233 = get_method_index (acfg, method);
      method_index = (int) D.32233;
      D.32234 = acfg->aot_opts.nodebug;
      if (D.32234 == 0) goto <D.32235>; else goto <D.32236>;
      <D.32235>:
      mono_debug_serialize_debug_info (cfg, &debug_info, &debug_info_size);
      goto <D.32237>;
      <D.32236>:
      debug_info = 0B;
      debug_info_size = 0;
      <D.32237>:
      seq_points = cfg->seq_point_info;
      D.32238 = header->num_clauses;
      D.32239 = (int) D.32238;
      D.32240 = D.32239 * 256;
      D.32241 = (unsigned int) D.32240;
      debug_info_size.212 = debug_info_size;
      D.32243 = D.32241 + debug_info_size.212;
      if (seq_points != 0B) goto <D.32245>; else goto <D.32246>;
      <D.32245>:
      D.32247 = seq_points->len;
      D.32248 = D.32247 * 128;
      iftmp.213 = (guint32) D.32248;
      goto <D.32249>;
      <D.32246>:
      iftmp.213 = 0;
      <D.32249>:
      D.32250 = D.32243 + iftmp.213;
      D.32251 = cfg->gc_map_size;
      D.32252 = D.32250 + D.32251;
      D.32253 = D.32252 + 2048;
      buf_size = (int) D.32253;
      D.32254 = (long unsigned int) buf_size;
      buf = monoeg_malloc (D.32254);
      p = buf;
      D.32255 = cfg->unwind_ops;
      D.32256 = D.32255 != 0B;
      use_unwind_ops = (gboolean) D.32256;
      D.32257 = BIT_FIELD_REF <*jinfo, 64, 256>;
      D.32258 = D.32257 & 131072;
      D.32259 = D.32258 != 0;
      D.32260 = (int) D.32259;
      if (use_unwind_ops != 0) goto <D.32262>; else goto <D.32263>;
      <D.32262>:
      iftmp.214 = 2;
      goto <D.32264>;
      <D.32263>:
      iftmp.214 = 0;
      <D.32264>:
      D.32265 = D.32260 | iftmp.214;
      D.32267 = BIT_FIELD_REF <*header, 64, 64>;
      D.32268 = D.32267 & 9223090561878065152;
      if (D.32268 != 0) goto <D.32269>; else goto <D.32270>;
      <D.32269>:
      iftmp.215 = 4;
      goto <D.32271>;
      <D.32270>:
      iftmp.215 = 0;
      <D.32271>:
      D.32272 = D.32265 | iftmp.215;
      if (seq_points != 0B) goto <D.32274>; else goto <D.32275>;
      <D.32274>:
      iftmp.216 = 8;
      goto <D.32276>;
      <D.32275>:
      iftmp.216 = 0;
      <D.32276>:
      D.32277 = D.32272 | iftmp.216;
      D.32279 = BIT_FIELD_REF <*cfg, 64, 5568>;
      D.32280 = D.32279 & 1099511627776;
      if (D.32280 != 0) goto <D.32281>; else goto <D.32282>;
      <D.32281>:
      iftmp.217 = 16;
      goto <D.32283>;
      <D.32282>:
      iftmp.217 = 0;
      <D.32283>:
      D.32284 = D.32277 | iftmp.217;
      D.32257 = BIT_FIELD_REF <*jinfo, 64, 256>;
      D.32286 = D.32257 & 262144;
      if (D.32286 != 0) goto <D.32287>; else goto <D.32288>;
      <D.32287>:
      iftmp.218 = 32;
      goto <D.32289>;
      <D.32288>:
      iftmp.218 = 0;
      <D.32289>:
      D.32290 = D.32284 | iftmp.218;
      D.32292 = cfg->gc_map;
      if (D.32292 != 0B) goto <D.32293>; else goto <D.32294>;
      <D.32293>:
      iftmp.219 = 64;
      goto <D.32295>;
      <D.32294>:
      iftmp.219 = 0;
      <D.32295>:
      D.32296 = D.32290 | iftmp.219;
      D.32257 = BIT_FIELD_REF <*jinfo, 64, 256>;
      D.32298 = D.32257 & 524288;
      if (D.32298 != 0) goto <D.32299>; else goto <D.32300>;
      <D.32299>:
      iftmp.220 = 128;
      goto <D.32301>;
      <D.32300>:
      iftmp.220 = 0;
      <D.32301>:
      D.32302 = D.32296 | iftmp.220;
      flags = (guint32) D.32302;
      flags.221 = (int) flags;
      p.222 = p;
      encode_value (flags.221, p.222, &p);
      if (use_unwind_ops != 0) goto <D.32305>; else goto <D.32306>;
      <D.32305>:
      {
        guint32 encoded_len;
        guint8 * encoded;

        try
          {
            D.32255 = cfg->unwind_ops;
            encoded = mono_unwind_ops_encode (D.32255, &encoded_len);
            encoded_len.223 = encoded_len;
            D.32308 = get_unwind_info_offset (acfg, encoded, encoded_len.223);
            D.32309 = (int) D.32308;
            p.222 = p;
            encode_value (D.32309, p.222, &p);
            monoeg_g_free (encoded);
          }
        finally
          {
            encoded_len = {CLOBBER};
          }
      }
      goto <D.32310>;
      <D.32306>:
      D.32311 = jinfo->used_regs;
      D.32312 = (int) D.32311;
      p.222 = p;
      encode_value (D.32312, p.222, &p);
      <D.32310>:
      D.32257 = BIT_FIELD_REF <*jinfo, 64, 256>;
      D.32286 = D.32257 & 262144;
      if (D.32286 != 0) goto <D.32313>; else goto <D.32314>;
      <D.32313>:
      {
        struct MonoTryBlockHoleTableJitInfo * table;

        table = mono_jit_info_get_try_block_hole_table_info (jinfo);
        D.32315 = table->num_holes;
        D.32316 = (int) D.32315;
        p.222 = p;
        encode_value (D.32316, p.222, &p);
      }
      <D.32314>:
      D.32279 = BIT_FIELD_REF <*cfg, 64, 5568>;
      D.32280 = D.32279 & 1099511627776;
      if (D.32280 != 0) goto <D.32317>; else goto <D.32318>;
      <D.32317>:
      D.32267 = BIT_FIELD_REF <*header, 64, 64>;
      D.32268 = D.32267 & 9223090561878065152;
      if (D.32268 != 0) goto <D.32319>; else goto <D.32320>;
      <D.32319>:
      D.32238 = header->num_clauses;
      D.32321 = (int) D.32238;
      p.222 = p;
      encode_value (D.32321, p.222, &p);
      <D.32320>:
      k = 0;
      goto <D.25535>;
      <D.25534>:
      {
        struct MonoExceptionClause * clause;

        D.32322 = header->clauses;
        D.32323 = (long unsigned int) k;
        D.32324 = D.32323 * 32;
        clause = D.32322 + D.32324;
        D.32325 = clause->flags;
        D.32326 = (int) D.32325;
        p.222 = p;
        encode_value (D.32326, p.222, &p);
        D.32327 = clause->data.catch_class;
        if (D.32327 != 0B) goto <D.32328>; else goto <D.32329>;
        <D.32328>:
        p.222 = p;
        encode_value (1, p.222, &p);
        D.32327 = clause->data.catch_class;
        p.222 = p;
        encode_klass_ref (acfg, D.32327, p.222, &p);
        goto <D.32330>;
        <D.32329>:
        p.222 = p;
        encode_value (0, p.222, &p);
        <D.32330>:
        i = 0;
        goto <D.25532>;
        <D.25531>:
        {
          gint32 cindex1;
          struct MonoExceptionClause * clause1;
          gint32 cindex2;
          struct MonoExceptionClause * clause2;

          cindex1 = k;
          D.32322 = header->clauses;
          D.32331 = (long unsigned int) cindex1;
          D.32332 = D.32331 * 32;
          clause1 = D.32322 + D.32332;
          cindex2 = i;
          D.32322 = header->clauses;
          D.32333 = (long unsigned int) cindex2;
          D.32334 = D.32333 * 32;
          clause2 = D.32322 + D.32334;
          if (cindex1 != cindex2) goto <D.32335>; else goto <D.32336>;
          <D.32335>:
          D.32337 = clause1->try_offset;
          D.32338 = clause2->try_offset;
          if (D.32337 >= D.32338) goto <D.32339>; else goto <D.32340>;
          <D.32339>:
          D.32341 = clause1->handler_offset;
          D.32342 = clause2->handler_offset;
          if (D.32341 <= D.32342) goto <D.32343>; else goto <D.32344>;
          <D.32343>:
          p.222 = p;
          encode_value (i, p.222, &p);
          <D.32344>:
          <D.32340>:
          <D.32336>:
        }
        i = i + 1;
        <D.25532>:
        D.32238 = header->num_clauses;
        D.32239 = (int) D.32238;
        if (D.32239 > i) goto <D.25531>; else goto <D.25533>;
        <D.25533>:
        p.222 = p;
        encode_value (-1, p.222, &p);
      }
      k = k + 1;
      <D.25535>:
      D.32238 = header->num_clauses;
      D.32239 = (int) D.32238;
      if (D.32239 > k) goto <D.25534>; else goto <D.25536>;
      <D.25536>:
      goto <D.32345>;
      <D.32318>:
      D.32257 = BIT_FIELD_REF <*jinfo, 64, 256>;
      D.32346 = D.32257 & 32767;
      if (D.32346 != 0) goto <D.32347>; else goto <D.32348>;
      <D.32347>:
      D.32349 = jinfo->num_clauses;
      D.32350 = (int) D.32349;
      p.222 = p;
      encode_value (D.32350, p.222, &p);
      <D.32348>:
      k = 0;
      goto <D.25542>;
      <D.25541>:
      {
        struct MonoJitExceptionInfo * ei;

        ei = &jinfo->clauses[k];
        D.32351 = ei->flags;
        D.32352 = (int) D.32351;
        p.222 = p;
        encode_value (D.32352, p.222, &p);
        D.32353 = ei->exvar_offset;
        p.222 = p;
        encode_value (D.32353, p.222, &p);
        D.32351 = ei->flags;
        D.32354 = D.32351 + 4294967295;
        if (D.32354 <= 1) goto <D.32355>; else goto <D.32356>;
        <D.32355>:
        D.32357 = ei->data.filter;
        D.32358 = (long int) D.32357;
        code.224 = (long int) code;
        D.32360 = D.32358 - code.224;
        D.32361 = (int) D.32360;
        p.222 = p;
        encode_value (D.32361, p.222, &p);
        goto <D.32362>;
        <D.32356>:
        D.32363 = ei->data.catch_class;
        if (D.32363 != 0B) goto <D.32364>; else goto <D.32365>;
        <D.32364>:
        {
          guint8 * buf2;
          guint8 * p2;
          int len;

          try
            {
              buf2 = monoeg_malloc (4096);
              p2 = buf2;
              D.32363 = ei->data.catch_class;
              p2.225 = p2;
              encode_klass_ref (acfg, D.32363, p2.225, &p2);
              p2.225 = p2;
              p2.226 = (long int) p2.225;
              buf2.227 = (long int) buf2;
              D.32369 = p2.226 - buf2.227;
              len = (int) D.32369;
              D.32370 = len > 4095;
              D.32371 = (long int) D.32370;
              D.32372 = __builtin_expect (D.32371, 0);
              if (D.32372 != 0) goto <D.32373>; else goto <D.32374>;
              <D.32373>:
              monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "aot-compiler.c", 5325, "len < 4096");
              <D.32374>:
              p.222 = p;
              encode_value (len, p.222, &p);
              p.222 = p;
              D.32375 = (long unsigned int) len;
              memcpy (p.222, buf2, D.32375);
              p.222 = p;
              p2.225 = p2;
              p2.226 = (long int) p2.225;
              buf2.227 = (long int) buf2;
              D.32369 = p2.226 - buf2.227;
              D.32376 = (sizetype) D.32369;
              p.228 = p.222 + D.32376;
              p = p.228;
              monoeg_g_free (buf2);
            }
          finally
            {
              p2 = {CLOBBER};
            }
        }
        goto <D.32378>;
        <D.32365>:
        p.222 = p;
        encode_value (0, p.222, &p);
        <D.32378>:
        <D.32362>:
        D.32379 = ei->try_start;
        D.32380 = (long int) D.32379;
        code.224 = (long int) code;
        D.32381 = D.32380 - code.224;
        D.32382 = (int) D.32381;
        p.222 = p;
        encode_value (D.32382, p.222, &p);
        D.32383 = ei->try_end;
        D.32384 = (long int) D.32383;
        code.224 = (long int) code;
        D.32385 = D.32384 - code.224;
        D.32386 = (int) D.32385;
        p.222 = p;
        encode_value (D.32386, p.222, &p);
        D.32387 = ei->handler_start;
        D.32388 = (long int) D.32387;
        code.224 = (long int) code;
        D.32389 = D.32388 - code.224;
        D.32390 = (int) D.32389;
        p.222 = p;
        encode_value (D.32390, p.222, &p);
      }
      k = k + 1;
      <D.25542>:
      D.32349 = jinfo->num_clauses;
      D.32391 = (int) D.32349;
      if (D.32391 > k) goto <D.25541>; else goto <D.25543>;
      <D.25543>:
      <D.32345>:
      D.32257 = BIT_FIELD_REF <*jinfo, 64, 256>;
      D.32286 = D.32257 & 262144;
      if (D.32286 != 0) goto <D.32392>; else goto <D.32393>;
      <D.32392>:
      {
        struct MonoTryBlockHoleTableJitInfo * table;

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

          hole = &table->holes[i];
          D.32394 = hole->clause;
          D.32395 = (int) D.32394;
          p.222 = p;
          encode_value (D.32395, p.222, &p);
          D.32396 = hole->length;
          D.32397 = (int) D.32396;
          p.222 = p;
          encode_value (D.32397, p.222, &p);
          D.32398 = hole->offset;
          D.32399 = (int) D.32398;
          p.222 = p;
          encode_value (D.32399, p.222, &p);
        }
        i = i + 1;
        <D.25547>:
        D.32400 = table->num_holes;
        D.32401 = (int) D.32400;
        if (D.32401 > i) goto <D.25546>; else goto <D.25548>;
        <D.25548>:
      }
      <D.32393>:
      D.32257 = BIT_FIELD_REF <*jinfo, 64, 256>;
      D.32298 = D.32257 & 524288;
      if (D.32298 != 0) goto <D.32402>; else goto <D.32403>;
      <D.32402>:
      {
        struct MonoArchEHJitInfo * eh_info;

        eh_info = mono_jit_info_get_arch_eh_info (jinfo);
        D.32404 = eh_info->stack_size;
        D.32405 = (int) D.32404;
        p.222 = p;
        encode_value (D.32405, p.222, &p);
      }
      <D.32403>:
      D.32257 = BIT_FIELD_REF <*jinfo, 64, 256>;
      D.32258 = D.32257 & 131072;
      if (D.32258 != 0) goto <D.32406>; else goto <D.32407>;
      <D.32406>:
      {
        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.32408 = gi->nlocs;
            p.222 = p;
            encode_value (D.32408, p.222, &p);
            D.32408 = gi->nlocs;
            if (D.32408 != 0) goto <D.32409>; else goto <D.32410>;
            <D.32409>:
            i = 0;
            goto <D.25558>;
            <D.25557>:
            {
              struct MonoDwarfLocListEntry * entry;

              D.32411 = gi->locations;
              D.32412 = (long unsigned int) i;
              D.32413 = D.32412 * 20;
              entry = D.32411 + D.32413;
              D.32414 = entry->is_reg;
              D.32415 = D.32414 != 0;
              D.32416 = (int) D.32415;
              p.222 = p;
              encode_value (D.32416, p.222, &p);
              D.32417 = entry->reg;
              p.222 = p;
              encode_value (D.32417, p.222, &p);
              D.32414 = entry->is_reg;
              if (D.32414 == 0) goto <D.32418>; else goto <D.32419>;
              <D.32418>:
              D.32420 = entry->offset;
              p.222 = p;
              encode_value (D.32420, p.222, &p);
              <D.32419>:
              if (i == 0) goto <D.32421>; else goto <D.32422>;
              <D.32421>:
              D.32423 = entry->from;
              D.32424 = D.32423 != 0;
              D.32425 = (long int) D.32424;
              D.32426 = __builtin_expect (D.32425, 0);
              if (D.32426 != 0) goto <D.32427>; else goto <D.32428>;
              <D.32427>:
              monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "aot-compiler.c", 5376, "entry->from == 0");
              <D.32428>:
              goto <D.32429>;
              <D.32422>:
              D.32423 = entry->from;
              p.222 = p;
              encode_value (D.32423, p.222, &p);
              <D.32429>:
              D.32430 = entry->to;
              p.222 = p;
              encode_value (D.32430, p.222, &p);
            }
            i = i + 1;
            <D.25558>:
            D.32408 = gi->nlocs;
            if (D.32408 > i) goto <D.25557>; else goto <D.25559>;
            <D.25559>:
            goto <D.32431>;
            <D.32410>:
            D.32279 = BIT_FIELD_REF <*cfg, 64, 5568>;
            D.32280 = D.32279 & 1099511627776;
            if (D.32280 == 0) goto <D.32432>; else goto <D.32433>;
            <D.32432>:
            D.32434 = BIT_FIELD_REF <*gi, 64, 192>;
            D.32435 = D.32434 & 1099511627776;
            D.32436 = D.32435 != 0;
            D.32437 = (int) D.32436;
            p.222 = p;
            encode_value (D.32437, p.222, &p);
            D.32438 = gi->this_reg;
            D.32439 = (int) D.32438;
            p.222 = p;
            encode_value (D.32439, p.222, &p);
            D.32440 = gi->this_offset;
            p.222 = p;
            encode_value (D.32440, p.222, &p);
            <D.32433>:
            <D.32431>:
            buf2 = monoeg_malloc (4096);
            p2 = buf2;
            D.32441 = jinfo->d.method;
            p2.229 = p2;
            encode_method_ref (acfg, D.32441, p2.229, &p2);
            p2.229 = p2;
            p2.230 = (long int) p2.229;
            buf2.231 = (long int) buf2;
            D.32445 = p2.230 - buf2.231;
            len = (int) D.32445;
            D.32446 = len > 4095;
            D.32447 = (long int) D.32446;
            D.32448 = __builtin_expect (D.32447, 0);
            if (D.32448 != 0) goto <D.32449>; else goto <D.32450>;
            <D.32449>:
            monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "aot-compiler.c", 5397, "len < 4096");
            <D.32450>:
            p.222 = p;
            encode_value (len, p.222, &p);
            p.222 = p;
            D.32451 = (long unsigned int) len;
            memcpy (p.222, buf2, D.32451);
            p.222 = p;
            p2.229 = p2;
            p2.230 = (long int) p2.229;
            buf2.231 = (long int) buf2;
            D.32445 = p2.230 - buf2.231;
            D.32452 = (sizetype) D.32445;
            p.232 = p.222 + D.32452;
            p = p.232;
            monoeg_g_free (buf2);
            if (gsctx != 0B) goto <D.32457>; else goto <D.32454>;
            <D.32457>:
            D.32458 = gsctx->var_is_vt;
            if (D.32458 != 0B) goto <D.32455>; else goto <D.32459>;
            <D.32459>:
            D.32460 = gsctx->mvar_is_vt;
            if (D.32460 != 0B) goto <D.32455>; else goto <D.32454>;
            <D.32455>:
            {
              struct MonoMethodInflated * inflated;
              struct MonoGenericContext * context;
              struct MonoGenericInst * inst;

              D.32441 = jinfo->d.method;
              D.32461 = BIT_FIELD_REF <*D.32441, 64, 256>;
              D.32462 = D.32461 & 4096;
              D.32463 = D.32462 == 0;
              D.32464 = (long int) D.32463;
              D.32465 = __builtin_expect (D.32464, 0);
              if (D.32465 != 0) goto <D.32466>; else goto <D.32467>;
              <D.32466>:
              monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "aot-compiler.c", 5408, "jinfo->d.method->is_inflated");
              <D.32467>:
              inflated = jinfo->d.method;
              context = &inflated->context;
              p.222 = p;
              encode_value (1, p.222, &p);
              D.32468 = context->class_inst;
              if (D.32468 != 0B) goto <D.32469>; else goto <D.32470>;
              <D.32469>:
              inst = context->class_inst;
              D.32471 = inst->type_argc;
              D.32472 = (int) D.32471;
              p.222 = p;
              encode_value (D.32472, p.222, &p);
              i = 0;
              goto <D.25564>;
              <D.25563>:
              D.32458 = gsctx->var_is_vt;
              D.32412 = (long unsigned int) i;
              D.32473 = D.32412 * 4;
              D.32474 = D.32458 + D.32473;
              D.32475 = *D.32474;
              p.222 = p;
              encode_value (D.32475, p.222, &p);
              i = i + 1;
              <D.25564>:
              D.32471 = inst->type_argc;
              D.32476 = (int) D.32471;
              if (D.32476 > i) goto <D.25563>; else goto <D.25565>;
              <D.25565>:
              goto <D.32477>;
              <D.32470>:
              p.222 = p;
              encode_value (0, p.222, &p);
              <D.32477>:
              D.32478 = context->method_inst;
              if (D.32478 != 0B) goto <D.32479>; else goto <D.32480>;
              <D.32479>:
              inst = context->method_inst;
              D.32471 = inst->type_argc;
              D.32472 = (int) D.32471;
              p.222 = p;
              encode_value (D.32472, p.222, &p);
              i = 0;
              goto <D.25567>;
              <D.25566>:
              D.32460 = gsctx->mvar_is_vt;
              D.32412 = (long unsigned int) i;
              D.32473 = D.32412 * 4;
              D.32481 = D.32460 + D.32473;
              D.32482 = *D.32481;
              p.222 = p;
              encode_value (D.32482, p.222, &p);
              i = i + 1;
              <D.25567>:
              D.32471 = inst->type_argc;
              D.32476 = (int) D.32471;
              if (D.32476 > i) goto <D.25566>; else goto <D.25568>;
              <D.25568>:
              goto <D.32483>;
              <D.32480>:
              p.222 = p;
              encode_value (0, p.222, &p);
              <D.32483>:
            }
            goto <D.32456>;
            <D.32454>:
            p.222 = p;
            encode_value (0, p.222, &p);
            <D.32456>:
          }
        finally
          {
            p2 = {CLOBBER};
          }
      }
      <D.32407>:
      if (seq_points != 0B) goto <D.32484>; else goto <D.32485>;
      <D.32484>:
      {
        int il_offset;
        int native_offset;
        int last_il_offset;
        int last_native_offset;
        int j;

        D.32247 = seq_points->len;
        p.222 = p;
        encode_value (D.32247, p.222, &p);
        last_native_offset = 0;
        last_il_offset = last_native_offset;
        i = 0;
        goto <D.25579>;
        <D.25578>:
        {
          struct SeqPoint * sp;

          sp = &seq_points->seq_points[i];
          il_offset = sp->il_offset;
          native_offset = sp->native_offset;
          D.32486 = il_offset - last_il_offset;
          p.222 = p;
          encode_value (D.32486, p.222, &p);
          D.32487 = native_offset - last_native_offset;
          p.222 = p;
          encode_value (D.32487, p.222, &p);
          last_il_offset = il_offset;
          last_native_offset = native_offset;
          D.32488 = sp->flags;
          p.222 = p;
          encode_value (D.32488, p.222, &p);
          D.32489 = sp->next_len;
          p.222 = p;
          encode_value (D.32489, p.222, &p);
          j = 0;
          goto <D.25576>;
          <D.25575>:
          D.32490 = sp->next;
          D.32491 = (long unsigned int) j;
          D.32492 = D.32491 * 4;
          D.32493 = D.32490 + D.32492;
          D.32494 = *D.32493;
          p.222 = p;
          encode_value (D.32494, p.222, &p);
          j = j + 1;
          <D.25576>:
          D.32489 = sp->next_len;
          if (D.32489 > j) goto <D.25575>; else goto <D.25577>;
          <D.25577>:
        }
        i = i + 1;
        <D.25579>:
        D.32247 = seq_points->len;
        if (D.32247 > i) goto <D.25578>; else goto <D.25580>;
        <D.25580>:
      }
      <D.32485>:
      buf_size.233 = (unsigned int) buf_size;
      debug_info_size.212 = debug_info_size;
      D.32496 = buf_size.233 <= debug_info_size.212;
      D.32497 = (long int) D.32496;
      D.32498 = __builtin_expect (D.32497, 0);
      if (D.32498 != 0) goto <D.32499>; else goto <D.32500>;
      <D.32499>:
      monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "aot-compiler.c", 5457, "debug_info_size < buf_size");
      <D.32500>:
      debug_info_size.212 = debug_info_size;
      debug_info_size.234 = (int) debug_info_size.212;
      p.222 = p;
      encode_value (debug_info_size.234, p.222, &p);
      debug_info_size.212 = debug_info_size;
      if (debug_info_size.212 != 0) goto <D.32502>; else goto <D.32503>;
      <D.32502>:
      p.222 = p;
      debug_info.235 = debug_info;
      debug_info_size.212 = debug_info_size;
      D.32505 = (long unsigned int) debug_info_size.212;
      memcpy (p.222, debug_info.235, D.32505);
      p.222 = p;
      debug_info_size.212 = debug_info_size;
      D.32506 = (sizetype) debug_info_size.212;
      p.236 = p.222 + D.32506;
      p = p.236;
      debug_info.235 = debug_info;
      monoeg_g_free (debug_info.235);
      <D.32503>:
      D.32292 = cfg->gc_map;
      if (D.32292 != 0B) goto <D.32508>; else goto <D.32509>;
      <D.32508>:
      D.32251 = cfg->gc_map_size;
      D.32510 = (int) D.32251;
      p.222 = p;
      encode_value (D.32510, p.222, &p);
      goto <D.25582>;
      <D.25581>:
      p.222 = p;
      p.237 = p.222 + 1;
      p = p.237;
      <D.25582>:
      p.222 = p;
      p.238 = (long unsigned int) p.222;
      D.32513 = p.238 & 3;
      if (D.32513 != 0) goto <D.25581>; else goto <D.25583>;
      <D.25583>:
      p.222 = p;
      D.32292 = cfg->gc_map;
      D.32251 = cfg->gc_map_size;
      D.32514 = (long unsigned int) D.32251;
      memcpy (p.222, D.32292, D.32514);
      p.222 = p;
      D.32251 = cfg->gc_map_size;
      D.32515 = (sizetype) D.32251;
      p.239 = p.222 + D.32515;
      p = p.239;
      <D.32509>:
      D.32517 = acfg->stats.ex_info_size;
      D.32518 = (unsigned int) D.32517;
      p.222 = p;
      p.240 = (long int) p.222;
      buf.241 = (long int) buf;
      D.32521 = p.240 - buf.241;
      D.32522 = (unsigned int) D.32521;
      D.32523 = D.32518 + D.32522;
      D.32524 = (int) D.32523;
      acfg->stats.ex_info_size = D.32524;
      p.222 = p;
      p.240 = (long int) p.222;
      buf.241 = (long int) buf;
      D.32521 = p.240 - buf.241;
      D.32525 = (long int) buf_size;
      D.32526 = D.32521 >= D.32525;
      D.32527 = (long int) D.32526;
      D.32528 = __builtin_expect (D.32527, 0);
      if (D.32528 != 0) goto <D.32529>; else goto <D.32530>;
      <D.32529>:
      monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "aot-compiler.c", 5478, "p - buf < buf_size");
      <D.32530>:
      p.222 = p;
      p.240 = (long int) p.222;
      buf.241 = (long int) buf;
      D.32521 = p.240 - buf.241;
      D.32531 = (unsigned int) D.32521;
      D.32292 = cfg->gc_map;
      if (D.32292 != 0B) goto <D.32533>; else goto <D.32534>;
      <D.32533>:
      iftmp.242 = 4;
      goto <D.32535>;
      <D.32534>:
      iftmp.242 = 1;
      <D.32535>:
      D.32536 = add_to_blob_aligned (acfg, buf, D.32531, iftmp.242);
      cfg->ex_info_offset = D.32536;
      monoeg_g_free (buf);
    }
  finally
    {
      debug_info_size = {CLOBBER};
      p = {CLOBBER};
      debug_info = {CLOBBER};
    }
}


add_to_blob_aligned (struct MonoAotCompile * acfg, const guint8 * data, guint32 data_len, guint32 align)
{
  unsigned int D.32537;
  struct MonoDynamicStream * D.32540;
  unsigned int D.32541;
  unsigned int D.32544;
  guint32 D.32545;
  char buf[4];
  guint32 count;

  try
    {
      buf = {};
      D.32537 = acfg->blob.alloc_size;
      if (D.32537 == 0) goto <D.32538>; else goto <D.32539>;
      <D.32538>:
      D.32540 = &acfg->blob;
      stream_init (D.32540);
      <D.32539>:
      D.32541 = acfg->blob.index;
      count = D.32541 % align;
      if (count != 0) goto <D.32542>; else goto <D.32543>;
      <D.32542>:
      D.32540 = &acfg->blob;
      D.32544 = 4 - count;
      add_stream_data (D.32540, &buf, D.32544);
      <D.32543>:
      D.32540 = &acfg->blob;
      D.32545 = add_stream_data (D.32540, data, data_len);
      return D.32545;
    }
  finally
    {
      buf = {CLOBBER};
    }
}


emit_unwind_info (struct MonoAotCompile * acfg)
{
  struct GPtrArray * D.32548;
  void * * D.32549;
  long unsigned int D.32550;
  long unsigned int D.32551;
  void * * D.32552;
  void * D.32553;
  long int D.32554;
  unsigned int unwind_info_len.243;
  int unwind_info_len.244;
  guint8 * p.245;
  long int p.246;
  long int buf.247;
  long int D.32560;
  int D.32561;
  int unwind_info_len.248;
  int D.32563;
  unsigned int D.32564;
  unsigned int D.32565;
  unsigned int D.32566;
  unsigned int D.32567;
  int D.32568;
  unsigned int i.249;
  unsigned int D.32570;
  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.26219>;
      <D.26218>:
      {
        guint32 index;
        guint8 * unwind_info;
        guint32 unwind_info_len;
        guint8 buf[16];
        guint8 * p;

        try
          {
            D.32548 = acfg->unwind_ops;
            D.32549 = D.32548->pdata;
            D.32550 = (long unsigned int) i;
            D.32551 = D.32550 * 8;
            D.32552 = D.32549 + D.32551;
            D.32553 = *D.32552;
            D.32554 = (long int) D.32553;
            index = (guint32) D.32554;
            unwind_info = mono_get_cached_unwind_info (index, &unwind_info_len);
            p = &buf;
            unwind_info_len.243 = unwind_info_len;
            unwind_info_len.244 = (int) unwind_info_len.243;
            p.245 = p;
            encode_value (unwind_info_len.244, p.245, &p);
            p.245 = p;
            p.246 = (long int) p.245;
            buf.247 = (long int) &buf;
            D.32560 = p.246 - buf.247;
            D.32561 = (int) D.32560;
            emit_bytes (acfg, &buf, D.32561);
            unwind_info_len.243 = unwind_info_len;
            unwind_info_len.248 = (int) unwind_info_len.243;
            emit_bytes (acfg, unwind_info, unwind_info_len.248);
            D.32563 = acfg->stats.unwind_info_size;
            D.32564 = (unsigned int) D.32563;
            p.245 = p;
            p.246 = (long int) p.245;
            buf.247 = (long int) &buf;
            D.32560 = p.246 - buf.247;
            D.32565 = (unsigned int) D.32560;
            unwind_info_len.243 = unwind_info_len;
            D.32566 = D.32565 + unwind_info_len.243;
            D.32567 = D.32564 + D.32566;
            D.32568 = (int) D.32567;
            acfg->stats.unwind_info_size = D.32568;
          }
        finally
          {
            unwind_info_len = {CLOBBER};
            buf = {CLOBBER};
            p = {CLOBBER};
          }
      }
      i = i + 1;
      <D.26219>:
      i.249 = (unsigned int) i;
      D.32548 = acfg->unwind_ops;
      D.32570 = D.32548->len;
      if (i.249 < D.32570) goto <D.26218>; else goto <D.26220>;
      <D.26220>:
    }
  finally
    {
      symbol = {CLOBBER};
    }
}


emit_class_info (struct MonoAotCompile * acfg)
{
  struct MonoImage * D.32571;
  <unnamed-unsigned:24> D.32572;
  long unsigned int D.32573;
  long unsigned int D.32574;
  long unsigned int D.32575;
  long unsigned int D.32576;
  gint32 * D.32577;
  int D.32578;
  int D.32579;
  unsigned int D.32580;
  unsigned int D.32581;
  int D.32582;
  int D.32583;
  unsigned int D.32584;
  int D.32585;
  unsigned int D.32586;
  unsigned int D.32587;
  int D.32588;
  int i;
  char symbol[256];
  gint32 * offsets;

  try
    {
      D.32571 = acfg->image;
      D.32572 = D.32571->tables[2].rows;
      D.32573 = (long unsigned int) D.32572;
      D.32574 = D.32573 * 4;
      offsets = monoeg_malloc0 (D.32574);
      i = 0;
      goto <D.26228>;
      <D.26227>:
      D.32575 = (long unsigned int) i;
      D.32576 = D.32575 * 4;
      D.32577 = offsets + D.32576;
      D.32578 = i + 1;
      D.32579 = D.32578 | 33554432;
      D.32580 = (unsigned int) D.32579;
      D.32581 = emit_klass_info (acfg, D.32580);
      D.32582 = (int) D.32581;
      *D.32577 = D.32582;
      i = i + 1;
      <D.26228>:
      D.32571 = acfg->image;
      D.32572 = D.32571->tables[2].rows;
      D.32583 = (int) D.32572;
      if (D.32583 > i) goto <D.26227>; else goto <D.26229>;
      <D.26229>:
      sprintf (&symbol, "class_info_offsets");
      emit_section_change (acfg, ".rodata", 1);
      emit_alignment (acfg, 8);
      emit_label (acfg, &symbol);
      D.32571 = acfg->image;
      D.32572 = D.32571->tables[2].rows;
      D.32583 = (int) D.32572;
      D.32584 = emit_offset_table (acfg, D.32583, 10, offsets);
      D.32585 = acfg->stats.offsets_size;
      D.32586 = (unsigned int) D.32585;
      D.32587 = D.32586 + D.32584;
      D.32588 = (int) D.32587;
      acfg->stats.offsets_size = D.32588;
      monoeg_g_free (offsets);
    }
  finally
    {
      symbol = {CLOBBER};
    }
}


emit_klass_info (struct MonoAotCompile * acfg, guint32 token)
{
  struct MonoImage * D.32589;
  long unsigned int D.32592;
  guint8 * p.250;
  long int p.251;
  long int buf.252;
  long int D.32596;
  unsigned int D.32597;
  unsigned int D.32598;
  guint32 D.32599;
  int D.32600;
  int D.32601;
  _Bool D.32602;
  long int D.32603;
  long int D.32604;
  long unsigned int D.32607;
  long unsigned int D.32608;
  _Bool D.32609;
  long int D.32610;
  long int D.32611;
  int D.32614;
  _Bool D.32615;
  struct MonoMethod * * D.32616;
  long unsigned int D.32617;
  long unsigned int D.32618;
  struct MonoMethod * * D.32619;
  struct MonoMethodSignature * D.32622;
  long unsigned int D.32623;
  long unsigned int D.32624;
  struct GHashTable * D.32627;
  void * D.32628;
  struct MonoGenericContainer * D.32633;
  gboolean iftmp.253;
  int D.32639;
  int D.32640;
  <unnamed-unsigned:1> D.32641;
  int D.32642;
  int D.32643;
  int D.32644;
  <unnamed-unsigned:1> D.32645;
  int D.32646;
  int D.32647;
  int D.32648;
  <unnamed-unsigned:1> D.32649;
  int D.32650;
  int D.32651;
  int iftmp.254;
  struct MonoClassExt * D.32655;
  struct GList * D.32657;
  int D.32659;
  int D.32660;
  int D.32661;
  <unnamed-unsigned:1> D.32662;
  int D.32663;
  int D.32664;
  int D.32665;
  <unnamed-unsigned:1> D.32666;
  int D.32667;
  int D.32668;
  int D.32669;
  <unnamed-unsigned:1> D.32670;
  int D.32671;
  int D.32672;
  long unsigned int D.32673;
  struct MonoMethod * D.32676;
  long unsigned int D.32677;
  struct MonoMethod * D.32680;
  int D.32681;
  int D.32682;
  <unnamed-unsigned:4> D.32683;
  int D.32684;
  unsigned char D.32685;
  int D.32686;
  int D.32690;
  unsigned int D.32691;
  unsigned int D.32692;
  unsigned int D.32693;
  int D.32694;
  long int D.32695;
  _Bool D.32696;
  long int D.32697;
  long int D.32698;
  unsigned int D.32701;
  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.32589 = acfg->image;
      klass = mono_class_get (D.32589, token);
      iter = 0B;
      if (klass == 0B) goto <D.32590>; else goto <D.32591>;
      <D.32590>:
      mono_loader_clear_error ();
      buf_size = 16;
      D.32592 = (long unsigned int) buf_size;
      buf = monoeg_malloc (D.32592);
      p = buf;
      p.250 = p;
      encode_value (-1, p.250, &p);
      p.250 = p;
      p.251 = (long int) p.250;
      buf.252 = (long int) buf;
      D.32596 = p.251 - buf.252;
      D.32597 = (unsigned int) D.32596;
      D.32598 = add_to_blob (acfg, buf, D.32597);
      res = (int) D.32598;
      monoeg_g_free (buf);
      D.32599 = (guint32) res;
      return D.32599;
      <D.32591>:
      D.32600 = klass->vtable_size;
      D.32601 = D.32600 + 640;
      buf_size = D.32601 * 16;
      D.32592 = (long unsigned int) buf_size;
      buf = monoeg_malloc (D.32592);
      p = buf;
      D.32602 = klass == 0B;
      D.32603 = (long int) D.32602;
      D.32604 = __builtin_expect (D.32603, 0);
      if (D.32604 != 0) goto <D.32605>; else goto <D.32606>;
      <D.32605>:
      monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "aot-compiler.c", 5514, "klass");
      <D.32606>:
      mono_class_init (klass);
      mono_class_get_nested_types (klass, &iter);
      D.32607 = BIT_FIELD_REF <*klass, 64, 256>;
      D.32608 = D.32607 & 2147483648;
      D.32609 = D.32608 == 0;
      D.32610 = (long int) D.32609;
      D.32611 = __builtin_expect (D.32610, 0);
      if (D.32611 != 0) goto <D.32612>; else goto <D.32613>;
      <D.32612>:
      monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "aot-compiler.c", 5519, "klass->nested_classes_inited");
      <D.32613>:
      mono_class_setup_vtable (klass);
      D.32614 = mono_class_has_special_static_fields (klass);
      D.32615 = D.32614 == 0;
      no_special_static = (gboolean) D.32615;
      cant_encode = 0;
      i = 0;
      goto <D.25599>;
      <D.25598>:
      {
        struct MonoMethod * cm;

        D.32616 = klass->vtable;
        D.32617 = (long unsigned int) i;
        D.32618 = D.32617 * 8;
        D.32619 = D.32616 + D.32618;
        cm = *D.32619;
        if (cm != 0B) goto <D.32620>; else goto <D.32621>;
        <D.32620>:
        D.32622 = mono_method_signature (cm);
        D.32623 = BIT_FIELD_REF <*D.32622, 64, 64>;
        D.32624 = D.32623 & 144115188075855872;
        if (D.32624 != 0) goto <D.32625>; else goto <D.32626>;
        <D.32625>:
        D.32627 = acfg->token_info_hash;
        D.32628 = monoeg_g_hash_table_lookup (D.32627, cm);
        if (D.32628 == 0B) goto <D.32629>; else goto <D.32630>;
        <D.32629>:
        cant_encode = 1;
        <D.32630>:
        <D.32626>:
        <D.32621>:
      }
      i = i + 1;
      <D.25599>:
      D.32600 = klass->vtable_size;
      if (D.32600 > i) goto <D.25598>; else goto <D.25600>;
      <D.25600>:
      mono_class_has_finalizer (klass);
      D.32633 = klass->generic_container;
      if (D.32633 != 0B) goto <D.32631>; else goto <D.32634>;
      <D.32634>:
      if (cant_encode != 0) goto <D.32631>; else goto <D.32632>;
      <D.32631>:
      p.250 = p;
      encode_value (-1, p.250, &p);
      goto <D.25604>;
      <D.32632>:
      D.32600 = klass->vtable_size;
      p.250 = p;
      encode_value (D.32600, p.250, &p);
      D.32633 = klass->generic_container;
      if (D.32633 != 0B) goto <D.32636>; else goto <D.32637>;
      <D.32636>:
      iftmp.253 = 256;
      goto <D.32638>;
      <D.32637>:
      iftmp.253 = 0;
      <D.32638>:
      D.32639 = no_special_static << 7;
      D.32640 = iftmp.253 | D.32639;
      D.32641 = klass->has_static_refs;
      D.32642 = (int) D.32641;
      D.32643 = D.32642 << 6;
      D.32644 = D.32640 | D.32643;
      D.32645 = klass->has_references;
      D.32646 = (int) D.32645;
      D.32647 = D.32646 << 5;
      D.32648 = D.32644 | D.32647;
      D.32649 = klass->blittable;
      D.32650 = (int) D.32649;
      D.32651 = D.32650 << 4;
      D.32655 = klass->ext;
      if (D.32655 != 0B) goto <D.32656>; else goto <D.32653>;
      <D.32656>:
      D.32655 = klass->ext;
      D.32657 = D.32655->nested_classes;
      if (D.32657 != 0B) goto <D.32658>; else goto <D.32653>;
      <D.32658>:
      iftmp.254 = 1;
      goto <D.32654>;
      <D.32653>:
      iftmp.254 = 0;
      <D.32654>:
      D.32659 = iftmp.254 << 3;
      D.32660 = D.32651 | D.32659;
      D.32661 = D.32648 | D.32660;
      D.32662 = klass->has_cctor;
      D.32663 = (int) D.32662;
      D.32664 = D.32663 << 2;
      D.32665 = D.32661 | D.32664;
      D.32666 = klass->has_finalize;
      D.32667 = (int) D.32666;
      D.32668 = D.32667 << 1;
      D.32669 = D.32665 | D.32668;
      D.32670 = klass->ghcimpl;
      D.32671 = (int) D.32670;
      D.32672 = D.32669 | D.32671;
      p.250 = p;
      encode_value (D.32672, p.250, &p);
      D.32607 = BIT_FIELD_REF <*klass, 64, 256>;
      D.32673 = D.32607 & 67108864;
      if (D.32673 != 0) goto <D.32674>; else goto <D.32675>;
      <D.32674>:
      D.32676 = mono_class_get_cctor (klass);
      p.250 = p;
      encode_method_ref (acfg, D.32676, p.250, &p);
      <D.32675>:
      D.32607 = BIT_FIELD_REF <*klass, 64, 256>;
      D.32677 = D.32607 & 2097152;
      if (D.32677 != 0) goto <D.32678>; else goto <D.32679>;
      <D.32678>:
      D.32680 = mono_class_get_finalizer (klass);
      p.250 = p;
      encode_method_ref (acfg, D.32680, p.250, &p);
      <D.32679>:
      D.32681 = klass->instance_size;
      p.250 = p;
      encode_value (D.32681, p.250, &p);
      D.32682 = mono_class_data_size (klass);
      p.250 = p;
      encode_value (D.32682, p.250, &p);
      D.32683 = klass->packing_size;
      D.32684 = (int) D.32683;
      p.250 = p;
      encode_value (D.32684, p.250, &p);
      D.32685 = klass->min_align;
      D.32686 = (int) D.32685;
      p.250 = p;
      encode_value (D.32686, p.250, &p);
      i = 0;
      goto <D.25603>;
      <D.25602>:
      {
        struct MonoMethod * cm;

        D.32616 = klass->vtable;
        D.32617 = (long unsigned int) i;
        D.32618 = D.32617 * 8;
        D.32619 = D.32616 + D.32618;
        cm = *D.32619;
        if (cm != 0B) goto <D.32687>; else goto <D.32688>;
        <D.32687>:
        p.250 = p;
        encode_method_ref (acfg, cm, p.250, &p);
        goto <D.32689>;
        <D.32688>:
        p.250 = p;
        encode_value (0, p.250, &p);
        <D.32689>:
      }
      i = i + 1;
      <D.25603>:
      D.32600 = klass->vtable_size;
      if (D.32600 > i) goto <D.25602>; else goto <D.25604>;
      <D.25604>:
      D.32690 = acfg->stats.class_info_size;
      D.32691 = (unsigned int) D.32690;
      p.250 = p;
      p.251 = (long int) p.250;
      buf.252 = (long int) buf;
      D.32596 = p.251 - buf.252;
      D.32692 = (unsigned int) D.32596;
      D.32693 = D.32691 + D.32692;
      D.32694 = (int) D.32693;
      acfg->stats.class_info_size = D.32694;
      p.250 = p;
      p.251 = (long int) p.250;
      buf.252 = (long int) buf;
      D.32596 = p.251 - buf.252;
      D.32695 = (long int) buf_size;
      D.32696 = D.32596 >= D.32695;
      D.32697 = (long int) D.32696;
      D.32698 = __builtin_expect (D.32697, 0);
      if (D.32698 != 0) goto <D.32699>; else goto <D.32700>;
      <D.32699>:
      monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "aot-compiler.c", 5569, "p - buf < buf_size");
      <D.32700>:
      p.250 = p;
      p.251 = (long int) p.250;
      buf.252 = (long int) buf;
      D.32596 = p.251 - buf.252;
      D.32597 = (unsigned int) D.32596;
      D.32701 = add_to_blob (acfg, buf, D.32597);
      res = (int) D.32701;
      monoeg_g_free (buf);
      D.32599 = (guint32) res;
      return D.32599;
    }
  finally
    {
      p = {CLOBBER};
      iter = {CLOBBER};
    }
}


emit_plt (struct MonoAotCompile * acfg)
{
  char * D.32704;
  struct GHashTable * D.32707;
  long unsigned int D.32708;
  const void * D.32709;
  int D.32710;
  int D.32715;
  int D.32718;
  struct GHashTable * D.32721;
  struct MonoMethod * D.32722;
  int D.32727;
  long unsigned int D.32729;
  long unsigned int D.32730;
  struct FILE * D.32732;
  char * D.32733;
  char * D.32734;
  int D.32737;
  int D.32746;
  char * D.32749;
  unsigned int i.255;
  unsigned int D.32753;
  int D.32760;
  int D.32765;
  int D.32768;
  char * D.32771;
  char * D.32776;
  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.32704 = acfg->plt_symbol;
      emit_label (acfg, D.32704);
      i = 0;
      goto <D.25633>;
      <D.25632>:
      {
        char * debug_sym;
        struct MonoPltEntry * plt_entry;
        struct MonoJumpInfo * ji;

        debug_sym = 0B;
        plt_entry = 0B;
        if (i == 0) goto <D.32705>; else goto <D.32706>;
        <D.32705>:
        // predicted unlikely by continue predictor.
        goto <D.25630>;
        <D.32706>:
        D.32707 = acfg->plt_offset_to_entry;
        D.32708 = (long unsigned int) i;
        D.32709 = (const void *) D.32708;
        plt_entry = monoeg_g_hash_table_lookup (D.32707, D.32709);
        ji = plt_entry->ji;
        D.32710 = acfg->llvm;
        if (D.32710 != 0) goto <D.32711>; else goto <D.32712>;
        <D.32711>:
        if (ji != 0B) goto <D.32713>; else goto <D.32714>;
        <D.32713>:
        D.32715 = is_direct_callable (acfg, 0B, ji);
        if (D.32715 != 0) goto <D.32716>; else goto <D.32717>;
        <D.32716>:
        D.32718 = acfg->use_bin_writer;
        if (D.32718 == 0) goto <D.32719>; else goto <D.32720>;
        <D.32719>:
        {
          struct MonoCompile * callee_cfg;

          D.32721 = acfg->method_to_cfg;
          D.32722 = ji->data.method;
          callee_cfg = monoeg_g_hash_table_lookup (D.32721, D.32722);
          if (callee_cfg != 0B) goto <D.32723>; else goto <D.32724>;
          <D.32723>:
          D.32727 = acfg->thumb_mixed;
          if (D.32727 != 0) goto <D.32728>; else goto <D.32725>;
          <D.32728>:
          D.32729 = BIT_FIELD_REF <*callee_cfg, 64, 5568>;
          D.32730 = D.32729 & 1099511627776;
          if (D.32730 == 0) goto <D.32731>; else goto <D.32725>;
          <D.32731>:
          emit_set_thumb_mode (acfg);
          D.32732 = acfg->fp;
          fprintf (D.32732, "\n.thumb_func\n");
          D.32733 = plt_entry->llvm_symbol;
          emit_label (acfg, D.32733);
          D.32732 = acfg->fp;
          fprintf (D.32732, "bx pc\n");
          D.32732 = acfg->fp;
          fprintf (D.32732, "nop\n");
          emit_set_arm_mode (acfg);
          D.32732 = acfg->fp;
          D.32734 = callee_cfg->asm_symbol;
          fprintf (D.32732, "b %s\n", D.32734);
          goto <D.32726>;
          <D.32725>:
          D.32732 = acfg->fp;
          D.32733 = plt_entry->llvm_symbol;
          D.32734 = callee_cfg->asm_symbol;
          fprintf (D.32732, "\n.set %s, %s\n", D.32733, D.32734);
          <D.32726>:
          // predicted unlikely by continue predictor.
          goto <D.25630>;
          <D.32724>:
        }
        <D.32720>:
        <D.32717>:
        <D.32714>:
        <D.32712>:
        debug_sym = plt_entry->debug_sym;
        D.32727 = acfg->thumb_mixed;
        if (D.32727 != 0) goto <D.32735>; else goto <D.32736>;
        <D.32735>:
        D.32737 = plt_entry->jit_used;
        if (D.32737 == 0) goto <D.32738>; else goto <D.32739>;
        <D.32738>:
        // predicted unlikely by continue predictor.
        goto <D.25630>;
        <D.32739>:
        <D.32736>:
        D.32710 = acfg->llvm;
        if (D.32710 != 0) goto <D.32740>; else goto <D.32741>;
        <D.32740>:
        D.32727 = acfg->thumb_mixed;
        if (D.32727 == 0) goto <D.32742>; else goto <D.32743>;
        <D.32742>:
        D.32733 = plt_entry->llvm_symbol;
        emit_label (acfg, D.32733);
        <D.32743>:
        <D.32741>:
        if (debug_sym != 0B) goto <D.32744>; else goto <D.32745>;
        <D.32744>:
        D.32746 = acfg->need_no_dead_strip;
        if (D.32746 != 0) goto <D.32747>; else goto <D.32748>;
        <D.32747>:
        emit_unset_mode (acfg);
        D.32732 = acfg->fp;
        fprintf (D.32732, "\t.no_dead_strip %s\n", debug_sym);
        <D.32748>:
        emit_local_symbol (acfg, debug_sym, 0B, 1);
        emit_label (acfg, debug_sym);
        <D.32745>:
        D.32749 = plt_entry->symbol;
        emit_label (acfg, D.32749);
        arch_emit_plt_entry (acfg, i);
        if (debug_sym != 0B) goto <D.32750>; else goto <D.32751>;
        <D.32750>:
        emit_symbol_size (acfg, debug_sym, ".");
        <D.32751>:
      }
      <D.25630>:
      i = i + 1;
      <D.25633>:
      i.255 = (unsigned int) i;
      D.32753 = acfg->plt_offset;
      if (i.255 < D.32753) goto <D.25632>; else goto <D.25634>;
      <D.25634>:
      D.32727 = acfg->thumb_mixed;
      if (D.32727 != 0) goto <D.32754>; else goto <D.32755>;
      <D.32754>:
      emit_zero_bytes (acfg, 16);
      i = 0;
      goto <D.25640>;
      <D.25639>:
      {
        char * debug_sym;
        struct MonoPltEntry * plt_entry;
        struct MonoJumpInfo * ji;

        debug_sym = 0B;
        plt_entry = 0B;
        if (i == 0) goto <D.32756>; else goto <D.32757>;
        <D.32756>:
        // predicted unlikely by continue predictor.
        goto <D.25638>;
        <D.32757>:
        D.32707 = acfg->plt_offset_to_entry;
        D.32708 = (long unsigned int) i;
        D.32709 = (const void *) D.32708;
        plt_entry = monoeg_g_hash_table_lookup (D.32707, D.32709);
        ji = plt_entry->ji;
        if (ji != 0B) goto <D.32758>; else goto <D.32759>;
        <D.32758>:
        D.32760 = is_direct_callable (acfg, 0B, ji);
        if (D.32760 != 0) goto <D.32761>; else goto <D.32762>;
        <D.32761>:
        D.32718 = acfg->use_bin_writer;
        if (D.32718 == 0) goto <D.32763>; else goto <D.32764>;
        <D.32763>:
        // predicted unlikely by continue predictor.
        goto <D.25638>;
        <D.32764>:
        <D.32762>:
        <D.32759>:
        D.32765 = plt_entry->llvm_used;
        if (D.32765 == 0) goto <D.32766>; else goto <D.32767>;
        <D.32766>:
        // predicted unlikely by continue predictor.
        goto <D.25638>;
        <D.32767>:
        D.32768 = acfg->aot_opts.write_symbols;
        if (D.32768 != 0) goto <D.32769>; else goto <D.32770>;
        <D.32769>:
        D.32771 = plt_entry->debug_sym;
        if (D.32771 != 0B) goto <D.32772>; else goto <D.32773>;
        <D.32772>:
        D.32771 = plt_entry->debug_sym;
        debug_sym = monoeg_g_strdup_printf ("%s_thumb", D.32771);
        <D.32773>:
        <D.32770>:
        if (debug_sym != 0B) goto <D.32774>; else goto <D.32775>;
        <D.32774>:
        emit_local_symbol (acfg, debug_sym, 0B, 1);
        emit_label (acfg, debug_sym);
        <D.32775>:
        D.32732 = acfg->fp;
        fprintf (D.32732, "\n.thumb_func\n");
        D.32776 = plt_entry->llvm_symbol;
        emit_label (acfg, D.32776);
        arch_emit_llvm_plt_entry (acfg, i);
        if (debug_sym != 0B) goto <D.32777>; else goto <D.32778>;
        <D.32777>:
        emit_symbol_size (acfg, debug_sym, ".");
        monoeg_g_free (debug_sym);
        <D.32778>:
      }
      <D.25638>:
      i = i + 1;
      <D.25640>:
      i.255 = (unsigned int) i;
      D.32753 = acfg->plt_offset;
      if (i.255 < D.32753) goto <D.25639>; else goto <D.25641>;
      <D.25641>:
      <D.32755>:
      D.32704 = acfg->plt_symbol;
      emit_symbol_size (acfg, D.32704, ".");
      sprintf (&symbol, "plt_end");
      emit_label (acfg, &symbol);
    }
  finally
    {
      symbol = {CLOBBER};
    }
}


arch_emit_plt_entry (struct MonoAotCompile * acfg, int index)
{
  unsigned int D.32779;
  unsigned int index.256;
  unsigned int D.32781;
  int D.32782;
  _Bool D.32783;
  long int D.32784;
  long int D.32785;
  struct FILE * D.32788;
  guint32 * D.32789;
  long unsigned int D.32790;
  long unsigned int D.32791;
  guint32 * D.32792;
  unsigned int D.32793;
  int D.32794;
  guint32 offset;

  D.32779 = acfg->plt_got_offset_base;
  index.256 = (unsigned int) index;
  D.32781 = D.32779 + index.256;
  offset = D.32781 * 8;
  D.32782 = acfg->use_bin_writer;
  D.32783 = D.32782 != 0;
  D.32784 = (long int) D.32783;
  D.32785 = __builtin_expect (D.32784, 0);
  if (D.32785 != 0) goto <D.32786>; else goto <D.32787>;
  <D.32786>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "aot-compiler.c", 955, "!acfg->use_bin_writer");
  <D.32787>:
  emit_unset_mode (acfg);
  D.32788 = acfg->fp;
  fprintf (D.32788, "lis 11, %d@h\n", offset);
  D.32788 = acfg->fp;
  fprintf (D.32788, "ori 11, 11, %d@l\n", offset);
  D.32788 = acfg->fp;
  fprintf (D.32788, "add 11, 11, 30\n");
  D.32788 = acfg->fp;
  fprintf (D.32788, "%s 11, 0(11)\n", "ld");
  D.32788 = acfg->fp;
  fprintf (D.32788, "%s 2, %d(11)\n", "ld", 8);
  D.32788 = acfg->fp;
  fprintf (D.32788, "%s 11, 0(11)\n", "ld");
  D.32788 = acfg->fp;
  fprintf (D.32788, "mtctr 11\n");
  D.32788 = acfg->fp;
  fprintf (D.32788, "bctr\n");
  D.32789 = acfg->plt_got_info_offsets;
  D.32790 = (long unsigned int) index;
  D.32791 = D.32790 * 4;
  D.32792 = D.32789 + D.32791;
  D.32793 = *D.32792;
  D.32794 = (int) D.32793;
  emit_int32 (acfg, D.32794);
}


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.32795;
  unsigned int D.32796;
  int D.32797;
  void * * D.32798;
  long unsigned int D.32799;
  long unsigned int D.32800;
  void * * D.32801;
  struct MonoAssembly * D.32802;
  struct MonoImage * D.32803;
  _Bool D.32804;
  long int D.32805;
  long int D.32806;
  const char * D.32809;
  char * D.32810;
  const char * iftmp.257;
  const char * D.32812;
  mono_byte[17] * D.32816;
  unsigned int D.32817;
  int D.32818;
  short unsigned int D.32819;
  int D.32820;
  short unsigned int D.32821;
  int D.32822;
  short unsigned int D.32823;
  int D.32824;
  short unsigned int D.32825;
  int D.32826;
  unsigned int i.258;
  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.32795 = acfg->image_table;
      D.32796 = D.32795->len;
      D.32797 = (int) D.32796;
      emit_int32 (acfg, D.32797);
      i = 0;
      goto <D.26270>;
      <D.26269>:
      {
        struct MonoImage * image;
        struct MonoAssemblyName * aname;

        D.32795 = acfg->image_table;
        D.32798 = D.32795->pdata;
        D.32799 = (long unsigned int) i;
        D.32800 = D.32799 * 8;
        D.32801 = D.32798 + D.32800;
        image = *D.32801;
        D.32802 = image->assembly;
        aname = &D.32802->aname;
        D.32802 = image->assembly;
        D.32803 = D.32802->image;
        D.32804 = D.32803 != image;
        D.32805 = (long int) D.32804;
        D.32806 = __builtin_expect (D.32805, 0);
        if (D.32806 != 0) goto <D.32807>; else goto <D.32808>;
        <D.32807>:
        monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "aot-compiler.c", 7785, "image->assembly->image == image");
        <D.32808>:
        D.32809 = image->assembly_name;
        emit_string (acfg, D.32809);
        D.32810 = image->guid;
        emit_string (acfg, D.32810);
        D.32812 = aname->culture;
        if (D.32812 != 0B) goto <D.32813>; else goto <D.32814>;
        <D.32813>:
        iftmp.257 = aname->culture;
        goto <D.32815>;
        <D.32814>:
        iftmp.257 = "";
        <D.32815>:
        emit_string (acfg, iftmp.257);
        D.32816 = &aname->public_key_token;
        emit_string (acfg, D.32816);
        emit_alignment (acfg, 8);
        D.32817 = aname->flags;
        D.32818 = (int) D.32817;
        emit_int32 (acfg, D.32818);
        D.32819 = aname->major;
        D.32820 = (int) D.32819;
        emit_int32 (acfg, D.32820);
        D.32821 = aname->minor;
        D.32822 = (int) D.32821;
        emit_int32 (acfg, D.32822);
        D.32823 = aname->build;
        D.32824 = (int) D.32823;
        emit_int32 (acfg, D.32824);
        D.32825 = aname->revision;
        D.32826 = (int) D.32825;
        emit_int32 (acfg, D.32826);
      }
      i = i + 1;
      <D.26270>:
      i.258 = (unsigned int) i;
      D.32795 = acfg->image_table;
      D.32796 = D.32795->len;
      if (i.258 < D.32796) goto <D.26269>; else goto <D.26271>;
      <D.26271>:
    }
  finally
    {
      symbol = {CLOBBER};
    }
}


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

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


emit_got (struct MonoAotCompile * acfg)
{
  int D.32829;
  char * D.32832;
  unsigned int D.32833;
  unsigned int D.32836;
  int D.32837;
  char symbol[256];

  try
    {
      D.32829 = acfg->llvm;
      if (D.32829 == 0) goto <D.32830>; else goto <D.32831>;
      <D.32830>:
      D.32832 = acfg->got_symbol;
      sprintf (&symbol, "%s", D.32832);
      emit_section_change (acfg, ".bss", 0);
      emit_alignment (acfg, 8);
      emit_local_symbol (acfg, &symbol, "got_end", 0);
      emit_label (acfg, &symbol);
      D.32833 = acfg->got_offset;
      if (D.32833 != 0) goto <D.32834>; else goto <D.32835>;
      <D.32834>:
      D.32833 = acfg->got_offset;
      D.32836 = D.32833 * 8;
      D.32837 = (int) D.32836;
      emit_zero_bytes (acfg, D.32837);
      <D.32835>:
      sprintf (&symbol, "got_end");
      emit_label (acfg, &symbol);
      <D.32831>:
    }
  finally
    {
      symbol = {CLOBBER};
    }
}


emit_file_info (struct MonoAotCompile * acfg)
{
  struct MonoImage * D.32838;
  char * D.32839;
  int D.32840;
  struct MonoAssembly * D.32844;
  const char * D.32845;
  long unsigned int D.32846;
  unsigned int D.32847;
  unsigned int D.32848;
  unsigned int D.32849;
  const char * D.32850;
  int D.32851;
  char * D.32854;
  char * D.32855;
  int D.32856;
  int D.32860;
  unsigned int D.32864;
  int D.32868;
  unsigned int D.32875;
  int D.32876;
  unsigned int D.32877;
  unsigned int D.32878;
  int D.32879;
  unsigned int D.32880;
  int D.32881;
  unsigned int D.32882;
  int D.32883;
  <unnamed type> D.32884;
  int D.32885;
  unsigned int D.32886;
  int D.32887;
  unsigned int D.32888;
  int D.32889;
  unsigned int D.32890;
  int D.32891;
  unsigned int D.32892;
  int D.32893;
  unsigned int D.32894;
  int D.32895;
  int D.32896;
  unsigned int D.32897;
  int D.32898;
  unsigned int D.32899;
  int D.32900;
  const short unsigned int * * D.32903;
  const short unsigned int * D.32904;
  char D.32905;
  long unsigned int D.32906;
  long unsigned int D.32907;
  const short unsigned int * D.32908;
  short unsigned int D.32909;
  int D.32910;
  int D.32911;
  gchar * D.32916;
  char symbol[256];
  int i;
  int gc_name_offset;
  const char * gc_name;
  char * build_info;

  try
    {
      D.32838 = acfg->image;
      D.32839 = D.32838->guid;
      emit_string_symbol (acfg, "assembly_guid", D.32839);
      D.32840 = acfg->aot_opts.bind_to_runtime_version;
      if (D.32840 != 0) goto <D.32841>; else goto <D.32842>;
      <D.32841>:
      build_info = mono_get_runtime_build_info ();
      emit_string_symbol (acfg, "runtime_version", build_info);
      monoeg_g_free (build_info);
      goto <D.32843>;
      <D.32842>:
      emit_string_symbol (acfg, "runtime_version", "");
      <D.32843>:
      D.32838 = acfg->image;
      D.32844 = D.32838->assembly;
      D.32845 = D.32844->aname.name;
      emit_string_symbol (acfg, "assembly_name", D.32845);
      gc_name = mono_gc_get_gc_name ();
      D.32846 = strlen (gc_name);
      D.32847 = (unsigned int) D.32846;
      D.32848 = D.32847 + 1;
      D.32849 = add_to_blob (acfg, gc_name, D.32848);
      gc_name_offset = (int) D.32849;
      D.32850 = acfg->user_symbol_prefix;
      sprintf (&symbol, "%smono_aot_file_info", D.32850);
      emit_section_change (acfg, ".data", 0);
      emit_alignment (acfg, 8);
      emit_label (acfg, &symbol);
      D.32851 = acfg->aot_opts.static_link;
      if (D.32851 == 0) goto <D.32852>; else goto <D.32853>;
      <D.32852>:
      emit_global (acfg, &symbol, 0);
      <D.32853>:
      emit_int32 (acfg, 97);
      emit_int32 (acfg, 0);
      D.32854 = acfg->got_symbol;
      emit_pointer (acfg, D.32854);
      D.32855 = acfg->methods_symbol;
      emit_pointer (acfg, D.32855);
      D.32856 = acfg->llvm;
      if (D.32856 != 0) goto <D.32857>; else goto <D.32858>;
      <D.32857>:
      emit_pointer (acfg, "mono_eh_frame");
      goto <D.32859>;
      <D.32858>:
      emit_pointer (acfg, 0B);
      <D.32859>:
      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.32860 = acfg->direct_method_addresses;
      if (D.32860 != 0) goto <D.32861>; else goto <D.32862>;
      <D.32861>:
      emit_pointer (acfg, "method_addresses");
      goto <D.32863>;
      <D.32862>:
      emit_pointer (acfg, 0B);
      <D.32863>:
      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.32864 = acfg->num_trampoline_got_entries;
      if (D.32864 != 0) goto <D.32865>; else goto <D.32866>;
      <D.32865>:
      emit_pointer (acfg, "specific_trampolines");
      emit_pointer (acfg, "static_rgctx_trampolines");
      emit_pointer (acfg, "imt_thunks");
      emit_pointer (acfg, "gsharedvt_arg_trampolines");
      goto <D.32867>;
      <D.32866>:
      emit_pointer (acfg, 0B);
      emit_pointer (acfg, 0B);
      emit_pointer (acfg, 0B);
      emit_pointer (acfg, 0B);
      <D.32867>:
      D.32868 = acfg->thumb_mixed;
      if (D.32868 != 0) goto <D.32869>; else goto <D.32870>;
      <D.32869>:
      emit_pointer (acfg, "thumb_end");
      goto <D.32871>;
      <D.32870>:
      emit_pointer (acfg, 0B);
      <D.32871>:
      D.32851 = acfg->aot_opts.static_link;
      if (D.32851 != 0) goto <D.32872>; else goto <D.32873>;
      <D.32872>:
      emit_pointer (acfg, "globals");
      goto <D.32874>;
      <D.32873>:
      emit_pointer (acfg, 0B);
      <D.32874>:
      emit_pointer (acfg, "assembly_name");
      emit_pointer (acfg, "unbox_trampolines");
      emit_pointer (acfg, "unbox_trampolines_end");
      D.32875 = acfg->plt_got_offset_base;
      D.32876 = (int) D.32875;
      emit_int32 (acfg, D.32876);
      D.32877 = acfg->got_offset;
      D.32878 = D.32877 * 8;
      D.32879 = (int) D.32878;
      emit_int32 (acfg, D.32879);
      D.32880 = acfg->plt_offset;
      D.32881 = (int) D.32880;
      emit_int32 (acfg, D.32881);
      D.32882 = acfg->nmethods;
      D.32883 = (int) D.32882;
      emit_int32 (acfg, D.32883);
      D.32884 = acfg->flags;
      D.32885 = (int) D.32884;
      emit_int32 (acfg, D.32885);
      D.32886 = acfg->opts;
      D.32887 = (int) D.32886;
      emit_int32 (acfg, D.32887);
      D.32888 = acfg->simd_opts;
      D.32889 = (int) D.32888;
      emit_int32 (acfg, D.32889);
      emit_int32 (acfg, gc_name_offset);
      i = 0;
      goto <D.26349>;
      <D.26348>:
      D.32890 = acfg->num_trampolines[i];
      D.32891 = (int) D.32890;
      emit_int32 (acfg, D.32891);
      i = i + 1;
      <D.26349>:
      if (i <= 3) goto <D.26348>; else goto <D.26350>;
      <D.26350>:
      i = 0;
      goto <D.26352>;
      <D.26351>:
      D.32892 = acfg->trampoline_got_offset_base[i];
      D.32893 = (int) D.32892;
      emit_int32 (acfg, D.32893);
      i = i + 1;
      <D.26352>:
      if (i <= 3) goto <D.26351>; else goto <D.26353>;
      <D.26353>:
      i = 0;
      goto <D.26355>;
      <D.26354>:
      D.32894 = acfg->trampoline_size[i];
      D.32895 = (int) D.32894;
      emit_int32 (acfg, D.32895);
      i = i + 1;
      <D.26355>:
      if (i <= 3) goto <D.26354>; else goto <D.26356>;
      <D.26356>:
      D.32896 = acfg->aot_opts.nrgctx_fetch_trampolines;
      emit_int32 (acfg, D.32896);
      emit_int32 (acfg, 8);
      emit_int32 (acfg, 8);
      emit_int32 (acfg, 14);
      D.32897 = acfg->tramp_page_size;
      D.32898 = (int) D.32897;
      emit_int32 (acfg, D.32898);
      i = 0;
      goto <D.26358>;
      <D.26357>:
      D.32899 = acfg->tramp_page_code_offsets[i];
      D.32900 = (int) D.32899;
      emit_int32 (acfg, D.32900);
      i = i + 1;
      <D.26358>:
      if (i <= 3) goto <D.26357>; else goto <D.26359>;
      <D.26359>:
      D.32851 = acfg->aot_opts.static_link;
      if (D.32851 != 0) goto <D.32901>; else goto <D.32902>;
      <D.32901>:
      {
        char * p;

        D.32850 = acfg->user_symbol_prefix;
        D.32838 = acfg->image;
        D.32844 = D.32838->assembly;
        D.32845 = D.32844->aname.name;
        sprintf (&symbol, "%smono_aot_module_%s_info", D.32850, D.32845);
        p = &symbol;
        p = &symbol;
        goto <D.26362>;
        <D.26361>:
        D.32903 = __ctype_b_loc ();
        D.32904 = *D.32903;
        D.32905 = *p;
        D.32906 = (long unsigned int) D.32905;
        D.32907 = D.32906 * 2;
        D.32908 = D.32904 + D.32907;
        D.32909 = *D.32908;
        D.32910 = (int) D.32909;
        D.32911 = D.32910 & 8;
        if (D.32911 == 0) goto <D.32912>; else goto <D.32913>;
        <D.32912>:
        D.32905 = *p;
        if (D.32905 != 95) goto <D.32914>; else goto <D.32915>;
        <D.32914>:
        *p = 95;
        <D.32915>:
        <D.32913>:
        p = p + 1;
        <D.26362>:
        D.32905 = *p;
        if (D.32905 != 0) goto <D.26361>; else goto <D.26363>;
        <D.26363>:
        D.32916 = monoeg_strdup (&symbol);
        acfg->static_linking_symbol = D.32916;
        emit_global_inner (acfg, &symbol, 0);
        emit_alignment (acfg, 8);
        emit_label (acfg, &symbol);
        D.32850 = acfg->user_symbol_prefix;
        emit_pointer_2 (acfg, D.32850, "mono_aot_file_info");
      }
      <D.32902>:
    }
  finally
    {
      symbol = {CLOBBER};
    }
}


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

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


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

  D.32918 = *prefix;
  if (D.32918 != 0) goto <D.32919>; else goto <D.32920>;
  <D.32919>:
  {
    char * s;

    s = monoeg_g_strdup_printf ("%s%s", prefix, target);
    D.32921 = acfg->w;
    img_writer_emit_pointer (D.32921, s);
    monoeg_g_free (s);
  }
  goto <D.32922>;
  <D.32920>:
  D.32921 = acfg->w;
  img_writer_emit_pointer (D.32921, target);
  <D.32922>:
}


emit_blob (struct MonoAotCompile * acfg)
{
  char * D.32923;
  unsigned int D.32924;
  int D.32925;
  char symbol[128];

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


emit_objc_selectors (struct MonoAotCompile * acfg)
{
  struct GPtrArray * D.32928;
  unsigned int D.32930;
  struct MonoImageWriter * D.32931;
  struct FILE * D.32932;
  _Bool D.32933;
  long int D.32934;
  long int D.32935;
  unsigned int i.259;
  void * * D.32939;
  long unsigned int D.32940;
  long unsigned int D.32941;
  void * * D.32942;
  void * D.32943;
  int i;

  D.32928 = acfg->objc_selectors;
  if (D.32928 == 0B) goto <D.32926>; else goto <D.32929>;
  <D.32929>:
  D.32928 = acfg->objc_selectors;
  D.32930 = D.32928->len;
  if (D.32930 == 0) goto <D.32926>; else goto <D.32927>;
  <D.32926>:
  return;
  <D.32927>:
  D.32931 = acfg->w;
  img_writer_emit_unset_mode (D.32931);
  D.32932 = acfg->fp;
  D.32933 = D.32932 == 0B;
  D.32934 = (long int) D.32933;
  D.32935 = __builtin_expect (D.32934, 0);
  if (D.32935 != 0) goto <D.32936>; else goto <D.32937>;
  <D.32936>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "aot-compiler.c", 8235, "acfg->fp");
  <D.32937>:
  D.32932 = acfg->fp;
  fprintf (D.32932, ".section\t__DATA,__objc_selrefs,literal_pointers,no_dead_strip\n");
  D.32932 = acfg->fp;
  fprintf (D.32932, ".align\t2\n");
  i = 0;
  goto <D.26373>;
  <D.26372>:
  D.32932 = acfg->fp;
  fprintf (D.32932, "L_OBJC_SELECTOR_REFERENCES_%d:\n", i);
  D.32932 = acfg->fp;
  fprintf (D.32932, ".long\tL_OBJC_METH_VAR_NAME_%d\n", i);
  i = i + 1;
  <D.26373>:
  i.259 = (unsigned int) i;
  D.32928 = acfg->objc_selectors;
  D.32930 = D.32928->len;
  if (i.259 < D.32930) goto <D.26372>; else goto <D.26374>;
  <D.26374>:
  D.32932 = acfg->fp;
  fprintf (D.32932, ".section\t__TEXT,__cstring,cstring_literals\n");
  i = 0;
  goto <D.26376>;
  <D.26375>:
  D.32932 = acfg->fp;
  fprintf (D.32932, "L_OBJC_METH_VAR_NAME_%d:\n", i);
  D.32932 = acfg->fp;
  D.32928 = acfg->objc_selectors;
  D.32939 = D.32928->pdata;
  D.32940 = (long unsigned int) i;
  D.32941 = D.32940 * 8;
  D.32942 = D.32939 + D.32941;
  D.32943 = *D.32942;
  fprintf (D.32932, ".asciz \"%s\"\n", D.32943);
  i = i + 1;
  <D.26376>:
  i.259 = (unsigned int) i;
  D.32928 = acfg->objc_selectors;
  D.32930 = D.32928->len;
  if (i.259 < D.32930) goto <D.26375>; else goto <D.26377>;
  <D.26377>:
  D.32932 = acfg->fp;
  fprintf (D.32932, ".section\t__DATA,__objc_imageinfo,regular,no_dead_strip\n");
  D.32932 = acfg->fp;
  fprintf (D.32932, ".align\t2\n");
  D.32932 = acfg->fp;
  fprintf (D.32932, "L_OBJC_IMAGE_INFO:\n");
  D.32932 = acfg->fp;
  fprintf (D.32932, ".long\t0\n");
  D.32932 = acfg->fp;
  fprintf (D.32932, ".long\t16\n");
}


emit_globals (struct MonoAotCompile * acfg)
{
  int D.32945;
  struct GPtrArray * D.32948;
  unsigned int D.32949;
  double D.32950;
  double D.32951;
  int D.32952;
  unsigned int D.32953;
  unsigned int D.32954;
  unsigned int table_size.260;
  void * * D.32956;
  long unsigned int D.32957;
  long unsigned int D.32958;
  void * * D.32959;
  unsigned int D.32960;
  unsigned int i.261;
  void * * D.32962;
  long unsigned int D.32963;
  long unsigned int D.32964;
  void * * D.32965;
  struct GlobalsTableEntry * D.32969;
  unsigned int D.32970;
  unsigned int i.262;
  _Bool D.32972;
  long int D.32973;
  long int D.32974;
  void * * D.32977;
  unsigned int D.32981;
  unsigned int D.32982;
  int D.32983;
  struct GlobalsTableEntry * D.32984;
  unsigned int D.32987;
  int D.32988;
  const char * D.32990;
  int i;
  int table_size;
  guint32 hash;
  struct GPtrArray * table;
  char symbol[256];
  struct GlobalsTableEntry * entry;
  struct GlobalsTableEntry * new_entry;

  try
    {
      D.32945 = acfg->aot_opts.static_link;
      if (D.32945 == 0) goto <D.32946>; else goto <D.32947>;
      <D.32946>:
      return;
      <D.32947>:
      D.32948 = acfg->globals;
      D.32949 = D.32948->len;
      D.32950 = (double) D.32949;
      D.32951 = D.32950 * 1.5e+0;
      D.32952 = (int) D.32951;
      D.32953 = (unsigned int) D.32952;
      D.32954 = monoeg_g_spaced_primes_closest (D.32953);
      table_size = (int) D.32954;
      table_size.260 = (unsigned int) table_size;
      table = monoeg_g_ptr_array_sized_new (table_size.260);
      i = 0;
      goto <D.26311>;
      <D.26310>:
      monoeg_g_ptr_array_add (table, 0B);
      i = i + 1;
      <D.26311>:
      if (i < table_size) goto <D.26310>; else goto <D.26312>;
      <D.26312>:
      i = 0;
      goto <D.26318>;
      <D.26317>:
      {
        char * name;

        D.32948 = acfg->globals;
        D.32956 = D.32948->pdata;
        D.32957 = (long unsigned int) i;
        D.32958 = D.32957 * 8;
        D.32959 = D.32956 + D.32958;
        name = *D.32959;
        D.32960 = mono_metadata_str_hash (name);
        table_size.260 = (unsigned int) table_size;
        hash = D.32960 % table_size.260;
        new_entry = monoeg_malloc0 (16);
        i.261 = (unsigned int) i;
        new_entry->value = i.261;
        D.32962 = table->pdata;
        D.32963 = (long unsigned int) hash;
        D.32964 = D.32963 * 8;
        D.32965 = D.32962 + D.32964;
        entry = *D.32965;
        if (entry == 0B) goto <D.32966>; else goto <D.32967>;
        <D.32966>:
        new_entry->index = hash;
        D.32962 = table->pdata;
        D.32963 = (long unsigned int) hash;
        D.32964 = D.32963 * 8;
        D.32965 = D.32962 + D.32964;
        *D.32965 = new_entry;
        goto <D.32968>;
        <D.32967>:
        goto <D.26315>;
        <D.26314>:
        entry = entry->next;
        <D.26315>:
        D.32969 = entry->next;
        if (D.32969 != 0B) goto <D.26314>; else goto <D.26316>;
        <D.26316>:
        entry->next = new_entry;
        D.32970 = table->len;
        new_entry->index = D.32970;
        monoeg_g_ptr_array_add (table, new_entry);
        <D.32968>:
      }
      i = i + 1;
      <D.26318>:
      i.262 = (unsigned int) i;
      D.32948 = acfg->globals;
      D.32949 = D.32948->len;
      if (i.262 < D.32949) goto <D.26317>; else goto <D.26319>;
      <D.26319>:
      sprintf (&symbol, ".Lglobals_hash");
      emit_section_change (acfg, ".rodata", 0);
      emit_alignment (acfg, 8);
      emit_label (acfg, &symbol);
      D.32972 = table_size > 64999;
      D.32973 = (long int) D.32972;
      D.32974 = __builtin_expect (D.32973, 0);
      if (D.32974 != 0) goto <D.32975>; else goto <D.32976>;
      <D.32975>:
      monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "aot-compiler.c", 7948, "table_size < 65000");
      <D.32976>:
      emit_int16 (acfg, table_size);
      i = 0;
      goto <D.26322>;
      <D.26321>:
      {
        struct GlobalsTableEntry * entry;

        D.32962 = table->pdata;
        D.32957 = (long unsigned int) i;
        D.32958 = D.32957 * 8;
        D.32977 = D.32962 + D.32958;
        entry = *D.32977;
        if (entry == 0B) goto <D.32978>; else goto <D.32979>;
        <D.32978>:
        emit_int16 (acfg, 0);
        emit_int16 (acfg, 0);
        goto <D.32980>;
        <D.32979>:
        D.32981 = entry->value;
        D.32982 = D.32981 + 1;
        D.32983 = (int) D.32982;
        emit_int16 (acfg, D.32983);
        D.32984 = entry->next;
        if (D.32984 != 0B) goto <D.32985>; else goto <D.32986>;
        <D.32985>:
        D.32984 = entry->next;
        D.32987 = D.32984->index;
        D.32988 = (int) D.32987;
        emit_int16 (acfg, D.32988);
        goto <D.32989>;
        <D.32986>:
        emit_int16 (acfg, 0);
        <D.32989>:
        <D.32980>:
      }
      i = i + 1;
      <D.26322>:
      i.262 = (unsigned int) i;
      D.32970 = table->len;
      if (i.262 < D.32970) goto <D.26321>; else goto <D.26323>;
      <D.26323>:
      i = 0;
      goto <D.26326>;
      <D.26325>:
      {
        char * name;

        D.32948 = acfg->globals;
        D.32956 = D.32948->pdata;
        D.32957 = (long unsigned int) i;
        D.32958 = D.32957 * 8;
        D.32959 = D.32956 + D.32958;
        name = *D.32959;
        sprintf (&symbol, "name_%d", i);
        emit_section_change (acfg, ".rodata", 1);
        emit_label (acfg, &symbol);
        emit_string (acfg, name);
      }
      i = i + 1;
      <D.26326>:
      i.262 = (unsigned int) i;
      D.32948 = acfg->globals;
      D.32949 = D.32948->len;
      if (i.262 < D.32949) goto <D.26325>; else goto <D.26327>;
      <D.26327>:
      sprintf (&symbol, "globals");
      emit_section_change (acfg, ".data", 0);
      emit_alignment (acfg, 8);
      emit_label (acfg, &symbol);
      D.32990 = acfg->temp_prefix;
      sprintf (&symbol, "%sglobals_hash", D.32990);
      emit_pointer (acfg, &symbol);
      i = 0;
      goto <D.26330>;
      <D.26329>:
      {
        char * name;

        D.32948 = acfg->globals;
        D.32956 = D.32948->pdata;
        D.32957 = (long unsigned int) i;
        D.32958 = D.32957 * 8;
        D.32959 = D.32956 + D.32958;
        name = *D.32959;
        sprintf (&symbol, "name_%d", i);
        emit_pointer (acfg, &symbol);
        sprintf (&symbol, "%s", name);
        emit_pointer (acfg, &symbol);
      }
      i = i + 1;
      <D.26330>:
      i.262 = (unsigned int) i;
      D.32948 = acfg->globals;
      D.32949 = D.32948->len;
      if (i.262 < D.32949) goto <D.26329>; else goto <D.26331>;
      <D.26331>:
      emit_int32 (acfg, 0);
      emit_int32 (acfg, 0);
    }
  finally
    {
      symbol = {CLOBBER};
    }
}


emit_autoreg (struct MonoAotCompile * acfg)
{
  int D.32996;
  int D.32998;
  int D.33000;
  char * D.33001;
  char * symbol;

  D.32996 = acfg->use_bin_writer;
  if (D.32996 != 0) goto <D.32994>; else goto <D.32997>;
  <D.32997>:
  D.32998 = acfg->aot_opts.static_link;
  if (D.32998 == 0) goto <D.32994>; else goto <D.32999>;
  <D.32999>:
  D.33000 = acfg->aot_opts.autoreg;
  if (D.33000 == 0) goto <D.32994>; else goto <D.32995>;
  <D.32994>:
  return;
  <D.32995>:
  D.33001 = acfg->static_linking_symbol;
  symbol = monoeg_g_strdup_printf ("_%s_autoreg", D.33001);
  arch_emit_autoreg (acfg, symbol);
  monoeg_g_free (symbol);
}


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

}


emit_dwarf_info (struct MonoAotCompile * acfg)
{
  struct MonoCompile * * D.33003;
  long unsigned int D.33004;
  long unsigned int D.33005;
  struct MonoCompile * * D.33006;
  long unsigned int D.33009;
  long unsigned int D.33010;
  const char * D.33013;
  struct MonoDwarfWriter * D.33014;
  struct MonoMethod * D.33015;
  char * D.33016;
  struct MonoJitInfo * D.33017;
  void * D.33018;
  int D.33019;
  unsigned int D.33020;
  struct MonoInst * * D.33021;
  struct MonoInst * * D.33022;
  struct GSList * D.33023;
  struct MonoMethod * D.33024;
  struct MonoDomain * D.33025;
  struct MonoDebugMethodJitInfo * D.33026;
  unsigned int i.263;
  unsigned int D.33028;
  int i;
  char symbol2[128];

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

        D.33003 = acfg->cfgs;
        D.33004 = (long unsigned int) i;
        D.33005 = D.33004 * 8;
        D.33006 = D.33003 + D.33005;
        cfg = *D.33006;
        if (cfg == 0B) goto <D.33007>; else goto <D.33008>;
        <D.33007>:
        // predicted unlikely by continue predictor.
        goto <D.26384>;
        <D.33008>:
        D.33009 = BIT_FIELD_REF <*cfg, 64, 5568>;
        D.33010 = D.33009 & 1099511627776;
        if (D.33010 != 0) goto <D.33011>; else goto <D.33012>;
        <D.33011>:
        // predicted unlikely by continue predictor.
        goto <D.26384>;
        <D.33012>:
        D.33013 = acfg->temp_prefix;
        sprintf (&symbol2, "%sme_%x", D.33013, i);
        D.33014 = acfg->dwarf;
        D.33015 = cfg->method;
        D.33016 = cfg->asm_symbol;
        D.33017 = cfg->jit_info;
        D.33018 = D.33017->code_start;
        D.33017 = cfg->jit_info;
        D.33019 = D.33017->code_size;
        D.33020 = (unsigned int) D.33019;
        D.33021 = cfg->args;
        D.33022 = cfg->locals;
        D.33023 = cfg->unwind_ops;
        D.33017 = cfg->jit_info;
        D.33024 = D.33017->d.method;
        D.33025 = mono_domain_get ();
        D.33026 = mono_debug_find_method (D.33024, D.33025);
        mono_dwarf_writer_emit_method (D.33014, cfg, D.33015, D.33016, &symbol2, D.33018, D.33020, D.33021, D.33022, D.33023, D.33026);
      }
      <D.26384>:
      i = i + 1;
      <D.26386>:
      i.263 = (unsigned int) i;
      D.33028 = acfg->nmethods;
      if (i.263 < D.33028) goto <D.26385>; else goto <D.26387>;
      <D.26387>:
    }
  finally
    {
      symbol2 = {CLOBBER};
    }
}


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

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


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

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


strcpy (char * restrict __dest, const char * restrict __src)
{
  char * D.33031;
  long unsigned int D.33032;

  D.33032 = __builtin_object_size (__dest, 1);
  D.33031 = __builtin___strcpy_chk (__dest, __src, D.33032);
  return D.33031;
}


compile_asm (struct MonoAotCompile * acfg)
{
  const char * iftmp.264;
  char * D.33035;
  int D.33039;
  char * D.33042;
  int D.33043;
  char * D.33046;
  int D.33047;
  char * D.33050;
  struct MonoImage * D.33054;
  char * D.33055;
  const char * iftmp.265;
  struct GString * D.33058;
  int D.33062;
  int D.33070;
  int D.33073;
  char * command;
  char * objfile;
  char * outfile_name;
  char * tmp_outfile_name;
  const char * tool_prefix;

  D.33035 = acfg->aot_opts.tool_prefix;
  if (D.33035 != 0B) goto <D.33036>; else goto <D.33037>;
  <D.33036>:
  iftmp.264 = acfg->aot_opts.tool_prefix;
  goto <D.33038>;
  <D.33037>:
  iftmp.264 = "";
  <D.33038>:
  tool_prefix = iftmp.264;
  D.33039 = acfg->aot_opts.asm_only;
  if (D.33039 != 0) goto <D.33040>; else goto <D.33041>;
  <D.33040>:
  D.33042 = acfg->tmpfname;
  printf ("Output file: \'%s\'.\n", D.33042);
  D.33043 = acfg->aot_opts.static_link;
  if (D.33043 != 0) goto <D.33044>; else goto <D.33045>;
  <D.33044>:
  D.33046 = acfg->static_linking_symbol;
  printf ("Linking symbol: \'%s\'.\n", D.33046);
  <D.33045>:
  D.33047 = 0;
  return D.33047;
  <D.33041>:
  D.33043 = acfg->aot_opts.static_link;
  if (D.33043 != 0) goto <D.33048>; else goto <D.33049>;
  <D.33048>:
  D.33050 = acfg->aot_opts.outfile;
  if (D.33050 != 0B) goto <D.33051>; else goto <D.33052>;
  <D.33051>:
  D.33050 = acfg->aot_opts.outfile;
  objfile = monoeg_g_strdup_printf ("%s", D.33050);
  goto <D.33053>;
  <D.33052>:
  D.33054 = acfg->image;
  D.33055 = D.33054->name;
  objfile = monoeg_g_strdup_printf ("%s.o", D.33055);
  <D.33053>:
  goto <D.33056>;
  <D.33049>:
  D.33042 = acfg->tmpfname;
  objfile = monoeg_g_strdup_printf ("%s.o", D.33042);
  <D.33056>:
  D.33058 = acfg->as_args;
  if (D.33058 != 0B) goto <D.33059>; else goto <D.33060>;
  <D.33059>:
  D.33058 = acfg->as_args;
  iftmp.265 = D.33058->str;
  goto <D.33061>;
  <D.33060>:
  iftmp.265 = "";
  <D.33061>:
  D.33042 = acfg->tmpfname;
  command = monoeg_g_strdup_printf ("%s%s %s %s -o %s %s", tool_prefix, "as", "-a64 -mppc64", iftmp.265, objfile, D.33042);
  printf ("Executing the native assembler: %s\n", command);
  D.33062 = system (command);
  if (D.33062 != 0) goto <D.33063>; else goto <D.33064>;
  <D.33063>:
  monoeg_g_free (command);
  monoeg_g_free (objfile);
  D.33047 = 1;
  return D.33047;
  <D.33064>:
  monoeg_g_free (command);
  D.33043 = acfg->aot_opts.static_link;
  if (D.33043 != 0) goto <D.33065>; else goto <D.33066>;
  <D.33065>:
  printf ("Output file: \'%s\'.\n", objfile);
  D.33046 = acfg->static_linking_symbol;
  printf ("Linking symbol: \'%s\'.\n", D.33046);
  monoeg_g_free (objfile);
  D.33047 = 0;
  return D.33047;
  <D.33066>:
  D.33050 = acfg->aot_opts.outfile;
  if (D.33050 != 0B) goto <D.33067>; else goto <D.33068>;
  <D.33067>:
  D.33050 = acfg->aot_opts.outfile;
  outfile_name = monoeg_g_strdup_printf ("%s", D.33050);
  goto <D.33069>;
  <D.33068>:
  D.33054 = acfg->image;
  D.33055 = D.33054->name;
  outfile_name = monoeg_g_strdup_printf ("%s%s", D.33055, ".so");
  <D.33069>:
  tmp_outfile_name = monoeg_g_strdup_printf ("%s.tmp", outfile_name);
  D.33042 = acfg->tmpfname;
  command = monoeg_g_strdup_printf ("%sld %s -shared -o %s %s.o", tool_prefix, "-m elf64ppc", tmp_outfile_name, D.33042);
  printf ("Executing the native linker: %s\n", command);
  D.33070 = system (command);
  if (D.33070 != 0) goto <D.33071>; else goto <D.33072>;
  <D.33071>:
  monoeg_g_free (tmp_outfile_name);
  monoeg_g_free (outfile_name);
  monoeg_g_free (command);
  monoeg_g_free (objfile);
  D.33047 = 1;
  return D.33047;
  <D.33072>:
  monoeg_g_free (command);
  rename (tmp_outfile_name, outfile_name);
  D.33073 = acfg->aot_opts.save_temps;
  if (D.33073 == 0) goto <D.33074>; else goto <D.33075>;
  <D.33074>:
  unlink (objfile);
  <D.33075>:
  monoeg_g_free (tmp_outfile_name);
  monoeg_g_free (outfile_name);
  monoeg_g_free (objfile);
  D.33073 = acfg->aot_opts.save_temps;
  if (D.33073 != 0) goto <D.33076>; else goto <D.33077>;
  <D.33076>:
  printf ("Retained input file.\n");
  goto <D.33078>;
  <D.33077>:
  D.33042 = acfg->tmpfname;
  unlink (D.33042);
  <D.33078>:
  D.33047 = 0;
  return D.33047;
}


get_patch_name (int info)
{
  const char * D.33080;
  short int D.33081;
  sizetype D.33082;

  D.33081 = opidx[info];
  D.33082 = (sizetype) D.33081;
  D.33080 = &opstr + D.33082;
  return D.33080;
}


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

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


acfg_free (struct MonoAotCompile * acfg)
{
  struct MonoImageWriter * D.33086;
  struct MonoCompile * * D.33087;
  long unsigned int D.33088;
  long unsigned int D.33089;
  struct MonoCompile * * D.33090;
  struct MonoCompile * D.33091;
  unsigned int i.266;
  unsigned int D.33095;
  char * D.33096;
  char * D.33097;
  char * D.33098;
  struct GPtrArray * D.33099;
  struct GPtrArray * D.33100;
  struct GPtrArray * D.33101;
  struct GPtrArray * D.33102;
  struct GPtrArray * D.33103;
  struct GHashTable * D.33104;
  struct GHashTable * D.33105;
  struct GHashTable * D.33106;
  struct GHashTable * * D.33107;
  struct GHashTable * * D.33108;
  struct GHashTable * D.33109;
  struct GHashTable * D.33112;
  struct GHashTable * D.33113;
  struct GHashTable * D.33114;
  struct GHashTable * D.33115;
  struct GHashTable * D.33116;
  struct GHashTable * D.33117;
  struct GHashTable * D.33118;
  struct GHashTable * D.33119;
  struct GHashTable * D.33120;
  struct GHashTable * D.33121;
  struct GHashTable * D.33122;
  struct GHashTable * * D.33123;
  struct GHashTable * * D.33124;
  struct GHashTable * D.33125;
  struct MonoMemPool * D.33126;
  int i;

  D.33086 = acfg->w;
  img_writer_destroy (D.33086);
  i = 0;
  goto <D.26457>;
  <D.26456>:
  D.33087 = acfg->cfgs;
  D.33088 = (long unsigned int) i;
  D.33089 = D.33088 * 8;
  D.33090 = D.33087 + D.33089;
  D.33091 = *D.33090;
  if (D.33091 != 0B) goto <D.33092>; else goto <D.33093>;
  <D.33092>:
  D.33087 = acfg->cfgs;
  D.33088 = (long unsigned int) i;
  D.33089 = D.33088 * 8;
  D.33090 = D.33087 + D.33089;
  D.33091 = *D.33090;
  monoeg_g_free (D.33091);
  <D.33093>:
  i = i + 1;
  <D.26457>:
  i.266 = (unsigned int) i;
  D.33095 = acfg->nmethods;
  if (i.266 < D.33095) goto <D.26456>; else goto <D.26458>;
  <D.26458>:
  D.33087 = acfg->cfgs;
  monoeg_g_free (D.33087);
  D.33096 = acfg->static_linking_symbol;
  monoeg_g_free (D.33096);
  D.33097 = acfg->got_symbol;
  monoeg_g_free (D.33097);
  D.33098 = acfg->plt_symbol;
  monoeg_g_free (D.33098);
  D.33099 = acfg->methods;
  monoeg_g_ptr_array_free (D.33099, 1);
  D.33100 = acfg->got_patches;
  monoeg_g_ptr_array_free (D.33100, 1);
  D.33101 = acfg->image_table;
  monoeg_g_ptr_array_free (D.33101, 1);
  D.33102 = acfg->globals;
  monoeg_g_ptr_array_free (D.33102, 1);
  D.33103 = acfg->unwind_ops;
  monoeg_g_ptr_array_free (D.33103, 1);
  D.33104 = acfg->method_indexes;
  monoeg_g_hash_table_destroy (D.33104);
  D.33105 = acfg->method_depth;
  monoeg_g_hash_table_destroy (D.33105);
  D.33106 = acfg->plt_offset_to_entry;
  monoeg_g_hash_table_destroy (D.33106);
  i = 0;
  goto <D.26460>;
  <D.26459>:
  D.33107 = acfg->patch_to_plt_entry;
  D.33088 = (long unsigned int) i;
  D.33089 = D.33088 * 8;
  D.33108 = D.33107 + D.33089;
  D.33109 = *D.33108;
  if (D.33109 != 0B) goto <D.33110>; else goto <D.33111>;
  <D.33110>:
  D.33107 = acfg->patch_to_plt_entry;
  D.33088 = (long unsigned int) i;
  D.33089 = D.33088 * 8;
  D.33108 = D.33107 + D.33089;
  D.33109 = *D.33108;
  monoeg_g_hash_table_destroy (D.33109);
  <D.33111>:
  i = i + 1;
  <D.26460>:
  if (i <= 51) goto <D.26459>; else goto <D.26461>;
  <D.26461>:
  D.33107 = acfg->patch_to_plt_entry;
  monoeg_g_free (D.33107);
  D.33112 = acfg->patch_to_got_offset;
  monoeg_g_hash_table_destroy (D.33112);
  D.33113 = acfg->method_to_cfg;
  monoeg_g_hash_table_destroy (D.33113);
  D.33114 = acfg->token_info_hash;
  monoeg_g_hash_table_destroy (D.33114);
  D.33115 = acfg->method_to_pinvoke_import;
  monoeg_g_hash_table_destroy (D.33115);
  D.33116 = acfg->image_hash;
  monoeg_g_hash_table_destroy (D.33116);
  D.33117 = acfg->unwind_info_offsets;
  monoeg_g_hash_table_destroy (D.33117);
  D.33118 = acfg->method_label_hash;
  monoeg_g_hash_table_destroy (D.33118);
  D.33119 = acfg->export_names;
  monoeg_g_hash_table_destroy (D.33119);
  D.33120 = acfg->plt_entry_debug_sym_cache;
  monoeg_g_hash_table_destroy (D.33120);
  D.33121 = acfg->klass_blob_hash;
  monoeg_g_hash_table_destroy (D.33121);
  D.33122 = acfg->method_blob_hash;
  monoeg_g_hash_table_destroy (D.33122);
  i = 0;
  goto <D.26463>;
  <D.26462>:
  D.33123 = acfg->patch_to_got_offset_by_type;
  D.33088 = (long unsigned int) i;
  D.33089 = D.33088 * 8;
  D.33124 = D.33123 + D.33089;
  D.33125 = *D.33124;
  monoeg_g_hash_table_destroy (D.33125);
  i = i + 1;
  <D.26463>:
  if (i <= 51) goto <D.26462>; else goto <D.26464>;
  <D.26464>:
  D.33123 = acfg->patch_to_got_offset_by_type;
  monoeg_g_free (D.33123);
  D.33126 = acfg->mempool;
  mono_mempool_destroy (D.33126);
  monoeg_g_free (acfg);
}