mono_aot_readonly_field_override (struct MonoClassField * field)
{
  struct MonoClass * D.26483;
  const char * D.26484;
  long unsigned int D.26485;
  long unsigned int D.26486;
  int D.26487;
  sizetype D.26490;
  char * p.0;
  char D.26492;
  const char * D.26495;
  long unsigned int D.26496;
  int D.26497;
  char * p.1;
  char D.26501;
  int D.25751;
  const char * D.26504;
  int D.26507;
  void * D.26508;
  struct ReadOnlyValue * rdv;

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

    p = rdv->name;
    D.26483 = field->parent;
    D.26484 = D.26483->name_space;
    D.26485 = strlen (D.26484);
    len = (int) D.26485;
    D.26486 = (long unsigned int) len;
    D.26483 = field->parent;
    D.26484 = D.26483->name_space;
    D.26487 = strncmp (p, D.26484, D.26486);
    if (D.26487 != 0) goto <D.26488>; else goto <D.26489>;
    <D.26488>:
    // predicted unlikely by continue predictor.
    goto <D.25733>;
    <D.26489>:
    D.26490 = (sizetype) len;
    p = p + D.26490;
    p.0 = p;
    p = p.0 + 1;
    D.26492 = *p.0;
    if (D.26492 != 46) goto <D.26493>; else goto <D.26494>;
    <D.26493>:
    // predicted unlikely by continue predictor.
    goto <D.25733>;
    <D.26494>:
    D.26483 = field->parent;
    D.26495 = D.26483->name;
    D.26496 = strlen (D.26495);
    len = (int) D.26496;
    D.26486 = (long unsigned int) len;
    D.26483 = field->parent;
    D.26495 = D.26483->name;
    D.26497 = strncmp (p, D.26495, D.26486);
    if (D.26497 != 0) goto <D.26498>; else goto <D.26499>;
    <D.26498>:
    // predicted unlikely by continue predictor.
    goto <D.25733>;
    <D.26499>:
    D.26490 = (sizetype) len;
    p = p + D.26490;
    p.1 = p;
    p = p.1 + 1;
    D.26501 = *p.1;
    if (D.26501 != 46) goto <D.26502>; else goto <D.26503>;
    <D.26502>:
    // predicted unlikely by continue predictor.
    goto <D.25733>;
    <D.26503>:
    {
      size_t __s1_len;
      size_t __s2_len;

      D.26504 = field->name;
      D.25751 = __builtin_strcmp (p, D.26504);
    }
    if (D.25751 != 0) goto <D.26505>; else goto <D.26506>;
    <D.26505>:
    // predicted unlikely by continue predictor.
    goto <D.25733>;
    <D.26506>:
    D.26507 = rdv->type;
    switch (D.26507) <default: <D.25755>, case 4: <D.25752>, case 6: <D.25753>, case 8: <D.25754>>
    <D.25752>:
    D.26508 = &rdv->value.i1;
    return D.26508;
    <D.25753>:
    D.26508 = &rdv->value.i2;
    return D.26508;
    <D.25754>:
    D.26508 = &rdv->value.i4;
    return D.26508;
    <D.25755>:
    goto <D.25756>;
    <D.25756>:
  }
  <D.25733>:
  rdv = rdv->next;
  <D.25758>:
  if (rdv != 0B) goto <D.25757>; else goto <D.25759>;
  <D.25759>:
  D.26508 = 0B;
  return D.26508;
}


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

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


get_got_offset (struct MonoAotCompile * acfg, struct MonoJumpInfo * ji)
{
  struct GHashTable * * D.26514;
  <unnamed type> D.26515;
  long unsigned int D.26516;
  long unsigned int D.26517;
  struct GHashTable * * D.26518;
  struct GHashTable * D.26519;
  void * D.26520;
  long int D.26521;
  guint32 D.26524;
  unsigned int D.26525;
  unsigned int D.26526;
  unsigned int D.26527;
  _Bool D.26530;
  long int D.26531;
  long int D.26532;
  int D.26535;
  int D.26536;
  int D.26537;
  int D.26538;
  unsigned int D.26539;
  long unsigned int D.26540;
  void * D.26541;
  struct GHashTable * D.26542;
  struct GPtrArray * D.26543;
  guint32 got_offset;

  D.26514 = acfg->patch_to_got_offset_by_type;
  D.26515 = ji->type;
  D.26516 = (long unsigned int) D.26515;
  D.26517 = D.26516 * 8;
  D.26518 = D.26514 + D.26517;
  D.26519 = *D.26518;
  D.26520 = monoeg_g_hash_table_lookup (D.26519, ji);
  D.26521 = (long int) D.26520;
  got_offset = (guint32) D.26521;
  if (got_offset != 0) goto <D.26522>; else goto <D.26523>;
  <D.26522>:
  D.26524 = got_offset + 4294967295;
  return D.26524;
  <D.26523>:
  got_offset = acfg->got_offset;
  D.26525 = acfg->got_offset;
  D.26526 = D.26525 + 1;
  acfg->got_offset = D.26526;
  D.26527 = acfg->final_got_size;
  if (D.26527 != 0) goto <D.26528>; else goto <D.26529>;
  <D.26528>:
  D.26527 = acfg->final_got_size;
  D.26530 = D.26527 <= got_offset;
  D.26531 = (long int) D.26530;
  D.26532 = __builtin_expect (D.26531, 0);
  if (D.26532 != 0) goto <D.26533>; else goto <D.26534>;
  <D.26533>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "aot-compiler.c", 2978, "got_offset < acfg->final_got_size");
  <D.26534>:
  <D.26529>:
  D.26535 = acfg->stats.got_slots;
  D.26536 = D.26535 + 1;
  acfg->stats.got_slots = D.26536;
  D.26515 = ji->type;
  D.26537 = acfg->stats.got_slot_types[D.26515];
  D.26538 = D.26537 + 1;
  acfg->stats.got_slot_types[D.26515] = D.26538;
  D.26539 = got_offset + 1;
  D.26540 = (long unsigned int) D.26539;
  D.26541 = (void *) D.26540;
  D.26542 = acfg->patch_to_got_offset;
  monoeg_g_hash_table_insert_replace (D.26542, ji, D.26541, 0);
  D.26539 = got_offset + 1;
  D.26540 = (long unsigned int) D.26539;
  D.26541 = (void *) D.26540;
  D.26514 = acfg->patch_to_got_offset_by_type;
  D.26515 = ji->type;
  D.26516 = (long unsigned int) D.26515;
  D.26517 = D.26516 * 8;
  D.26518 = D.26514 + D.26517;
  D.26519 = *D.26518;
  monoeg_g_hash_table_insert_replace (D.26519, ji, D.26541, 0);
  D.26543 = acfg->got_patches;
  monoeg_g_ptr_array_add (D.26543, ji);
  D.26524 = got_offset;
  return D.26524;
}


mono_aot_get_method_name (struct MonoCompile * cfg)
{
  struct MonoAotCompile * llvm_acfg.3;
  int D.26546;
  char * D.26549;
  struct GHashTable * D.26550;
  struct MonoMethod * D.26551;
  char * D.26552;
  char * D.26553;

  llvm_acfg.3 = llvm_acfg;
  D.26546 = llvm_acfg.3->aot_opts.static_link;
  if (D.26546 != 0) goto <D.26547>; else goto <D.26548>;
  <D.26547>:
  llvm_acfg.3 = llvm_acfg;
  D.26550 = llvm_acfg.3->method_label_hash;
  D.26551 = cfg->orig_method;
  D.26552 = get_debug_sym (D.26551, "", D.26550);
  llvm_acfg.3 = llvm_acfg;
  D.26553 = llvm_acfg.3->assembly_name_sym;
  D.26549 = monoeg_g_strdup_printf ("%s_%s", D.26553, D.26552);
  return D.26549;
  <D.26548>:
  llvm_acfg.3 = llvm_acfg;
  D.26550 = llvm_acfg.3->method_label_hash;
  D.26551 = cfg->orig_method;
  D.26549 = get_debug_sym (D.26551, "", D.26550);
  return D.26549;
}


get_debug_sym (struct MonoMethod * method, const char * prefix, struct GHashTable * cache)
{
  long unsigned int D.26555;
  long unsigned int D.26556;
  long unsigned int D.26557;
  long unsigned int D.26558;
  long unsigned int D.26559;
  long unsigned int D.26560;
  long unsigned int D.26561;
  const short unsigned int * * D.26562;
  const short unsigned int * D.26563;
  sizetype D.26564;
  char * D.26565;
  char D.26566;
  long unsigned int D.26567;
  long unsigned int D.26568;
  const short unsigned int * D.26569;
  short unsigned int D.26570;
  int D.26571;
  int D.26572;
  int j.4;
  sizetype D.26576;
  char * D.26577;
  sizetype D.26582;
  char * D.26583;
  char D.26584;
  sizetype D.26586;
  char * D.26587;
  char D.26588;
  int j.5;
  sizetype D.26595;
  char * D.26596;
  char D.26597;
  unsigned char D.26598;
  unsigned char D.26599;
  _Bool D.26600;
  _Bool D.26601;
  _Bool D.26602;
  int j.6;
  sizetype D.26607;
  char * D.26608;
  sizetype D.26609;
  char * D.26610;
  void * D.26611;
  char * D.26612;
  char * name1;
  char * name2;
  char * cached;
  int i;
  int j;
  int len;
  int count;

  name1 = mono_method_full_name (method, 1);
  D.26555 = strlen (name1);
  len = (int) D.26555;
  D.26556 = strlen (prefix);
  D.26557 = (long unsigned int) len;
  D.26558 = D.26556 + D.26557;
  D.26559 = D.26558 + 16;
  name2 = malloc (D.26559);
  D.26560 = strlen (prefix);
  memcpy (name2, prefix, D.26560);
  D.26561 = strlen (prefix);
  j = (int) D.26561;
  i = 0;
  goto <D.25336>;
  <D.25335>:
  D.26562 = __ctype_b_loc ();
  D.26563 = *D.26562;
  D.26564 = (sizetype) i;
  D.26565 = name1 + D.26564;
  D.26566 = *D.26565;
  D.26567 = (long unsigned int) D.26566;
  D.26568 = D.26567 * 2;
  D.26569 = D.26563 + D.26568;
  D.26570 = *D.26569;
  D.26571 = (int) D.26570;
  D.26572 = D.26571 & 8;
  if (D.26572 != 0) goto <D.26573>; else goto <D.26574>;
  <D.26573>:
  j.4 = j;
  j = j.4 + 1;
  D.26576 = (sizetype) j.4;
  D.26577 = name2 + D.26576;
  D.26564 = (sizetype) i;
  D.26565 = name1 + D.26564;
  D.26566 = *D.26565;
  *D.26577 = D.26566;
  goto <D.26578>;
  <D.26574>:
  D.26564 = (sizetype) i;
  D.26565 = name1 + D.26564;
  D.26566 = *D.26565;
  if (D.26566 == 32) goto <D.26581>; else goto <D.26579>;
  <D.26581>:
  D.26564 = (sizetype) i;
  D.26582 = D.26564 + 1;
  D.26583 = name1 + D.26582;
  D.26584 = *D.26583;
  if (D.26584 == 40) goto <D.26585>; else goto <D.26579>;
  <D.26585>:
  D.26564 = (sizetype) i;
  D.26586 = D.26564 + 2;
  D.26587 = name1 + D.26586;
  D.26588 = *D.26587;
  if (D.26588 == 41) goto <D.26589>; else goto <D.26579>;
  <D.26589>:
  i = i + 2;
  goto <D.26580>;
  <D.26579>:
  D.26564 = (sizetype) i;
  D.26565 = name1 + D.26564;
  D.26566 = *D.26565;
  if (D.26566 == 44) goto <D.26592>; else goto <D.26590>;
  <D.26592>:
  D.26564 = (sizetype) i;
  D.26582 = D.26564 + 1;
  D.26583 = name1 + D.26582;
  D.26584 = *D.26583;
  if (D.26584 == 32) goto <D.26593>; else goto <D.26590>;
  <D.26593>:
  j.5 = j;
  j = j.5 + 1;
  D.26595 = (sizetype) j.5;
  D.26596 = name2 + D.26595;
  *D.26596 = 95;
  i = i + 1;
  goto <D.26591>;
  <D.26590>:
  D.26564 = (sizetype) i;
  D.26565 = name1 + D.26564;
  D.26597 = *D.26565;
  D.26598 = (unsigned char) D.26597;
  D.26599 = D.26598 + 216;
  D.26600 = D.26599 <= 1;
  D.26601 = D.26597 == 62;
  D.26602 = D.26600 | D.26601;
  if (D.26602 != 0) goto <D.26603>; else goto <D.26604>;
  <D.26603>:
  goto <D.26605>;
  <D.26604>:
  j.6 = j;
  j = j.6 + 1;
  D.26607 = (sizetype) j.6;
  D.26608 = name2 + D.26607;
  *D.26608 = 95;
  <D.26605>:
  <D.26591>:
  <D.26580>:
  <D.26578>:
  i = i + 1;
  <D.25336>:
  if (i < len) goto <D.25335>; else goto <D.25337>;
  <D.25337>:
  D.26609 = (sizetype) j;
  D.26610 = name2 + D.26609;
  *D.26610 = 0;
  monoeg_g_free (name1);
  count = 0;
  goto <D.25339>;
  <D.25338>:
  D.26609 = (sizetype) j;
  D.26610 = name2 + D.26609;
  sprintf (D.26610, "_%d", count);
  count = count + 1;
  <D.25339>:
  D.26611 = monoeg_g_hash_table_lookup (cache, name2);
  if (D.26611 != 0B) goto <D.25338>; else goto <D.25340>;
  <D.25340>:
  cached = monoeg_strdup (name2);
  monoeg_g_hash_table_insert_replace (cache, cached, cached, 0);
  D.26612 = name2;
  return D.26612;
}


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

  D.26615 = __builtin_object_size (__dest, 0);
  D.26614 = __builtin___memcpy_chk (__dest, __src, __len, D.26615);
  return D.26614;
}


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

  D.26618 = __builtin_object_size (__s, 1);
  D.26617 = __builtin___sprintf_chk (__s, 1, D.26618, __fmt, __builtin_va_arg_pack ());
  return D.26617;
}


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

  if (str != 0B) goto <D.26620>; else goto <D.26621>;
  <D.26620>:
  D.26622 = __strdup (str);
  return D.26622;
  <D.26621>:
  D.26622 = 0B;
  return D.26622;
}


mono_aot_get_plt_symbol (MonoJumpInfoType type, const void * data)
{
  struct MonoAotCompile * llvm_acfg.7;
  struct MonoMemPool * D.26625;
  int D.26626;
  char * D.26629;
  char * D.26630;
  struct MonoJumpInfo * ji;
  struct MonoPltEntry * plt_entry;

  llvm_acfg.7 = llvm_acfg;
  D.26625 = llvm_acfg.7->mempool;
  ji = mono_mempool_alloc (D.26625, 40);
  ji->type = type;
  ji->data.target = data;
  llvm_acfg.7 = llvm_acfg;
  D.26626 = can_encode_patch (llvm_acfg.7, ji);
  if (D.26626 == 0) goto <D.26627>; else goto <D.26628>;
  <D.26627>:
  D.26629 = 0B;
  return D.26629;
  <D.26628>:
  llvm_acfg.7 = llvm_acfg;
  plt_entry = get_plt_entry (llvm_acfg.7, ji);
  plt_entry->llvm_used = 1;
  D.26630 = plt_entry->llvm_symbol;
  D.26629 = monoeg_g_strdup_printf (D.26630);
  return D.26629;
}


can_encode_patch (struct MonoAotCompile * acfg, struct MonoJumpInfo * patch_info)
{
  <unnamed type> D.26632;
  gboolean D.26633;
  struct MonoClass * D.26634;
  int D.26635;
  struct MonoMethod * D.26638;
  int D.26639;
  struct MonoJumpInfo * D.26642;
  int D.26643;

  D.26632 = patch_info->type;
  switch (D.26632) <default: <D.25862>, case 3: <D.25849>, case 6: <D.25850>, case 11: <D.25856>, case 14: <D.25853>, case 15: <D.25854>, case 23: <D.25857>, case 24: <D.25858>, case 30: <D.25855>, case 35: <D.25860>, case 50: <D.25851>>
  <D.25849>:
  <D.25850>:
  <D.25851>:
  {
    struct MonoMethod * method;

    method = patch_info->data.method;
    D.26633 = can_encode_method (acfg, method);
    return D.26633;
  }
  <D.25853>:
  <D.25854>:
  <D.25855>:
  <D.25856>:
  <D.25857>:
  <D.25858>:
  D.26634 = patch_info->data.klass;
  D.26635 = can_encode_class (acfg, D.26634);
  if (D.26635 == 0) goto <D.26636>; else goto <D.26637>;
  <D.26636>:
  D.26633 = 0;
  return D.26633;
  <D.26637>:
  goto <D.25859>;
  <D.25860>:
  {
    struct MonoJumpInfoRgctxEntry * entry;

    entry = patch_info->data.rgctx_entry;
    D.26638 = entry->method;
    D.26639 = can_encode_method (acfg, D.26638);
    if (D.26639 == 0) goto <D.26640>; else goto <D.26641>;
    <D.26640>:
    D.26633 = 0;
    return D.26633;
    <D.26641>:
    D.26642 = entry->data;
    D.26643 = can_encode_patch (acfg, D.26642);
    if (D.26643 == 0) goto <D.26644>; else goto <D.26645>;
    <D.26644>:
    D.26633 = 0;
    return D.26633;
    <D.26645>:
    goto <D.25859>;
  }
  <D.25862>:
  goto <D.25859>;
  <D.25859>:
  D.26633 = 1;
  return D.26633;
}


can_encode_class (struct MonoAotCompile * acfg, struct MonoClass * klass)
{
  unsigned int D.26648;
  gboolean D.26651;
  unsigned char D.26654;
  _Bool D.26655;
  _Bool D.26656;
  _Bool D.26657;
  unsigned char D.26659;
  unsigned char D.26660;
  struct MonoClass * D.26663;

  D.26648 = klass->type_token;
  if (D.26648 != 0) goto <D.26649>; else goto <D.26650>;
  <D.26649>:
  D.26651 = 1;
  return D.26651;
  <D.26650>:
  D.26654 = klass->byval_arg.type;
  D.26655 = D.26654 == 19;
  D.26656 = D.26654 == 30;
  D.26657 = D.26655 | D.26656;
  if (D.26657 != 0) goto <D.26652>; else goto <D.26658>;
  <D.26658>:
  D.26659 = klass->byval_arg.type;
  if (D.26659 == 15) goto <D.26652>; else goto <D.26653>;
  <D.26652>:
  D.26651 = 1;
  return D.26651;
  <D.26653>:
  D.26660 = klass->rank;
  if (D.26660 != 0) goto <D.26661>; else goto <D.26662>;
  <D.26661>:
  D.26663 = klass->element_class;
  D.26651 = can_encode_class (acfg, D.26663);
  return D.26651;
  <D.26662>:
  D.26651 = 0;
  return D.26651;
}


can_encode_method (struct MonoAotCompile * acfg, struct MonoMethod * method)
{
  unsigned char D.26665;
  unsigned char D.26666;
  <unnamed-unsigned:5> D.26669;
  int D.26670;
  gboolean D.26673;
  unsigned int D.26675;
  struct GHashTable * D.26678;
  void * D.26679;
  struct MonoClass * D.26682;
  unsigned char D.26683;

  D.26665 = BIT_FIELD_REF <*method, 8, 256>;
  D.26666 = D.26665 & 124;
  if (D.26666 != 0) goto <D.26667>; else goto <D.26668>;
  <D.26667>:
  D.26669 = method->wrapper_type;
  D.26670 = (int) D.26669;
  switch (D.26670) <default: <D.25844>, case 0: <D.25821>, case 1: <D.25836>, case 2: <D.25837>, case 3: <D.25838>, case 7: <D.25841>, case 8: <D.25833>, case 9: <D.25822>, case 10: <D.25823>, case 12: <D.25825>, case 13: <D.25824>, case 14: <D.25827>, case 15: <D.25828>, case 16: <D.25839>, case 18: <D.25830>, case 19: <D.25842>, case 20: <D.25831>, case 21: <D.25829>, case 23: <D.25826>, case 24: <D.25835>, case 25: <D.25834>, case 28: <D.25832>>
  <D.25821>:
  <D.25822>:
  <D.25823>:
  <D.25824>:
  <D.25825>:
  <D.25826>:
  <D.25827>:
  <D.25828>:
  <D.25829>:
  <D.25830>:
  <D.25831>:
  <D.25832>:
  <D.25833>:
  <D.25834>:
  <D.25835>:
  <D.25836>:
  <D.25837>:
  <D.25838>:
  <D.25839>:
  goto <D.25840>;
  <D.25841>:
  <D.25842>:
  {
    struct WrapperInfo * info;

    info = mono_marshal_get_wrapper_info (method);
    if (info != 0B) goto <D.26671>; else goto <D.26672>;
    <D.26671>:
    D.26673 = 1;
    return D.26673;
    <D.26672>:
    D.26673 = 0;
    return D.26673;
  }
  <D.25844>:
  D.26673 = 0;
  return D.26673;
  <D.25840>:
  goto <D.26674>;
  <D.26668>:
  D.26675 = method->token;
  if (D.26675 == 0) goto <D.26676>; else goto <D.26677>;
  <D.26676>:
  D.26678 = acfg->token_info_hash;
  D.26679 = monoeg_g_hash_table_lookup (D.26678, method);
  if (D.26679 == 0B) goto <D.26680>; else goto <D.26681>;
  <D.26680>:
  D.26682 = method->klass;
  D.26683 = D.26682->rank;
  if (D.26683 != 0) goto <D.26684>; else goto <D.26685>;
  <D.26684>:
  D.26673 = 1;
  return D.26673;
  <D.26685>:
  D.26673 = 0;
  return D.26673;
  <D.26681>:
  <D.26677>:
  <D.26674>:
  D.26673 = 1;
  return D.26673;
}


get_plt_entry (struct MonoAotCompile * acfg, struct MonoJumpInfo * patch_info)
{
  int D.26689;
  struct MonoPltEntry * D.26692;
  struct GHashTable * * D.26693;
  <unnamed type> D.26694;
  long unsigned int D.26695;
  long unsigned int D.26696;
  struct GHashTable * * D.26697;
  struct GHashTable * D.26698;
  struct GHashTable * D.26701;
  int D.26702;
  struct MonoMethod * D.26707;
  short unsigned int D.26708;
  int D.26709;
  int D.26710;
  unsigned int D.26715;
  _Bool D.26716;
  long int D.26717;
  long int D.26718;
  struct MonoMemPool * D.26721;
  unsigned int D.26722;
  int D.26723;
  int D.26724;
  char * D.26725;
  int D.26726;
  struct GHashTable * D.26729;
  struct MonoJumpInfo * D.26730;
  char * D.26731;
  char * D.26732;
  char * D.26735;
  gchar * D.26736;
  gchar * D.26738;
  <unnamed type> D.26739;
  long unsigned int D.26740;
  long unsigned int D.26741;
  struct GHashTable * * D.26742;
  struct GHashTable * D.26743;
  long unsigned int D.26744;
  void * D.26745;
  struct GHashTable * D.26746;
  unsigned int D.26747;
  struct MonoPltEntry * res;

  D.26689 = is_plt_patch (patch_info);
  if (D.26689 == 0) goto <D.26690>; else goto <D.26691>;
  <D.26690>:
  D.26692 = 0B;
  return D.26692;
  <D.26691>:
  D.26693 = acfg->patch_to_plt_entry;
  D.26694 = patch_info->type;
  D.26695 = (long unsigned int) D.26694;
  D.26696 = D.26695 * 8;
  D.26697 = D.26693 + D.26696;
  D.26698 = *D.26697;
  if (D.26698 == 0B) goto <D.26699>; else goto <D.26700>;
  <D.26699>:
  D.26693 = acfg->patch_to_plt_entry;
  D.26694 = patch_info->type;
  D.26695 = (long unsigned int) D.26694;
  D.26696 = D.26695 * 8;
  D.26697 = D.26693 + D.26696;
  D.26701 = monoeg_g_hash_table_new (mono_patch_info_hash, mono_patch_info_equal);
  *D.26697 = D.26701;
  <D.26700>:
  D.26693 = acfg->patch_to_plt_entry;
  D.26694 = patch_info->type;
  D.26695 = (long unsigned int) D.26694;
  D.26696 = D.26695 * 8;
  D.26697 = D.26693 + D.26696;
  D.26698 = *D.26697;
  res = monoeg_g_hash_table_lookup (D.26698, patch_info);
  D.26702 = acfg->llvm;
  if (D.26702 == 0) goto <D.26703>; else goto <D.26704>;
  <D.26703>:
  D.26694 = patch_info->type;
  if (D.26694 == 3) goto <D.26705>; else goto <D.26706>;
  <D.26705>:
  D.26707 = patch_info->data.method;
  D.26708 = D.26707->iflags;
  D.26709 = (int) D.26708;
  D.26710 = D.26709 & 32;
  if (D.26710 != 0) goto <D.26711>; else goto <D.26712>;
  <D.26711>:
  res = 0B;
  <D.26712>:
  <D.26706>:
  <D.26704>:
  if (res == 0B) goto <D.26713>; else goto <D.26714>;
  <D.26713>:
  {
    struct MonoJumpInfo * new_ji;

    D.26715 = acfg->final_got_size;
    D.26716 = D.26715 != 0;
    D.26717 = (long int) D.26716;
    D.26718 = __builtin_expect (D.26717, 0);
    if (D.26718 != 0) goto <D.26719>; else goto <D.26720>;
    <D.26719>:
    monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "aot-compiler.c", 2930, "!acfg->final_got_size");
    <D.26720>:
    D.26721 = acfg->mempool;
    new_ji = mono_patch_info_dup_mp (D.26721, patch_info);
    D.26721 = acfg->mempool;
    res = mono_mempool_alloc0 (D.26721, 48);
    D.26722 = acfg->plt_offset;
    D.26723 = (int) D.26722;
    res->plt_offset = D.26723;
    res->ji = new_ji;
    D.26724 = res->plt_offset;
    D.26725 = get_plt_symbol (acfg, D.26724, patch_info);
    res->symbol = D.26725;
    D.26726 = acfg->aot_opts.write_symbols;
    if (D.26726 != 0) goto <D.26727>; else goto <D.26728>;
    <D.26727>:
    D.26729 = acfg->plt_entry_debug_sym_cache;
    D.26730 = res->ji;
    D.26731 = get_plt_entry_debug_sym (acfg, D.26730, D.26729);
    res->debug_sym = D.26731;
    <D.26728>:
    D.26732 = res->debug_sym;
    if (D.26732 != 0B) goto <D.26733>; else goto <D.26734>;
    <D.26733>:
    D.26732 = res->debug_sym;
    D.26735 = res->symbol;
    D.26736 = monoeg_g_strdup_printf ("%s_%s_llvm", D.26735, D.26732);
    res->llvm_symbol = D.26736;
    goto <D.26737>;
    <D.26734>:
    D.26735 = res->symbol;
    D.26738 = monoeg_g_strdup_printf ("%s_llvm", D.26735);
    res->llvm_symbol = D.26738;
    <D.26737>:
    D.26693 = acfg->patch_to_plt_entry;
    D.26739 = new_ji->type;
    D.26740 = (long unsigned int) D.26739;
    D.26741 = D.26740 * 8;
    D.26742 = D.26693 + D.26741;
    D.26743 = *D.26742;
    monoeg_g_hash_table_insert_replace (D.26743, new_ji, res, 0);
    D.26724 = res->plt_offset;
    D.26744 = (long unsigned int) D.26724;
    D.26745 = (void *) D.26744;
    D.26746 = acfg->plt_offset_to_entry;
    monoeg_g_hash_table_insert_replace (D.26746, D.26745, res, 0);
    D.26722 = acfg->plt_offset;
    D.26747 = D.26722 + 1;
    acfg->plt_offset = D.26747;
  }
  <D.26714>:
  D.26692 = res;
  return D.26692;
}


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

  D.26749 = patch_info->type;
  switch (D.26749) <default: <D.24525>, case 3: <D.24515>, case 7: <D.24516>, case 15: <D.24519>, case 31: <D.24518>, case 32: <D.24517>, case 35: <D.24520>, case 36: <D.24521>, case 37: <D.24522>, case 38: <D.24523>, case 41: <D.24524>>
  <D.24515>:
  <D.24516>:
  <D.24517>:
  <D.24518>:
  <D.24519>:
  <D.24520>:
  <D.24521>:
  <D.24522>:
  <D.24523>:
  <D.24524>:
  D.26750 = 1;
  return D.26750;
  <D.24525>:
  D.26750 = 0;
  return D.26750;
}


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

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


get_plt_entry_debug_sym (struct MonoAotCompile * acfg, struct MonoJumpInfo * ji, struct GHashTable * cache)
{
  <unnamed type> D.26755;
  struct MonoMethod * D.26756;
  const char * D.26757;
  struct MonoClass * D.26758;
  struct MonoType * D.26759;
  unsigned int D.26760;
  unsigned int D.26761;
  unsigned int D.26762;
  char * D.26763;
  char * debug_sym;
  char * s;

  debug_sym = 0B;
  D.26755 = ji->type;
  switch (D.26755) <default: <D.25596>, case 3: <D.25587>, case 7: <D.25589>, case 15: <D.25590>, case 31: <D.25592>, case 32: <D.25594>, case 35: <D.25591>, case 36: <D.25595>>
  <D.25587>:
  D.26756 = ji->data.method;
  debug_sym = get_debug_sym (D.26756, "plt_", cache);
  goto <D.25588>;
  <D.25589>:
  D.26757 = ji->data.name;
  debug_sym = monoeg_g_strdup_printf ("plt__jit_icall_%s", D.26757);
  goto <D.25588>;
  <D.25590>:
  D.26758 = ji->data.klass;
  D.26759 = &D.26758->byval_arg;
  s = mono_type_get_name (D.26759);
  debug_sym = monoeg_g_strdup_printf ("plt__class_init_%s", s);
  monoeg_g_free (s);
  goto <D.25588>;
  <D.25591>:
  D.26760 = acfg->label_generator;
  D.26761 = D.26760;
  D.26762 = D.26761 + 1;
  acfg->label_generator = D.26762;
  debug_sym = monoeg_g_strdup_printf ("plt__rgctx_fetch_%d", D.26761);
  goto <D.25588>;
  <D.25592>:
  {
    char * s;

    D.26756 = ji->data.method;
    s = get_debug_sym (D.26756, "", cache);
    debug_sym = monoeg_g_strdup_printf ("plt__icall_native_%s", s);
    monoeg_g_free (s);
    goto <D.25588>;
  }
  <D.25594>:
  D.26757 = ji->data.name;
  debug_sym = monoeg_g_strdup_printf ("plt__jit_icall_native_%s", D.26757);
  goto <D.25588>;
  <D.25595>:
  debug_sym = monoeg_g_strdup_printf ("plt__generic_class_init");
  goto <D.25588>;
  <D.25596>:
  goto <D.25588>;
  <D.25588>:
  D.26763 = sanitize_symbol (acfg, debug_sym);
  return D.26763;
}


sanitize_symbol (struct MonoAotCompile * acfg, char * s)
{
  char * D.26768;
  long unsigned int D.26769;
  const short unsigned int * * D.26770;
  const short unsigned int * D.26771;
  sizetype D.26772;
  char * D.26773;
  char D.26774;
  long unsigned int D.26775;
  long unsigned int D.26776;
  const short unsigned int * D.26777;
  short unsigned int D.26778;
  int D.26779;
  int D.26780;
  long unsigned int D.26787;
  signed char c.8;
  long unsigned int D.26793;
  long unsigned int D.26794;
  const short unsigned int * D.26795;
  short unsigned int D.26796;
  int D.26797;
  int D.26798;
  char c.9;
  int D.26801;
  int D.26804;
  unsigned char D.26805;
  char * D.26807;
  struct MonoMemPool * D.26808;
  gboolean process;
  int i;
  int len;
  struct GString * gs;
  char * res;

  process = 0;
  if (s == 0B) goto <D.26766>; else goto <D.26767>;
  <D.26766>:
  D.26768 = s;
  return D.26768;
  <D.26767>:
  D.26769 = strlen (s);
  len = (int) D.26769;
  i = 0;
  goto <D.25314>;
  <D.25313>:
  D.26770 = __ctype_b_loc ();
  D.26771 = *D.26770;
  D.26772 = (sizetype) i;
  D.26773 = s + D.26772;
  D.26774 = *D.26773;
  D.26775 = (long unsigned int) D.26774;
  D.26776 = D.26775 * 2;
  D.26777 = D.26771 + D.26776;
  D.26778 = *D.26777;
  D.26779 = (int) D.26778;
  D.26780 = D.26779 & 8;
  if (D.26780 == 0) goto <D.26781>; else goto <D.26782>;
  <D.26781>:
  D.26772 = (sizetype) i;
  D.26773 = s + D.26772;
  D.26774 = *D.26773;
  if (D.26774 != 95) goto <D.26783>; else goto <D.26784>;
  <D.26783>:
  process = 1;
  <D.26784>:
  <D.26782>:
  i = i + 1;
  <D.25314>:
  if (i < len) goto <D.25313>; else goto <D.25315>;
  <D.25315>:
  if (process == 0) goto <D.26785>; else goto <D.26786>;
  <D.26785>:
  D.26768 = s;
  return D.26768;
  <D.26786>:
  D.26787 = (long unsigned int) len;
  gs = monoeg_g_string_sized_new (D.26787);
  i = 0;
  goto <D.25321>;
  <D.25320>:
  {
    guint8 c;

    D.26772 = (sizetype) i;
    D.26773 = s + D.26772;
    D.26774 = *D.26773;
    c = (guint8) D.26774;
    c.8 = (signed char) c;
    if (c.8 >= 0) goto <D.26792>; else goto <D.26788>;
    <D.26792>:
    D.26770 = __ctype_b_loc ();
    D.26771 = *D.26770;
    D.26793 = (long unsigned int) c;
    D.26794 = D.26793 * 2;
    D.26795 = D.26771 + D.26794;
    D.26796 = *D.26795;
    D.26797 = (int) D.26796;
    D.26798 = D.26797 & 8;
    if (D.26798 != 0) goto <D.26789>; else goto <D.26799>;
    <D.26799>:
    if (c == 95) goto <D.26789>; else goto <D.26788>;
    <D.26789>:
    c.9 = (char) c;
    D.26801 = (int) c.9;
    monoeg_g_string_append_c (gs, D.26801);
    goto <D.26790>;
    <D.26788>:
    c.8 = (signed char) c;
    if (c.8 < 0) goto <D.26802>; else goto <D.26803>;
    <D.26802>:
    D.26804 = (int) c;
    monoeg_g_string_append_printf (gs, "_0x%x", D.26804);
    i = i + 1;
    D.26772 = (sizetype) i;
    D.26773 = s + D.26772;
    D.26774 = *D.26773;
    c = (guint8) D.26774;
    goto <D.25318>;
    <D.25317>:
    D.26804 = (int) c;
    monoeg_g_string_append_printf (gs, "%x", D.26804);
    i = i + 1;
    D.26772 = (sizetype) i;
    D.26773 = s + D.26772;
    D.26774 = *D.26773;
    c = (guint8) D.26774;
    <D.25318>:
    D.26805 = c >> 6;
    if (D.26805 == 2) goto <D.25317>; else goto <D.25319>;
    <D.25319>:
    monoeg_g_string_append_printf (gs, "_");
    i = i + -1;
    goto <D.26806>;
    <D.26803>:
    monoeg_g_string_append_c (gs, 95);
    <D.26806>:
    <D.26790>:
  }
  i = i + 1;
  <D.25321>:
  if (i < len) goto <D.25320>; else goto <D.25322>;
  <D.25322>:
  D.26807 = gs->str;
  D.26808 = acfg->mempool;
  res = mono_mempool_strdup (D.26808, D.26807);
  monoeg_g_string_free (gs, 1);
  D.26768 = res;
  return D.26768;
}


mono_aot_get_method_index (struct MonoMethod * method)
{
  struct MonoAotCompile * llvm_acfg.10;
  _Bool D.26811;
  long int D.26812;
  long int D.26813;
  int D.26816;
  unsigned int D.26817;

  llvm_acfg.10 = llvm_acfg;
  D.26811 = llvm_acfg.10 == 0B;
  D.26812 = (long int) D.26811;
  D.26813 = __builtin_expect (D.26812, 0);
  if (D.26813 != 0) goto <D.26814>; else goto <D.26815>;
  <D.26814>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "aot-compiler.c", 6895, "llvm_acfg");
  <D.26815>:
  llvm_acfg.10 = llvm_acfg;
  D.26817 = get_method_index (llvm_acfg.10, method);
  D.26816 = (int) D.26817;
  return D.26816;
}


get_method_index (struct MonoAotCompile * acfg, struct MonoMethod * method)
{
  struct GHashTable * D.26819;
  void * D.26820;
  long int D.26821;
  _Bool D.26822;
  long int D.26823;
  long int D.26824;
  guint32 D.26827;
  int D.26828;
  int index;

  D.26819 = acfg->method_indexes;
  D.26820 = monoeg_g_hash_table_lookup (D.26819, method);
  D.26821 = (long int) D.26820;
  index = (int) D.26821;
  D.26822 = index == 0;
  D.26823 = (long int) D.26822;
  D.26824 = __builtin_expect (D.26823, 0);
  if (D.26824 != 0) goto <D.26825>; else goto <D.26826>;
  <D.26825>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "aot-compiler.c", 3010, "index");
  <D.26826>:
  D.26828 = index + -1;
  D.26827 = (guint32) D.26828;
  return D.26827;
}


mono_aot_patch_info_dup (struct MonoJumpInfo * ji)
{
  struct MonoAotCompile * llvm_acfg.11;
  union mono_mutex_t * D.26831;
  _Bool D.26834;
  long int D.26835;
  long int D.26836;
  struct MonoMemPool * D.26839;
  _Bool D.26842;
  long int D.26843;
  long int D.26844;
  struct MonoJumpInfo * D.26847;
  struct MonoJumpInfo * res;

  {
    int ret;

    llvm_acfg.11 = llvm_acfg;
    D.26831 = &llvm_acfg.11->mutex.mutex;
    ret = pthread_mutex_lock (D.26831);
    if (ret != 0) goto <D.26832>; else goto <D.26833>;
    <D.26832>:
    monoeg_g_log (0B, 16, "Bad call to mono_mutex_lock result %d", ret);
    <D.26833>:
    D.26834 = ret != 0;
    D.26835 = (long int) D.26834;
    D.26836 = __builtin_expect (D.26835, 0);
    if (D.26836 != 0) goto <D.26837>; else goto <D.26838>;
    <D.26837>:
    monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "aot-compiler.c", 6904, "ret == 0");
    <D.26838>:
  }
  llvm_acfg.11 = llvm_acfg;
  D.26839 = llvm_acfg.11->mempool;
  res = mono_patch_info_dup_mp (D.26839, ji);
  {
    int ret;

    llvm_acfg.11 = llvm_acfg;
    D.26831 = &llvm_acfg.11->mutex.mutex;
    ret = pthread_mutex_unlock (D.26831);
    if (ret != 0) goto <D.26840>; else goto <D.26841>;
    <D.26840>:
    monoeg_g_log (0B, 16, "Bad call to mono_mutex_unlock result %d", ret);
    <D.26841>:
    D.26842 = ret != 0;
    D.26843 = (long int) D.26842;
    D.26844 = __builtin_expect (D.26843, 0);
    if (D.26844 != 0) goto <D.26845>; else goto <D.26846>;
    <D.26845>:
    monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "aot-compiler.c", 6906, "ret == 0");
    <D.26846>:
  }
  D.26847 = res;
  return D.26847;
}


mono_aot_method_hash (struct MonoMethod * method)
{
  unsigned char D.26849;
  unsigned char D.26850;
  short unsigned int D.26853;
  int D.26854;
  int D.26855;
  int iftmp.12;
  <unnamed-unsigned:22> D.26859;
  long unsigned int D.26861;
  long unsigned int D.26862;
  unsigned char D.26863;
  unsigned char D.26864;
  _Bool D.26865;
  _Bool D.26866;
  _Bool D.26867;
  unsigned char D.26871;
  struct MonoType * D.26874;
  unsigned int D.26875;
  guint32 * D.26876;
  const char * D.26878;
  unsigned int D.26879;
  const char * D.26880;
  unsigned int D.26881;
  unsigned char D.26885;
  _Bool D.26886;
  _Bool D.26887;
  _Bool D.26888;
  guint32 * D.26890;
  const char * D.26891;
  unsigned int D.26892;
  guint32 * D.26893;
  <unnamed-unsigned:5> D.26894;
  unsigned int D.26895;
  guint32 * D.26896;
  struct MonoType * D.26897;
  unsigned int D.26898;
  int hindex.13;
  long unsigned int D.26900;
  long unsigned int D.26901;
  guint32 * D.26902;
  struct MonoType * D.26903;
  unsigned int D.26904;
  int hindex.14;
  long unsigned int D.26908;
  long unsigned int D.26909;
  guint32 * D.26910;
  struct MonoType * D.26911;
  unsigned int D.26912;
  int D.26913;
  _Bool D.26914;
  long int D.26915;
  long int D.26916;
  unsigned int hashes_count.15;
  unsigned int D.26920;
  unsigned int D.26921;
  unsigned int D.26922;
  unsigned int D.26923;
  unsigned int D.26924;
  unsigned int D.26925;
  unsigned int D.26926;
  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;
  guint32 D.26937;
  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.26849 = BIT_FIELD_REF <*method, 8, 264>;
  D.26850 = D.26849 & 16;
  if (D.26850 != 0) goto <D.26851>; else goto <D.26852>;
  <D.26851>:
  ginst = MEM[(struct MonoMethodInflated *)method].context.method_inst;
  <D.26852>:
  D.26853 = sig->param_count;
  D.26854 = (int) D.26853;
  D.26855 = D.26854 + 5;
  if (ginst != 0B) goto <D.26857>; else goto <D.26858>;
  <D.26857>:
  D.26859 = ginst->type_argc;
  iftmp.12 = (int) D.26859;
  goto <D.26860>;
  <D.26858>:
  iftmp.12 = 0;
  <D.26860>:
  hashes_count = D.26855 + iftmp.12;
  D.26861 = (long unsigned int) hashes_count;
  D.26862 = D.26861 * 4;
  hashes_start = monoeg_malloc0 (D.26862);
  hashes = hashes_start;
  D.26863 = BIT_FIELD_REF <*method, 8, 256>;
  D.26864 = D.26863 & 124;
  D.26865 = D.26864 == 0;
  D.26866 = D.26864 == 36;
  D.26867 = D.26865 | D.26866;
  if (D.26867 != 0) goto <D.26868>; else goto <D.26869>;
  <D.26868>:
  klass = method->klass;
  goto <D.26870>;
  <D.26869>:
  klass = mono_defaults.object_class;
  <D.26870>:
  D.26863 = BIT_FIELD_REF <*method, 8, 256>;
  D.26871 = D.26863 & 124;
  if (D.26871 == 0) goto <D.26872>; else goto <D.26873>;
  <D.26872>:
  {
    char * full_name;

    D.26874 = &klass->byval_arg;
    full_name = mono_type_full_name (D.26874);
    D.26875 = mono_metadata_str_hash (full_name);
    *hashes = D.26875;
    D.26876 = hashes + 4;
    *D.26876 = 0;
    monoeg_g_free (full_name);
  }
  goto <D.26877>;
  <D.26873>:
  D.26878 = klass->name;
  D.26879 = mono_metadata_str_hash (D.26878);
  *hashes = D.26879;
  D.26876 = hashes + 4;
  D.26880 = klass->name_space;
  D.26881 = mono_metadata_str_hash (D.26880);
  *D.26876 = D.26881;
  <D.26877>:
  D.26863 = BIT_FIELD_REF <*method, 8, 256>;
  D.26885 = D.26863 & 124;
  D.26886 = D.26885 == 52;
  D.26887 = D.26885 == 48;
  D.26888 = D.26886 | D.26887;
  if (D.26888 != 0) goto <D.26882>; else goto <D.26889>;
  <D.26889>:
  D.26863 = BIT_FIELD_REF <*method, 8, 256>;
  D.26871 = D.26863 & 124;
  if (D.26871 == 92) goto <D.26882>; else goto <D.26883>;
  <D.26882>:
  D.26890 = hashes + 8;
  *D.26890 = 0;
  goto <D.26884>;
  <D.26883>:
  D.26890 = hashes + 8;
  D.26891 = method->name;
  D.26892 = mono_metadata_str_hash (D.26891);
  *D.26890 = D.26892;
  <D.26884>:
  D.26893 = hashes + 12;
  D.26894 = method->wrapper_type;
  D.26895 = (unsigned int) D.26894;
  *D.26893 = D.26895;
  D.26896 = hashes + 16;
  D.26897 = sig->ret;
  D.26898 = mono_aot_type_hash (D.26897);
  *D.26896 = D.26898;
  hindex = 5;
  i = 0;
  goto <D.26093>;
  <D.26092>:
  hindex.13 = hindex;
  hindex = hindex.13 + 1;
  D.26900 = (long unsigned int) hindex.13;
  D.26901 = D.26900 * 4;
  D.26902 = hashes + D.26901;
  D.26903 = sig->params[i];
  D.26904 = mono_aot_type_hash (D.26903);
  *D.26902 = D.26904;
  i = i + 1;
  <D.26093>:
  D.26853 = sig->param_count;
  D.26854 = (int) D.26853;
  if (D.26854 > i) goto <D.26092>; else goto <D.26094>;
  <D.26094>:
  if (ginst != 0B) goto <D.26905>; else goto <D.26906>;
  <D.26905>:
  i = 0;
  goto <D.26096>;
  <D.26095>:
  hindex.14 = hindex;
  hindex = hindex.14 + 1;
  D.26908 = (long unsigned int) hindex.14;
  D.26909 = D.26908 * 4;
  D.26910 = hashes + D.26909;
  D.26911 = ginst->type_argv[i];
  D.26912 = mono_aot_type_hash (D.26911);
  *D.26910 = D.26912;
  i = i + 1;
  <D.26096>:
  D.26859 = ginst->type_argc;
  D.26913 = (int) D.26859;
  if (D.26913 > i) goto <D.26095>; else goto <D.26097>;
  <D.26097>:
  <D.26906>:
  D.26914 = hindex != hashes_count;
  D.26915 = (long int) D.26914;
  D.26916 = __builtin_expect (D.26915, 0);
  if (D.26916 != 0) goto <D.26917>; else goto <D.26918>;
  <D.26917>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "aot-compiler.c", 7387, "hindex == hashes_count");
  <D.26918>:
  hashes_count.15 = (unsigned int) hashes_count;
  D.26920 = hashes_count.15 << 2;
  c = D.26920 + 3735928559;
  b = c;
  a = b;
  goto <D.26099>;
  <D.26098>:
  D.26921 = *hashes;
  a = D.26921 + a;
  D.26876 = hashes + 4;
  D.26922 = *D.26876;
  b = D.26922 + b;
  D.26890 = hashes + 8;
  D.26923 = *D.26890;
  c = D.26923 + c;
  a = a - c;
  D.26924 = c r>> 28;
  a = D.26924 ^ a;
  c = c + b;
  b = b - a;
  D.26925 = a r>> 26;
  b = D.26925 ^ b;
  a = a + c;
  c = c - b;
  D.26926 = b r>> 24;
  c = D.26926 ^ c;
  b = b + a;
  a = a - c;
  D.26927 = c r>> 16;
  a = D.26927 ^ a;
  c = c + b;
  b = b - a;
  D.26928 = a r>> 13;
  b = D.26928 ^ b;
  a = a + c;
  c = c - b;
  D.26929 = b r>> 28;
  c = D.26929 ^ c;
  b = b + a;
  hashes_count = hashes_count + -3;
  hashes = hashes + 12;
  <D.26099>:
  if (hashes_count > 3) goto <D.26098>; else goto <D.26100>;
  <D.26100>:
  switch (hashes_count) <default: <D.26936>, case 0: <D.26104>, case 1: <D.26103>, case 2: <D.26102>, case 3: <D.26101>>
  <D.26101>:
  D.26890 = hashes + 8;
  D.26923 = *D.26890;
  c = D.26923 + c;
  <D.26102>:
  D.26876 = hashes + 4;
  D.26922 = *D.26876;
  b = D.26922 + b;
  <D.26103>:
  D.26921 = *hashes;
  a = D.26921 + a;
  c = c ^ b;
  D.26930 = b r>> 18;
  c = c - D.26930;
  a = a ^ c;
  D.26931 = c r>> 21;
  a = a - D.26931;
  b = b ^ a;
  D.26932 = a r>> 7;
  b = b - D.26932;
  c = c ^ b;
  D.26933 = b r>> 16;
  c = c - D.26933;
  a = a ^ c;
  D.26924 = c r>> 28;
  a = a - D.26924;
  b = b ^ a;
  D.26934 = a r>> 18;
  b = b - D.26934;
  c = c ^ b;
  D.26935 = b r>> 8;
  c = c - D.26935;
  <D.26104>:
  goto <D.26105>;
  <D.26936>:
  <D.26105>:
  free (hashes_start);
  D.26937 = c;
  return D.26937;
}


mono_aot_type_hash (struct MonoType * t1)
{
  unsigned char D.26939;
  <unnamed-unsigned:1> D.26940;
  int D.26941;
  int D.26942;
  unsigned int D.26943;
  int D.26944;
  guint D.26945;
  unsigned int D.26946;
  unsigned int D.26947;
  struct MonoClass * D.26948;
  const char * D.26949;
  unsigned int D.26950;
  struct MonoType * D.26951;
  unsigned int D.26952;
  struct MonoArrayType * D.26953;
  struct MonoClass * D.26954;
  struct MonoType * D.26955;
  unsigned int D.26956;
  guint hash;

  D.26939 = t1->type;
  hash = (guint) D.26939;
  D.26940 = t1->byref;
  D.26941 = (int) D.26940;
  D.26942 = D.26941 << 6;
  D.26943 = (unsigned int) D.26942;
  hash = D.26943 | hash;
  D.26939 = t1->type;
  D.26944 = (int) D.26939;
  switch (D.26944) <default: <D.26076>, case 15: <D.26073>, case 17: <D.26070>, case 18: <D.26071>, case 20: <D.26074>, case 21: <D.26075>, case 29: <D.26072>>
  <D.26070>:
  <D.26071>:
  <D.26072>:
  D.26946 = hash << 5;
  D.26947 = D.26946 - hash;
  D.26948 = t1->data.klass;
  D.26949 = D.26948->name;
  D.26950 = mono_metadata_str_hash (D.26949);
  D.26945 = D.26947 ^ D.26950;
  return D.26945;
  <D.26073>:
  D.26946 = hash << 5;
  D.26947 = D.26946 - hash;
  D.26951 = t1->data.type;
  D.26952 = mono_metadata_type_hash (D.26951);
  D.26945 = D.26947 ^ D.26952;
  return D.26945;
  <D.26074>:
  D.26946 = hash << 5;
  D.26947 = D.26946 - hash;
  D.26953 = t1->data.array;
  D.26954 = D.26953->eklass;
  D.26955 = &D.26954->byval_arg;
  D.26956 = mono_metadata_type_hash (D.26955);
  D.26945 = D.26947 ^ D.26956;
  return D.26945;
  <D.26075>:
  D.26946 = hash << 5;
  D.26945 = D.26946 - hash;
  return D.26945;
  <D.26076>:
  D.26945 = hash;
  return D.26945;
}


mono_aot_get_array_helper_from_wrapper (struct MonoMethod * method)
{
  const char * D.26958;
  long unsigned int D.26959;
  sizetype D.26960;
  const char * D.26961;
  _Bool D.26962;
  long int D.26963;
  long int D.26964;
  int D.26126;
  int iftmp.16;
  int D.26125;
  const char[6] * D.26970;
  unsigned char D.26971;
  int D.26972;
  unsigned char D.26973;
  int D.26974;
  _Bool D.26975;
  _Bool D.26976;
  _Bool D.26977;
  const unsigned char * D.26980;
  unsigned char D.26981;
  int D.26982;
  const unsigned char * D.26983;
  unsigned char D.26984;
  int D.26985;
  _Bool D.26986;
  _Bool D.26987;
  const unsigned char * D.26990;
  unsigned char D.26991;
  int D.26992;
  const unsigned char * D.26993;
  unsigned char D.26994;
  int D.26995;
  _Bool D.26996;
  _Bool D.26997;
  const unsigned char * D.27000;
  unsigned char D.27001;
  int D.27002;
  const unsigned char * D.27003;
  unsigned char D.27004;
  int D.27005;
  struct MonoMethodSignature * D.27010;
  short unsigned int D.27011;
  int D.27012;
  struct MonoClass * D.27013;
  _Bool D.27014;
  long int D.27015;
  long int D.27016;
  unsigned char D.27019;
  unsigned char D.27020;
  struct MonoClass * D.27023;
  struct MonoClass * D.27024;
  struct MonoType * D.27025;
  struct MonoGenericInst * D.27026;
  struct MonoMethod * D.27027;
  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.26958 = method->name;
      D.26959 = strlen (prefix);
      D.26960 = D.26959 + 1;
      D.26961 = D.26958 + D.26960;
      s = monoeg_g_strdup_printf ("%s", D.26961);
      s2 = strstr (s, "`1.");
      D.26962 = s2 == 0B;
      D.26963 = (long int) D.26962;
      D.26964 = __builtin_expect (D.26963, 0);
      if (D.26964 != 0) goto <D.26965>; else goto <D.26966>;
      <D.26965>:
      monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "aot-compiler.c", 7437, "s2");
      <D.26966>:
      *s2 = 0;
      iname = s;
      mname = s2 + 3;
      {
        size_t __s1_len;
        size_t __s2_len;

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

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


memset (void * __dest, int __ch, size_t __len)
{
  int D.27032;
  int D.27037;
  void * D.27039;
  long unsigned int D.27040;

  D.27032 = __builtin_constant_p (__len);
  if (D.27032 != 0) goto <D.27033>; else goto <D.27034>;
  <D.27033>:
  if (__len == 0) goto <D.27035>; else goto <D.27036>;
  <D.27035>:
  D.27037 = __builtin_constant_p (__ch);
  if (D.27037 == 0) goto <D.27030>; else goto <D.27038>;
  <D.27038>:
  if (__ch != 0) goto <D.27030>; else goto <D.27031>;
  <D.27030>:
  __warn_memset_zero_len ();
  D.27039 = __dest;
  return D.27039;
  <D.27031>:
  <D.27036>:
  <D.27034>:
  D.27040 = __builtin_object_size (__dest, 0);
  D.27039 = __builtin___memset_chk (__dest, __ch, __len, D.27040);
  return D.27039;
}


mono_compile_assembly (struct MonoAssembly * ass, guint32 opts, const char * aot_options)
{
  unsigned int D.27042;
  struct _IO_FILE * stderr.17;
  char * D.27046;
  struct MonoAotOptions * D.27047;
  gchar * D.27048;
  int D.27049;
  int D.27052;
  int D.27059;
  int D.27062;
  int D.27065;
  <unnamed type> D.27066;
  unsigned int D.27067;
  int mono_use_llvm.18;
  unsigned int D.27071;
  int D.27074;
  unsigned int D.27077;
  guint32 iftmp.19;
  int D.27081;
  guint32 iftmp.20;
  int D.27086;
  guint32 iftmp.21;
  int D.27091;
  const char * D.27093;
  struct MonoImage * D.27094;
  struct MonoAssembly * D.27095;
  const char * D.27096;
  gchar * D.27097;
  const char * D.27098;
  gchar * D.27099;
  gchar * D.27100;
  const short unsigned int * * D.27101;
  const short unsigned int * D.27102;
  char D.27103;
  long unsigned int D.27104;
  long unsigned int D.27105;
  const short unsigned int * D.27106;
  short unsigned int D.27107;
  int D.27108;
  int D.27109;
  struct GPtrArray * D.27122;
  unsigned int D.27123;
  unsigned int D.27124;
  int D.27125;
  int D.27126;
  long unsigned int D.27127;
  long unsigned int D.27128;
  void * D.27129;
  struct MonoMemPool * D.27130;
  long int D.27131;
  long int D.27132;
  int D.27133;
  int D.27136;
  int D.27138;
  int D.27140;
  char * D.27142;
  char * D.27146;
  struct FILE * D.27147;
  struct FILE * D.27148;
  int * D.27151;
  int D.27152;
  char * D.27153;
  struct MonoImageWriter * D.27154;
  int D.27155;
  char * D.27158;
  struct FILE * D.27159;
  gchar * D.27165;
  gchar * D.27167;
  struct FILE * D.27168;
  char * * D.27170;
  struct FILE * D.27171;
  char * D.27174;
  struct MonoImageWriter * D.27175;
  char * D.27176;
  gchar * D.27177;
  struct MonoCompile * * D.27178;
  long unsigned int D.27179;
  long unsigned int D.27180;
  struct MonoCompile * * D.27181;
  struct MonoCompile * D.27182;
  struct MonoMethod * D.27185;
  unsigned int D.27186;
  char * D.27189;
  gchar * D.27190;
  int D.27192;
  struct GHashTable * D.27195;
  struct MonoMethod * D.27196;
  char * D.27197;
  const char * D.27199;
  gchar * D.27200;
  unsigned int i.22;
  unsigned int D.27202;
  int D.27203;
  int D.27208;
  int D.27213;
  int D.27217;
  int D.27220;
  _Bool D.27221;
  int D.27222;
  struct MonoImageWriter * D.27223;
  struct MonoDwarfWriter * D.27224;
  struct MonoDwarfWriter * D.27225;
  struct GSList * D.27228;
  gchar * D.27229;
  int D.27230;
  int D.27235;
  int D.27238;
  unsigned int D.27243;
  unsigned int D.27244;
  _Bool D.27245;
  long int D.27246;
  long int D.27247;
  int iftmp.23;
  int D.27253;
  int D.27256;
  int D.27257;
  int D.27260;
  unsigned int D.27261;
  int D.27262;
  int D.27263;
  unsigned int D.27264;
  int D.27265;
  int D.27266;
  int D.27267;
  int D.27268;
  int D.27269;
  int iftmp.24;
  int D.27271;
  int D.27274;
  int D.27275;
  int iftmp.25;
  int D.27280;
  int D.27281;
  int iftmp.26;
  int D.27286;
  int D.27287;
  int D.27289;
  int iftmp.27;
  int D.27295;
  int D.27297;
  int iftmp.28;
  int D.27303;
  int D.27305;
  int iftmp.29;
  int D.27311;
  int D.27313;
  int iftmp.30;
  int D.27319;
  char * D.27327;
  int D.27331;
  int D.27334;
  int D.27337;
  const char * D.27338;
  int D.27339;
  int D.27340;
  int D.27341;
  int D.27342;
  int D.27343;
  int D.27344;
  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.27042 = opts & 16777216;
      if (D.27042 != 0) goto <D.27043>; else goto <D.27044>;
      <D.27043>:
      stderr.17 = stderr;
      fprintf (stderr.17, "-O=gsharedvt not supported on this platform.\n");
      exit (1);
      <D.27044>:
      D.27046 = image->name;
      printf ("Mono Ahead of Time compiler - compiling assembly %s\n", D.27046);
      acfg = acfg_create (ass, opts);
      D.27047 = &acfg->aot_opts;
      memset (D.27047, 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.27048 = monoeg_strdup ("");
      acfg->aot_opts.llvm_path = D.27048;
      D.27047 = &acfg->aot_opts;
      mono_aot_parse_options (aot_options, D.27047);
      D.27049 = acfg->aot_opts.static_link;
      if (D.27049 != 0) goto <D.27050>; else goto <D.27051>;
      <D.27050>:
      acfg->aot_opts.autoreg = 1;
      <D.27051>:
      D.27052 = acfg->aot_opts.direct_pinvoke;
      if (D.27052 != 0) goto <D.27053>; else goto <D.27054>;
      <D.27053>:
      D.27049 = acfg->aot_opts.static_link;
      if (D.27049 == 0) goto <D.27055>; else goto <D.27056>;
      <D.27055>:
      stderr.17 = stderr;
      fprintf (stderr.17, "The \'direct-pinvoke\' AOT option also requires the \'static\' AOT option.\n");
      exit (1);
      <D.27056>:
      <D.27054>:
      D.27049 = acfg->aot_opts.static_link;
      if (D.27049 != 0) goto <D.27057>; else goto <D.27058>;
      <D.27057>:
      acfg->aot_opts.asm_writer = 1;
      <D.27058>:
      D.27059 = acfg->aot_opts.soft_debug;
      if (D.27059 != 0) goto <D.27060>; else goto <D.27061>;
      <D.27060>:
      {
        struct MonoDebugOptions * opt;

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

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

        D.27170 = &acfg->tmpfname;
        i = monoeg_g_file_open_tmp ("mono_aot_XXXXXX", D.27170, 0B);
        D.27171 = fdopen (i, "w+");
        acfg->fp = D.27171;
      }
      <D.27169>:
      <D.27160>:
      D.27148 = acfg->fp;
      if (D.27148 == 0B) goto <D.27172>; else goto <D.27173>;
      <D.27172>:
      D.27151 = __errno_location ();
      D.27152 = *D.27151;
      D.27174 = strerror (D.27152);
      D.27158 = acfg->tmpfname;
      stderr.17 = stderr;
      fprintf (stderr.17, "Unable to open file \'%s\': %s\n", D.27158, D.27174);
      D.27065 = 1;
      return D.27065;
      <D.27173>:
      D.27148 = acfg->fp;
      D.27175 = img_writer_create (D.27148, 0);
      acfg->w = D.27175;
      tmp_outfile_name = 0B;
      outfile_name = 0B;
      <D.27135>:
      D.27176 = acfg->got_symbol_base;
      D.27098 = acfg->llvm_label_prefix;
      D.27177 = monoeg_g_strdup_printf ("%s%s", D.27098, D.27176);
      acfg->got_symbol = D.27177;
      i = 0;
      goto <D.26474>;
      <D.26473>:
      D.27178 = acfg->cfgs;
      D.27179 = (long unsigned int) i;
      D.27180 = D.27179 * 8;
      D.27181 = D.27178 + D.27180;
      D.27182 = *D.27181;
      if (D.27182 != 0B) goto <D.27183>; else goto <D.27184>;
      <D.27183>:
      {
        struct MonoCompile * cfg;
        int method_index;

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

        err = rename (tmp_outfile_name, outfile_name);
        if (err != 0) goto <D.27325>; else goto <D.27326>;
        <D.27325>:
        D.27151 = __errno_location ();
        D.27152 = *D.27151;
        D.27327 = strerror (D.27152);
        printf ("Unable to rename \'%s\' to \'%s\': %s\n", tmp_outfile_name, outfile_name, D.27327);
        D.27065 = 1;
        return D.27065;
        <D.27326>:
      }
      goto <D.27328>;
      <D.27324>:
      res = compile_asm (acfg);
      if (res != 0) goto <D.27329>; else goto <D.27330>;
      <D.27329>:
      acfg_free (acfg);
      D.27065 = res;
      return D.27065;
      <D.27330>:
      <D.27328>:
      btv = mono_100ns_ticks ();
      D.27131 = btv - atv;
      D.27132 = D.27131 / 10;
      D.27133 = (int) D.27132;
      acfg->stats.link_time = D.27133;
      D.27331 = acfg->aot_opts.stats;
      if (D.27331 != 0) goto <D.27332>; else goto <D.27333>;
      <D.27332>:
      {
        int i;

        printf ("GOT slot distribution:\n");
        i = 0;
        goto <D.26480>;
        <D.26479>:
        D.27334 = acfg->stats.got_slot_types[i];
        if (D.27334 != 0) goto <D.27335>; else goto <D.27336>;
        <D.27335>:
        D.27337 = acfg->stats.got_slot_info_sizes[i];
        D.27334 = acfg->stats.got_slot_types[i];
        D.27338 = get_patch_name (i);
        printf ("\t%s: %d (%d)\n", D.27338, D.27334, D.27337);
        <D.27336>:
        i = i + 1;
        <D.26480>:
        if (i <= 50) goto <D.26479>; else goto <D.26481>;
        <D.26481>:
      }
      <D.27333>:
      D.27339 = acfg->stats.link_time;
      D.27340 = D.27339 / 1000;
      D.27341 = acfg->stats.gen_time;
      D.27342 = D.27341 / 1000;
      D.27343 = acfg->stats.jit_time;
      D.27344 = D.27343 / 1000;
      printf ("JIT time: %d ms, Generation time: %d ms, Assembly+Link time: %d ms.\n", D.27344, D.27342, D.27340);
      acfg_free (acfg);
      D.27065 = 0;
      return D.27065;
    }
  finally
    {
      llvm_stats_msg = {CLOBBER};
    }
}


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

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


mono_aot_parse_options (const char * aot_options, struct MonoAotOptions * opts)
{
  const gchar * iftmp.31;
  int D.27384;
  const gchar * D.27387;
  gchar * D.27388;
  int D.27390;
  int D.27394;
  int D.27398;
  int D.27402;
  int D.27406;
  int D.27410;
  int D.27414;
  int D.27418;
  const char * D.27421;
  int D.27422;
  int D.27424;
  int D.27428;
  int D.27432;
  int D.27436;
  int D.27440;
  int D.27444;
  int D.27448;
  const char * D.27451;
  int D.27452;
  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;
  int D.27476;
  const gchar * D.27479;
  gchar * D.27480;
  int D.27482;
  int D.27486;
  int D.27490;
  int D.27494;
  int D.27498;
  int D.27502;
  int D.27506;
  int D.27510;
  int D.27514;
  gchar * D.27517;
  int D.27519;
  const gchar * D.27522;
  gchar * D.27523;
  int D.27525;
  const char * D.27528;
  int D.27530;
  int D.27533;
  int D.27539;
  int D.27541;
  struct _IO_FILE * stderr.32;
  gchar * D.27544;
  int D.27545;
  gchar * * args;
  gchar * * ptr;

  if (aot_options != 0B) goto <D.27381>; else goto <D.27382>;
  <D.27381>:
  iftmp.31 = aot_options;
  goto <D.27383>;
  <D.27382>:
  iftmp.31 = "";
  <D.27383>:
  args = monoeg_g_strsplit (iftmp.31, ",", -1);
  ptr = args;
  goto <D.25802>;
  <D.25801>:
  {
    const char * arg;

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


atoi (const char * __nptr)
{
  int D.27548;
  long int D.27549;

  D.27549 = strtol (__nptr, 0B, 10);
  D.27548 = (int) D.27549;
  return D.27548;
}


add_readonly_value (struct MonoAotOptions * opts, const char * val)
{
  struct _IO_FILE * stderr.33;
  long int tval.34;
  long int val.35;
  long int D.27558;
  long int D.27559;
  long unsigned int D.27560;
  void * D.27561;
  long unsigned int D.27562;
  char * D.27563;
  int D.27564;
  int D.27567;
  unsigned char D.27568;
  int D.27570;
  int D.27573;
  short unsigned int D.27574;
  int D.27576;
  int D.27579;
  unsigned int D.27580;
  struct ReadOnlyValue * readonly_values.36;
  struct ReadOnlyValue * rdv;
  const char * fval;
  const char * tval;

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


str_begins_with (const char * str1, const char * str2)
{
  long unsigned int D.27583;
  gboolean D.27584;
  long unsigned int D.27585;
  int D.27586;
  _Bool D.27587;
  int len;

  D.27583 = strlen (str2);
  len = (int) D.27583;
  D.27585 = (long unsigned int) len;
  D.27586 = strncmp (str1, str2, D.27585);
  D.27587 = D.27586 == 0;
  D.27584 = (gboolean) D.27587;
  return D.27584;
}


load_profile_files (struct MonoAotCompile * acfg)
{
  struct MonoImage * D.27589;
  const char * D.27590;
  const gchar * D.27591;
  int D.27592;
  _Bool D.27595;
  long int D.27596;
  long int D.27597;
  int D.25986;
  int iftmp.37;
  int D.25985;
  const char[7] * D.27606;
  unsigned char D.27607;
  int D.27608;
  unsigned char D.27609;
  int D.27610;
  _Bool D.27611;
  _Bool D.27612;
  _Bool D.27613;
  const unsigned char * D.27616;
  unsigned char D.27617;
  int D.27618;
  const unsigned char * D.27619;
  unsigned char D.27620;
  int D.27621;
  _Bool D.27622;
  _Bool D.27623;
  const unsigned char * D.27626;
  unsigned char D.27627;
  int D.27628;
  const unsigned char * D.27629;
  unsigned char D.27630;
  int D.27631;
  _Bool D.27632;
  _Bool D.27633;
  const unsigned char * D.27636;
  unsigned char D.27637;
  int D.27638;
  const unsigned char * D.27639;
  unsigned char D.27640;
  int D.27641;
  char * D.27643;
  char[1024] * name.38;
  char D.27646;
  long unsigned int D.27649;
  long unsigned int D.27650;
  unsigned int D.27653;
  unsigned int D.27656;
  unsigned int D.27657;
  struct GPtrArray * D.27658;
  void * * D.27659;
  long unsigned int D.27660;
  long unsigned int D.27661;
  void * * D.27662;
  void * D.27663;
  long unsigned int D.27664;
  void * D.27665;
  unsigned int i.39;
  unsigned int D.27669;
  <unnamed-unsigned:24> D.27677;
  int D.27678;
  void * D.27679;
  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.25996>:
      D.27589 = acfg->image;
      D.27590 = D.27589->assembly_name;
      D.27591 = monoeg_g_get_home_dir ();
      tmp = monoeg_g_strdup_printf ("%s/.mono/aot-profile-data/%s-%d", D.27591, D.27590, file_index);
      D.27592 = monoeg_g_file_test (tmp, 1);
      if (D.27592 == 0) goto <D.27593>; else goto <D.27594>;
      <D.27593>:
      monoeg_g_free (tmp);
      goto <D.25977>;
      <D.27594>:
      infile = fopen (tmp, "r");
      D.27595 = infile == 0B;
      D.27596 = (long int) D.27595;
      D.27597 = __builtin_expect (D.27596, 0);
      if (D.27597 != 0) goto <D.27598>; else goto <D.27599>;
      <D.27598>:
      monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "aot-compiler.c", 6785, "infile");
      <D.27599>:
      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.27600>; else goto <D.27602>;
      <D.27602>:
      {
        size_t __s1_len;
        size_t __s2_len;

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

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

        try
          {
            D.27643 = fgets (&name, 1023, infile);
            if (D.27643 == 0B) goto <D.25991>; else goto <D.27644>;
            <D.27644>:
            name.38 = &name;
            D.27646 = MEM[(const char *)name.38];
            if (D.27646 != 0) goto <D.27647>; else goto <D.27648>;
            <D.27647>:
            D.27649 = strlen (&name);
            D.27650 = D.27649 + 18446744073709551615;
            name[D.27650] = 0;
            <D.27648>:
            desc = mono_method_desc_new (&name, 1);
            D.27589 = acfg->image;
            method = mono_method_desc_search_in_image (desc, D.27589);
            if (method != 0B) goto <D.27651>; else goto <D.27652>;
            <D.27651>:
            D.27653 = mono_method_get_token (method);
            if (D.27653 != 0) goto <D.27654>; else goto <D.27655>;
            <D.27654>:
            token = mono_method_get_token (method);
            D.27656 = token & 16777215;
            D.27657 = D.27656 + 4294967295;
            method_index = (int) D.27657;
            found = 0;
            i = 0;
            goto <D.25994>;
            <D.25993>:
            D.27658 = acfg->method_order;
            D.27659 = D.27658->pdata;
            D.27660 = (long unsigned int) i;
            D.27661 = D.27660 * 8;
            D.27662 = D.27659 + D.27661;
            D.27663 = *D.27662;
            D.27664 = (long unsigned int) method_index;
            D.27665 = (void *) D.27664;
            if (D.27663 == D.27665) goto <D.27666>; else goto <D.27667>;
            <D.27666>:
            found = 1;
            goto <D.25992>;
            <D.27667>:
            i = i + 1;
            <D.25994>:
            i.39 = (unsigned int) i;
            D.27658 = acfg->method_order;
            D.27669 = D.27658->len;
            if (i.39 < D.27669) goto <D.25993>; else goto <D.25992>;
            <D.25992>:
            if (found == 0) goto <D.27670>; else goto <D.27671>;
            <D.27670>:
            D.27664 = (long unsigned int) method_index;
            D.27665 = (void *) D.27664;
            D.27658 = acfg->method_order;
            monoeg_g_ptr_array_add (D.27658, D.27665);
            <D.27671>:
            goto <D.27672>;
            <D.27655>:
            <D.27672>:
            <D.27652>:
          }
        finally
          {
            name = {CLOBBER};
          }
      }
      goto <D.25995>;
      <D.25991>:
      fclose (infile);
      <D.25987>:
      goto <D.25996>;
      <D.25977>:
      unordered = 0B;
      method_index = 0;
      goto <D.26001>;
      <D.26000>:
      found = 0;
      i = 0;
      goto <D.25999>;
      <D.25998>:
      D.27658 = acfg->method_order;
      D.27659 = D.27658->pdata;
      D.27660 = (long unsigned int) i;
      D.27661 = D.27660 * 8;
      D.27662 = D.27659 + D.27661;
      D.27663 = *D.27662;
      D.27664 = (long unsigned int) method_index;
      D.27665 = (void *) D.27664;
      if (D.27663 == D.27665) goto <D.27673>; else goto <D.27674>;
      <D.27673>:
      found = 1;
      goto <D.25997>;
      <D.27674>:
      i = i + 1;
      <D.25999>:
      i.39 = (unsigned int) i;
      D.27658 = acfg->method_order;
      D.27669 = D.27658->len;
      if (i.39 < D.27669) goto <D.25998>; else goto <D.25997>;
      <D.25997>:
      if (found == 0) goto <D.27675>; else goto <D.27676>;
      <D.27675>:
      D.27664 = (long unsigned int) method_index;
      D.27665 = (void *) D.27664;
      unordered = monoeg_g_list_prepend (unordered, D.27665);
      <D.27676>:
      method_index = method_index + 1;
      <D.26001>:
      D.27589 = acfg->image;
      D.27677 = D.27589->tables[6].rows;
      D.27678 = (int) D.27677;
      if (D.27678 > method_index) goto <D.26000>; else goto <D.26002>;
      <D.26002>:
      unordered = monoeg_g_list_reverse (unordered);
      l = unordered;
      goto <D.26004>;
      <D.26003>:
      D.27679 = l->data;
      D.27658 = acfg->method_order;
      monoeg_g_ptr_array_add (D.27658, D.27679);
      l = l->next;
      <D.26004>:
      if (l != 0B) goto <D.26003>; else goto <D.26005>;
      <D.26005>:
    }
  finally
    {
      ver = {CLOBBER};
    }
}


fgets (char * restrict __s, int __n, struct FILE * restrict __stream)
{
  long unsigned int D.27682;
  int D.27687;
  char * D.27689;
  long unsigned int D.27690;
  long unsigned int D.27691;
  long unsigned int D.27692;
  long unsigned int D.27695;

  D.27682 = __builtin_object_size (__s, 1);
  if (D.27682 != 18446744073709551615) goto <D.27683>; else goto <D.27684>;
  <D.27683>:
  D.27687 = __builtin_constant_p (__n);
  if (D.27687 == 0) goto <D.27685>; else goto <D.27688>;
  <D.27688>:
  if (__n <= 0) goto <D.27685>; else goto <D.27686>;
  <D.27685>:
  D.27690 = __builtin_object_size (__s, 1);
  D.27689 = __fgets_chk (__s, D.27690, __n, __stream);
  return D.27689;
  <D.27686>:
  D.27691 = (long unsigned int) __n;
  D.27692 = __builtin_object_size (__s, 1);
  if (D.27691 > D.27692) goto <D.27693>; else goto <D.27694>;
  <D.27693>:
  D.27695 = __builtin_object_size (__s, 1);
  D.27689 = __fgets_chk_warn (__s, D.27695, __n, __stream);
  return D.27689;
  <D.27694>:
  <D.27684>:
  D.27689 = __fgets_alias (__s, __n, __stream);
  return D.27689;
}


arch_init (struct MonoAotCompile * acfg)
{
  struct GString * D.27697;
  struct GString * D.27698;
  struct GString * D.27699;

  D.27697 = monoeg_g_string_new ("");
  acfg->llc_args = D.27697;
  D.27698 = monoeg_g_string_new ("");
  acfg->as_args = D.27698;
  acfg->llvm_label_prefix = "";
  acfg->user_symbol_prefix = "";
  D.27699 = acfg->llc_args;
  monoeg_g_string_append (D.27699, " -march=x86-64");
  acfg->need_pt_gnu_stack = 1;
}


collect_methods (struct MonoAotCompile * acfg)
{
  int D.27700;
  int D.27701;
  struct MonoImage * D.27702;
  char * D.27705;
  struct MonoClass * D.27706;
  int D.27707;
  short unsigned int D.27710;
  int D.27711;
  int D.27712;
  int check_for_pending_exc.40;
  int D.27716;
  int D.27717;
  <unnamed-unsigned:24> D.27718;
  int D.27719;
  int D.27720;
  int D.27721;
  unsigned int D.27722;
  unsigned int D.27723;
  unsigned char D.27730;
  unsigned char D.27731;
  struct MonoClass * D.27733;
  struct MonoGenericContainer * D.27734;
  int mindex;
  int i;
  struct MonoImage * image;

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

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

      check_for_pending_exc.40 = check_for_pending_exc;
      wrapper = mono_marshal_get_native_wrapper (method, check_for_pending_exc.40, 1);
      method = wrapper;
    }
    <D.27714>:
    <D.27709>:
    add_method_with_index (acfg, method, i, 0);
    D.27716 = acfg->method_index;
    D.27717 = D.27716 + 1;
    acfg->method_index = D.27717;
  }
  i = i + 1;
  <D.26377>:
  D.27718 = image->tables[6].rows;
  D.27719 = (int) D.27718;
  if (D.27719 > i) goto <D.26376>; else goto <D.26378>;
  <D.26378>:
  mindex = 0;
  goto <D.26384>;
  <D.26383>:
  {
    struct MonoMethod * method;
    guint32 token;

    D.27720 = mindex + 1;
    D.27721 = D.27720 | 100663296;
    token = (guint32) D.27721;
    D.27722 = acfg->opts;
    D.27723 = D.27722 & 16777216;
    if (D.27723 == 0) goto <D.27724>; else goto <D.27725>;
    <D.27724>:
    // predicted unlikely by continue predictor.
    goto <D.26381>;
    <D.27725>:
    D.27702 = acfg->image;
    method = mono_get_method (D.27702, token, 0B);
    if (method == 0B) goto <D.27726>; else goto <D.27727>;
    <D.27726>:
    // predicted unlikely by continue predictor.
    goto <D.26381>;
    <D.27727>:
    D.27730 = BIT_FIELD_REF <*method, 8, 264>;
    D.27731 = D.27730 & 8;
    if (D.27731 != 0) goto <D.27728>; else goto <D.27732>;
    <D.27732>:
    D.27733 = method->klass;
    D.27734 = D.27733->generic_container;
    if (D.27734 != 0B) goto <D.27728>; else goto <D.27729>;
    <D.27728>:
    {
      struct MonoMethod * gshared;

      gshared = mini_get_shared_method_full (method, 1, 1);
      add_extra_method (acfg, gshared);
    }
    <D.27729>:
  }
  <D.26381>:
  mindex = mindex + 1;
  <D.26384>:
  D.27718 = image->tables[6].rows;
  D.27719 = (int) D.27718;
  if (D.27719 > mindex) goto <D.26383>; else goto <D.26385>;
  <D.26385>:
  add_generic_instances (acfg);
  D.27707 = acfg->aot_opts.full_aot;
  if (D.27707 != 0) goto <D.27735>; else goto <D.27736>;
  <D.27735>:
  add_wrappers (acfg);
  <D.27736>:
}


add_method_with_index (struct MonoAotCompile * acfg, struct MonoMethod * method, int index, gboolean extra)
{
  _Bool D.27737;
  long int D.27738;
  long int D.27739;
  struct GHashTable * D.27742;
  void * D.27743;
  struct GPtrArray * D.27746;
  int D.27747;
  long unsigned int D.27748;
  void * D.27749;
  unsigned int D.27750;
  unsigned int D.27751;
  unsigned char D.27754;
  unsigned char D.27755;
  struct GPtrArray * D.27757;

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


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.27758;
  int D.27761;
  char * D.27764;

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


add_method_full (struct MonoAotCompile * acfg, struct MonoMethod * method, gboolean extra, int depth)
{
  struct GHashTable * D.27765;
  void * D.27766;
  long int D.27767;
  int D.27770;
  long unsigned int D.27771;
  void * D.27772;
  struct GPtrArray * D.27773;
  long unsigned int D.27774;
  void * D.27775;
  struct GHashTable * D.27776;
  int D.27777;
  int D.27778;
  int index;

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


add_generic_instances (struct MonoAotCompile * acfg)
{
  int D.27780;
  int D.27783;
  int D.27784;
  struct MonoImage * D.27785;
  struct MonoClass * D.27788;
  struct MonoImage * D.27789;
  struct MonoGenericInst * D.27794;
  unsigned char D.27797;
  unsigned char D.27798;
  struct MonoGenericInst * D.27803;
  unsigned char D.27806;
  unsigned char D.27807;
  struct MonoType * D.27814;
  int D.27815;
  unsigned char D.27817;
  int D.27819;
  <unnamed-unsigned:22> D.27822;
  int D.27823;
  int D.27828;
  int D.27831;
  long unsigned int D.27838;
  long unsigned int D.27839;
  int D.27843;
  long unsigned int D.27846;
  long unsigned int D.27847;
  struct MonoType * * D.27848;
  struct MonoClass * D.27849;
  struct MonoType * D.27850;
  struct MonoGenericInst * D.27851;
  int D.27857;
  struct MonoGenericInst * D.27860;
  unsigned char D.27864;
  unsigned char D.27865;
  struct MonoGenericContainer * D.27867;
  int D.27868;
  <unnamed-unsigned:24> D.27871;
  int D.27872;
  int D.27873;
  unsigned char D.27877;
  <unnamed-unsigned:24> D.27878;
  int D.27879;
  struct GPtrArray * D.27880;
  void * * D.27881;
  long unsigned int D.27882;
  long unsigned int D.27883;
  void * * D.27884;
  unsigned int i.41;
  unsigned int D.27886;
  struct MonoImage * D.27887;
  int ninsts.42;
  struct MonoClass * D.27891;
  struct MonoType * D.27892;
  int ninsts.43;
  struct MonoClass * D.27894;
  struct MonoType * D.27895;
  int ninsts.44;
  struct MonoClass * D.27897;
  struct MonoType * D.27898;
  int ninsts.45;
  struct MonoClass * D.27900;
  struct MonoType * D.27901;
  int ninsts.46;
  struct MonoClass * D.27903;
  struct MonoType * D.27904;
  int ninsts.47;
  struct MonoClass * D.27906;
  struct MonoType * D.27907;
  int ninsts.48;
  struct MonoClass * D.27909;
  struct MonoType * D.27910;
  int ninsts.49;
  struct MonoClass * D.27912;
  struct MonoType * D.27913;
  int ninsts.50;
  struct MonoClass * D.27915;
  struct MonoType * D.27916;
  int ninsts.51;
  struct MonoClass * D.27918;
  struct MonoType * D.27919;
  int ninsts.52;
  struct MonoClass * D.27921;
  struct MonoType * D.27922;
  int ninsts.53;
  struct MonoClass * D.27924;
  struct MonoType * D.27925;
  struct MonoClass * D.27936;
  struct MonoGenericInst * D.27939;
  struct MonoMethod * D.27940;
  struct MonoMethod * D.27941;
  int D.25146;
  int iftmp.54;
  int D.25145;
  const char[16] * D.27947;
  unsigned char D.27948;
  int D.27949;
  unsigned char D.27950;
  int D.27951;
  _Bool D.27952;
  _Bool D.27953;
  _Bool D.27954;
  const unsigned char * D.27957;
  unsigned char D.27958;
  int D.27959;
  const unsigned char * D.27960;
  unsigned char D.27961;
  int D.27962;
  _Bool D.27963;
  _Bool D.27964;
  const unsigned char * D.27967;
  unsigned char D.27968;
  int D.27969;
  const unsigned char * D.27970;
  unsigned char D.27971;
  int D.27972;
  _Bool D.27973;
  _Bool D.27974;
  const unsigned char * D.27977;
  unsigned char D.27978;
  int D.27979;
  const unsigned char * D.27980;
  unsigned char D.27981;
  int D.27982;
  const char * D.27984;
  int D.25155;
  int iftmp.55;
  int D.25154;
  const char[9] * D.27989;
  unsigned char D.27990;
  int D.27991;
  unsigned char D.27992;
  int D.27993;
  _Bool D.27994;
  _Bool D.27995;
  _Bool D.27996;
  const unsigned char * D.27999;
  unsigned char D.28000;
  int D.28001;
  const unsigned char * D.28002;
  unsigned char D.28003;
  int D.28004;
  _Bool D.28005;
  _Bool D.28006;
  const unsigned char * D.28009;
  unsigned char D.28010;
  int D.28011;
  const unsigned char * D.28012;
  unsigned char D.28013;
  int D.28014;
  _Bool D.28015;
  _Bool D.28016;
  const unsigned char * D.28019;
  unsigned char D.28020;
  int D.28021;
  const unsigned char * D.28022;
  unsigned char D.28023;
  int D.28024;
  unsigned char D.28026;
  unsigned char D.28027;
  struct MonoGenericInst * D.28030;
  struct MonoMethod * D.28031;
  struct MonoMethod * D.28032;
  int D.25172;
  int iftmp.56;
  int D.25171;
  const char[5] * D.28040;
  unsigned char D.28041;
  int D.28042;
  unsigned char D.28043;
  int D.28044;
  _Bool D.28045;
  _Bool D.28046;
  _Bool D.28047;
  const unsigned char * D.28050;
  unsigned char D.28051;
  int D.28052;
  const unsigned char * D.28053;
  unsigned char D.28054;
  int D.28055;
  _Bool D.28056;
  _Bool D.28057;
  const unsigned char * D.28060;
  unsigned char D.28061;
  int D.28062;
  const unsigned char * D.28063;
  unsigned char D.28064;
  int D.28065;
  _Bool D.28066;
  _Bool D.28067;
  const unsigned char * D.28070;
  unsigned char D.28071;
  int D.28072;
  const unsigned char * D.28073;
  unsigned char D.28074;
  int D.28075;
  const char * D.28077;
  int D.25181;
  int iftmp.57;
  int D.25180;
  const char[6] * D.28082;
  unsigned char D.28083;
  int D.28084;
  unsigned char D.28085;
  int D.28086;
  _Bool D.28087;
  _Bool D.28088;
  _Bool D.28089;
  const unsigned char * D.28092;
  unsigned char D.28093;
  int D.28094;
  const unsigned char * D.28095;
  unsigned char D.28096;
  int D.28097;
  _Bool D.28098;
  _Bool D.28099;
  const unsigned char * D.28102;
  unsigned char D.28103;
  int D.28104;
  const unsigned char * D.28105;
  unsigned char D.28106;
  int D.28107;
  _Bool D.28108;
  _Bool D.28109;
  const unsigned char * D.28112;
  unsigned char D.28113;
  int D.28114;
  const unsigned char * D.28115;
  unsigned char D.28116;
  int D.28117;
  unsigned char D.28119;
  unsigned char 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.27780 = acfg->aot_opts.no_instances;
  if (D.27780 != 0) goto <D.27781>; else goto <D.27782>;
  <D.27781>:
  return;
  <D.27782>:
  i = 0;
  goto <D.25116>;
  <D.25115>:
  D.27783 = i + 1;
  D.27784 = D.27783 | 721420288;
  token = (guint32) D.27784;
  D.27785 = acfg->image;
  method = mono_get_method (D.27785, token, 0B);
  if (method == 0B) goto <D.27786>; else goto <D.27787>;
  <D.27786>:
  // predicted unlikely by continue predictor.
  goto <D.25094>;
  <D.27787>:
  D.27788 = method->klass;
  D.27789 = D.27788->image;
  D.27785 = acfg->image;
  if (D.27789 != D.27785) goto <D.27790>; else goto <D.27791>;
  <D.27790>:
  // predicted unlikely by continue predictor.
  goto <D.25094>;
  <D.27791>:
  context = mono_method_get_context (method);
  if (context != 0B) goto <D.27792>; else goto <D.27793>;
  <D.27792>:
  D.27794 = context->class_inst;
  if (D.27794 != 0B) goto <D.27795>; else goto <D.27796>;
  <D.27795>:
  D.27794 = context->class_inst;
  D.27797 = BIT_FIELD_REF <*D.27794, 8, 48>;
  D.27798 = D.27797 & 64;
  if (D.27798 != 0) goto <D.27799>; else goto <D.27800>;
  <D.27799>:
  // predicted unlikely by continue predictor.
  goto <D.25094>;
  <D.27800>:
  <D.27796>:
  <D.27793>:
  if (context != 0B) goto <D.27801>; else goto <D.27802>;
  <D.27801>:
  D.27803 = context->method_inst;
  if (D.27803 != 0B) goto <D.27804>; else goto <D.27805>;
  <D.27804>:
  D.27803 = context->method_inst;
  D.27806 = BIT_FIELD_REF <*D.27803, 8, 48>;
  D.27807 = D.27806 & 64;
  if (D.27807 != 0) goto <D.27808>; else goto <D.27809>;
  <D.27808>:
  {
    struct MonoGenericContext shared_context;
    struct MonoGenericInst * inst;
    struct MonoType * * type_argv;
    int i;
    struct MonoMethod * declaring_method;
    gboolean supported;

    try
      {
        supported = 1;
        D.27794 = context->class_inst;
        if (D.27794 != 0B) goto <D.27810>; else goto <D.27811>;
        <D.27810>:
        inst = context->class_inst;
        i = 0;
        goto <D.25103>;
        <D.25102>:
        D.27814 = inst->type_argv[i];
        D.27815 = mono_type_is_reference (D.27814);
        if (D.27815 != 0) goto <D.27812>; else goto <D.27816>;
        <D.27816>:
        D.27814 = inst->type_argv[i];
        D.27817 = D.27814->type;
        if (D.27817 == 19) goto <D.27812>; else goto <D.27818>;
        <D.27818>:
        D.27814 = inst->type_argv[i];
        D.27817 = D.27814->type;
        if (D.27817 == 30) goto <D.27812>; else goto <D.27813>;
        <D.27812>:
        // predicted unlikely by continue predictor.
        goto <D.25101>;
        <D.27813>:
        D.27814 = inst->type_argv[i];
        D.27819 = mono_class_is_open_constructed_type (D.27814);
        if (D.27819 != 0) goto <D.27820>; else goto <D.27821>;
        <D.27820>:
        supported = 0;
        <D.27821>:
        <D.25101>:
        i = i + 1;
        <D.25103>:
        D.27822 = inst->type_argc;
        D.27823 = (int) D.27822;
        if (D.27823 > i) goto <D.25102>; else goto <D.25104>;
        <D.25104>:
        <D.27811>:
        D.27803 = context->method_inst;
        if (D.27803 != 0B) goto <D.27824>; else goto <D.27825>;
        <D.27824>:
        inst = context->method_inst;
        i = 0;
        goto <D.25107>;
        <D.25106>:
        D.27814 = inst->type_argv[i];
        D.27828 = mono_type_is_reference (D.27814);
        if (D.27828 != 0) goto <D.27826>; else goto <D.27829>;
        <D.27829>:
        D.27814 = inst->type_argv[i];
        D.27817 = D.27814->type;
        if (D.27817 == 19) goto <D.27826>; else goto <D.27830>;
        <D.27830>:
        D.27814 = inst->type_argv[i];
        D.27817 = D.27814->type;
        if (D.27817 == 30) goto <D.27826>; else goto <D.27827>;
        <D.27826>:
        // predicted unlikely by continue predictor.
        goto <D.25105>;
        <D.27827>:
        D.27814 = inst->type_argv[i];
        D.27831 = mono_class_is_open_constructed_type (D.27814);
        if (D.27831 != 0) goto <D.27832>; else goto <D.27833>;
        <D.27832>:
        supported = 0;
        <D.27833>:
        <D.25105>:
        i = i + 1;
        <D.25107>:
        D.27822 = inst->type_argc;
        D.27823 = (int) D.27822;
        if (D.27823 > i) goto <D.25106>; else goto <D.25108>;
        <D.25108>:
        <D.27825>:
        if (supported == 0) goto <D.27834>; else goto <D.27835>;
        <D.27834>:
        // predicted unlikely by continue predictor.
        goto <D.25094>;
        <D.27835>:
        memset (&shared_context, 0, 16);
        inst = context->class_inst;
        if (inst != 0B) goto <D.27836>; else goto <D.27837>;
        <D.27836>:
        D.27822 = inst->type_argc;
        D.27838 = (long unsigned int) D.27822;
        D.27839 = D.27838 * 8;
        type_argv = monoeg_malloc0 (D.27839);
        i = 0;
        goto <D.25110>;
        <D.25109>:
        D.27814 = inst->type_argv[i];
        D.27843 = mono_type_is_reference (D.27814);
        if (D.27843 != 0) goto <D.27840>; else goto <D.27844>;
        <D.27844>:
        D.27814 = inst->type_argv[i];
        D.27817 = D.27814->type;
        if (D.27817 == 19) goto <D.27840>; else goto <D.27845>;
        <D.27845>:
        D.27814 = inst->type_argv[i];
        D.27817 = D.27814->type;
        if (D.27817 == 30) goto <D.27840>; else goto <D.27841>;
        <D.27840>:
        D.27846 = (long unsigned int) i;
        D.27847 = D.27846 * 8;
        D.27848 = type_argv + D.27847;
        D.27849 = mono_defaults.object_class;
        D.27850 = &D.27849->byval_arg;
        *D.27848 = D.27850;
        goto <D.27842>;
        <D.27841>:
        D.27846 = (long unsigned int) i;
        D.27847 = D.27846 * 8;
        D.27848 = type_argv + D.27847;
        D.27814 = inst->type_argv[i];
        *D.27848 = D.27814;
        <D.27842>:
        i = i + 1;
        <D.25110>:
        D.27822 = inst->type_argc;
        D.27823 = (int) D.27822;
        if (D.27823 > i) goto <D.25109>; else goto <D.25111>;
        <D.25111>:
        D.27822 = inst->type_argc;
        D.27823 = (int) D.27822;
        D.27851 = mono_metadata_get_generic_inst (D.27823, type_argv);
        shared_context.class_inst = D.27851;
        monoeg_g_free (type_argv);
        <D.27837>:
        inst = context->method_inst;
        if (inst != 0B) goto <D.27852>; else goto <D.27853>;
        <D.27852>:
        D.27822 = inst->type_argc;
        D.27838 = (long unsigned int) D.27822;
        D.27839 = D.27838 * 8;
        type_argv = monoeg_malloc0 (D.27839);
        i = 0;
        goto <D.25113>;
        <D.25112>:
        D.27814 = inst->type_argv[i];
        D.27857 = mono_type_is_reference (D.27814);
        if (D.27857 != 0) goto <D.27854>; else goto <D.27858>;
        <D.27858>:
        D.27814 = inst->type_argv[i];
        D.27817 = D.27814->type;
        if (D.27817 == 19) goto <D.27854>; else goto <D.27859>;
        <D.27859>:
        D.27814 = inst->type_argv[i];
        D.27817 = D.27814->type;
        if (D.27817 == 30) goto <D.27854>; else goto <D.27855>;
        <D.27854>:
        D.27846 = (long unsigned int) i;
        D.27847 = D.27846 * 8;
        D.27848 = type_argv + D.27847;
        D.27849 = mono_defaults.object_class;
        D.27850 = &D.27849->byval_arg;
        *D.27848 = D.27850;
        goto <D.27856>;
        <D.27855>:
        D.27846 = (long unsigned int) i;
        D.27847 = D.27846 * 8;
        D.27848 = type_argv + D.27847;
        D.27814 = inst->type_argv[i];
        *D.27848 = D.27814;
        <D.27856>:
        i = i + 1;
        <D.25113>:
        D.27822 = inst->type_argc;
        D.27823 = (int) D.27822;
        if (D.27823 > i) goto <D.25112>; else goto <D.25114>;
        <D.25114>:
        D.27822 = inst->type_argc;
        D.27823 = (int) D.27822;
        D.27860 = mono_metadata_get_generic_inst (D.27823, type_argv);
        shared_context.method_inst = D.27860;
        monoeg_g_free (type_argv);
        <D.27853>:
        D.27864 = BIT_FIELD_REF <*method, 8, 264>;
        D.27865 = D.27864 & 8;
        if (D.27865 != 0) goto <D.27861>; else goto <D.27866>;
        <D.27866>:
        D.27788 = method->klass;
        D.27867 = D.27788->generic_container;
        if (D.27867 != 0B) goto <D.27861>; else goto <D.27862>;
        <D.27861>:
        declaring_method = method;
        goto <D.27863>;
        <D.27862>:
        declaring_method = mono_method_get_declaring_generic_method (method);
        <D.27863>:
        method = mono_class_inflate_generic_method (declaring_method, &shared_context);
      }
    finally
      {
        shared_context = {CLOBBER};
      }
  }
  <D.27809>:
  <D.27805>:
  <D.27802>:
  D.27868 = mono_method_is_generic_sharable_full (method, 0, 0, 0);
  if (D.27868 != 0) goto <D.27869>; else goto <D.27870>;
  <D.27869>:
  // predicted unlikely by continue predictor.
  goto <D.25094>;
  <D.27870>:
  add_extra_method (acfg, method);
  <D.25094>:
  i = i + 1;
  <D.25116>:
  D.27785 = acfg->image;
  D.27871 = D.27785->tables[43].rows;
  D.27872 = (int) D.27871;
  if (D.27872 > i) goto <D.25115>; else goto <D.25117>;
  <D.25117>:
  i = 0;
  goto <D.25121>;
  <D.25120>:
  {
    struct MonoClass * klass;

    D.27783 = i + 1;
    D.27873 = D.27783 | 452984832;
    token = (guint32) D.27873;
    D.27785 = acfg->image;
    klass = mono_class_get (D.27785, token);
    if (klass == 0B) goto <D.27874>; else goto <D.27876>;
    <D.27876>:
    D.27877 = klass->rank;
    if (D.27877 != 0) goto <D.27874>; else goto <D.27875>;
    <D.27874>:
    mono_loader_clear_error ();
    // predicted unlikely by continue predictor.
    goto <D.25119>;
    <D.27875>:
    add_generic_class (acfg, klass, 0, "typespec");
  }
  <D.25119>:
  i = i + 1;
  <D.25121>:
  D.27785 = acfg->image;
  D.27878 = D.27785->tables[27].rows;
  D.27879 = (int) D.27878;
  if (D.27879 > i) goto <D.25120>; else goto <D.25122>;
  <D.25122>:
  i = 0;
  goto <D.25124>;
  <D.25123>:
  D.27880 = acfg->methods;
  D.27881 = D.27880->pdata;
  D.27882 = (long unsigned int) i;
  D.27883 = D.27882 * 8;
  D.27884 = D.27881 + D.27883;
  method = *D.27884;
  add_types_from_method_header (acfg, method);
  i = i + 1;
  <D.25124>:
  i.41 = (unsigned int) i;
  D.27880 = acfg->methods;
  D.27886 = D.27880->len;
  if (i.41 < D.27886) goto <D.25123>; else goto <D.25125>;
  <D.25125>:
  D.27785 = acfg->image;
  D.27887 = mono_defaults.corlib;
  if (D.27785 == D.27887) goto <D.27888>; else goto <D.27889>;
  <D.27888>:
  {
    struct MonoClass * klass;
    struct MonoType * insts[256];
    int ninsts;

    try
      {
        ninsts = 0;
        ninsts.42 = ninsts;
        ninsts = ninsts.42 + 1;
        D.27891 = mono_defaults.byte_class;
        D.27892 = &D.27891->byval_arg;
        insts[ninsts.42] = D.27892;
        ninsts.43 = ninsts;
        ninsts = ninsts.43 + 1;
        D.27894 = mono_defaults.sbyte_class;
        D.27895 = &D.27894->byval_arg;
        insts[ninsts.43] = D.27895;
        ninsts.44 = ninsts;
        ninsts = ninsts.44 + 1;
        D.27897 = mono_defaults.int16_class;
        D.27898 = &D.27897->byval_arg;
        insts[ninsts.44] = D.27898;
        ninsts.45 = ninsts;
        ninsts = ninsts.45 + 1;
        D.27900 = mono_defaults.uint16_class;
        D.27901 = &D.27900->byval_arg;
        insts[ninsts.45] = D.27901;
        ninsts.46 = ninsts;
        ninsts = ninsts.46 + 1;
        D.27903 = mono_defaults.int32_class;
        D.27904 = &D.27903->byval_arg;
        insts[ninsts.46] = D.27904;
        ninsts.47 = ninsts;
        ninsts = ninsts.47 + 1;
        D.27906 = mono_defaults.uint32_class;
        D.27907 = &D.27906->byval_arg;
        insts[ninsts.47] = D.27907;
        ninsts.48 = ninsts;
        ninsts = ninsts.48 + 1;
        D.27909 = mono_defaults.int64_class;
        D.27910 = &D.27909->byval_arg;
        insts[ninsts.48] = D.27910;
        ninsts.49 = ninsts;
        ninsts = ninsts.49 + 1;
        D.27912 = mono_defaults.uint64_class;
        D.27913 = &D.27912->byval_arg;
        insts[ninsts.49] = D.27913;
        ninsts.50 = ninsts;
        ninsts = ninsts.50 + 1;
        D.27915 = mono_defaults.single_class;
        D.27916 = &D.27915->byval_arg;
        insts[ninsts.50] = D.27916;
        ninsts.51 = ninsts;
        ninsts = ninsts.51 + 1;
        D.27918 = mono_defaults.double_class;
        D.27919 = &D.27918->byval_arg;
        insts[ninsts.51] = D.27919;
        ninsts.52 = ninsts;
        ninsts = ninsts.52 + 1;
        D.27921 = mono_defaults.char_class;
        D.27922 = &D.27921->byval_arg;
        insts[ninsts.52] = D.27922;
        ninsts.53 = ninsts;
        ninsts = ninsts.53 + 1;
        D.27924 = mono_defaults.boolean_class;
        D.27925 = &D.27924->byval_arg;
        insts[ninsts.53] = D.27925;
        D.27785 = acfg->image;
        klass = mono_class_from_name (D.27785, "System.Collections.Generic", "GenericComparer`1");
        if (klass != 0B) goto <D.27926>; else goto <D.27927>;
        <D.27926>:
        add_instances_of (acfg, klass, &insts, ninsts, 1);
        <D.27927>:
        D.27785 = acfg->image;
        klass = mono_class_from_name (D.27785, "System.Collections.Generic", "GenericEqualityComparer`1");
        if (klass != 0B) goto <D.27928>; else goto <D.27929>;
        <D.27928>:
        add_instances_of (acfg, klass, &insts, ninsts, 1);
        <D.27929>:
        D.27785 = acfg->image;
        klass = mono_class_from_name (D.27785, "System.Collections.Generic", "ICollection`1");
        if (klass != 0B) goto <D.27930>; else goto <D.27931>;
        <D.27930>:
        add_instances_of (acfg, klass, &insts, ninsts, 1);
        <D.27931>:
        D.27785 = acfg->image;
        klass = mono_class_from_name (D.27785, "System.Collections.Generic", "IList`1");
        if (klass != 0B) goto <D.27932>; else goto <D.27933>;
        <D.27932>:
        add_instances_of (acfg, klass, &insts, ninsts, 1);
        <D.27933>:
        D.27785 = acfg->image;
        klass = mono_class_from_name (D.27785, "System.Collections.Generic", "IEnumerable`1");
        if (klass != 0B) goto <D.27934>; else goto <D.27935>;
        <D.27934>:
        add_instances_of (acfg, klass, &insts, ninsts, 1);
        <D.27935>:
        {
          struct MonoGenericContext ctx;
          struct MonoType * args[16];
          struct MonoMethod * get_method;
          struct MonoClass * array_klass;

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

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

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

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

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

                  __s2 = m->name;
                  D.27989 = "Exchange";
                  D.27990 = MEM[(const unsigned char *)D.27989];
                  D.27991 = (int) D.27990;
                  D.27992 = *__s2;
                  D.27993 = (int) D.27992;
                  __result = D.27991 - D.27993;
                  {
                    D.27994 = __s2_len != 0;
                    D.27995 = __result == 0;
                    D.27996 = D.27994 & D.27995;
                    if (D.27996 != 0) goto <D.27997>; else goto <D.27998>;
                    <D.27997>:
                    D.27999 = &MEM[(void *)"Exchange" + 1B];
                    D.28000 = *D.27999;
                    D.28001 = (int) D.28000;
                    D.28002 = __s2 + 1;
                    D.28003 = *D.28002;
                    D.28004 = (int) D.28003;
                    __result = D.28001 - D.28004;
                    D.28005 = __s2_len > 1;
                    D.27995 = __result == 0;
                    D.28006 = D.28005 & D.27995;
                    if (D.28006 != 0) goto <D.28007>; else goto <D.28008>;
                    <D.28007>:
                    D.28009 = &MEM[(void *)"Exchange" + 2B];
                    D.28010 = *D.28009;
                    D.28011 = (int) D.28010;
                    D.28012 = __s2 + 2;
                    D.28013 = *D.28012;
                    D.28014 = (int) D.28013;
                    __result = D.28011 - D.28014;
                    D.28015 = __s2_len > 2;
                    D.27995 = __result == 0;
                    D.28016 = D.28015 & D.27995;
                    if (D.28016 != 0) goto <D.28017>; else goto <D.28018>;
                    <D.28017>:
                    D.28019 = &MEM[(void *)"Exchange" + 3B];
                    D.28020 = *D.28019;
                    D.28021 = (int) D.28020;
                    D.28022 = __s2 + 3;
                    D.28023 = *D.28022;
                    D.28024 = (int) D.28023;
                    __result = D.28021 - D.28024;
                    <D.28018>:
                    <D.28008>:
                    <D.27998>:
                  }
                  D.25154 = __result;
                }
                iftmp.55 = -D.25154;
                goto <D.28025>;
                <D.27988>:
                D.27984 = m->name;
                iftmp.55 = __builtin_strcmp (D.27984, "Exchange");
                <D.28025>:
                D.25155 = iftmp.55;
              }
              if (D.25155 == 0) goto <D.27942>; else goto <D.27943>;
              <D.27942>:
              D.28026 = BIT_FIELD_REF <*m, 8, 264>;
              D.28027 = D.28026 & 8;
              if (D.28027 != 0) goto <D.28028>; else goto <D.28029>;
              <D.28028>:
              memset (&ctx, 0, 16);
              D.27849 = mono_defaults.object_class;
              D.27850 = &D.27849->byval_arg;
              args[0] = D.27850;
              D.28030 = mono_metadata_get_generic_inst (1, &args);
              ctx.method_inst = D.28030;
              D.28031 = mono_class_inflate_generic_method (m, &ctx);
              D.28032 = mono_marshal_get_native_wrapper (D.28031, 1, 1);
              add_extra_method (acfg, D.28032);
              <D.28029>:
              <D.27943>:
              <D.25157>:
              m = mono_class_get_methods (interlocked_klass, &iter);
              if (m != 0B) goto <D.25156>; else goto <D.25158>;
              <D.25158>:
            }
          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.27887 = mono_defaults.corlib;
              volatile_klass = mono_class_from_name (D.27887, "System.Threading", "Volatile");
              iter = 0B;
              if (volatile_klass != 0B) goto <D.28033>; else goto <D.28034>;
              <D.28033>:
              goto <D.25183>;
              <D.25182>:
              {
                size_t __s1_len;
                size_t __s2_len;

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

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

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

                  __s2 = m->name;
                  D.28082 = "Write";
                  D.28083 = MEM[(const unsigned char *)D.28082];
                  D.28084 = (int) D.28083;
                  D.28085 = *__s2;
                  D.28086 = (int) D.28085;
                  __result = D.28084 - D.28086;
                  {
                    D.28087 = __s2_len != 0;
                    D.28088 = __result == 0;
                    D.28089 = D.28087 & D.28088;
                    if (D.28089 != 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;
                    D.28098 = __s2_len > 1;
                    D.28088 = __result == 0;
                    D.28099 = D.28098 & D.28088;
                    if (D.28099 != 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;
                    D.28108 = __s2_len > 2;
                    D.28088 = __result == 0;
                    D.28109 = D.28108 & D.28088;
                    if (D.28109 != 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.28101>:
                    <D.28091>:
                  }
                  D.25180 = __result;
                }
                iftmp.57 = -D.25180;
                goto <D.28118>;
                <D.28081>:
                D.28077 = m->name;
                iftmp.57 = __builtin_strcmp (D.28077, "Write");
                <D.28118>:
                D.25181 = iftmp.57;
              }
              if (D.25181 == 0) goto <D.28035>; else goto <D.28036>;
              <D.28035>:
              D.28119 = BIT_FIELD_REF <*m, 8, 264>;
              D.28120 = D.28119 & 8;
              if (D.28120 != 0) goto <D.28121>; else goto <D.28122>;
              <D.28121>:
              memset (&ctx, 0, 16);
              D.27849 = mono_defaults.object_class;
              D.27850 = &D.27849->byval_arg;
              args[0] = D.27850;
              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.28036>:
              <D.25183>:
              m = mono_class_get_methods (volatile_klass, &iter);
              if (m != 0B) goto <D.25182>; else goto <D.25184>;
              <D.25184>:
              <D.28034>:
            }
          finally
            {
              ctx = {CLOBBER};
              args = {CLOBBER};
              iter = {CLOBBER};
            }
        }
      }
    finally
      {
        insts = {CLOBBER};
      }
  }
  <D.27889>:
}


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;
  unsigned char D.28142;
  unsigned char 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.24896;
  int iftmp.58;
  int D.24895;
  const char[13] * D.28191;
  unsigned char D.28192;
  int D.28193;
  unsigned char D.28194;
  int D.28195;
  _Bool D.28196;
  _Bool D.28197;
  _Bool D.28198;
  const unsigned char * D.28201;
  unsigned char D.28202;
  int D.28203;
  const unsigned char * D.28204;
  unsigned char D.28205;
  int D.28206;
  _Bool D.28207;
  _Bool D.28208;
  const unsigned char * D.28211;
  unsigned char D.28212;
  int D.28213;
  const unsigned char * D.28214;
  unsigned char D.28215;
  int D.28216;
  _Bool D.28217;
  _Bool D.28218;
  const unsigned char * D.28221;
  unsigned char D.28222;
  int D.28223;
  const unsigned char * D.28224;
  unsigned char D.28225;
  int D.28226;
  const char * D.28228;
  int D.24905;
  int iftmp.59;
  int D.24904;
  const char[7] * D.28233;
  unsigned char D.28234;
  int D.28235;
  unsigned char D.28236;
  int D.28237;
  _Bool D.28238;
  _Bool D.28239;
  _Bool D.28240;
  const unsigned char * D.28243;
  unsigned char D.28244;
  int D.28245;
  const unsigned char * D.28246;
  unsigned char D.28247;
  int D.28248;
  _Bool D.28249;
  _Bool D.28250;
  const unsigned char * D.28253;
  unsigned char D.28254;
  int D.28255;
  const unsigned char * D.28256;
  unsigned char D.28257;
  int D.28258;
  _Bool D.28259;
  _Bool D.28260;
  const unsigned char * D.28263;
  unsigned char D.28264;
  int D.28265;
  const unsigned char * D.28266;
  unsigned char D.28267;
  int D.28268;
  unsigned char D.28272;
  unsigned char D.28273;
  struct MonoGenericContext * D.28276;
  struct MonoGenericInst * D.28277;
  int D.28280;
  unsigned char D.28283;
  int D.28286;
  struct MonoType * D.28287;
  unsigned char D.28288;
  struct MonoClass * D.28291;
  unsigned char D.28292;
  unsigned char D.28293;
  char * D.28298;
  struct MonoClass * D.28299;
  int D.24920;
  int iftmp.60;
  int D.24919;
  const char[27] * D.28309;
  unsigned char D.28310;
  int D.28311;
  unsigned char D.28312;
  int D.28313;
  _Bool D.28314;
  _Bool D.28315;
  _Bool D.28316;
  const unsigned char * D.28319;
  unsigned char D.28320;
  int D.28321;
  const unsigned char * D.28322;
  unsigned char D.28323;
  int D.28324;
  _Bool D.28325;
  _Bool D.28326;
  const unsigned char * D.28329;
  unsigned char D.28330;
  int D.28331;
  const unsigned char * D.28332;
  unsigned char D.28333;
  int D.28334;
  _Bool D.28335;
  _Bool D.28336;
  const unsigned char * D.28339;
  unsigned char D.28340;
  int D.28341;
  const unsigned char * D.28342;
  unsigned char D.28343;
  int D.28344;
  const char * D.28346;
  int D.24929;
  int iftmp.61;
  int D.24928;
  const char[14] * D.28352;
  unsigned char D.28353;
  int D.28354;
  unsigned char D.28355;
  int D.28356;
  _Bool D.28357;
  _Bool D.28358;
  _Bool D.28359;
  const unsigned char * D.28362;
  unsigned char D.28363;
  int D.28364;
  const unsigned char * D.28365;
  unsigned char D.28366;
  int D.28367;
  _Bool D.28368;
  _Bool D.28369;
  const unsigned char * D.28372;
  unsigned char D.28373;
  int D.28374;
  const unsigned char * D.28375;
  unsigned char D.28376;
  int D.28377;
  _Bool D.28378;
  _Bool D.28379;
  const unsigned char * D.28382;
  unsigned char D.28383;
  int D.28384;
  const unsigned char * D.28385;
  unsigned char D.28386;
  int D.28387;
  int D.24938;
  int iftmp.62;
  int D.24937;
  const char[14] * D.28393;
  unsigned char D.28394;
  int D.28395;
  unsigned char D.28396;
  int D.28397;
  _Bool D.28398;
  _Bool D.28399;
  _Bool D.28400;
  const unsigned char * D.28403;
  unsigned char D.28404;
  int D.28405;
  const unsigned char * D.28406;
  unsigned char D.28407;
  int D.28408;
  _Bool D.28409;
  _Bool D.28410;
  const unsigned char * D.28413;
  unsigned char D.28414;
  int D.28415;
  const unsigned char * D.28416;
  unsigned char D.28417;
  int D.28418;
  _Bool D.28419;
  _Bool D.28420;
  const unsigned char * D.28423;
  unsigned char D.28424;
  int D.28425;
  const unsigned char * D.28426;
  unsigned char D.28427;
  int D.28428;
  int D.24947;
  int iftmp.63;
  int D.24946;
  const char[8] * D.28434;
  unsigned char D.28435;
  int D.28436;
  unsigned char D.28437;
  int D.28438;
  _Bool D.28439;
  _Bool D.28440;
  _Bool D.28441;
  const unsigned char * D.28444;
  unsigned char D.28445;
  int D.28446;
  const unsigned char * D.28447;
  unsigned char D.28448;
  int D.28449;
  _Bool D.28450;
  _Bool D.28451;
  const unsigned char * D.28454;
  unsigned char D.28455;
  int D.28456;
  const unsigned char * D.28457;
  unsigned char D.28458;
  int D.28459;
  _Bool D.28460;
  _Bool D.28461;
  const unsigned char * D.28464;
  unsigned char D.28465;
  int D.28466;
  const unsigned char * D.28467;
  unsigned char D.28468;
  int D.28469;
  int D.24956;
  int iftmp.64;
  int D.24955;
  const char[14] * D.28475;
  unsigned char D.28476;
  int D.28477;
  unsigned char D.28478;
  int D.28479;
  _Bool D.28480;
  _Bool D.28481;
  _Bool D.28482;
  const unsigned char * D.28485;
  unsigned char D.28486;
  int D.28487;
  const unsigned char * D.28488;
  unsigned char D.28489;
  int D.28490;
  _Bool D.28491;
  _Bool D.28492;
  const unsigned char * D.28495;
  unsigned char D.28496;
  int D.28497;
  const unsigned char * D.28498;
  unsigned char D.28499;
  int D.28500;
  _Bool D.28501;
  _Bool D.28502;
  const unsigned char * D.28505;
  unsigned char D.28506;
  int D.28507;
  const unsigned char * D.28508;
  unsigned char D.28509;
  int D.28510;
  int D.24965;
  int iftmp.65;
  int D.24964;
  const char[16] * D.28516;
  unsigned char D.28517;
  int D.28518;
  unsigned char D.28519;
  int D.28520;
  _Bool D.28521;
  _Bool D.28522;
  _Bool D.28523;
  const unsigned char * D.28526;
  unsigned char D.28527;
  int D.28528;
  const unsigned char * D.28529;
  unsigned char D.28530;
  int D.28531;
  _Bool D.28532;
  _Bool D.28533;
  const unsigned char * D.28536;
  unsigned char D.28537;
  int D.28538;
  const unsigned char * D.28539;
  unsigned char D.28540;
  int D.28541;
  _Bool D.28542;
  _Bool D.28543;
  const unsigned char * D.28546;
  unsigned char D.28547;
  int D.28548;
  const unsigned char * D.28549;
  unsigned char D.28550;
  int D.28551;
  struct MonoType * D.28553;
  int D.24978;
  int iftmp.66;
  int D.24977;
  unsigned char D.28557;
  int D.28558;
  _Bool D.28559;
  _Bool D.28560;
  _Bool D.28561;
  const unsigned char * D.28564;
  unsigned char D.28565;
  int D.28566;
  _Bool D.28567;
  _Bool D.28568;
  const unsigned char * D.28571;
  unsigned char D.28572;
  int D.28573;
  _Bool D.28574;
  _Bool D.28575;
  const unsigned char * D.28578;
  unsigned char D.28579;
  int D.28580;
  int D.24987;
  int iftmp.67;
  int D.24986;
  unsigned char D.28590;
  int D.28591;
  _Bool D.28592;
  _Bool D.28593;
  _Bool D.28594;
  const unsigned char * D.28597;
  unsigned char D.28598;
  int D.28599;
  _Bool D.28600;
  _Bool D.28601;
  const unsigned char * D.28604;
  unsigned char D.28605;
  int D.28606;
  _Bool D.28607;
  _Bool D.28608;
  const unsigned char * D.28611;
  unsigned char D.28612;
  int D.28613;
  int D.24996;
  int iftmp.68;
  int D.24995;
  unsigned char D.28619;
  int D.28620;
  _Bool D.28621;
  _Bool D.28622;
  _Bool D.28623;
  const unsigned char * D.28626;
  unsigned char D.28627;
  int D.28628;
  _Bool D.28629;
  _Bool D.28630;
  const unsigned char * D.28633;
  unsigned char D.28634;
  int D.28635;
  _Bool D.28636;
  _Bool D.28637;
  const unsigned char * D.28640;
  unsigned char D.28641;
  int D.28642;
  int D.25006;
  int iftmp.69;
  int D.25005;
  const char[21] * D.28647;
  unsigned char D.28648;
  int D.28649;
  unsigned char D.28650;
  int D.28651;
  _Bool D.28652;
  _Bool D.28653;
  _Bool D.28654;
  const unsigned char * D.28657;
  unsigned char D.28658;
  int D.28659;
  const unsigned char * D.28660;
  unsigned char D.28661;
  int D.28662;
  _Bool D.28663;
  _Bool D.28664;
  const unsigned char * D.28667;
  unsigned char D.28668;
  int D.28669;
  const unsigned char * D.28670;
  unsigned char D.28671;
  int D.28672;
  _Bool D.28673;
  _Bool D.28674;
  const unsigned char * D.28677;
  unsigned char D.28678;
  int D.28679;
  const unsigned char * D.28680;
  unsigned char D.28681;
  int D.28682;
  const char * D.28684;
  struct MonoClass * D.28686;
  _Bool D.28687;
  long int D.28688;
  long int D.28689;
  struct MonoGenericContext * D.28692;
  const char * D.28693;
  char * D.28694;
  int D.25022;
  int iftmp.70;
  int D.25021;
  unsigned char D.28702;
  int D.28703;
  _Bool D.28704;
  _Bool D.28705;
  _Bool D.28706;
  const unsigned char * D.28709;
  unsigned char D.28710;
  int D.28711;
  _Bool D.28712;
  _Bool D.28713;
  const unsigned char * D.28716;
  unsigned char D.28717;
  int D.28718;
  _Bool D.28719;
  _Bool D.28720;
  const unsigned char * D.28723;
  unsigned char D.28724;
  int D.28725;
  int D.25031;
  int iftmp.71;
  int D.25030;
  const char[11] * D.28732;
  unsigned char D.28733;
  int D.28734;
  unsigned char D.28735;
  int D.28736;
  _Bool D.28737;
  _Bool D.28738;
  _Bool D.28739;
  const unsigned char * D.28742;
  unsigned char D.28743;
  int D.28744;
  const unsigned char * D.28745;
  unsigned char D.28746;
  int D.28747;
  _Bool D.28748;
  _Bool D.28749;
  const unsigned char * D.28752;
  unsigned char D.28753;
  int D.28754;
  const unsigned char * D.28755;
  unsigned char D.28756;
  int D.28757;
  _Bool D.28758;
  _Bool D.28759;
  const unsigned char * D.28762;
  unsigned char D.28763;
  int D.28764;
  const unsigned char * D.28765;
  unsigned char D.28766;
  int D.28767;
  _Bool D.28771;
  long int D.28772;
  long int D.28773;
  struct MonoType * D.28776;
  struct MonoGenericInst * D.28777;
  struct MonoClass * D.28778;
  int D.28779;
  _Bool D.28782;
  long int D.28783;
  long int D.28784;
  struct MonoClass * D.28787;
  int D.25045;
  int iftmp.72;
  int D.25044;
  unsigned char D.28793;
  int D.28794;
  _Bool D.28795;
  _Bool D.28796;
  _Bool D.28797;
  const unsigned char * D.28800;
  unsigned char D.28801;
  int D.28802;
  _Bool D.28803;
  _Bool D.28804;
  const unsigned char * D.28807;
  unsigned char D.28808;
  int D.28809;
  _Bool D.28810;
  _Bool D.28811;
  const unsigned char * D.28814;
  unsigned char D.28815;
  int D.28816;
  int D.25054;
  int iftmp.73;
  int D.25053;
  const char[19] * D.28823;
  unsigned char D.28824;
  int D.28825;
  unsigned char D.28826;
  int D.28827;
  _Bool D.28828;
  _Bool D.28829;
  _Bool D.28830;
  const unsigned char * D.28833;
  unsigned char D.28834;
  int D.28835;
  const unsigned char * D.28836;
  unsigned char D.28837;
  int D.28838;
  _Bool D.28839;
  _Bool D.28840;
  const unsigned char * D.28843;
  unsigned char D.28844;
  int D.28845;
  const unsigned char * D.28846;
  unsigned char D.28847;
  int D.28848;
  _Bool D.28849;
  _Bool D.28850;
  const unsigned char * D.28853;
  unsigned char D.28854;
  int D.28855;
  const unsigned char * D.28856;
  unsigned char D.28857;
  int D.28858;
  _Bool D.28862;
  long int D.28863;
  long int D.28864;
  struct MonoType * D.28867;
  struct MonoGenericInst * D.28868;
  struct MonoClass * D.28869;
  int D.28870;
  _Bool D.28873;
  long int D.28874;
  long int D.28875;
  struct MonoClass * D.28878;
  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, 8, 48>;
      D.28143 = D.28142 & 64;
      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;
          {
            D.28196 = __s2_len != 0;
            D.28197 = __result == 0;
            D.28198 = D.28196 & D.28197;
            if (D.28198 != 0) goto <D.28199>; else goto <D.28200>;
            <D.28199>:
            D.28201 = &MEM[(void *)"Dictionary`2" + 1B];
            D.28202 = *D.28201;
            D.28203 = (int) D.28202;
            D.28204 = __s2 + 1;
            D.28205 = *D.28204;
            D.28206 = (int) D.28205;
            __result = D.28203 - D.28206;
            D.28207 = __s2_len > 1;
            D.28197 = __result == 0;
            D.28208 = D.28207 & D.28197;
            if (D.28208 != 0) goto <D.28209>; else goto <D.28210>;
            <D.28209>:
            D.28211 = &MEM[(void *)"Dictionary`2" + 2B];
            D.28212 = *D.28211;
            D.28213 = (int) D.28212;
            D.28214 = __s2 + 2;
            D.28215 = *D.28214;
            D.28216 = (int) D.28215;
            __result = D.28213 - D.28216;
            D.28217 = __s2_len > 2;
            D.28197 = __result == 0;
            D.28218 = D.28217 & D.28197;
            if (D.28218 != 0) goto <D.28219>; else goto <D.28220>;
            <D.28219>:
            D.28221 = &MEM[(void *)"Dictionary`2" + 3B];
            D.28222 = *D.28221;
            D.28223 = (int) D.28222;
            D.28224 = __s2 + 3;
            D.28225 = *D.28224;
            D.28226 = (int) D.28225;
            __result = D.28223 - D.28226;
            <D.28220>:
            <D.28210>:
            <D.28200>:
          }
          D.24895 = __result;
        }
        iftmp.58 = -D.24895;
        goto <D.28227>;
        <D.28190>:
        D.28228 = klass->name;
        iftmp.58 = __builtin_strcmp (D.28228, "Dictionary`2");
        <D.28227>:
        D.24896 = iftmp.58;
      }
      if (D.24896 == 0) goto <D.28171>; else goto <D.28229>;
      <D.28229>:
      {
        size_t __s1_len;
        size_t __s2_len;

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

          __s2 = klass->name;
          D.28233 = "List`1";
          D.28234 = MEM[(const unsigned char *)D.28233];
          D.28235 = (int) D.28234;
          D.28236 = *__s2;
          D.28237 = (int) D.28236;
          __result = D.28235 - D.28237;
          {
            D.28238 = __s2_len != 0;
            D.28239 = __result == 0;
            D.28240 = D.28238 & D.28239;
            if (D.28240 != 0) goto <D.28241>; else goto <D.28242>;
            <D.28241>:
            D.28243 = &MEM[(void *)"List`1" + 1B];
            D.28244 = *D.28243;
            D.28245 = (int) D.28244;
            D.28246 = __s2 + 1;
            D.28247 = *D.28246;
            D.28248 = (int) D.28247;
            __result = D.28245 - D.28248;
            D.28249 = __s2_len > 1;
            D.28239 = __result == 0;
            D.28250 = D.28249 & D.28239;
            if (D.28250 != 0) goto <D.28251>; else goto <D.28252>;
            <D.28251>:
            D.28253 = &MEM[(void *)"List`1" + 2B];
            D.28254 = *D.28253;
            D.28255 = (int) D.28254;
            D.28256 = __s2 + 2;
            D.28257 = *D.28256;
            D.28258 = (int) D.28257;
            __result = D.28255 - D.28258;
            D.28259 = __s2_len > 2;
            D.28239 = __result == 0;
            D.28260 = D.28259 & D.28239;
            if (D.28260 != 0) goto <D.28261>; else goto <D.28262>;
            <D.28261>:
            D.28263 = &MEM[(void *)"List`1" + 3B];
            D.28264 = *D.28263;
            D.28265 = (int) D.28264;
            D.28266 = __s2 + 3;
            D.28267 = *D.28266;
            D.28268 = (int) D.28267;
            __result = D.28265 - D.28268;
            <D.28262>:
            <D.28252>:
            <D.28242>:
          }
          D.24904 = __result;
        }
        iftmp.59 = -D.24904;
        goto <D.28269>;
        <D.28232>:
        D.28228 = klass->name;
        iftmp.59 = __builtin_strcmp (D.28228, "List`1");
        <D.28269>:
        D.24905 = iftmp.59;
      }
      if (D.24905 == 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.24906>;
      <D.24907>:
      D.28173 = acfg->opts;
      D.28174 = D.28173 & 16777216;
      if (D.28174 != 0) goto <D.28270>; else goto <D.28271>;
      <D.28270>:
      D.28272 = BIT_FIELD_REF <*method, 8, 264>;
      D.28273 = D.28272 & 16;
      if (D.28273 != 0) goto <D.28274>; else goto <D.28275>;
      <D.28274>:
      D.28276 = mono_method_get_context (method);
      D.28277 = D.28276->method_inst;
      if (D.28277 != 0B) goto <D.28278>; else goto <D.28279>;
      <D.28278>:
      // predicted unlikely by continue predictor.
      goto <D.24906>;
      <D.28279>:
      <D.28275>:
      <D.28271>:
      D.28280 = mono_method_is_generic_sharable_full (method, 0, 0, use_gsharedvt);
      if (D.28280 != 0) goto <D.28281>; else goto <D.28282>;
      <D.28281>:
      add_types_from_method_header (acfg, method);
      // predicted unlikely by continue predictor.
      goto <D.24906>;
      <D.28282>:
      D.28272 = BIT_FIELD_REF <*method, 8, 264>;
      D.28283 = D.28272 & 8;
      if (D.28283 != 0) goto <D.28284>; else goto <D.28285>;
      <D.28284>:
      // predicted unlikely by continue predictor.
      goto <D.24906>;
      <D.28285>:
      D.28286 = depth + 1;
      add_extra_method_with_depth (acfg, method, D.28286);
      <D.24906>:
      method = mono_class_get_methods (klass, &iter);
      if (method != 0B) goto <D.24907>; else goto <D.24908>;
      <D.24908>:
      iter = 0B;
      goto <D.24910>;
      <D.24909>:
      D.28287 = field->type;
      D.28288 = D.28287->type;
      if (D.28288 == 21) goto <D.28289>; else goto <D.28290>;
      <D.28289>:
      D.28286 = depth + 1;
      D.28287 = field->type;
      D.28291 = mono_class_from_mono_type (D.28287);
      add_generic_class_with_depth (acfg, D.28291, D.28286, "field");
      <D.28290>:
      <D.24910>:
      field = mono_class_get_fields (klass, &iter);
      if (field != 0B) goto <D.24909>; else goto <D.24911>;
      <D.24911>:
      D.28292 = BIT_FIELD_REF <*klass, 8, 280>;
      D.28293 = D.28292 & 1;
      if (D.28293 != 0) goto <D.28294>; else goto <D.28295>;
      <D.28294>:
      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.28296>; else goto <D.28297>;
      <D.28296>:
      D.28298 = mono_method_full_name (method, 1);
      printf ("%*sAdding method %s.\n", depth, "", D.28298);
      <D.28297>:
      add_method (acfg, method);
      <D.28295>:
      D.28299 = klass->parent;
      if (D.28299 != 0B) goto <D.28300>; else goto <D.28301>;
      <D.28300>:
      D.28299 = klass->parent;
      add_generic_class_with_depth (acfg, D.28299, depth, "parent");
      <D.28301>:
      D.28177 = klass->image;
      D.28178 = mono_defaults.corlib;
      if (D.28177 == D.28178) goto <D.28304>; else goto <D.28305>;
      <D.28304>:
      {
        size_t __s1_len;
        size_t __s2_len;

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

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

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

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

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

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

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

          __s2 = klass->name;
          D.28434 = "IList`1";
          D.28435 = MEM[(const unsigned char *)D.28434];
          D.28436 = (int) D.28435;
          D.28437 = *__s2;
          D.28438 = (int) D.28437;
          __result = D.28436 - D.28438;
          {
            D.28439 = __s2_len != 0;
            D.28440 = __result == 0;
            D.28441 = D.28439 & D.28440;
            if (D.28441 != 0) goto <D.28442>; else goto <D.28443>;
            <D.28442>:
            D.28444 = &MEM[(void *)"IList`1" + 1B];
            D.28445 = *D.28444;
            D.28446 = (int) D.28445;
            D.28447 = __s2 + 1;
            D.28448 = *D.28447;
            D.28449 = (int) D.28448;
            __result = D.28446 - D.28449;
            D.28450 = __s2_len > 1;
            D.28440 = __result == 0;
            D.28451 = D.28450 & D.28440;
            if (D.28451 != 0) goto <D.28452>; else goto <D.28453>;
            <D.28452>:
            D.28454 = &MEM[(void *)"IList`1" + 2B];
            D.28455 = *D.28454;
            D.28456 = (int) D.28455;
            D.28457 = __s2 + 2;
            D.28458 = *D.28457;
            D.28459 = (int) D.28458;
            __result = D.28456 - D.28459;
            D.28460 = __s2_len > 2;
            D.28440 = __result == 0;
            D.28461 = D.28460 & D.28440;
            if (D.28461 != 0) goto <D.28462>; else goto <D.28463>;
            <D.28462>:
            D.28464 = &MEM[(void *)"IList`1" + 3B];
            D.28465 = *D.28464;
            D.28466 = (int) D.28465;
            D.28467 = __s2 + 3;
            D.28468 = *D.28467;
            D.28469 = (int) D.28468;
            __result = D.28466 - D.28469;
            <D.28463>:
            <D.28453>:
            <D.28443>:
          }
          D.24946 = __result;
        }
        iftmp.63 = -D.24946;
        goto <D.28470>;
        <D.28433>:
        D.28228 = klass->name;
        iftmp.63 = __builtin_strcmp (D.28228, "IList`1");
        <D.28470>:
        D.24947 = iftmp.63;
      }
      if (D.24947 == 0) goto <D.28302>; else goto <D.28471>;
      <D.28471>:
      {
        size_t __s1_len;
        size_t __s2_len;

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

          __s2 = klass->name;
          D.28475 = "IEnumerator`1";
          D.28476 = MEM[(const unsigned char *)D.28475];
          D.28477 = (int) D.28476;
          D.28478 = *__s2;
          D.28479 = (int) D.28478;
          __result = D.28477 - D.28479;
          {
            D.28480 = __s2_len != 0;
            D.28481 = __result == 0;
            D.28482 = D.28480 & D.28481;
            if (D.28482 != 0) goto <D.28483>; else goto <D.28484>;
            <D.28483>:
            D.28485 = &MEM[(void *)"IEnumerator`1" + 1B];
            D.28486 = *D.28485;
            D.28487 = (int) D.28486;
            D.28488 = __s2 + 1;
            D.28489 = *D.28488;
            D.28490 = (int) D.28489;
            __result = D.28487 - D.28490;
            D.28491 = __s2_len > 1;
            D.28481 = __result == 0;
            D.28492 = D.28491 & D.28481;
            if (D.28492 != 0) goto <D.28493>; else goto <D.28494>;
            <D.28493>:
            D.28495 = &MEM[(void *)"IEnumerator`1" + 2B];
            D.28496 = *D.28495;
            D.28497 = (int) D.28496;
            D.28498 = __s2 + 2;
            D.28499 = *D.28498;
            D.28500 = (int) D.28499;
            __result = D.28497 - D.28500;
            D.28501 = __s2_len > 2;
            D.28481 = __result == 0;
            D.28502 = D.28501 & D.28481;
            if (D.28502 != 0) goto <D.28503>; else goto <D.28504>;
            <D.28503>:
            D.28505 = &MEM[(void *)"IEnumerator`1" + 3B];
            D.28506 = *D.28505;
            D.28507 = (int) D.28506;
            D.28508 = __s2 + 3;
            D.28509 = *D.28508;
            D.28510 = (int) D.28509;
            __result = D.28507 - D.28510;
            <D.28504>:
            <D.28494>:
            <D.28484>:
          }
          D.24955 = __result;
        }
        iftmp.64 = -D.24955;
        goto <D.28511>;
        <D.28474>:
        D.28228 = klass->name;
        iftmp.64 = __builtin_strcmp (D.28228, "IEnumerator`1");
        <D.28511>:
        D.24956 = iftmp.64;
      }
      if (D.24956 == 0) goto <D.28302>; else goto <D.28512>;
      <D.28512>:
      {
        size_t __s1_len;
        size_t __s2_len;

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

          __s2 = klass->name;
          D.28516 = "IReadOnlyList`1";
          D.28517 = MEM[(const unsigned char *)D.28516];
          D.28518 = (int) D.28517;
          D.28519 = *__s2;
          D.28520 = (int) D.28519;
          __result = D.28518 - D.28520;
          {
            D.28521 = __s2_len != 0;
            D.28522 = __result == 0;
            D.28523 = D.28521 & D.28522;
            if (D.28523 != 0) goto <D.28524>; else goto <D.28525>;
            <D.28524>:
            D.28526 = &MEM[(void *)"IReadOnlyList`1" + 1B];
            D.28527 = *D.28526;
            D.28528 = (int) D.28527;
            D.28529 = __s2 + 1;
            D.28530 = *D.28529;
            D.28531 = (int) D.28530;
            __result = D.28528 - D.28531;
            D.28532 = __s2_len > 1;
            D.28522 = __result == 0;
            D.28533 = D.28532 & D.28522;
            if (D.28533 != 0) goto <D.28534>; else goto <D.28535>;
            <D.28534>:
            D.28536 = &MEM[(void *)"IReadOnlyList`1" + 2B];
            D.28537 = *D.28536;
            D.28538 = (int) D.28537;
            D.28539 = __s2 + 2;
            D.28540 = *D.28539;
            D.28541 = (int) D.28540;
            __result = D.28538 - D.28541;
            D.28542 = __s2_len > 2;
            D.28522 = __result == 0;
            D.28543 = D.28542 & D.28522;
            if (D.28543 != 0) goto <D.28544>; else goto <D.28545>;
            <D.28544>:
            D.28546 = &MEM[(void *)"IReadOnlyList`1" + 3B];
            D.28547 = *D.28546;
            D.28548 = (int) D.28547;
            D.28549 = __s2 + 3;
            D.28550 = *D.28549;
            D.28551 = (int) D.28550;
            __result = D.28548 - D.28551;
            <D.28545>:
            <D.28535>:
            <D.28525>:
          }
          D.24964 = __result;
        }
        iftmp.65 = -D.24964;
        goto <D.28552>;
        <D.28515>:
        D.28228 = klass->name;
        iftmp.65 = __builtin_strcmp (D.28228, "IReadOnlyList`1");
        <D.28552>:
        D.24965 = iftmp.65;
      }
      if (D.24965 == 0) goto <D.28302>; else goto <D.28303>;
      <D.28302>:
      {
        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.28553 = D.28141->type_argv[0];
            tclass = mono_class_from_mono_type (D.28553);
            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.28555>; else goto <D.28556>;
              <D.28555>:
              {
                const unsigned char * __s2;
                int __result;

                __s2 = klass->name;
                D.28475 = "IEnumerator`1";
                D.28476 = MEM[(const unsigned char *)D.28475];
                D.28477 = (int) D.28476;
                D.28557 = *__s2;
                D.28558 = (int) D.28557;
                __result = D.28477 - D.28558;
                {
                  D.28559 = __s2_len != 0;
                  D.28560 = __result == 0;
                  D.28561 = D.28559 & D.28560;
                  if (D.28561 != 0) goto <D.28562>; else goto <D.28563>;
                  <D.28562>:
                  D.28485 = &MEM[(void *)"IEnumerator`1" + 1B];
                  D.28486 = *D.28485;
                  D.28487 = (int) D.28486;
                  D.28564 = __s2 + 1;
                  D.28565 = *D.28564;
                  D.28566 = (int) D.28565;
                  __result = D.28487 - D.28566;
                  D.28567 = __s2_len > 1;
                  D.28560 = __result == 0;
                  D.28568 = D.28567 & D.28560;
                  if (D.28568 != 0) goto <D.28569>; else goto <D.28570>;
                  <D.28569>:
                  D.28495 = &MEM[(void *)"IEnumerator`1" + 2B];
                  D.28496 = *D.28495;
                  D.28497 = (int) D.28496;
                  D.28571 = __s2 + 2;
                  D.28572 = *D.28571;
                  D.28573 = (int) D.28572;
                  __result = D.28497 - D.28573;
                  D.28574 = __s2_len > 2;
                  D.28560 = __result == 0;
                  D.28575 = D.28574 & D.28560;
                  if (D.28575 != 0) goto <D.28576>; else goto <D.28577>;
                  <D.28576>:
                  D.28505 = &MEM[(void *)"IEnumerator`1" + 3B];
                  D.28506 = *D.28505;
                  D.28507 = (int) D.28506;
                  D.28578 = __s2 + 3;
                  D.28579 = *D.28578;
                  D.28580 = (int) D.28579;
                  __result = D.28507 - D.28580;
                  <D.28577>:
                  <D.28570>:
                  <D.28563>:
                }
                D.24977 = __result;
              }
              iftmp.66 = -D.24977;
              goto <D.28581>;
              <D.28556>:
              D.28228 = klass->name;
              iftmp.66 = __builtin_strcmp (D.28228, "IEnumerator`1");
              <D.28581>:
              D.24978 = iftmp.66;
            }
            if (D.24978 == 0) goto <D.28582>; else goto <D.28583>;
            <D.28582>:
            D.28346 = klass->name_space;
            name_prefix = monoeg_g_strdup_printf ("%s.%s", D.28346, "IEnumerable`1");
            goto <D.28584>;
            <D.28583>:
            D.28228 = klass->name;
            D.28346 = klass->name_space;
            name_prefix = monoeg_g_strdup_printf ("%s.%s", D.28346, D.28228);
            <D.28584>:
            {
              size_t __s1_len;
              size_t __s2_len;

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

                __s2 = klass->name;
                D.28393 = "IEnumerable`1";
                D.28394 = MEM[(const unsigned char *)D.28393];
                D.28395 = (int) D.28394;
                D.28590 = *__s2;
                D.28591 = (int) D.28590;
                __result = D.28395 - D.28591;
                {
                  D.28592 = __s2_len != 0;
                  D.28593 = __result == 0;
                  D.28594 = D.28592 & D.28593;
                  if (D.28594 != 0) goto <D.28595>; else goto <D.28596>;
                  <D.28595>:
                  D.28403 = &MEM[(void *)"IEnumerable`1" + 1B];
                  D.28404 = *D.28403;
                  D.28405 = (int) D.28404;
                  D.28597 = __s2 + 1;
                  D.28598 = *D.28597;
                  D.28599 = (int) D.28598;
                  __result = D.28405 - D.28599;
                  D.28600 = __s2_len > 1;
                  D.28593 = __result == 0;
                  D.28601 = D.28600 & D.28593;
                  if (D.28601 != 0) goto <D.28602>; else goto <D.28603>;
                  <D.28602>:
                  D.28413 = &MEM[(void *)"IEnumerable`1" + 2B];
                  D.28414 = *D.28413;
                  D.28415 = (int) D.28414;
                  D.28604 = __s2 + 2;
                  D.28605 = *D.28604;
                  D.28606 = (int) D.28605;
                  __result = D.28415 - D.28606;
                  D.28607 = __s2_len > 2;
                  D.28593 = __result == 0;
                  D.28608 = D.28607 & D.28593;
                  if (D.28608 != 0) goto <D.28609>; else goto <D.28610>;
                  <D.28609>:
                  D.28423 = &MEM[(void *)"IEnumerable`1" + 3B];
                  D.28424 = *D.28423;
                  D.28425 = (int) D.28424;
                  D.28611 = __s2 + 3;
                  D.28612 = *D.28611;
                  D.28613 = (int) D.28612;
                  __result = D.28425 - D.28613;
                  <D.28610>:
                  <D.28603>:
                  <D.28596>:
                }
                D.24986 = __result;
              }
              iftmp.67 = -D.24986;
              goto <D.28614>;
              <D.28589>:
              D.28228 = klass->name;
              iftmp.67 = __builtin_strcmp (D.28228, "IEnumerable`1");
              <D.28614>:
              D.24987 = iftmp.67;
            }
            if (D.24987 == 0) goto <D.28585>; else goto <D.28615>;
            <D.28615>:
            {
              size_t __s1_len;
              size_t __s2_len;

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

                __s2 = klass->name;
                D.28475 = "IEnumerator`1";
                D.28476 = MEM[(const unsigned char *)D.28475];
                D.28477 = (int) D.28476;
                D.28619 = *__s2;
                D.28620 = (int) D.28619;
                __result = D.28477 - D.28620;
                {
                  D.28621 = __s2_len != 0;
                  D.28622 = __result == 0;
                  D.28623 = D.28621 & D.28622;
                  if (D.28623 != 0) goto <D.28624>; else goto <D.28625>;
                  <D.28624>:
                  D.28485 = &MEM[(void *)"IEnumerator`1" + 1B];
                  D.28486 = *D.28485;
                  D.28487 = (int) D.28486;
                  D.28626 = __s2 + 1;
                  D.28627 = *D.28626;
                  D.28628 = (int) D.28627;
                  __result = D.28487 - D.28628;
                  D.28629 = __s2_len > 1;
                  D.28622 = __result == 0;
                  D.28630 = D.28629 & D.28622;
                  if (D.28630 != 0) goto <D.28631>; else goto <D.28632>;
                  <D.28631>:
                  D.28495 = &MEM[(void *)"IEnumerator`1" + 2B];
                  D.28496 = *D.28495;
                  D.28497 = (int) D.28496;
                  D.28633 = __s2 + 2;
                  D.28634 = *D.28633;
                  D.28635 = (int) D.28634;
                  __result = D.28497 - D.28635;
                  D.28636 = __s2_len > 2;
                  D.28622 = __result == 0;
                  D.28637 = D.28636 & D.28622;
                  if (D.28637 != 0) goto <D.28638>; else goto <D.28639>;
                  <D.28638>:
                  D.28505 = &MEM[(void *)"IEnumerator`1" + 3B];
                  D.28506 = *D.28505;
                  D.28507 = (int) D.28506;
                  D.28640 = __s2 + 3;
                  D.28641 = *D.28640;
                  D.28642 = (int) D.28641;
                  __result = D.28507 - D.28642;
                  <D.28639>:
                  <D.28632>:
                  <D.28625>:
                }
                D.24995 = __result;
              }
              iftmp.68 = -D.24995;
              goto <D.28643>;
              <D.28618>:
              D.28228 = klass->name;
              iftmp.68 = __builtin_strcmp (D.28228, "IEnumerator`1");
              <D.28643>:
              D.24996 = iftmp.68;
            }
            if (D.24996 == 0) goto <D.28585>; else goto <D.28586>;
            <D.28585>:
            {
              struct MonoClass * nclass;

              iter = 0B;
              goto <D.25009>;
              <D.25008>:
              {
                size_t __s1_len;
                size_t __s2_len;

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

                  __s2 = nclass->name;
                  D.28647 = "InternalEnumerator`1";
                  D.28648 = MEM[(const unsigned char *)D.28647];
                  D.28649 = (int) D.28648;
                  D.28650 = *__s2;
                  D.28651 = (int) D.28650;
                  __result = D.28649 - D.28651;
                  {
                    D.28652 = __s2_len != 0;
                    D.28653 = __result == 0;
                    D.28654 = D.28652 & D.28653;
                    if (D.28654 != 0) goto <D.28655>; else goto <D.28656>;
                    <D.28655>:
                    D.28657 = &MEM[(void *)"InternalEnumerator`1" + 1B];
                    D.28658 = *D.28657;
                    D.28659 = (int) D.28658;
                    D.28660 = __s2 + 1;
                    D.28661 = *D.28660;
                    D.28662 = (int) D.28661;
                    __result = D.28659 - D.28662;
                    D.28663 = __s2_len > 1;
                    D.28653 = __result == 0;
                    D.28664 = D.28663 & D.28653;
                    if (D.28664 != 0) goto <D.28665>; else goto <D.28666>;
                    <D.28665>:
                    D.28667 = &MEM[(void *)"InternalEnumerator`1" + 2B];
                    D.28668 = *D.28667;
                    D.28669 = (int) D.28668;
                    D.28670 = __s2 + 2;
                    D.28671 = *D.28670;
                    D.28672 = (int) D.28671;
                    __result = D.28669 - D.28672;
                    D.28673 = __s2_len > 2;
                    D.28653 = __result == 0;
                    D.28674 = D.28673 & D.28653;
                    if (D.28674 != 0) goto <D.28675>; else goto <D.28676>;
                    <D.28675>:
                    D.28677 = &MEM[(void *)"InternalEnumerator`1" + 3B];
                    D.28678 = *D.28677;
                    D.28679 = (int) D.28678;
                    D.28680 = __s2 + 3;
                    D.28681 = *D.28680;
                    D.28682 = (int) D.28681;
                    __result = D.28679 - D.28682;
                    <D.28676>:
                    <D.28666>:
                    <D.28656>:
                  }
                  D.25005 = __result;
                }
                iftmp.69 = -D.25005;
                goto <D.28683>;
                <D.28646>:
                D.28684 = nclass->name;
                iftmp.69 = __builtin_strcmp (D.28684, "InternalEnumerator`1");
                <D.28683>:
                D.25006 = iftmp.69;
              }
              if (D.25006 == 0) goto <D.25007>; else goto <D.28685>;
              <D.28685>:
              <D.25009>:
              D.28686 = array_class->parent;
              nclass = mono_class_get_nested_types (D.28686, &iter);
              if (nclass != 0B) goto <D.25008>; else goto <D.25007>;
              <D.25007>:
              D.28687 = nclass == 0B;
              D.28688 = (long int) D.28687;
              D.28689 = __builtin_expect (D.28688, 0);
              if (D.28689 != 0) goto <D.28690>; else goto <D.28691>;
              <D.28690>:
              monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "aot-compiler.c", 3948, "nclass");
              <D.28691>:
              D.28138 = klass->generic_class;
              D.28692 = mono_generic_class_get_context (D.28138);
              nclass = mono_class_inflate_generic_class (nclass, D.28692);
              add_generic_class (acfg, nclass, 0, "ICollection<T>");
            }
            <D.28586>:
            iter = 0B;
            goto <D.25012>;
            <D.25011>:
            D.28693 = method->name;
            D.28694 = strstr (D.28693, name_prefix);
            if (D.28694 != 0B) goto <D.28695>; else goto <D.28696>;
            <D.28695>:
            {
              struct MonoMethod * m;

              m = mono_aot_get_array_helper_from_wrapper (method);
              add_extra_method_with_depth (acfg, m, depth);
            }
            <D.28696>:
            <D.25012>:
            method = mono_class_get_methods (array_class, &iter);
            if (method != 0B) goto <D.25011>; else goto <D.25013>;
            <D.25013>:
            monoeg_g_free (name_prefix);
          }
        finally
          {
            iter = {CLOBBER};
          }
      }
      <D.28303>:
      <D.28348>:
      <D.28305>:
      D.28177 = klass->image;
      D.28178 = mono_defaults.corlib;
      if (D.28177 == D.28178) goto <D.28697>; else goto <D.28698>;
      <D.28697>:
      {
        size_t __s1_len;
        size_t __s2_len;

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

          __s2 = klass->name_space;
          D.28309 = "System.Collections.Generic";
          D.28310 = MEM[(const unsigned char *)D.28309];
          D.28311 = (int) D.28310;
          D.28702 = *__s2;
          D.28703 = (int) D.28702;
          __result = D.28311 - D.28703;
          {
            D.28704 = __s2_len != 0;
            D.28705 = __result == 0;
            D.28706 = D.28704 & D.28705;
            if (D.28706 != 0) goto <D.28707>; else goto <D.28708>;
            <D.28707>:
            D.28319 = &MEM[(void *)"System.Collections.Generic" + 1B];
            D.28320 = *D.28319;
            D.28321 = (int) D.28320;
            D.28709 = __s2 + 1;
            D.28710 = *D.28709;
            D.28711 = (int) D.28710;
            __result = D.28321 - D.28711;
            D.28712 = __s2_len > 1;
            D.28705 = __result == 0;
            D.28713 = D.28712 & D.28705;
            if (D.28713 != 0) goto <D.28714>; else goto <D.28715>;
            <D.28714>:
            D.28329 = &MEM[(void *)"System.Collections.Generic" + 2B];
            D.28330 = *D.28329;
            D.28331 = (int) D.28330;
            D.28716 = __s2 + 2;
            D.28717 = *D.28716;
            D.28718 = (int) D.28717;
            __result = D.28331 - D.28718;
            D.28719 = __s2_len > 2;
            D.28705 = __result == 0;
            D.28720 = D.28719 & D.28705;
            if (D.28720 != 0) goto <D.28721>; else goto <D.28722>;
            <D.28721>:
            D.28339 = &MEM[(void *)"System.Collections.Generic" + 3B];
            D.28340 = *D.28339;
            D.28341 = (int) D.28340;
            D.28723 = __s2 + 3;
            D.28724 = *D.28723;
            D.28725 = (int) D.28724;
            __result = D.28341 - D.28725;
            <D.28722>:
            <D.28715>:
            <D.28708>:
          }
          D.25021 = __result;
        }
        iftmp.70 = -D.25021;
        goto <D.28726>;
        <D.28701>:
        D.28346 = klass->name_space;
        iftmp.70 = __builtin_strcmp (D.28346, "System.Collections.Generic");
        <D.28726>:
        D.25022 = iftmp.70;
      }
      if (D.25022 == 0) goto <D.28727>; else goto <D.28728>;
      <D.28727>:
      {
        size_t __s1_len;
        size_t __s2_len;

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

          __s2 = klass->name;
          D.28732 = "Comparer`1";
          D.28733 = MEM[(const unsigned char *)D.28732];
          D.28734 = (int) D.28733;
          D.28735 = *__s2;
          D.28736 = (int) D.28735;
          __result = D.28734 - D.28736;
          {
            D.28737 = __s2_len != 0;
            D.28738 = __result == 0;
            D.28739 = D.28737 & D.28738;
            if (D.28739 != 0) goto <D.28740>; else goto <D.28741>;
            <D.28740>:
            D.28742 = &MEM[(void *)"Comparer`1" + 1B];
            D.28743 = *D.28742;
            D.28744 = (int) D.28743;
            D.28745 = __s2 + 1;
            D.28746 = *D.28745;
            D.28747 = (int) D.28746;
            __result = D.28744 - D.28747;
            D.28748 = __s2_len > 1;
            D.28738 = __result == 0;
            D.28749 = D.28748 & D.28738;
            if (D.28749 != 0) goto <D.28750>; else goto <D.28751>;
            <D.28750>:
            D.28752 = &MEM[(void *)"Comparer`1" + 2B];
            D.28753 = *D.28752;
            D.28754 = (int) D.28753;
            D.28755 = __s2 + 2;
            D.28756 = *D.28755;
            D.28757 = (int) D.28756;
            __result = D.28754 - D.28757;
            D.28758 = __s2_len > 2;
            D.28738 = __result == 0;
            D.28759 = D.28758 & D.28738;
            if (D.28759 != 0) goto <D.28760>; else goto <D.28761>;
            <D.28760>:
            D.28762 = &MEM[(void *)"Comparer`1" + 3B];
            D.28763 = *D.28762;
            D.28764 = (int) D.28763;
            D.28765 = __s2 + 3;
            D.28766 = *D.28765;
            D.28767 = (int) D.28766;
            __result = D.28764 - D.28767;
            <D.28761>:
            <D.28751>:
            <D.28741>:
          }
          D.25030 = __result;
        }
        iftmp.71 = -D.25030;
        goto <D.28768>;
        <D.28731>:
        D.28228 = klass->name;
        iftmp.71 = __builtin_strcmp (D.28228, "Comparer`1");
        <D.28768>:
        D.25031 = iftmp.71;
      }
      if (D.25031 == 0) goto <D.28769>; else goto <D.28770>;
      <D.28769>:
      {
        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.28553 = D.28141->type_argv[0];
            tclass = mono_class_from_mono_type (D.28553);
            memset (&ctx, 0, 16);
            D.28178 = mono_defaults.corlib;
            icomparable = mono_class_from_name (D.28178, "System", "IComparable`1");
            D.28771 = icomparable == 0B;
            D.28772 = (long int) D.28771;
            D.28773 = __builtin_expect (D.28772, 0);
            if (D.28773 != 0) goto <D.28774>; else goto <D.28775>;
            <D.28774>:
            monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "aot-compiler.c", 3975, "icomparable");
            <D.28775>:
            D.28776 = &tclass->byval_arg;
            args[0] = D.28776;
            D.28777 = mono_metadata_get_generic_inst (1, &args);
            ctx.class_inst = D.28777;
            D.28778 = mono_class_inflate_generic_class (icomparable, &ctx);
            D.28779 = mono_class_is_assignable_from (D.28778, tclass);
            if (D.28779 != 0) goto <D.28780>; else goto <D.28781>;
            <D.28780>:
            D.28178 = mono_defaults.corlib;
            gcomparer = mono_class_from_name (D.28178, "System.Collections.Generic", "GenericComparer`1");
            D.28782 = gcomparer == 0B;
            D.28783 = (long int) D.28782;
            D.28784 = __builtin_expect (D.28783, 0);
            if (D.28784 != 0) goto <D.28785>; else goto <D.28786>;
            <D.28785>:
            monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "aot-compiler.c", 3981, "gcomparer");
            <D.28786>:
            D.28787 = mono_class_inflate_generic_class (gcomparer, &ctx);
            add_generic_class (acfg, D.28787, 0, "Comparer<T>");
            <D.28781>:
          }
        finally
          {
            ctx = {CLOBBER};
            args = {CLOBBER};
          }
      }
      <D.28770>:
      <D.28728>:
      <D.28698>:
      D.28177 = klass->image;
      D.28178 = mono_defaults.corlib;
      if (D.28177 == D.28178) goto <D.28788>; else goto <D.28789>;
      <D.28788>:
      {
        size_t __s1_len;
        size_t __s2_len;

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

          __s2 = klass->name_space;
          D.28309 = "System.Collections.Generic";
          D.28310 = MEM[(const unsigned char *)D.28309];
          D.28311 = (int) D.28310;
          D.28793 = *__s2;
          D.28794 = (int) D.28793;
          __result = D.28311 - D.28794;
          {
            D.28795 = __s2_len != 0;
            D.28796 = __result == 0;
            D.28797 = D.28795 & D.28796;
            if (D.28797 != 0) goto <D.28798>; else goto <D.28799>;
            <D.28798>:
            D.28319 = &MEM[(void *)"System.Collections.Generic" + 1B];
            D.28320 = *D.28319;
            D.28321 = (int) D.28320;
            D.28800 = __s2 + 1;
            D.28801 = *D.28800;
            D.28802 = (int) D.28801;
            __result = D.28321 - D.28802;
            D.28803 = __s2_len > 1;
            D.28796 = __result == 0;
            D.28804 = D.28803 & D.28796;
            if (D.28804 != 0) goto <D.28805>; else goto <D.28806>;
            <D.28805>:
            D.28329 = &MEM[(void *)"System.Collections.Generic" + 2B];
            D.28330 = *D.28329;
            D.28331 = (int) D.28330;
            D.28807 = __s2 + 2;
            D.28808 = *D.28807;
            D.28809 = (int) D.28808;
            __result = D.28331 - D.28809;
            D.28810 = __s2_len > 2;
            D.28796 = __result == 0;
            D.28811 = D.28810 & D.28796;
            if (D.28811 != 0) goto <D.28812>; else goto <D.28813>;
            <D.28812>:
            D.28339 = &MEM[(void *)"System.Collections.Generic" + 3B];
            D.28340 = *D.28339;
            D.28341 = (int) D.28340;
            D.28814 = __s2 + 3;
            D.28815 = *D.28814;
            D.28816 = (int) D.28815;
            __result = D.28341 - D.28816;
            <D.28813>:
            <D.28806>:
            <D.28799>:
          }
          D.25044 = __result;
        }
        iftmp.72 = -D.25044;
        goto <D.28817>;
        <D.28792>:
        D.28346 = klass->name_space;
        iftmp.72 = __builtin_strcmp (D.28346, "System.Collections.Generic");
        <D.28817>:
        D.25045 = iftmp.72;
      }
      if (D.25045 == 0) goto <D.28818>; else goto <D.28819>;
      <D.28818>:
      {
        size_t __s1_len;
        size_t __s2_len;

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

          __s2 = klass->name;
          D.28823 = "EqualityComparer`1";
          D.28824 = MEM[(const unsigned char *)D.28823];
          D.28825 = (int) D.28824;
          D.28826 = *__s2;
          D.28827 = (int) D.28826;
          __result = D.28825 - D.28827;
          {
            D.28828 = __s2_len != 0;
            D.28829 = __result == 0;
            D.28830 = D.28828 & D.28829;
            if (D.28830 != 0) goto <D.28831>; else goto <D.28832>;
            <D.28831>:
            D.28833 = &MEM[(void *)"EqualityComparer`1" + 1B];
            D.28834 = *D.28833;
            D.28835 = (int) D.28834;
            D.28836 = __s2 + 1;
            D.28837 = *D.28836;
            D.28838 = (int) D.28837;
            __result = D.28835 - D.28838;
            D.28839 = __s2_len > 1;
            D.28829 = __result == 0;
            D.28840 = D.28839 & D.28829;
            if (D.28840 != 0) goto <D.28841>; else goto <D.28842>;
            <D.28841>:
            D.28843 = &MEM[(void *)"EqualityComparer`1" + 2B];
            D.28844 = *D.28843;
            D.28845 = (int) D.28844;
            D.28846 = __s2 + 2;
            D.28847 = *D.28846;
            D.28848 = (int) D.28847;
            __result = D.28845 - D.28848;
            D.28849 = __s2_len > 2;
            D.28829 = __result == 0;
            D.28850 = D.28849 & D.28829;
            if (D.28850 != 0) goto <D.28851>; else goto <D.28852>;
            <D.28851>:
            D.28853 = &MEM[(void *)"EqualityComparer`1" + 3B];
            D.28854 = *D.28853;
            D.28855 = (int) D.28854;
            D.28856 = __s2 + 3;
            D.28857 = *D.28856;
            D.28858 = (int) D.28857;
            __result = D.28855 - D.28858;
            <D.28852>:
            <D.28842>:
            <D.28832>:
          }
          D.25053 = __result;
        }
        iftmp.73 = -D.25053;
        goto <D.28859>;
        <D.28822>:
        D.28228 = klass->name;
        iftmp.73 = __builtin_strcmp (D.28228, "EqualityComparer`1");
        <D.28859>:
        D.25054 = iftmp.73;
      }
      if (D.25054 == 0) goto <D.28860>; else goto <D.28861>;
      <D.28860>:
      {
        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.28553 = D.28141->type_argv[0];
            tclass = mono_class_from_mono_type (D.28553);
            memset (&ctx, 0, 16);
            D.28178 = mono_defaults.corlib;
            iface = mono_class_from_name (D.28178, "System", "IEquatable`1");
            D.28862 = iface == 0B;
            D.28863 = (long int) D.28862;
            D.28864 = __builtin_expect (D.28863, 0);
            if (D.28864 != 0) goto <D.28865>; else goto <D.28866>;
            <D.28865>:
            monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "aot-compiler.c", 3996, "iface");
            <D.28866>:
            D.28867 = &tclass->byval_arg;
            args[0] = D.28867;
            D.28868 = mono_metadata_get_generic_inst (1, &args);
            ctx.class_inst = D.28868;
            D.28869 = mono_class_inflate_generic_class (iface, &ctx);
            D.28870 = mono_class_is_assignable_from (D.28869, tclass);
            if (D.28870 != 0) goto <D.28871>; else goto <D.28872>;
            <D.28871>:
            D.28178 = mono_defaults.corlib;
            gcomparer = mono_class_from_name (D.28178, "System.Collections.Generic", "GenericEqualityComparer`1");
            D.28873 = gcomparer == 0B;
            D.28874 = (long int) D.28873;
            D.28875 = __builtin_expect (D.28874, 0);
            if (D.28875 != 0) goto <D.28876>; else goto <D.28877>;
            <D.28876>:
            monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "aot-compiler.c", 4002, "gcomparer");
            <D.28877>:
            D.28878 = mono_class_inflate_generic_class (gcomparer, &ctx);
            add_generic_class (acfg, D.28878, 0, "EqualityComparer<T>");
            <D.28872>:
          }
        finally
          {
            ctx = {CLOBBER};
            args = {CLOBBER};
          }
      }
      <D.28861>:
      <D.28819>:
      <D.28789>:
    }
  finally
    {
      iter = {CLOBBER};
    }
}


has_type_vars (struct MonoClass * klass)
{
  unsigned char D.28882;
  _Bool D.28883;
  _Bool D.28884;
  _Bool D.28885;
  gboolean D.28888;
  unsigned char D.28889;
  struct MonoClass * D.28892;
  struct MonoGenericClass * D.28893;
  struct MonoGenericInst * D.28896;
  struct MonoType * D.28899;
  struct MonoClass * D.28900;
  int D.28901;
  <unnamed-unsigned:22> D.28904;
  int D.28905;
  struct MonoGenericContainer * D.28906;

  D.28882 = klass->byval_arg.type;
  D.28883 = D.28882 == 19;
  D.28884 = D.28882 == 30;
  D.28885 = D.28883 | D.28884;
  if (D.28885 != 0) goto <D.28886>; else goto <D.28887>;
  <D.28886>:
  D.28888 = 1;
  return D.28888;
  <D.28887>:
  D.28889 = klass->rank;
  if (D.28889 != 0) goto <D.28890>; else goto <D.28891>;
  <D.28890>:
  D.28892 = klass->element_class;
  D.28888 = has_type_vars (D.28892);
  return D.28888;
  <D.28891>:
  D.28893 = klass->generic_class;
  if (D.28893 != 0B) goto <D.28894>; else goto <D.28895>;
  <D.28894>:
  {
    struct MonoGenericContext * context;

    D.28893 = klass->generic_class;
    context = &D.28893->context;
    D.28896 = context->class_inst;
    if (D.28896 != 0B) goto <D.28897>; else goto <D.28898>;
    <D.28897>:
    {
      int i;

      i = 0;
      goto <D.24833>;
      <D.24832>:
      D.28896 = context->class_inst;
      D.28899 = D.28896->type_argv[i];
      D.28900 = mono_class_from_mono_type (D.28899);
      D.28901 = has_type_vars (D.28900);
      if (D.28901 != 0) goto <D.28902>; else goto <D.28903>;
      <D.28902>:
      D.28888 = 1;
      return D.28888;
      <D.28903>:
      i = i + 1;
      <D.24833>:
      D.28896 = context->class_inst;
      D.28904 = D.28896->type_argc;
      D.28905 = (int) D.28904;
      if (D.28905 > i) goto <D.24832>; else goto <D.24834>;
      <D.24834>:
    }
    <D.28898>:
  }
  <D.28895>:
  D.28906 = klass->generic_container;
  if (D.28906 != 0B) goto <D.28907>; else goto <D.28908>;
  <D.28907>:
  D.28888 = 1;
  return D.28888;
  <D.28908>:
  D.28888 = 0;
  return D.28888;
}


check_type_depth (struct MonoType * t, int depth)
{
  gboolean D.28912;
  unsigned char D.28913;
  int D.28914;
  int D.28917;
  struct MonoType * D.28918;
  int D.28919;
  <unnamed-unsigned:22> D.28922;
  int D.28923;
  int i;

  if (depth > 8) goto <D.28910>; else goto <D.28911>;
  <D.28910>:
  D.28912 = 1;
  return D.28912;
  <D.28911>:
  D.28913 = t->type;
  D.28914 = (int) D.28913;
  switch (D.28914) <default: <D.24874>, case 21: <D.24867>>
  <D.24867>:
  {
    struct MonoGenericClass * gklass;
    struct MonoGenericInst * ginst;

    gklass = t->data.generic_class;
    ginst = gklass->context.class_inst;
    if (ginst != 0B) goto <D.28915>; else goto <D.28916>;
    <D.28915>:
    i = 0;
    goto <D.24871>;
    <D.24870>:
    D.28917 = depth + 1;
    D.28918 = ginst->type_argv[i];
    D.28919 = check_type_depth (D.28918, D.28917);
    if (D.28919 != 0) goto <D.28920>; else goto <D.28921>;
    <D.28920>:
    D.28912 = 1;
    return D.28912;
    <D.28921>:
    i = i + 1;
    <D.24871>:
    D.28922 = ginst->type_argc;
    D.28923 = (int) D.28922;
    if (D.28923 > i) goto <D.24870>; else goto <D.24872>;
    <D.24872>:
    <D.28916>:
    goto <D.24873>;
  }
  <D.24874>:
  goto <D.24873>;
  <D.24873>:
  D.28912 = 0;
  return D.28912;
}


is_vt_inst (struct MonoGenericInst * inst)
{
  unsigned char D.28926;
  gboolean D.28929;
  <unnamed-unsigned:22> D.28930;
  int D.28931;
  int i;

  i = 0;
  goto <D.24841>;
  <D.24840>:
  {
    struct MonoType * t;

    t = inst->type_argv[i];
    D.28926 = t->type;
    if (D.28926 == 17) goto <D.28927>; else goto <D.28928>;
    <D.28927>:
    D.28929 = 1;
    return D.28929;
    <D.28928>:
  }
  i = i + 1;
  <D.24841>:
  D.28930 = inst->type_argc;
  D.28931 = (int) D.28930;
  if (D.28931 > i) goto <D.24840>; else goto <D.24842>;
  <D.24842>:
  D.28929 = 0;
  return D.28929;
}


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

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


add_types_from_method_header (struct MonoAotCompile * acfg, struct MonoMethod * method)
{
  struct GHashTable * D.28935;
  void * D.28936;
  long int D.28937;
  struct MonoType * D.28940;
  unsigned char D.28941;
  int D.28944;
  struct MonoClass * D.28945;
  short unsigned int D.28946;
  int D.28947;
  struct MonoType * D.28950;
  unsigned char D.28951;
  struct MonoClass * D.28954;
  short unsigned int D.28955;
  int D.28956;
  struct MonoMethodHeader * header;
  struct MonoMethodSignature * sig;
  int j;
  int depth;

  D.28935 = acfg->method_depth;
  D.28936 = monoeg_g_hash_table_lookup (D.28935, method);
  D.28937 = (long int) D.28936;
  depth = (int) D.28937;
  sig = mono_method_signature (method);
  if (sig != 0B) goto <D.28938>; else goto <D.28939>;
  <D.28938>:
  j = 0;
  goto <D.25082>;
  <D.25081>:
  D.28940 = sig->params[j];
  D.28941 = D.28940->type;
  if (D.28941 == 21) goto <D.28942>; else goto <D.28943>;
  <D.28942>:
  D.28944 = depth + 1;
  D.28940 = sig->params[j];
  D.28945 = mono_class_from_mono_type (D.28940);
  add_generic_class_with_depth (acfg, D.28945, D.28944, "arg");
  <D.28943>:
  j = j + 1;
  <D.25082>:
  D.28946 = sig->param_count;
  D.28947 = (int) D.28946;
  if (D.28947 > j) goto <D.25081>; else goto <D.25083>;
  <D.25083>:
  <D.28939>:
  header = mono_method_get_header (method);
  if (header != 0B) goto <D.28948>; else goto <D.28949>;
  <D.28948>:
  j = 0;
  goto <D.25085>;
  <D.25084>:
  D.28950 = header->locals[j];
  D.28951 = D.28950->type;
  if (D.28951 == 21) goto <D.28952>; else goto <D.28953>;
  <D.28952>:
  D.28944 = depth + 1;
  D.28950 = header->locals[j];
  D.28954 = mono_class_from_mono_type (D.28950);
  add_generic_class_with_depth (acfg, D.28954, D.28944, "local");
  <D.28953>:
  j = j + 1;
  <D.25085>:
  D.28955 = header->num_locals;
  D.28956 = (int) D.28955;
  if (D.28956 > j) goto <D.25084>; else goto <D.25086>;
  <D.25086>:
  goto <D.28957>;
  <D.28949>:
  mono_loader_clear_error ();
  <D.28957>:
}


add_instances_of (struct MonoAotCompile * acfg, struct MonoClass * klass, struct MonoType * * insts, int ninsts, gboolean force)
{
  int D.28958;
  long unsigned int D.28961;
  long unsigned int D.28962;
  struct MonoType * * D.28963;
  struct MonoType * D.28964;
  struct MonoGenericInst * D.28965;
  struct MonoClass * D.28966;
  int i;
  struct MonoGenericContext ctx;
  struct MonoType * args[16];

  try
    {
      D.28958 = acfg->aot_opts.no_instances;
      if (D.28958 != 0) goto <D.28959>; else goto <D.28960>;
      <D.28959>:
      return;
      <D.28960>:
      memset (&ctx, 0, 16);
      i = 0;
      goto <D.25071>;
      <D.25070>:
      D.28961 = (long unsigned int) i;
      D.28962 = D.28961 * 8;
      D.28963 = insts + D.28962;
      D.28964 = *D.28963;
      args[0] = D.28964;
      D.28965 = mono_metadata_get_generic_inst (1, &args);
      ctx.class_inst = D.28965;
      D.28966 = mono_class_inflate_generic_class (klass, &ctx);
      add_generic_class (acfg, D.28966, force, "");
      i = i + 1;
      <D.25071>:
      if (i < ninsts) goto <D.25070>; else goto <D.25072>;
      <D.25072>:
    }
  finally
    {
      ctx = {CLOBBER};
      args = {CLOBBER};
    }
}


add_wrappers (struct MonoAotCompile * acfg)
{
  int D.28970;
  int D.28971;
  struct MonoImage * D.28972;
  short unsigned int D.28975;
  int D.28976;
  int D.28977;
  short unsigned int D.28979;
  int D.28980;
  int D.28981;
  int D.28983;
  struct MonoType * D.28986;
  unsigned char D.28987;
  _Bool D.28988;
  _Bool D.28989;
  _Bool D.28990;
  int D.28993;
  struct MonoType * D.28996;
  unsigned char D.28997;
  int D.29000;
  short unsigned int D.29003;
  int D.29004;
  struct MonoClass * D.29005;
  unsigned char D.29006;
  unsigned char D.29007;
  struct MonoClass * D.29012;
  int D.29013;
  _Bool D.29016;
  _Bool D.29017;
  _Bool D.29018;
  struct MonoMethod * D.29023;
  <unnamed-unsigned:24> D.29024;
  int D.29025;
  int D.24705;
  int iftmp.74;
  int D.24704;
  struct MonoAssembly * D.29029;
  const char[9] * D.29030;
  unsigned char D.29031;
  int D.29032;
  unsigned char D.29033;
  int D.29034;
  _Bool D.29035;
  _Bool D.29036;
  _Bool D.29037;
  const unsigned char * D.29040;
  unsigned char D.29041;
  int D.29042;
  const unsigned char * D.29043;
  unsigned char D.29044;
  int D.29045;
  _Bool D.29046;
  _Bool D.29047;
  const unsigned char * D.29050;
  unsigned char D.29051;
  int D.29052;
  const unsigned char * D.29053;
  unsigned char D.29054;
  int D.29055;
  _Bool D.29056;
  _Bool D.29057;
  const unsigned char * D.29060;
  unsigned char D.29061;
  int D.29062;
  const unsigned char * D.29063;
  unsigned char D.29064;
  int D.29065;
  const char * D.29067;
  struct MonoImage * D.29070;
  struct MonoClass * D.29071;
  struct MonoType * D.29072;
  struct MonoMethod * D.29073;
  struct MonoMethod * D.29074;
  struct MonoClass * D.29075;
  struct MonoType * D.29076;
  struct MonoMethod * D.29077;
  struct MonoMethod * D.29078;
  struct MonoMethod * D.29079;
  struct MonoClass * D.29080;
  struct MonoType * D.29081;
  struct MonoMethod * D.29082;
  struct MonoClass * D.29083;
  struct MonoType * D.29084;
  struct MonoClass * D.29085;
  struct MonoType * D.29086;
  struct MonoMethod * D.29087;
  struct MonoClass * D.29088;
  struct MonoMethod * D.29089;
  struct MonoMethod * D.29090;
  struct MonoMethod * D.29093;
  struct MonoMethod * D.29094;
  struct MonoMethod * D.29095;
  int D.29096;
  unsigned int D.29099;
  struct MonoClass * D.29102;
  _Bool D.29107;
  long int D.29108;
  long int D.29109;
  long unsigned int D.29114;
  long unsigned int D.29115;
  struct MonoMethod * * D.29116;
  struct MonoMethod * D.29117;
  int nwrappers.75;
  struct MonoMethod * D.29119;
  struct MonoMethod * D.29120;
  struct GHashTable * D.29125;
  int D.29126;
  unsigned char D.29131;
  unsigned char D.29132;
  struct MonoClass * D.29134;
  struct MonoClass * D.29136;
  struct MonoGenericContainer * D.29137;
  struct MonoMethod * D.29142;
  struct MonoMethod * D.29145;
  struct MonoMethod * D.29148;
  int D.24731;
  int iftmp.76;
  int D.24730;
  struct MonoClass * D.29154;
  const char[35] * D.29155;
  unsigned char D.29156;
  int D.29157;
  unsigned char D.29158;
  int D.29159;
  _Bool D.29160;
  _Bool D.29161;
  _Bool D.29162;
  const unsigned char * D.29165;
  unsigned char D.29166;
  int D.29167;
  const unsigned char * D.29168;
  unsigned char D.29169;
  int D.29170;
  _Bool D.29171;
  _Bool D.29172;
  const unsigned char * D.29175;
  unsigned char D.29176;
  int D.29177;
  const unsigned char * D.29178;
  unsigned char D.29179;
  int D.29180;
  _Bool D.29181;
  _Bool D.29182;
  const unsigned char * D.29185;
  unsigned char D.29186;
  int D.29187;
  const unsigned char * D.29188;
  unsigned char D.29189;
  int D.29190;
  const char * D.29192;
  int D.24740;
  int iftmp.77;
  int D.24739;
  const char[34] * D.29197;
  unsigned char D.29198;
  int D.29199;
  unsigned char D.29200;
  int D.29201;
  _Bool D.29202;
  _Bool D.29203;
  _Bool D.29204;
  const unsigned char * D.29207;
  unsigned char D.29208;
  int D.29209;
  const unsigned char * D.29210;
  unsigned char D.29211;
  int D.29212;
  _Bool D.29213;
  _Bool D.29214;
  const unsigned char * D.29217;
  unsigned char D.29218;
  int D.29219;
  const unsigned char * D.29220;
  unsigned char D.29221;
  int D.29222;
  _Bool D.29223;
  _Bool D.29224;
  const unsigned char * D.29227;
  unsigned char D.29228;
  int D.29229;
  const unsigned char * D.29230;
  unsigned char D.29231;
  int D.29232;
  int D.29235;
  struct MonoMethod * D.29238;
  unsigned int D.29240;
  unsigned int D.29241;
  unsigned char D.29246;
  unsigned char D.29247;
  _Bool D.29248;
  long int D.29249;
  long int D.29250;
  <unnamed-unsigned:24> D.29257;
  int D.29258;
  int D.29259;
  unsigned char D.29262;
  struct MonoClass * D.29265;
  unsigned char D.29266;
  unsigned char D.29267;
  unsigned char D.29270;
  unsigned char D.29271;
  _Bool D.29272;
  unsigned char D.29273;
  _Bool D.29274;
  _Bool D.29275;
  _Bool D.29278;
  long int D.29279;
  long int D.29280;
  struct MonoMethod * D.29283;
  struct MonoMethod * D.29286;
  <unnamed-unsigned:24> D.29287;
  int D.29288;
  short unsigned int D.29289;
  int D.29290;
  int D.29291;
  unsigned char D.29294;
  unsigned char D.29295;
  struct MonoClass * D.29299;
  struct MonoGenericContainer * D.29300;
  unsigned char D.29303;
  unsigned char D.29304;
  _Bool D.29305;
  long int D.29306;
  long int D.29307;
  struct MonoMethod * D.29311;
  short unsigned int D.29314;
  int D.29315;
  int D.29316;
  short unsigned int D.29318;
  int D.29319;
  int D.29320;
  struct MonoMethod * D.29321;
  struct MonoMethod * D.29324;
  int D.24781;
  int iftmp.78;
  int D.24780;
  struct MonoClass * D.29330;
  const char[29] * D.29331;
  unsigned char D.29332;
  int D.29333;
  unsigned char D.29334;
  int D.29335;
  _Bool D.29336;
  _Bool D.29337;
  _Bool D.29338;
  const unsigned char * D.29341;
  unsigned char D.29342;
  int D.29343;
  const unsigned char * D.29344;
  unsigned char D.29345;
  int D.29346;
  _Bool D.29347;
  _Bool D.29348;
  const unsigned char * D.29351;
  unsigned char D.29352;
  int D.29353;
  const unsigned char * D.29354;
  unsigned char D.29355;
  int D.29356;
  _Bool D.29357;
  _Bool D.29358;
  const unsigned char * D.29361;
  unsigned char D.29362;
  int D.29363;
  const unsigned char * D.29364;
  unsigned char D.29365;
  int D.29366;
  const char * D.29368;
  int D.29370;
  struct MonoMethod * D.29373;
  const mono_byte * p.79;
  short unsigned int D.29375;
  int D.29376;
  int D.29377;
  char * D.29380;
  short unsigned int D.29381;
  _Bool D.29382;
  long int D.29383;
  long int D.29384;
  int iftmp.80;
  struct MonoType * D.29391;
  unsigned char D.29392;
  int D.24806;
  int iftmp.81;
  int D.24805;
  struct MonoClass * D.29397;
  const char[5] * D.29398;
  unsigned char D.29399;
  int D.29400;
  unsigned char D.29401;
  int D.29402;
  _Bool D.29403;
  _Bool D.29404;
  _Bool D.29405;
  const unsigned char * D.29408;
  unsigned char D.29409;
  int D.29410;
  const unsigned char * D.29411;
  unsigned char D.29412;
  int D.29413;
  _Bool D.29414;
  _Bool D.29415;
  const unsigned char * D.29418;
  unsigned char D.29419;
  int D.29420;
  const unsigned char * D.29421;
  unsigned char D.29422;
  int D.29423;
  _Bool D.29424;
  _Bool D.29425;
  const unsigned char * D.29428;
  unsigned char D.29429;
  int D.29430;
  const unsigned char * D.29431;
  unsigned char D.29432;
  int D.29433;
  struct MonoClass * D.29435;
  const char * D.29436;
  _Bool D.29437;
  long int D.29438;
  long int D.29439;
  const char * p.82;
  const char * p.83;
  unsigned int D.29444;
  int D.29445;
  unsigned int D.29446;
  sizetype D.29447;
  char * D.29448;
  _Bool D.29449;
  long int D.29450;
  long int D.29451;
  struct MonoClass * D.29454;
  _Bool D.29455;
  long int D.29456;
  long int D.29457;
  const char * p.84;
  short unsigned int D.29461;
  _Bool D.29462;
  long int D.29463;
  long int D.29464;
  const char * named.85;
  char D.29470;
  const char * named.86;
  unsigned int D.29472;
  int D.29473;
  long unsigned int D.29474;
  long unsigned int D.29475;
  sizetype D.29476;
  char * D.29477;
  const char * named.87;
  _Bool D.29479;
  long int D.29480;
  long int D.29481;
  int D.24818;
  int iftmp.88;
  int D.24817;
  const char[13] * D.29487;
  unsigned char D.29488;
  int D.29489;
  unsigned char D.29490;
  int D.29491;
  _Bool D.29492;
  _Bool D.29493;
  _Bool D.29494;
  const unsigned char * D.29497;
  unsigned char D.29498;
  int D.29499;
  const unsigned char * D.29500;
  unsigned char D.29501;
  int D.29502;
  _Bool D.29503;
  _Bool D.29504;
  const unsigned char * D.29507;
  unsigned char D.29508;
  int D.29509;
  const unsigned char * D.29510;
  unsigned char D.29511;
  int D.29512;
  _Bool D.29513;
  _Bool D.29514;
  const unsigned char * D.29517;
  unsigned char D.29518;
  int D.29519;
  const unsigned char * D.29520;
  unsigned char D.29521;
  int D.29522;
  _Bool D.29524;
  long int D.29525;
  long int D.29526;
  _Bool D.29529;
  long int D.29530;
  long int D.29531;
  unsigned int D.29534;
  long unsigned int D.29535;
  long unsigned int D.29536;
  char * D.29537;
  const char * named.89;
  struct GHashTable * D.29541;
  int D.29544;
  short unsigned int D.29546;
  int D.29547;
  int D.29548;
  struct MonoMethod * D.29549;
  unsigned char D.29554;
  unsigned char D.29555;
  struct MonoGenericContainer * D.29558;
  int D.29561;
  struct MonoClass * D.29564;
  const char * D.29566;
  char * D.29567;
  struct MonoMethod * D.29568;
  struct MonoMethod * D.29569;
  struct MonoMethod * method;
  struct MonoMethod * m;
  int i;
  int j;
  struct MonoMethodSignature * sig;
  struct MonoMethodSignature * csig;
  guint32 token;

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

    D.28970 = i + 1;
    D.28971 = D.28970 | 100663296;
    token = (guint32) D.28971;
    skip = 0;
    D.28972 = acfg->image;
    method = mono_get_method (D.28972, token, 0B);
    D.28975 = method->flags;
    D.28976 = (int) D.28975;
    D.28977 = D.28976 & 8192;
    if (D.28977 != 0) goto <D.28973>; else goto <D.28978>;
    <D.28978>:
    D.28979 = method->iflags;
    D.28980 = (int) D.28979;
    D.28981 = D.28980 & 3;
    if (D.28981 != 0) goto <D.28973>; else goto <D.28982>;
    <D.28982>:
    D.28975 = method->flags;
    D.28976 = (int) D.28975;
    D.28983 = D.28976 & 1024;
    if (D.28983 != 0) goto <D.28973>; else goto <D.28974>;
    <D.28973>:
    skip = 1;
    <D.28974>:
    sig = mono_method_signature (method);
    if (sig == 0B) goto <D.28984>; else goto <D.28985>;
    <D.28984>:
    // predicted unlikely by continue predictor.
    goto <D.24685>;
    <D.28985>:
    D.28986 = sig->ret;
    D.28987 = D.28986->type;
    D.28988 = D.28987 == 15;
    D.28989 = D.28987 == 22;
    D.28990 = D.28988 | D.28989;
    if (D.28990 != 0) goto <D.28991>; else goto <D.28992>;
    <D.28991>:
    skip = 1;
    <D.28992>:
    D.28986 = sig->ret;
    D.28993 = mono_class_is_open_constructed_type (D.28986);
    if (D.28993 != 0) goto <D.28994>; else goto <D.28995>;
    <D.28994>:
    skip = 1;
    <D.28995>:
    j = 0;
    goto <D.24687>;
    <D.24686>:
    D.28996 = sig->params[j];
    D.28997 = D.28996->type;
    if (D.28997 == 22) goto <D.28998>; else goto <D.28999>;
    <D.28998>:
    skip = 1;
    <D.28999>:
    D.28996 = sig->params[j];
    D.29000 = mono_class_is_open_constructed_type (D.28996);
    if (D.29000 != 0) goto <D.29001>; else goto <D.29002>;
    <D.29001>:
    skip = 1;
    <D.29002>:
    j = j + 1;
    <D.24687>:
    D.29003 = sig->param_count;
    D.29004 = (int) D.29003;
    if (D.29004 > j) goto <D.24686>; else goto <D.24688>;
    <D.24688>:
    D.29005 = method->klass;
    D.29006 = BIT_FIELD_REF <*D.29005, 8, 272>;
    D.29007 = D.29006 & 128;
    if (D.29007 == 0) goto <D.29008>; else goto <D.29009>;
    <D.29008>:
    {
      struct MonoDynCallInfo * info;
      gboolean has_nullable;

      info = mono_arch_dyn_call_prepare (sig);
      has_nullable = 0;
      j = 0;
      goto <D.24692>;
      <D.24691>:
      D.28996 = sig->params[j];
      D.28997 = D.28996->type;
      if (D.28997 == 21) goto <D.29010>; else goto <D.29011>;
      <D.29010>:
      D.28996 = sig->params[j];
      D.29012 = mono_class_from_mono_type (D.28996);
      D.29013 = mono_class_is_nullable (D.29012);
      if (D.29013 != 0) goto <D.29014>; else goto <D.29015>;
      <D.29014>:
      has_nullable = 1;
      <D.29015>:
      <D.29011>:
      j = j + 1;
      <D.24692>:
      D.29003 = sig->param_count;
      D.29004 = (int) D.29003;
      if (D.29004 > j) goto <D.24691>; else goto <D.24693>;
      <D.24693>:
      D.29016 = info != 0B;
      D.29017 = has_nullable == 0;
      D.29018 = D.29016 & D.29017;
      if (D.29018 != 0) goto <D.29019>; else goto <D.29020>;
      <D.29019>:
      skip = 1;
      monoeg_g_free (info);
      <D.29020>:
    }
    <D.29009>:
    if (skip == 0) goto <D.29021>; else goto <D.29022>;
    <D.29021>:
    D.29023 = mono_marshal_get_runtime_invoke (method, 0);
    add_method (acfg, D.29023);
    <D.29022>:
  }
  <D.24685>:
  i = i + 1;
  <D.24695>:
  D.28972 = acfg->image;
  D.29024 = D.28972->tables[6].rows;
  D.29025 = (int) D.29024;
  if (D.29025 > i) goto <D.24694>; else goto <D.24696>;
  <D.24696>:
  {
    size_t __s1_len;
    size_t __s2_len;

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

      D.28972 = acfg->image;
      D.29029 = D.28972->assembly;
      __s2 = D.29029->aname.name;
      D.29030 = "mscorlib";
      D.29031 = MEM[(const unsigned char *)D.29030];
      D.29032 = (int) D.29031;
      D.29033 = *__s2;
      D.29034 = (int) D.29033;
      __result = D.29032 - D.29034;
      {
        D.29035 = __s2_len != 0;
        D.29036 = __result == 0;
        D.29037 = D.29035 & D.29036;
        if (D.29037 != 0) goto <D.29038>; else goto <D.29039>;
        <D.29038>:
        D.29040 = &MEM[(void *)"mscorlib" + 1B];
        D.29041 = *D.29040;
        D.29042 = (int) D.29041;
        D.29043 = __s2 + 1;
        D.29044 = *D.29043;
        D.29045 = (int) D.29044;
        __result = D.29042 - D.29045;
        D.29046 = __s2_len > 1;
        D.29036 = __result == 0;
        D.29047 = D.29046 & D.29036;
        if (D.29047 != 0) goto <D.29048>; else goto <D.29049>;
        <D.29048>:
        D.29050 = &MEM[(void *)"mscorlib" + 2B];
        D.29051 = *D.29050;
        D.29052 = (int) D.29051;
        D.29053 = __s2 + 2;
        D.29054 = *D.29053;
        D.29055 = (int) D.29054;
        __result = D.29052 - D.29055;
        D.29056 = __s2_len > 2;
        D.29036 = __result == 0;
        D.29057 = D.29056 & D.29036;
        if (D.29057 != 0) goto <D.29058>; else goto <D.29059>;
        <D.29058>:
        D.29060 = &MEM[(void *)"mscorlib" + 3B];
        D.29061 = *D.29060;
        D.29062 = (int) D.29061;
        D.29063 = __s2 + 3;
        D.29064 = *D.29063;
        D.29065 = (int) D.29064;
        __result = D.29062 - D.29065;
        <D.29059>:
        <D.29049>:
        <D.29039>:
      }
      D.24704 = __result;
    }
    iftmp.74 = -D.24704;
    goto <D.29066>;
    <D.29028>:
    D.28972 = acfg->image;
    D.29029 = D.28972->assembly;
    D.29067 = D.29029->aname.name;
    iftmp.74 = __builtin_strcmp (D.29067, "mscorlib");
    <D.29066>:
    D.24705 = iftmp.74;
  }
  if (D.24705 == 0) goto <D.29068>; else goto <D.29069>;
  <D.29068>:
  {
    struct MonoMethodDesc * desc;
    struct MonoMethod * orig_method;
    int nallocators;

    D.29070 = mono_defaults.corlib;
    csig = mono_metadata_signature_alloc (D.29070, 0);
    D.29071 = mono_defaults.void_class;
    D.29072 = &D.29071->byval_arg;
    csig->ret = D.29072;
    D.29073 = get_runtime_invoke_sig (csig);
    add_method (acfg, D.29073);
    D.29070 = mono_defaults.corlib;
    csig = mono_metadata_signature_alloc (D.29070, 0);
    csig->hasthis = 1;
    D.29071 = mono_defaults.void_class;
    D.29072 = &D.29071->byval_arg;
    csig->ret = D.29072;
    D.29074 = get_runtime_invoke_sig (csig);
    add_method (acfg, D.29074);
    D.29070 = mono_defaults.corlib;
    csig = mono_metadata_signature_alloc (D.29070, 1);
    csig->hasthis = 1;
    D.29071 = mono_defaults.void_class;
    D.29072 = &D.29071->byval_arg;
    csig->ret = D.29072;
    D.29075 = mono_defaults.string_class;
    D.29076 = &D.29075->byval_arg;
    csig->params[0] = D.29076;
    D.29077 = get_runtime_invoke_sig (csig);
    add_method (acfg, D.29077);
    D.29070 = mono_defaults.corlib;
    csig = mono_metadata_signature_alloc (D.29070, 2);
    csig->hasthis = 1;
    D.29071 = mono_defaults.void_class;
    D.29072 = &D.29071->byval_arg;
    csig->ret = D.29072;
    D.29075 = mono_defaults.string_class;
    D.29076 = &D.29075->byval_arg;
    csig->params[0] = D.29076;
    D.29075 = mono_defaults.string_class;
    D.29076 = &D.29075->byval_arg;
    csig->params[1] = D.29076;
    D.29078 = get_runtime_invoke_sig (csig);
    add_method (acfg, D.29078);
    D.29070 = mono_defaults.corlib;
    csig = mono_metadata_signature_alloc (D.29070, 0);
    csig->hasthis = 1;
    D.29075 = mono_defaults.string_class;
    D.29076 = &D.29075->byval_arg;
    csig->ret = D.29076;
    D.29079 = get_runtime_invoke_sig (csig);
    add_method (acfg, D.29079);
    D.29070 = mono_defaults.corlib;
    csig = mono_metadata_signature_alloc (D.29070, 2);
    csig->hasthis = 1;
    D.29071 = mono_defaults.void_class;
    D.29072 = &D.29071->byval_arg;
    csig->ret = D.29072;
    D.29075 = mono_defaults.string_class;
    D.29076 = &D.29075->byval_arg;
    csig->params[0] = D.29076;
    D.29080 = mono_defaults.exception_class;
    D.29081 = &D.29080->byval_arg;
    csig->params[1] = D.29081;
    D.29082 = get_runtime_invoke_sig (csig);
    add_method (acfg, D.29082);
    D.29070 = mono_defaults.corlib;
    csig = mono_metadata_signature_alloc (D.29070, 2);
    csig->hasthis = 1;
    D.29070 = mono_defaults.corlib;
    D.29083 = mono_class_from_name (D.29070, "System.Reflection", "Assembly");
    D.29084 = &D.29083->byval_arg;
    csig->ret = D.29084;
    D.29075 = mono_defaults.string_class;
    D.29076 = &D.29075->byval_arg;
    csig->params[0] = D.29076;
    D.29085 = mono_defaults.boolean_class;
    D.29086 = &D.29085->byval_arg;
    csig->params[1] = D.29086;
    D.29087 = get_runtime_invoke_sig (csig);
    add_method (acfg, D.29087);
    D.29088 = mono_defaults.object_class;
    D.29089 = mono_class_get_method_from_name_flags (D.29088, "Finalize", 0, 0);
    D.29090 = mono_marshal_get_runtime_invoke (D.29089, 1);
    add_method (acfg, D.29090);
    method = mono_get_context_capture_method ();
    if (method != 0B) goto <D.29091>; else goto <D.29092>;
    <D.29091>:
    D.29093 = mono_marshal_get_runtime_invoke (method, 0);
    add_method (acfg, D.29093);
    <D.29092>:
    D.29094 = mono_marshal_get_runtime_invoke_dynamic ();
    add_method (acfg, D.29094);
    D.29095 = mono_marshal_get_stelemref ();
    add_method (acfg, D.29095);
    D.29096 = mono_amd64_have_tls_get ();
    if (D.29096 != 0) goto <D.29097>; else goto <D.29098>;
    <D.29097>:
    D.29099 = mono_gc_get_managed_allocator_types ();
    nallocators = (int) D.29099;
    i = 0;
    goto <D.24710>;
    <D.24709>:
    m = mono_gc_get_managed_allocator_by_type (i);
    if (m != 0B) goto <D.29100>; else goto <D.29101>;
    <D.29100>:
    add_method (acfg, m);
    <D.29101>:
    i = i + 1;
    <D.24710>:
    if (i < nallocators) goto <D.24709>; else goto <D.24711>;
    <D.24711>:
    desc = mono_method_desc_new ("Monitor:Enter(object,bool&)", 0);
    D.29102 = mono_defaults.monitor_class;
    orig_method = mono_method_desc_search_in_class (desc, D.29102);
    if (orig_method != 0B) goto <D.29103>; else goto <D.29104>;
    <D.29103>:
    method = mono_monitor_get_fast_path (orig_method);
    if (method != 0B) goto <D.29105>; else goto <D.29106>;
    <D.29105>:
    add_method (acfg, method);
    <D.29106>:
    <D.29104>:
    mono_method_desc_free (desc);
    desc = mono_method_desc_new ("Monitor:Exit(object)", 0);
    D.29102 = mono_defaults.monitor_class;
    orig_method = mono_method_desc_search_in_class (desc, D.29102);
    D.29107 = orig_method == 0B;
    D.29108 = (long int) D.29107;
    D.29109 = __builtin_expect (D.29108, 0);
    if (D.29109 != 0) goto <D.29110>; else goto <D.29111>;
    <D.29110>:
    monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "aot-compiler.c", 3370, "orig_method");
    <D.29111>:
    mono_method_desc_free (desc);
    method = mono_monitor_get_fast_path (orig_method);
    if (method != 0B) goto <D.29112>; else goto <D.29113>;
    <D.29112>:
    add_method (acfg, method);
    <D.29113>:
    <D.29098>:
    {
      struct MonoMethod * * wrappers;
      int nwrappers;

      try
        {
          wrappers = mono_marshal_get_virtual_stelemref_wrappers (&nwrappers);
          i = 0;
          goto <D.24715>;
          <D.24714>:
          D.29114 = (long unsigned int) i;
          D.29115 = D.29114 * 8;
          D.29116 = wrappers + D.29115;
          D.29117 = *D.29116;
          add_method (acfg, D.29117);
          i = i + 1;
          <D.24715>:
          nwrappers.75 = nwrappers;
          if (i < nwrappers.75) goto <D.24714>; else goto <D.24716>;
          <D.24716>:
          monoeg_g_free (wrappers);
        }
      finally
        {
          nwrappers = {CLOBBER};
        }
    }
    D.29119 = mono_marshal_get_castclass_with_cache ();
    add_method (acfg, D.29119);
    D.29120 = mono_marshal_get_isinst_with_cache ();
    add_method (acfg, D.29120);
    {
      struct MonoMethodDesc * desc;
      struct MonoMethod * m;

      desc = mono_method_desc_new ("Monitor:Enter(object,bool&)", 0);
      D.29102 = mono_defaults.monitor_class;
      m = mono_method_desc_search_in_class (desc, D.29102);
      mono_method_desc_free (desc);
      if (m != 0B) goto <D.29121>; else goto <D.29122>;
      <D.29121>:
      m = mono_monitor_get_fast_path (m);
      if (m != 0B) goto <D.29123>; else goto <D.29124>;
      <D.29123>:
      add_method (acfg, m);
      <D.29124>:
      <D.29122>:
    }
    D.29125 = mono_get_jit_icall_info ();
    monoeg_g_hash_table_foreach (D.29125, add_jit_icall_wrapper, acfg);
  }
  <D.29069>:
  i = 0;
  goto <D.24748>;
  <D.24747>:
  {
    struct MonoClass * klass;
    struct MonoCustomAttrInfo * cattr;

    D.28970 = i + 1;
    D.29126 = D.28970 | 33554432;
    token = (guint32) D.29126;
    D.28972 = acfg->image;
    klass = mono_class_get (D.28972, token);
    if (klass == 0B) goto <D.29127>; else goto <D.29128>;
    <D.29127>:
    mono_loader_clear_error ();
    // predicted unlikely by continue predictor.
    goto <D.24721>;
    <D.29128>:
    D.29131 = BIT_FIELD_REF <*klass, 8, 280>;
    D.29132 = D.29131 & 1;
    if (D.29132 == 0) goto <D.29129>; else goto <D.29133>;
    <D.29133>:
    D.29134 = mono_defaults.delegate_class;
    if (D.29134 == klass) goto <D.29129>; else goto <D.29135>;
    <D.29135>:
    D.29136 = mono_defaults.multicastdelegate_class;
    if (D.29136 == klass) goto <D.29129>; else goto <D.29130>;
    <D.29129>:
    // predicted unlikely by continue predictor.
    goto <D.24721>;
    <D.29130>:
    D.29137 = klass->generic_container;
    if (D.29137 == 0B) goto <D.29138>; else goto <D.29139>;
    <D.29138>:
    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.29140>; else goto <D.29141>;
    <D.29140>:
    D.29142 = mono_marshal_get_delegate_begin_invoke (method);
    add_method (acfg, D.29142);
    <D.29141>:
    method = mono_class_get_method_from_name_flags (klass, "EndInvoke", -1, 0);
    if (method != 0B) goto <D.29143>; else goto <D.29144>;
    <D.29143>:
    D.29145 = mono_marshal_get_delegate_end_invoke (method);
    add_method (acfg, D.29145);
    <D.29144>:
    cattr = mono_custom_attrs_from_class (klass);
    if (cattr != 0B) goto <D.29146>; else goto <D.29147>;
    <D.29146>:
    {
      int j;

      j = 0;
      goto <D.24743>;
      <D.24742>:
      D.29148 = cattr->attrs[j].ctor;
      if (D.29148 != 0B) goto <D.29149>; else goto <D.29150>;
      <D.29149>:
      {
        size_t __s1_len;
        size_t __s2_len;

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

          D.29148 = cattr->attrs[j].ctor;
          D.29154 = D.29148->klass;
          __s2 = D.29154->name;
          D.29155 = "MonoNativeFunctionWrapperAttribute";
          D.29156 = MEM[(const unsigned char *)D.29155];
          D.29157 = (int) D.29156;
          D.29158 = *__s2;
          D.29159 = (int) D.29158;
          __result = D.29157 - D.29159;
          {
            D.29160 = __s2_len != 0;
            D.29161 = __result == 0;
            D.29162 = D.29160 & D.29161;
            if (D.29162 != 0) goto <D.29163>; else goto <D.29164>;
            <D.29163>:
            D.29165 = &MEM[(void *)"MonoNativeFunctionWrapperAttribute" + 1B];
            D.29166 = *D.29165;
            D.29167 = (int) D.29166;
            D.29168 = __s2 + 1;
            D.29169 = *D.29168;
            D.29170 = (int) D.29169;
            __result = D.29167 - D.29170;
            D.29171 = __s2_len > 1;
            D.29161 = __result == 0;
            D.29172 = D.29171 & D.29161;
            if (D.29172 != 0) goto <D.29173>; else goto <D.29174>;
            <D.29173>:
            D.29175 = &MEM[(void *)"MonoNativeFunctionWrapperAttribute" + 2B];
            D.29176 = *D.29175;
            D.29177 = (int) D.29176;
            D.29178 = __s2 + 2;
            D.29179 = *D.29178;
            D.29180 = (int) D.29179;
            __result = D.29177 - D.29180;
            D.29181 = __s2_len > 2;
            D.29161 = __result == 0;
            D.29182 = D.29181 & D.29161;
            if (D.29182 != 0) goto <D.29183>; else goto <D.29184>;
            <D.29183>:
            D.29185 = &MEM[(void *)"MonoNativeFunctionWrapperAttribute" + 3B];
            D.29186 = *D.29185;
            D.29187 = (int) D.29186;
            D.29188 = __s2 + 3;
            D.29189 = *D.29188;
            D.29190 = (int) D.29189;
            __result = D.29187 - D.29190;
            <D.29184>:
            <D.29174>:
            <D.29164>:
          }
          D.24730 = __result;
        }
        iftmp.76 = -D.24730;
        goto <D.29191>;
        <D.29153>:
        D.29148 = cattr->attrs[j].ctor;
        D.29154 = D.29148->klass;
        D.29192 = D.29154->name;
        iftmp.76 = __builtin_strcmp (D.29192, "MonoNativeFunctionWrapperAttribute");
        <D.29191>:
        D.24731 = iftmp.76;
      }
      if (D.24731 == 0) goto <D.24741>; else goto <D.29193>;
      <D.29193>:
      {
        size_t __s1_len;
        size_t __s2_len;

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

          D.29148 = cattr->attrs[j].ctor;
          D.29154 = D.29148->klass;
          __s2 = D.29154->name;
          D.29197 = "UnmanagedFunctionPointerAttribute";
          D.29198 = MEM[(const unsigned char *)D.29197];
          D.29199 = (int) D.29198;
          D.29200 = *__s2;
          D.29201 = (int) D.29200;
          __result = D.29199 - D.29201;
          {
            D.29202 = __s2_len != 0;
            D.29203 = __result == 0;
            D.29204 = D.29202 & D.29203;
            if (D.29204 != 0) goto <D.29205>; else goto <D.29206>;
            <D.29205>:
            D.29207 = &MEM[(void *)"UnmanagedFunctionPointerAttribute" + 1B];
            D.29208 = *D.29207;
            D.29209 = (int) D.29208;
            D.29210 = __s2 + 1;
            D.29211 = *D.29210;
            D.29212 = (int) D.29211;
            __result = D.29209 - D.29212;
            D.29213 = __s2_len > 1;
            D.29203 = __result == 0;
            D.29214 = D.29213 & D.29203;
            if (D.29214 != 0) goto <D.29215>; else goto <D.29216>;
            <D.29215>:
            D.29217 = &MEM[(void *)"UnmanagedFunctionPointerAttribute" + 2B];
            D.29218 = *D.29217;
            D.29219 = (int) D.29218;
            D.29220 = __s2 + 2;
            D.29221 = *D.29220;
            D.29222 = (int) D.29221;
            __result = D.29219 - D.29222;
            D.29223 = __s2_len > 2;
            D.29203 = __result == 0;
            D.29224 = D.29223 & D.29203;
            if (D.29224 != 0) goto <D.29225>; else goto <D.29226>;
            <D.29225>:
            D.29227 = &MEM[(void *)"UnmanagedFunctionPointerAttribute" + 3B];
            D.29228 = *D.29227;
            D.29229 = (int) D.29228;
            D.29230 = __s2 + 3;
            D.29231 = *D.29230;
            D.29232 = (int) D.29231;
            __result = D.29229 - D.29232;
            <D.29226>:
            <D.29216>:
            <D.29206>:
          }
          D.24739 = __result;
        }
        iftmp.77 = -D.24739;
        goto <D.29233>;
        <D.29196>:
        D.29148 = cattr->attrs[j].ctor;
        D.29154 = D.29148->klass;
        D.29192 = D.29154->name;
        iftmp.77 = __builtin_strcmp (D.29192, "UnmanagedFunctionPointerAttribute");
        <D.29233>:
        D.24740 = iftmp.77;
      }
      if (D.24740 == 0) goto <D.24741>; else goto <D.29234>;
      <D.29234>:
      <D.29150>:
      j = j + 1;
      <D.24743>:
      D.29235 = cattr->num_attrs;
      if (D.29235 > j) goto <D.24742>; else goto <D.24741>;
      <D.24741>:
      D.29235 = cattr->num_attrs;
      if (D.29235 > j) goto <D.29236>; else goto <D.29237>;
      <D.29236>:
      D.29238 = mono_marshal_get_native_func_wrapper_aot (klass);
      add_method (acfg, D.29238);
      <D.29237>:
    }
    <D.29147>:
    goto <D.29239>;
    <D.29139>:
    D.29240 = acfg->opts;
    D.29241 = D.29240 & 16777216;
    if (D.29241 != 0) goto <D.29242>; else goto <D.29243>;
    <D.29242>:
    D.29137 = klass->generic_container;
    if (D.29137 != 0B) goto <D.29244>; else goto <D.29245>;
    <D.29244>:
    {
      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.29246 = BIT_FIELD_REF <*m, 8, 264>;
          D.29247 = D.29246 & 16;
          D.29248 = D.29247 == 0;
          D.29249 = (long int) D.29248;
          D.29250 = __builtin_expect (D.29249, 0);
          if (D.29250 != 0) goto <D.29251>; else goto <D.29252>;
          <D.29251>:
          monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "aot-compiler.c", 3493, "m->is_inflated");
          <D.29252>:
          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.29246 = BIT_FIELD_REF <*m, 8, 264>;
          D.29247 = D.29246 & 16;
          D.29248 = D.29247 == 0;
          D.29249 = (long int) D.29248;
          D.29250 = __builtin_expect (D.29249, 0);
          if (D.29250 != 0) goto <D.29253>; else goto <D.29254>;
          <D.29253>:
          monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "aot-compiler.c", 3505, "m->is_inflated");
          <D.29254>:
          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.29246 = BIT_FIELD_REF <*m, 8, 264>;
          D.29247 = D.29246 & 16;
          D.29248 = D.29247 == 0;
          D.29249 = (long int) D.29248;
          D.29250 = __builtin_expect (D.29249, 0);
          if (D.29250 != 0) goto <D.29255>; else goto <D.29256>;
          <D.29255>:
          monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "aot-compiler.c", 3517, "m->is_inflated");
          <D.29256>:
          gshared = mini_get_shared_method_full (m, 0, 1);
          add_extra_method (acfg, gshared);
        }
      finally
        {
          ctx = {CLOBBER};
        }
    }
    <D.29245>:
    <D.29243>:
    <D.29239>:
  }
  <D.24721>:
  i = i + 1;
  <D.24748>:
  D.28972 = acfg->image;
  D.29257 = D.28972->tables[2].rows;
  D.29258 = (int) D.29257;
  if (D.29258 > i) goto <D.24747>; else goto <D.24749>;
  <D.24749>:
  i = 0;
  goto <D.24755>;
  <D.24754>:
  {
    struct MonoClass * klass;

    D.28970 = i + 1;
    D.29259 = D.28970 | 452984832;
    token = (guint32) D.29259;
    D.28972 = acfg->image;
    klass = mono_class_get (D.28972, token);
    if (klass == 0B) goto <D.29260>; else goto <D.29261>;
    <D.29260>:
    mono_loader_clear_error ();
    // predicted unlikely by continue predictor.
    goto <D.24751>;
    <D.29261>:
    D.29262 = klass->rank;
    if (D.29262 != 0) goto <D.29263>; else goto <D.29264>;
    <D.29263>:
    D.29265 = klass->element_class;
    D.29266 = BIT_FIELD_REF <*D.29265, 8, 1688>;
    D.29267 = D.29266 & 64;
    if (D.29267 == 0) goto <D.29268>; else goto <D.29269>;
    <D.29268>:
    D.29265 = klass->element_class;
    D.29270 = D.29265->byval_arg.type;
    D.29271 = D.29270 + 254;
    D.29272 = D.29271 <= 11;
    D.29273 = D.29270 + 232;
    D.29274 = D.29273 <= 1;
    D.29275 = D.29272 | D.29274;
    if (D.29275 != 0) goto <D.29276>; else goto <D.29277>;
    <D.29276>:
    {
      struct MonoMethod * m;
      struct MonoMethod * wrapper;

      m = mono_class_get_method_from_name (klass, "Get", -1);
      D.29278 = m == 0B;
      D.29279 = (long int) D.29278;
      D.29280 = __builtin_expect (D.29279, 0);
      if (D.29280 != 0) goto <D.29281>; else goto <D.29282>;
      <D.29281>:
      monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "aot-compiler.c", 3543, "m");
      <D.29282>:
      wrapper = mono_marshal_get_array_accessor_wrapper (m);
      add_extra_method (acfg, wrapper);
      D.29283 = mono_marshal_get_runtime_invoke (wrapper, 0);
      add_extra_method (acfg, D.29283);
      m = mono_class_get_method_from_name (klass, "Set", -1);
      D.29278 = m == 0B;
      D.29279 = (long int) D.29278;
      D.29280 = __builtin_expect (D.29279, 0);
      if (D.29280 != 0) goto <D.29284>; else goto <D.29285>;
      <D.29284>:
      monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "aot-compiler.c", 3549, "m");
      <D.29285>:
      wrapper = mono_marshal_get_array_accessor_wrapper (m);
      add_extra_method (acfg, wrapper);
      D.29286 = mono_marshal_get_runtime_invoke (wrapper, 0);
      add_extra_method (acfg, D.29286);
    }
    <D.29277>:
    <D.29269>:
    <D.29264>:
  }
  <D.24751>:
  i = i + 1;
  <D.24755>:
  D.28972 = acfg->image;
  D.29287 = D.28972->tables[27].rows;
  D.29288 = (int) D.29287;
  if (D.29288 > i) goto <D.24754>; else goto <D.24756>;
  <D.24756>:
  i = 0;
  goto <D.24762>;
  <D.24761>:
  D.28970 = i + 1;
  D.28971 = D.28970 | 100663296;
  token = (guint32) D.28971;
  D.28972 = acfg->image;
  method = mono_get_method (D.28972, token, 0B);
  D.29289 = method->iflags;
  D.29290 = (int) D.29289;
  D.29291 = D.29290 & 32;
  if (D.29291 != 0) goto <D.29292>; else goto <D.29293>;
  <D.29292>:
  D.29294 = BIT_FIELD_REF <*method, 8, 264>;
  D.29295 = D.29294 & 8;
  if (D.29295 != 0) goto <D.29296>; else goto <D.29297>;
  <D.29296>:
  goto <D.29298>;
  <D.29297>:
  D.29299 = method->klass;
  D.29300 = D.29299->generic_container;
  if (D.29300 != 0B) goto <D.29301>; else goto <D.29302>;
  <D.29301>:
  {
    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.29303 = BIT_FIELD_REF <*m, 8, 264>;
        D.29304 = D.29303 & 16;
        D.29305 = D.29304 == 0;
        D.29306 = (long int) D.29305;
        D.29307 = __builtin_expect (D.29306, 0);
        if (D.29307 != 0) goto <D.29308>; else goto <D.29309>;
        <D.29308>:
        monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "aot-compiler.c", 3574, "m->is_inflated");
        <D.29309>:
        gshared = mini_get_shared_method_full (m, 0, 1);
        add_method (acfg, gshared);
      }
    finally
      {
        ctx = {CLOBBER};
      }
  }
  goto <D.29310>;
  <D.29302>:
  D.29311 = mono_marshal_get_synchronized_wrapper (method);
  add_method (acfg, D.29311);
  <D.29310>:
  <D.29298>:
  <D.29293>:
  i = i + 1;
  <D.24762>:
  D.28972 = acfg->image;
  D.29024 = D.28972->tables[6].rows;
  D.29025 = (int) D.29024;
  if (D.29025 > i) goto <D.24761>; else goto <D.24763>;
  <D.24763>:
  i = 0;
  goto <D.24767>;
  <D.24766>:
  {
    struct MonoMethod * method;
    guint32 token;

    D.28970 = i + 1;
    D.28971 = D.28970 | 100663296;
    token = (guint32) D.28971;
    D.28972 = acfg->image;
    method = mono_get_method (D.28972, token, 0B);
    D.29314 = method->flags;
    D.29315 = (int) D.29314;
    D.29316 = D.29315 & 8192;
    if (D.29316 != 0) goto <D.29312>; else goto <D.29317>;
    <D.29317>:
    D.29318 = method->iflags;
    D.29319 = (int) D.29318;
    D.29320 = D.29319 & 4096;
    if (D.29320 != 0) goto <D.29312>; else goto <D.29313>;
    <D.29312>:
    D.29321 = mono_marshal_get_native_wrapper (method, 1, 1);
    add_method (acfg, D.29321);
    <D.29313>:
  }
  i = i + 1;
  <D.24767>:
  D.28972 = acfg->image;
  D.29024 = D.28972->tables[6].rows;
  D.29025 = (int) D.29024;
  if (D.29025 > i) goto <D.24766>; else goto <D.24768>;
  <D.24768>:
  i = 0;
  goto <D.24820>;
  <D.24819>:
  {
    struct MonoMethod * method;
    guint32 token;
    struct MonoCustomAttrInfo * cattr;
    int j;

    D.28970 = i + 1;
    D.28971 = D.28970 | 100663296;
    token = (guint32) D.28971;
    D.28972 = acfg->image;
    method = mono_get_method (D.28972, token, 0B);
    cattr = mono_custom_attrs_from_method (method);
    if (cattr != 0B) goto <D.29322>; else goto <D.29323>;
    <D.29322>:
    j = 0;
    goto <D.24784>;
    <D.24783>:
    D.29324 = cattr->attrs[j].ctor;
    if (D.29324 != 0B) goto <D.29325>; else goto <D.29326>;
    <D.29325>:
    {
      size_t __s1_len;
      size_t __s2_len;

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

        D.29324 = cattr->attrs[j].ctor;
        D.29330 = D.29324->klass;
        __s2 = D.29330->name;
        D.29331 = "MonoPInvokeCallbackAttribute";
        D.29332 = MEM[(const unsigned char *)D.29331];
        D.29333 = (int) D.29332;
        D.29334 = *__s2;
        D.29335 = (int) D.29334;
        __result = D.29333 - D.29335;
        {
          D.29336 = __s2_len != 0;
          D.29337 = __result == 0;
          D.29338 = D.29336 & D.29337;
          if (D.29338 != 0) goto <D.29339>; else goto <D.29340>;
          <D.29339>:
          D.29341 = &MEM[(void *)"MonoPInvokeCallbackAttribute" + 1B];
          D.29342 = *D.29341;
          D.29343 = (int) D.29342;
          D.29344 = __s2 + 1;
          D.29345 = *D.29344;
          D.29346 = (int) D.29345;
          __result = D.29343 - D.29346;
          D.29347 = __s2_len > 1;
          D.29337 = __result == 0;
          D.29348 = D.29347 & D.29337;
          if (D.29348 != 0) goto <D.29349>; else goto <D.29350>;
          <D.29349>:
          D.29351 = &MEM[(void *)"MonoPInvokeCallbackAttribute" + 2B];
          D.29352 = *D.29351;
          D.29353 = (int) D.29352;
          D.29354 = __s2 + 2;
          D.29355 = *D.29354;
          D.29356 = (int) D.29355;
          __result = D.29353 - D.29356;
          D.29357 = __s2_len > 2;
          D.29337 = __result == 0;
          D.29358 = D.29357 & D.29337;
          if (D.29358 != 0) goto <D.29359>; else goto <D.29360>;
          <D.29359>:
          D.29361 = &MEM[(void *)"MonoPInvokeCallbackAttribute" + 3B];
          D.29362 = *D.29361;
          D.29363 = (int) D.29362;
          D.29364 = __s2 + 3;
          D.29365 = *D.29364;
          D.29366 = (int) D.29365;
          __result = D.29363 - D.29366;
          <D.29360>:
          <D.29350>:
          <D.29340>:
        }
        D.24780 = __result;
      }
      iftmp.78 = -D.24780;
      goto <D.29367>;
      <D.29329>:
      D.29324 = cattr->attrs[j].ctor;
      D.29330 = D.29324->klass;
      D.29368 = D.29330->name;
      iftmp.78 = __builtin_strcmp (D.29368, "MonoPInvokeCallbackAttribute");
      <D.29367>:
      D.24781 = iftmp.78;
    }
    if (D.24781 == 0) goto <D.24782>; else goto <D.29369>;
    <D.29369>:
    <D.29326>:
    j = j + 1;
    <D.24784>:
    D.29370 = cattr->num_attrs;
    if (D.29370 > j) goto <D.24783>; else goto <D.24782>;
    <D.24782>:
    D.29370 = cattr->num_attrs;
    if (D.29370 > j) goto <D.29371>; else goto <D.29372>;
    <D.29371>:
    {
      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.29373 = e->ctor;
          sig = mono_method_signature (D.29373);
          p.79 = e->data;
          p = p.79;
          export_name = 0B;
          D.29375 = method->flags;
          D.29376 = (int) D.29375;
          D.29377 = D.29376 & 16;
          if (D.29377 == 0) goto <D.29378>; else goto <D.29379>;
          <D.29378>:
          D.29380 = 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.29380);
          exit (1);
          <D.29379>:
          D.29381 = sig->param_count;
          D.29382 = D.29381 != 1;
          D.29383 = (long int) D.29382;
          D.29384 = __builtin_expect (D.29383, 0);
          if (D.29384 != 0) goto <D.29385>; else goto <D.29386>;
          <D.29385>:
          monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "aot-compiler.c", 3635, "sig->param_count == 1");
          <D.29386>:
          D.29391 = sig->params[0];
          D.29392 = D.29391->type;
          if (D.29392 != 18) goto <D.29388>; else goto <D.29393>;
          <D.29393>:
          {
            size_t __s1_len;
            size_t __s2_len;

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

              D.29391 = sig->params[0];
              D.29397 = mono_class_from_mono_type (D.29391);
              __s2 = D.29397->name;
              D.29398 = "Type";
              D.29399 = MEM[(const unsigned char *)D.29398];
              D.29400 = (int) D.29399;
              D.29401 = *__s2;
              D.29402 = (int) D.29401;
              __result = D.29400 - D.29402;
              {
                D.29403 = __s2_len != 0;
                D.29404 = __result == 0;
                D.29405 = D.29403 & D.29404;
                if (D.29405 != 0) goto <D.29406>; else goto <D.29407>;
                <D.29406>:
                D.29408 = &MEM[(void *)"Type" + 1B];
                D.29409 = *D.29408;
                D.29410 = (int) D.29409;
                D.29411 = __s2 + 1;
                D.29412 = *D.29411;
                D.29413 = (int) D.29412;
                __result = D.29410 - D.29413;
                D.29414 = __s2_len > 1;
                D.29404 = __result == 0;
                D.29415 = D.29414 & D.29404;
                if (D.29415 != 0) goto <D.29416>; else goto <D.29417>;
                <D.29416>:
                D.29418 = &MEM[(void *)"Type" + 2B];
                D.29419 = *D.29418;
                D.29420 = (int) D.29419;
                D.29421 = __s2 + 2;
                D.29422 = *D.29421;
                D.29423 = (int) D.29422;
                __result = D.29420 - D.29423;
                D.29424 = __s2_len > 2;
                D.29404 = __result == 0;
                D.29425 = D.29424 & D.29404;
                if (D.29425 != 0) goto <D.29426>; else goto <D.29427>;
                <D.29426>:
                D.29428 = &MEM[(void *)"Type" + 3B];
                D.29429 = *D.29428;
                D.29430 = (int) D.29429;
                D.29431 = __s2 + 3;
                D.29432 = *D.29431;
                D.29433 = (int) D.29432;
                __result = D.29430 - D.29433;
                <D.29427>:
                <D.29417>:
                <D.29407>:
              }
              D.24805 = __result;
            }
            iftmp.81 = -D.24805;
            goto <D.29434>;
            <D.29396>:
            D.29391 = sig->params[0];
            D.29435 = mono_class_from_mono_type (D.29391);
            D.29436 = D.29435->name;
            iftmp.81 = __builtin_strcmp (D.29436, "Type");
            <D.29434>:
            D.24806 = iftmp.81;
          }
          if (D.24806 != 0) goto <D.29388>; else goto <D.29389>;
          <D.29388>:
          iftmp.80 = 1;
          goto <D.29390>;
          <D.29389>:
          iftmp.80 = 0;
          <D.29390>:
          D.29437 = iftmp.80 != 0;
          D.29438 = (long int) D.29437;
          D.29439 = __builtin_expect (D.29438, 0);
          if (D.29439 != 0) goto <D.29440>; else goto <D.29441>;
          <D.29440>:
          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.29441>:
          p.82 = p;
          p.83 = p.82 + 2;
          p = p.83;
          p.82 = p;
          D.29444 = mono_metadata_decode_value (p.82, &p);
          slen = (int) D.29444;
          D.29445 = slen + 1;
          D.29446 = (unsigned int) D.29445;
          p.82 = p;
          n = monoeg_g_memdup (p.82, D.29446);
          D.29447 = (sizetype) slen;
          D.29448 = n + D.29447;
          *D.29448 = 0;
          D.28972 = acfg->image;
          t = mono_reflection_type_from_name (n, D.28972);
          D.29449 = t == 0B;
          D.29450 = (long int) D.29449;
          D.29451 = __builtin_expect (D.29450, 0);
          if (D.29451 != 0) goto <D.29452>; else goto <D.29453>;
          <D.29452>:
          monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "aot-compiler.c", 3651, "t");
          <D.29453>:
          monoeg_g_free (n);
          klass = mono_class_from_mono_type (t);
          D.29454 = klass->parent;
          D.29136 = mono_defaults.multicastdelegate_class;
          D.29455 = D.29454 != D.29136;
          D.29456 = (long int) D.29455;
          D.29457 = __builtin_expect (D.29456, 0);
          if (D.29457 != 0) goto <D.29458>; else goto <D.29459>;
          <D.29458>:
          monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "aot-compiler.c", 3655, "klass->parent == mono_defaults.multicastdelegate_class");
          <D.29459>:
          p.82 = p;
          D.29447 = (sizetype) slen;
          p.84 = p.82 + D.29447;
          p = p.84;
          p.82 = p;
          D.29461 = MEM[(const guint16 *)p.82];
          num_named = (int) D.29461;
          p.82 = p;
          p.83 = p.82 + 2;
          p = p.83;
          D.29462 = num_named > 1;
          D.29463 = (long int) D.29462;
          D.29464 = __builtin_expect (D.29463, 0);
          if (D.29464 != 0) goto <D.29465>; else goto <D.29466>;
          <D.29465>:
          monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "aot-compiler.c", 3662, "num_named < 2");
          <D.29466>:
          if (num_named == 1) goto <D.29467>; else goto <D.29468>;
          <D.29467>:
          {
            int name_len;
            char * name;
            struct MonoType * prop_type;

            p.82 = p;
            named = p.82;
            named.85 = named;
            D.29470 = *named.85;
            named_type = (int) D.29470;
            named.85 = named;
            named.86 = named.85 + 1;
            named = named.86;
            named.85 = named;
            D.29470 = *named.85;
            data_type = (int) D.29470;
            named.85 = named;
            named.86 = named.85 + 1;
            named = named.86;
            named.85 = named;
            D.29472 = mono_metadata_decode_blob_size (named.85, &named);
            name_len = (int) D.29472;
            D.29473 = name_len + 1;
            D.29474 = (long unsigned int) D.29473;
            name = monoeg_malloc (D.29474);
            D.29475 = (long unsigned int) name_len;
            named.85 = named;
            memcpy (name, named.85, D.29475);
            D.29476 = (sizetype) name_len;
            D.29477 = name + D.29476;
            *D.29477 = 0;
            named.85 = named;
            D.29476 = (sizetype) name_len;
            named.87 = named.85 + D.29476;
            named = named.87;
            D.29479 = named_type != 84;
            D.29480 = (long int) D.29479;
            D.29481 = __builtin_expect (D.29480, 0);
            if (D.29481 != 0) goto <D.29482>; else goto <D.29483>;
            <D.29482>:
            monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "aot-compiler.c", 3681, "named_type == 0x54");
            <D.29483>:
            {
              size_t __s1_len;
              size_t __s2_len;

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

                __s2 = name;
                D.29487 = "ExportSymbol";
                D.29488 = MEM[(const unsigned char *)D.29487];
                D.29489 = (int) D.29488;
                D.29490 = *__s2;
                D.29491 = (int) D.29490;
                __result = D.29489 - D.29491;
                {
                  D.29492 = __s2_len != 0;
                  D.29493 = __result == 0;
                  D.29494 = D.29492 & D.29493;
                  if (D.29494 != 0) goto <D.29495>; else goto <D.29496>;
                  <D.29495>:
                  D.29497 = &MEM[(void *)"ExportSymbol" + 1B];
                  D.29498 = *D.29497;
                  D.29499 = (int) D.29498;
                  D.29500 = __s2 + 1;
                  D.29501 = *D.29500;
                  D.29502 = (int) D.29501;
                  __result = D.29499 - D.29502;
                  D.29503 = __s2_len > 1;
                  D.29493 = __result == 0;
                  D.29504 = D.29503 & D.29493;
                  if (D.29504 != 0) goto <D.29505>; else goto <D.29506>;
                  <D.29505>:
                  D.29507 = &MEM[(void *)"ExportSymbol" + 2B];
                  D.29508 = *D.29507;
                  D.29509 = (int) D.29508;
                  D.29510 = __s2 + 2;
                  D.29511 = *D.29510;
                  D.29512 = (int) D.29511;
                  __result = D.29509 - D.29512;
                  D.29513 = __s2_len > 2;
                  D.29493 = __result == 0;
                  D.29514 = D.29513 & D.29493;
                  if (D.29514 != 0) goto <D.29515>; else goto <D.29516>;
                  <D.29515>:
                  D.29517 = &MEM[(void *)"ExportSymbol" + 3B];
                  D.29518 = *D.29517;
                  D.29519 = (int) D.29518;
                  D.29520 = __s2 + 3;
                  D.29521 = *D.29520;
                  D.29522 = (int) D.29521;
                  __result = D.29519 - D.29522;
                  <D.29516>:
                  <D.29506>:
                  <D.29496>:
                }
                D.24817 = __result;
              }
              iftmp.88 = -D.24817;
              goto <D.29523>;
              <D.29486>:
              iftmp.88 = __builtin_strcmp (name, "ExportSymbol");
              <D.29523>:
              D.24818 = iftmp.88;
            }
            D.29524 = D.24818 != 0;
            D.29525 = (long int) D.29524;
            D.29526 = __builtin_expect (D.29525, 0);
            if (D.29526 != 0) goto <D.29527>; else goto <D.29528>;
            <D.29527>:
            monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "aot-compiler.c", 3682, "!strcmp (name, \"ExportSymbol\")");
            <D.29528>:
            D.29075 = mono_defaults.string_class;
            prop_type = &D.29075->byval_arg;
            named.85 = named;
            D.29470 = *named.85;
            D.29529 = D.29470 == -1;
            D.29530 = (long int) D.29529;
            D.29531 = __builtin_expect (D.29530, 0);
            if (D.29531 != 0) goto <D.29532>; else goto <D.29533>;
            <D.29532>:
            monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "aot-compiler.c", 3687, "*named != (char)0xff");
            <D.29533>:
            named.85 = named;
            D.29534 = mono_metadata_decode_value (named.85, &named);
            slen = (int) D.29534;
            D.29445 = slen + 1;
            D.29535 = (long unsigned int) D.29445;
            export_name = monoeg_malloc (D.29535);
            D.29536 = (long unsigned int) slen;
            named.85 = named;
            memcpy (export_name, named.85, D.29536);
            D.29447 = (sizetype) slen;
            D.29537 = export_name + D.29447;
            *D.29537 = 0;
            named.85 = named;
            D.29447 = (sizetype) slen;
            named.89 = named.85 + D.29447;
            named = named.89;
          }
          <D.29468>:
          wrapper = mono_marshal_get_managed_wrapper (method, klass, 0);
          add_method (acfg, wrapper);
          if (export_name != 0B) goto <D.29539>; else goto <D.29540>;
          <D.29539>:
          D.29541 = acfg->export_names;
          monoeg_g_hash_table_insert_replace (D.29541, wrapper, export_name, 0);
          <D.29540>:
        }
      finally
        {
          p = {CLOBBER};
          named = {CLOBBER};
        }
    }
    <D.29372>:
    <D.29323>:
    D.29375 = method->flags;
    D.29376 = (int) D.29375;
    D.29544 = D.29376 & 8192;
    if (D.29544 != 0) goto <D.29542>; else goto <D.29545>;
    <D.29545>:
    D.29546 = method->iflags;
    D.29547 = (int) D.29546;
    D.29548 = D.29547 & 4096;
    if (D.29548 != 0) goto <D.29542>; else goto <D.29543>;
    <D.29542>:
    D.29549 = mono_marshal_get_native_wrapper (method, 1, 1);
    add_method (acfg, D.29549);
    <D.29543>:
  }
  i = i + 1;
  <D.24820>:
  D.28972 = acfg->image;
  D.29024 = D.28972->tables[6].rows;
  D.29025 = (int) D.29024;
  if (D.29025 > i) goto <D.24819>; else goto <D.24821>;
  <D.24821>:
  i = 0;
  goto <D.24825>;
  <D.24824>:
  {
    struct MonoClass * klass;

    D.28970 = i + 1;
    D.29126 = D.28970 | 33554432;
    token = (guint32) D.29126;
    D.28972 = acfg->image;
    klass = mono_class_get (D.28972, token);
    if (klass == 0B) goto <D.29550>; else goto <D.29551>;
    <D.29550>:
    mono_loader_clear_error ();
    // predicted unlikely by continue predictor.
    goto <D.24823>;
    <D.29551>:
    D.29554 = BIT_FIELD_REF <*klass, 8, 256>;
    D.29555 = D.29554 & 8;
    if (D.29555 != 0) goto <D.29556>; else goto <D.29557>;
    <D.29556>:
    D.29558 = klass->generic_container;
    if (D.29558 == 0B) goto <D.29559>; else goto <D.29560>;
    <D.29559>:
    D.29561 = can_marshal_struct (klass);
    if (D.29561 != 0) goto <D.29562>; else goto <D.29563>;
    <D.29562>:
    D.29564 = klass->nested_in;
    if (D.29564 == 0B) goto <D.29552>; else goto <D.29565>;
    <D.29565>:
    D.29564 = klass->nested_in;
    D.29566 = D.29564->name;
    D.29567 = strstr (D.29566, "<PrivateImplementationDetails>");
    D.29564 = klass->nested_in;
    D.29566 = D.29564->name;
    if (D.29567 != D.29566) goto <D.29552>; else goto <D.29553>;
    <D.29552>:
    D.29568 = mono_marshal_get_struct_to_ptr (klass);
    add_method (acfg, D.29568);
    D.29569 = mono_marshal_get_ptr_to_struct (klass);
    add_method (acfg, D.29569);
    <D.29553>:
    <D.29563>:
    <D.29560>:
    <D.29557>:
  }
  <D.24823>:
  i = i + 1;
  <D.24825>:
  D.28972 = acfg->image;
  D.29257 = D.28972->tables[2].rows;
  D.29258 = (int) D.29257;
  if (D.29258 > i) goto <D.24824>; else goto <D.24826>;
  <D.24826>:
}


add_jit_icall_wrapper (void * key, void * value, void * user_data)
{
  struct MonoMethodSignature * D.29570;
  const char * D.29573;
  int check_for_pending_exc.90;
  const void * D.29575;
  struct MonoAotCompile * acfg;
  struct MonoJitICallInfo * callinfo;
  struct MonoMethod * wrapper;
  char * name;

  acfg = user_data;
  callinfo = value;
  D.29570 = callinfo->sig;
  if (D.29570 == 0B) goto <D.29571>; else goto <D.29572>;
  <D.29571>:
  return;
  <D.29572>:
  D.29573 = callinfo->name;
  name = monoeg_g_strdup_printf ("__icall_wrapper_%s", D.29573);
  check_for_pending_exc.90 = check_for_pending_exc;
  D.29575 = callinfo->func;
  D.29570 = callinfo->sig;
  wrapper = mono_marshal_get_icall_wrapper (D.29570, name, D.29575, check_for_pending_exc.90);
  monoeg_g_free (name);
  add_method (acfg, wrapper);
}


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

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


create_gsharedvt_inst (struct MonoAotCompile * acfg, struct MonoMethod * method, struct MonoGenericContext * ctx)
{
  struct MonoClass * D.29580;
  struct MonoGenericContainer * D.29581;
  <unnamed-unsigned:22> D.29584;
  long unsigned int D.29585;
  long unsigned int D.29586;
  long unsigned int D.29587;
  long unsigned int D.29588;
  struct MonoType * * D.29589;
  struct MonoClass * D.29590;
  struct MonoType * D.29591;
  int D.29592;
  struct MonoGenericInst * D.29593;
  unsigned char D.29594;
  unsigned char D.29595;
  struct MonoGenericParamFull * D.29598;
  long unsigned int D.29599;
  struct MonoGenericParamFull * D.29600;
  struct MonoClass * * D.29603;
  struct MonoClass * D.29608;
  struct MonoImage * D.29611;
  struct MonoImage * D.29612;
  int D.24665;
  int iftmp.91;
  int D.24664;
  const char[10] * D.29617;
  unsigned char D.29618;
  int D.29619;
  unsigned char D.29620;
  int D.29621;
  _Bool D.29622;
  _Bool D.29623;
  _Bool D.29624;
  const unsigned char * D.29627;
  unsigned char D.29628;
  int D.29629;
  const unsigned char * D.29630;
  unsigned char D.29631;
  int D.29632;
  _Bool D.29633;
  _Bool D.29634;
  const unsigned char * D.29637;
  unsigned char D.29638;
  int D.29639;
  const unsigned char * D.29640;
  unsigned char D.29641;
  int D.29642;
  _Bool D.29643;
  _Bool D.29644;
  const unsigned char * D.29647;
  unsigned char D.29648;
  int D.29649;
  const unsigned char * D.29650;
  unsigned char D.29651;
  int D.29652;
  const char * D.29654;
  struct MonoClass * D.29655;
  struct MonoType * D.29658;
  <unnamed-signed:31> D.29660;
  int D.29661;
  struct MonoGenericInst * D.29662;
  struct MonoGenericContext shared_context;
  struct MonoType * * args;
  struct MonoGenericInst * inst;
  struct MonoGenericContainer * container;
  struct MonoClass * * constraints;
  int i;

  try
    {
      memset (ctx, 0, 16);
      D.29580 = method->klass;
      D.29581 = D.29580->generic_container;
      if (D.29581 != 0B) goto <D.29582>; else goto <D.29583>;
      <D.29582>:
      D.29580 = method->klass;
      D.29581 = D.29580->generic_container;
      shared_context = D.29581->context;
      inst = shared_context.class_inst;
      D.29584 = inst->type_argc;
      D.29585 = (long unsigned int) D.29584;
      D.29586 = D.29585 * 8;
      args = monoeg_malloc0 (D.29586);
      i = 0;
      goto <D.24652>;
      <D.24651>:
      D.29587 = (long unsigned int) i;
      D.29588 = D.29587 * 8;
      D.29589 = args + D.29588;
      D.29590 = mono_defaults.int_class;
      D.29591 = &D.29590->byval_arg;
      *D.29589 = D.29591;
      i = i + 1;
      <D.24652>:
      D.29584 = inst->type_argc;
      D.29592 = (int) D.29584;
      if (D.29592 > i) goto <D.24651>; else goto <D.24653>;
      <D.24653>:
      D.29584 = inst->type_argc;
      D.29592 = (int) D.29584;
      D.29593 = mono_metadata_get_generic_inst (D.29592, args);
      ctx->class_inst = D.29593;
      <D.29583>:
      D.29594 = BIT_FIELD_REF <*method, 8, 264>;
      D.29595 = D.29594 & 8;
      if (D.29595 != 0) goto <D.29596>; else goto <D.29597>;
      <D.29596>:
      container = mono_method_get_generic_container (method);
      shared_context = container->context;
      inst = shared_context.method_inst;
      D.29584 = inst->type_argc;
      D.29585 = (long unsigned int) D.29584;
      D.29586 = D.29585 * 8;
      args = monoeg_malloc0 (D.29586);
      i = 0;
      goto <D.24670>;
      <D.24669>:
      {
        struct MonoGenericParamInfo * info;
        gboolean ref_only;

        D.29598 = container->type_params;
        D.29587 = (long unsigned int) i;
        D.29599 = D.29587 * 56;
        D.29600 = D.29598 + D.29599;
        info = &D.29600->info;
        ref_only = 0;
        if (info != 0B) goto <D.29601>; else goto <D.29602>;
        <D.29601>:
        D.29603 = info->constraints;
        if (D.29603 != 0B) goto <D.29604>; else goto <D.29605>;
        <D.29604>:
        constraints = info->constraints;
        goto <D.24667>;
        <D.24666>:
        {
          struct MonoClass * cklass;

          cklass = *constraints;
          D.29608 = mono_defaults.object_class;
          if (D.29608 != cklass) goto <D.29609>; else goto <D.29610>;
          <D.29609>:
          D.29611 = cklass->image;
          D.29612 = mono_defaults.corlib;
          if (D.29611 != D.29612) goto <D.29606>; else goto <D.29613>;
          <D.29613>:
          {
            size_t __s1_len;
            size_t __s2_len;

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

              __s2 = cklass->name;
              D.29617 = "ValueType";
              D.29618 = MEM[(const unsigned char *)D.29617];
              D.29619 = (int) D.29618;
              D.29620 = *__s2;
              D.29621 = (int) D.29620;
              __result = D.29619 - D.29621;
              {
                D.29622 = __s2_len != 0;
                D.29623 = __result == 0;
                D.29624 = D.29622 & D.29623;
                if (D.29624 != 0) goto <D.29625>; else goto <D.29626>;
                <D.29625>:
                D.29627 = &MEM[(void *)"ValueType" + 1B];
                D.29628 = *D.29627;
                D.29629 = (int) D.29628;
                D.29630 = __s2 + 1;
                D.29631 = *D.29630;
                D.29632 = (int) D.29631;
                __result = D.29629 - D.29632;
                D.29633 = __s2_len > 1;
                D.29623 = __result == 0;
                D.29634 = D.29633 & D.29623;
                if (D.29634 != 0) goto <D.29635>; else goto <D.29636>;
                <D.29635>:
                D.29637 = &MEM[(void *)"ValueType" + 2B];
                D.29638 = *D.29637;
                D.29639 = (int) D.29638;
                D.29640 = __s2 + 2;
                D.29641 = *D.29640;
                D.29642 = (int) D.29641;
                __result = D.29639 - D.29642;
                D.29643 = __s2_len > 2;
                D.29623 = __result == 0;
                D.29644 = D.29643 & D.29623;
                if (D.29644 != 0) goto <D.29645>; else goto <D.29646>;
                <D.29645>:
                D.29647 = &MEM[(void *)"ValueType" + 3B];
                D.29648 = *D.29647;
                D.29649 = (int) D.29648;
                D.29650 = __s2 + 3;
                D.29651 = *D.29650;
                D.29652 = (int) D.29651;
                __result = D.29649 - D.29652;
                <D.29646>:
                <D.29636>:
                <D.29626>:
              }
              D.24664 = __result;
            }
            iftmp.91 = -D.24664;
            goto <D.29653>;
            <D.29616>:
            D.29654 = cklass->name;
            iftmp.91 = __builtin_strcmp (D.29654, "ValueType");
            <D.29653>:
            D.24665 = iftmp.91;
          }
          if (D.24665 != 0) goto <D.29606>; else goto <D.29607>;
          <D.29606>:
          ref_only = 1;
          <D.29607>:
          <D.29610>:
          constraints = constraints + 8;
        }
        <D.24667>:
        D.29655 = *constraints;
        if (D.29655 != 0B) goto <D.24666>; else goto <D.24668>;
        <D.24668>:
        <D.29605>:
        <D.29602>:
        if (ref_only != 0) goto <D.29656>; else goto <D.29657>;
        <D.29656>:
        D.29587 = (long unsigned int) i;
        D.29588 = D.29587 * 8;
        D.29589 = args + D.29588;
        D.29608 = mono_defaults.object_class;
        D.29658 = &D.29608->byval_arg;
        *D.29589 = D.29658;
        goto <D.29659>;
        <D.29657>:
        D.29587 = (long unsigned int) i;
        D.29588 = D.29587 * 8;
        D.29589 = args + D.29588;
        D.29590 = mono_defaults.int_class;
        D.29591 = &D.29590->byval_arg;
        *D.29589 = D.29591;
        <D.29659>:
      }
      i = i + 1;
      <D.24670>:
      D.29660 = container->type_argc;
      D.29661 = (int) D.29660;
      if (D.29661 > i) goto <D.24669>; else goto <D.24671>;
      <D.24671>:
      D.29584 = inst->type_argc;
      D.29592 = (int) D.29584;
      D.29662 = mono_metadata_get_generic_inst (D.29592, args);
      ctx->method_inst = D.29662;
      <D.29597>:
    }
  finally
    {
      shared_context = {CLOBBER};
    }
}


can_marshal_struct (struct MonoClass * klass)
{
  unsigned int D.29663;
  unsigned int D.29664;
  gboolean D.29667;
  struct MonoType * D.29668;
  short unsigned int D.29669;
  int D.29670;
  int D.29671;
  unsigned char D.29674;
  int D.29675;
  struct MonoClass * D.29676;
  unsigned char D.29677;
  unsigned char D.29678;
  struct MonoClass * D.29681;
  int D.29682;
  struct MonoClassField * D.29687;
  struct MonoMarshalSpec * D.29690;
  unsigned int i.92;
  unsigned int D.29694;
  int D.24630;
  int iftmp.93;
  int D.24629;
  const char[43] * D.29700;
  unsigned char D.29701;
  int D.29702;
  unsigned char D.29703;
  int D.29704;
  _Bool D.29705;
  _Bool D.29706;
  _Bool D.29707;
  const unsigned char * D.29710;
  unsigned char D.29711;
  int D.29712;
  const unsigned char * D.29713;
  unsigned char D.29714;
  int D.29715;
  _Bool D.29716;
  _Bool D.29717;
  const unsigned char * D.29720;
  unsigned char D.29721;
  int D.29722;
  const unsigned char * D.29723;
  unsigned char D.29724;
  int D.29725;
  _Bool D.29726;
  _Bool D.29727;
  const unsigned char * D.29730;
  unsigned char D.29731;
  int D.29732;
  const unsigned char * D.29733;
  unsigned char D.29734;
  int D.29735;
  const char * D.29737;
  int D.24639;
  int iftmp.94;
  int D.24638;
  const char[12] * D.29743;
  unsigned char D.29744;
  int D.29745;
  unsigned char D.29746;
  int D.29747;
  _Bool D.29748;
  _Bool D.29749;
  _Bool D.29750;
  const unsigned char * D.29753;
  unsigned char D.29754;
  int D.29755;
  const unsigned char * D.29756;
  unsigned char D.29757;
  int D.29758;
  _Bool D.29759;
  _Bool D.29760;
  const unsigned char * D.29763;
  unsigned char D.29764;
  int D.29765;
  const unsigned char * D.29766;
  unsigned char D.29767;
  int D.29768;
  _Bool D.29769;
  _Bool D.29770;
  const unsigned char * D.29773;
  unsigned char D.29774;
  int D.29775;
  const unsigned char * D.29776;
  unsigned char D.29777;
  int D.29778;
  const char * D.29780;
  struct MonoClassField * field;
  gboolean can_marshal;
  void * iter;
  struct MonoMarshalType * info;
  int i;

  try
    {
      can_marshal = 1;
      iter = 0B;
      D.29663 = klass->flags;
      D.29664 = D.29663 & 24;
      if (D.29664 == 0) goto <D.29665>; else goto <D.29666>;
      <D.29665>:
      D.29667 = 0;
      return D.29667;
      <D.29666>:
      info = mono_marshal_load_type_info (klass);
      goto <D.24595>;
      <D.24620>:
      D.29668 = field->type;
      D.29669 = D.29668->attrs;
      D.29670 = (int) D.29669;
      D.29671 = D.29670 & 16;
      if (D.29671 != 0) goto <D.29672>; else goto <D.29673>;
      <D.29672>:
      // predicted unlikely by continue predictor.
      goto <D.24595>;
      <D.29673>:
      D.29668 = field->type;
      D.29674 = D.29668->type;
      D.29675 = (int) D.29674;
      switch (D.29675) <default: <D.24619>, case 2: <D.24600>, case 3: <D.24603>, case 4: <D.24598>, case 5: <D.24599>, case 6: <D.24601>, case 7: <D.24602>, case 8: <D.24596>, case 9: <D.24597>, case 10: <D.24604>, case 11: <D.24605>, case 12: <D.24609>, case 13: <D.24610>, case 14: <D.24611>, case 15: <D.24608>, case 17: <D.24613>, case 24: <D.24606>, case 25: <D.24607>, case 29: <D.24614>>
      <D.24596>:
      <D.24597>:
      <D.24598>:
      <D.24599>:
      <D.24600>:
      <D.24601>:
      <D.24602>:
      <D.24603>:
      <D.24604>:
      <D.24605>:
      <D.24606>:
      <D.24607>:
      <D.24608>:
      <D.24609>:
      <D.24610>:
      <D.24611>:
      goto <D.24612>;
      <D.24613>:
      D.29668 = field->type;
      D.29676 = mono_class_from_mono_type (D.29668);
      D.29677 = BIT_FIELD_REF <*D.29676, 8, 256>;
      D.29678 = D.29677 & 16;
      if (D.29678 == 0) goto <D.29679>; else goto <D.29680>;
      <D.29679>:
      D.29668 = field->type;
      D.29681 = mono_class_from_mono_type (D.29668);
      D.29682 = can_marshal_struct (D.29681);
      if (D.29682 == 0) goto <D.29683>; else goto <D.29684>;
      <D.29683>:
      can_marshal = 0;
      <D.29684>:
      <D.29680>:
      goto <D.24612>;
      <D.24614>:
      {
        gboolean has_mspec;

        has_mspec = 0;
        if (info != 0B) goto <D.29685>; else goto <D.29686>;
        <D.29685>:
        i = 0;
        goto <D.24617>;
        <D.24616>:
        D.29687 = info->fields[i].field;
        if (D.29687 == field) goto <D.29688>; else goto <D.29689>;
        <D.29688>:
        D.29690 = info->fields[i].mspec;
        if (D.29690 != 0B) goto <D.29691>; else goto <D.29692>;
        <D.29691>:
        has_mspec = 1;
        <D.29692>:
        <D.29689>:
        i = i + 1;
        <D.24617>:
        i.92 = (unsigned int) i;
        D.29694 = info->num_fields;
        if (i.92 < D.29694) goto <D.24616>; else goto <D.24618>;
        <D.24618>:
        <D.29686>:
        if (has_mspec == 0) goto <D.29695>; else goto <D.29696>;
        <D.29695>:
        can_marshal = 0;
        <D.29696>:
        goto <D.24612>;
      }
      <D.24619>:
      can_marshal = 0;
      goto <D.24612>;
      <D.24612>:
      <D.24595>:
      field = mono_class_get_fields (klass, &iter);
      if (field != 0B) goto <D.24620>; else goto <D.24621>;
      <D.24621>:
      {
        size_t __s1_len;
        size_t __s2_len;

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

          __s2 = klass->name_space;
          D.29700 = "System.Net.NetworkInformation.MacOsStructs";
          D.29701 = MEM[(const unsigned char *)D.29700];
          D.29702 = (int) D.29701;
          D.29703 = *__s2;
          D.29704 = (int) D.29703;
          __result = D.29702 - D.29704;
          {
            D.29705 = __s2_len != 0;
            D.29706 = __result == 0;
            D.29707 = D.29705 & D.29706;
            if (D.29707 != 0) goto <D.29708>; else goto <D.29709>;
            <D.29708>:
            D.29710 = &MEM[(void *)"System.Net.NetworkInformation.MacOsStructs" + 1B];
            D.29711 = *D.29710;
            D.29712 = (int) D.29711;
            D.29713 = __s2 + 1;
            D.29714 = *D.29713;
            D.29715 = (int) D.29714;
            __result = D.29712 - D.29715;
            D.29716 = __s2_len > 1;
            D.29706 = __result == 0;
            D.29717 = D.29716 & D.29706;
            if (D.29717 != 0) goto <D.29718>; else goto <D.29719>;
            <D.29718>:
            D.29720 = &MEM[(void *)"System.Net.NetworkInformation.MacOsStructs" + 2B];
            D.29721 = *D.29720;
            D.29722 = (int) D.29721;
            D.29723 = __s2 + 2;
            D.29724 = *D.29723;
            D.29725 = (int) D.29724;
            __result = D.29722 - D.29725;
            D.29726 = __s2_len > 2;
            D.29706 = __result == 0;
            D.29727 = D.29726 & D.29706;
            if (D.29727 != 0) goto <D.29728>; else goto <D.29729>;
            <D.29728>:
            D.29730 = &MEM[(void *)"System.Net.NetworkInformation.MacOsStructs" + 3B];
            D.29731 = *D.29730;
            D.29732 = (int) D.29731;
            D.29733 = __s2 + 3;
            D.29734 = *D.29733;
            D.29735 = (int) D.29734;
            __result = D.29732 - D.29735;
            <D.29729>:
            <D.29719>:
            <D.29709>:
          }
          D.24629 = __result;
        }
        iftmp.93 = -D.24629;
        goto <D.29736>;
        <D.29699>:
        D.29737 = klass->name_space;
        iftmp.93 = __builtin_strcmp (D.29737, "System.Net.NetworkInformation.MacOsStructs");
        <D.29736>:
        D.24630 = iftmp.93;
      }
      if (D.24630 == 0) goto <D.29738>; else goto <D.29739>;
      <D.29738>:
      {
        size_t __s1_len;
        size_t __s2_len;

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

          __s2 = klass->name;
          D.29743 = "sockaddr_dl";
          D.29744 = MEM[(const unsigned char *)D.29743];
          D.29745 = (int) D.29744;
          D.29746 = *__s2;
          D.29747 = (int) D.29746;
          __result = D.29745 - D.29747;
          {
            D.29748 = __s2_len != 0;
            D.29749 = __result == 0;
            D.29750 = D.29748 & D.29749;
            if (D.29750 != 0) goto <D.29751>; else goto <D.29752>;
            <D.29751>:
            D.29753 = &MEM[(void *)"sockaddr_dl" + 1B];
            D.29754 = *D.29753;
            D.29755 = (int) D.29754;
            D.29756 = __s2 + 1;
            D.29757 = *D.29756;
            D.29758 = (int) D.29757;
            __result = D.29755 - D.29758;
            D.29759 = __s2_len > 1;
            D.29749 = __result == 0;
            D.29760 = D.29759 & D.29749;
            if (D.29760 != 0) goto <D.29761>; else goto <D.29762>;
            <D.29761>:
            D.29763 = &MEM[(void *)"sockaddr_dl" + 2B];
            D.29764 = *D.29763;
            D.29765 = (int) D.29764;
            D.29766 = __s2 + 2;
            D.29767 = *D.29766;
            D.29768 = (int) D.29767;
            __result = D.29765 - D.29768;
            D.29769 = __s2_len > 2;
            D.29749 = __result == 0;
            D.29770 = D.29769 & D.29749;
            if (D.29770 != 0) goto <D.29771>; else goto <D.29772>;
            <D.29771>:
            D.29773 = &MEM[(void *)"sockaddr_dl" + 3B];
            D.29774 = *D.29773;
            D.29775 = (int) D.29774;
            D.29776 = __s2 + 3;
            D.29777 = *D.29776;
            D.29778 = (int) D.29777;
            __result = D.29775 - D.29778;
            <D.29772>:
            <D.29762>:
            <D.29752>:
          }
          D.24638 = __result;
        }
        iftmp.94 = -D.24638;
        goto <D.29779>;
        <D.29742>:
        D.29780 = klass->name;
        iftmp.94 = __builtin_strcmp (D.29780, "sockaddr_dl");
        <D.29779>:
        D.24639 = iftmp.94;
      }
      if (D.24639 != 0) goto <D.29781>; else goto <D.29782>;
      <D.29781>:
      D.29667 = 1;
      return D.29667;
      <D.29782>:
      <D.29739>:
      D.29667 = can_marshal;
      return D.29667;
    }
  finally
    {
      iter = {CLOBBER};
    }
}


compile_methods (struct MonoAotCompile * acfg)
{
  int D.29786;
  struct GPtrArray * D.29789;
  unsigned int D.29790;
  unsigned int D.29791;
  unsigned int D.29792;
  _Bool D.29793;
  long int D.29794;
  long int D.29795;
  long unsigned int D.29798;
  long unsigned int D.29799;
  long unsigned int D.29800;
  long unsigned int D.29801;
  struct MonoMethod * * D.29802;
  void * * D.29803;
  void * * D.29804;
  void * D.29805;
  struct MonoMethod * D.29808;
  struct MonoDomain * D.29809;
  void * * D.29810;
  void * * D.29811;
  void * * D.29812;
  void * * D.29813;
  void * D.29814;
  unsigned int i.95;
  unsigned int D.29816;
  int i;
  int methods_len;

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

    D.29789 = acfg->methods;
    D.29790 = D.29789->len;
    methods_len = (int) D.29790;
    D.29789 = acfg->methods;
    D.29790 = D.29789->len;
    D.29786 = acfg->aot_opts.nthreads;
    D.29791 = (unsigned int) D.29786;
    D.29792 = D.29790 / D.29791;
    len = (int) D.29792;
    D.29793 = len <= 0;
    D.29794 = (long int) D.29793;
    D.29795 = __builtin_expect (D.29794, 0);
    if (D.29795 != 0) goto <D.29796>; else goto <D.29797>;
    <D.29796>:
    monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "aot-compiler.c", 8377, "len > 0");
    <D.29797>:
    threads = monoeg_g_ptr_array_new ();
    D.29798 = (long unsigned int) methods_len;
    D.29799 = D.29798 * 8;
    methods = monoeg_malloc0 (D.29799);
    i = 0;
    goto <D.26399>;
    <D.26398>:
    D.29800 = (long unsigned int) i;
    D.29801 = D.29800 * 8;
    D.29802 = methods + D.29801;
    D.29789 = acfg->methods;
    D.29803 = D.29789->pdata;
    D.29800 = (long unsigned int) i;
    D.29801 = D.29800 * 8;
    D.29804 = D.29803 + D.29801;
    D.29805 = *D.29804;
    *D.29802 = D.29805;
    i = i + 1;
    <D.26399>:
    if (i < methods_len) goto <D.26398>; else goto <D.26400>;
    <D.26400>:
    i = 0;
    goto <D.26405>;
    <D.26404>:
    frag = monoeg_g_ptr_array_new ();
    j = 0;
    goto <D.26402>;
    <D.26401>:
    if (i < methods_len) goto <D.29806>; else goto <D.29807>;
    <D.29806>:
    D.29800 = (long unsigned int) i;
    D.29801 = D.29800 * 8;
    D.29802 = methods + D.29801;
    D.29808 = *D.29802;
    monoeg_g_ptr_array_add (frag, D.29808);
    i = i + 1;
    <D.29807>:
    j = j + 1;
    <D.26402>:
    if (j < len) goto <D.26401>; else goto <D.26403>;
    <D.26403>:
    user_data = monoeg_malloc0 (24);
    D.29809 = mono_domain_get ();
    *user_data = D.29809;
    D.29810 = user_data + 8;
    *D.29810 = acfg;
    D.29811 = user_data + 16;
    *D.29811 = frag;
    handle = mono_threads_create_thread (compile_thread_main, user_data, 0, 0, 0B);
    monoeg_g_ptr_array_add (threads, handle);
    <D.26405>:
    if (i < methods_len) goto <D.26404>; else goto <D.26406>;
    <D.26406>:
    monoeg_g_free (methods);
    i = 0;
    goto <D.26408>;
    <D.26407>:
    D.29812 = threads->pdata;
    D.29800 = (long unsigned int) i;
    D.29801 = D.29800 * 8;
    D.29813 = D.29812 + D.29801;
    D.29814 = *D.29813;
    WaitForSingleObjectEx (D.29814, 4294967295, 0);
    i = i + 1;
    <D.26408>:
    i.95 = (unsigned int) i;
    D.29816 = threads->len;
    if (i.95 < D.29816) goto <D.26407>; else goto <D.26409>;
    <D.26409>:
  }
  goto <D.29817>;
  <D.29788>:
  methods_len = 0;
  <D.29817>:
  i = methods_len;
  goto <D.26411>;
  <D.26410>:
  D.29789 = acfg->methods;
  D.29803 = D.29789->pdata;
  D.29800 = (long unsigned int) i;
  D.29801 = D.29800 * 8;
  D.29804 = D.29803 + D.29801;
  D.29805 = *D.29804;
  compile_method (acfg, D.29805);
  i = i + 1;
  <D.26411>:
  i.95 = (unsigned int) i;
  D.29789 = acfg->methods;
  D.29790 = D.29789->len;
  if (i.95 < D.29790) goto <D.26410>; else goto <D.26412>;
  <D.26412>:
}


compile_thread_main (void * * user_data)
{
  void * * D.29818;
  long unsigned int D.29819;
  long unsigned int D.29820;
  void * * D.29821;
  void * D.29822;
  unsigned int i.96;
  unsigned int D.29824;
  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.25961>;
  <D.25960>:
  D.29818 = methods->pdata;
  D.29819 = (long unsigned int) i;
  D.29820 = D.29819 * 8;
  D.29821 = D.29818 + D.29820;
  D.29822 = *D.29821;
  compile_method (acfg, D.29822);
  i = i + 1;
  <D.25961>:
  i.96 = (unsigned int) i;
  D.29824 = methods->len;
  if (i.96 < D.29824) goto <D.25960>; else goto <D.25962>;
  <D.25962>:
}


compile_method (struct MonoAotCompile * acfg, struct MonoMethod * method)
{
  int D.29825;
  union mono_mutex_t * D.29828;
  _Bool D.29831;
  long int D.29832;
  long int D.29833;
  unsigned int D.29836;
  _Bool D.29839;
  long int D.29840;
  long int D.29841;
  short unsigned int D.29846;
  int D.29847;
  int D.29848;
  short unsigned int D.29850;
  int D.29851;
  int D.29852;
  int D.29854;
  int D.29855;
  short unsigned int D.29860;
  int D.29861;
  int D.29862;
  unsigned char D.29865;
  unsigned char D.29866;
  unsigned char D.29869;
  unsigned char D.29870;
  int * D.29873;
  JitFlags iftmp.97;
  int D.29875;
  struct MonoDomain * D.29879;
  unsigned int D.29880;
  unsigned int D.29881;
  int D.29884;
  char * D.29887;
  char * D.29888;
  int * D.29889;
  char * D.29894;
  unsigned char D.29895;
  unsigned char D.29896;
  char * D.29901;
  int * D.29902;
  unsigned int index.98;
  <unnamed type> D.29904;
  _Bool D.29907;
  long int D.29908;
  long int D.29909;
  struct GHashTable * D.29912;
  _Bool D.29915;
  long int D.29916;
  long int D.29917;
  char * D.29924;
  int * D.29925;
  _Bool D.29928;
  long int D.29929;
  long int D.29930;
  int D.29933;
  char * D.29940;
  int D.29941;
  int D.29942;
  _Bool D.29945;
  long int D.29946;
  long int D.29947;
  struct GHashTable * D.29950;
  void * D.29951;
  long int D.29952;
  int D.29953;
  unsigned char D.29958;
  unsigned char D.29959;
  struct MonoClass * D.29964;
  int D.29965;
  int D.29967;
  int D.29968;
  short unsigned int D.29971;
  int D.29972;
  int D.29973;
  int D.29978;
  struct MonoMethod * D.29979;
  int D.29981;
  unsigned char D.29982;
  unsigned char D.29983;
  int D.25905;
  int iftmp.99;
  int D.25904;
  const char[12] * D.29989;
  unsigned char D.29990;
  int D.29991;
  unsigned char D.29992;
  int D.29993;
  _Bool D.29994;
  _Bool D.29995;
  _Bool D.29996;
  const unsigned char * D.29999;
  unsigned char D.30000;
  int D.30001;
  const unsigned char * D.30002;
  unsigned char D.30003;
  int D.30004;
  _Bool D.30005;
  _Bool D.30006;
  const unsigned char * D.30009;
  unsigned char D.30010;
  int D.30011;
  const unsigned char * D.30012;
  unsigned char D.30013;
  int D.30014;
  _Bool D.30015;
  _Bool D.30016;
  const unsigned char * D.30019;
  unsigned char D.30020;
  int D.30021;
  const unsigned char * D.30022;
  unsigned char D.30023;
  int D.30024;
  const char * D.30026;
  struct MonoGenericClass * D.30029;
  int D.30032;
  struct MonoClassField * D.30035;
  struct MonoGenericClass * D.30036;
  struct MonoGenericContext * D.30039;
  int D.30040;
  struct MonoMethod * D.30043;
  struct MonoMethod * D.30046;
  struct MonoImage * D.30047;
  struct MonoImage * D.30048;
  int D.30051;
  unsigned char D.30054;
  unsigned char D.30055;
  int * D.30058;
  struct MonoMemPool * D.30059;
  void * D.30063;
  struct GSList * D.30064;
  short unsigned int D.30065;
  int D.30066;
  <unnamed-unsigned:1> D.30067;
  int D.30068;
  int D.30069;
  long unsigned int D.30070;
  unsigned int D.30071;
  unsigned int D.30072;
  long unsigned int D.30073;
  long unsigned int D.30074;
  struct MonoInst * * D.30075;
  void * D.30076;
  struct MonoInst * * D.30077;
  struct MonoInst * * D.30078;
  struct MonoInst * D.30079;
  struct MonoInst * D.30080;
  short unsigned int D.30081;
  unsigned int D.30082;
  unsigned int D.30083;
  struct MonoInst * * D.30084;
  void * D.30085;
  struct MonoInst * * D.30086;
  struct MonoInst * * D.30087;
  struct MonoInst * D.30088;
  struct MonoInst * D.30089;
  int D.30090;
  struct MonoMemPool * D.30091;
  struct MonoInst * * D.30092;
  struct MonoMethodVar * D.30093;
  struct MonoRegState * D.30094;
  int D.30097;
  long unsigned int D.30098;
  long unsigned int D.30099;
  long unsigned int D.30100;
  long unsigned int D.30101;
  struct MonoCompile * * D.30102;
  long unsigned int D.30103;
  long unsigned int D.30104;
  struct MonoCompile * * D.30105;
  struct MonoMethod * D.30106;
  struct GHashTable * D.30107;
  _Bool D.30110;
  long int D.30111;
  long int D.30112;
  int * D.30115;
  struct MonoCompile * cfg;
  struct MonoJumpInfo * patch_info;
  gboolean skip;
  int index;
  int depth;
  struct MonoMethod * wrapped;

  D.29825 = acfg->aot_opts.metadata_only;
  if (D.29825 != 0) goto <D.29826>; else goto <D.29827>;
  <D.29826>:
  return;
  <D.29827>:
  {
    int ret;

    D.29828 = &acfg->mutex.mutex;
    ret = pthread_mutex_lock (D.29828);
    if (ret != 0) goto <D.29829>; else goto <D.29830>;
    <D.29829>:
    monoeg_g_log (0B, 16, "Bad call to mono_mutex_lock result %d", ret);
    <D.29830>:
    D.29831 = ret != 0;
    D.29832 = (long int) D.29831;
    D.29833 = __builtin_expect (D.29832, 0);
    if (D.29833 != 0) goto <D.29834>; else goto <D.29835>;
    <D.29834>:
    monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "aot-compiler.c", 6458, "ret == 0");
    <D.29835>:
  }
  D.29836 = get_method_index (acfg, method);
  index = (int) D.29836;
  {
    int ret;

    D.29828 = &acfg->mutex.mutex;
    ret = pthread_mutex_unlock (D.29828);
    if (ret != 0) goto <D.29837>; else goto <D.29838>;
    <D.29837>:
    monoeg_g_log (0B, 16, "Bad call to mono_mutex_unlock result %d", ret);
    <D.29838>:
    D.29839 = ret != 0;
    D.29840 = (long int) D.29839;
    D.29841 = __builtin_expect (D.29840, 0);
    if (D.29841 != 0) goto <D.29842>; else goto <D.29843>;
    <D.29842>:
    monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "aot-compiler.c", 6460, "ret == 0");
    <D.29843>:
  }
  D.29846 = method->flags;
  D.29847 = (int) D.29846;
  D.29848 = D.29847 & 8192;
  if (D.29848 != 0) goto <D.29844>; else goto <D.29849>;
  <D.29849>:
  D.29850 = method->iflags;
  D.29851 = (int) D.29850;
  D.29852 = D.29851 & 3;
  if (D.29852 != 0) goto <D.29844>; else goto <D.29853>;
  <D.29853>:
  D.29846 = method->flags;
  D.29847 = (int) D.29846;
  D.29854 = D.29847 & 1024;
  if (D.29854 != 0) goto <D.29844>; else goto <D.29845>;
  <D.29844>:
  return;
  <D.29845>:
  D.29850 = method->iflags;
  D.29851 = (int) D.29850;
  D.29855 = D.29851 & 4096;
  if (D.29855 != 0) goto <D.29856>; else goto <D.29857>;
  <D.29856>:
  return;
  <D.29857>:
  wrapped = mono_marshal_method_from_wrapper (method);
  if (wrapped != 0B) goto <D.29858>; else goto <D.29859>;
  <D.29858>:
  D.29860 = wrapped->iflags;
  D.29861 = (int) D.29860;
  D.29862 = D.29861 & 4096;
  if (D.29862 != 0) goto <D.29863>; else goto <D.29864>;
  <D.29863>:
  D.29865 = BIT_FIELD_REF <*wrapped, 8, 264>;
  D.29866 = D.29865 & 8;
  if (D.29866 != 0) goto <D.29867>; else goto <D.29868>;
  <D.29867>:
  return;
  <D.29868>:
  <D.29864>:
  <D.29859>:
  D.29869 = BIT_FIELD_REF <*method, 8, 256>;
  D.29870 = D.29869 & 124;
  if (D.29870 == 108) goto <D.29871>; else goto <D.29872>;
  <D.29871>:
  return;
  <D.29872>:
  D.29873 = &acfg->stats.mcount;
  InterlockedIncrement (D.29873);
  D.29875 = acfg->aot_opts.full_aot;
  if (D.29875 != 0) goto <D.29876>; else goto <D.29877>;
  <D.29876>:
  iftmp.97 = 6;
  goto <D.29878>;
  <D.29877>:
  iftmp.97 = 2;
  <D.29878>:
  D.29879 = mono_get_root_domain ();
  D.29880 = acfg->opts;
  cfg = mini_method_compile (method, D.29880, D.29879, iftmp.97, 0);
  mono_loader_clear_error ();
  D.29881 = cfg->exception_type;
  if (D.29881 == 11) goto <D.29882>; else goto <D.29883>;
  <D.29882>:
  D.29884 = acfg->aot_opts.print_skipped_methods;
  if (D.29884 != 0) goto <D.29885>; else goto <D.29886>;
  <D.29885>:
  D.29887 = cfg->exception_message;
  D.29888 = mono_method_full_name (method, 1);
  printf ("Skip (gshared failure): %s (%s)\n", D.29888, D.29887);
  <D.29886>:
  D.29889 = &acfg->stats.genericcount;
  InterlockedIncrement (D.29889);
  return;
  <D.29883>:
  D.29881 = cfg->exception_type;
  if (D.29881 != 0) goto <D.29890>; else goto <D.29891>;
  <D.29890>:
  D.29884 = acfg->aot_opts.print_skipped_methods;
  if (D.29884 != 0) goto <D.29892>; else goto <D.29893>;
  <D.29892>:
  D.29894 = mono_method_full_name (method, 1);
  printf ("Skip (JIT failure): %s\n", D.29894);
  <D.29893>:
  return;
  <D.29891>:
  D.29895 = BIT_FIELD_REF <*cfg, 8, 5600>;
  D.29896 = D.29895 & 1;
  if (D.29896 != 0) goto <D.29897>; else goto <D.29898>;
  <D.29897>:
  D.29884 = acfg->aot_opts.print_skipped_methods;
  if (D.29884 != 0) goto <D.29899>; else goto <D.29900>;
  <D.29899>:
  D.29901 = mono_method_full_name (method, 1);
  printf ("Skip (disabled): %s\n", D.29901);
  <D.29900>:
  D.29902 = &acfg->stats.ocount;
  InterlockedIncrement (D.29902);
  mono_destroy_compile (cfg);
  return;
  <D.29898>:
  index.98 = (unsigned int) index;
  cfg->method_index = index.98;
  patch_info = cfg->patch_info;
  goto <D.25880>;
  <D.25879>:
  D.29904 = patch_info->type;
  switch (D.29904) <default: <D.25878>, case 0: <D.25876>, case 2: <D.25875>>
  <D.25875>:
  <D.25876>:
  patch_info->type = 51;
  goto <D.25877>;
  <D.25878>:
  goto <D.25877>;
  <D.25877>:
  patch_info = patch_info->next;
  <D.25880>:
  if (patch_info != 0B) goto <D.25879>; else goto <D.25881>;
  <D.25881>:
  {
    int ret;

    D.29828 = &acfg->mutex.mutex;
    ret = pthread_mutex_lock (D.29828);
    if (ret != 0) goto <D.29905>; else goto <D.29906>;
    <D.29905>:
    monoeg_g_log (0B, 16, "Bad call to mono_mutex_lock result %d", ret);
    <D.29906>:
    D.29907 = ret != 0;
    D.29908 = (long int) D.29907;
    D.29909 = __builtin_expect (D.29908, 0);
    if (D.29909 != 0) goto <D.29910>; else goto <D.29911>;
    <D.29910>:
    monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "aot-compiler.c", 6536, "ret == 0");
    <D.29911>:
  }
  D.29912 = cfg->token_info_hash;
  monoeg_g_hash_table_foreach (D.29912, add_token_info_hash, acfg);
  {
    int ret;

    D.29828 = &acfg->mutex.mutex;
    ret = pthread_mutex_unlock (D.29828);
    if (ret != 0) goto <D.29913>; else goto <D.29914>;
    <D.29913>:
    monoeg_g_log (0B, 16, "Bad call to mono_mutex_unlock result %d", ret);
    <D.29914>:
    D.29915 = ret != 0;
    D.29916 = (long int) D.29915;
    D.29917 = __builtin_expect (D.29916, 0);
    if (D.29917 != 0) goto <D.29918>; else goto <D.29919>;
    <D.29918>:
    monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "aot-compiler.c", 6538, "ret == 0");
    <D.29919>:
  }
  skip = 0;
  patch_info = cfg->patch_info;
  goto <D.25888>;
  <D.25887>:
  D.29904 = patch_info->type;
  switch (D.29904) <default: <D.25886>, case 1: <D.25884>>
  <D.25884>:
  skip = 1;
  goto <D.25885>;
  <D.25886>:
  goto <D.25885>;
  <D.25885>:
  patch_info = patch_info->next;
  <D.25888>:
  if (patch_info != 0B) goto <D.25887>; else goto <D.25889>;
  <D.25889>:
  if (skip != 0) goto <D.29920>; else goto <D.29921>;
  <D.29920>:
  D.29884 = acfg->aot_opts.print_skipped_methods;
  if (D.29884 != 0) goto <D.29922>; else goto <D.29923>;
  <D.29922>:
  D.29924 = mono_method_full_name (method, 1);
  printf ("Skip (abs call): %s\n", D.29924);
  <D.29923>:
  D.29925 = &acfg->stats.abscount;
  InterlockedIncrement (D.29925);
  mono_destroy_compile (cfg);
  return;
  <D.29921>:
  {
    int ret;

    D.29828 = &acfg->mutex.mutex;
    ret = pthread_mutex_lock (D.29828);
    if (ret != 0) goto <D.29926>; else goto <D.29927>;
    <D.29926>:
    monoeg_g_log (0B, 16, "Bad call to mono_mutex_lock result %d", ret);
    <D.29927>:
    D.29928 = ret != 0;
    D.29929 = (long int) D.29928;
    D.29930 = __builtin_expect (D.29929, 0);
    if (D.29930 != 0) goto <D.29931>; else goto <D.29932>;
    <D.29931>:
    monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "aot-compiler.c", 6564, "ret == 0");
    <D.29932>:
  }
  skip = 0;
  patch_info = cfg->patch_info;
  goto <D.25892>;
  <D.25891>:
  D.29933 = can_encode_patch (acfg, patch_info);
  if (D.29933 == 0) goto <D.29934>; else goto <D.29935>;
  <D.29934>:
  skip = 1;
  <D.29935>:
  patch_info = patch_info->next;
  <D.25892>:
  if (patch_info != 0B) goto <D.25891>; else goto <D.25893>;
  <D.25893>:
  if (skip != 0) goto <D.29936>; else goto <D.29937>;
  <D.29936>:
  D.29884 = acfg->aot_opts.print_skipped_methods;
  if (D.29884 != 0) goto <D.29938>; else goto <D.29939>;
  <D.29938>:
  D.29940 = mono_method_full_name (method, 1);
  printf ("Skip (patches): %s\n", D.29940);
  <D.29939>:
  D.29941 = acfg->stats.ocount;
  D.29942 = D.29941 + 1;
  acfg->stats.ocount = D.29942;
  mono_destroy_compile (cfg);
  {
    int ret;

    D.29828 = &acfg->mutex.mutex;
    ret = pthread_mutex_unlock (D.29828);
    if (ret != 0) goto <D.29943>; else goto <D.29944>;
    <D.29943>:
    monoeg_g_log (0B, 16, "Bad call to mono_mutex_unlock result %d", ret);
    <D.29944>:
    D.29945 = ret != 0;
    D.29946 = (long int) D.29945;
    D.29947 = __builtin_expect (D.29946, 0);
    if (D.29947 != 0) goto <D.29948>; else goto <D.29949>;
    <D.29948>:
    monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "aot-compiler.c", 6580, "ret == 0");
    <D.29949>:
  }
  return;
  <D.29937>:
  D.29950 = acfg->method_depth;
  D.29951 = monoeg_g_hash_table_lookup (D.29950, method);
  D.29952 = (long int) D.29951;
  depth = (int) D.29952;
  D.29953 = acfg->aot_opts.no_instances;
  if (D.29953 == 0) goto <D.29954>; else goto <D.29955>;
  <D.29954>:
  if (depth <= 31) goto <D.29956>; else goto <D.29957>;
  <D.29956>:
  patch_info = cfg->patch_info;
  goto <D.25913>;
  <D.25912>:
  D.29904 = patch_info->type;
  switch (D.29904) <default: <D.25911>, case 3: <D.25895>, case 14: <D.25907>, case 16: <D.25909>>
  <D.25895>:
  {
    struct MonoMethod * m;

    m = patch_info->data.method;
    D.29958 = BIT_FIELD_REF <*m, 8, 264>;
    D.29959 = D.29958 & 16;
    if (D.29959 != 0) goto <D.29960>; else goto <D.29961>;
    <D.29960>:
    D.29964 = m->klass;
    D.29965 = mono_class_generic_sharing_enabled (D.29964);
    if (D.29965 == 0) goto <D.29962>; else goto <D.29966>;
    <D.29966>:
    D.29967 = mono_method_is_generic_sharable_full (m, 0, 0, 0);
    if (D.29967 == 0) goto <D.29962>; else goto <D.29963>;
    <D.29962>:
    D.29968 = method_has_type_vars (m);
    if (D.29968 == 0) goto <D.29969>; else goto <D.29970>;
    <D.29969>:
    D.29971 = m->iflags;
    D.29972 = (int) D.29971;
    D.29973 = D.29972 & 4096;
    if (D.29973 != 0) goto <D.29974>; else goto <D.29975>;
    <D.29974>:
    D.29875 = acfg->aot_opts.full_aot;
    if (D.29875 != 0) goto <D.29976>; else goto <D.29977>;
    <D.29976>:
    D.29978 = depth + 1;
    D.29979 = mono_marshal_get_native_wrapper (m, 1, 1);
    add_extra_method_with_depth (acfg, D.29979, D.29978);
    <D.29977>:
    goto <D.29980>;
    <D.29975>:
    D.29978 = depth + 1;
    add_extra_method_with_depth (acfg, m, D.29978);
    add_types_from_method_header (acfg, m);
    <D.29980>:
    <D.29970>:
    <D.29963>:
    D.29981 = depth + 5;
    D.29964 = m->klass;
    add_generic_class_with_depth (acfg, D.29964, D.29981, "method");
    <D.29961>:
    D.29982 = BIT_FIELD_REF <*m, 8, 256>;
    D.29983 = D.29982 & 124;
    if (D.29983 == 28) goto <D.29984>; else goto <D.29985>;
    <D.29984>:
    {
      size_t __s1_len;
      size_t __s2_len;

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

        __s2 = m->name;
        D.29989 = "ElementAddr";
        D.29990 = MEM[(const unsigned char *)D.29989];
        D.29991 = (int) D.29990;
        D.29992 = *__s2;
        D.29993 = (int) D.29992;
        __result = D.29991 - D.29993;
        {
          D.29994 = __s2_len != 0;
          D.29995 = __result == 0;
          D.29996 = D.29994 & D.29995;
          if (D.29996 != 0) goto <D.29997>; else goto <D.29998>;
          <D.29997>:
          D.29999 = &MEM[(void *)"ElementAddr" + 1B];
          D.30000 = *D.29999;
          D.30001 = (int) D.30000;
          D.30002 = __s2 + 1;
          D.30003 = *D.30002;
          D.30004 = (int) D.30003;
          __result = D.30001 - D.30004;
          D.30005 = __s2_len > 1;
          D.29995 = __result == 0;
          D.30006 = D.30005 & D.29995;
          if (D.30006 != 0) goto <D.30007>; else goto <D.30008>;
          <D.30007>:
          D.30009 = &MEM[(void *)"ElementAddr" + 2B];
          D.30010 = *D.30009;
          D.30011 = (int) D.30010;
          D.30012 = __s2 + 2;
          D.30013 = *D.30012;
          D.30014 = (int) D.30013;
          __result = D.30011 - D.30014;
          D.30015 = __s2_len > 2;
          D.29995 = __result == 0;
          D.30016 = D.30015 & D.29995;
          if (D.30016 != 0) goto <D.30017>; else goto <D.30018>;
          <D.30017>:
          D.30019 = &MEM[(void *)"ElementAddr" + 3B];
          D.30020 = *D.30019;
          D.30021 = (int) D.30020;
          D.30022 = __s2 + 3;
          D.30023 = *D.30022;
          D.30024 = (int) D.30023;
          __result = D.30021 - D.30024;
          <D.30018>:
          <D.30008>:
          <D.29998>:
        }
        D.25904 = __result;
      }
      iftmp.99 = -D.25904;
      goto <D.30025>;
      <D.29988>:
      D.30026 = m->name;
      iftmp.99 = __builtin_strcmp (D.30026, "ElementAddr");
      <D.30025>:
      D.25905 = iftmp.99;
    }
    if (D.25905 == 0) goto <D.30027>; else goto <D.30028>;
    <D.30027>:
    D.29978 = depth + 1;
    add_extra_method_with_depth (acfg, m, D.29978);
    <D.30028>:
    <D.29985>:
    goto <D.25906>;
  }
  <D.25907>:
  {
    struct MonoClass * klass;

    klass = patch_info->data.klass;
    D.30029 = klass->generic_class;
    if (D.30029 != 0B) goto <D.30030>; else goto <D.30031>;
    <D.30030>:
    D.30032 = mini_class_is_generic_sharable (klass);
    if (D.30032 == 0) goto <D.30033>; else goto <D.30034>;
    <D.30033>:
    D.29981 = depth + 5;
    add_generic_class_with_depth (acfg, klass, D.29981, "vtable");
    <D.30034>:
    <D.30031>:
    goto <D.25906>;
  }
  <D.25909>:
  {
    struct MonoClass * klass;

    D.30035 = patch_info->data.field;
    klass = D.30035->parent;
    D.30036 = klass->generic_class;
    if (D.30036 != 0B) goto <D.30037>; else goto <D.30038>;
    <D.30037>:
    D.30036 = klass->generic_class;
    D.30039 = &D.30036->context;
    D.30040 = mono_generic_context_is_sharable (D.30039, 0);
    if (D.30040 == 0) goto <D.30041>; else goto <D.30042>;
    <D.30041>:
    D.30043 = mono_class_get_cctor (klass);
    if (D.30043 != 0B) goto <D.30044>; else goto <D.30045>;
    <D.30044>:
    D.29978 = depth + 1;
    D.30046 = mono_class_get_cctor (klass);
    add_extra_method_with_depth (acfg, D.30046, D.29978);
    <D.30045>:
    <D.30042>:
    <D.30038>:
    goto <D.25906>;
  }
  <D.25911>:
  goto <D.25906>;
  <D.25906>:
  patch_info = patch_info->next;
  <D.25913>:
  if (patch_info != 0B) goto <D.25912>; else goto <D.25914>;
  <D.25914>:
  <D.29957>:
  <D.29955>:
  patch_info = cfg->patch_info;
  goto <D.25922>;
  <D.25921>:
  D.29904 = patch_info->type;
  switch (D.29904) <default: <D.25920>, case 12: <D.25919>, case 27: <D.25915>, case 42: <D.25917>, case 51: <D.25916>>
  <D.25915>:
  <D.25916>:
  <D.25917>:
  goto <D.25918>;
  <D.25919>:
  D.30047 = patch_info->data.image;
  D.30048 = acfg->image;
  if (D.30047 != D.30048) goto <D.30049>; else goto <D.30050>;
  <D.30049>:
  cfg->has_got_slots = 1;
  <D.30050>:
  goto <D.25918>;
  <D.25920>:
  D.30051 = is_plt_patch (patch_info);
  if (D.30051 == 0) goto <D.30052>; else goto <D.30053>;
  <D.30052>:
  cfg->has_got_slots = 1;
  <D.30053>:
  goto <D.25918>;
  <D.25918>:
  patch_info = patch_info->next;
  <D.25922>:
  if (patch_info != 0B) goto <D.25921>; else goto <D.25923>;
  <D.25923>:
  D.30054 = BIT_FIELD_REF <*cfg, 8, 5632>;
  D.30055 = D.30054 & 1;
  if (D.30055 == 0) goto <D.30056>; else goto <D.30057>;
  <D.30056>:
  D.30058 = &acfg->stats.methods_without_got_slots;
  InterlockedIncrement (D.30058);
  <D.30057>:
  {
    struct MonoJumpInfo * patches;
    struct MonoJumpInfo * patches_end;

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

      D.30059 = acfg->mempool;
      new_patch_info = mono_patch_info_dup_mp (D.30059, patch_info);
      if (patches == 0B) goto <D.30060>; else goto <D.30061>;
      <D.30060>:
      patches = new_patch_info;
      goto <D.30062>;
      <D.30061>:
      patches_end->next = new_patch_info;
      <D.30062>:
      patches_end = new_patch_info;
    }
    patch_info = patch_info->next;
    <D.25928>:
    if (patch_info != 0B) goto <D.25927>; else goto <D.25929>;
    <D.25929>:
    cfg->patch_info = patches;
  }
  {
    struct GSList * l;
    struct GSList * unwind_ops;
    struct MonoUnwindOp * op;

    unwind_ops = 0B;
    l = cfg->unwind_ops;
    goto <D.25934>;
    <D.25933>:
    D.30059 = acfg->mempool;
    op = mono_mempool_alloc (D.30059, 12);
    D.30063 = l->data;
    memcpy (op, D.30063, 12);
    D.30059 = acfg->mempool;
    unwind_ops = g_slist_prepend_mempool (D.30059, unwind_ops, op);
    l = l->next;
    <D.25934>:
    if (l != 0B) goto <D.25933>; else goto <D.25935>;
    <D.25935>:
    D.30064 = monoeg_g_slist_reverse (unwind_ops);
    cfg->unwind_ops = D.30064;
  }
  {
    struct MonoInst * * args;
    struct MonoInst * * locals;
    struct MonoMethodSignature * sig;
    struct MonoMethodHeader * header;
    int i;

    sig = mono_method_signature (method);
    D.30065 = sig->param_count;
    D.30066 = (int) D.30065;
    D.30067 = sig->hasthis;
    D.30068 = (int) D.30067;
    D.30069 = D.30066 + D.30068;
    D.30070 = (long unsigned int) D.30069;
    D.30071 = (unsigned int) D.30070;
    D.30072 = D.30071 * 8;
    D.30059 = acfg->mempool;
    args = mono_mempool_alloc (D.30059, D.30072);
    i = 0;
    goto <D.25942>;
    <D.25941>:
    D.30073 = (long unsigned int) i;
    D.30074 = D.30073 * 8;
    D.30075 = args + D.30074;
    D.30059 = acfg->mempool;
    D.30076 = mono_mempool_alloc (D.30059, 80);
    *D.30075 = D.30076;
    D.30077 = cfg->args;
    D.30073 = (long unsigned int) i;
    D.30074 = D.30073 * 8;
    D.30078 = D.30077 + D.30074;
    D.30079 = *D.30078;
    D.30073 = (long unsigned int) i;
    D.30074 = D.30073 * 8;
    D.30075 = args + D.30074;
    D.30080 = *D.30075;
    memcpy (D.30080, D.30079, 80);
    i = i + 1;
    <D.25942>:
    D.30065 = sig->param_count;
    D.30066 = (int) D.30065;
    D.30067 = sig->hasthis;
    D.30068 = (int) D.30067;
    D.30069 = D.30066 + D.30068;
    if (D.30069 > i) goto <D.25941>; else goto <D.25943>;
    <D.25943>:
    cfg->args = args;
    header = mono_method_get_header (method);
    D.30081 = header->num_locals;
    D.30082 = (unsigned int) D.30081;
    D.30083 = D.30082 * 8;
    D.30059 = acfg->mempool;
    locals = mono_mempool_alloc (D.30059, D.30083);
    i = 0;
    goto <D.25945>;
    <D.25944>:
    D.30073 = (long unsigned int) i;
    D.30074 = D.30073 * 8;
    D.30084 = locals + D.30074;
    D.30059 = acfg->mempool;
    D.30085 = mono_mempool_alloc (D.30059, 80);
    *D.30084 = D.30085;
    D.30086 = cfg->locals;
    D.30073 = (long unsigned int) i;
    D.30074 = D.30073 * 8;
    D.30087 = D.30086 + D.30074;
    D.30088 = *D.30087;
    D.30073 = (long unsigned int) i;
    D.30074 = D.30073 * 8;
    D.30084 = locals + D.30074;
    D.30089 = *D.30084;
    memcpy (D.30089, D.30088, 80);
    i = i + 1;
    <D.25945>:
    D.30081 = header->num_locals;
    D.30090 = (int) D.30081;
    if (D.30090 > i) goto <D.25944>; else goto <D.25946>;
    <D.25946>:
    cfg->locals = locals;
  }
  D.30091 = cfg->mempool;
  mono_mempool_destroy (D.30091);
  cfg->mempool = 0B;
  D.30092 = cfg->varinfo;
  monoeg_g_free (D.30092);
  cfg->varinfo = 0B;
  D.30093 = cfg->vars;
  monoeg_g_free (D.30093);
  cfg->vars = 0B;
  D.30094 = cfg->rs;
  if (D.30094 != 0B) goto <D.30095>; else goto <D.30096>;
  <D.30095>:
  D.30094 = cfg->rs;
  mono_regstate_free (D.30094);
  cfg->rs = 0B;
  <D.30096>:
  goto <D.25950>;
  <D.25949>:
  {
    struct MonoCompile * * new_cfgs;
    int new_size;

    D.30097 = acfg->cfgs_size;
    new_size = D.30097 * 2;
    D.30098 = (long unsigned int) new_size;
    D.30099 = D.30098 * 8;
    new_cfgs = monoeg_malloc0 (D.30099);
    D.30097 = acfg->cfgs_size;
    D.30100 = (long unsigned int) D.30097;
    D.30101 = D.30100 * 8;
    D.30102 = acfg->cfgs;
    memcpy (new_cfgs, D.30102, D.30101);
    D.30102 = acfg->cfgs;
    monoeg_g_free (D.30102);
    acfg->cfgs = new_cfgs;
    acfg->cfgs_size = new_size;
  }
  <D.25950>:
  D.30097 = acfg->cfgs_size;
  if (D.30097 <= index) goto <D.25949>; else goto <D.25951>;
  <D.25951>:
  D.30102 = acfg->cfgs;
  D.30103 = (long unsigned int) index;
  D.30104 = D.30103 * 8;
  D.30105 = D.30102 + D.30104;
  *D.30105 = cfg;
  D.30106 = cfg->orig_method;
  D.30107 = acfg->method_to_cfg;
  monoeg_g_hash_table_insert_replace (D.30107, D.30106, cfg, 0);
  {
    int ret;

    D.29828 = &acfg->mutex.mutex;
    ret = pthread_mutex_unlock (D.29828);
    if (ret != 0) goto <D.30108>; else goto <D.30109>;
    <D.30108>:
    monoeg_g_log (0B, 16, "Bad call to mono_mutex_unlock result %d", ret);
    <D.30109>:
    D.30110 = ret != 0;
    D.30111 = (long int) D.30110;
    D.30112 = __builtin_expect (D.30111, 0);
    if (D.30112 != 0) goto <D.30113>; else goto <D.30114>;
    <D.30113>:
    monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "aot-compiler.c", 6745, "ret == 0");
    <D.30114>:
  }
  D.30115 = &acfg->stats.ccount;
  InterlockedIncrement (D.30115);
}


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


method_has_type_vars (struct MonoMethod * method)
{
  struct MonoClass * D.30124;
  int D.30125;
  gboolean D.30128;
  unsigned char D.30129;
  unsigned char D.30130;
  struct MonoGenericInst * D.30133;
  struct MonoType * D.30136;
  struct MonoClass * D.30137;
  int D.30138;
  <unnamed-unsigned:22> D.30141;
  int D.30142;

  D.30124 = method->klass;
  D.30125 = has_type_vars (D.30124);
  if (D.30125 != 0) goto <D.30126>; else goto <D.30127>;
  <D.30126>:
  D.30128 = 1;
  return D.30128;
  <D.30127>:
  D.30129 = BIT_FIELD_REF <*method, 8, 264>;
  D.30130 = D.30129 & 16;
  if (D.30130 != 0) goto <D.30131>; else goto <D.30132>;
  <D.30131>:
  {
    struct MonoGenericContext * context;

    context = mono_method_get_context (method);
    D.30133 = context->method_inst;
    if (D.30133 != 0B) goto <D.30134>; else goto <D.30135>;
    <D.30134>:
    {
      int i;

      i = 0;
      goto <D.24849>;
      <D.24848>:
      D.30133 = context->method_inst;
      D.30136 = D.30133->type_argv[i];
      D.30137 = mono_class_from_mono_type (D.30136);
      D.30138 = has_type_vars (D.30137);
      if (D.30138 != 0) goto <D.30139>; else goto <D.30140>;
      <D.30139>:
      D.30128 = 1;
      return D.30128;
      <D.30140>:
      i = i + 1;
      <D.24849>:
      D.30133 = context->method_inst;
      D.30141 = D.30133->type_argc;
      D.30142 = (int) D.30141;
      if (D.30142 > i) goto <D.24848>; else goto <D.24850>;
      <D.24850>:
    }
    <D.30135>:
  }
  <D.30132>:
  D.30128 = 0;
  return D.30128;
}


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

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


InterlockedIncrement (volatile gint32 * val)
{
  gint32 D.30146;
  unsigned int D.30147;

  D.30147 = __sync_add_and_fetch_4 (val, 1);
  D.30146 = (gint32) D.30147;
  return D.30146;
}


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

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


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

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


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

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


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

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


emit_code (struct MonoAotCompile * acfg)
{
  int D.30153;
  struct MonoCompile * * D.30156;
  long unsigned int D.30157;
  long unsigned int D.30158;
  struct MonoCompile * * D.30159;
  struct MonoCompile * D.30160;
  unsigned char D.30163;
  unsigned char D.30164;
  char * D.30167;
  gchar * D.30168;
  unsigned int i.100;
  unsigned int D.30170;
  char * D.30171;
  gchar * D.30174;
  struct GPtrArray * D.30175;
  void * * D.30176;
  long unsigned int D.30177;
  long unsigned int D.30178;
  void * * D.30179;
  void * D.30180;
  long int D.30181;
  int D.30184;
  struct MonoMethod * D.30187;
  struct MonoClass * D.30188;
  unsigned char D.30189;
  unsigned char D.30190;
  unsigned int D.30193;
  int D.30194;
  unsigned char D.30197;
  unsigned char D.30198;
  struct FILE * D.30201;
  char * D.30202;
  int D.30209;
  int D.30210;
  unsigned int oindex.101;
  unsigned int D.30213;
  int D.30216;
  int D.30223;
  unsigned int D.30224;
  unsigned int D.30225;
  unsigned int D.30226;
  int D.30227;
  int D.30231;
  struct MonoMethod * D.30239;
  struct MonoClass * D.30240;
  unsigned char D.30241;
  unsigned char D.30242;
  unsigned int D.30245;
  unsigned char D.30251;
  unsigned char D.30252;
  _Bool D.30255;
  long int D.30256;
  long int D.30257;
  int oindex;
  int i;
  int prev_index;
  char symbol[256];

  try
    {
      emit_section_change (acfg, ".text", 0);
      emit_alignment (acfg, 8);
      D.30153 = acfg->llvm;
      if (D.30153 != 0) goto <D.30154>; else goto <D.30155>;
      <D.30154>:
      i = 0;
      goto <D.26036>;
      <D.26035>:
      D.30156 = acfg->cfgs;
      D.30157 = (long unsigned int) i;
      D.30158 = D.30157 * 8;
      D.30159 = D.30156 + D.30158;
      D.30160 = *D.30159;
      if (D.30160 != 0B) goto <D.30161>; else goto <D.30162>;
      <D.30161>:
      D.30156 = acfg->cfgs;
      D.30157 = (long unsigned int) i;
      D.30158 = D.30157 * 8;
      D.30159 = D.30156 + D.30158;
      D.30160 = *D.30159;
      D.30163 = BIT_FIELD_REF <*D.30160, 8, 5608>;
      D.30164 = D.30163 & 1;
      if (D.30164 != 0) goto <D.30165>; else goto <D.30166>;
      <D.30165>:
      D.30156 = acfg->cfgs;
      D.30157 = (long unsigned int) i;
      D.30158 = D.30157 * 8;
      D.30159 = D.30156 + D.30158;
      D.30160 = *D.30159;
      D.30167 = D.30160->asm_symbol;
      D.30168 = monoeg_strdup (D.30167);
      acfg->methods_symbol = D.30168;
      goto <D.26034>;
      <D.30166>:
      <D.30162>:
      i = i + 1;
      <D.26036>:
      i.100 = (unsigned int) i;
      D.30170 = acfg->nmethods;
      if (i.100 < D.30170) goto <D.26035>; else goto <D.26034>;
      <D.26034>:
      <D.30155>:
      D.30171 = acfg->methods_symbol;
      if (D.30171 == 0B) goto <D.30172>; else goto <D.30173>;
      <D.30172>:
      sprintf (&symbol, "methods");
      emit_label (acfg, &symbol);
      D.30174 = monoeg_strdup (&symbol);
      acfg->methods_symbol = D.30174;
      <D.30173>:
      emit_zero_bytes (acfg, 16);
      oindex = 0;
      goto <D.26041>;
      <D.26040>:
      {
        struct MonoCompile * cfg;
        struct MonoMethod * method;

        D.30175 = acfg->method_order;
        D.30176 = D.30175->pdata;
        D.30177 = (long unsigned int) oindex;
        D.30178 = D.30177 * 8;
        D.30179 = D.30176 + D.30178;
        D.30180 = *D.30179;
        D.30181 = (long int) D.30180;
        i = (int) D.30181;
        D.30156 = acfg->cfgs;
        D.30157 = (long unsigned int) i;
        D.30158 = D.30157 * 8;
        D.30159 = D.30156 + D.30158;
        cfg = *D.30159;
        if (cfg == 0B) goto <D.30182>; else goto <D.30183>;
        <D.30182>:
        // predicted unlikely by continue predictor.
        goto <D.26039>;
        <D.30183>:
        method = cfg->orig_method;
        D.30184 = acfg->aot_opts.full_aot;
        if (D.30184 != 0) goto <D.30185>; else goto <D.30186>;
        <D.30185>:
        D.30187 = cfg->orig_method;
        D.30188 = D.30187->klass;
        D.30189 = BIT_FIELD_REF <*D.30188, 8, 256>;
        D.30190 = D.30189 & 8;
        if (D.30190 != 0) goto <D.30191>; else goto <D.30192>;
        <D.30191>:
        D.30193 = get_method_index (acfg, method);
        sprintf (&symbol, "ut_%d", D.30193);
        emit_section_change (acfg, ".text", 0);
        D.30194 = acfg->thumb_mixed;
        if (D.30194 != 0) goto <D.30195>; else goto <D.30196>;
        <D.30195>:
        D.30197 = BIT_FIELD_REF <*cfg, 8, 5608>;
        D.30198 = D.30197 & 1;
        if (D.30198 != 0) goto <D.30199>; else goto <D.30200>;
        <D.30199>:
        emit_set_thumb_mode (acfg);
        D.30201 = acfg->fp;
        fprintf (D.30201, "\n.thumb_func\n");
        <D.30200>:
        <D.30196>:
        emit_label (acfg, &symbol);
        D.30202 = cfg->asm_symbol;
        D.30187 = cfg->orig_method;
        arch_emit_unbox_trampoline (acfg, cfg, D.30187, D.30202);
        D.30194 = acfg->thumb_mixed;
        if (D.30194 != 0) goto <D.30203>; else goto <D.30204>;
        <D.30203>:
        D.30197 = BIT_FIELD_REF <*cfg, 8, 5608>;
        D.30198 = D.30197 & 1;
        if (D.30198 != 0) goto <D.30205>; else goto <D.30206>;
        <D.30205>:
        emit_set_arm_mode (acfg);
        <D.30206>:
        <D.30204>:
        <D.30192>:
        <D.30186>:
        D.30197 = BIT_FIELD_REF <*cfg, 8, 5608>;
        D.30198 = D.30197 & 1;
        if (D.30198 != 0) goto <D.30207>; else goto <D.30208>;
        <D.30207>:
        D.30209 = acfg->stats.llvm_count;
        D.30210 = D.30209 + 1;
        acfg->stats.llvm_count = D.30210;
        goto <D.30211>;
        <D.30208>:
        emit_method_code (acfg, cfg);
        <D.30211>:
      }
      <D.26039>:
      oindex = oindex + 1;
      <D.26041>:
      oindex.101 = (unsigned int) oindex;
      D.30175 = acfg->method_order;
      D.30213 = D.30175->len;
      if (oindex.101 < D.30213) goto <D.26040>; else goto <D.26042>;
      <D.26042>:
      sprintf (&symbol, "methods_end");
      emit_section_change (acfg, ".text", 0);
      emit_alignment (acfg, 8);
      emit_label (acfg, &symbol);
      emit_int32 (acfg, 0);
      D.30153 = acfg->llvm;
      if (D.30153 != 0) goto <D.30214>; else goto <D.30215>;
      <D.30214>:
      D.30216 = acfg->need_no_dead_strip;
      if (D.30216 != 0) goto <D.30217>; else goto <D.30218>;
      <D.30217>:
      D.30201 = acfg->fp;
      fprintf (D.30201, "\n");
      i = 0;
      goto <D.26044>;
      <D.26043>:
      D.30156 = acfg->cfgs;
      D.30157 = (long unsigned int) i;
      D.30158 = D.30157 * 8;
      D.30159 = D.30156 + D.30158;
      D.30160 = *D.30159;
      if (D.30160 != 0B) goto <D.30219>; else goto <D.30220>;
      <D.30219>:
      D.30156 = acfg->cfgs;
      D.30157 = (long unsigned int) i;
      D.30158 = D.30157 * 8;
      D.30159 = D.30156 + D.30158;
      D.30160 = *D.30159;
      D.30163 = BIT_FIELD_REF <*D.30160, 8, 5608>;
      D.30164 = D.30163 & 1;
      if (D.30164 != 0) goto <D.30221>; else goto <D.30222>;
      <D.30221>:
      D.30156 = acfg->cfgs;
      D.30157 = (long unsigned int) i;
      D.30158 = D.30157 * 8;
      D.30159 = D.30156 + D.30158;
      D.30160 = *D.30159;
      D.30167 = D.30160->asm_symbol;
      D.30201 = acfg->fp;
      fprintf (D.30201, ".no_dead_strip %s\n", D.30167);
      <D.30222>:
      <D.30220>:
      i = i + 1;
      <D.26044>:
      i.100 = (unsigned int) i;
      D.30170 = acfg->nmethods;
      if (i.100 < D.30170) goto <D.26043>; else goto <D.26045>;
      <D.26045>:
      <D.30218>:
      <D.30215>:
      sprintf (&symbol, "code_offsets");
      emit_section_change (acfg, ".rodata", 1);
      emit_alignment (acfg, 8);
      emit_label (acfg, &symbol);
      D.30223 = acfg->stats.offsets_size;
      D.30224 = (unsigned int) D.30223;
      D.30170 = acfg->nmethods;
      D.30225 = D.30170 * 4;
      D.30226 = D.30224 + D.30225;
      D.30227 = (int) D.30226;
      acfg->stats.offsets_size = D.30227;
      i = 0;
      goto <D.26047>;
      <D.26046>:
      D.30156 = acfg->cfgs;
      D.30157 = (long unsigned int) i;
      D.30158 = D.30157 * 8;
      D.30159 = D.30156 + D.30158;
      D.30160 = *D.30159;
      if (D.30160 != 0B) goto <D.30228>; else goto <D.30229>;
      <D.30228>:
      D.30171 = acfg->methods_symbol;
      D.30156 = acfg->cfgs;
      D.30157 = (long unsigned int) i;
      D.30158 = D.30157 * 8;
      D.30159 = D.30156 + D.30158;
      D.30160 = *D.30159;
      D.30167 = D.30160->asm_symbol;
      emit_symbol_diff (acfg, D.30167, D.30171, 0);
      goto <D.30230>;
      <D.30229>:
      emit_int32 (acfg, -1);
      <D.30230>:
      i = i + 1;
      <D.26047>:
      i.100 = (unsigned int) i;
      D.30170 = acfg->nmethods;
      if (i.100 < D.30170) goto <D.26046>; else goto <D.26048>;
      <D.26048>:
      emit_line (acfg);
      sprintf (&symbol, "unbox_trampolines");
      D.30231 = acfg->direct_method_addresses;
      if (D.30231 != 0) goto <D.30232>; else goto <D.30233>;
      <D.30232>:
      emit_section_change (acfg, ".text", 0);
      goto <D.30234>;
      <D.30233>:
      emit_section_change (acfg, ".rodata", 0);
      <D.30234>:
      emit_alignment (acfg, 8);
      emit_label (acfg, &symbol);
      prev_index = -1;
      i = 0;
      goto <D.26054>;
      <D.26053>:
      {
        struct MonoCompile * cfg;
        struct MonoMethod * method;
        int index;

        D.30156 = acfg->cfgs;
        D.30157 = (long unsigned int) i;
        D.30158 = D.30157 * 8;
        D.30159 = D.30156 + D.30158;
        cfg = *D.30159;
        if (cfg == 0B) goto <D.30235>; else goto <D.30236>;
        <D.30235>:
        // predicted unlikely by continue predictor.
        goto <D.26052>;
        <D.30236>:
        method = cfg->orig_method;
        D.30184 = acfg->aot_opts.full_aot;
        if (D.30184 != 0) goto <D.30237>; else goto <D.30238>;
        <D.30237>:
        D.30239 = cfg->orig_method;
        D.30240 = D.30239->klass;
        D.30241 = BIT_FIELD_REF <*D.30240, 8, 256>;
        D.30242 = D.30241 & 8;
        if (D.30242 != 0) goto <D.30243>; else goto <D.30244>;
        <D.30243>:
        D.30245 = get_method_index (acfg, method);
        index = (int) D.30245;
        sprintf (&symbol, "ut_%d", index);
        emit_int32 (acfg, index);
        D.30231 = acfg->direct_method_addresses;
        if (D.30231 != 0) goto <D.30246>; else goto <D.30247>;
        <D.30246>:
        emit_unset_mode (acfg);
        D.30194 = acfg->thumb_mixed;
        if (D.30194 != 0) goto <D.30250>; else goto <D.30248>;
        <D.30250>:
        D.30251 = BIT_FIELD_REF <*cfg, 8, 5608>;
        D.30252 = D.30251 & 1;
        if (D.30252 != 0) goto <D.30253>; else goto <D.30248>;
        <D.30253>:
        D.30201 = acfg->fp;
        fprintf (D.30201, "\n\tblx %s\n", &symbol);
        goto <D.30249>;
        <D.30248>:
        D.30201 = acfg->fp;
        fprintf (D.30201, "\n\tbl %s\n", &symbol);
        <D.30249>:
        goto <D.30254>;
        <D.30247>:
        D.30171 = acfg->methods_symbol;
        emit_symbol_diff (acfg, &symbol, D.30171, 0);
        <D.30254>:
        D.30255 = index <= prev_index;
        D.30256 = (long int) D.30255;
        D.30257 = __builtin_expect (D.30256, 0);
        if (D.30257 != 0) goto <D.30258>; else goto <D.30259>;
        <D.30258>:
        monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "aot-compiler.c", 7246, "index > prev_index");
        <D.30259>:
        prev_index = index;
        <D.30244>:
        <D.30238>:
      }
      <D.26052>:
      i = i + 1;
      <D.26054>:
      i.100 = (unsigned int) i;
      D.30170 = acfg->nmethods;
      if (i.100 < D.30170) goto <D.26053>; else goto <D.26055>;
      <D.26055>:
      sprintf (&symbol, "unbox_trampolines_end");
      emit_label (acfg, &symbol);
      emit_int32 (acfg, 0);
    }
  finally
    {
      symbol = {CLOBBER};
    }
}


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

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


arch_emit_unbox_trampoline (struct MonoAotCompile * acfg, struct MonoCompile * cfg, struct MonoMethod * method, const char * call_target)
{
  unsigned char iftmp.102;
  guint8 * code.103;
  unsigned char D.30270;
  guint8 * code.104;
  guint8 * code.105;
  signed char D.30273;
  signed char D.30274;
  signed char D.30275;
  unsigned char D.30276;
  guint8 * code.106;
  unsigned char D.30283;
  guint8 * code.107;
  guint8 * code.108;
  unsigned char D.30286;
  guint8 * code.109;
  unsigned char D.30288;
  guint8 * code.110;
  unsigned char D.30290;
  guint8 * code.111;
  unsigned char D.30292;
  unsigned char iftmp.112;
  guint8 * code.113;
  unsigned char D.30301;
  guint8 * code.114;
  guint8 * code.115;
  guint8 * code.116;
  unsigned char D.30305;
  guint8 * code.117;
  unsigned char D.30307;
  guint8 * code.118;
  unsigned char D.30309;
  guint8 * code.119;
  unsigned char D.30311;
  long int code.120;
  long int buf.121;
  long int D.30314;
  int D.30315;
  guint8 buf[32];
  guint8 * code;
  int this_reg;

  try
    {
      this_reg = mono_arch_get_this_arg_reg (0B);
      code = &buf;
      if (1 != 0) goto <D.30261>; else goto <D.30262>;
      <D.30261>:
      {
        unsigned char _amd64_rex_bits;

        if (this_reg > 7) goto <D.30264>; else goto <D.30265>;
        <D.30264>:
        iftmp.102 = 9;
        goto <D.30266>;
        <D.30265>:
        iftmp.102 = 8;
        <D.30266>:
        _amd64_rex_bits = iftmp.102;
        if (_amd64_rex_bits != 0) goto <D.30267>; else goto <D.30268>;
        <D.30267>:
        code.103 = code;
        code = code.103 + 1;
        D.30270 = _amd64_rex_bits | 64;
        *code.103 = D.30270;
        <D.30268>:
      }
      code.104 = code;
      code = code.104 + 1;
      *code.104 = 131;
      code.105 = code;
      code = code.105 + 1;
      D.30273 = (signed char) this_reg;
      D.30274 = D.30273 & 7;
      D.30275 = D.30274 | -64;
      D.30276 = (unsigned char) D.30275;
      *code.105 = D.30276;
      *code = 16;
      code = code + 1;
      goto <D.30277>;
      <D.30262>:
      if (this_reg == 0) goto <D.30278>; else goto <D.30279>;
      <D.30278>:
      {
        unsigned char _amd64_rex_bits;

        _amd64_rex_bits = 8;
        if (_amd64_rex_bits != 0) goto <D.30280>; else goto <D.30281>;
        <D.30280>:
        code.106 = code;
        code = code.106 + 1;
        D.30283 = _amd64_rex_bits | 64;
        *code.106 = D.30283;
        <D.30281>:
      }
      code.107 = code;
      code = code.107 + 1;
      *code.107 = 5;
      {
        union x86_imm_buf imb;

        try
          {
            imb.val = 16;
            code.108 = code;
            code = code.108 + 1;
            D.30286 = imb.b[0];
            *code.108 = D.30286;
            code.109 = code;
            code = code.109 + 1;
            D.30288 = imb.b[1];
            *code.109 = D.30288;
            code.110 = code;
            code = code.110 + 1;
            D.30290 = imb.b[2];
            *code.110 = D.30290;
            code.111 = code;
            code = code.111 + 1;
            D.30292 = imb.b[3];
            *code.111 = D.30292;
          }
        finally
          {
            imb = {CLOBBER};
          }
      }
      goto <D.30293>;
      <D.30279>:
      {
        unsigned char _amd64_rex_bits;

        if (this_reg > 7) goto <D.30295>; else goto <D.30296>;
        <D.30295>:
        iftmp.112 = 9;
        goto <D.30297>;
        <D.30296>:
        iftmp.112 = 8;
        <D.30297>:
        _amd64_rex_bits = iftmp.112;
        if (_amd64_rex_bits != 0) goto <D.30298>; else goto <D.30299>;
        <D.30298>:
        code.113 = code;
        code = code.113 + 1;
        D.30301 = _amd64_rex_bits | 64;
        *code.113 = D.30301;
        <D.30299>:
      }
      code.114 = code;
      code = code.114 + 1;
      *code.114 = 129;
      code.115 = code;
      code = code.115 + 1;
      D.30273 = (signed char) this_reg;
      D.30274 = D.30273 & 7;
      D.30275 = D.30274 | -64;
      D.30276 = (unsigned char) D.30275;
      *code.115 = D.30276;
      {
        union x86_imm_buf imb;

        try
          {
            imb.val = 16;
            code.116 = code;
            code = code.116 + 1;
            D.30305 = imb.b[0];
            *code.116 = D.30305;
            code.117 = code;
            code = code.117 + 1;
            D.30307 = imb.b[1];
            *code.117 = D.30307;
            code.118 = code;
            code = code.118 + 1;
            D.30309 = imb.b[2];
            *code.118 = D.30309;
            code.119 = code;
            code = code.119 + 1;
            D.30311 = imb.b[3];
            *code.119 = D.30311;
          }
        finally
          {
            imb = {CLOBBER};
          }
      }
      <D.30293>:
      <D.30277>:
      code.120 = (long int) code;
      buf.121 = (long int) &buf;
      D.30314 = code.120 - buf.121;
      D.30315 = (int) D.30314;
      emit_bytes (acfg, &buf, D.30315);
      emit_byte (acfg, 233);
      emit_symbol_diff (acfg, call_target, ".", -4);
    }
  finally
    {
      buf = {CLOBBER};
    }
}


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

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


emit_byte (struct MonoAotCompile * acfg, guint8 val)
{
  int D.30317;
  struct MonoImageWriter * D.30318;

  D.30317 = (int) val;
  D.30318 = acfg->w;
  img_writer_emit_byte (D.30318, D.30317);
}


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

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


emit_method_code (struct MonoAotCompile * acfg, struct MonoCompile * cfg)
{
  unsigned int D.30320;
  const char * D.30321;
  int D.30322;
  int D.30325;
  char * D.30328;
  struct FILE * D.30329;
  int D.30330;
  struct GHashTable * D.30335;
  struct GHashTable * D.30338;
  unsigned int D.30341;
  char * D.30344;
  int D.30345;
  unsigned int D.30346;
  unsigned int D.30347;
  unsigned int D.30348;
  int D.30349;
  struct MonoCompile * * D.30350;
  long unsigned int D.30351;
  long unsigned int D.30352;
  struct MonoCompile * * D.30353;
  struct MonoCompile * D.30354;
  unsigned int D.30355;
  struct MonoDomain * D.30356;
  struct MonoJitInfo * D.30357;
  struct MonoMethod * D.30358;
  struct MonoDebugMethodJitInfo * D.30359;
  struct MonoJumpInfo * D.30360;
  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.30320 = get_method_index (acfg, method);
  method_index = (int) D.30320;
  D.30321 = acfg->temp_prefix;
  symbol = monoeg_g_strdup_printf ("%sme_%x", D.30321, method_index);
  emit_section_change (acfg, ".text", 0);
  emit_alignment (acfg, func_alignment);
  D.30322 = acfg->global_symbols;
  if (D.30322 != 0) goto <D.30323>; else goto <D.30324>;
  <D.30323>:
  D.30325 = acfg->need_no_dead_strip;
  if (D.30325 != 0) goto <D.30326>; else goto <D.30327>;
  <D.30326>:
  D.30328 = cfg->asm_symbol;
  D.30329 = acfg->fp;
  fprintf (D.30329, "\t.no_dead_strip %s\n", D.30328);
  <D.30327>:
  <D.30324>:
  D.30328 = cfg->asm_symbol;
  emit_label (acfg, D.30328);
  D.30330 = acfg->aot_opts.write_symbols;
  if (D.30330 != 0) goto <D.30331>; else goto <D.30332>;
  <D.30331>:
  D.30322 = acfg->global_symbols;
  if (D.30322 == 0) goto <D.30333>; else goto <D.30334>;
  <D.30333>:
  D.30335 = acfg->method_label_hash;
  debug_sym = get_debug_sym (method, "", D.30335);
  D.30325 = acfg->need_no_dead_strip;
  if (D.30325 != 0) goto <D.30336>; else goto <D.30337>;
  <D.30336>:
  D.30329 = acfg->fp;
  fprintf (D.30329, "\t.no_dead_strip %s\n", debug_sym);
  <D.30337>:
  emit_local_symbol (acfg, debug_sym, symbol, 1);
  emit_label (acfg, debug_sym);
  <D.30334>:
  <D.30332>:
  D.30338 = acfg->export_names;
  export_name = monoeg_g_hash_table_lookup (D.30338, method);
  if (export_name != 0B) goto <D.30339>; else goto <D.30340>;
  <D.30339>:
  emit_global_inner (acfg, export_name, 1);
  emit_label (acfg, export_name);
  <D.30340>:
  D.30341 = cfg->verbose_level;
  if (D.30341 != 0) goto <D.30342>; else goto <D.30343>;
  <D.30342>:
  D.30328 = cfg->asm_symbol;
  D.30344 = mono_method_full_name (method, 1);
  monoeg_g_print ("Method %s emitted as %s\n", D.30344, D.30328);
  <D.30343>:
  D.30345 = acfg->stats.code_size;
  D.30346 = (unsigned int) D.30345;
  D.30347 = cfg->code_len;
  D.30348 = D.30346 + D.30347;
  D.30349 = (int) D.30348;
  acfg->stats.code_size = D.30349;
  D.30350 = acfg->cfgs;
  D.30351 = (long unsigned int) method_index;
  D.30352 = D.30351 * 8;
  D.30353 = D.30350 + D.30352;
  D.30354 = *D.30353;
  D.30355 = acfg->got_offset;
  D.30354->got_offset = D.30355;
  D.30356 = mono_domain_get ();
  D.30357 = cfg->jit_info;
  D.30358 = D.30357->d.method;
  D.30359 = mono_debug_find_method (D.30358, D.30356);
  D.30360 = cfg->patch_info;
  D.30347 = cfg->code_len;
  emit_and_reloc_code (acfg, method, code, D.30347, D.30360, 0, D.30359);
  emit_line (acfg);
  D.30330 = acfg->aot_opts.write_symbols;
  if (D.30330 != 0) goto <D.30361>; else goto <D.30362>;
  <D.30361>:
  emit_symbol_size (acfg, debug_sym, ".");
  monoeg_g_free (debug_sym);
  <D.30362>:
  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.30363;

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


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

  D.30364 = acfg->w;
  img_writer_emit_global (D.30364, 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.30367;
  int D.30368;
  _Bool D.30371;
  _Bool D.30372;
  _Bool D.30373;
  int code_len.122;
  struct FILE * D.30379;
  void * * D.30380;
  long unsigned int D.30381;
  long unsigned int D.30382;
  void * * D.30383;
  int D.30384;
  unsigned int pindex.123;
  unsigned int D.30387;
  long unsigned int D.30390;
  long unsigned int D.30391;
  struct MonoDebugSourceLocation * * D.30392;
  struct MonoDebugSourceLocation * D.30393;
  char * D.30396;
  unsigned int D.30397;
  <unnamed type> D.30404;
  sizetype D.30405;
  guint8 * D.30406;
  int code_size.124;
  int D.30408;
  struct GHashTable * D.30409;
  struct GHashTable * D.30412;
  struct GPtrArray * D.30413;
  struct GPtrArray * D.30416;
  void * D.30417;
  long int D.30418;
  const void * D.30422;
  int D.30423;
  long unsigned int D.30424;
  void * D.30425;
  int D.30426;
  int D.30427;
  int code_size.125;
  int D.30429;
  struct MonoMethod * D.30433;
  struct MonoClass * D.30434;
  struct MonoImage * D.30435;
  struct MonoImage * D.30436;
  int D.30440;
  struct GHashTable * D.30443;
  int D.30444;
  int D.30445;
  int D.30446;
  int D.30447;
  int D.30452;
  short unsigned int D.30455;
  int D.30456;
  int D.30457;
  long unsigned int D.30463;
  _Bool D.30464;
  long int D.30465;
  long int D.30466;
  const char * D.30469;
  const char * D.30473;
  _Bool D.30474;
  _Bool D.30475;
  _Bool D.30476;
  int D.30479;
  long unsigned int D.30482;
  _Bool D.30483;
  long int D.30484;
  long int D.30485;
  _Bool D.30491;
  _Bool D.30492;
  const void * D.30497;
  const void * D.30498;
  long unsigned int D.30501;
  _Bool D.30502;
  long int D.30503;
  long int D.30504;
  int D.30509;
  int call_size.126;
  int D.30517;
  int got_slot.127;
  int code_size.128;
  int D.30521;
  long unsigned int D.30531;
  long unsigned int D.30532;
  struct MonoDebugSourceLocation * * D.30533;
  struct MonoDebugSourceLocation * D.30534;
  int D.30536;
  const guint8 * D.30537;
  unsigned int i.129;
  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.30365>; else goto <D.30366>;
  <D.30365>:
  header = mono_method_get_header (method);
  D.30367 = get_method_index (acfg, method);
  method_index = (int) D.30367;
  <D.30366>:
  D.30368 = acfg->gas_line_numbers;
  if (D.30368 != 0) goto <D.30369>; else goto <D.30370>;
  <D.30369>:
  D.30371 = method != 0B;
  D.30372 = debug_info != 0B;
  D.30373 = D.30371 & D.30372;
  if (D.30373 != 0) goto <D.30374>; else goto <D.30375>;
  <D.30374>:
  code_len.122 = (int) code_len;
  locs = compute_line_numbers (method, code_len.122, debug_info);
  if (locs == 0B) goto <D.30377>; else goto <D.30378>;
  <D.30377>:
  {
    int findex;

    findex = get_file_index (acfg, "<unknown>");
    emit_unset_mode (acfg);
    D.30379 = acfg->fp;
    fprintf (D.30379, ".loc %d %d 0\n", findex, 1);
  }
  <D.30378>:
  <D.30375>:
  <D.30370>:
  patches = monoeg_g_ptr_array_new ();
  patch_info = relocs;
  goto <D.25271>;
  <D.25270>:
  monoeg_g_ptr_array_add (patches, patch_info);
  patch_info = patch_info->next;
  <D.25271>:
  if (patch_info != 0B) goto <D.25270>; else goto <D.25272>;
  <D.25272>:
  monoeg_g_ptr_array_sort (patches, compare_patches);
  start_index = 0;
  i = 0;
  goto <D.25302>;
  <D.25301>:
  patch_info = 0B;
  pindex = start_index;
  goto <D.25275>;
  <D.25274>:
  D.30380 = patches->pdata;
  D.30381 = (long unsigned int) pindex;
  D.30382 = D.30381 * 8;
  D.30383 = D.30380 + D.30382;
  patch_info = *D.30383;
  D.30384 = patch_info->ip.i;
  if (D.30384 >= i) goto <D.25273>; else goto <D.30385>;
  <D.30385>:
  pindex = pindex + 1;
  <D.25275>:
  pindex.123 = (unsigned int) pindex;
  D.30387 = patches->len;
  if (pindex.123 < D.30387) goto <D.25274>; else goto <D.25273>;
  <D.25273>:
  if (locs != 0B) goto <D.30388>; else goto <D.30389>;
  <D.30388>:
  D.30390 = (long unsigned int) i;
  D.30391 = D.30390 * 8;
  D.30392 = locs + D.30391;
  D.30393 = *D.30392;
  if (D.30393 != 0B) goto <D.30394>; else goto <D.30395>;
  <D.30394>:
  {
    struct MonoDebugSourceLocation * loc;
    int findex;

    D.30390 = (long unsigned int) i;
    D.30391 = D.30390 * 8;
    D.30392 = locs + D.30391;
    loc = *D.30392;
    D.30396 = loc->source_file;
    findex = get_file_index (acfg, D.30396);
    emit_unset_mode (acfg);
    D.30397 = loc->row;
    D.30379 = acfg->fp;
    fprintf (D.30379, ".loc %d %d 0\n", findex, D.30397);
    mono_debug_symfile_free_location (loc);
  }
  <D.30395>:
  <D.30389>:
  skip = 0;
  if (patch_info != 0B) goto <D.30398>; else goto <D.30399>;
  <D.30398>:
  D.30384 = patch_info->ip.i;
  if (D.30384 == i) goto <D.30400>; else goto <D.30401>;
  <D.30400>:
  pindex.123 = (unsigned int) pindex;
  D.30387 = patches->len;
  if (pindex.123 < D.30387) goto <D.30402>; else goto <D.30403>;
  <D.30402>:
  start_index = pindex;
  D.30404 = patch_info->type;
  switch (D.30404) <default: <D.25286>, case 27: <D.25280>, case 49: <D.25282>, case 51: <D.25278>>
  <D.25278>:
  goto <D.25279>;
  <D.25280>:
  {
    int code_size;

    try
      {
        D.30405 = (sizetype) i;
        D.30406 = code + D.30405;
        arch_emit_got_offset (acfg, D.30406, &code_size);
        code_size.124 = code_size;
        D.30408 = code_size.124 + -1;
        i = D.30408 + i;
        skip = 1;
        patch_info->type = 51;
        goto <D.25279>;
      }
    finally
      {
        code_size = {CLOBBER};
      }
  }
  <D.25282>:
  {
    int code_size;
    int index;
    char * selector;

    try
      {
        selector = patch_info->data.target;
        D.30409 = acfg->objc_selector_to_index;
        if (D.30409 == 0B) goto <D.30410>; else goto <D.30411>;
        <D.30410>:
        D.30412 = monoeg_g_hash_table_new (monoeg_g_str_hash, monoeg_g_str_equal);
        acfg->objc_selector_to_index = D.30412;
        <D.30411>:
        D.30413 = acfg->objc_selectors;
        if (D.30413 == 0B) goto <D.30414>; else goto <D.30415>;
        <D.30414>:
        D.30416 = monoeg_g_ptr_array_new ();
        acfg->objc_selectors = D.30416;
        <D.30415>:
        D.30409 = acfg->objc_selector_to_index;
        D.30417 = monoeg_g_hash_table_lookup (D.30409, selector);
        D.30418 = (long int) D.30417;
        index = (int) D.30418;
        if (index != 0) goto <D.30419>; else goto <D.30420>;
        <D.30419>:
        index = index + -1;
        goto <D.30421>;
        <D.30420>:
        index = acfg->objc_selector_index;
        D.30422 = patch_info->data.target;
        D.30413 = acfg->objc_selectors;
        monoeg_g_ptr_array_add (D.30413, D.30422);
        D.30423 = index + 1;
        D.30424 = (long unsigned int) D.30423;
        D.30425 = (void *) D.30424;
        D.30409 = acfg->objc_selector_to_index;
        monoeg_g_hash_table_insert_replace (D.30409, selector, D.30425, 0);
        D.30426 = acfg->objc_selector_index;
        D.30427 = D.30426 + 1;
        acfg->objc_selector_index = D.30427;
        <D.30421>:
        D.30405 = (sizetype) i;
        D.30406 = code + D.30405;
        arch_emit_objc_selector_ref (acfg, D.30406, index, &code_size);
        code_size.125 = code_size;
        D.30429 = code_size.125 + -1;
        i = D.30429 + i;
        skip = 1;
        patch_info->type = 51;
        goto <D.25279>;
      }
    finally
      {
        code_size = {CLOBBER};
      }
  }
  <D.25286>:
  direct_call = 0;
  external_call = 0;
  D.30404 = patch_info->type;
  if (D.30404 == 3) goto <D.30432>; else goto <D.30430>;
  <D.30432>:
  D.30433 = patch_info->data.method;
  D.30434 = D.30433->klass;
  D.30435 = D.30434->image;
  D.30436 = acfg->image;
  if (D.30435 == D.30436) goto <D.30437>; else goto <D.30430>;
  <D.30437>:
  if (got_only == 0) goto <D.30438>; else goto <D.30439>;
  <D.30438>:
  D.30440 = is_direct_callable (acfg, method, patch_info);
  if (D.30440 != 0) goto <D.30441>; else goto <D.30442>;
  <D.30441>:
  {
    struct MonoCompile * callee_cfg;

    D.30433 = patch_info->data.method;
    D.30443 = acfg->method_to_cfg;
    callee_cfg = monoeg_g_hash_table_lookup (D.30443, D.30433);
    direct_call = 1;
    direct_call_target = callee_cfg->asm_symbol;
    patch_info->type = 51;
    D.30444 = acfg->stats.direct_calls;
    D.30445 = D.30444 + 1;
    acfg->stats.direct_calls = D.30445;
  }
  <D.30442>:
  <D.30439>:
  D.30446 = acfg->stats.all_calls;
  D.30447 = D.30446 + 1;
  acfg->stats.all_calls = D.30447;
  goto <D.30431>;
  <D.30430>:
  D.30404 = patch_info->type;
  if (D.30404 == 31) goto <D.30448>; else goto <D.30449>;
  <D.30448>:
  if (got_only == 0) goto <D.30450>; else goto <D.30451>;
  <D.30450>:
  D.30452 = is_direct_callable (acfg, method, patch_info);
  if (D.30452 != 0) goto <D.30453>; else goto <D.30454>;
  <D.30453>:
  D.30433 = patch_info->data.method;
  D.30455 = D.30433->flags;
  D.30456 = (int) D.30455;
  D.30457 = D.30456 & 8192;
  if (D.30457 == 0) goto <D.30458>; else goto <D.30459>;
  <D.30458>:
  D.30433 = patch_info->data.method;
  direct_pinvoke = mono_lookup_icall_symbol (D.30433);
  goto <D.30460>;
  <D.30459>:
  D.30433 = patch_info->data.method;
  direct_pinvoke = get_pinvoke_import (acfg, D.30433);
  <D.30460>:
  if (direct_pinvoke != 0B) goto <D.30461>; else goto <D.30462>;
  <D.30461>:
  direct_call = 1;
  D.30463 = strlen (direct_pinvoke);
  D.30464 = D.30463 > 999;
  D.30465 = (long int) D.30464;
  D.30466 = __builtin_expect (D.30465, 0);
  if (D.30466 != 0) goto <D.30467>; else goto <D.30468>;
  <D.30467>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "aot-compiler.c", 4615, "strlen (direct_pinvoke) < 1000");
  <D.30468>:
  D.30469 = acfg->user_symbol_prefix;
  direct_call_target = monoeg_g_strdup_printf ("%s%s", D.30469, direct_pinvoke);
  <D.30462>:
  <D.30454>:
  <D.30451>:
  goto <D.30470>;
  <D.30449>:
  D.30404 = patch_info->type;
  if (D.30404 == 32) goto <D.30471>; else goto <D.30472>;
  <D.30471>:
  {
    const char * sym;

    D.30473 = patch_info->data.name;
    sym = mono_lookup_jit_icall_symbol (D.30473);
    D.30474 = got_only == 0;
    D.30475 = sym != 0B;
    D.30476 = D.30474 & D.30475;
    if (D.30476 != 0) goto <D.30477>; else goto <D.30478>;
    <D.30477>:
    D.30479 = acfg->aot_opts.direct_icalls;
    if (D.30479 != 0) goto <D.30480>; else goto <D.30481>;
    <D.30480>:
    direct_call = 1;
    external_call = 1;
    D.30482 = strlen (sym);
    D.30483 = D.30482 > 999;
    D.30484 = (long int) D.30483;
    D.30485 = __builtin_expect (D.30484, 0);
    if (D.30485 != 0) goto <D.30486>; else goto <D.30487>;
    <D.30486>:
    monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "aot-compiler.c", 4625, "strlen (sym) < 1000");
    <D.30487>:
    D.30469 = acfg->user_symbol_prefix;
    direct_call_target = monoeg_g_strdup_printf ("%s%s", D.30469, sym);
    <D.30481>:
    <D.30478>:
  }
  goto <D.30488>;
  <D.30472>:
  D.30404 = patch_info->type;
  if (D.30404 == 7) goto <D.30489>; else goto <D.30490>;
  <D.30489>:
  {
    struct MonoJitICallInfo * info;
    const char * sym;

    D.30473 = patch_info->data.name;
    info = mono_find_jit_icall_by_name (D.30473);
    D.30473 = patch_info->data.name;
    sym = mono_lookup_jit_icall_symbol (D.30473);
    D.30474 = got_only == 0;
    D.30491 = sym != 0B;
    D.30492 = D.30474 & D.30491;
    if (D.30492 != 0) goto <D.30493>; else goto <D.30494>;
    <D.30493>:
    D.30479 = acfg->aot_opts.direct_icalls;
    if (D.30479 != 0) goto <D.30495>; else goto <D.30496>;
    <D.30495>:
    D.30497 = info->func;
    D.30498 = info->wrapper;
    if (D.30497 == D.30498) goto <D.30499>; else goto <D.30500>;
    <D.30499>:
    direct_call = 1;
    external_call = 1;
    D.30501 = strlen (sym);
    D.30502 = D.30501 > 999;
    D.30503 = (long int) D.30502;
    D.30504 = __builtin_expect (D.30503, 0);
    if (D.30504 != 0) goto <D.30505>; else goto <D.30506>;
    <D.30505>:
    monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "aot-compiler.c", 4635, "strlen (sym) < 1000");
    <D.30506>:
    D.30469 = acfg->user_symbol_prefix;
    direct_call_target = monoeg_g_strdup_printf ("%s%s", D.30469, sym);
    <D.30500>:
    <D.30496>:
    <D.30494>:
  }
  <D.30490>:
  <D.30488>:
  <D.30470>:
  <D.30431>:
  if (direct_call != 0) goto <D.30507>; else goto <D.30508>;
  <D.30507>:
  patch_info->type = 51;
  D.30444 = acfg->stats.direct_calls;
  D.30445 = D.30444 + 1;
  acfg->stats.direct_calls = D.30445;
  <D.30508>:
  D.30509 = got_only | direct_call;
  if (D.30509 == 0) goto <D.30510>; else goto <D.30511>;
  <D.30510>:
  {
    struct MonoPltEntry * plt_entry;

    plt_entry = get_plt_entry (acfg, patch_info);
    if (plt_entry != 0B) goto <D.30512>; else goto <D.30513>;
    <D.30512>:
    direct_call = 1;
    direct_call_target = plt_entry->symbol;
    patch_info->type = 51;
    plt_entry->jit_used = 1;
    <D.30513>:
  }
  <D.30511>:
  if (direct_call != 0) goto <D.30514>; else goto <D.30515>;
  <D.30514>:
  {
    int call_size;

    try
      {
        arch_emit_direct_call (acfg, direct_call_target, external_call, patch_info, &call_size);
        call_size.126 = call_size;
        D.30517 = call_size.126 + -1;
        i = D.30517 + i;
      }
    finally
      {
        call_size = {CLOBBER};
      }
  }
  goto <D.30518>;
  <D.30515>:
  {
    int code_size;

    try
      {
        got_slot = get_got_offset (acfg, patch_info);
        got_slot.127 = (int) got_slot;
        D.30405 = (sizetype) i;
        D.30406 = code + D.30405;
        arch_emit_got_access (acfg, D.30406, got_slot.127, &code_size);
        code_size.128 = code_size;
        D.30521 = code_size.128 + -1;
        i = D.30521 + i;
      }
    finally
      {
        code_size = {CLOBBER};
      }
  }
  <D.30518>:
  skip = 1;
  <D.25279>:
  <D.30403>:
  <D.30401>:
  <D.30399>:
  if (skip == 0) goto <D.30522>; else goto <D.30523>;
  <D.30522>:
  patch_info = 0B;
  pindex = start_index;
  goto <D.25296>;
  <D.25295>:
  D.30380 = patches->pdata;
  D.30381 = (long unsigned int) pindex;
  D.30382 = D.30381 * 8;
  D.30383 = D.30380 + D.30382;
  patch_info = *D.30383;
  D.30384 = patch_info->ip.i;
  if (D.30384 >= i) goto <D.25294>; else goto <D.30524>;
  <D.30524>:
  pindex = pindex + 1;
  <D.25296>:
  pindex.123 = (unsigned int) pindex;
  D.30387 = patches->len;
  if (pindex.123 < D.30387) goto <D.25295>; else goto <D.25294>;
  <D.25294>:
  pindex.123 = (unsigned int) pindex;
  D.30387 = patches->len;
  if (pindex.123 < D.30387) goto <D.30527>; else goto <D.30525>;
  <D.30527>:
  D.30384 = patch_info->ip.i;
  if (D.30384 > i) goto <D.30528>; else goto <D.30525>;
  <D.30528>:
  {
    int limit;

    limit = i + 1;
    goto <D.25300>;
    <D.25299>:
    if (locs != 0B) goto <D.30529>; else goto <D.30530>;
    <D.30529>:
    D.30531 = (long unsigned int) limit;
    D.30532 = D.30531 * 8;
    D.30533 = locs + D.30532;
    D.30534 = *D.30533;
    if (D.30534 != 0B) goto <D.25298>; else goto <D.30535>;
    <D.30535>:
    <D.30530>:
    limit = limit + 1;
    <D.25300>:
    D.30384 = patch_info->ip.i;
    if (D.30384 > limit) goto <D.25299>; else goto <D.25298>;
    <D.25298>:
    D.30536 = limit - i;
    D.30405 = (sizetype) i;
    D.30537 = code + D.30405;
    emit_bytes (acfg, D.30537, D.30536);
    i = limit + -1;
  }
  goto <D.30526>;
  <D.30525>:
  D.30405 = (sizetype) i;
  D.30537 = code + D.30405;
  emit_bytes (acfg, D.30537, 1);
  <D.30526>:
  <D.30523>:
  i = i + 1;
  <D.25302>:
  i.129 = (unsigned int) i;
  if (i.129 < code_len) goto <D.25301>; else goto <D.25303>;
  <D.25303>:
  monoeg_g_free (locs);
}


compare_patches (const void * a, const void * b)
{
  struct MonoJumpInfo * D.30542;
  struct MonoJumpInfo * D.30543;
  gint D.30546;
  int i;
  int j;

  D.30542 = MEM[(struct MonoJumpInfo * *)a];
  i = D.30542->ip.i;
  D.30543 = MEM[(struct MonoJumpInfo * *)b];
  j = D.30543->ip.i;
  if (i < j) goto <D.30544>; else goto <D.30545>;
  <D.30544>:
  D.30546 = -1;
  return D.30546;
  <D.30545>:
  if (i > j) goto <D.30547>; else goto <D.30548>;
  <D.30547>:
  D.30546 = 1;
  return D.30546;
  <D.30548>:
  D.30546 = 0;
  return D.30546;
}


compute_line_numbers (struct MonoMethod * method, int code_size, struct MonoDebugMethodJitInfo * debug_info)
{
  struct MonoDebugSourceLocation * * D.30552;
  unsigned int D.30553;
  unsigned int code_size.130;
  _Bool D.30557;
  long int D.30558;
  long int D.30559;
  unsigned int D.30562;
  long unsigned int D.30563;
  long unsigned int D.30564;
  struct MonoDebugLineNumberEntry * D.30565;
  long unsigned int D.30566;
  int D.30567;
  long unsigned int D.30568;
  long unsigned int D.30569;
  long unsigned int D.30570;
  long unsigned int D.30571;
  long unsigned int D.30574;
  long unsigned int D.30575;
  int * D.30576;
  unsigned int j.131;
  unsigned int D.30578;
  unsigned int i.132;
  unsigned int D.30580;
  sizetype D.30583;
  sizetype D.30584;
  sizetype D.30585;
  unsigned int D.30586;
  int D.30587;
  unsigned int D.30588;
  long unsigned int D.30590;
  long unsigned int D.30591;
  long unsigned int D.30592;
  int * D.30593;
  _Bool D.30594;
  _Bool D.30595;
  _Bool D.30596;
  unsigned int il_offset.133;
  char * D.30603;
  unsigned int D.30604;
  unsigned int prev_line.134;
  struct MonoDebugSourceLocation * * D.30611;
  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.30550>; else goto <D.30551>;
  <D.30550>:
  D.30552 = 0B;
  return D.30552;
  <D.30551>:
  D.30553 = debug_info->code_size;
  code_size.130 = (unsigned int) code_size;
  if (D.30553 != code_size.130) goto <D.30555>; else goto <D.30556>;
  <D.30555>:
  D.30552 = 0B;
  return D.30552;
  <D.30556>:
  D.30557 = code_size == 0;
  D.30558 = (long int) D.30557;
  D.30559 = __builtin_expect (D.30558, 0);
  if (D.30559 != 0) goto <D.30560>; else goto <D.30561>;
  <D.30560>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "aot-compiler.c", 4403, "code_size");
  <D.30561>:
  D.30562 = debug_info->num_line_numbers;
  D.30563 = (long unsigned int) D.30562;
  D.30564 = D.30563 * 8;
  ln_array = monoeg_malloc0 (D.30564);
  D.30562 = debug_info->num_line_numbers;
  D.30563 = (long unsigned int) D.30562;
  D.30564 = D.30563 * 8;
  D.30565 = debug_info->line_numbers;
  memcpy (ln_array, D.30565, D.30564);
  D.30562 = debug_info->num_line_numbers;
  D.30566 = (long unsigned int) D.30562;
  qsort (ln_array, D.30566, 8, compare_lne);
  D.30567 = code_size + 1;
  D.30568 = (long unsigned int) D.30567;
  D.30569 = D.30568 * 4;
  native_to_il_offset = monoeg_malloc0 (D.30569);
  i = 0;
  goto <D.25234>;
  <D.25233>:
  {
    int j;
    struct MonoDebugLineNumberEntry * lne;

    D.30570 = (long unsigned int) i;
    D.30571 = D.30570 * 8;
    lne = ln_array + D.30571;
    if (i == 0) goto <D.30572>; else goto <D.30573>;
    <D.30572>:
    j = 0;
    goto <D.25224>;
    <D.25223>:
    D.30574 = (long unsigned int) j;
    D.30575 = D.30574 * 4;
    D.30576 = native_to_il_offset + D.30575;
    *D.30576 = -1;
    j = j + 1;
    <D.25224>:
    j.131 = (unsigned int) j;
    D.30578 = lne->native_offset;
    if (j.131 < D.30578) goto <D.25223>; else goto <D.25225>;
    <D.25225>:
    <D.30573>:
    i.132 = (unsigned int) i;
    D.30562 = debug_info->num_line_numbers;
    D.30580 = D.30562 + 4294967295;
    if (i.132 < D.30580) goto <D.30581>; else goto <D.30582>;
    <D.30581>:
    {
      struct MonoDebugLineNumberEntry * lne_next;

      D.30583 = (sizetype) i;
      D.30584 = D.30583 + 1;
      D.30585 = D.30584 * 8;
      lne_next = ln_array + D.30585;
      D.30578 = lne->native_offset;
      j = (int) D.30578;
      goto <D.25228>;
      <D.25227>:
      D.30574 = (long unsigned int) j;
      D.30575 = D.30574 * 4;
      D.30576 = native_to_il_offset + D.30575;
      D.30586 = lne->il_offset;
      D.30587 = (int) D.30586;
      *D.30576 = D.30587;
      j = j + 1;
      <D.25228>:
      j.131 = (unsigned int) j;
      D.30588 = lne_next->native_offset;
      if (j.131 < D.30588) goto <D.25227>; else goto <D.25229>;
      <D.25229>:
    }
    goto <D.30589>;
    <D.30582>:
    D.30578 = lne->native_offset;
    j = (int) D.30578;
    goto <D.25231>;
    <D.25230>:
    D.30574 = (long unsigned int) j;
    D.30575 = D.30574 * 4;
    D.30576 = native_to_il_offset + D.30575;
    D.30586 = lne->il_offset;
    D.30587 = (int) D.30586;
    *D.30576 = D.30587;
    j = j + 1;
    <D.25231>:
    if (j < code_size) goto <D.25230>; else goto <D.25232>;
    <D.25232>:
    <D.30589>:
  }
  i = i + 1;
  <D.25234>:
  i.132 = (unsigned int) i;
  D.30562 = debug_info->num_line_numbers;
  if (i.132 < D.30562) goto <D.25233>; else goto <D.25235>;
  <D.25235>:
  monoeg_g_free (ln_array);
  D.30590 = (long unsigned int) code_size;
  D.30591 = D.30590 * 8;
  res = monoeg_malloc0 (D.30591);
  prev_il_offset = -1;
  prev_line = -1;
  first = 1;
  i = 0;
  goto <D.25239>;
  <D.25238>:
  {
    int il_offset;

    D.30570 = (long unsigned int) i;
    D.30592 = D.30570 * 4;
    D.30593 = native_to_il_offset + D.30592;
    il_offset = *D.30593;
    D.30594 = il_offset == -1;
    D.30595 = il_offset == prev_il_offset;
    D.30596 = D.30594 | D.30595;
    if (D.30596 != 0) goto <D.30597>; else goto <D.30598>;
    <D.30597>:
    // predicted unlikely by continue predictor.
    goto <D.25237>;
    <D.30598>:
    prev_il_offset = il_offset;
    il_offset.133 = (unsigned int) il_offset;
    loc = mono_debug_symfile_lookup_location (minfo, il_offset.133);
    if (loc == 0B) goto <D.30600>; else goto <D.30602>;
    <D.30602>:
    D.30603 = loc->source_file;
    if (D.30603 == 0B) goto <D.30600>; else goto <D.30601>;
    <D.30600>:
    // predicted unlikely by continue predictor.
    goto <D.25237>;
    <D.30601>:
    D.30604 = loc->row;
    prev_line.134 = (unsigned int) prev_line;
    if (D.30604 == prev_line.134) goto <D.30606>; else goto <D.30607>;
    <D.30606>:
    mono_debug_symfile_free_location (loc);
    // predicted unlikely by continue predictor.
    goto <D.25237>;
    <D.30607>:
    D.30604 = loc->row;
    prev_line = (int) D.30604;
    if (first != 0) goto <D.30608>; else goto <D.30609>;
    <D.30608>:
    *res = loc;
    goto <D.30610>;
    <D.30609>:
    D.30570 = (long unsigned int) i;
    D.30571 = D.30570 * 8;
    D.30611 = res + D.30571;
    *D.30611 = loc;
    <D.30610>:
    first = 0;
  }
  <D.25237>:
  i = i + 1;
  <D.25239>:
  if (i < code_size) goto <D.25238>; else goto <D.25240>;
  <D.25240>:
  D.30552 = res;
  return D.30552;
}


compare_lne (struct MonoDebugLineNumberEntry * a, struct MonoDebugLineNumberEntry * b)
{
  unsigned int D.30613;
  unsigned int D.30614;
  gint D.30617;
  unsigned int D.30618;
  unsigned int D.30619;
  unsigned int D.30620;
  unsigned int D.30621;

  D.30613 = a->native_offset;
  D.30614 = b->native_offset;
  if (D.30613 == D.30614) goto <D.30615>; else goto <D.30616>;
  <D.30615>:
  D.30618 = a->il_offset;
  D.30619 = b->il_offset;
  D.30620 = D.30618 - D.30619;
  D.30617 = (gint) D.30620;
  return D.30617;
  <D.30616>:
  D.30613 = a->native_offset;
  D.30614 = b->native_offset;
  D.30621 = D.30613 - D.30614;
  D.30617 = (gint) D.30621;
  return D.30617;
}


get_file_index (struct MonoAotCompile * acfg, const char * source_file)
{
  struct GHashTable * D.30623;
  struct GHashTable * D.30626;
  void * D.30627;
  long int D.30628;
  unsigned int D.30631;
  unsigned int D.30632;
  long int D.30633;
  void * D.30634;
  gchar * D.30635;
  char * D.30636;
  struct FILE * D.30637;
  int D.30638;
  int findex;

  D.30623 = acfg->dwarf_ln_filenames;
  if (D.30623 == 0B) goto <D.30624>; else goto <D.30625>;
  <D.30624>:
  D.30626 = monoeg_g_hash_table_new (monoeg_g_str_hash, monoeg_g_str_equal);
  acfg->dwarf_ln_filenames = D.30626;
  <D.30625>:
  D.30623 = acfg->dwarf_ln_filenames;
  D.30627 = monoeg_g_hash_table_lookup (D.30623, source_file);
  D.30628 = (long int) D.30627;
  findex = (int) D.30628;
  if (findex == 0) goto <D.30629>; else goto <D.30630>;
  <D.30629>:
  D.30623 = acfg->dwarf_ln_filenames;
  D.30631 = monoeg_g_hash_table_size (D.30623);
  D.30632 = D.30631 + 1;
  findex = (int) D.30632;
  D.30633 = (long int) findex;
  D.30634 = (void *) D.30633;
  D.30635 = monoeg_strdup (source_file);
  D.30623 = acfg->dwarf_ln_filenames;
  monoeg_g_hash_table_insert_replace (D.30623, D.30635, D.30634, 0);
  emit_unset_mode (acfg);
  D.30636 = mono_dwarf_escape_path (source_file);
  D.30637 = acfg->fp;
  fprintf (D.30637, ".file %d \"%s\"\n", findex, D.30636);
  <D.30630>:
  D.30638 = findex;
  return D.30638;
}


arch_emit_got_offset (struct MonoAotCompile * acfg, guint8 * code, int * code_size)
{
  int offset.135;
  char * D.30641;
  unsigned int D.30642;
  int D.30643;
  guint32 offset;

  offset = mono_arch_get_patch_offset (code);
  offset.135 = (int) offset;
  emit_bytes (acfg, code, offset.135);
  offset.135 = (int) offset;
  D.30641 = acfg->got_symbol;
  emit_symbol_diff (acfg, D.30641, ".", offset.135);
  D.30642 = offset + 4;
  D.30643 = (int) D.30642;
  *code_size = D.30643;
}


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.30646;
  struct MonoMethod * D.30648;
  struct MonoClass * D.30649;
  struct MonoImage * D.30650;
  struct MonoImage * D.30651;
  struct GHashTable * D.30653;
  unsigned char D.30660;
  unsigned char D.30661;
  struct MonoMethod * D.30663;
  struct MonoClass * D.30664;
  unsigned int D.30665;
  unsigned int D.30666;
  short unsigned int D.30669;
  int D.30670;
  int D.30671;
  unsigned char D.30675;
  unsigned char D.30676;
  int D.30679;
  int D.30681;
  unsigned char D.30682;
  unsigned char D.30683;
  gboolean D.30688;
  short unsigned int D.30692;
  int D.30693;
  int D.30694;
  int D.30696;
  int D.30701;

  D.30646 = patch_info->type;
  if (D.30646 == 3) goto <D.30647>; else goto <D.30644>;
  <D.30647>:
  D.30648 = patch_info->data.method;
  D.30649 = D.30648->klass;
  D.30650 = D.30649->image;
  D.30651 = acfg->image;
  if (D.30650 == D.30651) goto <D.30652>; else goto <D.30644>;
  <D.30652>:
  {
    struct MonoCompile * callee_cfg;

    D.30648 = patch_info->data.method;
    D.30653 = acfg->method_to_cfg;
    callee_cfg = monoeg_g_hash_table_lookup (D.30653, D.30648);
    if (callee_cfg != 0B) goto <D.30654>; else goto <D.30655>;
    <D.30654>:
    {
      gboolean direct_callable;

      direct_callable = 1;
      if (direct_callable != 0) goto <D.30658>; else goto <D.30659>;
      <D.30658>:
      D.30660 = BIT_FIELD_REF <*callee_cfg, 8, 5632>;
      D.30661 = D.30660 & 1;
      if (D.30661 != 0) goto <D.30656>; else goto <D.30662>;
      <D.30662>:
      D.30663 = callee_cfg->method;
      D.30664 = D.30663->klass;
      D.30665 = D.30664->flags;
      D.30666 = D.30665 & 1048576;
      if (D.30666 == 0) goto <D.30656>; else goto <D.30657>;
      <D.30656>:
      direct_callable = 0;
      <D.30657>:
      <D.30659>:
      D.30663 = callee_cfg->method;
      D.30669 = D.30663->iflags;
      D.30670 = (int) D.30669;
      D.30671 = D.30670 & 32;
      if (D.30671 != 0) goto <D.30672>; else goto <D.30673>;
      <D.30672>:
      if (method == 0B) goto <D.30667>; else goto <D.30674>;
      <D.30674>:
      D.30675 = BIT_FIELD_REF <*method, 8, 256>;
      D.30676 = D.30675 & 124;
      if (D.30676 != 64) goto <D.30667>; else goto <D.30668>;
      <D.30667>:
      direct_callable = 0;
      <D.30668>:
      <D.30673>:
      D.30679 = acfg->aot_opts.soft_debug;
      if (D.30679 != 0) goto <D.30677>; else goto <D.30680>;
      <D.30680>:
      D.30681 = acfg->aot_opts.no_direct_calls;
      if (D.30681 != 0) goto <D.30677>; else goto <D.30678>;
      <D.30677>:
      direct_callable = 0;
      <D.30678>:
      D.30663 = callee_cfg->method;
      D.30682 = BIT_FIELD_REF <*D.30663, 8, 256>;
      D.30683 = D.30682 & 124;
      if (D.30683 == 112) goto <D.30684>; else goto <D.30685>;
      <D.30684>:
      direct_callable = 0;
      <D.30685>:
      if (direct_callable != 0) goto <D.30686>; else goto <D.30687>;
      <D.30686>:
      D.30688 = 1;
      return D.30688;
      <D.30687>:
    }
    <D.30655>:
  }
  goto <D.30645>;
  <D.30644>:
  D.30646 = patch_info->type;
  if (D.30646 == 31) goto <D.30691>; else goto <D.30689>;
  <D.30691>:
  D.30648 = patch_info->data.method;
  D.30692 = D.30648->flags;
  D.30693 = (int) D.30692;
  D.30694 = D.30693 & 8192;
  if (D.30694 != 0) goto <D.30695>; else goto <D.30689>;
  <D.30695>:
  D.30696 = acfg->aot_opts.direct_pinvoke;
  if (D.30696 != 0) goto <D.30697>; else goto <D.30698>;
  <D.30697>:
  D.30688 = 1;
  return D.30688;
  <D.30698>:
  goto <D.30690>;
  <D.30689>:
  D.30646 = patch_info->type;
  if (D.30646 == 31) goto <D.30699>; else goto <D.30700>;
  <D.30699>:
  D.30701 = acfg->aot_opts.direct_icalls;
  if (D.30701 != 0) goto <D.30702>; else goto <D.30703>;
  <D.30702>:
  D.30688 = 1;
  return D.30688;
  <D.30703>:
  D.30688 = 0;
  return D.30688;
  <D.30700>:
  <D.30690>:
  <D.30645>:
  D.30688 = 0;
  return D.30688;
}


get_pinvoke_import (struct MonoAotCompile * acfg, struct MonoMethod * method)
{
  struct MonoClass * D.30705;
  struct GHashTable * D.30706;
  const char * D.30709;
  short unsigned int D.30712;
  int D.30714;
  <unnamed-unsigned:24> D.30715;
  int D.30716;
  int D.30717;
  unsigned int D.30720;
  <unnamed-unsigned:24> D.30722;
  unsigned int D.30723;
  unsigned int D.30724;
  const char * D.30725;
  struct MonoImage * image;
  struct MonoMethodPInvoke * piinfo;
  struct MonoTableInfo * tables;
  struct MonoTableInfo * im;
  struct MonoTableInfo * mr;
  guint32 im_cols[4];
  char * import;

  try
    {
      D.30705 = method->klass;
      image = D.30705->image;
      piinfo = method;
      tables = &image->tables;
      im = tables + 448;
      mr = tables + 416;
      D.30706 = acfg->method_to_pinvoke_import;
      import = monoeg_g_hash_table_lookup (D.30706, method);
      if (import != 0B) goto <D.30707>; else goto <D.30708>;
      <D.30707>:
      D.30709 = import;
      return D.30709;
      <D.30708>:
      D.30712 = piinfo->implmap_idx;
      if (D.30712 == 0) goto <D.30710>; else goto <D.30713>;
      <D.30713>:
      D.30712 = piinfo->implmap_idx;
      D.30714 = (int) D.30712;
      D.30715 = im->rows;
      D.30716 = (int) D.30715;
      if (D.30714 > D.30716) goto <D.30710>; else goto <D.30711>;
      <D.30710>:
      D.30709 = 0B;
      return D.30709;
      <D.30711>:
      D.30712 = piinfo->implmap_idx;
      D.30714 = (int) D.30712;
      D.30717 = D.30714 + -1;
      mono_metadata_decode_row (im, D.30717, &im_cols, 4);
      D.30720 = im_cols[3];
      if (D.30720 == 0) goto <D.30718>; else goto <D.30721>;
      <D.30721>:
      D.30720 = im_cols[3];
      D.30722 = mr->rows;
      D.30723 = (unsigned int) D.30722;
      if (D.30720 > D.30723) goto <D.30718>; else goto <D.30719>;
      <D.30718>:
      D.30709 = 0B;
      return D.30709;
      <D.30719>:
      D.30724 = im_cols[2];
      D.30725 = mono_metadata_string_heap (image, D.30724);
      import = monoeg_g_strdup_printf ("%s", D.30725);
      D.30706 = acfg->method_to_pinvoke_import;
      monoeg_g_hash_table_insert_replace (D.30706, method, import, 0);
      D.30709 = import;
      return D.30709;
    }
  finally
    {
      im_cols = {CLOBBER};
    }
}


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

  if (external != 0) goto <D.30730>; else goto <D.30728>;
  <D.30730>:
  D.30731 = acfg->use_bin_writer;
  if (D.30731 == 0) goto <D.30732>; else goto <D.30728>;
  <D.30732>:
  emit_unset_mode (acfg);
  D.30733 = acfg->fp;
  fprintf (D.30733, "call %s\n", target);
  goto <D.30729>;
  <D.30728>:
  emit_byte (acfg, 232);
  emit_symbol_diff (acfg, target, ".", -4);
  <D.30729>:
  *call_size = 5;
}


arch_emit_got_access (struct MonoAotCompile * acfg, guint8 * code, int got_slot, int * code_size)
{
  unsigned int D.30734;
  int D.30735;
  long unsigned int D.30736;
  unsigned int D.30737;
  unsigned int D.30738;
  unsigned int D.30739;
  int D.30740;
  char * D.30741;
  unsigned int D.30742;
  unsigned int D.30743;
  int D.30744;

  D.30734 = mono_arch_get_patch_offset (code);
  D.30735 = (int) D.30734;
  emit_bytes (acfg, code, D.30735);
  D.30736 = (long unsigned int) got_slot;
  D.30737 = (unsigned int) D.30736;
  D.30738 = D.30737 * 8;
  D.30739 = D.30738 + 4294967292;
  D.30740 = (int) D.30739;
  D.30741 = acfg->got_symbol;
  emit_symbol_diff (acfg, D.30741, ".", D.30740);
  D.30742 = mono_arch_get_patch_offset (code);
  D.30743 = D.30742 + 4;
  D.30744 = (int) D.30743;
  *code_size = D.30744;
}


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

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


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

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


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

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


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

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


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

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


emit_info (struct MonoAotCompile * acfg)
{
  unsigned int D.30750;
  long unsigned int D.30751;
  long unsigned int D.30752;
  struct GPtrArray * D.30753;
  void * * D.30754;
  long unsigned int D.30755;
  long unsigned int D.30756;
  void * * D.30757;
  void * D.30758;
  long int D.30759;
  struct MonoCompile * * D.30760;
  long unsigned int D.30761;
  long unsigned int D.30762;
  struct MonoCompile * * D.30763;
  struct MonoCompile * D.30764;
  long unsigned int D.30767;
  gint32 * D.30768;
  unsigned int D.30769;
  int D.30770;
  unsigned int oindex.136;
  unsigned int D.30773;
  int D.30774;
  unsigned int D.30775;
  int D.30776;
  unsigned int D.30777;
  unsigned int D.30778;
  int D.30779;
  int oindex;
  int i;
  char symbol[256];
  gint32 * offsets;

  try
    {
      D.30750 = acfg->nmethods;
      D.30751 = (long unsigned int) D.30750;
      D.30752 = D.30751 * 4;
      offsets = monoeg_malloc0 (D.30752);
      oindex = 0;
      goto <D.26064>;
      <D.26063>:
      D.30753 = acfg->method_order;
      D.30754 = D.30753->pdata;
      D.30755 = (long unsigned int) oindex;
      D.30756 = D.30755 * 8;
      D.30757 = D.30754 + D.30756;
      D.30758 = *D.30757;
      D.30759 = (long int) D.30758;
      i = (int) D.30759;
      D.30760 = acfg->cfgs;
      D.30761 = (long unsigned int) i;
      D.30762 = D.30761 * 8;
      D.30763 = D.30760 + D.30762;
      D.30764 = *D.30763;
      if (D.30764 != 0B) goto <D.30765>; else goto <D.30766>;
      <D.30765>:
      D.30760 = acfg->cfgs;
      D.30761 = (long unsigned int) i;
      D.30762 = D.30761 * 8;
      D.30763 = D.30760 + D.30762;
      D.30764 = *D.30763;
      emit_method_info (acfg, D.30764);
      D.30761 = (long unsigned int) i;
      D.30767 = D.30761 * 4;
      D.30768 = offsets + D.30767;
      D.30760 = acfg->cfgs;
      D.30761 = (long unsigned int) i;
      D.30762 = D.30761 * 8;
      D.30763 = D.30760 + D.30762;
      D.30764 = *D.30763;
      D.30769 = D.30764->method_info_offset;
      D.30770 = (int) D.30769;
      *D.30768 = D.30770;
      goto <D.30771>;
      <D.30766>:
      D.30761 = (long unsigned int) i;
      D.30767 = D.30761 * 4;
      D.30768 = offsets + D.30767;
      *D.30768 = 0;
      <D.30771>:
      oindex = oindex + 1;
      <D.26064>:
      oindex.136 = (unsigned int) oindex;
      D.30753 = acfg->method_order;
      D.30773 = D.30753->len;
      if (oindex.136 < D.30773) goto <D.26063>; else goto <D.26065>;
      <D.26065>:
      sprintf (&symbol, "method_info_offsets");
      emit_section_change (acfg, ".rodata", 1);
      emit_alignment (acfg, 8);
      emit_label (acfg, &symbol);
      D.30750 = acfg->nmethods;
      D.30774 = (int) D.30750;
      D.30775 = emit_offset_table (acfg, D.30774, 10, offsets);
      D.30776 = acfg->stats.offsets_size;
      D.30777 = (unsigned int) D.30776;
      D.30778 = D.30777 + D.30775;
      D.30779 = (int) D.30778;
      acfg->stats.offsets_size = D.30779;
      monoeg_g_free (offsets);
    }
  finally
    {
      symbol = {CLOBBER};
    }
}


emit_method_info (struct MonoAotCompile * acfg, struct MonoCompile * cfg)
{
  struct MonoCompile * * D.30780;
  long unsigned int D.30781;
  long unsigned int D.30782;
  struct MonoCompile * * D.30783;
  struct MonoCompile * D.30784;
  int iftmp.137;
  unsigned int D.30786;
  unsigned int D.30789;
  unsigned int D.30790;
  long unsigned int D.30792;
  struct MonoClass * D.30793;
  struct MonoMethod * D.30794;
  guint8 * p.138;
  unsigned int D.30799;
  unsigned int D.30800;
  struct GList * D.30803;
  unsigned int D.30804;
  int D.30805;
  void * D.30806;
  long int D.30807;
  int D.30808;
  _Bool D.30810;
  long int D.30811;
  long int D.30812;
  void * * D.30815;
  long unsigned int D.30816;
  long unsigned int D.30817;
  void * * D.30818;
  <unnamed type> D.30819;
  _Bool D.30820;
  _Bool D.30821;
  _Bool D.30822;
  <unnamed type> D.30825;
  struct MonoImage * D.30828;
  struct MonoImage * D.30829;
  int D.30834;
  unsigned int pindex.139;
  unsigned char D.30840;
  unsigned char D.30841;
  _Bool D.30842;
  long int D.30843;
  long int D.30844;
  int first_got_offset.140;
  int D.30848;
  unsigned int D.30849;
  long int p.141;
  long int buf.142;
  long int D.30852;
  unsigned int D.30853;
  unsigned int D.30854;
  int D.30855;
  long int D.30856;
  _Bool D.30857;
  long int D.30858;
  long int D.30859;
  unsigned int D.30862;
  unsigned int D.30863;
  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.25461>;
      <D.25460>:
      monoeg_g_ptr_array_add (patches, patch_info);
      patch_info = patch_info->next;
      <D.25461>:
      if (patch_info != 0B) goto <D.25460>; else goto <D.25462>;
      <D.25462>:
      monoeg_g_ptr_array_sort (patches, compare_patches);
      D.30780 = acfg->cfgs;
      D.30781 = (long unsigned int) method_index;
      D.30782 = D.30781 * 8;
      D.30783 = D.30780 + D.30782;
      D.30784 = *D.30783;
      first_got_offset = D.30784->got_offset;
      D.30786 = patches->len;
      if (D.30786 > 999) goto <D.30787>; else goto <D.30788>;
      <D.30787>:
      D.30786 = patches->len;
      D.30789 = D.30786 + 640;
      D.30790 = D.30789 * 64;
      iftmp.137 = (int) D.30790;
      goto <D.30791>;
      <D.30788>:
      iftmp.137 = 40960;
      <D.30791>:
      buf_size = iftmp.137;
      D.30792 = (long unsigned int) buf_size;
      buf = monoeg_malloc (D.30792);
      p = buf;
      D.30793 = method->klass;
      D.30794 = mono_class_get_cctor (D.30793);
      if (D.30794 != 0B) goto <D.30795>; else goto <D.30796>;
      <D.30795>:
      p.138 = p;
      D.30793 = method->klass;
      encode_klass_ref (acfg, D.30793, p.138, &p);
      goto <D.30798>;
      <D.30796>:
      p.138 = p;
      encode_value (0, p.138, &p);
      <D.30798>:
      D.30799 = cfg->opt;
      D.30800 = D.30799 & 512;
      if (D.30800 != 0) goto <D.30801>; else goto <D.30802>;
      <D.30801>:
      p.138 = p;
      D.30803 = cfg->ldstr_list;
      D.30804 = monoeg_g_list_length (D.30803);
      D.30805 = (int) D.30804;
      encode_value (D.30805, p.138, &p);
      l = cfg->ldstr_list;
      goto <D.25464>;
      <D.25463>:
      p.138 = p;
      D.30806 = l->data;
      D.30807 = (long int) D.30806;
      D.30808 = (int) D.30807;
      encode_value (D.30808, p.138, &p);
      l = l->next;
      <D.25464>:
      if (l != 0B) goto <D.25463>; else goto <D.25465>;
      <D.25465>:
      goto <D.30809>;
      <D.30802>:
      D.30803 = cfg->ldstr_list;
      D.30810 = D.30803 != 0B;
      D.30811 = (long int) D.30810;
      D.30812 = __builtin_expect (D.30811, 0);
      if (D.30812 != 0) goto <D.30813>; else goto <D.30814>;
      <D.30813>:
      monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "aot-compiler.c", 5129, "!cfg->ldstr_list");
      <D.30814>:
      <D.30809>:
      n_patches = 0;
      pindex = 0;
      goto <D.25468>;
      <D.25467>:
      D.30815 = patches->pdata;
      D.30816 = (long unsigned int) pindex;
      D.30817 = D.30816 * 8;
      D.30818 = D.30815 + D.30817;
      patch_info = *D.30818;
      D.30819 = patch_info->type;
      D.30820 = D.30819 == 27;
      D.30821 = D.30819 == 51;
      D.30822 = D.30820 | D.30821;
      if (D.30822 != 0) goto <D.30823>; else goto <D.30824>;
      <D.30823>:
      patch_info->type = 51;
      // predicted unlikely by continue predictor.
      goto <D.25466>;
      <D.30824>:
      D.30825 = patch_info->type;
      if (D.30825 == 12) goto <D.30826>; else goto <D.30827>;
      <D.30826>:
      D.30828 = patch_info->data.image;
      D.30829 = acfg->image;
      if (D.30828 == D.30829) goto <D.30830>; else goto <D.30831>;
      <D.30830>:
      patch_info->type = 51;
      // predicted unlikely by continue predictor.
      goto <D.25466>;
      <D.30831>:
      <D.30827>:
      D.30825 = patch_info->type;
      if (D.30825 == 42) goto <D.30832>; else goto <D.30833>;
      <D.30832>:
      patch_info->type = 51;
      // predicted unlikely by continue predictor.
      goto <D.25466>;
      <D.30833>:
      D.30834 = is_plt_patch (patch_info);
      if (D.30834 != 0) goto <D.30835>; else goto <D.30836>;
      <D.30835>:
      patch_info->type = 51;
      // predicted unlikely by continue predictor.
      goto <D.25466>;
      <D.30836>:
      n_patches = n_patches + 1;
      <D.25466>:
      pindex = pindex + 1;
      <D.25468>:
      pindex.139 = (unsigned int) pindex;
      D.30786 = patches->len;
      if (pindex.139 < D.30786) goto <D.25467>; else goto <D.25469>;
      <D.25469>:
      if (n_patches != 0) goto <D.30838>; else goto <D.30839>;
      <D.30838>:
      D.30840 = BIT_FIELD_REF <*cfg, 8, 5632>;
      D.30841 = D.30840 & 1;
      D.30842 = D.30841 == 0;
      D.30843 = (long int) D.30842;
      D.30844 = __builtin_expect (D.30843, 0);
      if (D.30844 != 0) goto <D.30845>; else goto <D.30846>;
      <D.30845>:
      monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "aot-compiler.c", 5164, "cfg->has_got_slots");
      <D.30846>:
      <D.30839>:
      p.138 = p;
      first_got_offset.140 = (int) first_got_offset;
      encode_patch_list (acfg, patches, n_patches, first_got_offset.140, p.138, &p);
      D.30848 = acfg->stats.info_size;
      D.30849 = (unsigned int) D.30848;
      p.138 = p;
      p.141 = (long int) p.138;
      buf.142 = (long int) buf;
      D.30852 = p.141 - buf.142;
      D.30853 = (unsigned int) D.30852;
      D.30854 = D.30849 + D.30853;
      D.30855 = (int) D.30854;
      acfg->stats.info_size = D.30855;
      p.138 = p;
      p.141 = (long int) p.138;
      buf.142 = (long int) buf;
      D.30852 = p.141 - buf.142;
      D.30856 = (long int) buf_size;
      D.30857 = D.30852 >= D.30856;
      D.30858 = (long int) D.30857;
      D.30859 = __builtin_expect (D.30858, 0);
      if (D.30859 != 0) goto <D.30860>; else goto <D.30861>;
      <D.30860>:
      monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "aot-compiler.c", 5170, "p - buf < buf_size");
      <D.30861>:
      p.138 = p;
      p.141 = (long int) p.138;
      buf.142 = (long int) buf;
      D.30852 = p.141 - buf.142;
      D.30862 = (unsigned int) D.30852;
      D.30863 = add_to_blob (acfg, buf, D.30862);
      cfg->method_info_offset = D.30863;
      monoeg_g_free (buf);
    }
  finally
    {
      p = {CLOBBER};
    }
}


encode_klass_ref (struct MonoAotCompile * acfg, struct MonoClass * klass, guint8 * buf, guint8 * * endbuf)
{
  struct MonoGenericClass * D.30864;
  unsigned int D.30867;
  _Bool D.30868;
  long int D.30869;
  long int D.30870;
  unsigned char D.30876;
  _Bool D.30877;
  _Bool D.30878;
  _Bool D.30879;
  struct GHashTable * D.30884;
  void * D.30885;
  long int D.30886;
  guint8 * p.143;
  long int p.144;
  long int buf2.145;
  long int D.30892;
  _Bool D.30893;
  long int D.30894;
  long int D.30895;
  unsigned int D.30898;
  unsigned int D.30899;
  long unsigned int D.30900;
  void * D.30901;
  int offset.146;
  gboolean shared;

  shared = 0;
  D.30864 = klass->generic_class;
  if (D.30864 != 0B) goto <D.30865>; else goto <D.30866>;
  <D.30865>:
  {
    guint32 token;

    D.30867 = klass->type_token;
    D.30868 = D.30867 == 0;
    D.30869 = (long int) D.30868;
    D.30870 = __builtin_expect (D.30869, 0);
    if (D.30870 != 0) goto <D.30871>; else goto <D.30872>;
    <D.30871>:
    monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "aot-compiler.c", 2354, "klass->type_token");
    <D.30872>:
    token = find_typespec_for_class (acfg, klass);
    if (token == 0) goto <D.30873>; else goto <D.30874>;
    <D.30873>:
    shared = 1;
    <D.30874>:
  }
  goto <D.30875>;
  <D.30866>:
  D.30876 = klass->byval_arg.type;
  D.30877 = D.30876 == 19;
  D.30878 = D.30876 == 30;
  D.30879 = D.30877 | D.30878;
  if (D.30879 != 0) goto <D.30880>; else goto <D.30881>;
  <D.30880>:
  shared = 1;
  <D.30881>:
  <D.30875>:
  if (shared != 0) goto <D.30882>; else goto <D.30883>;
  <D.30882>:
  {
    guint offset;
    guint8 * buf2;
    guint8 * p;

    try
      {
        D.30884 = acfg->klass_blob_hash;
        D.30885 = monoeg_g_hash_table_lookup (D.30884, klass);
        D.30886 = (long int) D.30885;
        offset = (guint) D.30886;
        if (offset == 0) goto <D.30887>; else goto <D.30888>;
        <D.30887>:
        buf2 = monoeg_malloc (1024);
        p = buf2;
        p.143 = p;
        encode_klass_ref_inner (acfg, klass, p.143, &p);
        p.143 = p;
        p.144 = (long int) p.143;
        buf2.145 = (long int) buf2;
        D.30892 = p.144 - buf2.145;
        D.30893 = D.30892 > 1023;
        D.30894 = (long int) D.30893;
        D.30895 = __builtin_expect (D.30894, 0);
        if (D.30895 != 0) goto <D.30896>; else goto <D.30897>;
        <D.30896>:
        monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "aot-compiler.c", 2373, "p - buf2 < 1024");
        <D.30897>:
        p.143 = p;
        p.144 = (long int) p.143;
        buf2.145 = (long int) buf2;
        D.30892 = p.144 - buf2.145;
        D.30898 = (unsigned int) D.30892;
        offset = add_to_blob (acfg, buf2, D.30898);
        monoeg_g_free (buf2);
        D.30899 = offset + 1;
        D.30900 = (long unsigned int) D.30899;
        D.30901 = (void *) D.30900;
        D.30884 = acfg->klass_blob_hash;
        monoeg_g_hash_table_insert_replace (D.30884, klass, D.30901, 0);
        goto <D.30902>;
        <D.30888>:
        offset = offset + 4294967295;
        <D.30902>:
        p = buf;
        p.143 = p;
        encode_value (7, p.143, &p);
        p.143 = p;
        offset.146 = (int) offset;
        encode_value (offset.146, p.143, &p);
        p.143 = p;
        *endbuf = p.143;
        return;
      }
    finally
      {
        p = {CLOBBER};
      }
  }
  <D.30883>:
  encode_klass_ref_inner (acfg, klass, buf, endbuf);
}


find_typespec_for_class (struct MonoAotCompile * acfg, struct MonoClass * klass)
{
  struct MonoImage * D.30906;
  <unnamed-unsigned:24> D.30907;
  struct MonoClass * * D.30908;
  long unsigned int D.30911;
  unsigned int D.30912;
  unsigned int D.30913;
  struct MonoMemPool * D.30914;
  void * D.30915;
  long unsigned int D.30916;
  long unsigned int D.30917;
  struct MonoClass * * D.30918;
  int D.30919;
  int D.30920;
  unsigned int D.30921;
  struct MonoClass * D.30922;
  struct MonoClass * D.30923;
  guint32 D.30927;
  int i;
  int len;

  D.30906 = acfg->image;
  D.30907 = D.30906->tables[27].rows;
  len = (int) D.30907;
  D.30908 = acfg->typespec_classes;
  if (D.30908 == 0B) goto <D.30909>; else goto <D.30910>;
  <D.30909>:
  D.30911 = (long unsigned int) len;
  D.30912 = (unsigned int) D.30911;
  D.30913 = D.30912 * 8;
  D.30914 = acfg->mempool;
  D.30915 = mono_mempool_alloc0 (D.30914, D.30913);
  acfg->typespec_classes = D.30915;
  i = 0;
  goto <D.24269>;
  <D.24268>:
  D.30908 = acfg->typespec_classes;
  D.30916 = (long unsigned int) i;
  D.30917 = D.30916 * 8;
  D.30918 = D.30908 + D.30917;
  D.30919 = i + 1;
  D.30920 = D.30919 | 452984832;
  D.30921 = (unsigned int) D.30920;
  D.30906 = acfg->image;
  D.30922 = mono_class_get_full (D.30906, D.30921, 0B);
  *D.30918 = D.30922;
  i = i + 1;
  <D.24269>:
  if (i < len) goto <D.24268>; else goto <D.24270>;
  <D.24270>:
  <D.30910>:
  i = 0;
  goto <D.24273>;
  <D.24272>:
  D.30908 = acfg->typespec_classes;
  D.30916 = (long unsigned int) i;
  D.30917 = D.30916 * 8;
  D.30918 = D.30908 + D.30917;
  D.30923 = *D.30918;
  if (D.30923 == klass) goto <D.24271>; else goto <D.30924>;
  <D.30924>:
  i = i + 1;
  <D.24273>:
  if (i < len) goto <D.24272>; else goto <D.24271>;
  <D.24271>:
  if (i < len) goto <D.30925>; else goto <D.30926>;
  <D.30925>:
  D.30919 = i + 1;
  D.30920 = D.30919 | 452984832;
  D.30927 = (guint32) D.30920;
  return D.30927;
  <D.30926>:
  D.30927 = 0;
  return D.30927;
}


encode_klass_ref_inner (struct MonoAotCompile * acfg, struct MonoClass * klass, guint8 * buf, guint8 * * endbuf)
{
  struct MonoGenericClass * D.30929;
  unsigned int D.30932;
  _Bool D.30933;
  long int D.30934;
  long int D.30935;
  guint8 * p.147;
  int token.148;
  long int p.149;
  long int p1.150;
  long int D.30945;
  unsigned int D.30946;
  int count.151;
  unsigned int count.152;
  unsigned int D.30949;
  int count.153;
  struct MonoImage * D.30954;
  unsigned int D.30955;
  unsigned int D.30956;
  _Bool D.30957;
  long int D.30958;
  long int D.30959;
  unsigned int D.30964;
  int D.30965;
  unsigned int D.30967;
  int D.30968;
  unsigned char D.30970;
  _Bool D.30971;
  _Bool D.30972;
  _Bool D.30973;
  struct MonoGenericParam * D.30976;
  unsigned char D.30977;
  int D.30978;
  short unsigned int D.30979;
  int D.30980;
  _Bool D.30981;
  int D.30982;
  <unnamed-signed:1> D.30985;
  int D.30986;
  short unsigned int D.30987;
  _Bool D.30988;
  long int D.30989;
  long int D.30990;
  unsigned char D.30993;
  unsigned char D.30994;
  struct MonoMethod * D.30997;
  struct MonoClass * D.30999;
  int D.31001;
  struct MonoType * D.31005;
  unsigned char D.31007;
  _Bool D.31008;
  long int D.31009;
  long int D.31010;
  int D.31013;
  struct MonoClass * D.31014;
  guint8 * p;

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

        D.30932 = klass->type_token;
        D.30933 = D.30932 == 0;
        D.30934 = (long int) D.30933;
        D.30935 = __builtin_expect (D.30934, 0);
        if (D.30935 != 0) goto <D.30936>; else goto <D.30937>;
        <D.30936>:
        monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "aot-compiler.c", 2275, "klass->type_token");
        <D.30937>:
        token = find_typespec_for_class (acfg, klass);
        if (token != 0) goto <D.30938>; else goto <D.30939>;
        <D.30938>:
        p.147 = p;
        encode_value (3, p.147, &p);
        p.147 = p;
        token.148 = (int) token;
        encode_value (token.148, p.147, &p);
        goto <D.30942>;
        <D.30939>:
        {
          struct MonoClass * gclass;
          struct MonoGenericInst * inst;
          static int count = 0;
          guint8 * p1;

          D.30929 = klass->generic_class;
          gclass = D.30929->container_class;
          D.30929 = klass->generic_class;
          inst = D.30929->context.class_inst;
          p1 = p;
          p.147 = p;
          encode_value (4, p.147, &p);
          p.147 = p;
          encode_klass_ref (acfg, gclass, p.147, &p);
          p.147 = p;
          encode_ginst (acfg, inst, p.147, &p);
          p.147 = p;
          p.149 = (long int) p.147;
          p1.150 = (long int) p1;
          D.30945 = p.149 - p1.150;
          D.30946 = (unsigned int) D.30945;
          count.151 = count;
          count.152 = (unsigned int) count.151;
          D.30949 = D.30946 + count.152;
          count.153 = (int) D.30949;
          count = count.153;
        }
        <D.30942>:
      }
      goto <D.30951>;
      <D.30931>:
      D.30932 = klass->type_token;
      if (D.30932 != 0) goto <D.30952>; else goto <D.30953>;
      <D.30952>:
      {
        int iindex;

        D.30954 = klass->image;
        D.30955 = get_image_index (acfg, D.30954);
        iindex = (int) D.30955;
        D.30932 = klass->type_token;
        D.30956 = D.30932 & 4278190080;
        D.30957 = D.30956 != 33554432;
        D.30958 = (long int) D.30957;
        D.30959 = __builtin_expect (D.30958, 0);
        if (D.30959 != 0) goto <D.30960>; else goto <D.30961>;
        <D.30960>:
        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.30961>:
        if (iindex == 0) goto <D.30962>; else goto <D.30963>;
        <D.30962>:
        p.147 = p;
        encode_value (1, p.147, &p);
        p.147 = p;
        D.30932 = klass->type_token;
        D.30964 = D.30932 + 4261412864;
        D.30965 = (int) D.30964;
        encode_value (D.30965, p.147, &p);
        goto <D.30966>;
        <D.30963>:
        p.147 = p;
        encode_value (2, p.147, &p);
        p.147 = p;
        D.30932 = klass->type_token;
        D.30964 = D.30932 + 4261412864;
        D.30965 = (int) D.30964;
        encode_value (D.30965, p.147, &p);
        p.147 = p;
        D.30954 = klass->image;
        D.30967 = get_image_index (acfg, D.30954);
        D.30968 = (int) D.30967;
        encode_value (D.30968, p.147, &p);
        <D.30966>:
      }
      goto <D.30969>;
      <D.30953>:
      D.30970 = klass->byval_arg.type;
      D.30971 = D.30970 == 19;
      D.30972 = D.30970 == 30;
      D.30973 = D.30971 | D.30972;
      if (D.30973 != 0) goto <D.30974>; else goto <D.30975>;
      <D.30974>:
      {
        struct MonoGenericContainer * container;
        struct MonoGenericParam * par;

        D.30976 = klass->byval_arg.data.generic_param;
        container = D.30976->owner;
        par = klass->byval_arg.data.generic_param;
        p.147 = p;
        encode_value (5, p.147, &p);
        p.147 = p;
        D.30977 = klass->byval_arg.type;
        D.30978 = (int) D.30977;
        encode_value (D.30978, p.147, &p);
        p.147 = p;
        D.30976 = klass->byval_arg.data.generic_param;
        D.30979 = D.30976->num;
        D.30980 = (int) D.30979;
        encode_value (D.30980, p.147, &p);
        p.147 = p;
        D.30981 = container != 0B;
        D.30982 = (int) D.30981;
        encode_value (D.30982, p.147, &p);
        if (container != 0B) goto <D.30983>; else goto <D.30984>;
        <D.30983>:
        p.147 = p;
        D.30985 = container->is_method;
        D.30986 = (int) D.30985;
        encode_value (D.30986, p.147, &p);
        D.30987 = par->serial;
        D.30988 = D.30987 != 0;
        D.30989 = (long int) D.30988;
        D.30990 = __builtin_expect (D.30989, 0);
        if (D.30990 != 0) goto <D.30991>; else goto <D.30992>;
        <D.30991>:
        monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "aot-compiler.c", 2317, "par->serial == 0");
        <D.30992>:
        D.30993 = BIT_FIELD_REF <*container, 8, 280>;
        D.30994 = D.30993 & 128;
        if (D.30994 != 0) goto <D.30995>; else goto <D.30996>;
        <D.30995>:
        p.147 = p;
        D.30997 = container->owner.method;
        encode_method_ref (acfg, D.30997, p.147, &p);
        goto <D.30998>;
        <D.30996>:
        p.147 = p;
        D.30999 = container->owner.klass;
        encode_klass_ref (acfg, D.30999, p.147, &p);
        <D.30998>:
        goto <D.31000>;
        <D.30984>:
        p.147 = p;
        D.30987 = par->serial;
        D.31001 = (int) D.30987;
        encode_value (D.31001, p.147, &p);
        <D.31000>:
      }
      goto <D.31002>;
      <D.30975>:
      D.30977 = klass->byval_arg.type;
      if (D.30977 == 15) goto <D.31003>; else goto <D.31004>;
      <D.31003>:
      p.147 = p;
      encode_value (8, p.147, &p);
      p.147 = p;
      D.31005 = &klass->byval_arg;
      encode_type (acfg, D.31005, p.147, &p);
      goto <D.31006>;
      <D.31004>:
      D.31007 = klass->rank;
      D.31008 = D.31007 == 0;
      D.31009 = (long int) D.31008;
      D.31010 = __builtin_expect (D.31009, 0);
      if (D.31010 != 0) goto <D.31011>; else goto <D.31012>;
      <D.31011>:
      monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "aot-compiler.c", 2330, "klass->rank > 0");
      <D.31012>:
      p.147 = p;
      encode_value (6, p.147, &p);
      p.147 = p;
      D.31007 = klass->rank;
      D.31013 = (int) D.31007;
      encode_value (D.31013, p.147, &p);
      p.147 = p;
      D.31014 = klass->element_class;
      encode_klass_ref (acfg, D.31014, p.147, &p);
      <D.31006>:
      <D.31002>:
      <D.30969>:
      <D.30951>:
      p.147 = p;
      *endbuf = p.147;
    }
  finally
    {
      p = {CLOBBER};
    }
}


encode_ginst (struct MonoAotCompile * acfg, struct MonoGenericInst * inst, guint8 * buf, guint8 * * endbuf)
{
  guint8 * p.154;
  <unnamed-unsigned:22> D.31016;
  int D.31017;
  struct MonoType * D.31018;
  struct MonoClass * D.31019;
  int D.31020;
  guint8 * p;
  int i;

  try
    {
      p = buf;
      p.154 = p;
      D.31016 = inst->type_argc;
      D.31017 = (int) D.31016;
      encode_value (D.31017, p.154, &p);
      i = 0;
      goto <D.24337>;
      <D.24336>:
      p.154 = p;
      D.31018 = inst->type_argv[i];
      D.31019 = mono_class_from_mono_type (D.31018);
      encode_klass_ref (acfg, D.31019, p.154, &p);
      i = i + 1;
      <D.24337>:
      D.31016 = inst->type_argc;
      D.31020 = (int) D.31016;
      if (D.31020 > i) goto <D.24336>; else goto <D.24338>;
      <D.24338>:
      p.154 = p;
      *endbuf = p.154;
    }
  finally
    {
      p = {CLOBBER};
    }
}


get_image_index (struct MonoAotCompile * cfg, struct MonoImage * image)
{
  struct GHashTable * D.31021;
  void * D.31022;
  long int D.31023;
  guint32 D.31026;
  unsigned int D.31027;
  long unsigned int D.31028;
  void * D.31029;
  struct GPtrArray * D.31030;
  guint32 index;

  D.31021 = cfg->image_hash;
  D.31022 = monoeg_g_hash_table_lookup (D.31021, image);
  D.31023 = (long int) D.31022;
  index = (guint32) D.31023;
  if (index != 0) goto <D.31024>; else goto <D.31025>;
  <D.31024>:
  D.31026 = index + 4294967295;
  return D.31026;
  <D.31025>:
  D.31021 = cfg->image_hash;
  index = monoeg_g_hash_table_size (D.31021);
  D.31027 = index + 1;
  D.31028 = (long unsigned int) D.31027;
  D.31029 = (void *) D.31028;
  D.31021 = cfg->image_hash;
  monoeg_g_hash_table_insert_replace (D.31021, image, D.31029, 0);
  D.31030 = cfg->image_table;
  monoeg_g_ptr_array_add (D.31030, image);
  D.31026 = index;
  return D.31026;
}


encode_method_ref (struct MonoAotCompile * acfg, struct MonoMethod * method, guint8 * buf, guint8 * * endbuf)
{
  struct MonoClass * D.31032;
  struct MonoImage * D.31033;
  unsigned char D.31037;
  unsigned char D.31038;
  short unsigned int D.31040;
  int D.31041;
  int D.31042;
  short unsigned int D.31043;
  int D.31044;
  int D.31045;
  guint8 * p.155;
  unsigned char D.31047;
  unsigned char D.31048;
  <unnamed-unsigned:5> D.31051;
  int D.31052;
  int D.31053;
  _Bool D.31054;
  long int D.31055;
  long int D.31056;
  int D.31059;
  _Bool D.31060;
  long int D.31061;
  long int D.31062;
  _Bool D.31065;
  long int D.31066;
  long int D.31067;
  <unnamed type> D.31070;
  int D.31071;
  int D.31074;
  _Bool D.31075;
  long int D.31076;
  long int D.31077;
  <unnamed type> D.31080;
  int D.31081;
  unsigned int D.31082;
  struct MonoMethod * D.31088;
  struct MonoMethod * D.31092;
  _Bool D.31093;
  long int D.31094;
  long int D.31095;
  <unnamed type> D.31098;
  int D.31099;
  const char * D.31102;
  long unsigned int D.31103;
  sizetype D.31104;
  guint8 * p.156;
  struct MonoMethod * D.31109;
  _Bool D.31111;
  long int D.31112;
  long int D.31113;
  _Bool D.31116;
  long int D.31117;
  long int D.31118;
  _Bool D.31121;
  long int D.31122;
  long int D.31123;
  _Bool D.31126;
  long int D.31127;
  long int D.31128;
  <unnamed type> D.31131;
  int D.31132;
  unsigned int D.31135;
  int D.31136;
  unsigned int D.31137;
  int D.31138;
  struct MonoMethod * D.31142;
  _Bool D.31144;
  long int D.31145;
  long int D.31146;
  <unnamed type> D.31149;
  int D.31150;
  _Bool D.31151;
  long int D.31152;
  long int D.31153;
  <unnamed type> D.31156;
  int D.31157;
  unsigned int D.31158;
  struct MonoMethod * D.31161;
  struct MonoMethodSignature * D.31165;
  unsigned char D.31166;
  gint32 iftmp.157;
  <unnamed type> D.31175;
  _Bool D.31177;
  long int D.31178;
  long int D.31179;
  struct MonoMethod * D.31182;
  struct MonoClass * D.31183;
  struct MonoMethodSignature * D.31185;
  unsigned char D.31186;
  unsigned char D.31187;
  struct GHashTable * D.31190;
  struct MonoImage * D.31193;
  _Bool D.31194;
  long int D.31195;
  long int D.31196;
  int image_index.158;
  int token.159;
  _Bool D.31202;
  long int D.31203;
  long int D.31204;
  unsigned int D.31209;
  _Bool D.31210;
  long int D.31211;
  long int D.31212;
  unsigned int D.31215;
  _Bool D.31216;
  long int D.31217;
  long int D.31218;
  unsigned char D.31229;
  _Bool D.31230;
  long int D.31231;
  long int D.31232;
  int D.24462;
  int iftmp.160;
  int D.24461;
  const char[6] * D.31240;
  unsigned char D.31241;
  int D.31242;
  unsigned char D.31243;
  int D.31244;
  _Bool D.31245;
  _Bool D.31246;
  _Bool D.31247;
  const unsigned char * D.31250;
  unsigned char D.31251;
  int D.31252;
  const unsigned char * D.31253;
  unsigned char D.31254;
  int D.31255;
  _Bool D.31256;
  _Bool D.31257;
  const unsigned char * D.31260;
  unsigned char D.31261;
  int D.31262;
  const unsigned char * D.31263;
  unsigned char D.31264;
  int D.31265;
  _Bool D.31266;
  _Bool D.31267;
  const unsigned char * D.31270;
  unsigned char D.31271;
  int D.31272;
  const unsigned char * D.31273;
  unsigned char D.31274;
  int D.31275;
  struct MonoMethodSignature * D.31278;
  short unsigned int D.31279;
  short unsigned int D.31280;
  int D.24471;
  int iftmp.161;
  int D.24470;
  unsigned char D.31287;
  int D.31288;
  _Bool D.31289;
  _Bool D.31290;
  _Bool D.31291;
  const unsigned char * D.31294;
  unsigned char D.31295;
  int D.31296;
  _Bool D.31297;
  _Bool D.31298;
  const unsigned char * D.31301;
  unsigned char D.31302;
  int D.31303;
  _Bool D.31304;
  _Bool D.31305;
  const unsigned char * D.31308;
  unsigned char D.31309;
  int D.31310;
  struct MonoMethodSignature * D.31313;
  short unsigned int D.31314;
  int D.31315;
  int D.31316;
  int D.31317;
  int D.24480;
  int iftmp.162;
  int D.24479;
  const char[4] * D.31322;
  unsigned char D.31323;
  int D.31324;
  unsigned char D.31325;
  int D.31326;
  _Bool D.31327;
  _Bool D.31328;
  _Bool D.31329;
  const unsigned char * D.31332;
  unsigned char D.31333;
  int D.31334;
  const unsigned char * D.31335;
  unsigned char D.31336;
  int D.31337;
  _Bool D.31338;
  _Bool D.31339;
  const unsigned char * D.31342;
  unsigned char D.31343;
  int D.31344;
  const unsigned char * D.31345;
  unsigned char D.31346;
  int D.31347;
  _Bool D.31348;
  _Bool D.31349;
  const unsigned char * D.31352;
  unsigned char D.31353;
  int D.31354;
  const unsigned char * D.31355;
  unsigned char D.31356;
  int D.31357;
  int D.24489;
  int iftmp.163;
  int D.24488;
  const char[8] * D.31365;
  unsigned char D.31366;
  int D.31367;
  unsigned char D.31368;
  int D.31369;
  _Bool D.31370;
  _Bool D.31371;
  _Bool D.31372;
  const unsigned char * D.31375;
  unsigned char D.31376;
  int D.31377;
  const unsigned char * D.31378;
  unsigned char D.31379;
  int D.31380;
  _Bool D.31381;
  _Bool D.31382;
  const unsigned char * D.31385;
  unsigned char D.31386;
  int D.31387;
  const unsigned char * D.31388;
  unsigned char D.31389;
  int D.31390;
  _Bool D.31391;
  _Bool D.31392;
  const unsigned char * D.31395;
  unsigned char D.31396;
  int D.31397;
  const unsigned char * D.31398;
  unsigned char D.31399;
  int D.31400;
  int D.24498;
  int iftmp.164;
  int D.24497;
  const char[4] * D.31408;
  unsigned char D.31409;
  int D.31410;
  unsigned char D.31411;
  int D.31412;
  _Bool D.31413;
  _Bool D.31414;
  _Bool D.31415;
  const unsigned char * D.31418;
  unsigned char D.31419;
  int D.31420;
  const unsigned char * D.31421;
  unsigned char D.31422;
  int D.31423;
  _Bool D.31424;
  _Bool D.31425;
  const unsigned char * D.31428;
  unsigned char D.31429;
  int D.31430;
  const unsigned char * D.31431;
  unsigned char D.31432;
  int D.31433;
  _Bool D.31434;
  _Bool D.31435;
  const unsigned char * D.31438;
  unsigned char D.31439;
  int D.31440;
  const unsigned char * D.31441;
  unsigned char D.31442;
  int D.31443;
  int D.31453;
  unsigned int D.31455;
  unsigned int D.31456;
  unsigned int D.31457;
  int D.31458;
  guint32 image_index;
  guint32 token;
  struct MonoJumpInfoToken * ji;
  guint8 * p;

  try
    {
      D.31032 = method->klass;
      D.31033 = D.31032->image;
      image_index = get_image_index (acfg, D.31033);
      token = method->token;
      p = buf;
      D.31037 = BIT_FIELD_REF <*method, 8, 264>;
      D.31038 = D.31037 & 8;
      if (D.31038 != 0) goto <D.31039>; else goto <D.31034>;
      <D.31039>:
      D.31040 = method->flags;
      D.31041 = (int) D.31040;
      D.31042 = D.31041 & 64;
      if (D.31042 != 0) goto <D.31035>; else goto <D.31034>;
      <D.31034>:
      D.31043 = method->iflags;
      D.31044 = (int) D.31043;
      D.31045 = D.31044 & 32;
      if (D.31045 != 0) goto <D.31035>; else goto <D.31036>;
      <D.31035>:
      p.155 = p;
      encode_value (-83886080, p.155, &p);
      <D.31036>:
      D.31047 = BIT_FIELD_REF <*method, 8, 256>;
      D.31048 = D.31047 & 124;
      if (D.31048 != 0) goto <D.31049>; else goto <D.31050>;
      <D.31049>:
      p.155 = p;
      encode_value (-67108864, p.155, &p);
      p.155 = p;
      D.31051 = method->wrapper_type;
      D.31052 = (int) D.31051;
      encode_value (D.31052, p.155, &p);
      D.31051 = method->wrapper_type;
      D.31053 = (int) D.31051;
      switch (D.31053) <default: <D.24451>, case 1: <D.24444>, case 2: <D.24445>, case 3: <D.24446>, case 4: <D.24442>, case 5: <D.24449>, case 6: <D.24434>, case 7: <D.24438>, case 8: <D.24414>, case 9: <D.24415>, case 10: <D.24416>, case 12: <D.24420>, case 13: <D.24422>, case 14: <D.24425>, case 15: <D.24426>, case 16: <D.24436>, case 18: <D.24423>, case 19: <D.24440>, case 20: <D.24419>, case 21: <D.24430>, case 23: <D.24421>, case 24: <D.24429>, case 25: <D.24432>, case 28: <D.24427>>
      <D.24414>:
      <D.24415>:
      <D.24416>:
      {
        struct MonoMethod * m;

        m = mono_marshal_method_from_wrapper (method);
        D.31054 = m == 0B;
        D.31055 = (long int) D.31054;
        D.31056 = __builtin_expect (D.31055, 0);
        if (D.31056 != 0) goto <D.31057>; else goto <D.31058>;
        <D.31057>:
        monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "aot-compiler.c", 2595, "m");
        <D.31058>:
        p.155 = p;
        encode_method_ref (acfg, m, p.155, &p);
        goto <D.24418>;
      }
      <D.24419>:
      <D.24420>:
      <D.24421>:
      <D.24422>:
      <D.24423>:
      {
        struct MonoClass * proxy_class;

        proxy_class = mono_marshal_get_wrapper_info (method);
        p.155 = p;
        encode_klass_ref (acfg, proxy_class, p.155, &p);
        goto <D.24418>;
      }
      <D.24425>:
      <D.24426>:
      goto <D.24418>;
      <D.24427>:
      {
        struct AllocatorWrapperInfo * info;

        info = mono_marshal_get_wrapper_info (method);
        D.31059 = info->alloc_type;
        D.31060 = D.31059 == -1;
        D.31061 = (long int) D.31060;
        D.31062 = __builtin_expect (D.31061, 0);
        if (D.31062 != 0) goto <D.31063>; else goto <D.31064>;
        <D.31063>:
        monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "aot-compiler.c", 2615, "info->alloc_type != -1");
        <D.31064>:
        p.155 = p;
        D.31059 = info->alloc_type;
        encode_value (D.31059, p.155, &p);
        goto <D.24418>;
      }
      <D.24429>:
      goto <D.24418>;
      <D.24430>:
      {
        struct WrapperInfo * info;

        info = mono_marshal_get_wrapper_info (method);
        D.31065 = info == 0B;
        D.31066 = (long int) D.31065;
        D.31067 = __builtin_expect (D.31066, 0);
        if (D.31067 != 0) goto <D.31068>; else goto <D.31069>;
        <D.31068>:
        monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "aot-compiler.c", 2624, "info");
        <D.31069>:
        p.155 = p;
        D.31070 = info->subtype;
        D.31071 = (int) D.31070;
        encode_value (D.31071, p.155, &p);
        D.31070 = info->subtype;
        if (D.31070 == 3) goto <D.31072>; else goto <D.31073>;
        <D.31072>:
        p.155 = p;
        D.31074 = info->d.virtual_stelemref.kind;
        encode_value (D.31074, p.155, &p);
        <D.31073>:
        goto <D.24418>;
      }
      <D.24432>:
      {
        struct WrapperInfo * info;

        info = mono_marshal_get_wrapper_info (method);
        D.31075 = info == 0B;
        D.31076 = (long int) D.31075;
        D.31077 = __builtin_expect (D.31076, 0);
        if (D.31077 != 0) goto <D.31078>; else goto <D.31079>;
        <D.31078>:
        monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "aot-compiler.c", 2633, "info");
        <D.31079>:
        p.155 = p;
        D.31080 = info->subtype;
        D.31081 = (int) D.31080;
        encode_value (D.31081, p.155, &p);
        D.31080 = info->subtype;
        D.31082 = D.31080 + 4294967289;
        if (D.31082 <= 1) goto <D.31083>; else goto <D.31084>;
        <D.31083>:
        p.155 = p;
        D.31032 = method->klass;
        encode_klass_ref (acfg, D.31032, p.155, &p);
        goto <D.31085>;
        <D.31084>:
        D.31080 = info->subtype;
        if (D.31080 == 17) goto <D.31086>; else goto <D.31087>;
        <D.31086>:
        p.155 = p;
        D.31088 = info->d.synchronized_inner.method;
        encode_method_ref (acfg, D.31088, p.155, &p);
        goto <D.31089>;
        <D.31087>:
        D.31080 = info->subtype;
        if (D.31080 == 20) goto <D.31090>; else goto <D.31091>;
        <D.31090>:
        p.155 = p;
        D.31092 = info->d.array_accessor.method;
        encode_method_ref (acfg, D.31092, p.155, &p);
        <D.31091>:
        <D.31089>:
        <D.31085>:
        goto <D.24418>;
      }
      <D.24434>:
      {
        struct WrapperInfo * info;

        info = mono_marshal_get_wrapper_info (method);
        D.31093 = info == 0B;
        D.31094 = (long int) D.31093;
        D.31095 = __builtin_expect (D.31094, 0);
        if (D.31095 != 0) goto <D.31096>; else goto <D.31097>;
        <D.31096>:
        monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "aot-compiler.c", 2647, "info");
        <D.31097>:
        p.155 = p;
        D.31098 = info->subtype;
        D.31099 = (int) D.31098;
        encode_value (D.31099, p.155, &p);
        D.31098 = info->subtype;
        if (D.31098 == 15) goto <D.31100>; else goto <D.31101>;
        <D.31100>:
        D.31102 = method->name;
        p.155 = p;
        strcpy (p.155, D.31102);
        p.155 = p;
        D.31102 = method->name;
        D.31103 = strlen (D.31102);
        D.31104 = D.31103 + 1;
        p.156 = p.155 + D.31104;
        p = p.156;
        goto <D.31106>;
        <D.31101>:
        D.31098 = info->subtype;
        if (D.31098 == 16) goto <D.31107>; else goto <D.31108>;
        <D.31107>:
        p.155 = p;
        D.31109 = info->d.managed_to_native.method;
        encode_method_ref (acfg, D.31109, p.155, &p);
        goto <D.31110>;
        <D.31108>:
        D.31098 = info->subtype;
        D.31111 = D.31098 != 0;
        D.31112 = (long int) D.31111;
        D.31113 = __builtin_expect (D.31112, 0);
        if (D.31113 != 0) goto <D.31114>; else goto <D.31115>;
        <D.31114>:
        monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "aot-compiler.c", 2655, "info->subtype == WRAPPER_SUBTYPE_NONE");
        <D.31115>:
        p.155 = p;
        D.31109 = info->d.managed_to_native.method;
        encode_method_ref (acfg, D.31109, p.155, &p);
        <D.31110>:
        <D.31106>:
        goto <D.24418>;
      }
      <D.24436>:
      {
        struct MonoMethod * m;

        m = mono_marshal_method_from_wrapper (method);
        D.31116 = m == 0B;
        D.31117 = (long int) D.31116;
        D.31118 = __builtin_expect (D.31117, 0);
        if (D.31118 != 0) goto <D.31119>; else goto <D.31120>;
        <D.31119>:
        monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "aot-compiler.c", 2664, "m");
        <D.31120>:
        D.31121 = m == method;
        D.31122 = (long int) D.31121;
        D.31123 = __builtin_expect (D.31122, 0);
        if (D.31123 != 0) goto <D.31124>; else goto <D.31125>;
        <D.31124>:
        monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "aot-compiler.c", 2665, "m != method");
        <D.31125>:
        p.155 = p;
        encode_method_ref (acfg, m, p.155, &p);
        goto <D.24418>;
      }
      <D.24438>:
      {
        struct WrapperInfo * info;

        info = mono_marshal_get_wrapper_info (method);
        D.31126 = info == 0B;
        D.31127 = (long int) D.31126;
        D.31128 = __builtin_expect (D.31127, 0);
        if (D.31128 != 0) goto <D.31129>; else goto <D.31130>;
        <D.31129>:
        monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "aot-compiler.c", 2672, "info");
        <D.31130>:
        p.155 = p;
        D.31131 = info->subtype;
        D.31132 = (int) D.31131;
        encode_value (D.31132, p.155, &p);
        D.31131 = info->subtype;
        if (D.31131 == 1) goto <D.31133>; else goto <D.31134>;
        <D.31133>:
        p.155 = p;
        D.31135 = info->d.element_addr.rank;
        D.31136 = (int) D.31135;
        encode_value (D.31136, p.155, &p);
        p.155 = p;
        D.31137 = info->d.element_addr.elem_size;
        D.31138 = (int) D.31137;
        encode_value (D.31138, p.155, &p);
        goto <D.31139>;
        <D.31134>:
        D.31131 = info->subtype;
        if (D.31131 == 2) goto <D.31140>; else goto <D.31141>;
        <D.31140>:
        p.155 = p;
        D.31142 = info->d.string_ctor.method;
        encode_method_ref (acfg, D.31142, p.155, &p);
        goto <D.31143>;
        <D.31141>:
        monoeg_assertion_message ("* Assertion: should not be reached at %s:%d\n", "aot-compiler.c", 2681);
        <D.31143>:
        <D.31139>:
        goto <D.24418>;
      }
      <D.24440>:
      {
        struct WrapperInfo * info;

        info = mono_marshal_get_wrapper_info (method);
        D.31144 = info == 0B;
        D.31145 = (long int) D.31144;
        D.31146 = __builtin_expect (D.31145, 0);
        if (D.31146 != 0) goto <D.31147>; else goto <D.31148>;
        <D.31147>:
        monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "aot-compiler.c", 2688, "info");
        <D.31148>:
        p.155 = p;
        D.31149 = info->subtype;
        D.31150 = (int) D.31149;
        encode_value (D.31150, p.155, &p);
        goto <D.24418>;
      }
      <D.24442>:
      {
        struct WrapperInfo * info;

        info = mono_marshal_get_wrapper_info (method);
        D.31151 = info == 0B;
        D.31152 = (long int) D.31151;
        D.31153 = __builtin_expect (D.31152, 0);
        if (D.31153 != 0) goto <D.31154>; else goto <D.31155>;
        <D.31154>:
        monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "aot-compiler.c", 2695, "info");
        <D.31155>:
        p.155 = p;
        D.31156 = info->subtype;
        D.31157 = (int) D.31156;
        encode_value (D.31157, p.155, &p);
        D.31156 = info->subtype;
        D.31158 = D.31156 + 4294967283;
        if (D.31158 <= 1) goto <D.31159>; else goto <D.31160>;
        <D.31159>:
        p.155 = p;
        D.31161 = info->d.runtime_invoke.method;
        encode_method_ref (acfg, D.31161, p.155, &p);
        goto <D.31162>;
        <D.31160>:
        D.31156 = info->subtype;
        if (D.31156 == 11) goto <D.31163>; else goto <D.31164>;
        <D.31163>:
        p.155 = p;
        D.31165 = info->d.runtime_invoke.sig;
        encode_signature (acfg, D.31165, p.155, &p);
        <D.31164>:
        <D.31162>:
        goto <D.24418>;
      }
      <D.24444>:
      <D.24445>:
      <D.24446>:
      D.31037 = BIT_FIELD_REF <*method, 8, 264>;
      D.31166 = D.31037 & 16;
      if (D.31166 != 0) goto <D.31167>; else goto <D.31168>;
      <D.31167>:
      p.155 = p;
      encode_value (1, p.155, &p);
      p.155 = p;
      D.31032 = method->klass;
      encode_klass_ref (acfg, D.31032, p.155, &p);
      goto <D.31169>;
      <D.31168>:
      {
        struct MonoMethodSignature * sig;
        struct WrapperInfo * info;

        sig = mono_method_signature (method);
        info = mono_marshal_get_wrapper_info (method);
        p.155 = p;
        encode_value (0, p.155, &p);
        D.31047 = BIT_FIELD_REF <*method, 8, 256>;
        D.31048 = D.31047 & 124;
        if (D.31048 == 4) goto <D.31170>; else goto <D.31171>;
        <D.31170>:
        p.155 = p;
        if (info != 0B) goto <D.31173>; else goto <D.31174>;
        <D.31173>:
        D.31175 = info->subtype;
        iftmp.157 = (gint32) D.31175;
        goto <D.31176>;
        <D.31174>:
        iftmp.157 = 0;
        <D.31176>:
        encode_value (iftmp.157, p.155, &p);
        <D.31171>:
        p.155 = p;
        encode_signature (acfg, sig, p.155, &p);
      }
      <D.31169>:
      goto <D.24418>;
      <D.24449>:
      {
        struct WrapperInfo * info;

        info = mono_marshal_get_wrapper_info (method);
        D.31177 = info == 0B;
        D.31178 = (long int) D.31177;
        D.31179 = __builtin_expect (D.31178, 0);
        if (D.31179 != 0) goto <D.31180>; else goto <D.31181>;
        <D.31180>:
        monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "aot-compiler.c", 2724, "info");
        <D.31181>:
        p.155 = p;
        D.31182 = info->d.native_to_managed.method;
        encode_method_ref (acfg, D.31182, p.155, &p);
        p.155 = p;
        D.31183 = info->d.native_to_managed.klass;
        encode_klass_ref (acfg, D.31183, p.155, &p);
        goto <D.24418>;
      }
      <D.24451>:
      monoeg_assertion_message ("* Assertion: should not be reached at %s:%d\n", "aot-compiler.c", 2730);
      <D.24418>:
      goto <D.31184>;
      <D.31050>:
      D.31185 = mono_method_signature (method);
      D.31186 = BIT_FIELD_REF <*D.31185, 8, 120>;
      D.31187 = D.31186 & 2;
      if (D.31187 != 0) goto <D.31188>; else goto <D.31189>;
      <D.31188>:
      D.31190 = acfg->token_info_hash;
      ji = monoeg_g_hash_table_lookup (D.31190, method);
      if (ji != 0B) goto <D.31191>; else goto <D.31192>;
      <D.31191>:
      D.31193 = ji->image;
      image_index = get_image_index (acfg, D.31193);
      D.31194 = image_index > 249;
      D.31195 = (long int) D.31194;
      D.31196 = __builtin_expect (D.31195, 0);
      if (D.31196 != 0) goto <D.31197>; else goto <D.31198>;
      <D.31197>:
      monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "aot-compiler.c", 2741, "image_index < MAX_IMAGE_INDEX");
      <D.31198>:
      token = ji->token;
      p.155 = p;
      encode_value (-33554432, p.155, &p);
      p.155 = p;
      image_index.158 = (int) image_index;
      encode_value (image_index.158, p.155, &p);
      p.155 = p;
      token.159 = (int) token;
      encode_value (token.159, p.155, &p);
      goto <D.31201>;
      <D.31192>:
      {
        struct MonoMethod * declaring;
        struct MonoGenericContext * context;

        context = mono_method_get_context (method);
        D.31037 = BIT_FIELD_REF <*method, 8, 264>;
        D.31166 = D.31037 & 16;
        D.31202 = D.31166 == 0;
        D.31203 = (long int) D.31202;
        D.31204 = __builtin_expect (D.31203, 0);
        if (D.31204 != 0) goto <D.31205>; else goto <D.31206>;
        <D.31205>:
        monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "aot-compiler.c", 2751, "method->is_inflated");
        <D.31206>:
        declaring = MEM[(struct MonoMethodInflated *)method].declaring;
        p.155 = p;
        encode_value (-50331648, p.155, &p);
        p.155 = p;
        D.31032 = method->klass;
        encode_klass_ref (acfg, D.31032, p.155, &p);
        D.31032 = method->klass;
        D.31033 = D.31032->image;
        image_index = get_image_index (acfg, D.31033);
        D.31194 = image_index > 249;
        D.31195 = (long int) D.31194;
        D.31196 = __builtin_expect (D.31195, 0);
        if (D.31196 != 0) goto <D.31207>; else goto <D.31208>;
        <D.31207>:
        monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "aot-compiler.c", 2764, "image_index < MAX_IMAGE_INDEX");
        <D.31208>:
        D.31209 = declaring->token;
        D.31210 = D.31209 == 0;
        D.31211 = (long int) D.31210;
        D.31212 = __builtin_expect (D.31211, 0);
        if (D.31212 != 0) goto <D.31213>; else goto <D.31214>;
        <D.31213>:
        monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "aot-compiler.c", 2765, "declaring->token");
        <D.31214>:
        token = declaring->token;
        D.31215 = token >> 24;
        D.31216 = D.31215 != 6;
        D.31217 = (long int) D.31216;
        D.31218 = __builtin_expect (D.31217, 0);
        if (D.31218 != 0) goto <D.31219>; else goto <D.31220>;
        <D.31219>:
        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.31220>:
        p.155 = p;
        image_index.158 = (int) image_index;
        encode_value (image_index.158, p.155, &p);
        p.155 = p;
        token.159 = (int) token;
        encode_value (token.159, p.155, &p);
        p.155 = p;
        encode_generic_context (acfg, context, p.155, &p);
      }
      <D.31201>:
      goto <D.31221>;
      <D.31189>:
      if (token == 0) goto <D.31222>; else goto <D.31223>;
      <D.31222>:
      D.31190 = acfg->token_info_hash;
      ji = monoeg_g_hash_table_lookup (D.31190, method);
      if (ji != 0B) goto <D.31224>; else goto <D.31225>;
      <D.31224>:
      D.31193 = ji->image;
      image_index = get_image_index (acfg, D.31193);
      D.31194 = image_index > 249;
      D.31195 = (long int) D.31194;
      D.31196 = __builtin_expect (D.31195, 0);
      if (D.31196 != 0) goto <D.31226>; else goto <D.31227>;
      <D.31226>:
      monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "aot-compiler.c", 2778, "image_index < MAX_IMAGE_INDEX");
      <D.31227>:
      token = ji->token;
      p.155 = p;
      encode_value (-33554432, p.155, &p);
      p.155 = p;
      image_index.158 = (int) image_index;
      encode_value (image_index.158, p.155, &p);
      p.155 = p;
      token.159 = (int) token;
      encode_value (token.159, p.155, &p);
      goto <D.31228>;
      <D.31225>:
      D.31032 = method->klass;
      D.31229 = D.31032->rank;
      D.31230 = D.31229 == 0;
      D.31231 = (long int) D.31230;
      D.31232 = __builtin_expect (D.31231, 0);
      if (D.31232 != 0) goto <D.31233>; else goto <D.31234>;
      <D.31233>:
      monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "aot-compiler.c", 2786, "method->klass->rank");
      <D.31234>:
      p.155 = p;
      encode_value (-100663296, p.155, &p);
      p.155 = p;
      D.31032 = method->klass;
      encode_klass_ref (acfg, D.31032, p.155, &p);
      {
        size_t __s1_len;
        size_t __s2_len;

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

          __s2 = method->name;
          D.31240 = ".ctor";
          D.31241 = MEM[(const unsigned char *)D.31240];
          D.31242 = (int) D.31241;
          D.31243 = *__s2;
          D.31244 = (int) D.31243;
          __result = D.31242 - D.31244;
          {
            D.31245 = __s2_len != 0;
            D.31246 = __result == 0;
            D.31247 = D.31245 & D.31246;
            if (D.31247 != 0) goto <D.31248>; else goto <D.31249>;
            <D.31248>:
            D.31250 = &MEM[(void *)".ctor" + 1B];
            D.31251 = *D.31250;
            D.31252 = (int) D.31251;
            D.31253 = __s2 + 1;
            D.31254 = *D.31253;
            D.31255 = (int) D.31254;
            __result = D.31252 - D.31255;
            D.31256 = __s2_len > 1;
            D.31246 = __result == 0;
            D.31257 = D.31256 & D.31246;
            if (D.31257 != 0) goto <D.31258>; else goto <D.31259>;
            <D.31258>:
            D.31260 = &MEM[(void *)".ctor" + 2B];
            D.31261 = *D.31260;
            D.31262 = (int) D.31261;
            D.31263 = __s2 + 2;
            D.31264 = *D.31263;
            D.31265 = (int) D.31264;
            __result = D.31262 - D.31265;
            D.31266 = __s2_len > 2;
            D.31246 = __result == 0;
            D.31267 = D.31266 & D.31246;
            if (D.31267 != 0) goto <D.31268>; else goto <D.31269>;
            <D.31268>:
            D.31270 = &MEM[(void *)".ctor" + 3B];
            D.31271 = *D.31270;
            D.31272 = (int) D.31271;
            D.31273 = __s2 + 3;
            D.31274 = *D.31273;
            D.31275 = (int) D.31274;
            __result = D.31272 - D.31275;
            <D.31269>:
            <D.31259>:
            <D.31249>:
          }
          D.24461 = __result;
        }
        iftmp.160 = -D.24461;
        goto <D.31276>;
        <D.31239>:
        D.31102 = method->name;
        iftmp.160 = __builtin_strcmp (D.31102, ".ctor");
        <D.31276>:
        D.24462 = iftmp.160;
      }
      if (D.24462 == 0) goto <D.31277>; else goto <D.31235>;
      <D.31277>:
      D.31278 = mono_method_signature (method);
      D.31279 = D.31278->param_count;
      D.31032 = method->klass;
      D.31229 = D.31032->rank;
      D.31280 = (short unsigned int) D.31229;
      if (D.31279 == D.31280) goto <D.31281>; else goto <D.31235>;
      <D.31281>:
      p.155 = p;
      encode_value (0, p.155, &p);
      goto <D.31236>;
      <D.31235>:
      {
        size_t __s1_len;
        size_t __s2_len;

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

          __s2 = method->name;
          D.31240 = ".ctor";
          D.31241 = MEM[(const unsigned char *)D.31240];
          D.31242 = (int) D.31241;
          D.31287 = *__s2;
          D.31288 = (int) D.31287;
          __result = D.31242 - D.31288;
          {
            D.31289 = __s2_len != 0;
            D.31290 = __result == 0;
            D.31291 = D.31289 & D.31290;
            if (D.31291 != 0) goto <D.31292>; else goto <D.31293>;
            <D.31292>:
            D.31250 = &MEM[(void *)".ctor" + 1B];
            D.31251 = *D.31250;
            D.31252 = (int) D.31251;
            D.31294 = __s2 + 1;
            D.31295 = *D.31294;
            D.31296 = (int) D.31295;
            __result = D.31252 - D.31296;
            D.31297 = __s2_len > 1;
            D.31290 = __result == 0;
            D.31298 = D.31297 & D.31290;
            if (D.31298 != 0) goto <D.31299>; else goto <D.31300>;
            <D.31299>:
            D.31260 = &MEM[(void *)".ctor" + 2B];
            D.31261 = *D.31260;
            D.31262 = (int) D.31261;
            D.31301 = __s2 + 2;
            D.31302 = *D.31301;
            D.31303 = (int) D.31302;
            __result = D.31262 - D.31303;
            D.31304 = __s2_len > 2;
            D.31290 = __result == 0;
            D.31305 = D.31304 & D.31290;
            if (D.31305 != 0) goto <D.31306>; else goto <D.31307>;
            <D.31306>:
            D.31270 = &MEM[(void *)".ctor" + 3B];
            D.31271 = *D.31270;
            D.31272 = (int) D.31271;
            D.31308 = __s2 + 3;
            D.31309 = *D.31308;
            D.31310 = (int) D.31309;
            __result = D.31272 - D.31310;
            <D.31307>:
            <D.31300>:
            <D.31293>:
          }
          D.24470 = __result;
        }
        iftmp.161 = -D.24470;
        goto <D.31311>;
        <D.31286>:
        D.31102 = method->name;
        iftmp.161 = __builtin_strcmp (D.31102, ".ctor");
        <D.31311>:
        D.24471 = iftmp.161;
      }
      if (D.24471 == 0) goto <D.31312>; else goto <D.31282>;
      <D.31312>:
      D.31313 = mono_method_signature (method);
      D.31314 = D.31313->param_count;
      D.31315 = (int) D.31314;
      D.31032 = method->klass;
      D.31229 = D.31032->rank;
      D.31316 = (int) D.31229;
      D.31317 = D.31316 * 2;
      if (D.31315 == D.31317) goto <D.31318>; else goto <D.31282>;
      <D.31318>:
      p.155 = p;
      encode_value (1, p.155, &p);
      goto <D.31283>;
      <D.31282>:
      {
        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 = "Get";
          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;
          {
            D.31327 = __s2_len != 0;
            D.31328 = __result == 0;
            D.31329 = D.31327 & D.31328;
            if (D.31329 != 0) goto <D.31330>; else goto <D.31331>;
            <D.31330>:
            D.31332 = &MEM[(void *)"Get" + 1B];
            D.31333 = *D.31332;
            D.31334 = (int) D.31333;
            D.31335 = __s2 + 1;
            D.31336 = *D.31335;
            D.31337 = (int) D.31336;
            __result = D.31334 - D.31337;
            D.31338 = __s2_len > 1;
            D.31328 = __result == 0;
            D.31339 = D.31338 & D.31328;
            if (D.31339 != 0) goto <D.31340>; else goto <D.31341>;
            <D.31340>:
            D.31342 = &MEM[(void *)"Get" + 2B];
            D.31343 = *D.31342;
            D.31344 = (int) D.31343;
            D.31345 = __s2 + 2;
            D.31346 = *D.31345;
            D.31347 = (int) D.31346;
            __result = D.31344 - D.31347;
            D.31348 = __s2_len > 2;
            D.31328 = __result == 0;
            D.31349 = D.31348 & D.31328;
            if (D.31349 != 0) goto <D.31350>; else goto <D.31351>;
            <D.31350>:
            D.31352 = &MEM[(void *)"Get" + 3B];
            D.31353 = *D.31352;
            D.31354 = (int) D.31353;
            D.31355 = __s2 + 3;
            D.31356 = *D.31355;
            D.31357 = (int) D.31356;
            __result = D.31354 - D.31357;
            <D.31351>:
            <D.31341>:
            <D.31331>:
          }
          D.24479 = __result;
        }
        iftmp.162 = -D.24479;
        goto <D.31358>;
        <D.31321>:
        D.31102 = method->name;
        iftmp.162 = __builtin_strcmp (D.31102, "Get");
        <D.31358>:
        D.24480 = iftmp.162;
      }
      if (D.24480 == 0) goto <D.31359>; else goto <D.31360>;
      <D.31359>:
      p.155 = p;
      encode_value (2, p.155, &p);
      goto <D.31361>;
      <D.31360>:
      {
        size_t __s1_len;
        size_t __s2_len;

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

          __s2 = method->name;
          D.31365 = "Address";
          D.31366 = MEM[(const unsigned char *)D.31365];
          D.31367 = (int) D.31366;
          D.31368 = *__s2;
          D.31369 = (int) D.31368;
          __result = D.31367 - D.31369;
          {
            D.31370 = __s2_len != 0;
            D.31371 = __result == 0;
            D.31372 = D.31370 & D.31371;
            if (D.31372 != 0) goto <D.31373>; else goto <D.31374>;
            <D.31373>:
            D.31375 = &MEM[(void *)"Address" + 1B];
            D.31376 = *D.31375;
            D.31377 = (int) D.31376;
            D.31378 = __s2 + 1;
            D.31379 = *D.31378;
            D.31380 = (int) D.31379;
            __result = D.31377 - D.31380;
            D.31381 = __s2_len > 1;
            D.31371 = __result == 0;
            D.31382 = D.31381 & D.31371;
            if (D.31382 != 0) goto <D.31383>; else goto <D.31384>;
            <D.31383>:
            D.31385 = &MEM[(void *)"Address" + 2B];
            D.31386 = *D.31385;
            D.31387 = (int) D.31386;
            D.31388 = __s2 + 2;
            D.31389 = *D.31388;
            D.31390 = (int) D.31389;
            __result = D.31387 - D.31390;
            D.31391 = __s2_len > 2;
            D.31371 = __result == 0;
            D.31392 = D.31391 & D.31371;
            if (D.31392 != 0) goto <D.31393>; else goto <D.31394>;
            <D.31393>:
            D.31395 = &MEM[(void *)"Address" + 3B];
            D.31396 = *D.31395;
            D.31397 = (int) D.31396;
            D.31398 = __s2 + 3;
            D.31399 = *D.31398;
            D.31400 = (int) D.31399;
            __result = D.31397 - D.31400;
            <D.31394>:
            <D.31384>:
            <D.31374>:
          }
          D.24488 = __result;
        }
        iftmp.163 = -D.24488;
        goto <D.31401>;
        <D.31364>:
        D.31102 = method->name;
        iftmp.163 = __builtin_strcmp (D.31102, "Address");
        <D.31401>:
        D.24489 = iftmp.163;
      }
      if (D.24489 == 0) goto <D.31402>; else goto <D.31403>;
      <D.31402>:
      p.155 = p;
      encode_value (3, p.155, &p);
      goto <D.31404>;
      <D.31403>:
      {
        size_t __s1_len;
        size_t __s2_len;

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

          __s2 = method->name;
          D.31408 = "Set";
          D.31409 = MEM[(const unsigned char *)D.31408];
          D.31410 = (int) D.31409;
          D.31411 = *__s2;
          D.31412 = (int) D.31411;
          __result = D.31410 - D.31412;
          {
            D.31413 = __s2_len != 0;
            D.31414 = __result == 0;
            D.31415 = D.31413 & D.31414;
            if (D.31415 != 0) goto <D.31416>; else goto <D.31417>;
            <D.31416>:
            D.31418 = &MEM[(void *)"Set" + 1B];
            D.31419 = *D.31418;
            D.31420 = (int) D.31419;
            D.31421 = __s2 + 1;
            D.31422 = *D.31421;
            D.31423 = (int) D.31422;
            __result = D.31420 - D.31423;
            D.31424 = __s2_len > 1;
            D.31414 = __result == 0;
            D.31425 = D.31424 & D.31414;
            if (D.31425 != 0) goto <D.31426>; else goto <D.31427>;
            <D.31426>:
            D.31428 = &MEM[(void *)"Set" + 2B];
            D.31429 = *D.31428;
            D.31430 = (int) D.31429;
            D.31431 = __s2 + 2;
            D.31432 = *D.31431;
            D.31433 = (int) D.31432;
            __result = D.31430 - D.31433;
            D.31434 = __s2_len > 2;
            D.31414 = __result == 0;
            D.31435 = D.31434 & D.31414;
            if (D.31435 != 0) goto <D.31436>; else goto <D.31437>;
            <D.31436>:
            D.31438 = &MEM[(void *)"Set" + 3B];
            D.31439 = *D.31438;
            D.31440 = (int) D.31439;
            D.31441 = __s2 + 3;
            D.31442 = *D.31441;
            D.31443 = (int) D.31442;
            __result = D.31440 - D.31443;
            <D.31437>:
            <D.31427>:
            <D.31417>:
          }
          D.24497 = __result;
        }
        iftmp.164 = -D.24497;
        goto <D.31444>;
        <D.31407>:
        D.31102 = method->name;
        iftmp.164 = __builtin_strcmp (D.31102, "Set");
        <D.31444>:
        D.24498 = iftmp.164;
      }
      if (D.24498 == 0) goto <D.31445>; else goto <D.31446>;
      <D.31445>:
      p.155 = p;
      encode_value (4, p.155, &p);
      goto <D.31447>;
      <D.31446>:
      monoeg_assertion_message ("* Assertion: should not be reached at %s:%d\n", "aot-compiler.c", 2802);
      <D.31447>:
      <D.31404>:
      <D.31361>:
      <D.31283>:
      <D.31236>:
      <D.31228>:
      goto <D.31448>;
      <D.31223>:
      D.31215 = token >> 24;
      D.31216 = D.31215 != 6;
      D.31217 = (long int) D.31216;
      D.31218 = __builtin_expect (D.31217, 0);
      if (D.31218 != 0) goto <D.31449>; else goto <D.31450>;
      <D.31449>:
      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.31450>:
      if (image_index > 239) goto <D.31451>; else goto <D.31452>;
      <D.31451>:
      p.155 = p;
      encode_value (-117440512, p.155, &p);
      p.155 = p;
      image_index.158 = (int) image_index;
      encode_value (image_index.158, p.155, &p);
      p.155 = p;
      token.159 = (int) token;
      D.31453 = token.159 & 16777215;
      encode_value (D.31453, p.155, &p);
      goto <D.31454>;
      <D.31452>:
      p.155 = p;
      D.31455 = image_index << 24;
      D.31456 = token & 16777215;
      D.31457 = D.31455 | D.31456;
      D.31458 = (int) D.31457;
      encode_value (D.31458, p.155, &p);
      <D.31454>:
      <D.31448>:
      <D.31221>:
      <D.31184>:
      p.155 = p;
      *endbuf = p.155;
    }
  finally
    {
      p = {CLOBBER};
    }
}


encode_signature (struct MonoAotCompile * acfg, struct MonoMethodSignature * sig, guint8 * buf, guint8 * * endbuf)
{
  short unsigned int D.31461;
  unsigned char D.31464;
  unsigned char D.31465;
  unsigned char D.31468;
  <unnamed-unsigned:6> D.31471;
  unsigned int D.31472;
  unsigned int D.31473;
  guint8 * p.165;
  unsigned char D.31475;
  guint8 * p.166;
  int D.31479;
  short unsigned int D.31480;
  int D.31481;
  struct MonoType * D.31482;
  short int D.31483;
  int D.31484;
  struct MonoType * D.31487;
  int D.31488;
  guint8 * p;
  guint32 flags;
  int i;

  try
    {
      p = buf;
      flags = 0;
      D.31461 = sig->generic_param_count;
      if (D.31461 != 0) goto <D.31462>; else goto <D.31463>;
      <D.31462>:
      flags = flags | 16;
      <D.31463>:
      D.31464 = BIT_FIELD_REF <*sig, 8, 112>;
      D.31465 = D.31464 & 64;
      if (D.31465 != 0) goto <D.31466>; else goto <D.31467>;
      <D.31466>:
      flags = flags | 32;
      <D.31467>:
      D.31464 = BIT_FIELD_REF <*sig, 8, 112>;
      D.31468 = D.31464 & 128;
      if (D.31468 != 0) goto <D.31469>; else goto <D.31470>;
      <D.31469>:
      flags = flags | 64;
      <D.31470>:
      D.31471 = sig->call_convention;
      D.31472 = (unsigned int) D.31471;
      D.31473 = D.31472 & 15;
      flags = D.31473 | flags;
      p.165 = p;
      D.31475 = (unsigned char) flags;
      *p.165 = D.31475;
      p.165 = p;
      p.166 = p.165 + 1;
      p = p.166;
      D.31461 = sig->generic_param_count;
      if (D.31461 != 0) goto <D.31477>; else goto <D.31478>;
      <D.31477>:
      p.165 = p;
      D.31461 = sig->generic_param_count;
      D.31479 = (int) D.31461;
      encode_value (D.31479, p.165, &p);
      <D.31478>:
      p.165 = p;
      D.31480 = sig->param_count;
      D.31481 = (int) D.31480;
      encode_value (D.31481, p.165, &p);
      p.165 = p;
      D.31482 = sig->ret;
      encode_type (acfg, D.31482, p.165, &p);
      i = 0;
      goto <D.24402>;
      <D.24401>:
      D.31483 = sig->sentinelpos;
      D.31484 = (int) D.31483;
      if (D.31484 == i) goto <D.31485>; else goto <D.31486>;
      <D.31485>:
      p.165 = p;
      *p.165 = 65;
      p.165 = p;
      p.166 = p.165 + 1;
      p = p.166;
      <D.31486>:
      p.165 = p;
      D.31487 = sig->params[i];
      encode_type (acfg, D.31487, p.165, &p);
      i = i + 1;
      <D.24402>:
      D.31480 = sig->param_count;
      D.31488 = (int) D.31480;
      if (D.31488 > i) goto <D.24401>; else goto <D.24403>;
      <D.24403>:
      p.165 = p;
      *endbuf = p.165;
    }
  finally
    {
      p = {CLOBBER};
    }
}


encode_generic_context (struct MonoAotCompile * acfg, struct MonoGenericContext * context, guint8 * buf, guint8 * * endbuf)
{
  unsigned int D.31491;
  unsigned int D.31492;
  _Bool D.31493;
  long int D.31494;
  long int D.31495;
  guint8 * p.167;
  guint8 * p;
  struct MonoGenericInst * inst;

  try
    {
      p = buf;
      inst = context->class_inst;
      if (inst != 0B) goto <D.31489>; else goto <D.31490>;
      <D.31489>:
      D.31491 = BIT_FIELD_REF <*inst, 32, 32>;
      D.31492 = D.31491 & 4194303;
      D.31493 = D.31492 == 0;
      D.31494 = (long int) D.31493;
      D.31495 = __builtin_expect (D.31494, 0);
      if (D.31495 != 0) goto <D.31496>; else goto <D.31497>;
      <D.31496>:
      monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "aot-compiler.c", 2425, "inst->type_argc");
      <D.31497>:
      p.167 = p;
      encode_ginst (acfg, inst, p.167, &p);
      goto <D.31499>;
      <D.31490>:
      p.167 = p;
      encode_value (0, p.167, &p);
      <D.31499>:
      inst = context->method_inst;
      if (inst != 0B) goto <D.31500>; else goto <D.31501>;
      <D.31500>:
      D.31491 = BIT_FIELD_REF <*inst, 32, 32>;
      D.31492 = D.31491 & 4194303;
      D.31493 = D.31492 == 0;
      D.31494 = (long int) D.31493;
      D.31495 = __builtin_expect (D.31494, 0);
      if (D.31495 != 0) goto <D.31502>; else goto <D.31503>;
      <D.31502>:
      monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "aot-compiler.c", 2432, "inst->type_argc");
      <D.31503>:
      p.167 = p;
      encode_ginst (acfg, inst, p.167, &p);
      goto <D.31504>;
      <D.31501>:
      p.167 = p;
      encode_value (0, p.167, &p);
      <D.31504>:
      p.167 = p;
      *endbuf = p.167;
    }
  finally
    {
      p = {CLOBBER};
    }
}


encode_type (struct MonoAotCompile * acfg, struct MonoType * t, guint8 * buf, guint8 * * endbuf)
{
  unsigned char D.31505;
  unsigned char D.31506;
  _Bool D.31507;
  long int D.31508;
  long int D.31509;
  unsigned char D.31512;
  guint8 * p.168;
  guint8 * p.169;
  unsigned char D.31517;
  unsigned char D.31520;
  int D.31521;
  struct MonoClass * D.31522;
  struct MonoClass * D.31523;
  struct MonoType * D.31524;
  struct MonoGenericClass * D.31525;
  struct MonoClass * D.31526;
  unsigned char D.31527;
  int D.31528;
  unsigned char D.31529;
  int D.31530;
  int * D.31531;
  long unsigned int D.31532;
  long unsigned int D.31533;
  int * D.31534;
  int D.31535;
  int D.31536;
  unsigned char D.31537;
  int D.31538;
  int * D.31539;
  int * D.31540;
  int D.31541;
  int D.31542;
  struct MonoClass * D.31543;
  guint8 * p;

  try
    {
      p = buf;
      D.31505 = BIT_FIELD_REF <*t, 8, 88>;
      D.31506 = D.31505 & 63;
      D.31507 = D.31506 != 0;
      D.31508 = (long int) D.31507;
      D.31509 = __builtin_expect (D.31508, 0);
      if (D.31509 != 0) goto <D.31510>; else goto <D.31511>;
      <D.31510>:
      monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "aot-compiler.c", 2445, "t->num_mods == 0");
      <D.31511>:
      D.31505 = BIT_FIELD_REF <*t, 8, 88>;
      D.31512 = D.31505 & 128;
      if (D.31512 != 0) goto <D.31513>; else goto <D.31514>;
      <D.31513>:
      p.168 = p;
      *p.168 = 69;
      p.168 = p;
      p.169 = p.168 + 1;
      p = p.169;
      <D.31514>:
      D.31505 = BIT_FIELD_REF <*t, 8, 88>;
      D.31517 = D.31505 & 64;
      if (D.31517 != 0) goto <D.31518>; else goto <D.31519>;
      <D.31518>:
      p.168 = p;
      *p.168 = 16;
      p.168 = p;
      p.169 = p.168 + 1;
      p = p.169;
      <D.31519>:
      p.168 = p;
      D.31520 = t->type;
      *p.168 = D.31520;
      p.168 = p;
      p.169 = p.168 + 1;
      p = p.169;
      D.31520 = t->type;
      D.31521 = (int) D.31520;
      switch (D.31521) <default: <D.24391>, case 1: <D.24354>, case 2: <D.24355>, case 3: <D.24356>, case 4: <D.24357>, case 5: <D.24358>, case 6: <D.24359>, case 7: <D.24360>, case 8: <D.24361>, case 9: <D.24362>, case 10: <D.24363>, case 11: <D.24364>, case 12: <D.24365>, case 13: <D.24366>, case 14: <D.24369>, case 15: <D.24376>, case 17: <D.24373>, case 18: <D.24374>, case 19: <D.24389>, case 20: <D.24380>, case 21: <D.24377>, case 22: <D.24371>, case 24: <D.24367>, case 25: <D.24368>, case 28: <D.24370>, case 29: <D.24375>, case 30: <D.24390>>
      <D.24354>:
      <D.24355>:
      <D.24356>:
      <D.24357>:
      <D.24358>:
      <D.24359>:
      <D.24360>:
      <D.24361>:
      <D.24362>:
      <D.24363>:
      <D.24364>:
      <D.24365>:
      <D.24366>:
      <D.24367>:
      <D.24368>:
      <D.24369>:
      <D.24370>:
      <D.24371>:
      goto <D.24372>;
      <D.24373>:
      <D.24374>:
      p.168 = p;
      D.31522 = mono_class_from_mono_type (t);
      encode_klass_ref (acfg, D.31522, p.168, &p);
      goto <D.24372>;
      <D.24375>:
      p.168 = p;
      D.31523 = t->data.klass;
      encode_klass_ref (acfg, D.31523, p.168, &p);
      goto <D.24372>;
      <D.24376>:
      p.168 = p;
      D.31524 = t->data.type;
      encode_type (acfg, D.31524, p.168, &p);
      goto <D.24372>;
      <D.24377>:
      {
        struct MonoClass * gclass;
        struct MonoGenericInst * inst;

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

        array = t->data.array;
        p.168 = p;
        D.31526 = array->eklass;
        encode_klass_ref (acfg, D.31526, p.168, &p);
        p.168 = p;
        D.31527 = array->rank;
        D.31528 = (int) D.31527;
        encode_value (D.31528, p.168, &p);
        p.168 = p;
        D.31529 = array->numsizes;
        D.31530 = (int) D.31529;
        encode_value (D.31530, p.168, &p);
        i = 0;
        goto <D.24384>;
        <D.24383>:
        p.168 = p;
        D.31531 = array->sizes;
        D.31532 = (long unsigned int) i;
        D.31533 = D.31532 * 4;
        D.31534 = D.31531 + D.31533;
        D.31535 = *D.31534;
        encode_value (D.31535, p.168, &p);
        i = i + 1;
        <D.24384>:
        D.31529 = array->numsizes;
        D.31536 = (int) D.31529;
        if (D.31536 > i) goto <D.24383>; else goto <D.24385>;
        <D.24385>:
        p.168 = p;
        D.31537 = array->numlobounds;
        D.31538 = (int) D.31537;
        encode_value (D.31538, p.168, &p);
        i = 0;
        goto <D.24387>;
        <D.24386>:
        p.168 = p;
        D.31539 = array->lobounds;
        D.31532 = (long unsigned int) i;
        D.31533 = D.31532 * 4;
        D.31540 = D.31539 + D.31533;
        D.31541 = *D.31540;
        encode_value (D.31541, p.168, &p);
        i = i + 1;
        <D.24387>:
        D.31537 = array->numlobounds;
        D.31542 = (int) D.31537;
        if (D.31542 > i) goto <D.24386>; else goto <D.24388>;
        <D.24388>:
        goto <D.24372>;
      }
      <D.24389>:
      <D.24390>:
      p.168 = p;
      D.31543 = mono_class_from_mono_type (t);
      encode_klass_ref (acfg, D.31543, p.168, &p);
      goto <D.24372>;
      <D.24391>:
      monoeg_assertion_message ("* Assertion: should not be reached at %s:%d\n", "aot-compiler.c", 2518);
      <D.24372>:
      p.168 = p;
      *endbuf = p.168;
    }
  finally
    {
      p = {CLOBBER};
    }
}


encode_value (gint32 value, guint8 * buf, guint8 * * endbuf)
{
  unsigned int value.170;
  guint8 * p.171;
  unsigned char D.31549;
  int D.31553;
  signed char D.31554;
  signed char D.31555;
  unsigned char D.31556;
  guint8 * D.31557;
  unsigned char D.31558;
  int D.31562;
  signed char D.31563;
  signed char D.31564;
  unsigned char D.31565;
  int D.31566;
  unsigned char D.31567;
  guint8 * D.31568;
  unsigned char D.31569;
  guint8 * D.31570;
  unsigned int D.31572;
  unsigned char D.31573;
  guint8 * D.31574;
  guint8 * p;

  p = buf;
  value.170 = (unsigned int) value;
  if (value.170 <= 127) goto <D.31546>; else goto <D.31547>;
  <D.31546>:
  p.171 = p;
  p = p.171 + 1;
  D.31549 = (unsigned char) value;
  *p.171 = D.31549;
  goto <D.31550>;
  <D.31547>:
  value.170 = (unsigned int) value;
  if (value.170 <= 16383) goto <D.31551>; else goto <D.31552>;
  <D.31551>:
  D.31553 = value >> 8;
  D.31554 = (signed char) D.31553;
  D.31555 = D.31554 | -128;
  D.31556 = (unsigned char) D.31555;
  *p = D.31556;
  D.31557 = p + 1;
  D.31558 = (unsigned char) value;
  *D.31557 = D.31558;
  p = p + 2;
  goto <D.31559>;
  <D.31552>:
  value.170 = (unsigned int) value;
  if (value.170 <= 536870911) goto <D.31560>; else goto <D.31561>;
  <D.31560>:
  D.31562 = value >> 24;
  D.31563 = (signed char) D.31562;
  D.31564 = D.31563 | -64;
  D.31565 = (unsigned char) D.31564;
  *p = D.31565;
  D.31557 = p + 1;
  D.31566 = value >> 16;
  D.31567 = (unsigned char) D.31566;
  *D.31557 = D.31567;
  D.31568 = p + 2;
  D.31553 = value >> 8;
  D.31569 = (unsigned char) D.31553;
  *D.31568 = D.31569;
  D.31570 = p + 3;
  D.31558 = (unsigned char) value;
  *D.31570 = D.31558;
  p = p + 4;
  goto <D.31571>;
  <D.31561>:
  *p = 255;
  D.31557 = p + 1;
  value.170 = (unsigned int) value;
  D.31572 = value.170 >> 24;
  D.31573 = (unsigned char) D.31572;
  *D.31557 = D.31573;
  D.31568 = p + 2;
  D.31566 = value >> 16;
  D.31567 = (unsigned char) D.31566;
  *D.31568 = D.31567;
  D.31570 = p + 3;
  D.31553 = value >> 8;
  D.31569 = (unsigned char) D.31553;
  *D.31570 = D.31569;
  D.31574 = p + 4;
  D.31558 = (unsigned char) value;
  *D.31574 = D.31558;
  p = p + 5;
  <D.31571>:
  <D.31559>:
  <D.31550>:
  if (endbuf != 0B) goto <D.31575>; else goto <D.31576>;
  <D.31575>:
  *endbuf = p;
  <D.31576>:
}


encode_patch_list (struct MonoAotCompile * acfg, struct GPtrArray * patches, int n_patches, int first_got_offset, guint8 * buf, guint8 * * endbuf)
{
  guint8 * p.172;
  void * * D.31578;
  long unsigned int D.31579;
  long unsigned int D.31580;
  void * * D.31581;
  <unnamed type> D.31582;
  _Bool D.31583;
  _Bool D.31584;
  _Bool D.31585;
  int offset.173;
  unsigned int D.31589;
  guint8 * p;
  guint32 pindex;
  guint32 offset;
  struct MonoJumpInfo * patch_info;

  try
    {
      p = buf;
      p.172 = p;
      encode_value (n_patches, p.172, &p);
      pindex = 0;
      goto <D.25442>;
      <D.25441>:
      D.31578 = patches->pdata;
      D.31579 = (long unsigned int) pindex;
      D.31580 = D.31579 * 8;
      D.31581 = D.31578 + D.31580;
      patch_info = *D.31581;
      D.31582 = patch_info->type;
      D.31583 = D.31582 == 51;
      D.31584 = D.31582 == 0;
      D.31585 = D.31583 | D.31584;
      if (D.31585 != 0) goto <D.31586>; else goto <D.31587>;
      <D.31586>:
      // predicted unlikely by continue predictor.
      goto <D.25440>;
      <D.31587>:
      offset = get_got_offset (acfg, patch_info);
      p.172 = p;
      offset.173 = (int) offset;
      encode_value (offset.173, p.172, &p);
      <D.25440>:
      pindex = pindex + 1;
      <D.25442>:
      D.31589 = patches->len;
      if (D.31589 > pindex) goto <D.25441>; else goto <D.25443>;
      <D.25443>:
      p.172 = p;
      *endbuf = p.172;
    }
  finally
    {
      p = {CLOBBER};
    }
}


add_to_blob (struct MonoAotCompile * acfg, const guint8 * data, guint32 data_len)
{
  unsigned int D.31590;
  struct MonoDynamicStream * D.31593;
  guint32 D.31594;

  D.31590 = acfg->blob.alloc_size;
  if (D.31590 == 0) goto <D.31591>; else goto <D.31592>;
  <D.31591>:
  D.31593 = &acfg->blob;
  stream_init (D.31593);
  <D.31592>:
  D.31593 = &acfg->blob;
  D.31594 = add_stream_data (D.31593, data, data_len);
  return D.31594;
}


stream_init (struct MonoDynamicStream * sh)
{
  void * D.31596;
  char * D.31597;
  unsigned int D.31598;
  unsigned int D.31599;

  sh->index = 0;
  sh->alloc_size = 4096;
  D.31596 = monoeg_malloc (4096);
  sh->data = D.31596;
  D.31597 = sh->data;
  *D.31597 = 0;
  D.31598 = sh->index;
  D.31599 = D.31598 + 1;
  sh->index = D.31599;
}


add_stream_data (struct MonoDynamicStream * stream, const char * data, guint32 len)
{
  unsigned int D.31600;
  unsigned int D.31601;
  int D.31602;
  long unsigned int D.31603;
  char * D.31604;
  sizetype D.31605;
  char * D.31606;
  guint32 D.31607;
  guint32 idx;

  D.31600 = stream->index;
  D.31601 = D.31600 + len;
  D.31602 = (int) D.31601;
  make_room_in_stream (stream, D.31602);
  D.31603 = (long unsigned int) len;
  D.31604 = stream->data;
  D.31600 = stream->index;
  D.31605 = (sizetype) D.31600;
  D.31606 = D.31604 + D.31605;
  memcpy (D.31606, data, D.31603);
  idx = stream->index;
  D.31600 = stream->index;
  D.31601 = D.31600 + len;
  stream->index = D.31601;
  D.31607 = idx;
  return D.31607;
}


make_room_in_stream (struct MonoDynamicStream * stream, int size)
{
  unsigned int size.174;
  unsigned int D.31610;
  unsigned int D.31616;
  long unsigned int D.31617;
  char * D.31618;
  void * D.31619;

  size.174 = (unsigned int) size;
  D.31610 = stream->alloc_size;
  if (size.174 <= D.31610) goto <D.31611>; else goto <D.31612>;
  <D.31611>:
  return;
  <D.31612>:
  goto <D.24216>;
  <D.24215>:
  D.31610 = stream->alloc_size;
  if (D.31610 <= 4095) goto <D.31613>; else goto <D.31614>;
  <D.31613>:
  stream->alloc_size = 4096;
  goto <D.31615>;
  <D.31614>:
  D.31610 = stream->alloc_size;
  D.31616 = D.31610 * 2;
  stream->alloc_size = D.31616;
  <D.31615>:
  <D.24216>:
  D.31610 = stream->alloc_size;
  size.174 = (unsigned int) size;
  if (D.31610 <= size.174) goto <D.24215>; else goto <D.24217>;
  <D.24217>:
  D.31610 = stream->alloc_size;
  D.31617 = (long unsigned int) D.31610;
  D.31618 = stream->data;
  D.31619 = monoeg_realloc (D.31618, D.31617);
  stream->data = D.31619;
}


emit_offset_table (struct MonoAotCompile * acfg, int noffsets, int group_size, gint32 * offsets)
{
  int D.31621;
  int D.31622;
  long unsigned int D.31623;
  long unsigned int D.31624;
  long unsigned int D.31625;
  int D.31626;
  int D.31629;
  long unsigned int D.31630;
  long unsigned int D.31631;
  guint32 * D.31632;
  guint8 * p.175;
  long int p.176;
  long int buf.177;
  long int D.31636;
  unsigned int D.31637;
  long unsigned int D.31638;
  long unsigned int D.31639;
  gint32 * D.31640;
  int D.31641;
  int D.31643;
  sizetype D.31647;
  guint32 * D.31648;
  unsigned int D.31649;
  guint32 * D.31653;
  unsigned int D.31654;
  int D.31655;
  int D.31657;
  guint32 D.31658;
  int D.31659;
  int D.31660;
  gint32 current_offset;
  int i;
  int buf_size;
  int ngroups;
  int index_entry_size;
  guint8 * p;
  guint8 * buf;
  guint32 * index_offsets;

  try
    {
      D.31621 = group_size + -1;
      D.31622 = D.31621 + noffsets;
      ngroups = D.31622 / group_size;
      D.31623 = (long unsigned int) ngroups;
      D.31624 = D.31623 * 4;
      index_offsets = monoeg_malloc0 (D.31624);
      buf_size = noffsets * 4;
      D.31625 = (long unsigned int) buf_size;
      buf = monoeg_malloc0 (D.31625);
      p = buf;
      current_offset = 0;
      i = 0;
      goto <D.24252>;
      <D.24251>:
      D.31626 = i % group_size;
      if (D.31626 == 0) goto <D.31627>; else goto <D.31628>;
      <D.31627>:
      D.31629 = i / group_size;
      D.31630 = (long unsigned int) D.31629;
      D.31631 = D.31630 * 4;
      D.31632 = index_offsets + D.31631;
      p.175 = p;
      p.176 = (long int) p.175;
      buf.177 = (long int) buf;
      D.31636 = p.176 - buf.177;
      D.31637 = (unsigned int) D.31636;
      *D.31632 = D.31637;
      p.175 = p;
      D.31638 = (long unsigned int) i;
      D.31639 = D.31638 * 4;
      D.31640 = offsets + D.31639;
      D.31641 = *D.31640;
      encode_value (D.31641, p.175, &p);
      goto <D.31642>;
      <D.31628>:
      p.175 = p;
      D.31638 = (long unsigned int) i;
      D.31639 = D.31638 * 4;
      D.31640 = offsets + D.31639;
      D.31641 = *D.31640;
      D.31643 = D.31641 - current_offset;
      encode_value (D.31643, p.175, &p);
      <D.31642>:
      D.31638 = (long unsigned int) i;
      D.31639 = D.31638 * 4;
      D.31640 = offsets + D.31639;
      current_offset = *D.31640;
      i = i + 1;
      <D.24252>:
      if (i < noffsets) goto <D.24251>; else goto <D.24253>;
      <D.24253>:
      if (ngroups != 0) goto <D.31646>; else goto <D.31644>;
      <D.31646>:
      D.31623 = (long unsigned int) ngroups;
      D.31624 = D.31623 * 4;
      D.31647 = D.31624 + 18446744073709551612;
      D.31648 = index_offsets + D.31647;
      D.31649 = *D.31648;
      if (D.31649 <= 64999) goto <D.31650>; else goto <D.31644>;
      <D.31650>:
      index_entry_size = 2;
      goto <D.31645>;
      <D.31644>:
      index_entry_size = 4;
      <D.31645>:
      emit_int32 (acfg, noffsets);
      emit_int32 (acfg, group_size);
      emit_int32 (acfg, ngroups);
      emit_int32 (acfg, index_entry_size);
      i = 0;
      goto <D.24255>;
      <D.24254>:
      if (index_entry_size == 2) goto <D.31651>; else goto <D.31652>;
      <D.31651>:
      D.31638 = (long unsigned int) i;
      D.31639 = D.31638 * 4;
      D.31653 = index_offsets + D.31639;
      D.31654 = *D.31653;
      D.31655 = (int) D.31654;
      emit_int16 (acfg, D.31655);
      goto <D.31656>;
      <D.31652>:
      D.31638 = (long unsigned int) i;
      D.31639 = D.31638 * 4;
      D.31653 = index_offsets + D.31639;
      D.31654 = *D.31653;
      D.31655 = (int) D.31654;
      emit_int32 (acfg, D.31655);
      <D.31656>:
      i = i + 1;
      <D.24255>:
      if (i < ngroups) goto <D.24254>; else goto <D.24256>;
      <D.24256>:
      p.175 = p;
      p.176 = (long int) p.175;
      buf.177 = (long int) buf;
      D.31636 = p.176 - buf.177;
      D.31657 = (int) D.31636;
      emit_bytes (acfg, buf, D.31657);
      p.175 = p;
      p.176 = (long int) p.175;
      buf.177 = (long int) buf;
      D.31636 = p.176 - buf.177;
      D.31657 = (int) D.31636;
      D.31659 = ngroups * 4;
      D.31660 = D.31657 + D.31659;
      D.31658 = (guint32) D.31660;
      return D.31658;
    }
  finally
    {
      p = {CLOBBER};
    }
}


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

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


emit_extra_methods (struct MonoAotCompile * acfg)
{
  struct GPtrArray * D.31664;
  unsigned int D.31665;
  long unsigned int D.31666;
  long unsigned int D.31667;
  void * * D.31668;
  long unsigned int D.31669;
  long unsigned int D.31670;
  void * * D.31671;
  struct GHashTable * D.31672;
  long unsigned int D.31675;
  guint8 * p.178;
  long int p.179;
  long int buf.180;
  long int D.31679;
  long int D.31680;
  _Bool D.31681;
  long int D.31682;
  long int D.31683;
  long unsigned int D.31686;
  guint32 * D.31687;
  unsigned int D.31688;
  unsigned int D.31689;
  unsigned int i.181;
  double D.31691;
  double D.31692;
  int D.31693;
  unsigned int D.31694;
  unsigned int D.31695;
  unsigned int table_size.182;
  long unsigned int D.31697;
  long unsigned int D.31698;
  unsigned int D.31701;
  unsigned int table_size.183;
  long unsigned int D.31703;
  long unsigned int D.31704;
  int * D.31705;
  int D.31706;
  int D.31707;
  struct MonoMemPool * D.31708;
  void * * D.31709;
  long unsigned int D.31710;
  void * * D.31711;
  struct HashEntry * D.31715;
  unsigned int D.31716;
  void * * D.31717;
  unsigned int D.31721;
  int D.31722;
  unsigned int D.31723;
  int D.31724;
  struct HashEntry * D.31725;
  unsigned int D.31728;
  int D.31729;
  int D.31731;
  unsigned int D.31732;
  int D.31733;
  unsigned int D.31734;
  int D.31735;
  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.31664 = acfg->extra_methods;
      D.31665 = D.31664->len;
      D.31666 = (long unsigned int) D.31665;
      D.31667 = D.31666 * 4;
      info_offsets = monoeg_malloc0 (D.31667);
      nmethods = 0;
      i = 0;
      goto <D.26154>;
      <D.26153>:
      {
        struct MonoMethod * method;
        struct MonoCompile * cfg;

        D.31664 = acfg->extra_methods;
        D.31668 = D.31664->pdata;
        D.31669 = (long unsigned int) i;
        D.31670 = D.31669 * 8;
        D.31671 = D.31668 + D.31670;
        method = *D.31671;
        D.31672 = acfg->method_to_cfg;
        cfg = monoeg_g_hash_table_lookup (D.31672, method);
        if (cfg == 0B) goto <D.31673>; else goto <D.31674>;
        <D.31673>:
        // predicted unlikely by continue predictor.
        goto <D.26152>;
        <D.31674>:
        buf_size = 10240;
        D.31675 = (long unsigned int) buf_size;
        buf = monoeg_malloc (D.31675);
        p = buf;
        nmethods = nmethods + 1;
        method = cfg->method_to_register;
        p.178 = p;
        encode_method_ref (acfg, method, p.178, &p);
        p.178 = p;
        p.179 = (long int) p.178;
        buf.180 = (long int) buf;
        D.31679 = p.179 - buf.180;
        D.31680 = (long int) buf_size;
        D.31681 = D.31679 >= D.31680;
        D.31682 = (long int) D.31681;
        D.31683 = __builtin_expect (D.31682, 0);
        if (D.31683 != 0) goto <D.31684>; else goto <D.31685>;
        <D.31684>:
        monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "aot-compiler.c", 7508, "(p - buf) < buf_size");
        <D.31685>:
        D.31669 = (long unsigned int) i;
        D.31686 = D.31669 * 4;
        D.31687 = info_offsets + D.31686;
        p.178 = p;
        p.179 = (long int) p.178;
        buf.180 = (long int) buf;
        D.31679 = p.179 - buf.180;
        D.31688 = (unsigned int) D.31679;
        D.31689 = add_to_blob (acfg, buf, D.31688);
        *D.31687 = D.31689;
        monoeg_g_free (buf);
      }
      <D.26152>:
      i = i + 1;
      <D.26154>:
      i.181 = (unsigned int) i;
      D.31664 = acfg->extra_methods;
      D.31665 = D.31664->len;
      if (i.181 < D.31665) goto <D.26153>; else goto <D.26155>;
      <D.26155>:
      D.31691 = (double) nmethods;
      D.31692 = D.31691 * 1.5e+0;
      D.31693 = (int) D.31692;
      D.31694 = (unsigned int) D.31693;
      D.31695 = monoeg_g_spaced_primes_closest (D.31694);
      table_size = (int) D.31695;
      table_size.182 = (unsigned int) table_size;
      table = monoeg_g_ptr_array_sized_new (table_size.182);
      i = 0;
      goto <D.26157>;
      <D.26156>:
      monoeg_g_ptr_array_add (table, 0B);
      i = i + 1;
      <D.26157>:
      if (i < table_size) goto <D.26156>; else goto <D.26158>;
      <D.26158>:
      D.31697 = (long unsigned int) table_size;
      D.31698 = D.31697 * 4;
      chain_lengths = monoeg_malloc0 (D.31698);
      max_chain_length = 0;
      i = 0;
      goto <D.26168>;
      <D.26167>:
      {
        struct MonoMethod * method;
        struct MonoCompile * cfg;
        guint32 key;
        guint32 value;

        D.31664 = acfg->extra_methods;
        D.31668 = D.31664->pdata;
        D.31669 = (long unsigned int) i;
        D.31670 = D.31669 * 8;
        D.31671 = D.31668 + D.31670;
        method = *D.31671;
        D.31672 = acfg->method_to_cfg;
        cfg = monoeg_g_hash_table_lookup (D.31672, method);
        if (cfg == 0B) goto <D.31699>; else goto <D.31700>;
        <D.31699>:
        // predicted unlikely by continue predictor.
        goto <D.26163>;
        <D.31700>:
        D.31669 = (long unsigned int) i;
        D.31686 = D.31669 * 4;
        D.31687 = info_offsets + D.31686;
        key = *D.31687;
        value = get_method_index (acfg, method);
        D.31701 = mono_aot_method_hash (method);
        table_size.183 = (unsigned int) table_size;
        hash = D.31701 % table_size.183;
        D.31703 = (long unsigned int) hash;
        D.31704 = D.31703 * 4;
        D.31705 = chain_lengths + D.31704;
        D.31706 = *D.31705;
        D.31707 = D.31706 + 1;
        *D.31705 = D.31707;
        D.31703 = (long unsigned int) hash;
        D.31704 = D.31703 * 4;
        D.31705 = chain_lengths + D.31704;
        D.31706 = *D.31705;
        max_chain_length = MAX_EXPR <D.31706, max_chain_length>;
        D.31708 = acfg->mempool;
        new_entry = mono_mempool_alloc0 (D.31708, 24);
        new_entry->key = key;
        new_entry->value = value;
        D.31709 = table->pdata;
        D.31703 = (long unsigned int) hash;
        D.31710 = D.31703 * 8;
        D.31711 = D.31709 + D.31710;
        entry = *D.31711;
        if (entry == 0B) goto <D.31712>; else goto <D.31713>;
        <D.31712>:
        new_entry->index = hash;
        D.31709 = table->pdata;
        D.31703 = (long unsigned int) hash;
        D.31710 = D.31703 * 8;
        D.31711 = D.31709 + D.31710;
        *D.31711 = new_entry;
        goto <D.31714>;
        <D.31713>:
        goto <D.26165>;
        <D.26164>:
        entry = entry->next;
        <D.26165>:
        D.31715 = entry->next;
        if (D.31715 != 0B) goto <D.26164>; else goto <D.26166>;
        <D.26166>:
        entry->next = new_entry;
        D.31716 = table->len;
        new_entry->index = D.31716;
        monoeg_g_ptr_array_add (table, new_entry);
        <D.31714>:
      }
      <D.26163>:
      i = i + 1;
      <D.26168>:
      i.181 = (unsigned int) i;
      D.31664 = acfg->extra_methods;
      D.31665 = D.31664->len;
      if (i.181 < D.31665) goto <D.26167>; else goto <D.26169>;
      <D.26169>:
      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.26172>;
      <D.26171>:
      {
        struct HashEntry * entry;

        D.31709 = table->pdata;
        D.31669 = (long unsigned int) i;
        D.31670 = D.31669 * 8;
        D.31717 = D.31709 + D.31670;
        entry = *D.31717;
        if (entry == 0B) goto <D.31718>; else goto <D.31719>;
        <D.31718>:
        emit_int32 (acfg, 0);
        emit_int32 (acfg, 0);
        emit_int32 (acfg, 0);
        goto <D.31720>;
        <D.31719>:
        D.31721 = entry->key;
        D.31722 = (int) D.31721;
        emit_int32 (acfg, D.31722);
        D.31723 = entry->value;
        D.31724 = (int) D.31723;
        emit_int32 (acfg, D.31724);
        D.31725 = entry->next;
        if (D.31725 != 0B) goto <D.31726>; else goto <D.31727>;
        <D.31726>:
        D.31725 = entry->next;
        D.31728 = D.31725->index;
        D.31729 = (int) D.31728;
        emit_int32 (acfg, D.31729);
        goto <D.31730>;
        <D.31727>:
        emit_int32 (acfg, 0);
        <D.31730>:
        <D.31720>:
      }
      i = i + 1;
      <D.26172>:
      i.181 = (unsigned int) i;
      D.31716 = table->len;
      if (i.181 < D.31716) goto <D.26171>; else goto <D.26173>;
      <D.26173>:
      sprintf (&symbol, "extra_method_info_offsets");
      emit_section_change (acfg, ".rodata", 0);
      emit_alignment (acfg, 8);
      emit_label (acfg, &symbol);
      D.31664 = acfg->extra_methods;
      D.31665 = D.31664->len;
      D.31731 = (int) D.31665;
      emit_int32 (acfg, D.31731);
      i = 0;
      goto <D.26176>;
      <D.26175>:
      {
        struct MonoMethod * method;

        D.31664 = acfg->extra_methods;
        D.31668 = D.31664->pdata;
        D.31669 = (long unsigned int) i;
        D.31670 = D.31669 * 8;
        D.31671 = D.31668 + D.31670;
        method = *D.31671;
        D.31732 = get_method_index (acfg, method);
        D.31733 = (int) D.31732;
        emit_int32 (acfg, D.31733);
        D.31669 = (long unsigned int) i;
        D.31686 = D.31669 * 4;
        D.31687 = info_offsets + D.31686;
        D.31734 = *D.31687;
        D.31735 = (int) D.31734;
        emit_int32 (acfg, D.31735);
      }
      i = i + 1;
      <D.26176>:
      i.181 = (unsigned int) i;
      D.31664 = acfg->extra_methods;
      D.31665 = D.31664->len;
      if (i.181 < D.31665) goto <D.26175>; else goto <D.26177>;
      <D.26177>:
    }
  finally
    {
      symbol = {CLOBBER};
      p = {CLOBBER};
    }
}


emit_trampolines (struct MonoAotCompile * acfg)
{
  int D.31736;
  struct MonoImage * D.31739;
  struct MonoAssembly * D.31740;
  _Bool D.31741;
  long int D.31742;
  long int D.31743;
  int D.25666;
  int iftmp.184;
  int D.25665;
  const char[9] * D.31749;
  unsigned char D.31750;
  int D.31751;
  unsigned char D.31752;
  int D.31753;
  _Bool D.31754;
  _Bool D.31755;
  _Bool D.31756;
  const unsigned char * D.31759;
  unsigned char D.31760;
  int D.31761;
  const unsigned char * D.31762;
  unsigned char D.31763;
  int D.31764;
  _Bool D.31765;
  _Bool D.31766;
  const unsigned char * D.31769;
  unsigned char D.31770;
  int D.31771;
  const unsigned char * D.31772;
  unsigned char D.31773;
  int D.31774;
  _Bool D.31775;
  _Bool D.31776;
  const unsigned char * D.31779;
  unsigned char D.31780;
  int D.31781;
  const unsigned char * D.31782;
  unsigned char D.31783;
  int D.31784;
  const char * D.31786;
  int iftmp.185;
  int D.31790;
  <unnamed type> tramp_type.186;
  struct MonoTrampInfo * info.187;
  unsigned int D.31796;
  int D.31797;
  unsigned int offset.188;
  unsigned int i.189;
  unsigned int D.31800;
  int D.31801;
  int D.31802;
  unsigned int tramp_got_offset.190;
  unsigned int D.31806;
  int tramp_size.191;
  _Bool D.31810;
  long int D.31811;
  long int D.31812;
  unsigned int tramp_size.192;
  unsigned int i.193;
  unsigned int D.31817;
  unsigned int D.31818;
  unsigned int D.31819;
  unsigned int D.31820;
  char symbol[256];
  char end_symbol[256];
  int i;
  int tramp_got_offset;
  MonoAotTrampoline ntype;
  int tramp_type;

  try
    {
      D.31736 = acfg->aot_opts.full_aot;
      if (D.31736 == 0) goto <D.31737>; else goto <D.31738>;
      <D.31737>:
      return;
      <D.31738>:
      D.31739 = acfg->image;
      D.31740 = D.31739->assembly;
      D.31741 = D.31740 == 0B;
      D.31742 = (long int) D.31741;
      D.31743 = __builtin_expect (D.31742, 0);
      if (D.31743 != 0) goto <D.31744>; else goto <D.31745>;
      <D.31744>:
      monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "aot-compiler.c", 5896, "acfg->image->assembly");
      <D.31745>:
      {
        size_t __s1_len;
        size_t __s2_len;

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

          D.31739 = acfg->image;
          D.31740 = D.31739->assembly;
          __s2 = D.31740->aname.name;
          D.31749 = "mscorlib";
          D.31750 = MEM[(const unsigned char *)D.31749];
          D.31751 = (int) D.31750;
          D.31752 = *__s2;
          D.31753 = (int) D.31752;
          __result = D.31751 - D.31753;
          {
            D.31754 = __s2_len != 0;
            D.31755 = __result == 0;
            D.31756 = D.31754 & D.31755;
            if (D.31756 != 0) goto <D.31757>; else goto <D.31758>;
            <D.31757>:
            D.31759 = &MEM[(void *)"mscorlib" + 1B];
            D.31760 = *D.31759;
            D.31761 = (int) D.31760;
            D.31762 = __s2 + 1;
            D.31763 = *D.31762;
            D.31764 = (int) D.31763;
            __result = D.31761 - D.31764;
            D.31765 = __s2_len > 1;
            D.31755 = __result == 0;
            D.31766 = D.31765 & D.31755;
            if (D.31766 != 0) goto <D.31767>; else goto <D.31768>;
            <D.31767>:
            D.31769 = &MEM[(void *)"mscorlib" + 2B];
            D.31770 = *D.31769;
            D.31771 = (int) D.31770;
            D.31772 = __s2 + 2;
            D.31773 = *D.31772;
            D.31774 = (int) D.31773;
            __result = D.31771 - D.31774;
            D.31775 = __s2_len > 2;
            D.31755 = __result == 0;
            D.31776 = D.31775 & D.31755;
            if (D.31776 != 0) goto <D.31777>; else goto <D.31778>;
            <D.31777>:
            D.31779 = &MEM[(void *)"mscorlib" + 3B];
            D.31780 = *D.31779;
            D.31781 = (int) D.31780;
            D.31782 = __s2 + 3;
            D.31783 = *D.31782;
            D.31784 = (int) D.31783;
            __result = D.31781 - D.31784;
            <D.31778>:
            <D.31768>:
            <D.31758>:
          }
          D.25665 = __result;
        }
        iftmp.184 = -D.25665;
        goto <D.31785>;
        <D.31748>:
        D.31739 = acfg->image;
        D.31740 = D.31739->assembly;
        D.31786 = D.31740->aname.name;
        iftmp.184 = __builtin_strcmp (D.31786, "mscorlib");
        <D.31785>:
        D.25666 = iftmp.184;
      }
      if (D.25666 == 0) goto <D.31787>; else goto <D.31788>;
      <D.31787>:
      {
        struct MonoTrampInfo * info;

        try
          {
            tramp_type = 0;
            goto <D.25669>;
            <D.25668>:
            D.31790 = acfg->aot_opts.use_trampolines_page;
            if (D.31790 != 0) goto <D.31791>; else goto <D.31792>;
            <D.31791>:
            iftmp.185 = 2;
            goto <D.31793>;
            <D.31792>:
            iftmp.185 = 1;
            <D.31793>:
            tramp_type.186 = (<unnamed type>) tramp_type;
            mono_arch_create_generic_trampoline (tramp_type.186, &info, iftmp.185);
            info.187 = info;
            D.31796 = acfg->got_offset;
            D.31797 = (int) D.31796;
            emit_trampoline (acfg, D.31797, info.187);
            tramp_type = tramp_type + 1;
            <D.25669>:
            if (tramp_type <= 13) goto <D.25668>; else goto <D.25670>;
            <D.25670>:
            mono_arch_get_nullified_class_init_trampoline (&info);
            info.187 = info;
            D.31796 = acfg->got_offset;
            D.31797 = (int) D.31796;
            emit_trampoline (acfg, D.31797, info.187);
            mono_arch_create_monitor_enter_trampoline (&info, 1);
            info.187 = info;
            D.31796 = acfg->got_offset;
            D.31797 = (int) D.31796;
            emit_trampoline (acfg, D.31797, info.187);
            mono_arch_create_monitor_exit_trampoline (&info, 1);
            info.187 = info;
            D.31796 = acfg->got_offset;
            D.31797 = (int) D.31796;
            emit_trampoline (acfg, D.31797, info.187);
            mono_arch_create_generic_class_init_trampoline (&info, 1);
            info.187 = info;
            D.31796 = acfg->got_offset;
            D.31797 = (int) D.31796;
            emit_trampoline (acfg, D.31797, info.187);
            mono_arch_get_restore_context (&info, 1);
            info.187 = info;
            D.31796 = acfg->got_offset;
            D.31797 = (int) D.31796;
            emit_trampoline (acfg, D.31797, info.187);
            mono_arch_get_call_filter (&info, 1);
            info.187 = info;
            D.31796 = acfg->got_offset;
            D.31797 = (int) D.31796;
            emit_trampoline (acfg, D.31797, info.187);
            mono_arch_get_throw_exception (&info, 1);
            info.187 = info;
            D.31796 = acfg->got_offset;
            D.31797 = (int) D.31796;
            emit_trampoline (acfg, D.31797, info.187);
            mono_arch_get_rethrow_exception (&info, 1);
            info.187 = info;
            D.31796 = acfg->got_offset;
            D.31797 = (int) D.31796;
            emit_trampoline (acfg, D.31797, info.187);
            mono_arch_get_throw_corlib_exception (&info, 1);
            info.187 = info;
            D.31796 = acfg->got_offset;
            D.31797 = (int) D.31796;
            emit_trampoline (acfg, D.31797, info.187);
            {
              struct GSList * l;

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

                info = l->data;
                D.31796 = acfg->got_offset;
                D.31797 = (int) D.31796;
                emit_trampoline (acfg, D.31797, info);
                l = l->next;
              }
              <D.25674>:
              if (l != 0B) goto <D.25673>; else goto <D.25675>;
              <D.25675>:
            }
            i = 0;
            goto <D.25678>;
            <D.25677>:
            {
              int offset;

              offset = i;
              offset.188 = (unsigned int) offset;
              mono_arch_create_rgctx_lazy_fetch_trampoline (offset.188, &info, 1);
              info.187 = info;
              D.31796 = acfg->got_offset;
              D.31797 = (int) D.31796;
              emit_trampoline (acfg, D.31797, info.187);
              i.189 = (unsigned int) i;
              D.31800 = i.189 | 2147483648;
              offset = (int) D.31800;
              offset.188 = (unsigned int) offset;
              mono_arch_create_rgctx_lazy_fetch_trampoline (offset.188, &info, 1);
              info.187 = info;
              D.31796 = acfg->got_offset;
              D.31797 = (int) D.31796;
              emit_trampoline (acfg, D.31797, info.187);
            }
            i = i + 1;
            <D.25678>:
            D.31801 = acfg->aot_opts.nrgctx_fetch_trampolines;
            if (D.31801 > i) goto <D.25677>; else goto <D.25679>;
            <D.25679>:
            {
              struct GSList * l;

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

                info = l->data;
                D.31796 = acfg->got_offset;
                D.31797 = (int) D.31796;
                emit_trampoline (acfg, D.31797, info);
                l = l->next;
              }
              <D.25683>:
              if (l != 0B) goto <D.25682>; else goto <D.25684>;
              <D.25684>:
            }
            emit_section_change (acfg, ".text", 0);
            D.31796 = acfg->got_offset;
            tramp_got_offset = (int) D.31796;
            ntype = 0;
            goto <D.25702>;
            <D.25701>:
            switch (ntype) <default: <D.25690>, case 0: <D.25685>, case 1: <D.25687>, case 2: <D.25688>, case 3: <D.25689>>
            <D.25685>:
            sprintf (&symbol, "specific_trampolines");
            goto <D.25686>;
            <D.25687>:
            sprintf (&symbol, "static_rgctx_trampolines");
            goto <D.25686>;
            <D.25688>:
            sprintf (&symbol, "imt_thunks");
            goto <D.25686>;
            <D.25689>:
            sprintf (&symbol, "gsharedvt_arg_trampolines");
            goto <D.25686>;
            <D.25690>:
            monoeg_assertion_message ("* Assertion: should not be reached at %s:%d\n", "aot-compiler.c", 6053);
            <D.25686>:
            sprintf (&end_symbol, "%s_e", &symbol);
            D.31802 = acfg->aot_opts.write_symbols;
            if (D.31802 != 0) goto <D.31803>; else goto <D.31804>;
            <D.31803>:
            emit_local_symbol (acfg, &symbol, &end_symbol, 1);
            <D.31804>:
            emit_alignment (acfg, 16);
            emit_label (acfg, &symbol);
            tramp_got_offset.190 = (unsigned int) tramp_got_offset;
            acfg->trampoline_got_offset_base[ntype] = tramp_got_offset.190;
            i = 0;
            goto <D.25699>;
            <D.25698>:
            {
              int tramp_size;

              try
                {
                  tramp_size = 0;
                  switch (ntype) <default: <D.25697>, case 0: <D.25692>, case 1: <D.25694>, case 2: <D.25695>, case 3: <D.25696>>
                  <D.25692>:
                  arch_emit_specific_trampoline (acfg, tramp_got_offset, &tramp_size);
                  tramp_got_offset = tramp_got_offset + 2;
                  goto <D.25693>;
                  <D.25694>:
                  arch_emit_static_rgctx_trampoline (acfg, tramp_got_offset, &tramp_size);
                  tramp_got_offset = tramp_got_offset + 2;
                  goto <D.25693>;
                  <D.25695>:
                  arch_emit_imt_thunk (acfg, tramp_got_offset, &tramp_size);
                  tramp_got_offset = tramp_got_offset + 1;
                  goto <D.25693>;
                  <D.25696>:
                  arch_emit_gsharedvt_arg_trampoline (acfg, tramp_got_offset, &tramp_size);
                  tramp_got_offset = tramp_got_offset + 2;
                  goto <D.25693>;
                  <D.25697>:
                  monoeg_assertion_message ("* Assertion: should not be reached at %s:%d\n", "aot-compiler.c", 6087);
                  <D.25693>:
                  D.31806 = acfg->trampoline_size[ntype];
                  if (D.31806 == 0) goto <D.31807>; else goto <D.31808>;
                  <D.31807>:
                  tramp_size.191 = tramp_size;
                  D.31810 = tramp_size.191 == 0;
                  D.31811 = (long int) D.31810;
                  D.31812 = __builtin_expect (D.31811, 0);
                  if (D.31812 != 0) goto <D.31813>; else goto <D.31814>;
                  <D.31813>:
                  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "aot-compiler.c", 6095, "tramp_size");
                  <D.31814>:
                  tramp_size.191 = tramp_size;
                  tramp_size.192 = (unsigned int) tramp_size.191;
                  acfg->trampoline_size[ntype] = tramp_size.192;
                  <D.31808>:
                }
              finally
                {
                  tramp_size = {CLOBBER};
                }
            }
            i = i + 1;
            <D.25699>:
            i.193 = (unsigned int) i;
            D.31817 = acfg->num_trampolines[ntype];
            if (i.193 < D.31817) goto <D.25698>; else goto <D.25700>;
            <D.25700>:
            emit_label (acfg, &end_symbol);
            emit_int32 (acfg, 0);
            ntype = ntype + 1;
            <D.25702>:
            if (ntype <= 3) goto <D.25701>; else goto <D.25703>;
            <D.25703>:
            arch_emit_specific_trampoline_pages (acfg);
            tramp_got_offset.190 = (unsigned int) tramp_got_offset;
            D.31796 = acfg->got_offset;
            D.31818 = tramp_got_offset.190 - D.31796;
            acfg->num_trampoline_got_entries = D.31818;
          }
        finally
          {
            info = {CLOBBER};
          }
      }
      <D.31788>:
      D.31796 = acfg->got_offset;
      D.31819 = acfg->num_trampoline_got_entries;
      D.31820 = D.31796 + D.31819;
      acfg->got_offset = D.31820;
    }
  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.31824;
  long int D.31825;
  long int D.31826;
  const char * D.31829;
  const char * D.31830;
  <unnamed type> D.31833;
  unsigned int D.31836;
  unsigned int D.31837;
  long unsigned int D.31838;
  guint8 * p.194;
  int D.31840;
  long int p.195;
  long int buf.196;
  long int D.31843;
  long int D.31844;
  _Bool D.31845;
  long int D.31846;
  long int D.31847;
  unsigned int D.31850;
  int info_offset.197;
  struct GSList * D.31854;
  unsigned int encoded_len.198;
  int uw_offset.199;
  struct MonoDwarfWriter * D.31859;
  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.31824 = info == 0B;
      D.31825 = (long int) D.31824;
      D.31826 = __builtin_expect (D.31825, 0);
      if (D.31826 != 0) goto <D.31827>; else goto <D.31828>;
      <D.31827>:
      monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "aot-compiler.c", 5785, "info");
      <D.31828>:
      name = info->name;
      code = info->code;
      code_size = info->code_size;
      ji = info->ji;
      unwind_ops = info->unwind_ops;
      D.31829 = acfg->user_symbol_prefix;
      sprintf (&start_symbol, "%s%s", D.31829, name);
      emit_section_change (acfg, ".text", 0);
      emit_global (acfg, &start_symbol, 1);
      emit_alignment (acfg, 16);
      emit_label (acfg, &start_symbol);
      D.31830 = acfg->temp_prefix;
      sprintf (&symbol, "%snamed_%s", D.31830, 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.31831>; else goto <D.31832>;
      <D.31831>:
      D.31830 = acfg->temp_prefix;
      sprintf (&end_symbol, "%snamede_%s", D.31830, name);
      emit_label (acfg, &end_symbol);
      <D.31832>:
      patches = monoeg_g_ptr_array_new ();
      patch_info = ji;
      goto <D.25638>;
      <D.25637>:
      D.31833 = patch_info->type;
      if (D.31833 != 51) goto <D.31834>; else goto <D.31835>;
      <D.31834>:
      monoeg_g_ptr_array_add (patches, patch_info);
      <D.31835>:
      patch_info = patch_info->next;
      <D.25638>:
      if (patch_info != 0B) goto <D.25637>; else goto <D.25639>;
      <D.25639>:
      monoeg_g_ptr_array_sort (patches, compare_patches);
      D.31836 = patches->len;
      D.31837 = D.31836 + 1;
      buf_size = D.31837 * 128;
      D.31838 = (long unsigned int) buf_size;
      buf = monoeg_malloc (D.31838);
      p = buf;
      p.194 = p;
      D.31836 = patches->len;
      D.31840 = (int) D.31836;
      encode_patch_list (acfg, patches, D.31840, got_offset, p.194, &p);
      p.194 = p;
      p.195 = (long int) p.194;
      buf.196 = (long int) buf;
      D.31843 = p.195 - buf.196;
      D.31844 = (long int) buf_size;
      D.31845 = D.31843 >= D.31844;
      D.31846 = (long int) D.31845;
      D.31847 = __builtin_expect (D.31846, 0);
      if (D.31847 != 0) goto <D.31848>; else goto <D.31849>;
      <D.31848>:
      monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "aot-compiler.c", 5836, "p - buf < buf_size");
      <D.31849>:
      D.31829 = acfg->user_symbol_prefix;
      sprintf (&symbol, "%s%s_p", D.31829, name);
      p.194 = p;
      p.195 = (long int) p.194;
      buf.196 = (long int) buf;
      D.31843 = p.195 - buf.196;
      D.31850 = (unsigned int) D.31843;
      info_offset = add_to_blob (acfg, buf, D.31850);
      emit_section_change (acfg, ".rodata", 0);
      emit_global (acfg, &symbol, 0);
      emit_label (acfg, &symbol);
      info_offset.197 = (int) info_offset;
      emit_int32 (acfg, info_offset.197);
      if (emit_tinfo != 0) goto <D.31852>; else goto <D.31853>;
      <D.31852>:
      {
        guint8 * encoded;
        guint32 encoded_len;
        guint32 uw_offset;

        try
          {
            D.31854 = info->unwind_ops;
            encoded = mono_unwind_ops_encode (D.31854, &encoded_len);
            encoded_len.198 = encoded_len;
            uw_offset = get_unwind_info_offset (acfg, encoded, encoded_len.198);
            monoeg_g_free (encoded);
            emit_symbol_diff (acfg, &end_symbol, &start_symbol, 0);
            uw_offset.199 = (int) uw_offset;
            emit_int32 (acfg, uw_offset.199);
          }
        finally
          {
            encoded_len = {CLOBBER};
          }
      }
      <D.31853>:
      if (unwind_ops != 0B) goto <D.31857>; else goto <D.31858>;
      <D.31857>:
      {
        char symbol2[256];

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


emit_global (struct MonoAotCompile * acfg, const char * name, gboolean func)
{
  int D.31862;
  gchar * D.31865;
  struct GPtrArray * D.31866;
  struct MonoImageWriter * D.31867;

  D.31862 = acfg->aot_opts.no_dlsym;
  if (D.31862 != 0) goto <D.31863>; else goto <D.31864>;
  <D.31863>:
  D.31865 = monoeg_strdup (name);
  D.31866 = acfg->globals;
  monoeg_g_ptr_array_add (D.31866, D.31865);
  D.31867 = acfg->w;
  img_writer_emit_local_symbol (D.31867, name, 0B, func);
  goto <D.31868>;
  <D.31864>:
  D.31867 = acfg->w;
  img_writer_emit_global (D.31867, name, func);
  <D.31868>:
}


get_unwind_info_offset (struct MonoAotCompile * acfg, guint8 * encoded, guint32 encoded_len)
{
  unsigned int D.31869;
  long unsigned int D.31870;
  const void * D.31871;
  struct GHashTable * D.31872;
  void * D.31873;
  long int D.31874;
  guint32 D.31877;
  unsigned int D.31878;
  long unsigned int D.31879;
  void * D.31880;
  void * D.31881;
  long unsigned int D.31882;
  void * D.31883;
  struct GPtrArray * D.31884;
  guint8 * p.200;
  int encoded_len.201;
  unsigned int D.31887;
  long int p.202;
  long int buf.203;
  long int D.31890;
  unsigned int D.31891;
  unsigned int D.31892;
  unsigned int D.31893;
  guint32 cache_index;
  guint32 offset;

  cache_index = mono_cache_unwind_info (encoded, encoded_len);
  D.31869 = cache_index + 1;
  D.31870 = (long unsigned int) D.31869;
  D.31871 = (const void *) D.31870;
  D.31872 = acfg->unwind_info_offsets;
  D.31873 = monoeg_g_hash_table_lookup (D.31872, D.31871);
  D.31874 = (long int) D.31873;
  offset = (guint32) D.31874;
  if (offset != 0) goto <D.31875>; else goto <D.31876>;
  <D.31875>:
  D.31877 = offset + 4294967295;
  return D.31877;
  <D.31876>:
  {
    guint8 buf[16];
    guint8 * p;

    try
      {
        offset = acfg->unwind_info_offset;
        D.31878 = offset + 1;
        D.31879 = (long unsigned int) D.31878;
        D.31880 = (void *) D.31879;
        D.31869 = cache_index + 1;
        D.31870 = (long unsigned int) D.31869;
        D.31881 = (void *) D.31870;
        D.31872 = acfg->unwind_info_offsets;
        monoeg_g_hash_table_insert_replace (D.31872, D.31881, D.31880, 0);
        D.31882 = (long unsigned int) cache_index;
        D.31883 = (void *) D.31882;
        D.31884 = acfg->unwind_ops;
        monoeg_g_ptr_array_add (D.31884, D.31883);
        p = &buf;
        p.200 = p;
        encoded_len.201 = (int) encoded_len;
        encode_value (encoded_len.201, p.200, &p);
        D.31887 = acfg->unwind_info_offset;
        p.200 = p;
        p.202 = (long int) p.200;
        buf.203 = (long int) &buf;
        D.31890 = p.202 - buf.203;
        D.31891 = (unsigned int) D.31890;
        D.31892 = D.31891 + encoded_len;
        D.31893 = D.31887 + D.31892;
        acfg->unwind_info_offset = D.31893;
        D.31877 = offset;
        return D.31877;
      }
    finally
      {
        buf = {CLOBBER};
        p = {CLOBBER};
      }
  }
}


arch_emit_specific_trampoline (struct MonoAotCompile * acfg, int offset, int * tramp_size)
{
  long unsigned int D.31896;
  unsigned int D.31897;
  unsigned int D.31898;
  unsigned int D.31899;
  int D.31900;
  char * D.31901;
  int D.31902;
  long unsigned int D.31903;
  unsigned int D.31904;
  unsigned int D.31905;
  unsigned int D.31906;
  int D.31907;

  *tramp_size = 16;
  emit_byte (acfg, 65);
  emit_byte (acfg, 255);
  emit_byte (acfg, 21);
  D.31896 = (long unsigned int) offset;
  D.31897 = (unsigned int) D.31896;
  D.31898 = D.31897 * 8;
  D.31899 = D.31898 + 4294967292;
  D.31900 = (int) D.31899;
  D.31901 = acfg->got_symbol;
  emit_symbol_diff (acfg, D.31901, ".", D.31900);
  D.31902 = offset + 1;
  D.31903 = (long unsigned int) D.31902;
  D.31904 = (unsigned int) D.31903;
  D.31905 = D.31904 * 8;
  D.31906 = D.31905 + 7;
  D.31907 = (int) D.31906;
  D.31901 = acfg->got_symbol;
  emit_symbol_diff (acfg, D.31901, ".", D.31907);
  emit_zero_bytes (acfg, 5);
}


arch_emit_static_rgctx_trampoline (struct MonoAotCompile * acfg, int offset, int * tramp_size)
{
  long unsigned int D.31908;
  unsigned int D.31909;
  unsigned int D.31910;
  unsigned int D.31911;
  int D.31912;
  char * D.31913;
  int D.31914;
  long unsigned int D.31915;
  unsigned int D.31916;
  unsigned int D.31917;
  unsigned int D.31918;
  int D.31919;

  *tramp_size = 13;
  emit_byte (acfg, 77);
  emit_byte (acfg, 139);
  emit_byte (acfg, 21);
  D.31908 = (long unsigned int) offset;
  D.31909 = (unsigned int) D.31908;
  D.31910 = D.31909 * 8;
  D.31911 = D.31910 + 4294967292;
  D.31912 = (int) D.31911;
  D.31913 = acfg->got_symbol;
  emit_symbol_diff (acfg, D.31913, ".", D.31912);
  emit_byte (acfg, 255);
  emit_byte (acfg, 37);
  D.31914 = offset + 1;
  D.31915 = (long unsigned int) D.31914;
  D.31916 = (unsigned int) D.31915;
  D.31917 = D.31916 * 8;
  D.31918 = D.31917 + 4294967292;
  D.31919 = (int) D.31918;
  D.31913 = acfg->got_symbol;
  emit_symbol_diff (acfg, D.31913, ".", D.31919);
}


arch_emit_imt_thunk (struct MonoAotCompile * acfg, int offset, int * tramp_size)
{
  guint8 * code.204;
  unsigned char D.31923;
  guint8 * code.205;
  guint8 * code.206;
  guint8 * code.207;
  guint8 * code.208;
  guint8 * code.209;
  guint8 * code.210;
  guint8 * code.211;
  guint8 * code.212;
  unsigned char D.31942;
  guint8 * code.213;
  unsigned char D.31944;
  guint8 * code.214;
  unsigned char D.31946;
  guint8 * code.215;
  unsigned char D.31948;
  guint8 * code.216;
  guint8 * code.217;
  guint8 * code.218;
  guint8 * code.219;
  unsigned char D.31958;
  guint8 * code.220;
  unsigned char D.31960;
  guint8 * code.221;
  unsigned char D.31962;
  guint8 * code.222;
  unsigned char D.31964;
  guint8 * code.223;
  guint8 * code.224;
  guint8 * code.225;
  guint8 * code.226;
  guint8 * code.227;
  guint8 * code.228;
  guint8 * code.229;
  guint8 * code.230;
  unsigned char D.31982;
  guint8 * code.231;
  unsigned char D.31984;
  guint8 * code.232;
  unsigned char D.31986;
  guint8 * code.233;
  unsigned char D.31988;
  guint8 * code.234;
  guint8 * code.235;
  guint8 * code.236;
  guint8 * code.237;
  unsigned char D.31998;
  guint8 * code.238;
  unsigned char D.32000;
  guint8 * code.239;
  unsigned char D.32002;
  guint8 * code.240;
  unsigned char D.32004;
  guint8 * code.241;
  unsigned char D.32006;
  guint8 * code.242;
  unsigned char D.32008;
  guint8 * code.243;
  unsigned char D.32010;
  guint8 * code.244;
  unsigned char D.32012;
  guint8 * code.245;
  unsigned char D.32016;
  guint8 * code.246;
  unsigned char D.32019;
  guint8 * code.247;
  unsigned char D.32023;
  guint8 * code.248;
  guint8 * code.249;
  guint8 * code.250;
  guint8 * code.251;
  guint8 * code.252;
  guint8 * code.253;
  guint8 * code.254;
  guint8 * code.255;
  unsigned char D.32040;
  guint8 * code.256;
  unsigned char D.32042;
  guint8 * code.257;
  unsigned char D.32044;
  guint8 * code.258;
  unsigned char D.32046;
  guint8 * code.259;
  guint8 * code.260;
  guint8 * code.261;
  guint8 * code.262;
  unsigned char D.32056;
  guint8 * code.263;
  unsigned char D.32058;
  guint8 * code.264;
  unsigned char D.32060;
  guint8 * code.265;
  unsigned char D.32062;
  guint8 * code.266;
  guint8 * code.267;
  guint8 * code.268;
  unsigned char D.32073;
  guint8 * code.269;
  guint8 * code.270;
  guint8 * code.271;
  unsigned char D.32082;
  guint8 * code.272;
  guint8 * code.273;
  unsigned char D.32085;
  guint8 * code.274;
  unsigned char D.32087;
  guint8 * code.275;
  unsigned char D.32089;
  guint8 * code.276;
  unsigned char D.32091;
  guint8 * code.277;
  unsigned char D.32096;
  guint8 * code.278;
  guint8 * code.279;
  guint8 * code.280;
  unsigned char D.32100;
  guint8 * code.281;
  unsigned char D.32102;
  guint8 * code.282;
  unsigned char D.32104;
  guint8 * code.283;
  unsigned char D.32106;
  guint8 * D.32107;
  long int D.32108;
  long int code.284;
  long int D.32110;
  unsigned long D.32111;
  unsigned long D.32112;
  unsigned int D.32115;
  unsigned int D.32116;
  unsigned int t.285;
  unsigned int D.32118;
  guint8 * code.286;
  unsigned char D.32122;
  unsigned int D.32124;
  guint8 * code.287;
  guint8 * code.288;
  unsigned char D.32127;
  guint8 * code.289;
  unsigned char D.32129;
  guint8 * code.290;
  unsigned char D.32131;
  guint8 * code.291;
  unsigned char D.32133;
  guint8 * code.292;
  unsigned char D.32138;
  guint8 * code.293;
  guint8 * code.294;
  guint8 * code.295;
  unsigned char D.32144;
  guint8 * code.296;
  unsigned char D.32146;
  guint8 * code.297;
  unsigned char D.32148;
  guint8 * code.298;
  unsigned char D.32150;
  guint8 * code.299;
  guint8 * code.300;
  guint8 * code.301;
  guint8 * code.302;
  guint8 * code.303;
  guint8 * code.304;
  guint8 * code.305;
  unsigned char D.32167;
  guint8 * code.306;
  unsigned char D.32169;
  guint8 * code.307;
  unsigned char D.32171;
  guint8 * code.308;
  unsigned char D.32173;
  guint8 * code.309;
  guint8 * code.310;
  guint8 * code.311;
  guint8 * code.312;
  unsigned char D.32183;
  guint8 * code.313;
  unsigned char D.32185;
  guint8 * code.314;
  unsigned char D.32187;
  guint8 * code.315;
  unsigned char D.32189;
  long unsigned int D.32190;
  guint8 * D.32191;
  guint8 * code.316;
  guint8 * code.317;
  unsigned char D.32198;
  guint8 * code.318;
  guint8 * code.319;
  guint8 * code.320;
  guint8 * code.321;
  unsigned char D.32205;
  guint8 * code.322;
  unsigned char D.32207;
  guint8 * code.323;
  unsigned char D.32209;
  guint8 * code.324;
  unsigned char D.32211;
  guint8 * code.325;
  guint8 * code.326;
  guint8 * code.327;
  guint8 * code.328;
  guint8 * code.329;
  guint8 * code.330;
  guint8 * code.331;
  unsigned char D.32228;
  guint8 * code.332;
  unsigned char D.32230;
  guint8 * code.333;
  unsigned char D.32232;
  guint8 * code.334;
  unsigned char D.32234;
  guint8 * code.335;
  guint8 * code.336;
  guint8 * code.337;
  guint8 * code.338;
  unsigned char D.32244;
  guint8 * code.339;
  unsigned char D.32246;
  guint8 * code.340;
  unsigned char D.32248;
  guint8 * code.341;
  unsigned char D.32250;
  guint8 * code.342;
  unsigned char D.32254;
  guint8 * code.343;
  guint8 * code.344;
  guint8 * code.345;
  unsigned char D.32260;
  guint8 * code.346;
  unsigned char D.32262;
  guint8 * code.347;
  unsigned char D.32264;
  guint8 * code.348;
  unsigned char D.32266;
  guint8 * code.349;
  guint8 * code.350;
  guint8 * code.351;
  guint8 * code.352;
  guint8 * code.353;
  guint8 * code.354;
  guint8 * code.355;
  unsigned char D.32283;
  guint8 * code.356;
  unsigned char D.32285;
  guint8 * code.357;
  unsigned char D.32287;
  guint8 * code.358;
  unsigned char D.32289;
  guint8 * code.359;
  guint8 * code.360;
  guint8 * code.361;
  guint8 * code.362;
  unsigned char D.32299;
  guint8 * code.363;
  unsigned char D.32301;
  guint8 * code.364;
  unsigned char D.32303;
  guint8 * code.365;
  unsigned char D.32305;
  guint8 * D.32306;
  guint8 * code.366;
  unsigned char D.32312;
  guint8 * code.367;
  guint8 * code.368;
  guint8 * code.369;
  unsigned char D.32321;
  guint8 * code.370;
  guint8 * code.371;
  unsigned char D.32324;
  guint8 * code.372;
  unsigned char D.32326;
  guint8 * code.373;
  unsigned char D.32328;
  guint8 * code.374;
  unsigned char D.32330;
  guint8 * code.375;
  unsigned char D.32335;
  guint8 * code.376;
  guint8 * code.377;
  guint8 * code.378;
  unsigned char D.32339;
  guint8 * code.379;
  unsigned char D.32341;
  guint8 * code.380;
  unsigned char D.32343;
  guint8 * code.381;
  unsigned char D.32345;
  guint8 * code.382;
  unsigned char D.32349;
  guint8 * code.383;
  guint8 * code.384;
  guint8 * code.385;
  guint8 * code.386;
  guint8 * code.387;
  guint8 * code.388;
  guint8 * code.389;
  guint8 * code.390;
  unsigned char D.32368;
  guint8 * code.391;
  unsigned char D.32370;
  guint8 * code.392;
  unsigned char D.32372;
  guint8 * code.393;
  unsigned char D.32374;
  guint8 * code.394;
  guint8 * code.395;
  guint8 * code.396;
  guint8 * code.397;
  unsigned char D.32384;
  guint8 * code.398;
  unsigned char D.32386;
  guint8 * code.399;
  unsigned char D.32388;
  guint8 * code.400;
  unsigned char D.32390;
  guint8 * code.401;
  guint8 * code.402;
  guint8 * code.403;
  guint8 * code.404;
  guint8 * code.405;
  guint8 * code.406;
  guint8 * code.407;
  guint8 * code.408;
  unsigned char D.32408;
  guint8 * code.409;
  unsigned char D.32410;
  guint8 * code.410;
  unsigned char D.32412;
  guint8 * code.411;
  unsigned char D.32414;
  guint8 * code.412;
  guint8 * code.413;
  guint8 * code.414;
  guint8 * code.415;
  unsigned char D.32424;
  guint8 * code.416;
  unsigned char D.32426;
  guint8 * code.417;
  unsigned char D.32428;
  guint8 * code.418;
  unsigned char D.32430;
  guint8 * code.419;
  unsigned char D.32432;
  guint8 * code.420;
  unsigned char D.32434;
  guint8 * code.421;
  unsigned char D.32436;
  guint8 * code.422;
  unsigned char D.32438;
  guint8 * code.423;
  guint8 * code.424;
  guint8 * code.425;
  unsigned char D.32447;
  guint8 * code.426;
  guint8 * code.427;
  guint8 * code.428;
  unsigned char D.32453;
  guint8 * code.429;
  unsigned char D.32455;
  guint8 * code.430;
  unsigned char D.32457;
  guint8 * code.431;
  unsigned char D.32459;
  guint8 * code.432;
  guint8 * code.433;
  guint8 * code.434;
  guint8 * code.435;
  guint8 * code.436;
  guint8 * code.437;
  guint8 * code.438;
  unsigned char D.32476;
  guint8 * code.439;
  unsigned char D.32478;
  guint8 * code.440;
  unsigned char D.32480;
  guint8 * code.441;
  unsigned char D.32482;
  guint8 * code.442;
  guint8 * code.443;
  guint8 * code.444;
  guint8 * code.445;
  unsigned char D.32492;
  guint8 * code.446;
  unsigned char D.32494;
  guint8 * code.447;
  unsigned char D.32496;
  guint8 * code.448;
  unsigned char D.32498;
  guint8 * D.32499;
  guint8 * code.449;
  guint8 * mov_buf_ptr.450;
  unsigned char D.32504;
  guint8 * mov_buf_ptr.451;
  guint8 * mov_buf_ptr.452;
  long int mov_buf_ptr.453;
  long int mov_buf.454;
  long int D.32509;
  int D.32510;
  long unsigned int D.32511;
  unsigned int D.32512;
  unsigned int D.32513;
  unsigned int D.32514;
  int D.32515;
  char * D.32516;
  long int buf.455;
  long int D.32518;
  int D.32519;
  unsigned int D.32520;
  unsigned int D.32521;
  int D.32522;
  guint8 * buf;
  guint8 * code;
  guint8 * labels[16];
  guint8 mov_buf[3];
  guint8 * mov_buf_ptr;
  const int kSizeOfMove;
  static const char __PRETTY_FUNCTION__[20] = "arch_emit_imt_thunk";

  try
    {
      mov_buf_ptr = &mov_buf;
      kSizeOfMove = 7;
      buf = monoeg_malloc (256);
      code = buf;
      labels[0] = code;
      {
        unsigned char _amd64_rex_bits;

        _amd64_rex_bits = 9;
        if (_amd64_rex_bits != 0) goto <D.31920>; else goto <D.31921>;
        <D.31920>:
        code.204 = code;
        code = code.204 + 1;
        D.31923 = _amd64_rex_bits | 64;
        *code.204 = D.31923;
        <D.31921>:
      }
      if (1 != 0) goto <D.31924>; else goto <D.31925>;
      <D.31924>:
      code.205 = code;
      code = code.205 + 1;
      *code.205 = 131;
      if (0 != 0) goto <D.31927>; else goto <D.31928>;
      <D.31927>:
      if (1 != 0) goto <D.31929>; else goto <D.31930>;
      <D.31929>:
      code.206 = code;
      code = code.206 + 1;
      *code.206 = 60;
      code.207 = code;
      code = code.207 + 1;
      *code.207 = 36;
      goto <D.31933>;
      <D.31930>:
      if (1 != 0) goto <D.31934>; else goto <D.31935>;
      <D.31934>:
      code.208 = code;
      code = code.208 + 1;
      *code.208 = 124;
      code.209 = code;
      code = code.209 + 1;
      *code.209 = 36;
      *code = 0;
      code = code + 1;
      goto <D.31938>;
      <D.31935>:
      code.210 = code;
      code = code.210 + 1;
      *code.210 = 188;
      code.211 = code;
      code = code.211 + 1;
      *code.211 = 36;
      {
        union x86_imm_buf imb;

        try
          {
            imb.val = 0;
            code.212 = code;
            code = code.212 + 1;
            D.31942 = imb.b[0];
            *code.212 = D.31942;
            code.213 = code;
            code = code.213 + 1;
            D.31944 = imb.b[1];
            *code.213 = D.31944;
            code.214 = code;
            code = code.214 + 1;
            D.31946 = imb.b[2];
            *code.214 = D.31946;
            code.215 = code;
            code = code.215 + 1;
            D.31948 = imb.b[3];
            *code.215 = D.31948;
          }
        finally
          {
            imb = {CLOBBER};
          }
      }
      <D.31938>:
      <D.31933>:
      goto <D.24127>;
      <D.31928>:
      if (1 != 0) goto <D.31949>; else goto <D.31950>;
      <D.31949>:
      code.216 = code;
      code = code.216 + 1;
      *code.216 = 59;
      goto <D.24127>;
      <D.31950>:
      if (1 != 0) goto <D.31952>; else goto <D.31953>;
      <D.31952>:
      code.217 = code;
      code = code.217 + 1;
      *code.217 = 123;
      *code = 0;
      code = code + 1;
      goto <D.31955>;
      <D.31953>:
      code.218 = code;
      code = code.218 + 1;
      *code.218 = 187;
      {
        union x86_imm_buf imb;

        try
          {
            imb.val = 0;
            code.219 = code;
            code = code.219 + 1;
            D.31958 = imb.b[0];
            *code.219 = D.31958;
            code.220 = code;
            code = code.220 + 1;
            D.31960 = imb.b[1];
            *code.220 = D.31960;
            code.221 = code;
            code = code.221 + 1;
            D.31962 = imb.b[2];
            *code.221 = D.31962;
            code.222 = code;
            code = code.222 + 1;
            D.31964 = imb.b[3];
            *code.222 = D.31964;
          }
        finally
          {
            imb = {CLOBBER};
          }
      }
      <D.31955>:
      <D.24127>:
      *code = 0;
      code = code + 1;
      goto <D.31965>;
      <D.31925>:
      code.223 = code;
      code = code.223 + 1;
      *code.223 = 129;
      if (0 != 0) goto <D.31967>; else goto <D.31968>;
      <D.31967>:
      if (1 != 0) goto <D.31969>; else goto <D.31970>;
      <D.31969>:
      code.224 = code;
      code = code.224 + 1;
      *code.224 = 60;
      code.225 = code;
      code = code.225 + 1;
      *code.225 = 36;
      goto <D.31973>;
      <D.31970>:
      if (1 != 0) goto <D.31974>; else goto <D.31975>;
      <D.31974>:
      code.226 = code;
      code = code.226 + 1;
      *code.226 = 124;
      code.227 = code;
      code = code.227 + 1;
      *code.227 = 36;
      *code = 0;
      code = code + 1;
      goto <D.31978>;
      <D.31975>:
      code.228 = code;
      code = code.228 + 1;
      *code.228 = 188;
      code.229 = code;
      code = code.229 + 1;
      *code.229 = 36;
      {
        union x86_imm_buf imb;

        try
          {
            imb.val = 0;
            code.230 = code;
            code = code.230 + 1;
            D.31982 = imb.b[0];
            *code.230 = D.31982;
            code.231 = code;
            code = code.231 + 1;
            D.31984 = imb.b[1];
            *code.231 = D.31984;
            code.232 = code;
            code = code.232 + 1;
            D.31986 = imb.b[2];
            *code.232 = D.31986;
            code.233 = code;
            code = code.233 + 1;
            D.31988 = imb.b[3];
            *code.233 = D.31988;
          }
        finally
          {
            imb = {CLOBBER};
          }
      }
      <D.31978>:
      <D.31973>:
      goto <D.24130>;
      <D.31968>:
      if (1 != 0) goto <D.31989>; else goto <D.31990>;
      <D.31989>:
      code.234 = code;
      code = code.234 + 1;
      *code.234 = 59;
      goto <D.24130>;
      <D.31990>:
      if (1 != 0) goto <D.31992>; else goto <D.31993>;
      <D.31992>:
      code.235 = code;
      code = code.235 + 1;
      *code.235 = 123;
      *code = 0;
      code = code + 1;
      goto <D.31995>;
      <D.31993>:
      code.236 = code;
      code = code.236 + 1;
      *code.236 = 187;
      {
        union x86_imm_buf imb;

        try
          {
            imb.val = 0;
            code.237 = code;
            code = code.237 + 1;
            D.31998 = imb.b[0];
            *code.237 = D.31998;
            code.238 = code;
            code = code.238 + 1;
            D.32000 = imb.b[1];
            *code.238 = D.32000;
            code.239 = code;
            code = code.239 + 1;
            D.32002 = imb.b[2];
            *code.239 = D.32002;
            code.240 = code;
            code = code.240 + 1;
            D.32004 = imb.b[3];
            *code.240 = D.32004;
          }
        finally
          {
            imb = {CLOBBER};
          }
      }
      <D.31995>:
      <D.24130>:
      {
        union x86_imm_buf imb;

        try
          {
            imb.val = 0;
            code.241 = code;
            code = code.241 + 1;
            D.32006 = imb.b[0];
            *code.241 = D.32006;
            code.242 = code;
            code = code.242 + 1;
            D.32008 = imb.b[1];
            *code.242 = D.32008;
            code.243 = code;
            code = code.243 + 1;
            D.32010 = imb.b[2];
            *code.243 = D.32010;
            code.244 = code;
            code = code.244 + 1;
            D.32012 = imb.b[3];
            *code.244 = D.32012;
          }
        finally
          {
            imb = {CLOBBER};
          }
      }
      <D.31965>:
      labels[1] = code;
      if (0 != 0) goto <D.32013>; else goto <D.32014>;
      <D.32013>:
      code.245 = code;
      code = code.245 + 1;
      D.32016 = 116;
      *code.245 = D.32016;
      goto <D.32017>;
      <D.32014>:
      code.246 = code;
      code = code.246 + 1;
      D.32019 = 116;
      *code.246 = D.32019;
      <D.32017>:
      *code = 0;
      code = code + 1;
      {
        unsigned char _amd64_rex_bits;

        _amd64_rex_bits = 13;
        if (_amd64_rex_bits != 0) goto <D.32020>; else goto <D.32021>;
        <D.32020>:
        code.247 = code;
        code = code.247 + 1;
        D.32023 = _amd64_rex_bits | 64;
        *code.247 = D.32023;
        <D.32021>:
      }
      code.248 = code;
      code = code.248 + 1;
      *code.248 = 57;
      if (0 != 0) goto <D.32025>; else goto <D.32026>;
      <D.32025>:
      if (1 != 0) goto <D.32027>; else goto <D.32028>;
      <D.32027>:
      code.249 = code;
      code = code.249 + 1;
      *code.249 = 20;
      code.250 = code;
      code = code.250 + 1;
      *code.250 = 36;
      goto <D.32031>;
      <D.32028>:
      if (1 != 0) goto <D.32032>; else goto <D.32033>;
      <D.32032>:
      code.251 = code;
      code = code.251 + 1;
      *code.251 = 84;
      code.252 = code;
      code = code.252 + 1;
      *code.252 = 36;
      *code = 0;
      code = code + 1;
      goto <D.32036>;
      <D.32033>:
      code.253 = code;
      code = code.253 + 1;
      *code.253 = 148;
      code.254 = code;
      code = code.254 + 1;
      *code.254 = 36;
      {
        union x86_imm_buf imb;

        try
          {
            imb.val = 0;
            code.255 = code;
            code = code.255 + 1;
            D.32040 = imb.b[0];
            *code.255 = D.32040;
            code.256 = code;
            code = code.256 + 1;
            D.32042 = imb.b[1];
            *code.256 = D.32042;
            code.257 = code;
            code = code.257 + 1;
            D.32044 = imb.b[2];
            *code.257 = D.32044;
            code.258 = code;
            code = code.258 + 1;
            D.32046 = imb.b[3];
            *code.258 = D.32046;
          }
        finally
          {
            imb = {CLOBBER};
          }
      }
      <D.32036>:
      <D.32031>:
      goto <D.24135>;
      <D.32026>:
      if (1 != 0) goto <D.32047>; else goto <D.32048>;
      <D.32047>:
      code.259 = code;
      code = code.259 + 1;
      *code.259 = 19;
      goto <D.24135>;
      <D.32048>:
      if (1 != 0) goto <D.32050>; else goto <D.32051>;
      <D.32050>:
      code.260 = code;
      code = code.260 + 1;
      *code.260 = 83;
      *code = 0;
      code = code + 1;
      goto <D.32053>;
      <D.32051>:
      code.261 = code;
      code = code.261 + 1;
      *code.261 = 147;
      {
        union x86_imm_buf imb;

        try
          {
            imb.val = 0;
            code.262 = code;
            code = code.262 + 1;
            D.32056 = imb.b[0];
            *code.262 = D.32056;
            code.263 = code;
            code = code.263 + 1;
            D.32058 = imb.b[1];
            *code.263 = D.32058;
            code.264 = code;
            code = code.264 + 1;
            D.32060 = imb.b[2];
            *code.264 = D.32060;
            code.265 = code;
            code = code.265 + 1;
            D.32062 = imb.b[3];
            *code.265 = D.32062;
          }
        finally
          {
            imb = {CLOBBER};
          }
      }
      <D.32053>:
      <D.24135>:
      labels[2] = code;
      if (0 != 0) goto <D.32063>; else goto <D.32064>;
      <D.32063>:
      code.266 = code;
      code = code.266 + 1;
      D.32016 = 116;
      *code.266 = D.32016;
      goto <D.32066>;
      <D.32064>:
      code.267 = code;
      code = code.267 + 1;
      D.32019 = 116;
      *code.267 = D.32019;
      <D.32066>:
      *code = 0;
      code = code + 1;
      if (1 != 0) goto <D.32068>; else goto <D.32069>;
      <D.32068>:
      {
        unsigned char _amd64_rex_bits;

        _amd64_rex_bits = 9;
        if (_amd64_rex_bits != 0) goto <D.32070>; else goto <D.32071>;
        <D.32070>:
        code.268 = code;
        code = code.268 + 1;
        D.32073 = _amd64_rex_bits | 64;
        *code.268 = D.32073;
        <D.32071>:
      }
      code.269 = code;
      code = code.269 + 1;
      *code.269 = 131;
      code.270 = code;
      code = code.270 + 1;
      *code.270 = 195;
      *code = 16;
      code = code + 1;
      goto <D.32076>;
      <D.32069>:
      if (0 != 0) goto <D.32077>; else goto <D.32078>;
      <D.32077>:
      {
        unsigned char _amd64_rex_bits;

        _amd64_rex_bits = 8;
        if (_amd64_rex_bits != 0) goto <D.32079>; else goto <D.32080>;
        <D.32079>:
        code.271 = code;
        code = code.271 + 1;
        D.32082 = _amd64_rex_bits | 64;
        *code.271 = D.32082;
        <D.32080>:
      }
      code.272 = code;
      code = code.272 + 1;
      *code.272 = 5;
      {
        union x86_imm_buf imb;

        try
          {
            imb.val = 16;
            code.273 = code;
            code = code.273 + 1;
            D.32085 = imb.b[0];
            *code.273 = D.32085;
            code.274 = code;
            code = code.274 + 1;
            D.32087 = imb.b[1];
            *code.274 = D.32087;
            code.275 = code;
            code = code.275 + 1;
            D.32089 = imb.b[2];
            *code.275 = D.32089;
            code.276 = code;
            code = code.276 + 1;
            D.32091 = imb.b[3];
            *code.276 = D.32091;
          }
        finally
          {
            imb = {CLOBBER};
          }
      }
      goto <D.32092>;
      <D.32078>:
      {
        unsigned char _amd64_rex_bits;

        _amd64_rex_bits = 9;
        if (_amd64_rex_bits != 0) goto <D.32093>; else goto <D.32094>;
        <D.32093>:
        code.277 = code;
        code = code.277 + 1;
        D.32096 = _amd64_rex_bits | 64;
        *code.277 = D.32096;
        <D.32094>:
      }
      code.278 = code;
      code = code.278 + 1;
      *code.278 = 129;
      code.279 = code;
      code = code.279 + 1;
      *code.279 = 195;
      {
        union x86_imm_buf imb;

        try
          {
            imb.val = 16;
            code.280 = code;
            code = code.280 + 1;
            D.32100 = imb.b[0];
            *code.280 = D.32100;
            code.281 = code;
            code = code.281 + 1;
            D.32102 = imb.b[1];
            *code.281 = D.32102;
            code.282 = code;
            code = code.282 + 1;
            D.32104 = imb.b[2];
            *code.282 = D.32104;
            code.283 = code;
            code = code.283 + 1;
            D.32106 = imb.b[3];
            *code.283 = D.32106;
          }
        finally
          {
            imb = {CLOBBER};
          }
      }
      <D.32092>:
      <D.32076>:
      D.32107 = labels[0];
      D.32108 = (long int) D.32107;
      code.284 = (long int) code;
      D.32110 = D.32108 - code.284;
      D.32111 = (unsigned long) D.32110;
      D.32112 = D.32111 + 2147483648;
      if (D.32112 <= 4294967295) goto <D.32113>; else goto <D.32114>;
      <D.32113>:
      {
        int t;

        D.32107 = labels[0];
        D.32108 = (long int) D.32107;
        code.284 = (long int) code;
        D.32110 = D.32108 - code.284;
        D.32115 = (unsigned int) D.32110;
        D.32116 = D.32115 + 4294967294;
        t = (int) D.32116;
        t.285 = (unsigned int) t;
        D.32118 = t.285 + 128;
        if (D.32118 <= 255) goto <D.32119>; else goto <D.32120>;
        <D.32119>:
        code.286 = code;
        code = code.286 + 1;
        *code.286 = 235;
        D.32122 = (unsigned char) t;
        *code = D.32122;
        code = code + 1;
        goto <D.32123>;
        <D.32120>:
        D.32107 = labels[0];
        D.32108 = (long int) D.32107;
        code.284 = (long int) code;
        D.32110 = D.32108 - code.284;
        D.32115 = (unsigned int) D.32110;
        D.32124 = D.32115 + 4294967291;
        t = (int) D.32124;
        code.287 = code;
        code = code.287 + 1;
        *code.287 = 233;
        {
          union x86_imm_buf imb;

          try
            {
              imb.val = t;
              code.288 = code;
              code = code.288 + 1;
              D.32127 = imb.b[0];
              *code.288 = D.32127;
              code.289 = code;
              code = code.289 + 1;
              D.32129 = imb.b[1];
              *code.289 = D.32129;
              code.290 = code;
              code = code.290 + 1;
              D.32131 = imb.b[2];
              *code.290 = D.32131;
              code.291 = code;
              code = code.291 + 1;
              D.32133 = imb.b[3];
              *code.291 = D.32133;
            }
          finally
            {
              imb = {CLOBBER};
            }
        }
        <D.32123>:
      }
      goto <D.32134>;
      <D.32114>:
      {
        unsigned char _amd64_rex_bits;

        _amd64_rex_bits = 1;
        if (_amd64_rex_bits != 0) goto <D.32135>; else goto <D.32136>;
        <D.32135>:
        code.292 = code;
        code = code.292 + 1;
        D.32138 = _amd64_rex_bits | 64;
        *code.292 = D.32138;
        <D.32136>:
      }
      code.293 = code;
      code = code.293 + 1;
      *code.293 = 255;
      if (1 != 0) goto <D.32140>; else goto <D.32141>;
      <D.32140>:
      code.294 = code;
      code = code.294 + 1;
      *code.294 = 37;
      {
        union x86_imm_buf imb;

        try
          {
            imb.val = 0;
            code.295 = code;
            code = code.295 + 1;
            D.32144 = imb.b[0];
            *code.295 = D.32144;
            code.296 = code;
            code = code.296 + 1;
            D.32146 = imb.b[1];
            *code.296 = D.32146;
            code.297 = code;
            code = code.297 + 1;
            D.32148 = imb.b[2];
            *code.297 = D.32148;
            code.298 = code;
            code = code.298 + 1;
            D.32150 = imb.b[3];
            *code.298 = D.32150;
          }
        finally
          {
            imb = {CLOBBER};
          }
      }
      goto <D.32151>;
      <D.32141>:
      if (0 != 0) goto <D.32152>; else goto <D.32153>;
      <D.32152>:
      if (1 != 0) goto <D.32154>; else goto <D.32155>;
      <D.32154>:
      code.299 = code;
      code = code.299 + 1;
      *code.299 = 36;
      code.300 = code;
      code = code.300 + 1;
      *code.300 = 36;
      goto <D.32158>;
      <D.32155>:
      if (1 != 0) goto <D.32159>; else goto <D.32160>;
      <D.32159>:
      code.301 = code;
      code = code.301 + 1;
      *code.301 = 100;
      code.302 = code;
      code = code.302 + 1;
      *code.302 = 36;
      *code = 0;
      code = code + 1;
      goto <D.32163>;
      <D.32160>:
      code.303 = code;
      code = code.303 + 1;
      *code.303 = 164;
      code.304 = code;
      code = code.304 + 1;
      *code.304 = 36;
      {
        union x86_imm_buf imb;

        try
          {
            imb.val = 0;
            code.305 = code;
            code = code.305 + 1;
            D.32167 = imb.b[0];
            *code.305 = D.32167;
            code.306 = code;
            code = code.306 + 1;
            D.32169 = imb.b[1];
            *code.306 = D.32169;
            code.307 = code;
            code = code.307 + 1;
            D.32171 = imb.b[2];
            *code.307 = D.32171;
            code.308 = code;
            code = code.308 + 1;
            D.32173 = imb.b[3];
            *code.308 = D.32173;
          }
        finally
          {
            imb = {CLOBBER};
          }
      }
      <D.32163>:
      <D.32158>:
      goto <D.24147>;
      <D.32153>:
      if (1 != 0) goto <D.32174>; else goto <D.32175>;
      <D.32174>:
      code.309 = code;
      code = code.309 + 1;
      *code.309 = 32;
      goto <D.24147>;
      <D.32175>:
      if (1 != 0) goto <D.32177>; else goto <D.32178>;
      <D.32177>:
      code.310 = code;
      code = code.310 + 1;
      *code.310 = 96;
      *code = 0;
      code = code + 1;
      goto <D.32180>;
      <D.32178>:
      code.311 = code;
      code = code.311 + 1;
      *code.311 = 160;
      {
        union x86_imm_buf imb;

        try
          {
            imb.val = 0;
            code.312 = code;
            code = code.312 + 1;
            D.32183 = imb.b[0];
            *code.312 = D.32183;
            code.313 = code;
            code = code.313 + 1;
            D.32185 = imb.b[1];
            *code.313 = D.32185;
            code.314 = code;
            code = code.314 + 1;
            D.32187 = imb.b[2];
            *code.314 = D.32187;
            code.315 = code;
            code = code.315 + 1;
            D.32189 = imb.b[3];
            *code.315 = D.32189;
          }
        finally
          {
            imb = {CLOBBER};
          }
      }
      <D.32180>:
      <D.24147>:
      <D.32151>:
      D.32107 = labels[0];
      D.32190 = (long unsigned int) D.32107;
      MEM[(guint64 *)code] = D.32190;
      code = code + 8;
      <D.32134>:
      D.32191 = labels[2];
      mono_amd64_patch (D.32191, code);
      if (0 != 0) goto <D.32192>; else goto <D.32193>;
      <D.32192>:
      code.316 = code;
      code = code.316 + 1;
      *code.316 = 102;
      <D.32193>:
      {
        unsigned char _amd64_rex_bits;

        _amd64_rex_bits = 13;
        if (_amd64_rex_bits != 0) goto <D.32195>; else goto <D.32196>;
        <D.32195>:
        code.317 = code;
        code = code.317 + 1;
        D.32198 = _amd64_rex_bits | 64;
        *code.317 = D.32198;
        <D.32196>:
      }
      switch (8) <default: <D.24155>, case 1: <D.24150>, case 2: <D.24152>, case 4: <D.24153>, case 8: <D.24154>>
      <D.24150>:
      code.318 = code;
      code = code.318 + 1;
      *code.318 = 138;
      goto <D.24151>;
      <D.24152>:
      <D.24153>:
      <D.24154>:
      code.319 = code;
      code = code.319 + 1;
      *code.319 = 139;
      goto <D.24151>;
      <D.24155>:
      __assert_fail ("0", "aot-compiler.c", 1659, &__PRETTY_FUNCTION__);
      <D.24151>:
      if (0 != 0) goto <D.32201>; else goto <D.32202>;
      <D.32201>:
      code.320 = code;
      code = code.320 + 1;
      *code.320 = 29;
      {
        union x86_imm_buf imb;

        try
          {
            imb.val = 8;
            code.321 = code;
            code = code.321 + 1;
            D.32205 = imb.b[0];
            *code.321 = D.32205;
            code.322 = code;
            code = code.322 + 1;
            D.32207 = imb.b[1];
            *code.322 = D.32207;
            code.323 = code;
            code = code.323 + 1;
            D.32209 = imb.b[2];
            *code.323 = D.32209;
            code.324 = code;
            code = code.324 + 1;
            D.32211 = imb.b[3];
            *code.324 = D.32211;
          }
        finally
          {
            imb = {CLOBBER};
          }
      }
      goto <D.32212>;
      <D.32202>:
      if (0 != 0) goto <D.32213>; else goto <D.32214>;
      <D.32213>:
      if (0 != 0) goto <D.32215>; else goto <D.32216>;
      <D.32215>:
      code.325 = code;
      code = code.325 + 1;
      *code.325 = 28;
      code.326 = code;
      code = code.326 + 1;
      *code.326 = 36;
      goto <D.32219>;
      <D.32216>:
      if (1 != 0) goto <D.32220>; else goto <D.32221>;
      <D.32220>:
      code.327 = code;
      code = code.327 + 1;
      *code.327 = 92;
      code.328 = code;
      code = code.328 + 1;
      *code.328 = 36;
      *code = 8;
      code = code + 1;
      goto <D.32224>;
      <D.32221>:
      code.329 = code;
      code = code.329 + 1;
      *code.329 = 156;
      code.330 = code;
      code = code.330 + 1;
      *code.330 = 36;
      {
        union x86_imm_buf imb;

        try
          {
            imb.val = 8;
            code.331 = code;
            code = code.331 + 1;
            D.32228 = imb.b[0];
            *code.331 = D.32228;
            code.332 = code;
            code = code.332 + 1;
            D.32230 = imb.b[1];
            *code.332 = D.32230;
            code.333 = code;
            code = code.333 + 1;
            D.32232 = imb.b[2];
            *code.333 = D.32232;
            code.334 = code;
            code = code.334 + 1;
            D.32234 = imb.b[3];
            *code.334 = D.32234;
          }
        finally
          {
            imb = {CLOBBER};
          }
      }
      <D.32224>:
      <D.32219>:
      goto <D.24159>;
      <D.32214>:
      if (0 != 0) goto <D.32235>; else goto <D.32236>;
      <D.32235>:
      code.335 = code;
      code = code.335 + 1;
      *code.335 = 27;
      goto <D.24159>;
      <D.32236>:
      if (1 != 0) goto <D.32238>; else goto <D.32239>;
      <D.32238>:
      code.336 = code;
      code = code.336 + 1;
      *code.336 = 91;
      *code = 8;
      code = code + 1;
      goto <D.32241>;
      <D.32239>:
      code.337 = code;
      code = code.337 + 1;
      *code.337 = 155;
      {
        union x86_imm_buf imb;

        try
          {
            imb.val = 8;
            code.338 = code;
            code = code.338 + 1;
            D.32244 = imb.b[0];
            *code.338 = D.32244;
            code.339 = code;
            code = code.339 + 1;
            D.32246 = imb.b[1];
            *code.339 = D.32246;
            code.340 = code;
            code = code.340 + 1;
            D.32248 = imb.b[2];
            *code.340 = D.32248;
            code.341 = code;
            code = code.341 + 1;
            D.32250 = imb.b[3];
            *code.341 = D.32250;
          }
        finally
          {
            imb = {CLOBBER};
          }
      }
      <D.32241>:
      <D.24159>:
      <D.32212>:
      {
        unsigned char _amd64_rex_bits;

        _amd64_rex_bits = 1;
        if (_amd64_rex_bits != 0) goto <D.32251>; else goto <D.32252>;
        <D.32251>:
        code.342 = code;
        code = code.342 + 1;
        D.32254 = _amd64_rex_bits | 64;
        *code.342 = D.32254;
        <D.32252>:
      }
      code.343 = code;
      code = code.343 + 1;
      *code.343 = 255;
      if (0 != 0) goto <D.32256>; else goto <D.32257>;
      <D.32256>:
      code.344 = code;
      code = code.344 + 1;
      *code.344 = 37;
      {
        union x86_imm_buf imb;

        try
          {
            imb.val = 0;
            code.345 = code;
            code = code.345 + 1;
            D.32260 = imb.b[0];
            *code.345 = D.32260;
            code.346 = code;
            code = code.346 + 1;
            D.32262 = imb.b[1];
            *code.346 = D.32262;
            code.347 = code;
            code = code.347 + 1;
            D.32264 = imb.b[2];
            *code.347 = D.32264;
            code.348 = code;
            code = code.348 + 1;
            D.32266 = imb.b[3];
            *code.348 = D.32266;
          }
        finally
          {
            imb = {CLOBBER};
          }
      }
      goto <D.32267>;
      <D.32257>:
      if (0 != 0) goto <D.32268>; else goto <D.32269>;
      <D.32268>:
      if (1 != 0) goto <D.32270>; else goto <D.32271>;
      <D.32270>:
      code.349 = code;
      code = code.349 + 1;
      *code.349 = 36;
      code.350 = code;
      code = code.350 + 1;
      *code.350 = 36;
      goto <D.32274>;
      <D.32271>:
      if (1 != 0) goto <D.32275>; else goto <D.32276>;
      <D.32275>:
      code.351 = code;
      code = code.351 + 1;
      *code.351 = 100;
      code.352 = code;
      code = code.352 + 1;
      *code.352 = 36;
      *code = 0;
      code = code + 1;
      goto <D.32279>;
      <D.32276>:
      code.353 = code;
      code = code.353 + 1;
      *code.353 = 164;
      code.354 = code;
      code = code.354 + 1;
      *code.354 = 36;
      {
        union x86_imm_buf imb;

        try
          {
            imb.val = 0;
            code.355 = code;
            code = code.355 + 1;
            D.32283 = imb.b[0];
            *code.355 = D.32283;
            code.356 = code;
            code = code.356 + 1;
            D.32285 = imb.b[1];
            *code.356 = D.32285;
            code.357 = code;
            code = code.357 + 1;
            D.32287 = imb.b[2];
            *code.357 = D.32287;
            code.358 = code;
            code = code.358 + 1;
            D.32289 = imb.b[3];
            *code.358 = D.32289;
          }
        finally
          {
            imb = {CLOBBER};
          }
      }
      <D.32279>:
      <D.32274>:
      goto <D.24164>;
      <D.32269>:
      if (1 != 0) goto <D.32290>; else goto <D.32291>;
      <D.32290>:
      code.359 = code;
      code = code.359 + 1;
      *code.359 = 35;
      goto <D.24164>;
      <D.32291>:
      if (1 != 0) goto <D.32293>; else goto <D.32294>;
      <D.32293>:
      code.360 = code;
      code = code.360 + 1;
      *code.360 = 99;
      *code = 0;
      code = code + 1;
      goto <D.32296>;
      <D.32294>:
      code.361 = code;
      code = code.361 + 1;
      *code.361 = 163;
      {
        union x86_imm_buf imb;

        try
          {
            imb.val = 0;
            code.362 = code;
            code = code.362 + 1;
            D.32299 = imb.b[0];
            *code.362 = D.32299;
            code.363 = code;
            code = code.363 + 1;
            D.32301 = imb.b[1];
            *code.363 = D.32301;
            code.364 = code;
            code = code.364 + 1;
            D.32303 = imb.b[2];
            *code.364 = D.32303;
            code.365 = code;
            code = code.365 + 1;
            D.32305 = imb.b[3];
            *code.365 = D.32305;
          }
        finally
          {
            imb = {CLOBBER};
          }
      }
      <D.32296>:
      <D.24164>:
      <D.32267>:
      D.32306 = labels[1];
      mono_amd64_patch (D.32306, code);
      if (1 != 0) goto <D.32307>; else goto <D.32308>;
      <D.32307>:
      {
        unsigned char _amd64_rex_bits;

        _amd64_rex_bits = 9;
        if (_amd64_rex_bits != 0) goto <D.32309>; else goto <D.32310>;
        <D.32309>:
        code.366 = code;
        code = code.366 + 1;
        D.32312 = _amd64_rex_bits | 64;
        *code.366 = D.32312;
        <D.32310>:
      }
      code.367 = code;
      code = code.367 + 1;
      *code.367 = 131;
      code.368 = code;
      code = code.368 + 1;
      *code.368 = 195;
      *code = 8;
      code = code + 1;
      goto <D.32315>;
      <D.32308>:
      if (0 != 0) goto <D.32316>; else goto <D.32317>;
      <D.32316>:
      {
        unsigned char _amd64_rex_bits;

        _amd64_rex_bits = 8;
        if (_amd64_rex_bits != 0) goto <D.32318>; else goto <D.32319>;
        <D.32318>:
        code.369 = code;
        code = code.369 + 1;
        D.32321 = _amd64_rex_bits | 64;
        *code.369 = D.32321;
        <D.32319>:
      }
      code.370 = code;
      code = code.370 + 1;
      *code.370 = 5;
      {
        union x86_imm_buf imb;

        try
          {
            imb.val = 8;
            code.371 = code;
            code = code.371 + 1;
            D.32324 = imb.b[0];
            *code.371 = D.32324;
            code.372 = code;
            code = code.372 + 1;
            D.32326 = imb.b[1];
            *code.372 = D.32326;
            code.373 = code;
            code = code.373 + 1;
            D.32328 = imb.b[2];
            *code.373 = D.32328;
            code.374 = code;
            code = code.374 + 1;
            D.32330 = imb.b[3];
            *code.374 = D.32330;
          }
        finally
          {
            imb = {CLOBBER};
          }
      }
      goto <D.32331>;
      <D.32317>:
      {
        unsigned char _amd64_rex_bits;

        _amd64_rex_bits = 9;
        if (_amd64_rex_bits != 0) goto <D.32332>; else goto <D.32333>;
        <D.32332>:
        code.375 = code;
        code = code.375 + 1;
        D.32335 = _amd64_rex_bits | 64;
        *code.375 = D.32335;
        <D.32333>:
      }
      code.376 = code;
      code = code.376 + 1;
      *code.376 = 129;
      code.377 = code;
      code = code.377 + 1;
      *code.377 = 195;
      {
        union x86_imm_buf imb;

        try
          {
            imb.val = 8;
            code.378 = code;
            code = code.378 + 1;
            D.32339 = imb.b[0];
            *code.378 = D.32339;
            code.379 = code;
            code = code.379 + 1;
            D.32341 = imb.b[1];
            *code.379 = D.32341;
            code.380 = code;
            code = code.380 + 1;
            D.32343 = imb.b[2];
            *code.380 = D.32343;
            code.381 = code;
            code = code.381 + 1;
            D.32345 = imb.b[3];
            *code.381 = D.32345;
          }
        finally
          {
            imb = {CLOBBER};
          }
      }
      <D.32331>:
      <D.32315>:
      {
        unsigned char _amd64_rex_bits;

        _amd64_rex_bits = 9;
        if (_amd64_rex_bits != 0) goto <D.32346>; else goto <D.32347>;
        <D.32346>:
        code.382 = code;
        code = code.382 + 1;
        D.32349 = _amd64_rex_bits | 64;
        *code.382 = D.32349;
        <D.32347>:
      }
      if (1 != 0) goto <D.32350>; else goto <D.32351>;
      <D.32350>:
      code.383 = code;
      code = code.383 + 1;
      *code.383 = 131;
      if (0 != 0) goto <D.32353>; else goto <D.32354>;
      <D.32353>:
      if (1 != 0) goto <D.32355>; else goto <D.32356>;
      <D.32355>:
      code.384 = code;
      code = code.384 + 1;
      *code.384 = 60;
      code.385 = code;
      code = code.385 + 1;
      *code.385 = 36;
      goto <D.32359>;
      <D.32356>:
      if (1 != 0) goto <D.32360>; else goto <D.32361>;
      <D.32360>:
      code.386 = code;
      code = code.386 + 1;
      *code.386 = 124;
      code.387 = code;
      code = code.387 + 1;
      *code.387 = 36;
      *code = 0;
      code = code + 1;
      goto <D.32364>;
      <D.32361>:
      code.388 = code;
      code = code.388 + 1;
      *code.388 = 188;
      code.389 = code;
      code = code.389 + 1;
      *code.389 = 36;
      {
        union x86_imm_buf imb;

        try
          {
            imb.val = 0;
            code.390 = code;
            code = code.390 + 1;
            D.32368 = imb.b[0];
            *code.390 = D.32368;
            code.391 = code;
            code = code.391 + 1;
            D.32370 = imb.b[1];
            *code.391 = D.32370;
            code.392 = code;
            code = code.392 + 1;
            D.32372 = imb.b[2];
            *code.392 = D.32372;
            code.393 = code;
            code = code.393 + 1;
            D.32374 = imb.b[3];
            *code.393 = D.32374;
          }
        finally
          {
            imb = {CLOBBER};
          }
      }
      <D.32364>:
      <D.32359>:
      goto <D.24173>;
      <D.32354>:
      if (1 != 0) goto <D.32375>; else goto <D.32376>;
      <D.32375>:
      code.394 = code;
      code = code.394 + 1;
      *code.394 = 59;
      goto <D.24173>;
      <D.32376>:
      if (1 != 0) goto <D.32378>; else goto <D.32379>;
      <D.32378>:
      code.395 = code;
      code = code.395 + 1;
      *code.395 = 123;
      *code = 0;
      code = code + 1;
      goto <D.32381>;
      <D.32379>:
      code.396 = code;
      code = code.396 + 1;
      *code.396 = 187;
      {
        union x86_imm_buf imb;

        try
          {
            imb.val = 0;
            code.397 = code;
            code = code.397 + 1;
            D.32384 = imb.b[0];
            *code.397 = D.32384;
            code.398 = code;
            code = code.398 + 1;
            D.32386 = imb.b[1];
            *code.398 = D.32386;
            code.399 = code;
            code = code.399 + 1;
            D.32388 = imb.b[2];
            *code.399 = D.32388;
            code.400 = code;
            code = code.400 + 1;
            D.32390 = imb.b[3];
            *code.400 = D.32390;
          }
        finally
          {
            imb = {CLOBBER};
          }
      }
      <D.32381>:
      <D.24173>:
      *code = 0;
      code = code + 1;
      goto <D.32391>;
      <D.32351>:
      code.401 = code;
      code = code.401 + 1;
      *code.401 = 129;
      if (0 != 0) goto <D.32393>; else goto <D.32394>;
      <D.32393>:
      if (1 != 0) goto <D.32395>; else goto <D.32396>;
      <D.32395>:
      code.402 = code;
      code = code.402 + 1;
      *code.402 = 60;
      code.403 = code;
      code = code.403 + 1;
      *code.403 = 36;
      goto <D.32399>;
      <D.32396>:
      if (1 != 0) goto <D.32400>; else goto <D.32401>;
      <D.32400>:
      code.404 = code;
      code = code.404 + 1;
      *code.404 = 124;
      code.405 = code;
      code = code.405 + 1;
      *code.405 = 36;
      *code = 0;
      code = code + 1;
      goto <D.32404>;
      <D.32401>:
      code.406 = code;
      code = code.406 + 1;
      *code.406 = 188;
      code.407 = code;
      code = code.407 + 1;
      *code.407 = 36;
      {
        union x86_imm_buf imb;

        try
          {
            imb.val = 0;
            code.408 = code;
            code = code.408 + 1;
            D.32408 = imb.b[0];
            *code.408 = D.32408;
            code.409 = code;
            code = code.409 + 1;
            D.32410 = imb.b[1];
            *code.409 = D.32410;
            code.410 = code;
            code = code.410 + 1;
            D.32412 = imb.b[2];
            *code.410 = D.32412;
            code.411 = code;
            code = code.411 + 1;
            D.32414 = imb.b[3];
            *code.411 = D.32414;
          }
        finally
          {
            imb = {CLOBBER};
          }
      }
      <D.32404>:
      <D.32399>:
      goto <D.24176>;
      <D.32394>:
      if (1 != 0) goto <D.32415>; else goto <D.32416>;
      <D.32415>:
      code.412 = code;
      code = code.412 + 1;
      *code.412 = 59;
      goto <D.24176>;
      <D.32416>:
      if (1 != 0) goto <D.32418>; else goto <D.32419>;
      <D.32418>:
      code.413 = code;
      code = code.413 + 1;
      *code.413 = 123;
      *code = 0;
      code = code + 1;
      goto <D.32421>;
      <D.32419>:
      code.414 = code;
      code = code.414 + 1;
      *code.414 = 187;
      {
        union x86_imm_buf imb;

        try
          {
            imb.val = 0;
            code.415 = code;
            code = code.415 + 1;
            D.32424 = imb.b[0];
            *code.415 = D.32424;
            code.416 = code;
            code = code.416 + 1;
            D.32426 = imb.b[1];
            *code.416 = D.32426;
            code.417 = code;
            code = code.417 + 1;
            D.32428 = imb.b[2];
            *code.417 = D.32428;
            code.418 = code;
            code = code.418 + 1;
            D.32430 = imb.b[3];
            *code.418 = D.32430;
          }
        finally
          {
            imb = {CLOBBER};
          }
      }
      <D.32421>:
      <D.24176>:
      {
        union x86_imm_buf imb;

        try
          {
            imb.val = 0;
            code.419 = code;
            code = code.419 + 1;
            D.32432 = imb.b[0];
            *code.419 = D.32432;
            code.420 = code;
            code = code.420 + 1;
            D.32434 = imb.b[1];
            *code.420 = D.32434;
            code.421 = code;
            code = code.421 + 1;
            D.32436 = imb.b[2];
            *code.421 = D.32436;
            code.422 = code;
            code = code.422 + 1;
            D.32438 = imb.b[3];
            *code.422 = D.32438;
          }
        finally
          {
            imb = {CLOBBER};
          }
      }
      <D.32391>:
      labels[3] = code;
      if (0 != 0) goto <D.32439>; else goto <D.32440>;
      <D.32439>:
      code.423 = code;
      code = code.423 + 1;
      D.32016 = 116;
      *code.423 = D.32016;
      goto <D.32442>;
      <D.32440>:
      code.424 = code;
      code = code.424 + 1;
      D.32019 = 116;
      *code.424 = D.32019;
      <D.32442>:
      *code = 0;
      code = code + 1;
      {
        unsigned char _amd64_rex_bits;

        _amd64_rex_bits = 1;
        if (_amd64_rex_bits != 0) goto <D.32444>; else goto <D.32445>;
        <D.32444>:
        code.425 = code;
        code = code.425 + 1;
        D.32447 = _amd64_rex_bits | 64;
        *code.425 = D.32447;
        <D.32445>:
      }
      code.426 = code;
      code = code.426 + 1;
      *code.426 = 255;
      if (0 != 0) goto <D.32449>; else goto <D.32450>;
      <D.32449>:
      code.427 = code;
      code = code.427 + 1;
      *code.427 = 37;
      {
        union x86_imm_buf imb;

        try
          {
            imb.val = 0;
            code.428 = code;
            code = code.428 + 1;
            D.32453 = imb.b[0];
            *code.428 = D.32453;
            code.429 = code;
            code = code.429 + 1;
            D.32455 = imb.b[1];
            *code.429 = D.32455;
            code.430 = code;
            code = code.430 + 1;
            D.32457 = imb.b[2];
            *code.430 = D.32457;
            code.431 = code;
            code = code.431 + 1;
            D.32459 = imb.b[3];
            *code.431 = D.32459;
          }
        finally
          {
            imb = {CLOBBER};
          }
      }
      goto <D.32460>;
      <D.32450>:
      if (0 != 0) goto <D.32461>; else goto <D.32462>;
      <D.32461>:
      if (1 != 0) goto <D.32463>; else goto <D.32464>;
      <D.32463>:
      code.432 = code;
      code = code.432 + 1;
      *code.432 = 36;
      code.433 = code;
      code = code.433 + 1;
      *code.433 = 36;
      goto <D.32467>;
      <D.32464>:
      if (1 != 0) goto <D.32468>; else goto <D.32469>;
      <D.32468>:
      code.434 = code;
      code = code.434 + 1;
      *code.434 = 100;
      code.435 = code;
      code = code.435 + 1;
      *code.435 = 36;
      *code = 0;
      code = code + 1;
      goto <D.32472>;
      <D.32469>:
      code.436 = code;
      code = code.436 + 1;
      *code.436 = 164;
      code.437 = code;
      code = code.437 + 1;
      *code.437 = 36;
      {
        union x86_imm_buf imb;

        try
          {
            imb.val = 0;
            code.438 = code;
            code = code.438 + 1;
            D.32476 = imb.b[0];
            *code.438 = D.32476;
            code.439 = code;
            code = code.439 + 1;
            D.32478 = imb.b[1];
            *code.439 = D.32478;
            code.440 = code;
            code = code.440 + 1;
            D.32480 = imb.b[2];
            *code.440 = D.32480;
            code.441 = code;
            code = code.441 + 1;
            D.32482 = imb.b[3];
            *code.441 = D.32482;
          }
        finally
          {
            imb = {CLOBBER};
          }
      }
      <D.32472>:
      <D.32467>:
      goto <D.24182>;
      <D.32462>:
      if (1 != 0) goto <D.32483>; else goto <D.32484>;
      <D.32483>:
      code.442 = code;
      code = code.442 + 1;
      *code.442 = 35;
      goto <D.24182>;
      <D.32484>:
      if (1 != 0) goto <D.32486>; else goto <D.32487>;
      <D.32486>:
      code.443 = code;
      code = code.443 + 1;
      *code.443 = 99;
      *code = 0;
      code = code + 1;
      goto <D.32489>;
      <D.32487>:
      code.444 = code;
      code = code.444 + 1;
      *code.444 = 163;
      {
        union x86_imm_buf imb;

        try
          {
            imb.val = 0;
            code.445 = code;
            code = code.445 + 1;
            D.32492 = imb.b[0];
            *code.445 = D.32492;
            code.446 = code;
            code = code.446 + 1;
            D.32494 = imb.b[1];
            *code.446 = D.32494;
            code.447 = code;
            code = code.447 + 1;
            D.32496 = imb.b[2];
            *code.447 = D.32496;
            code.448 = code;
            code = code.448 + 1;
            D.32498 = imb.b[3];
            *code.448 = D.32498;
          }
        finally
          {
            imb = {CLOBBER};
          }
      }
      <D.32489>:
      <D.24182>:
      <D.32460>:
      D.32499 = labels[3];
      mono_amd64_patch (D.32499, code);
      code.449 = code;
      code = code.449 + 1;
      *code.449 = 204;
      {
        unsigned char _amd64_rex_bits;

        _amd64_rex_bits = 13;
        if (_amd64_rex_bits != 0) goto <D.32501>; else goto <D.32502>;
        <D.32501>:
        mov_buf_ptr.450 = mov_buf_ptr;
        mov_buf_ptr = mov_buf_ptr.450 + 1;
        D.32504 = _amd64_rex_bits | 64;
        *mov_buf_ptr.450 = D.32504;
        <D.32502>:
      }
      mov_buf_ptr.451 = mov_buf_ptr;
      mov_buf_ptr = mov_buf_ptr.451 + 1;
      *mov_buf_ptr.451 = 139;
      mov_buf_ptr.452 = mov_buf_ptr;
      mov_buf_ptr = mov_buf_ptr.452 + 1;
      *mov_buf_ptr.452 = 29;
      mov_buf_ptr.453 = (long int) mov_buf_ptr;
      mov_buf.454 = (long int) &mov_buf;
      D.32509 = mov_buf_ptr.453 - mov_buf.454;
      D.32510 = (int) D.32509;
      emit_bytes (acfg, &mov_buf, D.32510);
      D.32511 = (long unsigned int) offset;
      D.32512 = (unsigned int) D.32511;
      D.32513 = D.32512 * 8;
      D.32514 = D.32513 + 4294967292;
      D.32515 = (int) D.32514;
      D.32516 = acfg->got_symbol;
      emit_symbol_diff (acfg, D.32516, ".", D.32515);
      code.284 = (long int) code;
      buf.455 = (long int) buf;
      D.32518 = code.284 - buf.455;
      D.32519 = (int) D.32518;
      emit_bytes (acfg, buf, D.32519);
      code.284 = (long int) code;
      buf.455 = (long int) buf;
      D.32518 = code.284 - buf.455;
      D.32520 = (unsigned int) D.32518;
      D.32521 = D.32520 + 7;
      D.32522 = (int) D.32521;
      *tramp_size = D.32522;
      monoeg_g_free (buf);
    }
  finally
    {
      labels = {CLOBBER};
      mov_buf = {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.32523;
  <unnamed-unsigned:24> D.32524;
  int D.32525;
  double D.32526;
  double D.32527;
  int D.32528;
  unsigned int D.32529;
  unsigned int D.32530;
  unsigned int table_size.456;
  int D.32532;
  int D.32533;
  struct MonoType * D.32536;
  unsigned int D.32537;
  void * * D.32538;
  long unsigned int D.32539;
  long unsigned int D.32540;
  void * * D.32541;
  struct ClassNameTableEntry * D.32545;
  unsigned int D.32546;
  _Bool D.32547;
  long int D.32548;
  long int D.32549;
  _Bool D.32552;
  long int D.32553;
  long int D.32554;
  long unsigned int D.32557;
  long unsigned int D.32558;
  void * * D.32559;
  unsigned int D.32563;
  int D.32564;
  int D.32565;
  struct ClassNameTableEntry * D.32566;
  unsigned int D.32569;
  int D.32570;
  unsigned int i.457;
  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.32523 = acfg->image;
      D.32524 = D.32523->tables[2].rows;
      D.32525 = (int) D.32524;
      D.32526 = (double) D.32525;
      D.32527 = D.32526 * 1.5e+0;
      D.32528 = (int) D.32527;
      D.32529 = (unsigned int) D.32528;
      D.32530 = monoeg_g_spaced_primes_closest (D.32529);
      table_size = (int) D.32530;
      table_size.456 = (unsigned int) table_size;
      table = monoeg_g_ptr_array_sized_new (table_size.456);
      i = 0;
      goto <D.26228>;
      <D.26227>:
      monoeg_g_ptr_array_add (table, 0B);
      i = i + 1;
      <D.26228>:
      if (i < table_size) goto <D.26227>; else goto <D.26229>;
      <D.26229>:
      i = 0;
      goto <D.26235>;
      <D.26234>:
      D.32532 = i + 1;
      D.32533 = D.32532 | 33554432;
      token = (guint32) D.32533;
      D.32523 = acfg->image;
      klass = mono_class_get (D.32523, token);
      if (klass == 0B) goto <D.32534>; else goto <D.32535>;
      <D.32534>:
      mono_loader_clear_error ();
      // predicted unlikely by continue predictor.
      goto <D.26230>;
      <D.32535>:
      D.32536 = mono_class_get_type (klass);
      full_name = mono_type_get_name_full (D.32536, 2);
      D.32537 = mono_metadata_str_hash (full_name);
      table_size.456 = (unsigned int) table_size;
      hash = D.32537 % table_size.456;
      monoeg_g_free (full_name);
      new_entry = monoeg_malloc0 (16);
      new_entry->token = token;
      D.32538 = table->pdata;
      D.32539 = (long unsigned int) hash;
      D.32540 = D.32539 * 8;
      D.32541 = D.32538 + D.32540;
      entry = *D.32541;
      if (entry == 0B) goto <D.32542>; else goto <D.32543>;
      <D.32542>:
      new_entry->index = hash;
      D.32538 = table->pdata;
      D.32539 = (long unsigned int) hash;
      D.32540 = D.32539 * 8;
      D.32541 = D.32538 + D.32540;
      *D.32541 = new_entry;
      goto <D.32544>;
      <D.32543>:
      goto <D.26232>;
      <D.26231>:
      entry = entry->next;
      <D.26232>:
      D.32545 = entry->next;
      if (D.32545 != 0B) goto <D.26231>; else goto <D.26233>;
      <D.26233>:
      entry->next = new_entry;
      D.32546 = table->len;
      new_entry->index = D.32546;
      monoeg_g_ptr_array_add (table, new_entry);
      <D.32544>:
      <D.26230>:
      i = i + 1;
      <D.26235>:
      D.32523 = acfg->image;
      D.32524 = D.32523->tables[2].rows;
      D.32525 = (int) D.32524;
      if (D.32525 > i) goto <D.26234>; else goto <D.26236>;
      <D.26236>:
      sprintf (&symbol, "class_name_table");
      emit_section_change (acfg, ".rodata", 0);
      emit_alignment (acfg, 8);
      emit_label (acfg, &symbol);
      D.32547 = table_size > 64999;
      D.32548 = (long int) D.32547;
      D.32549 = __builtin_expect (D.32548, 0);
      if (D.32549 != 0) goto <D.32550>; else goto <D.32551>;
      <D.32550>:
      monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "aot-compiler.c", 7744, "table_size < 65000");
      <D.32551>:
      emit_int16 (acfg, table_size);
      D.32546 = table->len;
      D.32552 = D.32546 > 64999;
      D.32553 = (long int) D.32552;
      D.32554 = __builtin_expect (D.32553, 0);
      if (D.32554 != 0) goto <D.32555>; else goto <D.32556>;
      <D.32555>:
      monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "aot-compiler.c", 7746, "table->len < 65000");
      <D.32556>:
      i = 0;
      goto <D.26239>;
      <D.26238>:
      {
        struct ClassNameTableEntry * entry;

        D.32538 = table->pdata;
        D.32557 = (long unsigned int) i;
        D.32558 = D.32557 * 8;
        D.32559 = D.32538 + D.32558;
        entry = *D.32559;
        if (entry == 0B) goto <D.32560>; else goto <D.32561>;
        <D.32560>:
        emit_int16 (acfg, 0);
        emit_int16 (acfg, 0);
        goto <D.32562>;
        <D.32561>:
        D.32563 = entry->token;
        D.32564 = (int) D.32563;
        D.32565 = D.32564 & 16777215;
        emit_int16 (acfg, D.32565);
        D.32566 = entry->next;
        if (D.32566 != 0B) goto <D.32567>; else goto <D.32568>;
        <D.32567>:
        D.32566 = entry->next;
        D.32569 = D.32566->index;
        D.32570 = (int) D.32569;
        emit_int16 (acfg, D.32570);
        goto <D.32571>;
        <D.32568>:
        emit_int16 (acfg, 0);
        <D.32571>:
        <D.32562>:
      }
      i = i + 1;
      <D.26239>:
      i.457 = (unsigned int) i;
      D.32546 = table->len;
      if (i.457 < D.32546) goto <D.26238>; else goto <D.26240>;
      <D.26240>:
    }
  finally
    {
      symbol = {CLOBBER};
    }
}


emit_got_info (struct MonoAotCompile * acfg)
{
  unsigned int D.32573;
  struct GPtrArray * D.32574;
  unsigned int D.32575;
  long unsigned int D.32576;
  const void * D.32577;
  struct GHashTable * D.32578;
  struct MonoJumpInfo * D.32579;
  <unnamed type> D.32580;
  int D.32581;
  int D.32582;
  unsigned int i.458;
  unsigned int D.32584;
  unsigned int D.32585;
  unsigned int D.32586;
  unsigned int buf_size.459;
  struct MonoMemPool * D.32588;
  unsigned int D.32589;
  unsigned int D.32590;
  void * D.32591;
  guint32 * D.32594;
  void * * D.32595;
  long unsigned int D.32596;
  void * * D.32597;
  guint8 * p.460;
  <unnamed type> D.32599;
  int D.32600;
  int D.32601;
  unsigned int D.32602;
  long int p.461;
  long int p2.462;
  long int D.32605;
  unsigned int D.32606;
  unsigned int D.32607;
  int D.32608;
  long int buf.463;
  long int D.32610;
  long int D.32611;
  _Bool D.32612;
  long int D.32613;
  long int D.32614;
  long unsigned int D.32617;
  guint32 * D.32618;
  unsigned int D.32619;
  unsigned int D.32620;
  int D.32623;
  sizetype D.32624;
  sizetype D.32625;
  sizetype D.32626;
  guint32 * D.32627;
  unsigned int D.32628;
  int D.32629;
  unsigned int D.32630;
  unsigned int D.32631;
  unsigned int D.32632;
  int D.32633;
  unsigned int i.464;
  unsigned int D.32635;
  int D.32636;
  unsigned int D.32637;
  unsigned int D.32638;
  int D.32639;
  char symbol[256];
  int i;
  int first_plt_got_patch;
  int buf_size;
  guint8 * p;
  guint8 * buf;
  guint32 * got_info_offsets;

  try
    {
      D.32573 = acfg->got_offset;
      acfg->plt_got_offset_base = D.32573;
      D.32574 = acfg->got_patches;
      D.32575 = D.32574->len;
      first_plt_got_patch = (int) D.32575;
      i = 1;
      goto <D.26263>;
      <D.26262>:
      {
        struct MonoPltEntry * plt_entry;

        D.32576 = (long unsigned int) i;
        D.32577 = (const void *) D.32576;
        D.32578 = acfg->plt_offset_to_entry;
        plt_entry = monoeg_g_hash_table_lookup (D.32578, D.32577);
        D.32579 = plt_entry->ji;
        D.32574 = acfg->got_patches;
        monoeg_g_ptr_array_add (D.32574, D.32579);
        D.32579 = plt_entry->ji;
        D.32580 = D.32579->type;
        D.32581 = acfg->stats.got_slot_types[D.32580];
        D.32582 = D.32581 + 1;
        acfg->stats.got_slot_types[D.32580] = D.32582;
      }
      i = i + 1;
      <D.26263>:
      i.458 = (unsigned int) i;
      D.32584 = acfg->plt_offset;
      if (i.458 < D.32584) goto <D.26262>; else goto <D.26264>;
      <D.26264>:
      D.32573 = acfg->got_offset;
      D.32584 = acfg->plt_offset;
      D.32585 = D.32573 + D.32584;
      acfg->got_offset = D.32585;
      D.32574 = acfg->got_patches;
      D.32575 = D.32574->len;
      D.32586 = D.32575 * 128;
      buf_size = (int) D.32586;
      buf_size.459 = (unsigned int) buf_size;
      D.32588 = acfg->mempool;
      buf = mono_mempool_alloc (D.32588, buf_size.459);
      p = buf;
      D.32574 = acfg->got_patches;
      D.32575 = D.32574->len;
      D.32589 = D.32575 * 4;
      D.32588 = acfg->mempool;
      got_info_offsets = mono_mempool_alloc (D.32588, D.32589);
      D.32584 = acfg->plt_offset;
      D.32590 = D.32584 * 4;
      D.32588 = acfg->mempool;
      D.32591 = mono_mempool_alloc (D.32588, D.32590);
      acfg->plt_got_info_offsets = D.32591;
      D.32584 = acfg->plt_offset;
      if (D.32584 != 0) goto <D.32592>; else goto <D.32593>;
      <D.32592>:
      D.32594 = acfg->plt_got_info_offsets;
      *D.32594 = 0;
      <D.32593>:
      i = 0;
      goto <D.26268>;
      <D.26267>:
      {
        struct MonoJumpInfo * ji;
        guint8 * p2;

        D.32574 = acfg->got_patches;
        D.32595 = D.32574->pdata;
        D.32576 = (long unsigned int) i;
        D.32596 = D.32576 * 8;
        D.32597 = D.32595 + D.32596;
        ji = *D.32597;
        p = buf;
        p.460 = p;
        D.32599 = ji->type;
        D.32600 = (int) D.32599;
        encode_value (D.32600, p.460, &p);
        p2 = p;
        p.460 = p;
        encode_patch (acfg, ji, p.460, &p);
        D.32599 = ji->type;
        D.32599 = ji->type;
        D.32601 = acfg->stats.got_slot_info_sizes[D.32599];
        D.32602 = (unsigned int) D.32601;
        p.460 = p;
        p.461 = (long int) p.460;
        p2.462 = (long int) p2;
        D.32605 = p.461 - p2.462;
        D.32606 = (unsigned int) D.32605;
        D.32607 = D.32602 + D.32606;
        D.32608 = (int) D.32607;
        acfg->stats.got_slot_info_sizes[D.32599] = D.32608;
        p.460 = p;
        p.461 = (long int) p.460;
        buf.463 = (long int) buf;
        D.32610 = p.461 - buf.463;
        D.32611 = (long int) buf_size;
        D.32612 = D.32610 > D.32611;
        D.32613 = (long int) D.32612;
        D.32614 = __builtin_expect (D.32613, 0);
        if (D.32614 != 0) goto <D.32615>; else goto <D.32616>;
        <D.32615>:
        monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "aot-compiler.c", 7851, "p - buf <= buf_size");
        <D.32616>:
        D.32576 = (long unsigned int) i;
        D.32617 = D.32576 * 4;
        D.32618 = got_info_offsets + D.32617;
        p.460 = p;
        p.461 = (long int) p.460;
        buf.463 = (long int) buf;
        D.32610 = p.461 - buf.463;
        D.32619 = (unsigned int) D.32610;
        D.32620 = add_to_blob (acfg, buf, D.32619);
        *D.32618 = D.32620;
        if (i >= first_plt_got_patch) goto <D.32621>; else goto <D.32622>;
        <D.32621>:
        D.32594 = acfg->plt_got_info_offsets;
        D.32623 = i - first_plt_got_patch;
        D.32624 = (sizetype) D.32623;
        D.32625 = D.32624 + 1;
        D.32626 = D.32625 * 4;
        D.32627 = D.32594 + D.32626;
        D.32576 = (long unsigned int) i;
        D.32617 = D.32576 * 4;
        D.32618 = got_info_offsets + D.32617;
        D.32628 = *D.32618;
        *D.32627 = D.32628;
        <D.32622>:
        D.32629 = acfg->stats.got_info_size;
        D.32630 = (unsigned int) D.32629;
        p.460 = p;
        p.461 = (long int) p.460;
        buf.463 = (long int) buf;
        D.32610 = p.461 - buf.463;
        D.32631 = (unsigned int) D.32610;
        D.32632 = D.32630 + D.32631;
        D.32633 = (int) D.32632;
        acfg->stats.got_info_size = D.32633;
      }
      i = i + 1;
      <D.26268>:
      i.464 = (unsigned int) i;
      D.32574 = acfg->got_patches;
      D.32575 = D.32574->len;
      if (i.464 < D.32575) goto <D.26267>; else goto <D.26269>;
      <D.26269>:
      sprintf (&symbol, "got_info_offsets");
      emit_section_change (acfg, ".rodata", 1);
      emit_alignment (acfg, 8);
      emit_label (acfg, &symbol);
      D.32635 = emit_offset_table (acfg, first_plt_got_patch, 10, got_info_offsets);
      D.32636 = acfg->stats.offsets_size;
      D.32637 = (unsigned int) D.32636;
      D.32638 = D.32637 + D.32635;
      D.32639 = (int) D.32638;
      acfg->stats.offsets_size = D.32639;
    }
  finally
    {
      symbol = {CLOBBER};
      p = {CLOBBER};
    }
}


encode_patch (struct MonoAotCompile * acfg, struct MonoJumpInfo * patch_info, guint8 * buf, guint8 * * endbuf)
{
  <unnamed type> D.32640;
  guint8 * p.465;
  struct MonoImage * D.32642;
  unsigned int D.32643;
  int D.32644;
  long int D.32645;
  int D.32646;
  struct MonoJumpInfoBBTable * D.32647;
  int D.32648;
  long unsigned int D.32649;
  long unsigned int D.32650;
  void * * D.32651;
  void * D.32652;
  long int D.32653;
  int D.32654;
  struct MonoMethod * D.32655;
  const char * D.32656;
  long unsigned int D.32657;
  int len.466;
  long unsigned int D.32659;
  sizetype D.32660;
  guint8 * p.467;
  guint8 * p.468;
  guint8 * p.469;
  struct MonoJumpInfoToken * D.32664;
  struct MonoImage * D.32665;
  unsigned int D.32666;
  _Bool D.32667;
  long int D.32668;
  long int D.32669;
  int image_index.470;
  unsigned int D.32673;
  unsigned int D.32674;
  int D.32675;
  unsigned int D.32676;
  int D.32677;
  int D.32678;
  int D.32679;
  struct MonoGenericContext * D.32682;
  const void * D.32683;
  struct MonoClass * D.32684;
  struct MonoImage * D.32685;
  _Bool D.32686;
  long int D.32687;
  long int D.32688;
  unsigned int D.32691;
  int D.32692;
  guint32 * D.32693;
  unsigned int D.32694;
  int D.32695;
  struct MonoClass * D.32696;
  struct MonoClassField * D.32697;
  struct MonoMethod * D.32698;
  struct GHashTable * D.32699;
  void * D.32700;
  long int D.32701;
  guint8 * p2.471;
  long int p2.472;
  long int buf2.473;
  long int D.32707;
  _Bool D.32708;
  long int D.32709;
  long int D.32710;
  unsigned int D.32713;
  unsigned int D.32714;
  long unsigned int D.32715;
  void * D.32716;
  int offset.474;
  <unnamed type> D.32719;
  int D.32720;
  _Bool D.32721;
  long int D.32722;
  long int D.32723;
  struct MonoJumpInfo * D.32726;
  <unnamed type> D.32727;
  _Bool D.32728;
  long int D.32729;
  long int D.32730;
  unsigned int iftmp.475;
  int D.32734;
  unsigned int D.32738;
  unsigned int D.32739;
  unsigned int D.32740;
  unsigned int D.32741;
  int D.32742;
  struct MonoJumpInfoImtTramp * D.32743;
  struct MonoMethod * D.32744;
  int D.32745;
  long int D.32746;
  int D.32747;
  struct MonoJumpInfoGSharedVtCall * D.32748;
  struct MonoMethodSignature * D.32749;
  struct MonoMethod * D.32750;
  struct MonoMethod * D.32751;
  struct GPtrArray * D.32752;
  unsigned int D.32753;
  int D.32754;
  void * * D.32755;
  long unsigned int D.32756;
  long unsigned int D.32757;
  void * * D.32758;
  <unnamed type> D.32759;
  int D.32760;
  <unnamed type> D.32761;
  void * D.32762;
  struct MonoClass * D.32763;
  unsigned int i.476;
  guint8 * p;

  try
    {
      p = buf;
      D.32640 = patch_info->type;
      switch (D.32640) <default: <D.25427>, case 3: <D.25375>, case 4: <D.25376>, case 5: <D.25367>, case 6: <D.25374>, case 7: <D.25380>, case 8: <D.25368>, case 10: <D.25390>, case 11: <D.25395>, case 12: <D.25362>, case 13: <D.25400>, case 14: <D.25394>, case 15: <D.25398>, case 16: <D.25401>, case 17: <D.25383>, case 18: <D.25388>, case 19: <D.25389>, case 20: <D.25392>, case 21: <D.25393>, case 23: <D.25396>, case 24: <D.25397>, case 28: <D.25387>, case 29: <D.25386>, case 30: <D.25399>, case 31: <D.25377>, case 32: <D.25381>, case 33: <D.25402>, case 34: <D.25378>, case 35: <D.25403>, case 36: <D.25408>, case 37: <D.25409>, case 38: <D.25410>, case 39: <D.25363>, case 40: <D.25411>, case 41: <D.25412>, case 42: <D.25365>, case 43: <D.25366>, case 44: <D.25413>, case 45: <D.25415>, case 46: <D.25416>, case 47: <D.25364>, case 48: <D.25414>, case 50: <D.25379>, case 51: <D.25360>>
      <D.25360>:
      goto <D.25361>;
      <D.25362>:
      p.465 = p;
      D.32642 = patch_info->data.image;
      D.32643 = get_image_index (acfg, D.32642);
      D.32644 = (int) D.32643;
      encode_value (D.32644, p.465, &p);
      goto <D.25361>;
      <D.25363>:
      <D.25364>:
      <D.25365>:
      <D.25366>:
      goto <D.25361>;
      <D.25367>:
      p.465 = p;
      D.32645 = patch_info->data.offset;
      D.32646 = (int) D.32645;
      encode_value (D.32646, p.465, &p);
      goto <D.25361>;
      <D.25368>:
      {
        void * * table;
        int k;

        D.32647 = patch_info->data.table;
        table = D.32647->table;
        p.465 = p;
        D.32647 = patch_info->data.table;
        D.32648 = D.32647->table_size;
        encode_value (D.32648, p.465, &p);
        k = 0;
        goto <D.25372>;
        <D.25371>:
        p.465 = p;
        D.32649 = (long unsigned int) k;
        D.32650 = D.32649 * 8;
        D.32651 = table + D.32650;
        D.32652 = *D.32651;
        D.32653 = (long int) D.32652;
        D.32654 = (int) D.32653;
        encode_value (D.32654, p.465, &p);
        k = k + 1;
        <D.25372>:
        D.32647 = patch_info->data.table;
        D.32648 = D.32647->table_size;
        if (D.32648 > k) goto <D.25371>; else goto <D.25373>;
        <D.25373>:
        goto <D.25361>;
      }
      <D.25374>:
      <D.25375>:
      <D.25376>:
      <D.25377>:
      <D.25378>:
      <D.25379>:
      p.465 = p;
      D.32655 = patch_info->data.method;
      encode_method_ref (acfg, D.32655, p.465, &p);
      goto <D.25361>;
      <D.25380>:
      <D.25381>:
      {
        guint32 len;

        D.32656 = patch_info->data.name;
        D.32657 = strlen (D.32656);
        len = (guint32) D.32657;
        p.465 = p;
        len.466 = (int) len;
        encode_value (len.466, p.465, &p);
        D.32659 = (long unsigned int) len;
        D.32656 = patch_info->data.name;
        p.465 = p;
        memcpy (p.465, D.32656, D.32659);
        p.465 = p;
        D.32660 = (sizetype) len;
        p.467 = p.465 + D.32660;
        p = p.467;
        p.465 = p;
        p.468 = p.465;
        p.469 = p.468 + 1;
        p = p.469;
        *p.468 = 0;
        goto <D.25361>;
      }
      <D.25383>:
      {
        guint32 image_index;
        guint32 token;

        D.32664 = patch_info->data.token;
        D.32665 = D.32664->image;
        image_index = get_image_index (acfg, D.32665);
        D.32664 = patch_info->data.token;
        token = D.32664->token;
        D.32666 = token & 4278190080;
        D.32667 = D.32666 != 1879048192;
        D.32668 = (long int) D.32667;
        D.32669 = __builtin_expect (D.32668, 0);
        if (D.32669 != 0) goto <D.32670>; else goto <D.32671>;
        <D.32670>:
        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.32671>:
        p.465 = p;
        image_index.470 = (int) image_index;
        encode_value (image_index.470, p.465, &p);
        p.465 = p;
        D.32664 = patch_info->data.token;
        D.32673 = D.32664->token;
        D.32674 = D.32673 + 2415919104;
        D.32675 = (int) D.32674;
        encode_value (D.32675, p.465, &p);
        goto <D.25361>;
      }
      <D.25386>:
      <D.25387>:
      <D.25388>:
      <D.25389>:
      p.465 = p;
      D.32664 = patch_info->data.token;
      D.32665 = D.32664->image;
      D.32676 = get_image_index (acfg, D.32665);
      D.32677 = (int) D.32676;
      encode_value (D.32677, p.465, &p);
      p.465 = p;
      D.32664 = patch_info->data.token;
      D.32673 = D.32664->token;
      D.32678 = (int) D.32673;
      encode_value (D.32678, p.465, &p);
      p.465 = p;
      D.32664 = patch_info->data.token;
      D.32679 = D.32664->has_context;
      encode_value (D.32679, p.465, &p);
      D.32664 = patch_info->data.token;
      D.32679 = D.32664->has_context;
      if (D.32679 != 0) goto <D.32680>; else goto <D.32681>;
      <D.32680>:
      p.465 = p;
      D.32664 = patch_info->data.token;
      D.32682 = &D.32664->context;
      encode_generic_context (acfg, D.32682, p.465, &p);
      <D.32681>:
      goto <D.25361>;
      <D.25390>:
      {
        struct MonoClass * ex_class;

        D.32683 = patch_info->data.target;
        D.32684 = mono_defaults.exception_class;
        D.32685 = D.32684->image;
        ex_class = mono_class_from_name (D.32685, "System", D.32683);
        D.32686 = ex_class == 0B;
        D.32687 = (long int) D.32686;
        D.32688 = __builtin_expect (D.32687, 0);
        if (D.32688 != 0) goto <D.32689>; else goto <D.32690>;
        <D.32689>:
        monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "aot-compiler.c", 4948, "ex_class");
        <D.32690>:
        p.465 = p;
        encode_klass_ref (acfg, ex_class, p.465, &p);
        goto <D.25361>;
      }
      <D.25392>:
      p.465 = p;
      D.32683 = patch_info->data.target;
      D.32691 = MEM[(guint32 *)D.32683];
      D.32692 = (int) D.32691;
      encode_value (D.32692, p.465, &p);
      goto <D.25361>;
      <D.25393>:
      p.465 = p;
      D.32683 = patch_info->data.target;
      D.32691 = MEM[(guint32 *)D.32683];
      D.32692 = (int) D.32691;
      encode_value (D.32692, p.465, &p);
      p.465 = p;
      D.32683 = patch_info->data.target;
      D.32693 = D.32683 + 4;
      D.32694 = *D.32693;
      D.32695 = (int) D.32694;
      encode_value (D.32695, p.465, &p);
      goto <D.25361>;
      <D.25394>:
      <D.25395>:
      <D.25396>:
      <D.25397>:
      p.465 = p;
      D.32696 = patch_info->data.klass;
      encode_klass_ref (acfg, D.32696, p.465, &p);
      goto <D.25361>;
      <D.25398>:
      <D.25399>:
      p.465 = p;
      D.32696 = patch_info->data.klass;
      encode_klass_ref (acfg, D.32696, p.465, &p);
      goto <D.25361>;
      <D.25400>:
      <D.25401>:
      p.465 = p;
      D.32697 = patch_info->data.field;
      encode_field_info (acfg, D.32697, p.465, &p);
      goto <D.25361>;
      <D.25402>:
      goto <D.25361>;
      <D.25403>:
      {
        struct MonoJumpInfoRgctxEntry * entry;
        guint32 offset;
        guint8 * buf2;
        guint8 * p2;

        try
          {
            entry = patch_info->data.rgctx_entry;
            D.32698 = entry->method;
            D.32699 = acfg->method_blob_hash;
            D.32700 = monoeg_g_hash_table_lookup (D.32699, D.32698);
            D.32701 = (long int) D.32700;
            offset = (guint32) D.32701;
            if (offset == 0) goto <D.32702>; else goto <D.32703>;
            <D.32702>:
            buf2 = monoeg_malloc (1024);
            p2 = buf2;
            p2.471 = p2;
            D.32698 = entry->method;
            encode_method_ref (acfg, D.32698, p2.471, &p2);
            p2.471 = p2;
            p2.472 = (long int) p2.471;
            buf2.473 = (long int) buf2;
            D.32707 = p2.472 - buf2.473;
            D.32708 = D.32707 > 1023;
            D.32709 = (long int) D.32708;
            D.32710 = __builtin_expect (D.32709, 0);
            if (D.32710 != 0) goto <D.32711>; else goto <D.32712>;
            <D.32711>:
            monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "aot-compiler.c", 4990, "p2 - buf2 < 1024");
            <D.32712>:
            p2.471 = p2;
            p2.472 = (long int) p2.471;
            buf2.473 = (long int) buf2;
            D.32707 = p2.472 - buf2.473;
            D.32713 = (unsigned int) D.32707;
            offset = add_to_blob (acfg, buf2, D.32713);
            monoeg_g_free (buf2);
            D.32714 = offset + 1;
            D.32715 = (long unsigned int) D.32714;
            D.32716 = (void *) D.32715;
            D.32698 = entry->method;
            D.32699 = acfg->method_blob_hash;
            monoeg_g_hash_table_insert_replace (D.32699, D.32698, D.32716, 0);
            goto <D.32717>;
            <D.32703>:
            offset = offset + 4294967295;
            <D.32717>:
            p.465 = p;
            offset.474 = (int) offset;
            encode_value (offset.474, p.465, &p);
            D.32719 = entry->info_type;
            D.32720 = (int) D.32719;
            D.32721 = D.32720 > 255;
            D.32722 = (long int) D.32721;
            D.32723 = __builtin_expect (D.32722, 0);
            if (D.32723 != 0) goto <D.32724>; else goto <D.32725>;
            <D.32724>:
            monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "aot-compiler.c", 5001, "(int)entry->info_type < 256");
            <D.32725>:
            D.32726 = entry->data;
            D.32727 = D.32726->type;
            D.32728 = D.32727 > 255;
            D.32729 = (long int) D.32728;
            D.32730 = __builtin_expect (D.32729, 0);
            if (D.32730 != 0) goto <D.32731>; else goto <D.32732>;
            <D.32731>:
            monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "aot-compiler.c", 5002, "entry->data->type < 256");
            <D.32732>:
            p.465 = p;
            D.32734 = entry->in_mrgctx;
            if (D.32734 != 0) goto <D.32735>; else goto <D.32736>;
            <D.32735>:
            iftmp.475 = 1;
            goto <D.32737>;
            <D.32736>:
            iftmp.475 = 0;
            <D.32737>:
            D.32719 = entry->info_type;
            D.32738 = D.32719 << 1;
            D.32739 = iftmp.475 | D.32738;
            D.32726 = entry->data;
            D.32727 = D.32726->type;
            D.32740 = D.32727 << 9;
            D.32741 = D.32739 | D.32740;
            D.32742 = (int) D.32741;
            encode_value (D.32742, p.465, &p);
            p.465 = p;
            D.32726 = entry->data;
            encode_patch (acfg, D.32726, p.465, &p);
            goto <D.25361>;
          }
        finally
          {
            p2 = {CLOBBER};
          }
      }
      <D.25408>:
      <D.25409>:
      <D.25410>:
      <D.25411>:
      goto <D.25361>;
      <D.25412>:
      p.465 = p;
      D.32743 = patch_info->data.imt_tramp;
      D.32744 = D.32743->method;
      encode_method_ref (acfg, D.32744, p.465, &p);
      p.465 = p;
      D.32743 = patch_info->data.imt_tramp;
      D.32745 = D.32743->vt_offset;
      encode_value (D.32745, p.465, &p);
      goto <D.25361>;
      <D.25413>:
      p.465 = p;
      D.32683 = patch_info->data.target;
      encode_signature (acfg, D.32683, p.465, &p);
      goto <D.25361>;
      <D.25414>:
      p.465 = p;
      D.32683 = patch_info->data.target;
      D.32746 = (long int) D.32683;
      D.32747 = (int) D.32746;
      encode_value (D.32747, p.465, &p);
      goto <D.25361>;
      <D.25415>:
      p.465 = p;
      D.32748 = patch_info->data.gsharedvt;
      D.32749 = D.32748->sig;
      encode_signature (acfg, D.32749, p.465, &p);
      p.465 = p;
      D.32748 = patch_info->data.gsharedvt;
      D.32750 = D.32748->method;
      encode_method_ref (acfg, D.32750, p.465, &p);
      goto <D.25361>;
      <D.25416>:
      {
        struct MonoGSharedVtMethodInfo * info;
        int i;

        info = patch_info->data.gsharedvt_method;
        p.465 = p;
        D.32751 = info->method;
        encode_method_ref (acfg, D.32751, p.465, &p);
        p.465 = p;
        D.32752 = info->entries;
        D.32753 = D.32752->len;
        D.32754 = (int) D.32753;
        encode_value (D.32754, p.465, &p);
        i = 0;
        goto <D.25425>;
        <D.25424>:
        {
          struct MonoRuntimeGenericContextInfoTemplate * template;

          D.32752 = info->entries;
          D.32755 = D.32752->pdata;
          D.32756 = (long unsigned int) i;
          D.32757 = D.32756 * 8;
          D.32758 = D.32755 + D.32757;
          template = *D.32758;
          p.465 = p;
          D.32759 = template->info_type;
          D.32760 = (int) D.32759;
          encode_value (D.32760, p.465, &p);
          D.32759 = template->info_type;
          D.32761 = mini_rgctx_info_type_to_patch_info_type (D.32759);
          switch (D.32761) <default: <D.25423>, case 11: <D.25420>, case 13: <D.25422>>
          <D.25420>:
          p.465 = p;
          D.32762 = template->data;
          D.32763 = mono_class_from_mono_type (D.32762);
          encode_klass_ref (acfg, D.32763, p.465, &p);
          goto <D.25421>;
          <D.25422>:
          p.465 = p;
          D.32762 = template->data;
          encode_field_info (acfg, D.32762, p.465, &p);
          goto <D.25421>;
          <D.25423>:
          monoeg_assertion_message ("* Assertion: should not be reached at %s:%d\n", "aot-compiler.c", 5044);
          <D.25421>:
        }
        i = i + 1;
        <D.25425>:
        i.476 = (unsigned int) i;
        D.32752 = info->entries;
        D.32753 = D.32752->len;
        if (i.476 < D.32753) goto <D.25424>; else goto <D.25426>;
        <D.25426>:
        goto <D.25361>;
      }
      <D.25427>:
      D.32640 = patch_info->type;
      monoeg_g_log (0B, 16, "unable to handle jump info %d", D.32640);
      monoeg_assertion_message ("* Assertion: should not be reached at %s:%d\n", "aot-compiler.c", 5052);
      <D.25361>:
      p.465 = p;
      *endbuf = p.465;
    }
  finally
    {
      p = {CLOBBER};
    }
}


encode_field_info (struct MonoAotCompile * cfg, struct MonoClassField * field, guint8 * buf, guint8 * * endbuf)
{
  guint8 * p.477;
  struct MonoClass * D.32768;
  unsigned int D.32769;
  _Bool D.32770;
  long int D.32771;
  long int D.32772;
  unsigned int D.32775;
  int D.32776;
  guint32 token;
  guint8 * p;

  try
    {
      token = mono_get_field_token (field);
      p = buf;
      p.477 = p;
      D.32768 = field->parent;
      encode_klass_ref (cfg, D.32768, p.477, &p);
      D.32769 = token & 4278190080;
      D.32770 = D.32769 != 67108864;
      D.32771 = (long int) D.32770;
      D.32772 = __builtin_expect (D.32771, 0);
      if (D.32772 != 0) goto <D.32773>; else goto <D.32774>;
      <D.32773>:
      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.32774>:
      p.477 = p;
      D.32775 = token + 4227858432;
      D.32776 = (int) D.32775;
      encode_value (D.32776, p.477, &p);
      p.477 = p;
      *endbuf = p.477;
    }
  finally
    {
      p = {CLOBBER};
    }
}


mono_get_field_token (struct MonoClassField * field)
{
  struct MonoClassField * D.32777;
  long unsigned int D.32778;
  long unsigned int D.32779;
  struct MonoClassField * D.32780;
  guint32 D.32783;
  unsigned int D.32784;
  unsigned int i.478;
  unsigned int D.32786;
  unsigned int D.32787;
  unsigned int D.32788;
  struct MonoClass * klass;
  int i;

  klass = field->parent;
  i = 0;
  goto <D.24200>;
  <D.24199>:
  D.32777 = klass->fields;
  D.32778 = (long unsigned int) i;
  D.32779 = D.32778 * 32;
  D.32780 = D.32777 + D.32779;
  if (D.32780 == field) goto <D.32781>; else goto <D.32782>;
  <D.32781>:
  D.32784 = klass->field.first;
  i.478 = (unsigned int) i;
  D.32786 = D.32784 + i.478;
  D.32787 = D.32786 + 1;
  D.32783 = D.32787 | 67108864;
  return D.32783;
  <D.32782>:
  i = i + 1;
  <D.24200>:
  i.478 = (unsigned int) i;
  D.32788 = klass->field.count;
  if (i.478 < D.32788) goto <D.24199>; else goto <D.24201>;
  <D.24201>:
  monoeg_assertion_message ("* Assertion: should not be reached at %s:%d\n", "aot-compiler.c", 2035);
  D.32783 = 0;
  return D.32783;
}


emit_exception_info (struct MonoAotCompile * acfg)
{
  unsigned int D.32790;
  long unsigned int D.32791;
  long unsigned int D.32792;
  struct MonoCompile * * D.32793;
  long unsigned int D.32794;
  long unsigned int D.32795;
  struct MonoCompile * * D.32796;
  struct MonoCompile * D.32797;
  long unsigned int D.32800;
  gint32 * D.32801;
  unsigned int D.32802;
  int D.32803;
  unsigned int i.479;
  int D.32806;
  unsigned int D.32807;
  int D.32808;
  unsigned int D.32809;
  unsigned int D.32810;
  int D.32811;
  int i;
  char symbol[256];
  gint32 * offsets;

  try
    {
      D.32790 = acfg->nmethods;
      D.32791 = (long unsigned int) D.32790;
      D.32792 = D.32791 * 4;
      offsets = monoeg_malloc0 (D.32792);
      i = 0;
      goto <D.26185>;
      <D.26184>:
      D.32793 = acfg->cfgs;
      D.32794 = (long unsigned int) i;
      D.32795 = D.32794 * 8;
      D.32796 = D.32793 + D.32795;
      D.32797 = *D.32796;
      if (D.32797 != 0B) goto <D.32798>; else goto <D.32799>;
      <D.32798>:
      D.32793 = acfg->cfgs;
      D.32794 = (long unsigned int) i;
      D.32795 = D.32794 * 8;
      D.32796 = D.32793 + D.32795;
      D.32797 = *D.32796;
      emit_exception_debug_info (acfg, D.32797);
      D.32794 = (long unsigned int) i;
      D.32800 = D.32794 * 4;
      D.32801 = offsets + D.32800;
      D.32793 = acfg->cfgs;
      D.32794 = (long unsigned int) i;
      D.32795 = D.32794 * 8;
      D.32796 = D.32793 + D.32795;
      D.32797 = *D.32796;
      D.32802 = D.32797->ex_info_offset;
      D.32803 = (int) D.32802;
      *D.32801 = D.32803;
      goto <D.32804>;
      <D.32799>:
      D.32794 = (long unsigned int) i;
      D.32800 = D.32794 * 4;
      D.32801 = offsets + D.32800;
      *D.32801 = 0;
      <D.32804>:
      i = i + 1;
      <D.26185>:
      i.479 = (unsigned int) i;
      D.32790 = acfg->nmethods;
      if (i.479 < D.32790) goto <D.26184>; else goto <D.26186>;
      <D.26186>:
      sprintf (&symbol, "ex_info_offsets");
      emit_section_change (acfg, ".rodata", 1);
      emit_alignment (acfg, 8);
      emit_label (acfg, &symbol);
      D.32790 = acfg->nmethods;
      D.32806 = (int) D.32790;
      D.32807 = emit_offset_table (acfg, D.32806, 10, offsets);
      D.32808 = acfg->stats.offsets_size;
      D.32809 = (unsigned int) D.32808;
      D.32810 = D.32809 + D.32807;
      D.32811 = (int) D.32810;
      acfg->stats.offsets_size = D.32811;
      monoeg_g_free (offsets);
    }
  finally
    {
      symbol = {CLOBBER};
    }
}


emit_exception_debug_info (struct MonoAotCompile * acfg, struct MonoCompile * cfg)
{
  unsigned int D.32812;
  int D.32813;
  <unnamed-unsigned:15> D.32817;
  int D.32818;
  int D.32819;
  unsigned int D.32820;
  unsigned int debug_info_size.480;
  unsigned int D.32822;
  guint32 iftmp.481;
  int D.32826;
  int D.32827;
  unsigned int D.32829;
  unsigned int D.32830;
  unsigned int D.32831;
  unsigned int D.32832;
  long unsigned int D.32833;
  struct GSList * D.32834;
  _Bool D.32835;
  unsigned char D.32836;
  unsigned char D.32837;
  _Bool D.32838;
  int D.32839;
  int iftmp.482;
  int D.32844;
  int iftmp.483;
  short unsigned int D.32846;
  short unsigned int D.32847;
  int D.32851;
  int iftmp.484;
  int D.32856;
  int iftmp.485;
  unsigned char D.32858;
  unsigned char D.32859;
  int D.32863;
  int iftmp.486;
  unsigned char D.32865;
  int D.32869;
  int iftmp.487;
  guint8 * D.32871;
  int D.32875;
  int iftmp.488;
  unsigned char D.32877;
  int D.32881;
  guint8 * p.489;
  int flags.490;
  unsigned int encoded_len.491;
  unsigned int D.32887;
  int D.32888;
  unsigned int D.32890;
  int D.32891;
  short unsigned int D.32894;
  int D.32895;
  int D.32900;
  struct MonoExceptionClause * D.32901;
  long unsigned int D.32902;
  long unsigned int D.32903;
  unsigned int D.32904;
  int D.32905;
  struct MonoClass * D.32906;
  long unsigned int D.32910;
  long unsigned int D.32911;
  long unsigned int D.32912;
  long unsigned int D.32913;
  unsigned int D.32916;
  unsigned int D.32917;
  unsigned int D.32920;
  unsigned int D.32921;
  short unsigned int D.32925;
  short unsigned int D.32926;
  <unnamed-unsigned:15> D.32929;
  int D.32930;
  unsigned int D.32931;
  int D.32932;
  int D.32933;
  unsigned int D.32934;
  void * D.32937;
  long int D.32938;
  long int code.492;
  long int D.32940;
  int D.32941;
  struct MonoClass * D.32943;
  guint8 * p2.493;
  long int p2.494;
  long int buf2.495;
  long int D.32949;
  _Bool D.32950;
  long int D.32951;
  long int D.32952;
  long unsigned int D.32955;
  sizetype D.32956;
  guint8 * p.496;
  void * D.32959;
  long int D.32960;
  long int D.32961;
  int D.32962;
  void * D.32963;
  long int D.32964;
  long int D.32965;
  int D.32966;
  void * D.32967;
  long int D.32968;
  long int D.32969;
  int D.32970;
  int D.32971;
  short unsigned int D.32974;
  int D.32975;
  short unsigned int D.32976;
  int D.32977;
  unsigned int D.32978;
  int D.32979;
  short unsigned int D.32980;
  int D.32981;
  unsigned int D.32984;
  int D.32985;
  int D.32988;
  struct MonoDwarfLocListEntry * D.32991;
  long unsigned int D.32992;
  long unsigned int D.32993;
  int D.32994;
  _Bool D.32995;
  int D.32996;
  int D.32997;
  int D.33000;
  int D.33003;
  _Bool D.33004;
  long int D.33005;
  long int D.33006;
  int D.33010;
  unsigned char D.33014;
  unsigned char D.33015;
  _Bool D.33016;
  int D.33017;
  unsigned char D.33018;
  int D.33019;
  int D.33020;
  guint8 * p2.497;
  struct MonoMethod * D.33022;
  long int p2.498;
  long int buf2.499;
  long int D.33025;
  _Bool D.33026;
  long int D.33027;
  long int D.33028;
  long unsigned int D.33031;
  sizetype D.33032;
  guint8 * p.500;
  gboolean * D.33038;
  gboolean * D.33040;
  unsigned char D.33041;
  unsigned char D.33042;
  _Bool D.33043;
  long int D.33044;
  long int D.33045;
  struct MonoGenericInst * D.33048;
  <unnamed-unsigned:22> D.33051;
  int D.33052;
  long unsigned int D.33053;
  gboolean * D.33054;
  int D.33055;
  int D.33056;
  struct MonoGenericInst * D.33058;
  gboolean * D.33061;
  int D.33062;
  int D.33066;
  int D.33067;
  int D.33068;
  int D.33069;
  int * D.33070;
  long unsigned int D.33071;
  long unsigned int D.33072;
  int * D.33073;
  int D.33074;
  unsigned int buf_size.501;
  _Bool D.33076;
  long int D.33077;
  long int D.33078;
  int debug_info_size.502;
  long unsigned int D.33084;
  guint8 * debug_info.503;
  sizetype D.33086;
  guint8 * p.504;
  int D.33090;
  guint8 * p.505;
  long unsigned int p.506;
  long unsigned int D.33093;
  long unsigned int D.33094;
  sizetype D.33095;
  guint8 * p.507;
  int D.33097;
  unsigned int D.33098;
  long int p.508;
  long int buf.509;
  long int D.33101;
  unsigned int D.33102;
  unsigned int D.33103;
  int D.33104;
  long int D.33105;
  _Bool D.33106;
  long int D.33107;
  long int D.33108;
  guint32 iftmp.510;
  unsigned int D.33115;
  unsigned int D.33116;
  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.32812 = get_method_index (acfg, method);
      method_index = (int) D.32812;
      D.32813 = acfg->aot_opts.nodebug;
      if (D.32813 == 0) goto <D.32814>; else goto <D.32815>;
      <D.32814>:
      mono_debug_serialize_debug_info (cfg, &debug_info, &debug_info_size);
      goto <D.32816>;
      <D.32815>:
      debug_info = 0B;
      debug_info_size = 0;
      <D.32816>:
      seq_points = cfg->seq_point_info;
      D.32817 = header->num_clauses;
      D.32818 = (int) D.32817;
      D.32819 = D.32818 * 256;
      D.32820 = (unsigned int) D.32819;
      debug_info_size.480 = debug_info_size;
      D.32822 = D.32820 + debug_info_size.480;
      if (seq_points != 0B) goto <D.32824>; else goto <D.32825>;
      <D.32824>:
      D.32826 = seq_points->len;
      D.32827 = D.32826 * 128;
      iftmp.481 = (guint32) D.32827;
      goto <D.32828>;
      <D.32825>:
      iftmp.481 = 0;
      <D.32828>:
      D.32829 = D.32822 + iftmp.481;
      D.32830 = cfg->gc_map_size;
      D.32831 = D.32829 + D.32830;
      D.32832 = D.32831 + 2048;
      buf_size = (int) D.32832;
      D.32833 = (long unsigned int) buf_size;
      buf = monoeg_malloc (D.32833);
      p = buf;
      D.32834 = cfg->unwind_ops;
      D.32835 = D.32834 != 0B;
      use_unwind_ops = (gboolean) D.32835;
      D.32836 = BIT_FIELD_REF <*jinfo, 8, 272>;
      D.32837 = D.32836 & 2;
      D.32838 = D.32837 != 0;
      D.32839 = (int) D.32838;
      if (use_unwind_ops != 0) goto <D.32841>; else goto <D.32842>;
      <D.32841>:
      iftmp.482 = 2;
      goto <D.32843>;
      <D.32842>:
      iftmp.482 = 0;
      <D.32843>:
      D.32844 = D.32839 | iftmp.482;
      D.32846 = BIT_FIELD_REF <*header, 16, 112>;
      D.32847 = D.32846 & 32767;
      if (D.32847 != 0) goto <D.32848>; else goto <D.32849>;
      <D.32848>:
      iftmp.483 = 4;
      goto <D.32850>;
      <D.32849>:
      iftmp.483 = 0;
      <D.32850>:
      D.32851 = D.32844 | iftmp.483;
      if (seq_points != 0B) goto <D.32853>; else goto <D.32854>;
      <D.32853>:
      iftmp.484 = 8;
      goto <D.32855>;
      <D.32854>:
      iftmp.484 = 0;
      <D.32855>:
      D.32856 = D.32851 | iftmp.484;
      D.32858 = BIT_FIELD_REF <*cfg, 8, 5608>;
      D.32859 = D.32858 & 1;
      if (D.32859 != 0) goto <D.32860>; else goto <D.32861>;
      <D.32860>:
      iftmp.485 = 16;
      goto <D.32862>;
      <D.32861>:
      iftmp.485 = 0;
      <D.32862>:
      D.32863 = D.32856 | iftmp.485;
      D.32836 = BIT_FIELD_REF <*jinfo, 8, 272>;
      D.32865 = D.32836 & 4;
      if (D.32865 != 0) goto <D.32866>; else goto <D.32867>;
      <D.32866>:
      iftmp.486 = 32;
      goto <D.32868>;
      <D.32867>:
      iftmp.486 = 0;
      <D.32868>:
      D.32869 = D.32863 | iftmp.486;
      D.32871 = cfg->gc_map;
      if (D.32871 != 0B) goto <D.32872>; else goto <D.32873>;
      <D.32872>:
      iftmp.487 = 64;
      goto <D.32874>;
      <D.32873>:
      iftmp.487 = 0;
      <D.32874>:
      D.32875 = D.32869 | iftmp.487;
      D.32836 = BIT_FIELD_REF <*jinfo, 8, 272>;
      D.32877 = D.32836 & 8;
      if (D.32877 != 0) goto <D.32878>; else goto <D.32879>;
      <D.32878>:
      iftmp.488 = 128;
      goto <D.32880>;
      <D.32879>:
      iftmp.488 = 0;
      <D.32880>:
      D.32881 = D.32875 | iftmp.488;
      flags = (guint32) D.32881;
      p.489 = p;
      flags.490 = (int) flags;
      encode_value (flags.490, p.489, &p);
      if (use_unwind_ops != 0) goto <D.32884>; else goto <D.32885>;
      <D.32884>:
      {
        guint32 encoded_len;
        guint8 * encoded;

        try
          {
            D.32834 = cfg->unwind_ops;
            encoded = mono_unwind_ops_encode (D.32834, &encoded_len);
            p.489 = p;
            encoded_len.491 = encoded_len;
            D.32887 = get_unwind_info_offset (acfg, encoded, encoded_len.491);
            D.32888 = (int) D.32887;
            encode_value (D.32888, p.489, &p);
            monoeg_g_free (encoded);
          }
        finally
          {
            encoded_len = {CLOBBER};
          }
      }
      goto <D.32889>;
      <D.32885>:
      p.489 = p;
      D.32890 = jinfo->used_regs;
      D.32891 = (int) D.32890;
      encode_value (D.32891, p.489, &p);
      <D.32889>:
      D.32836 = BIT_FIELD_REF <*jinfo, 8, 272>;
      D.32865 = D.32836 & 4;
      if (D.32865 != 0) goto <D.32892>; else goto <D.32893>;
      <D.32892>:
      {
        struct MonoTryBlockHoleTableJitInfo * table;

        table = mono_jit_info_get_try_block_hole_table_info (jinfo);
        p.489 = p;
        D.32894 = table->num_holes;
        D.32895 = (int) D.32894;
        encode_value (D.32895, p.489, &p);
      }
      <D.32893>:
      D.32858 = BIT_FIELD_REF <*cfg, 8, 5608>;
      D.32859 = D.32858 & 1;
      if (D.32859 != 0) goto <D.32896>; else goto <D.32897>;
      <D.32896>:
      D.32846 = BIT_FIELD_REF <*header, 16, 112>;
      D.32847 = D.32846 & 32767;
      if (D.32847 != 0) goto <D.32898>; else goto <D.32899>;
      <D.32898>:
      p.489 = p;
      D.32817 = header->num_clauses;
      D.32900 = (int) D.32817;
      encode_value (D.32900, p.489, &p);
      <D.32899>:
      k = 0;
      goto <D.25510>;
      <D.25509>:
      {
        struct MonoExceptionClause * clause;

        D.32901 = header->clauses;
        D.32902 = (long unsigned int) k;
        D.32903 = D.32902 * 32;
        clause = D.32901 + D.32903;
        p.489 = p;
        D.32904 = clause->flags;
        D.32905 = (int) D.32904;
        encode_value (D.32905, p.489, &p);
        D.32906 = clause->data.catch_class;
        if (D.32906 != 0B) goto <D.32907>; else goto <D.32908>;
        <D.32907>:
        p.489 = p;
        encode_value (1, p.489, &p);
        p.489 = p;
        D.32906 = clause->data.catch_class;
        encode_klass_ref (acfg, D.32906, p.489, &p);
        goto <D.32909>;
        <D.32908>:
        p.489 = p;
        encode_value (0, p.489, &p);
        <D.32909>:
        i = 0;
        goto <D.25507>;
        <D.25506>:
        {
          gint32 cindex1;
          struct MonoExceptionClause * clause1;
          gint32 cindex2;
          struct MonoExceptionClause * clause2;

          cindex1 = k;
          D.32901 = header->clauses;
          D.32910 = (long unsigned int) cindex1;
          D.32911 = D.32910 * 32;
          clause1 = D.32901 + D.32911;
          cindex2 = i;
          D.32901 = header->clauses;
          D.32912 = (long unsigned int) cindex2;
          D.32913 = D.32912 * 32;
          clause2 = D.32901 + D.32913;
          if (cindex1 != cindex2) goto <D.32914>; else goto <D.32915>;
          <D.32914>:
          D.32916 = clause1->try_offset;
          D.32917 = clause2->try_offset;
          if (D.32916 >= D.32917) goto <D.32918>; else goto <D.32919>;
          <D.32918>:
          D.32920 = clause1->handler_offset;
          D.32921 = clause2->handler_offset;
          if (D.32920 <= D.32921) goto <D.32922>; else goto <D.32923>;
          <D.32922>:
          p.489 = p;
          encode_value (i, p.489, &p);
          <D.32923>:
          <D.32919>:
          <D.32915>:
        }
        i = i + 1;
        <D.25507>:
        D.32817 = header->num_clauses;
        D.32818 = (int) D.32817;
        if (D.32818 > i) goto <D.25506>; else goto <D.25508>;
        <D.25508>:
        p.489 = p;
        encode_value (-1, p.489, &p);
      }
      k = k + 1;
      <D.25510>:
      D.32817 = header->num_clauses;
      D.32818 = (int) D.32817;
      if (D.32818 > k) goto <D.25509>; else goto <D.25511>;
      <D.25511>:
      goto <D.32924>;
      <D.32897>:
      D.32925 = BIT_FIELD_REF <*jinfo, 16, 256>;
      D.32926 = D.32925 & 32767;
      if (D.32926 != 0) goto <D.32927>; else goto <D.32928>;
      <D.32927>:
      p.489 = p;
      D.32929 = jinfo->num_clauses;
      D.32930 = (int) D.32929;
      encode_value (D.32930, p.489, &p);
      <D.32928>:
      k = 0;
      goto <D.25517>;
      <D.25516>:
      {
        struct MonoJitExceptionInfo * ei;

        ei = &jinfo->clauses[k];
        p.489 = p;
        D.32931 = ei->flags;
        D.32932 = (int) D.32931;
        encode_value (D.32932, p.489, &p);
        p.489 = p;
        D.32933 = ei->exvar_offset;
        encode_value (D.32933, p.489, &p);
        D.32931 = ei->flags;
        D.32934 = D.32931 + 4294967295;
        if (D.32934 <= 1) goto <D.32935>; else goto <D.32936>;
        <D.32935>:
        p.489 = p;
        D.32937 = ei->data.filter;
        D.32938 = (long int) D.32937;
        code.492 = (long int) code;
        D.32940 = D.32938 - code.492;
        D.32941 = (int) D.32940;
        encode_value (D.32941, p.489, &p);
        goto <D.32942>;
        <D.32936>:
        D.32943 = ei->data.catch_class;
        if (D.32943 != 0B) goto <D.32944>; else goto <D.32945>;
        <D.32944>:
        {
          guint8 * buf2;
          guint8 * p2;
          int len;

          try
            {
              buf2 = monoeg_malloc (4096);
              p2 = buf2;
              p2.493 = p2;
              D.32943 = ei->data.catch_class;
              encode_klass_ref (acfg, D.32943, p2.493, &p2);
              p2.493 = p2;
              p2.494 = (long int) p2.493;
              buf2.495 = (long int) buf2;
              D.32949 = p2.494 - buf2.495;
              len = (int) D.32949;
              D.32950 = len > 4095;
              D.32951 = (long int) D.32950;
              D.32952 = __builtin_expect (D.32951, 0);
              if (D.32952 != 0) goto <D.32953>; else goto <D.32954>;
              <D.32953>:
              monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "aot-compiler.c", 5325, "len < 4096");
              <D.32954>:
              p.489 = p;
              encode_value (len, p.489, &p);
              D.32955 = (long unsigned int) len;
              p.489 = p;
              memcpy (p.489, buf2, D.32955);
              p.489 = p;
              p2.493 = p2;
              p2.494 = (long int) p2.493;
              buf2.495 = (long int) buf2;
              D.32949 = p2.494 - buf2.495;
              D.32956 = (sizetype) D.32949;
              p.496 = p.489 + D.32956;
              p = p.496;
              monoeg_g_free (buf2);
            }
          finally
            {
              p2 = {CLOBBER};
            }
        }
        goto <D.32958>;
        <D.32945>:
        p.489 = p;
        encode_value (0, p.489, &p);
        <D.32958>:
        <D.32942>:
        p.489 = p;
        D.32959 = ei->try_start;
        D.32960 = (long int) D.32959;
        code.492 = (long int) code;
        D.32961 = D.32960 - code.492;
        D.32962 = (int) D.32961;
        encode_value (D.32962, p.489, &p);
        p.489 = p;
        D.32963 = ei->try_end;
        D.32964 = (long int) D.32963;
        code.492 = (long int) code;
        D.32965 = D.32964 - code.492;
        D.32966 = (int) D.32965;
        encode_value (D.32966, p.489, &p);
        p.489 = p;
        D.32967 = ei->handler_start;
        D.32968 = (long int) D.32967;
        code.492 = (long int) code;
        D.32969 = D.32968 - code.492;
        D.32970 = (int) D.32969;
        encode_value (D.32970, p.489, &p);
      }
      k = k + 1;
      <D.25517>:
      D.32929 = jinfo->num_clauses;
      D.32971 = (int) D.32929;
      if (D.32971 > k) goto <D.25516>; else goto <D.25518>;
      <D.25518>:
      <D.32924>:
      D.32836 = BIT_FIELD_REF <*jinfo, 8, 272>;
      D.32865 = D.32836 & 4;
      if (D.32865 != 0) goto <D.32972>; else goto <D.32973>;
      <D.32972>:
      {
        struct MonoTryBlockHoleTableJitInfo * table;

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

          hole = &table->holes[i];
          p.489 = p;
          D.32974 = hole->clause;
          D.32975 = (int) D.32974;
          encode_value (D.32975, p.489, &p);
          p.489 = p;
          D.32976 = hole->length;
          D.32977 = (int) D.32976;
          encode_value (D.32977, p.489, &p);
          p.489 = p;
          D.32978 = hole->offset;
          D.32979 = (int) D.32978;
          encode_value (D.32979, p.489, &p);
        }
        i = i + 1;
        <D.25522>:
        D.32980 = table->num_holes;
        D.32981 = (int) D.32980;
        if (D.32981 > i) goto <D.25521>; else goto <D.25523>;
        <D.25523>:
      }
      <D.32973>:
      D.32836 = BIT_FIELD_REF <*jinfo, 8, 272>;
      D.32877 = D.32836 & 8;
      if (D.32877 != 0) goto <D.32982>; else goto <D.32983>;
      <D.32982>:
      {
        struct MonoArchEHJitInfo * eh_info;

        eh_info = mono_jit_info_get_arch_eh_info (jinfo);
        p.489 = p;
        D.32984 = eh_info->stack_size;
        D.32985 = (int) D.32984;
        encode_value (D.32985, p.489, &p);
      }
      <D.32983>:
      D.32836 = BIT_FIELD_REF <*jinfo, 8, 272>;
      D.32837 = D.32836 & 2;
      if (D.32837 != 0) goto <D.32986>; else goto <D.32987>;
      <D.32986>:
      {
        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;
            p.489 = p;
            D.32988 = gi->nlocs;
            encode_value (D.32988, p.489, &p);
            D.32988 = gi->nlocs;
            if (D.32988 != 0) goto <D.32989>; else goto <D.32990>;
            <D.32989>:
            i = 0;
            goto <D.25533>;
            <D.25532>:
            {
              struct MonoDwarfLocListEntry * entry;

              D.32991 = gi->locations;
              D.32992 = (long unsigned int) i;
              D.32993 = D.32992 * 20;
              entry = D.32991 + D.32993;
              p.489 = p;
              D.32994 = entry->is_reg;
              D.32995 = D.32994 != 0;
              D.32996 = (int) D.32995;
              encode_value (D.32996, p.489, &p);
              p.489 = p;
              D.32997 = entry->reg;
              encode_value (D.32997, p.489, &p);
              D.32994 = entry->is_reg;
              if (D.32994 == 0) goto <D.32998>; else goto <D.32999>;
              <D.32998>:
              p.489 = p;
              D.33000 = entry->offset;
              encode_value (D.33000, p.489, &p);
              <D.32999>:
              if (i == 0) goto <D.33001>; else goto <D.33002>;
              <D.33001>:
              D.33003 = entry->from;
              D.33004 = D.33003 != 0;
              D.33005 = (long int) D.33004;
              D.33006 = __builtin_expect (D.33005, 0);
              if (D.33006 != 0) goto <D.33007>; else goto <D.33008>;
              <D.33007>:
              monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "aot-compiler.c", 5376, "entry->from == 0");
              <D.33008>:
              goto <D.33009>;
              <D.33002>:
              p.489 = p;
              D.33003 = entry->from;
              encode_value (D.33003, p.489, &p);
              <D.33009>:
              p.489 = p;
              D.33010 = entry->to;
              encode_value (D.33010, p.489, &p);
            }
            i = i + 1;
            <D.25533>:
            D.32988 = gi->nlocs;
            if (D.32988 > i) goto <D.25532>; else goto <D.25534>;
            <D.25534>:
            goto <D.33011>;
            <D.32990>:
            D.32858 = BIT_FIELD_REF <*cfg, 8, 5608>;
            D.32859 = D.32858 & 1;
            if (D.32859 == 0) goto <D.33012>; else goto <D.33013>;
            <D.33012>:
            p.489 = p;
            D.33014 = BIT_FIELD_REF <*gi, 8, 232>;
            D.33015 = D.33014 & 1;
            D.33016 = D.33015 != 0;
            D.33017 = (int) D.33016;
            encode_value (D.33017, p.489, &p);
            p.489 = p;
            D.33018 = gi->this_reg;
            D.33019 = (int) D.33018;
            encode_value (D.33019, p.489, &p);
            p.489 = p;
            D.33020 = gi->this_offset;
            encode_value (D.33020, p.489, &p);
            <D.33013>:
            <D.33011>:
            buf2 = monoeg_malloc (4096);
            p2 = buf2;
            p2.497 = p2;
            D.33022 = jinfo->d.method;
            encode_method_ref (acfg, D.33022, p2.497, &p2);
            p2.497 = p2;
            p2.498 = (long int) p2.497;
            buf2.499 = (long int) buf2;
            D.33025 = p2.498 - buf2.499;
            len = (int) D.33025;
            D.33026 = len > 4095;
            D.33027 = (long int) D.33026;
            D.33028 = __builtin_expect (D.33027, 0);
            if (D.33028 != 0) goto <D.33029>; else goto <D.33030>;
            <D.33029>:
            monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "aot-compiler.c", 5397, "len < 4096");
            <D.33030>:
            p.489 = p;
            encode_value (len, p.489, &p);
            D.33031 = (long unsigned int) len;
            p.489 = p;
            memcpy (p.489, buf2, D.33031);
            p.489 = p;
            p2.497 = p2;
            p2.498 = (long int) p2.497;
            buf2.499 = (long int) buf2;
            D.33025 = p2.498 - buf2.499;
            D.33032 = (sizetype) D.33025;
            p.500 = p.489 + D.33032;
            p = p.500;
            monoeg_g_free (buf2);
            if (gsctx != 0B) goto <D.33037>; else goto <D.33034>;
            <D.33037>:
            D.33038 = gsctx->var_is_vt;
            if (D.33038 != 0B) goto <D.33035>; else goto <D.33039>;
            <D.33039>:
            D.33040 = gsctx->mvar_is_vt;
            if (D.33040 != 0B) goto <D.33035>; else goto <D.33034>;
            <D.33035>:
            {
              struct MonoMethodInflated * inflated;
              struct MonoGenericContext * context;
              struct MonoGenericInst * inst;

              D.33022 = jinfo->d.method;
              D.33041 = BIT_FIELD_REF <*D.33022, 8, 264>;
              D.33042 = D.33041 & 16;
              D.33043 = D.33042 == 0;
              D.33044 = (long int) D.33043;
              D.33045 = __builtin_expect (D.33044, 0);
              if (D.33045 != 0) goto <D.33046>; else goto <D.33047>;
              <D.33046>:
              monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "aot-compiler.c", 5408, "jinfo->d.method->is_inflated");
              <D.33047>:
              inflated = jinfo->d.method;
              context = &inflated->context;
              p.489 = p;
              encode_value (1, p.489, &p);
              D.33048 = context->class_inst;
              if (D.33048 != 0B) goto <D.33049>; else goto <D.33050>;
              <D.33049>:
              inst = context->class_inst;
              p.489 = p;
              D.33051 = inst->type_argc;
              D.33052 = (int) D.33051;
              encode_value (D.33052, p.489, &p);
              i = 0;
              goto <D.25539>;
              <D.25538>:
              p.489 = p;
              D.33038 = gsctx->var_is_vt;
              D.32992 = (long unsigned int) i;
              D.33053 = D.32992 * 4;
              D.33054 = D.33038 + D.33053;
              D.33055 = *D.33054;
              encode_value (D.33055, p.489, &p);
              i = i + 1;
              <D.25539>:
              D.33051 = inst->type_argc;
              D.33056 = (int) D.33051;
              if (D.33056 > i) goto <D.25538>; else goto <D.25540>;
              <D.25540>:
              goto <D.33057>;
              <D.33050>:
              p.489 = p;
              encode_value (0, p.489, &p);
              <D.33057>:
              D.33058 = context->method_inst;
              if (D.33058 != 0B) goto <D.33059>; else goto <D.33060>;
              <D.33059>:
              inst = context->method_inst;
              p.489 = p;
              D.33051 = inst->type_argc;
              D.33052 = (int) D.33051;
              encode_value (D.33052, p.489, &p);
              i = 0;
              goto <D.25542>;
              <D.25541>:
              p.489 = p;
              D.33040 = gsctx->mvar_is_vt;
              D.32992 = (long unsigned int) i;
              D.33053 = D.32992 * 4;
              D.33061 = D.33040 + D.33053;
              D.33062 = *D.33061;
              encode_value (D.33062, p.489, &p);
              i = i + 1;
              <D.25542>:
              D.33051 = inst->type_argc;
              D.33056 = (int) D.33051;
              if (D.33056 > i) goto <D.25541>; else goto <D.25543>;
              <D.25543>:
              goto <D.33063>;
              <D.33060>:
              p.489 = p;
              encode_value (0, p.489, &p);
              <D.33063>:
            }
            goto <D.33036>;
            <D.33034>:
            p.489 = p;
            encode_value (0, p.489, &p);
            <D.33036>:
          }
        finally
          {
            p2 = {CLOBBER};
          }
      }
      <D.32987>:
      if (seq_points != 0B) goto <D.33064>; else goto <D.33065>;
      <D.33064>:
      {
        int il_offset;
        int native_offset;
        int last_il_offset;
        int last_native_offset;
        int j;

        p.489 = p;
        D.32826 = seq_points->len;
        encode_value (D.32826, p.489, &p);
        last_native_offset = 0;
        last_il_offset = last_native_offset;
        i = 0;
        goto <D.25554>;
        <D.25553>:
        {
          struct SeqPoint * sp;

          sp = &seq_points->seq_points[i];
          il_offset = sp->il_offset;
          native_offset = sp->native_offset;
          p.489 = p;
          D.33066 = il_offset - last_il_offset;
          encode_value (D.33066, p.489, &p);
          p.489 = p;
          D.33067 = native_offset - last_native_offset;
          encode_value (D.33067, p.489, &p);
          last_il_offset = il_offset;
          last_native_offset = native_offset;
          p.489 = p;
          D.33068 = sp->flags;
          encode_value (D.33068, p.489, &p);
          p.489 = p;
          D.33069 = sp->next_len;
          encode_value (D.33069, p.489, &p);
          j = 0;
          goto <D.25551>;
          <D.25550>:
          p.489 = p;
          D.33070 = sp->next;
          D.33071 = (long unsigned int) j;
          D.33072 = D.33071 * 4;
          D.33073 = D.33070 + D.33072;
          D.33074 = *D.33073;
          encode_value (D.33074, p.489, &p);
          j = j + 1;
          <D.25551>:
          D.33069 = sp->next_len;
          if (D.33069 > j) goto <D.25550>; else goto <D.25552>;
          <D.25552>:
        }
        i = i + 1;
        <D.25554>:
        D.32826 = seq_points->len;
        if (D.32826 > i) goto <D.25553>; else goto <D.25555>;
        <D.25555>:
      }
      <D.33065>:
      buf_size.501 = (unsigned int) buf_size;
      debug_info_size.480 = debug_info_size;
      D.33076 = buf_size.501 <= debug_info_size.480;
      D.33077 = (long int) D.33076;
      D.33078 = __builtin_expect (D.33077, 0);
      if (D.33078 != 0) goto <D.33079>; else goto <D.33080>;
      <D.33079>:
      monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "aot-compiler.c", 5457, "debug_info_size < buf_size");
      <D.33080>:
      p.489 = p;
      debug_info_size.480 = debug_info_size;
      debug_info_size.502 = (int) debug_info_size.480;
      encode_value (debug_info_size.502, p.489, &p);
      debug_info_size.480 = debug_info_size;
      if (debug_info_size.480 != 0) goto <D.33082>; else goto <D.33083>;
      <D.33082>:
      debug_info_size.480 = debug_info_size;
      D.33084 = (long unsigned int) debug_info_size.480;
      debug_info.503 = debug_info;
      p.489 = p;
      memcpy (p.489, debug_info.503, D.33084);
      p.489 = p;
      debug_info_size.480 = debug_info_size;
      D.33086 = (sizetype) debug_info_size.480;
      p.504 = p.489 + D.33086;
      p = p.504;
      debug_info.503 = debug_info;
      monoeg_g_free (debug_info.503);
      <D.33083>:
      D.32871 = cfg->gc_map;
      if (D.32871 != 0B) goto <D.33088>; else goto <D.33089>;
      <D.33088>:
      p.489 = p;
      D.32830 = cfg->gc_map_size;
      D.33090 = (int) D.32830;
      encode_value (D.33090, p.489, &p);
      goto <D.25557>;
      <D.25556>:
      p.489 = p;
      p.505 = p.489 + 1;
      p = p.505;
      <D.25557>:
      p.489 = p;
      p.506 = (long unsigned int) p.489;
      D.33093 = p.506 & 3;
      if (D.33093 != 0) goto <D.25556>; else goto <D.25558>;
      <D.25558>:
      D.32830 = cfg->gc_map_size;
      D.33094 = (long unsigned int) D.32830;
      D.32871 = cfg->gc_map;
      p.489 = p;
      memcpy (p.489, D.32871, D.33094);
      p.489 = p;
      D.32830 = cfg->gc_map_size;
      D.33095 = (sizetype) D.32830;
      p.507 = p.489 + D.33095;
      p = p.507;
      <D.33089>:
      D.33097 = acfg->stats.ex_info_size;
      D.33098 = (unsigned int) D.33097;
      p.489 = p;
      p.508 = (long int) p.489;
      buf.509 = (long int) buf;
      D.33101 = p.508 - buf.509;
      D.33102 = (unsigned int) D.33101;
      D.33103 = D.33098 + D.33102;
      D.33104 = (int) D.33103;
      acfg->stats.ex_info_size = D.33104;
      p.489 = p;
      p.508 = (long int) p.489;
      buf.509 = (long int) buf;
      D.33101 = p.508 - buf.509;
      D.33105 = (long int) buf_size;
      D.33106 = D.33101 >= D.33105;
      D.33107 = (long int) D.33106;
      D.33108 = __builtin_expect (D.33107, 0);
      if (D.33108 != 0) goto <D.33109>; else goto <D.33110>;
      <D.33109>:
      monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "aot-compiler.c", 5478, "p - buf < buf_size");
      <D.33110>:
      D.32871 = cfg->gc_map;
      if (D.32871 != 0B) goto <D.33112>; else goto <D.33113>;
      <D.33112>:
      iftmp.510 = 4;
      goto <D.33114>;
      <D.33113>:
      iftmp.510 = 1;
      <D.33114>:
      p.489 = p;
      p.508 = (long int) p.489;
      buf.509 = (long int) buf;
      D.33101 = p.508 - buf.509;
      D.33115 = (unsigned int) D.33101;
      D.33116 = add_to_blob_aligned (acfg, buf, D.33115, iftmp.510);
      cfg->ex_info_offset = D.33116;
      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.33117;
  struct MonoDynamicStream * D.33120;
  unsigned int D.33121;
  unsigned int D.33124;
  guint32 D.33125;
  char buf[4];
  guint32 count;

  try
    {
      buf = {};
      D.33117 = acfg->blob.alloc_size;
      if (D.33117 == 0) goto <D.33118>; else goto <D.33119>;
      <D.33118>:
      D.33120 = &acfg->blob;
      stream_init (D.33120);
      <D.33119>:
      D.33121 = acfg->blob.index;
      count = D.33121 % align;
      if (count != 0) goto <D.33122>; else goto <D.33123>;
      <D.33122>:
      D.33124 = 4 - count;
      D.33120 = &acfg->blob;
      add_stream_data (D.33120, &buf, D.33124);
      <D.33123>:
      D.33120 = &acfg->blob;
      D.33125 = add_stream_data (D.33120, data, data_len);
      return D.33125;
    }
  finally
    {
      buf = {CLOBBER};
    }
}


emit_unwind_info (struct MonoAotCompile * acfg)
{
  struct GPtrArray * D.33128;
  void * * D.33129;
  long unsigned int D.33130;
  long unsigned int D.33131;
  void * * D.33132;
  void * D.33133;
  long int D.33134;
  guint8 * p.511;
  unsigned int unwind_info_len.512;
  int unwind_info_len.513;
  long int p.514;
  long int buf.515;
  long int D.33140;
  int D.33141;
  int unwind_info_len.516;
  int D.33143;
  unsigned int D.33144;
  unsigned int D.33145;
  unsigned int D.33146;
  unsigned int D.33147;
  int D.33148;
  unsigned int i.517;
  unsigned int D.33150;
  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.26198>;
      <D.26197>:
      {
        guint32 index;
        guint8 * unwind_info;
        guint32 unwind_info_len;
        guint8 buf[16];
        guint8 * p;

        try
          {
            D.33128 = acfg->unwind_ops;
            D.33129 = D.33128->pdata;
            D.33130 = (long unsigned int) i;
            D.33131 = D.33130 * 8;
            D.33132 = D.33129 + D.33131;
            D.33133 = *D.33132;
            D.33134 = (long int) D.33133;
            index = (guint32) D.33134;
            unwind_info = mono_get_cached_unwind_info (index, &unwind_info_len);
            p = &buf;
            p.511 = p;
            unwind_info_len.512 = unwind_info_len;
            unwind_info_len.513 = (int) unwind_info_len.512;
            encode_value (unwind_info_len.513, p.511, &p);
            p.511 = p;
            p.514 = (long int) p.511;
            buf.515 = (long int) &buf;
            D.33140 = p.514 - buf.515;
            D.33141 = (int) D.33140;
            emit_bytes (acfg, &buf, D.33141);
            unwind_info_len.512 = unwind_info_len;
            unwind_info_len.516 = (int) unwind_info_len.512;
            emit_bytes (acfg, unwind_info, unwind_info_len.516);
            D.33143 = acfg->stats.unwind_info_size;
            D.33144 = (unsigned int) D.33143;
            p.511 = p;
            p.514 = (long int) p.511;
            buf.515 = (long int) &buf;
            D.33140 = p.514 - buf.515;
            D.33145 = (unsigned int) D.33140;
            unwind_info_len.512 = unwind_info_len;
            D.33146 = D.33145 + unwind_info_len.512;
            D.33147 = D.33144 + D.33146;
            D.33148 = (int) D.33147;
            acfg->stats.unwind_info_size = D.33148;
          }
        finally
          {
            unwind_info_len = {CLOBBER};
            buf = {CLOBBER};
            p = {CLOBBER};
          }
      }
      i = i + 1;
      <D.26198>:
      i.517 = (unsigned int) i;
      D.33128 = acfg->unwind_ops;
      D.33150 = D.33128->len;
      if (i.517 < D.33150) goto <D.26197>; else goto <D.26199>;
      <D.26199>:
    }
  finally
    {
      symbol = {CLOBBER};
    }
}


emit_class_info (struct MonoAotCompile * acfg)
{
  struct MonoImage * D.33151;
  <unnamed-unsigned:24> D.33152;
  long unsigned int D.33153;
  long unsigned int D.33154;
  long unsigned int D.33155;
  long unsigned int D.33156;
  gint32 * D.33157;
  int D.33158;
  int D.33159;
  unsigned int D.33160;
  unsigned int D.33161;
  int D.33162;
  int D.33163;
  unsigned int D.33164;
  int D.33165;
  unsigned int D.33166;
  unsigned int D.33167;
  int D.33168;
  int i;
  char symbol[256];
  gint32 * offsets;

  try
    {
      D.33151 = acfg->image;
      D.33152 = D.33151->tables[2].rows;
      D.33153 = (long unsigned int) D.33152;
      D.33154 = D.33153 * 4;
      offsets = monoeg_malloc0 (D.33154);
      i = 0;
      goto <D.26207>;
      <D.26206>:
      D.33155 = (long unsigned int) i;
      D.33156 = D.33155 * 4;
      D.33157 = offsets + D.33156;
      D.33158 = i + 1;
      D.33159 = D.33158 | 33554432;
      D.33160 = (unsigned int) D.33159;
      D.33161 = emit_klass_info (acfg, D.33160);
      D.33162 = (int) D.33161;
      *D.33157 = D.33162;
      i = i + 1;
      <D.26207>:
      D.33151 = acfg->image;
      D.33152 = D.33151->tables[2].rows;
      D.33163 = (int) D.33152;
      if (D.33163 > i) goto <D.26206>; else goto <D.26208>;
      <D.26208>:
      sprintf (&symbol, "class_info_offsets");
      emit_section_change (acfg, ".rodata", 1);
      emit_alignment (acfg, 8);
      emit_label (acfg, &symbol);
      D.33151 = acfg->image;
      D.33152 = D.33151->tables[2].rows;
      D.33163 = (int) D.33152;
      D.33164 = emit_offset_table (acfg, D.33163, 10, offsets);
      D.33165 = acfg->stats.offsets_size;
      D.33166 = (unsigned int) D.33165;
      D.33167 = D.33166 + D.33164;
      D.33168 = (int) D.33167;
      acfg->stats.offsets_size = D.33168;
      monoeg_g_free (offsets);
    }
  finally
    {
      symbol = {CLOBBER};
    }
}


emit_klass_info (struct MonoAotCompile * acfg, guint32 token)
{
  struct MonoImage * D.33169;
  long unsigned int D.33172;
  guint8 * p.518;
  long int p.519;
  long int buf.520;
  long int D.33176;
  unsigned int D.33177;
  unsigned int D.33178;
  guint32 D.33179;
  int D.33180;
  int D.33181;
  _Bool D.33182;
  long int D.33183;
  long int D.33184;
  unsigned char D.33187;
  signed char D.33188;
  _Bool D.33189;
  long int D.33190;
  long int D.33191;
  int D.33194;
  _Bool D.33195;
  struct MonoMethod * * D.33196;
  long unsigned int D.33197;
  long unsigned int D.33198;
  struct MonoMethod * * D.33199;
  struct MonoMethodSignature * D.33202;
  unsigned char D.33203;
  unsigned char D.33204;
  struct GHashTable * D.33207;
  void * D.33208;
  struct MonoGenericContainer * D.33213;
  gboolean iftmp.521;
  int D.33219;
  int D.33220;
  <unnamed-unsigned:1> D.33221;
  int D.33222;
  int D.33223;
  int D.33224;
  <unnamed-unsigned:1> D.33225;
  int D.33226;
  int D.33227;
  int D.33228;
  <unnamed-unsigned:1> D.33229;
  int D.33230;
  int D.33231;
  int iftmp.522;
  struct MonoClassExt * D.33235;
  struct GList * D.33237;
  int D.33239;
  int D.33240;
  int D.33241;
  <unnamed-unsigned:1> D.33242;
  int D.33243;
  int D.33244;
  int D.33245;
  <unnamed-unsigned:1> D.33246;
  int D.33247;
  int D.33248;
  int D.33249;
  <unnamed-unsigned:1> D.33250;
  int D.33251;
  int D.33252;
  unsigned char D.33253;
  struct MonoMethod * D.33256;
  unsigned char D.33257;
  unsigned char D.33258;
  struct MonoMethod * D.33261;
  int D.33262;
  int D.33263;
  <unnamed-unsigned:4> D.33264;
  int D.33265;
  unsigned char D.33266;
  int D.33267;
  int D.33271;
  unsigned int D.33272;
  unsigned int D.33273;
  unsigned int D.33274;
  int D.33275;
  long int D.33276;
  _Bool D.33277;
  long int D.33278;
  long int D.33279;
  unsigned int D.33282;
  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.33169 = acfg->image;
      klass = mono_class_get (D.33169, token);
      iter = 0B;
      if (klass == 0B) goto <D.33170>; else goto <D.33171>;
      <D.33170>:
      mono_loader_clear_error ();
      buf_size = 16;
      D.33172 = (long unsigned int) buf_size;
      buf = monoeg_malloc (D.33172);
      p = buf;
      p.518 = p;
      encode_value (-1, p.518, &p);
      p.518 = p;
      p.519 = (long int) p.518;
      buf.520 = (long int) buf;
      D.33176 = p.519 - buf.520;
      D.33177 = (unsigned int) D.33176;
      D.33178 = add_to_blob (acfg, buf, D.33177);
      res = (int) D.33178;
      monoeg_g_free (buf);
      D.33179 = (guint32) res;
      return D.33179;
      <D.33171>:
      D.33180 = klass->vtable_size;
      D.33181 = D.33180 + 640;
      buf_size = D.33181 * 16;
      D.33172 = (long unsigned int) buf_size;
      buf = monoeg_malloc (D.33172);
      p = buf;
      D.33182 = klass == 0B;
      D.33183 = (long int) D.33182;
      D.33184 = __builtin_expect (D.33183, 0);
      if (D.33184 != 0) goto <D.33185>; else goto <D.33186>;
      <D.33185>:
      monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "aot-compiler.c", 5514, "klass");
      <D.33186>:
      mono_class_init (klass);
      mono_class_get_nested_types (klass, &iter);
      D.33187 = BIT_FIELD_REF <*klass, 8, 280>;
      D.33188 = (signed char) D.33187;
      D.33189 = D.33188 >= 0;
      D.33190 = (long int) D.33189;
      D.33191 = __builtin_expect (D.33190, 0);
      if (D.33191 != 0) goto <D.33192>; else goto <D.33193>;
      <D.33192>:
      monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "aot-compiler.c", 5519, "klass->nested_classes_inited");
      <D.33193>:
      mono_class_setup_vtable (klass);
      D.33194 = mono_class_has_special_static_fields (klass);
      D.33195 = D.33194 == 0;
      no_special_static = (gboolean) D.33195;
      cant_encode = 0;
      i = 0;
      goto <D.25574>;
      <D.25573>:
      {
        struct MonoMethod * cm;

        D.33196 = klass->vtable;
        D.33197 = (long unsigned int) i;
        D.33198 = D.33197 * 8;
        D.33199 = D.33196 + D.33198;
        cm = *D.33199;
        if (cm != 0B) goto <D.33200>; else goto <D.33201>;
        <D.33200>:
        D.33202 = mono_method_signature (cm);
        D.33203 = BIT_FIELD_REF <*D.33202, 8, 120>;
        D.33204 = D.33203 & 2;
        if (D.33204 != 0) goto <D.33205>; else goto <D.33206>;
        <D.33205>:
        D.33207 = acfg->token_info_hash;
        D.33208 = monoeg_g_hash_table_lookup (D.33207, cm);
        if (D.33208 == 0B) goto <D.33209>; else goto <D.33210>;
        <D.33209>:
        cant_encode = 1;
        <D.33210>:
        <D.33206>:
        <D.33201>:
      }
      i = i + 1;
      <D.25574>:
      D.33180 = klass->vtable_size;
      if (D.33180 > i) goto <D.25573>; else goto <D.25575>;
      <D.25575>:
      mono_class_has_finalizer (klass);
      D.33213 = klass->generic_container;
      if (D.33213 != 0B) goto <D.33211>; else goto <D.33214>;
      <D.33214>:
      if (cant_encode != 0) goto <D.33211>; else goto <D.33212>;
      <D.33211>:
      p.518 = p;
      encode_value (-1, p.518, &p);
      goto <D.25579>;
      <D.33212>:
      p.518 = p;
      D.33180 = klass->vtable_size;
      encode_value (D.33180, p.518, &p);
      p.518 = p;
      D.33213 = klass->generic_container;
      if (D.33213 != 0B) goto <D.33216>; else goto <D.33217>;
      <D.33216>:
      iftmp.521 = 256;
      goto <D.33218>;
      <D.33217>:
      iftmp.521 = 0;
      <D.33218>:
      D.33219 = no_special_static << 7;
      D.33220 = iftmp.521 | D.33219;
      D.33221 = klass->has_static_refs;
      D.33222 = (int) D.33221;
      D.33223 = D.33222 << 6;
      D.33224 = D.33220 | D.33223;
      D.33225 = klass->has_references;
      D.33226 = (int) D.33225;
      D.33227 = D.33226 << 5;
      D.33228 = D.33224 | D.33227;
      D.33229 = klass->blittable;
      D.33230 = (int) D.33229;
      D.33231 = D.33230 << 4;
      D.33235 = klass->ext;
      if (D.33235 != 0B) goto <D.33236>; else goto <D.33233>;
      <D.33236>:
      D.33235 = klass->ext;
      D.33237 = D.33235->nested_classes;
      if (D.33237 != 0B) goto <D.33238>; else goto <D.33233>;
      <D.33238>:
      iftmp.522 = 1;
      goto <D.33234>;
      <D.33233>:
      iftmp.522 = 0;
      <D.33234>:
      D.33239 = iftmp.522 << 3;
      D.33240 = D.33231 | D.33239;
      D.33241 = D.33228 | D.33240;
      D.33242 = klass->has_cctor;
      D.33243 = (int) D.33242;
      D.33244 = D.33243 << 2;
      D.33245 = D.33241 | D.33244;
      D.33246 = klass->has_finalize;
      D.33247 = (int) D.33246;
      D.33248 = D.33247 << 1;
      D.33249 = D.33245 | D.33248;
      D.33250 = klass->ghcimpl;
      D.33251 = (int) D.33250;
      D.33252 = D.33249 | D.33251;
      encode_value (D.33252, p.518, &p);
      D.33187 = BIT_FIELD_REF <*klass, 8, 280>;
      D.33253 = D.33187 & 4;
      if (D.33253 != 0) goto <D.33254>; else goto <D.33255>;
      <D.33254>:
      p.518 = p;
      D.33256 = mono_class_get_cctor (klass);
      encode_method_ref (acfg, D.33256, p.518, &p);
      <D.33255>:
      D.33257 = BIT_FIELD_REF <*klass, 8, 272>;
      D.33258 = D.33257 & 32;
      if (D.33258 != 0) goto <D.33259>; else goto <D.33260>;
      <D.33259>:
      p.518 = p;
      D.33261 = mono_class_get_finalizer (klass);
      encode_method_ref (acfg, D.33261, p.518, &p);
      <D.33260>:
      p.518 = p;
      D.33262 = klass->instance_size;
      encode_value (D.33262, p.518, &p);
      p.518 = p;
      D.33263 = mono_class_data_size (klass);
      encode_value (D.33263, p.518, &p);
      p.518 = p;
      D.33264 = klass->packing_size;
      D.33265 = (int) D.33264;
      encode_value (D.33265, p.518, &p);
      p.518 = p;
      D.33266 = klass->min_align;
      D.33267 = (int) D.33266;
      encode_value (D.33267, p.518, &p);
      i = 0;
      goto <D.25578>;
      <D.25577>:
      {
        struct MonoMethod * cm;

        D.33196 = klass->vtable;
        D.33197 = (long unsigned int) i;
        D.33198 = D.33197 * 8;
        D.33199 = D.33196 + D.33198;
        cm = *D.33199;
        if (cm != 0B) goto <D.33268>; else goto <D.33269>;
        <D.33268>:
        p.518 = p;
        encode_method_ref (acfg, cm, p.518, &p);
        goto <D.33270>;
        <D.33269>:
        p.518 = p;
        encode_value (0, p.518, &p);
        <D.33270>:
      }
      i = i + 1;
      <D.25578>:
      D.33180 = klass->vtable_size;
      if (D.33180 > i) goto <D.25577>; else goto <D.25579>;
      <D.25579>:
      D.33271 = acfg->stats.class_info_size;
      D.33272 = (unsigned int) D.33271;
      p.518 = p;
      p.519 = (long int) p.518;
      buf.520 = (long int) buf;
      D.33176 = p.519 - buf.520;
      D.33273 = (unsigned int) D.33176;
      D.33274 = D.33272 + D.33273;
      D.33275 = (int) D.33274;
      acfg->stats.class_info_size = D.33275;
      p.518 = p;
      p.519 = (long int) p.518;
      buf.520 = (long int) buf;
      D.33176 = p.519 - buf.520;
      D.33276 = (long int) buf_size;
      D.33277 = D.33176 >= D.33276;
      D.33278 = (long int) D.33277;
      D.33279 = __builtin_expect (D.33278, 0);
      if (D.33279 != 0) goto <D.33280>; else goto <D.33281>;
      <D.33280>:
      monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "aot-compiler.c", 5569, "p - buf < buf_size");
      <D.33281>:
      p.518 = p;
      p.519 = (long int) p.518;
      buf.520 = (long int) buf;
      D.33176 = p.519 - buf.520;
      D.33177 = (unsigned int) D.33176;
      D.33282 = add_to_blob (acfg, buf, D.33177);
      res = (int) D.33282;
      monoeg_g_free (buf);
      D.33179 = (guint32) res;
      return D.33179;
    }
  finally
    {
      p = {CLOBBER};
      iter = {CLOBBER};
    }
}


emit_plt (struct MonoAotCompile * acfg)
{
  char * D.33285;
  long unsigned int D.33288;
  const void * D.33289;
  struct GHashTable * D.33290;
  int D.33291;
  int D.33296;
  int D.33299;
  struct MonoMethod * D.33302;
  struct GHashTable * D.33303;
  int D.33308;
  unsigned char D.33310;
  unsigned char D.33311;
  struct FILE * D.33313;
  char * D.33314;
  char * D.33315;
  int D.33318;
  int D.33327;
  char * D.33330;
  unsigned int i.523;
  unsigned int D.33334;
  int D.33341;
  int D.33346;
  int D.33349;
  char * D.33352;
  char * D.33357;
  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.33285 = acfg->plt_symbol;
      emit_label (acfg, D.33285);
      i = 0;
      goto <D.25608>;
      <D.25607>:
      {
        char * debug_sym;
        struct MonoPltEntry * plt_entry;
        struct MonoJumpInfo * ji;

        debug_sym = 0B;
        plt_entry = 0B;
        if (i == 0) goto <D.33286>; else goto <D.33287>;
        <D.33286>:
        // predicted unlikely by continue predictor.
        goto <D.25605>;
        <D.33287>:
        D.33288 = (long unsigned int) i;
        D.33289 = (const void *) D.33288;
        D.33290 = acfg->plt_offset_to_entry;
        plt_entry = monoeg_g_hash_table_lookup (D.33290, D.33289);
        ji = plt_entry->ji;
        D.33291 = acfg->llvm;
        if (D.33291 != 0) goto <D.33292>; else goto <D.33293>;
        <D.33292>:
        if (ji != 0B) goto <D.33294>; else goto <D.33295>;
        <D.33294>:
        D.33296 = is_direct_callable (acfg, 0B, ji);
        if (D.33296 != 0) goto <D.33297>; else goto <D.33298>;
        <D.33297>:
        D.33299 = acfg->use_bin_writer;
        if (D.33299 == 0) goto <D.33300>; else goto <D.33301>;
        <D.33300>:
        {
          struct MonoCompile * callee_cfg;

          D.33302 = ji->data.method;
          D.33303 = acfg->method_to_cfg;
          callee_cfg = monoeg_g_hash_table_lookup (D.33303, D.33302);
          if (callee_cfg != 0B) goto <D.33304>; else goto <D.33305>;
          <D.33304>:
          D.33308 = acfg->thumb_mixed;
          if (D.33308 != 0) goto <D.33309>; else goto <D.33306>;
          <D.33309>:
          D.33310 = BIT_FIELD_REF <*callee_cfg, 8, 5608>;
          D.33311 = D.33310 & 1;
          if (D.33311 == 0) goto <D.33312>; else goto <D.33306>;
          <D.33312>:
          emit_set_thumb_mode (acfg);
          D.33313 = acfg->fp;
          fprintf (D.33313, "\n.thumb_func\n");
          D.33314 = plt_entry->llvm_symbol;
          emit_label (acfg, D.33314);
          D.33313 = acfg->fp;
          fprintf (D.33313, "bx pc\n");
          D.33313 = acfg->fp;
          fprintf (D.33313, "nop\n");
          emit_set_arm_mode (acfg);
          D.33315 = callee_cfg->asm_symbol;
          D.33313 = acfg->fp;
          fprintf (D.33313, "b %s\n", D.33315);
          goto <D.33307>;
          <D.33306>:
          D.33315 = callee_cfg->asm_symbol;
          D.33314 = plt_entry->llvm_symbol;
          D.33313 = acfg->fp;
          fprintf (D.33313, "\n.set %s, %s\n", D.33314, D.33315);
          <D.33307>:
          // predicted unlikely by continue predictor.
          goto <D.25605>;
          <D.33305>:
        }
        <D.33301>:
        <D.33298>:
        <D.33295>:
        <D.33293>:
        debug_sym = plt_entry->debug_sym;
        D.33308 = acfg->thumb_mixed;
        if (D.33308 != 0) goto <D.33316>; else goto <D.33317>;
        <D.33316>:
        D.33318 = plt_entry->jit_used;
        if (D.33318 == 0) goto <D.33319>; else goto <D.33320>;
        <D.33319>:
        // predicted unlikely by continue predictor.
        goto <D.25605>;
        <D.33320>:
        <D.33317>:
        D.33291 = acfg->llvm;
        if (D.33291 != 0) goto <D.33321>; else goto <D.33322>;
        <D.33321>:
        D.33308 = acfg->thumb_mixed;
        if (D.33308 == 0) goto <D.33323>; else goto <D.33324>;
        <D.33323>:
        D.33314 = plt_entry->llvm_symbol;
        emit_label (acfg, D.33314);
        <D.33324>:
        <D.33322>:
        if (debug_sym != 0B) goto <D.33325>; else goto <D.33326>;
        <D.33325>:
        D.33327 = acfg->need_no_dead_strip;
        if (D.33327 != 0) goto <D.33328>; else goto <D.33329>;
        <D.33328>:
        emit_unset_mode (acfg);
        D.33313 = acfg->fp;
        fprintf (D.33313, "\t.no_dead_strip %s\n", debug_sym);
        <D.33329>:
        emit_local_symbol (acfg, debug_sym, 0B, 1);
        emit_label (acfg, debug_sym);
        <D.33326>:
        D.33330 = plt_entry->symbol;
        emit_label (acfg, D.33330);
        arch_emit_plt_entry (acfg, i);
        if (debug_sym != 0B) goto <D.33331>; else goto <D.33332>;
        <D.33331>:
        emit_symbol_size (acfg, debug_sym, ".");
        <D.33332>:
      }
      <D.25605>:
      i = i + 1;
      <D.25608>:
      i.523 = (unsigned int) i;
      D.33334 = acfg->plt_offset;
      if (i.523 < D.33334) goto <D.25607>; else goto <D.25609>;
      <D.25609>:
      D.33308 = acfg->thumb_mixed;
      if (D.33308 != 0) goto <D.33335>; else goto <D.33336>;
      <D.33335>:
      emit_zero_bytes (acfg, 16);
      i = 0;
      goto <D.25615>;
      <D.25614>:
      {
        char * debug_sym;
        struct MonoPltEntry * plt_entry;
        struct MonoJumpInfo * ji;

        debug_sym = 0B;
        plt_entry = 0B;
        if (i == 0) goto <D.33337>; else goto <D.33338>;
        <D.33337>:
        // predicted unlikely by continue predictor.
        goto <D.25613>;
        <D.33338>:
        D.33288 = (long unsigned int) i;
        D.33289 = (const void *) D.33288;
        D.33290 = acfg->plt_offset_to_entry;
        plt_entry = monoeg_g_hash_table_lookup (D.33290, D.33289);
        ji = plt_entry->ji;
        if (ji != 0B) goto <D.33339>; else goto <D.33340>;
        <D.33339>:
        D.33341 = is_direct_callable (acfg, 0B, ji);
        if (D.33341 != 0) goto <D.33342>; else goto <D.33343>;
        <D.33342>:
        D.33299 = acfg->use_bin_writer;
        if (D.33299 == 0) goto <D.33344>; else goto <D.33345>;
        <D.33344>:
        // predicted unlikely by continue predictor.
        goto <D.25613>;
        <D.33345>:
        <D.33343>:
        <D.33340>:
        D.33346 = plt_entry->llvm_used;
        if (D.33346 == 0) goto <D.33347>; else goto <D.33348>;
        <D.33347>:
        // predicted unlikely by continue predictor.
        goto <D.25613>;
        <D.33348>:
        D.33349 = acfg->aot_opts.write_symbols;
        if (D.33349 != 0) goto <D.33350>; else goto <D.33351>;
        <D.33350>:
        D.33352 = plt_entry->debug_sym;
        if (D.33352 != 0B) goto <D.33353>; else goto <D.33354>;
        <D.33353>:
        D.33352 = plt_entry->debug_sym;
        debug_sym = monoeg_g_strdup_printf ("%s_thumb", D.33352);
        <D.33354>:
        <D.33351>:
        if (debug_sym != 0B) goto <D.33355>; else goto <D.33356>;
        <D.33355>:
        emit_local_symbol (acfg, debug_sym, 0B, 1);
        emit_label (acfg, debug_sym);
        <D.33356>:
        D.33313 = acfg->fp;
        fprintf (D.33313, "\n.thumb_func\n");
        D.33357 = plt_entry->llvm_symbol;
        emit_label (acfg, D.33357);
        arch_emit_llvm_plt_entry (acfg, i);
        if (debug_sym != 0B) goto <D.33358>; else goto <D.33359>;
        <D.33358>:
        emit_symbol_size (acfg, debug_sym, ".");
        monoeg_g_free (debug_sym);
        <D.33359>:
      }
      <D.25613>:
      i = i + 1;
      <D.25615>:
      i.523 = (unsigned int) i;
      D.33334 = acfg->plt_offset;
      if (i.523 < D.33334) goto <D.25614>; else goto <D.25616>;
      <D.25616>:
      <D.33336>:
      D.33285 = acfg->plt_symbol;
      emit_symbol_size (acfg, D.33285, ".");
      sprintf (&symbol, "plt_end");
      emit_label (acfg, &symbol);
    }
  finally
    {
      symbol = {CLOBBER};
    }
}


arch_emit_plt_entry (struct MonoAotCompile * acfg, int index)
{
  unsigned int D.33360;
  unsigned int index.524;
  unsigned int D.33362;
  unsigned int D.33363;
  unsigned int D.33364;
  int D.33365;
  char * D.33366;
  guint32 * D.33367;
  long unsigned int D.33368;
  long unsigned int D.33369;
  guint32 * D.33370;
  unsigned int D.33371;
  int D.33372;

  emit_byte (acfg, 255);
  emit_byte (acfg, 37);
  D.33360 = acfg->plt_got_offset_base;
  index.524 = (unsigned int) index;
  D.33362 = D.33360 + index.524;
  D.33363 = D.33362 * 8;
  D.33364 = D.33363 + 4294967292;
  D.33365 = (int) D.33364;
  D.33366 = acfg->got_symbol;
  emit_symbol_diff (acfg, D.33366, ".", D.33365);
  D.33367 = acfg->plt_got_info_offsets;
  D.33368 = (long unsigned int) index;
  D.33369 = D.33368 * 4;
  D.33370 = D.33367 + D.33369;
  D.33371 = *D.33370;
  D.33372 = (int) D.33371;
  emit_int32 (acfg, D.33372);
}


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.33373;
  unsigned int D.33374;
  int D.33375;
  void * * D.33376;
  long unsigned int D.33377;
  long unsigned int D.33378;
  void * * D.33379;
  struct MonoAssembly * D.33380;
  struct MonoImage * D.33381;
  _Bool D.33382;
  long int D.33383;
  long int D.33384;
  const char * D.33387;
  char * D.33388;
  const char * iftmp.525;
  const char * D.33390;
  mono_byte[17] * D.33394;
  unsigned int D.33395;
  int D.33396;
  short unsigned int D.33397;
  int D.33398;
  short unsigned int D.33399;
  int D.33400;
  short unsigned int D.33401;
  int D.33402;
  short unsigned int D.33403;
  int D.33404;
  unsigned int i.526;
  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.33373 = acfg->image_table;
      D.33374 = D.33373->len;
      D.33375 = (int) D.33374;
      emit_int32 (acfg, D.33375);
      i = 0;
      goto <D.26249>;
      <D.26248>:
      {
        struct MonoImage * image;
        struct MonoAssemblyName * aname;

        D.33373 = acfg->image_table;
        D.33376 = D.33373->pdata;
        D.33377 = (long unsigned int) i;
        D.33378 = D.33377 * 8;
        D.33379 = D.33376 + D.33378;
        image = *D.33379;
        D.33380 = image->assembly;
        aname = &D.33380->aname;
        D.33380 = image->assembly;
        D.33381 = D.33380->image;
        D.33382 = D.33381 != image;
        D.33383 = (long int) D.33382;
        D.33384 = __builtin_expect (D.33383, 0);
        if (D.33384 != 0) goto <D.33385>; else goto <D.33386>;
        <D.33385>:
        monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "aot-compiler.c", 7785, "image->assembly->image == image");
        <D.33386>:
        D.33387 = image->assembly_name;
        emit_string (acfg, D.33387);
        D.33388 = image->guid;
        emit_string (acfg, D.33388);
        D.33390 = aname->culture;
        if (D.33390 != 0B) goto <D.33391>; else goto <D.33392>;
        <D.33391>:
        iftmp.525 = aname->culture;
        goto <D.33393>;
        <D.33392>:
        iftmp.525 = "";
        <D.33393>:
        emit_string (acfg, iftmp.525);
        D.33394 = &aname->public_key_token;
        emit_string (acfg, D.33394);
        emit_alignment (acfg, 8);
        D.33395 = aname->flags;
        D.33396 = (int) D.33395;
        emit_int32 (acfg, D.33396);
        D.33397 = aname->major;
        D.33398 = (int) D.33397;
        emit_int32 (acfg, D.33398);
        D.33399 = aname->minor;
        D.33400 = (int) D.33399;
        emit_int32 (acfg, D.33400);
        D.33401 = aname->build;
        D.33402 = (int) D.33401;
        emit_int32 (acfg, D.33402);
        D.33403 = aname->revision;
        D.33404 = (int) D.33403;
        emit_int32 (acfg, D.33404);
      }
      i = i + 1;
      <D.26249>:
      i.526 = (unsigned int) i;
      D.33373 = acfg->image_table;
      D.33374 = D.33373->len;
      if (i.526 < D.33374) goto <D.26248>; else goto <D.26250>;
      <D.26250>:
    }
  finally
    {
      symbol = {CLOBBER};
    }
}


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

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


emit_got (struct MonoAotCompile * acfg)
{
  int D.33407;
  char * D.33410;
  unsigned int D.33411;
  unsigned int D.33414;
  int D.33415;
  char symbol[256];

  try
    {
      D.33407 = acfg->llvm;
      if (D.33407 == 0) goto <D.33408>; else goto <D.33409>;
      <D.33408>:
      D.33410 = acfg->got_symbol;
      sprintf (&symbol, "%s", D.33410);
      emit_section_change (acfg, ".bss", 0);
      emit_alignment (acfg, 8);
      emit_local_symbol (acfg, &symbol, "got_end", 0);
      emit_label (acfg, &symbol);
      D.33411 = acfg->got_offset;
      if (D.33411 != 0) goto <D.33412>; else goto <D.33413>;
      <D.33412>:
      D.33411 = acfg->got_offset;
      D.33414 = D.33411 * 8;
      D.33415 = (int) D.33414;
      emit_zero_bytes (acfg, D.33415);
      <D.33413>:
      sprintf (&symbol, "got_end");
      emit_label (acfg, &symbol);
      <D.33409>:
    }
  finally
    {
      symbol = {CLOBBER};
    }
}


emit_file_info (struct MonoAotCompile * acfg)
{
  struct MonoImage * D.33416;
  char * D.33417;
  int D.33418;
  struct MonoAssembly * D.33422;
  const char * D.33423;
  long unsigned int D.33424;
  unsigned int D.33425;
  unsigned int D.33426;
  unsigned int D.33427;
  const char * D.33428;
  int D.33429;
  char * D.33432;
  char * D.33433;
  int D.33434;
  int D.33438;
  unsigned int D.33442;
  int D.33446;
  unsigned int D.33453;
  int D.33454;
  unsigned int D.33455;
  unsigned int D.33456;
  int D.33457;
  unsigned int D.33458;
  int D.33459;
  unsigned int D.33460;
  int D.33461;
  <unnamed type> D.33462;
  int D.33463;
  unsigned int D.33464;
  int D.33465;
  unsigned int D.33466;
  int D.33467;
  unsigned int D.33468;
  int D.33469;
  unsigned int D.33470;
  int D.33471;
  unsigned int D.33472;
  int D.33473;
  int D.33474;
  unsigned int D.33475;
  int D.33476;
  unsigned int D.33477;
  int D.33478;
  const short unsigned int * * D.33481;
  const short unsigned int * D.33482;
  char D.33483;
  long unsigned int D.33484;
  long unsigned int D.33485;
  const short unsigned int * D.33486;
  short unsigned int D.33487;
  int D.33488;
  int D.33489;
  gchar * D.33494;
  char symbol[256];
  int i;
  int gc_name_offset;
  const char * gc_name;
  char * build_info;

  try
    {
      D.33416 = acfg->image;
      D.33417 = D.33416->guid;
      emit_string_symbol (acfg, "assembly_guid", D.33417);
      D.33418 = acfg->aot_opts.bind_to_runtime_version;
      if (D.33418 != 0) goto <D.33419>; else goto <D.33420>;
      <D.33419>:
      build_info = mono_get_runtime_build_info ();
      emit_string_symbol (acfg, "runtime_version", build_info);
      monoeg_g_free (build_info);
      goto <D.33421>;
      <D.33420>:
      emit_string_symbol (acfg, "runtime_version", "");
      <D.33421>:
      D.33416 = acfg->image;
      D.33422 = D.33416->assembly;
      D.33423 = D.33422->aname.name;
      emit_string_symbol (acfg, "assembly_name", D.33423);
      gc_name = mono_gc_get_gc_name ();
      D.33424 = strlen (gc_name);
      D.33425 = (unsigned int) D.33424;
      D.33426 = D.33425 + 1;
      D.33427 = add_to_blob (acfg, gc_name, D.33426);
      gc_name_offset = (int) D.33427;
      D.33428 = acfg->user_symbol_prefix;
      sprintf (&symbol, "%smono_aot_file_info", D.33428);
      emit_section_change (acfg, ".data", 0);
      emit_alignment (acfg, 8);
      emit_label (acfg, &symbol);
      D.33429 = acfg->aot_opts.static_link;
      if (D.33429 == 0) goto <D.33430>; else goto <D.33431>;
      <D.33430>:
      emit_global (acfg, &symbol, 0);
      <D.33431>:
      emit_int32 (acfg, 97);
      emit_int32 (acfg, 0);
      D.33432 = acfg->got_symbol;
      emit_pointer (acfg, D.33432);
      D.33433 = acfg->methods_symbol;
      emit_pointer (acfg, D.33433);
      D.33434 = acfg->llvm;
      if (D.33434 != 0) goto <D.33435>; else goto <D.33436>;
      <D.33435>:
      emit_pointer (acfg, "mono_eh_frame");
      goto <D.33437>;
      <D.33436>:
      emit_pointer (acfg, 0B);
      <D.33437>:
      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.33438 = acfg->direct_method_addresses;
      if (D.33438 != 0) goto <D.33439>; else goto <D.33440>;
      <D.33439>:
      emit_pointer (acfg, "method_addresses");
      goto <D.33441>;
      <D.33440>:
      emit_pointer (acfg, 0B);
      <D.33441>:
      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.33442 = acfg->num_trampoline_got_entries;
      if (D.33442 != 0) goto <D.33443>; else goto <D.33444>;
      <D.33443>:
      emit_pointer (acfg, "specific_trampolines");
      emit_pointer (acfg, "static_rgctx_trampolines");
      emit_pointer (acfg, "imt_thunks");
      emit_pointer (acfg, "gsharedvt_arg_trampolines");
      goto <D.33445>;
      <D.33444>:
      emit_pointer (acfg, 0B);
      emit_pointer (acfg, 0B);
      emit_pointer (acfg, 0B);
      emit_pointer (acfg, 0B);
      <D.33445>:
      D.33446 = acfg->thumb_mixed;
      if (D.33446 != 0) goto <D.33447>; else goto <D.33448>;
      <D.33447>:
      emit_pointer (acfg, "thumb_end");
      goto <D.33449>;
      <D.33448>:
      emit_pointer (acfg, 0B);
      <D.33449>:
      D.33429 = acfg->aot_opts.static_link;
      if (D.33429 != 0) goto <D.33450>; else goto <D.33451>;
      <D.33450>:
      emit_pointer (acfg, "globals");
      goto <D.33452>;
      <D.33451>:
      emit_pointer (acfg, 0B);
      <D.33452>:
      emit_pointer (acfg, "assembly_name");
      emit_pointer (acfg, "unbox_trampolines");
      emit_pointer (acfg, "unbox_trampolines_end");
      D.33453 = acfg->plt_got_offset_base;
      D.33454 = (int) D.33453;
      emit_int32 (acfg, D.33454);
      D.33455 = acfg->got_offset;
      D.33456 = D.33455 * 8;
      D.33457 = (int) D.33456;
      emit_int32 (acfg, D.33457);
      D.33458 = acfg->plt_offset;
      D.33459 = (int) D.33458;
      emit_int32 (acfg, D.33459);
      D.33460 = acfg->nmethods;
      D.33461 = (int) D.33460;
      emit_int32 (acfg, D.33461);
      D.33462 = acfg->flags;
      D.33463 = (int) D.33462;
      emit_int32 (acfg, D.33463);
      D.33464 = acfg->opts;
      D.33465 = (int) D.33464;
      emit_int32 (acfg, D.33465);
      D.33466 = acfg->simd_opts;
      D.33467 = (int) D.33466;
      emit_int32 (acfg, D.33467);
      emit_int32 (acfg, gc_name_offset);
      i = 0;
      goto <D.26328>;
      <D.26327>:
      D.33468 = acfg->num_trampolines[i];
      D.33469 = (int) D.33468;
      emit_int32 (acfg, D.33469);
      i = i + 1;
      <D.26328>:
      if (i <= 3) goto <D.26327>; else goto <D.26329>;
      <D.26329>:
      i = 0;
      goto <D.26331>;
      <D.26330>:
      D.33470 = acfg->trampoline_got_offset_base[i];
      D.33471 = (int) D.33470;
      emit_int32 (acfg, D.33471);
      i = i + 1;
      <D.26331>:
      if (i <= 3) goto <D.26330>; else goto <D.26332>;
      <D.26332>:
      i = 0;
      goto <D.26334>;
      <D.26333>:
      D.33472 = acfg->trampoline_size[i];
      D.33473 = (int) D.33472;
      emit_int32 (acfg, D.33473);
      i = i + 1;
      <D.26334>:
      if (i <= 3) goto <D.26333>; else goto <D.26335>;
      <D.26335>:
      D.33474 = acfg->aot_opts.nrgctx_fetch_trampolines;
      emit_int32 (acfg, D.33474);
      emit_int32 (acfg, 8);
      emit_int32 (acfg, 8);
      emit_int32 (acfg, 14);
      D.33475 = acfg->tramp_page_size;
      D.33476 = (int) D.33475;
      emit_int32 (acfg, D.33476);
      i = 0;
      goto <D.26337>;
      <D.26336>:
      D.33477 = acfg->tramp_page_code_offsets[i];
      D.33478 = (int) D.33477;
      emit_int32 (acfg, D.33478);
      i = i + 1;
      <D.26337>:
      if (i <= 3) goto <D.26336>; else goto <D.26338>;
      <D.26338>:
      D.33429 = acfg->aot_opts.static_link;
      if (D.33429 != 0) goto <D.33479>; else goto <D.33480>;
      <D.33479>:
      {
        char * p;

        D.33416 = acfg->image;
        D.33422 = D.33416->assembly;
        D.33423 = D.33422->aname.name;
        D.33428 = acfg->user_symbol_prefix;
        sprintf (&symbol, "%smono_aot_module_%s_info", D.33428, D.33423);
        p = &symbol;
        p = &symbol;
        goto <D.26341>;
        <D.26340>:
        D.33481 = __ctype_b_loc ();
        D.33482 = *D.33481;
        D.33483 = *p;
        D.33484 = (long unsigned int) D.33483;
        D.33485 = D.33484 * 2;
        D.33486 = D.33482 + D.33485;
        D.33487 = *D.33486;
        D.33488 = (int) D.33487;
        D.33489 = D.33488 & 8;
        if (D.33489 == 0) goto <D.33490>; else goto <D.33491>;
        <D.33490>:
        D.33483 = *p;
        if (D.33483 != 95) goto <D.33492>; else goto <D.33493>;
        <D.33492>:
        *p = 95;
        <D.33493>:
        <D.33491>:
        p = p + 1;
        <D.26341>:
        D.33483 = *p;
        if (D.33483 != 0) goto <D.26340>; else goto <D.26342>;
        <D.26342>:
        D.33494 = monoeg_strdup (&symbol);
        acfg->static_linking_symbol = D.33494;
        emit_global_inner (acfg, &symbol, 0);
        emit_alignment (acfg, 8);
        emit_label (acfg, &symbol);
        D.33428 = acfg->user_symbol_prefix;
        emit_pointer_2 (acfg, D.33428, "mono_aot_file_info");
      }
      <D.33480>:
    }
  finally
    {
      symbol = {CLOBBER};
    }
}


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

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


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

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


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

  D.33497 = *prefix;
  if (D.33497 != 0) goto <D.33498>; else goto <D.33499>;
  <D.33498>:
  {
    char * s;

    s = monoeg_g_strdup_printf ("%s%s", prefix, target);
    D.33500 = acfg->w;
    img_writer_emit_pointer (D.33500, s);
    monoeg_g_free (s);
  }
  goto <D.33501>;
  <D.33499>:
  D.33500 = acfg->w;
  img_writer_emit_pointer (D.33500, target);
  <D.33501>:
}


emit_blob (struct MonoAotCompile * acfg)
{
  unsigned int D.33502;
  int D.33503;
  char * D.33504;
  char symbol[128];

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


emit_objc_selectors (struct MonoAotCompile * acfg)
{
  struct GPtrArray * D.33507;
  unsigned int D.33509;
  struct MonoImageWriter * D.33510;
  struct FILE * D.33511;
  _Bool D.33512;
  long int D.33513;
  long int D.33514;
  unsigned int i.527;
  void * * D.33518;
  long unsigned int D.33519;
  long unsigned int D.33520;
  void * * D.33521;
  void * D.33522;
  int i;

  D.33507 = acfg->objc_selectors;
  if (D.33507 == 0B) goto <D.33505>; else goto <D.33508>;
  <D.33508>:
  D.33507 = acfg->objc_selectors;
  D.33509 = D.33507->len;
  if (D.33509 == 0) goto <D.33505>; else goto <D.33506>;
  <D.33505>:
  return;
  <D.33506>:
  D.33510 = acfg->w;
  img_writer_emit_unset_mode (D.33510);
  D.33511 = acfg->fp;
  D.33512 = D.33511 == 0B;
  D.33513 = (long int) D.33512;
  D.33514 = __builtin_expect (D.33513, 0);
  if (D.33514 != 0) goto <D.33515>; else goto <D.33516>;
  <D.33515>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "aot-compiler.c", 8235, "acfg->fp");
  <D.33516>:
  D.33511 = acfg->fp;
  fprintf (D.33511, ".section\t__DATA,__objc_selrefs,literal_pointers,no_dead_strip\n");
  D.33511 = acfg->fp;
  fprintf (D.33511, ".align\t2\n");
  i = 0;
  goto <D.26352>;
  <D.26351>:
  D.33511 = acfg->fp;
  fprintf (D.33511, "L_OBJC_SELECTOR_REFERENCES_%d:\n", i);
  D.33511 = acfg->fp;
  fprintf (D.33511, ".long\tL_OBJC_METH_VAR_NAME_%d\n", i);
  i = i + 1;
  <D.26352>:
  i.527 = (unsigned int) i;
  D.33507 = acfg->objc_selectors;
  D.33509 = D.33507->len;
  if (i.527 < D.33509) goto <D.26351>; else goto <D.26353>;
  <D.26353>:
  D.33511 = acfg->fp;
  fprintf (D.33511, ".section\t__TEXT,__cstring,cstring_literals\n");
  i = 0;
  goto <D.26355>;
  <D.26354>:
  D.33511 = acfg->fp;
  fprintf (D.33511, "L_OBJC_METH_VAR_NAME_%d:\n", i);
  D.33507 = acfg->objc_selectors;
  D.33518 = D.33507->pdata;
  D.33519 = (long unsigned int) i;
  D.33520 = D.33519 * 8;
  D.33521 = D.33518 + D.33520;
  D.33522 = *D.33521;
  D.33511 = acfg->fp;
  fprintf (D.33511, ".asciz \"%s\"\n", D.33522);
  i = i + 1;
  <D.26355>:
  i.527 = (unsigned int) i;
  D.33507 = acfg->objc_selectors;
  D.33509 = D.33507->len;
  if (i.527 < D.33509) goto <D.26354>; else goto <D.26356>;
  <D.26356>:
  D.33511 = acfg->fp;
  fprintf (D.33511, ".section\t__DATA,__objc_imageinfo,regular,no_dead_strip\n");
  D.33511 = acfg->fp;
  fprintf (D.33511, ".align\t2\n");
  D.33511 = acfg->fp;
  fprintf (D.33511, "L_OBJC_IMAGE_INFO:\n");
  D.33511 = acfg->fp;
  fprintf (D.33511, ".long\t0\n");
  D.33511 = acfg->fp;
  fprintf (D.33511, ".long\t16\n");
}


emit_globals (struct MonoAotCompile * acfg)
{
  int D.33524;
  struct GPtrArray * D.33527;
  unsigned int D.33528;
  double D.33529;
  double D.33530;
  int D.33531;
  unsigned int D.33532;
  unsigned int D.33533;
  unsigned int table_size.528;
  void * * D.33535;
  long unsigned int D.33536;
  long unsigned int D.33537;
  void * * D.33538;
  unsigned int D.33539;
  unsigned int i.529;
  void * * D.33541;
  long unsigned int D.33542;
  long unsigned int D.33543;
  void * * D.33544;
  struct GlobalsTableEntry * D.33548;
  unsigned int D.33549;
  unsigned int i.530;
  _Bool D.33551;
  long int D.33552;
  long int D.33553;
  void * * D.33556;
  unsigned int D.33560;
  unsigned int D.33561;
  int D.33562;
  struct GlobalsTableEntry * D.33563;
  unsigned int D.33566;
  int D.33567;
  const char * D.33569;
  int i;
  int table_size;
  guint32 hash;
  struct GPtrArray * table;
  char symbol[256];
  struct GlobalsTableEntry * entry;
  struct GlobalsTableEntry * new_entry;

  try
    {
      D.33524 = acfg->aot_opts.static_link;
      if (D.33524 == 0) goto <D.33525>; else goto <D.33526>;
      <D.33525>:
      return;
      <D.33526>:
      D.33527 = acfg->globals;
      D.33528 = D.33527->len;
      D.33529 = (double) D.33528;
      D.33530 = D.33529 * 1.5e+0;
      D.33531 = (int) D.33530;
      D.33532 = (unsigned int) D.33531;
      D.33533 = monoeg_g_spaced_primes_closest (D.33532);
      table_size = (int) D.33533;
      table_size.528 = (unsigned int) table_size;
      table = monoeg_g_ptr_array_sized_new (table_size.528);
      i = 0;
      goto <D.26290>;
      <D.26289>:
      monoeg_g_ptr_array_add (table, 0B);
      i = i + 1;
      <D.26290>:
      if (i < table_size) goto <D.26289>; else goto <D.26291>;
      <D.26291>:
      i = 0;
      goto <D.26297>;
      <D.26296>:
      {
        char * name;

        D.33527 = acfg->globals;
        D.33535 = D.33527->pdata;
        D.33536 = (long unsigned int) i;
        D.33537 = D.33536 * 8;
        D.33538 = D.33535 + D.33537;
        name = *D.33538;
        D.33539 = mono_metadata_str_hash (name);
        table_size.528 = (unsigned int) table_size;
        hash = D.33539 % table_size.528;
        new_entry = monoeg_malloc0 (16);
        i.529 = (unsigned int) i;
        new_entry->value = i.529;
        D.33541 = table->pdata;
        D.33542 = (long unsigned int) hash;
        D.33543 = D.33542 * 8;
        D.33544 = D.33541 + D.33543;
        entry = *D.33544;
        if (entry == 0B) goto <D.33545>; else goto <D.33546>;
        <D.33545>:
        new_entry->index = hash;
        D.33541 = table->pdata;
        D.33542 = (long unsigned int) hash;
        D.33543 = D.33542 * 8;
        D.33544 = D.33541 + D.33543;
        *D.33544 = new_entry;
        goto <D.33547>;
        <D.33546>:
        goto <D.26294>;
        <D.26293>:
        entry = entry->next;
        <D.26294>:
        D.33548 = entry->next;
        if (D.33548 != 0B) goto <D.26293>; else goto <D.26295>;
        <D.26295>:
        entry->next = new_entry;
        D.33549 = table->len;
        new_entry->index = D.33549;
        monoeg_g_ptr_array_add (table, new_entry);
        <D.33547>:
      }
      i = i + 1;
      <D.26297>:
      i.530 = (unsigned int) i;
      D.33527 = acfg->globals;
      D.33528 = D.33527->len;
      if (i.530 < D.33528) goto <D.26296>; else goto <D.26298>;
      <D.26298>:
      sprintf (&symbol, ".Lglobals_hash");
      emit_section_change (acfg, ".rodata", 0);
      emit_alignment (acfg, 8);
      emit_label (acfg, &symbol);
      D.33551 = table_size > 64999;
      D.33552 = (long int) D.33551;
      D.33553 = __builtin_expect (D.33552, 0);
      if (D.33553 != 0) goto <D.33554>; else goto <D.33555>;
      <D.33554>:
      monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "aot-compiler.c", 7948, "table_size < 65000");
      <D.33555>:
      emit_int16 (acfg, table_size);
      i = 0;
      goto <D.26301>;
      <D.26300>:
      {
        struct GlobalsTableEntry * entry;

        D.33541 = table->pdata;
        D.33536 = (long unsigned int) i;
        D.33537 = D.33536 * 8;
        D.33556 = D.33541 + D.33537;
        entry = *D.33556;
        if (entry == 0B) goto <D.33557>; else goto <D.33558>;
        <D.33557>:
        emit_int16 (acfg, 0);
        emit_int16 (acfg, 0);
        goto <D.33559>;
        <D.33558>:
        D.33560 = entry->value;
        D.33561 = D.33560 + 1;
        D.33562 = (int) D.33561;
        emit_int16 (acfg, D.33562);
        D.33563 = entry->next;
        if (D.33563 != 0B) goto <D.33564>; else goto <D.33565>;
        <D.33564>:
        D.33563 = entry->next;
        D.33566 = D.33563->index;
        D.33567 = (int) D.33566;
        emit_int16 (acfg, D.33567);
        goto <D.33568>;
        <D.33565>:
        emit_int16 (acfg, 0);
        <D.33568>:
        <D.33559>:
      }
      i = i + 1;
      <D.26301>:
      i.530 = (unsigned int) i;
      D.33549 = table->len;
      if (i.530 < D.33549) goto <D.26300>; else goto <D.26302>;
      <D.26302>:
      i = 0;
      goto <D.26305>;
      <D.26304>:
      {
        char * name;

        D.33527 = acfg->globals;
        D.33535 = D.33527->pdata;
        D.33536 = (long unsigned int) i;
        D.33537 = D.33536 * 8;
        D.33538 = D.33535 + D.33537;
        name = *D.33538;
        sprintf (&symbol, "name_%d", i);
        emit_section_change (acfg, ".rodata", 1);
        emit_label (acfg, &symbol);
        emit_string (acfg, name);
      }
      i = i + 1;
      <D.26305>:
      i.530 = (unsigned int) i;
      D.33527 = acfg->globals;
      D.33528 = D.33527->len;
      if (i.530 < D.33528) goto <D.26304>; else goto <D.26306>;
      <D.26306>:
      sprintf (&symbol, "globals");
      emit_section_change (acfg, ".data", 0);
      emit_alignment (acfg, 8);
      emit_label (acfg, &symbol);
      D.33569 = acfg->temp_prefix;
      sprintf (&symbol, "%sglobals_hash", D.33569);
      emit_pointer (acfg, &symbol);
      i = 0;
      goto <D.26309>;
      <D.26308>:
      {
        char * name;

        D.33527 = acfg->globals;
        D.33535 = D.33527->pdata;
        D.33536 = (long unsigned int) i;
        D.33537 = D.33536 * 8;
        D.33538 = D.33535 + D.33537;
        name = *D.33538;
        sprintf (&symbol, "name_%d", i);
        emit_pointer (acfg, &symbol);
        sprintf (&symbol, "%s", name);
        emit_pointer (acfg, &symbol);
      }
      i = i + 1;
      <D.26309>:
      i.530 = (unsigned int) i;
      D.33527 = acfg->globals;
      D.33528 = D.33527->len;
      if (i.530 < D.33528) goto <D.26308>; else goto <D.26310>;
      <D.26310>:
      emit_int32 (acfg, 0);
      emit_int32 (acfg, 0);
    }
  finally
    {
      symbol = {CLOBBER};
    }
}


emit_autoreg (struct MonoAotCompile * acfg)
{
  int D.33575;
  int D.33577;
  int D.33579;
  char * D.33580;
  char * symbol;

  D.33575 = acfg->use_bin_writer;
  if (D.33575 != 0) goto <D.33573>; else goto <D.33576>;
  <D.33576>:
  D.33577 = acfg->aot_opts.static_link;
  if (D.33577 == 0) goto <D.33573>; else goto <D.33578>;
  <D.33578>:
  D.33579 = acfg->aot_opts.autoreg;
  if (D.33579 == 0) goto <D.33573>; else goto <D.33574>;
  <D.33573>:
  return;
  <D.33574>:
  D.33580 = acfg->static_linking_symbol;
  symbol = monoeg_g_strdup_printf ("_%s_autoreg", D.33580);
  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.33582;
  long unsigned int D.33583;
  long unsigned int D.33584;
  struct MonoCompile * * D.33585;
  unsigned char D.33588;
  unsigned char D.33589;
  const char * D.33592;
  struct MonoDomain * D.33593;
  struct MonoJitInfo * D.33594;
  struct MonoMethod * D.33595;
  struct MonoDebugMethodJitInfo * D.33596;
  struct GSList * D.33597;
  struct MonoInst * * D.33598;
  struct MonoInst * * D.33599;
  int D.33600;
  unsigned int D.33601;
  void * D.33602;
  char * D.33603;
  struct MonoMethod * D.33604;
  struct MonoDwarfWriter * D.33605;
  unsigned int i.531;
  unsigned int D.33607;
  int i;
  char symbol2[128];

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

        D.33582 = acfg->cfgs;
        D.33583 = (long unsigned int) i;
        D.33584 = D.33583 * 8;
        D.33585 = D.33582 + D.33584;
        cfg = *D.33585;
        if (cfg == 0B) goto <D.33586>; else goto <D.33587>;
        <D.33586>:
        // predicted unlikely by continue predictor.
        goto <D.26363>;
        <D.33587>:
        D.33588 = BIT_FIELD_REF <*cfg, 8, 5608>;
        D.33589 = D.33588 & 1;
        if (D.33589 != 0) goto <D.33590>; else goto <D.33591>;
        <D.33590>:
        // predicted unlikely by continue predictor.
        goto <D.26363>;
        <D.33591>:
        D.33592 = acfg->temp_prefix;
        sprintf (&symbol2, "%sme_%x", D.33592, i);
        D.33593 = mono_domain_get ();
        D.33594 = cfg->jit_info;
        D.33595 = D.33594->d.method;
        D.33596 = mono_debug_find_method (D.33595, D.33593);
        D.33597 = cfg->unwind_ops;
        D.33598 = cfg->locals;
        D.33599 = cfg->args;
        D.33594 = cfg->jit_info;
        D.33600 = D.33594->code_size;
        D.33601 = (unsigned int) D.33600;
        D.33594 = cfg->jit_info;
        D.33602 = D.33594->code_start;
        D.33603 = cfg->asm_symbol;
        D.33604 = cfg->method;
        D.33605 = acfg->dwarf;
        mono_dwarf_writer_emit_method (D.33605, cfg, D.33604, D.33603, &symbol2, D.33602, D.33601, D.33599, D.33598, D.33597, D.33596);
      }
      <D.26363>:
      i = i + 1;
      <D.26365>:
      i.531 = (unsigned int) i;
      D.33607 = acfg->nmethods;
      if (i.531 < D.33607) goto <D.26364>; else goto <D.26366>;
      <D.26366>:
    }
  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.33608;

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


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

  D.33611 = __builtin_object_size (__dest, 1);
  D.33610 = __builtin___strcpy_chk (__dest, __src, D.33611);
  return D.33610;
}


compile_asm (struct MonoAotCompile * acfg)
{
  const char * iftmp.532;
  char * D.33614;
  int D.33618;
  char * D.33621;
  int D.33622;
  char * D.33625;
  int D.33626;
  char * D.33629;
  struct MonoImage * D.33633;
  char * D.33634;
  const char * iftmp.533;
  struct GString * D.33637;
  int D.33641;
  int D.33649;
  int D.33652;
  char * command;
  char * objfile;
  char * outfile_name;
  char * tmp_outfile_name;
  const char * tool_prefix;

  D.33614 = acfg->aot_opts.tool_prefix;
  if (D.33614 != 0B) goto <D.33615>; else goto <D.33616>;
  <D.33615>:
  iftmp.532 = acfg->aot_opts.tool_prefix;
  goto <D.33617>;
  <D.33616>:
  iftmp.532 = "";
  <D.33617>:
  tool_prefix = iftmp.532;
  D.33618 = acfg->aot_opts.asm_only;
  if (D.33618 != 0) goto <D.33619>; else goto <D.33620>;
  <D.33619>:
  D.33621 = acfg->tmpfname;
  printf ("Output file: \'%s\'.\n", D.33621);
  D.33622 = acfg->aot_opts.static_link;
  if (D.33622 != 0) goto <D.33623>; else goto <D.33624>;
  <D.33623>:
  D.33625 = acfg->static_linking_symbol;
  printf ("Linking symbol: \'%s\'.\n", D.33625);
  <D.33624>:
  D.33626 = 0;
  return D.33626;
  <D.33620>:
  D.33622 = acfg->aot_opts.static_link;
  if (D.33622 != 0) goto <D.33627>; else goto <D.33628>;
  <D.33627>:
  D.33629 = acfg->aot_opts.outfile;
  if (D.33629 != 0B) goto <D.33630>; else goto <D.33631>;
  <D.33630>:
  D.33629 = acfg->aot_opts.outfile;
  objfile = monoeg_g_strdup_printf ("%s", D.33629);
  goto <D.33632>;
  <D.33631>:
  D.33633 = acfg->image;
  D.33634 = D.33633->name;
  objfile = monoeg_g_strdup_printf ("%s.o", D.33634);
  <D.33632>:
  goto <D.33635>;
  <D.33628>:
  D.33621 = acfg->tmpfname;
  objfile = monoeg_g_strdup_printf ("%s.o", D.33621);
  <D.33635>:
  D.33621 = acfg->tmpfname;
  D.33637 = acfg->as_args;
  if (D.33637 != 0B) goto <D.33638>; else goto <D.33639>;
  <D.33638>:
  D.33637 = acfg->as_args;
  iftmp.533 = D.33637->str;
  goto <D.33640>;
  <D.33639>:
  iftmp.533 = "";
  <D.33640>:
  command = monoeg_g_strdup_printf ("%s%s %s %s -o %s %s", tool_prefix, "as", "--64", iftmp.533, objfile, D.33621);
  printf ("Executing the native assembler: %s\n", command);
  D.33641 = system (command);
  if (D.33641 != 0) goto <D.33642>; else goto <D.33643>;
  <D.33642>:
  monoeg_g_free (command);
  monoeg_g_free (objfile);
  D.33626 = 1;
  return D.33626;
  <D.33643>:
  monoeg_g_free (command);
  D.33622 = acfg->aot_opts.static_link;
  if (D.33622 != 0) goto <D.33644>; else goto <D.33645>;
  <D.33644>:
  printf ("Output file: \'%s\'.\n", objfile);
  D.33625 = acfg->static_linking_symbol;
  printf ("Linking symbol: \'%s\'.\n", D.33625);
  monoeg_g_free (objfile);
  D.33626 = 0;
  return D.33626;
  <D.33645>:
  D.33629 = acfg->aot_opts.outfile;
  if (D.33629 != 0B) goto <D.33646>; else goto <D.33647>;
  <D.33646>:
  D.33629 = acfg->aot_opts.outfile;
  outfile_name = monoeg_g_strdup_printf ("%s", D.33629);
  goto <D.33648>;
  <D.33647>:
  D.33633 = acfg->image;
  D.33634 = D.33633->name;
  outfile_name = monoeg_g_strdup_printf ("%s%s", D.33634, ".so");
  <D.33648>:
  tmp_outfile_name = monoeg_g_strdup_printf ("%s.tmp", outfile_name);
  D.33621 = acfg->tmpfname;
  command = monoeg_g_strdup_printf ("%sld %s -shared -o %s %s.o", tool_prefix, "", tmp_outfile_name, D.33621);
  printf ("Executing the native linker: %s\n", command);
  D.33649 = system (command);
  if (D.33649 != 0) goto <D.33650>; else goto <D.33651>;
  <D.33650>:
  monoeg_g_free (tmp_outfile_name);
  monoeg_g_free (outfile_name);
  monoeg_g_free (command);
  monoeg_g_free (objfile);
  D.33626 = 1;
  return D.33626;
  <D.33651>:
  monoeg_g_free (command);
  rename (tmp_outfile_name, outfile_name);
  D.33652 = acfg->aot_opts.save_temps;
  if (D.33652 == 0) goto <D.33653>; else goto <D.33654>;
  <D.33653>:
  unlink (objfile);
  <D.33654>:
  monoeg_g_free (tmp_outfile_name);
  monoeg_g_free (outfile_name);
  monoeg_g_free (objfile);
  D.33652 = acfg->aot_opts.save_temps;
  if (D.33652 != 0) goto <D.33655>; else goto <D.33656>;
  <D.33655>:
  printf ("Retained input file.\n");
  goto <D.33657>;
  <D.33656>:
  D.33621 = acfg->tmpfname;
  unlink (D.33621);
  <D.33657>:
  D.33626 = 0;
  return D.33626;
}


get_patch_name (int info)
{
  const char * D.33659;
  short int D.33660;
  sizetype D.33661;

  D.33660 = opidx[info];
  D.33661 = (sizetype) D.33660;
  D.33659 = &opstr + D.33661;
  return D.33659;
}


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

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


acfg_free (struct MonoAotCompile * acfg)
{
  struct MonoImageWriter * D.33665;
  struct MonoCompile * * D.33666;
  long unsigned int D.33667;
  long unsigned int D.33668;
  struct MonoCompile * * D.33669;
  struct MonoCompile * D.33670;
  unsigned int i.534;
  unsigned int D.33674;
  char * D.33675;
  char * D.33676;
  char * D.33677;
  struct GPtrArray * D.33678;
  struct GPtrArray * D.33679;
  struct GPtrArray * D.33680;
  struct GPtrArray * D.33681;
  struct GPtrArray * D.33682;
  struct GHashTable * D.33683;
  struct GHashTable * D.33684;
  struct GHashTable * D.33685;
  struct GHashTable * * D.33686;
  struct GHashTable * * D.33687;
  struct GHashTable * D.33688;
  struct GHashTable * D.33691;
  struct GHashTable * D.33692;
  struct GHashTable * D.33693;
  struct GHashTable * D.33694;
  struct GHashTable * D.33695;
  struct GHashTable * D.33696;
  struct GHashTable * D.33697;
  struct GHashTable * D.33698;
  struct GHashTable * D.33699;
  struct GHashTable * D.33700;
  struct GHashTable * D.33701;
  struct GHashTable * * D.33702;
  struct GHashTable * * D.33703;
  struct GHashTable * D.33704;
  struct MonoMemPool * D.33705;
  int i;

  D.33665 = acfg->w;
  img_writer_destroy (D.33665);
  i = 0;
  goto <D.26436>;
  <D.26435>:
  D.33666 = acfg->cfgs;
  D.33667 = (long unsigned int) i;
  D.33668 = D.33667 * 8;
  D.33669 = D.33666 + D.33668;
  D.33670 = *D.33669;
  if (D.33670 != 0B) goto <D.33671>; else goto <D.33672>;
  <D.33671>:
  D.33666 = acfg->cfgs;
  D.33667 = (long unsigned int) i;
  D.33668 = D.33667 * 8;
  D.33669 = D.33666 + D.33668;
  D.33670 = *D.33669;
  monoeg_g_free (D.33670);
  <D.33672>:
  i = i + 1;
  <D.26436>:
  i.534 = (unsigned int) i;
  D.33674 = acfg->nmethods;
  if (i.534 < D.33674) goto <D.26435>; else goto <D.26437>;
  <D.26437>:
  D.33666 = acfg->cfgs;
  monoeg_g_free (D.33666);
  D.33675 = acfg->static_linking_symbol;
  monoeg_g_free (D.33675);
  D.33676 = acfg->got_symbol;
  monoeg_g_free (D.33676);
  D.33677 = acfg->plt_symbol;
  monoeg_g_free (D.33677);
  D.33678 = acfg->methods;
  monoeg_g_ptr_array_free (D.33678, 1);
  D.33679 = acfg->got_patches;
  monoeg_g_ptr_array_free (D.33679, 1);
  D.33680 = acfg->image_table;
  monoeg_g_ptr_array_free (D.33680, 1);
  D.33681 = acfg->globals;
  monoeg_g_ptr_array_free (D.33681, 1);
  D.33682 = acfg->unwind_ops;
  monoeg_g_ptr_array_free (D.33682, 1);
  D.33683 = acfg->method_indexes;
  monoeg_g_hash_table_destroy (D.33683);
  D.33684 = acfg->method_depth;
  monoeg_g_hash_table_destroy (D.33684);
  D.33685 = acfg->plt_offset_to_entry;
  monoeg_g_hash_table_destroy (D.33685);
  i = 0;
  goto <D.26439>;
  <D.26438>:
  D.33686 = acfg->patch_to_plt_entry;
  D.33667 = (long unsigned int) i;
  D.33668 = D.33667 * 8;
  D.33687 = D.33686 + D.33668;
  D.33688 = *D.33687;
  if (D.33688 != 0B) goto <D.33689>; else goto <D.33690>;
  <D.33689>:
  D.33686 = acfg->patch_to_plt_entry;
  D.33667 = (long unsigned int) i;
  D.33668 = D.33667 * 8;
  D.33687 = D.33686 + D.33668;
  D.33688 = *D.33687;
  monoeg_g_hash_table_destroy (D.33688);
  <D.33690>:
  i = i + 1;
  <D.26439>:
  if (i <= 51) goto <D.26438>; else goto <D.26440>;
  <D.26440>:
  D.33686 = acfg->patch_to_plt_entry;
  monoeg_g_free (D.33686);
  D.33691 = acfg->patch_to_got_offset;
  monoeg_g_hash_table_destroy (D.33691);
  D.33692 = acfg->method_to_cfg;
  monoeg_g_hash_table_destroy (D.33692);
  D.33693 = acfg->token_info_hash;
  monoeg_g_hash_table_destroy (D.33693);
  D.33694 = acfg->method_to_pinvoke_import;
  monoeg_g_hash_table_destroy (D.33694);
  D.33695 = acfg->image_hash;
  monoeg_g_hash_table_destroy (D.33695);
  D.33696 = acfg->unwind_info_offsets;
  monoeg_g_hash_table_destroy (D.33696);
  D.33697 = acfg->method_label_hash;
  monoeg_g_hash_table_destroy (D.33697);
  D.33698 = acfg->export_names;
  monoeg_g_hash_table_destroy (D.33698);
  D.33699 = acfg->plt_entry_debug_sym_cache;
  monoeg_g_hash_table_destroy (D.33699);
  D.33700 = acfg->klass_blob_hash;
  monoeg_g_hash_table_destroy (D.33700);
  D.33701 = acfg->method_blob_hash;
  monoeg_g_hash_table_destroy (D.33701);
  i = 0;
  goto <D.26442>;
  <D.26441>:
  D.33702 = acfg->patch_to_got_offset_by_type;
  D.33667 = (long unsigned int) i;
  D.33668 = D.33667 * 8;
  D.33703 = D.33702 + D.33668;
  D.33704 = *D.33703;
  monoeg_g_hash_table_destroy (D.33704);
  i = i + 1;
  <D.26442>:
  if (i <= 51) goto <D.26441>; else goto <D.26443>;
  <D.26443>:
  D.33702 = acfg->patch_to_got_offset_by_type;
  monoeg_g_free (D.33702);
  D.33705 = acfg->mempool;
  mono_mempool_destroy (D.33705);
  monoeg_g_free (acfg);
}