mono_aot_readonly_field_override (struct MonoClassField * field)
{
  struct MonoClass * D.26127;
  const char * D.26128;
  unsigned int D.26129;
  unsigned int len.0;
  int D.26131;
  sizetype len.1;
  char * p.2;
  char D.26136;
  const char * D.26139;
  unsigned int D.26140;
  int D.26141;
  char * p.3;
  char D.26145;
  int D.25395;
  const char * D.26148;
  int D.26151;
  void * D.26152;
  struct ReadOnlyValue * rdv;

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

    p = rdv->name;
    D.26127 = field->parent;
    D.26128 = D.26127->name_space;
    D.26129 = strlen (D.26128);
    len = (int) D.26129;
    len.0 = (unsigned int) len;
    D.26127 = field->parent;
    D.26128 = D.26127->name_space;
    D.26131 = strncmp (p, D.26128, len.0);
    if (D.26131 != 0) goto <D.26132>; else goto <D.26133>;
    <D.26132>:
    // predicted unlikely by continue predictor.
    goto <D.25377>;
    <D.26133>:
    len.1 = (sizetype) len;
    p = p + len.1;
    p.2 = p;
    p = p.2 + 1;
    D.26136 = *p.2;
    if (D.26136 != 46) goto <D.26137>; else goto <D.26138>;
    <D.26137>:
    // predicted unlikely by continue predictor.
    goto <D.25377>;
    <D.26138>:
    D.26127 = field->parent;
    D.26139 = D.26127->name;
    D.26140 = strlen (D.26139);
    len = (int) D.26140;
    len.0 = (unsigned int) len;
    D.26127 = field->parent;
    D.26139 = D.26127->name;
    D.26141 = strncmp (p, D.26139, len.0);
    if (D.26141 != 0) goto <D.26142>; else goto <D.26143>;
    <D.26142>:
    // predicted unlikely by continue predictor.
    goto <D.25377>;
    <D.26143>:
    len.1 = (sizetype) len;
    p = p + len.1;
    p.3 = p;
    p = p.3 + 1;
    D.26145 = *p.3;
    if (D.26145 != 46) goto <D.26146>; else goto <D.26147>;
    <D.26146>:
    // predicted unlikely by continue predictor.
    goto <D.25377>;
    <D.26147>:
    {
      size_t __s1_len;
      size_t __s2_len;

      D.26148 = field->name;
      D.25395 = __builtin_strcmp (p, D.26148);
    }
    if (D.25395 != 0) goto <D.26149>; else goto <D.26150>;
    <D.26149>:
    // predicted unlikely by continue predictor.
    goto <D.25377>;
    <D.26150>:
    D.26151 = rdv->type;
    switch (D.26151) <default: <D.25399>, case 4: <D.25396>, case 6: <D.25397>, case 8: <D.25398>>
    <D.25396>:
    D.26152 = &rdv->value.i1;
    return D.26152;
    <D.25397>:
    D.26152 = &rdv->value.i2;
    return D.26152;
    <D.25398>:
    D.26152 = &rdv->value.i4;
    return D.26152;
    <D.25399>:
    goto <D.25400>;
    <D.25400>:
  }
  <D.25377>:
  rdv = rdv->next;
  <D.25402>:
  if (rdv != 0B) goto <D.25401>; else goto <D.25403>;
  <D.25403>:
  D.26152 = 0B;
  return D.26152;
}


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

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


get_got_offset (struct MonoAotCompile * acfg, struct MonoJumpInfo * ji)
{
  struct GHashTable * * D.26158;
  <unnamed type> D.26159;
  unsigned int D.26160;
  struct GHashTable * * D.26161;
  struct GHashTable * D.26162;
  void * D.26163;
  guint32 D.26166;
  unsigned int D.26167;
  unsigned int D.26168;
  unsigned int D.26169;
  _Bool D.26172;
  long int D.26173;
  long int D.26174;
  int D.26177;
  int D.26178;
  int D.26179;
  int D.26180;
  unsigned int D.26181;
  void * D.26182;
  struct GHashTable * D.26183;
  struct GPtrArray * D.26184;
  guint32 got_offset;

  D.26158 = acfg->patch_to_got_offset_by_type;
  D.26159 = ji->type;
  D.26160 = D.26159 * 4;
  D.26161 = D.26158 + D.26160;
  D.26162 = *D.26161;
  D.26163 = monoeg_g_hash_table_lookup (D.26162, ji);
  got_offset = (guint32) D.26163;
  if (got_offset != 0) goto <D.26164>; else goto <D.26165>;
  <D.26164>:
  D.26166 = got_offset + 4294967295;
  return D.26166;
  <D.26165>:
  got_offset = acfg->got_offset;
  D.26167 = acfg->got_offset;
  D.26168 = D.26167 + 1;
  acfg->got_offset = D.26168;
  D.26169 = acfg->final_got_size;
  if (D.26169 != 0) goto <D.26170>; else goto <D.26171>;
  <D.26170>:
  D.26169 = acfg->final_got_size;
  D.26172 = D.26169 <= got_offset;
  D.26173 = (long int) D.26172;
  D.26174 = __builtin_expect (D.26173, 0);
  if (D.26174 != 0) goto <D.26175>; else goto <D.26176>;
  <D.26175>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "aot-compiler.c", 2978, "got_offset < acfg->final_got_size");
  <D.26176>:
  <D.26171>:
  D.26177 = acfg->stats.got_slots;
  D.26178 = D.26177 + 1;
  acfg->stats.got_slots = D.26178;
  D.26159 = ji->type;
  D.26179 = acfg->stats.got_slot_types[D.26159];
  D.26180 = D.26179 + 1;
  acfg->stats.got_slot_types[D.26159] = D.26180;
  D.26181 = got_offset + 1;
  D.26182 = (void *) D.26181;
  D.26183 = acfg->patch_to_got_offset;
  monoeg_g_hash_table_insert_replace (D.26183, ji, D.26182, 0);
  D.26181 = got_offset + 1;
  D.26182 = (void *) D.26181;
  D.26158 = acfg->patch_to_got_offset_by_type;
  D.26159 = ji->type;
  D.26160 = D.26159 * 4;
  D.26161 = D.26158 + D.26160;
  D.26162 = *D.26161;
  monoeg_g_hash_table_insert_replace (D.26162, ji, D.26182, 0);
  D.26184 = acfg->got_patches;
  monoeg_g_ptr_array_add (D.26184, ji);
  D.26166 = got_offset;
  return D.26166;
}


mono_aot_get_method_name (struct MonoCompile * cfg)
{
  struct MonoAotCompile * llvm_acfg.5;
  int D.26187;
  char * D.26190;
  struct GHashTable * D.26191;
  struct MonoMethod * D.26192;
  char * D.26193;
  char * D.26194;

  llvm_acfg.5 = llvm_acfg;
  D.26187 = llvm_acfg.5->aot_opts.static_link;
  if (D.26187 != 0) goto <D.26188>; else goto <D.26189>;
  <D.26188>:
  llvm_acfg.5 = llvm_acfg;
  D.26191 = llvm_acfg.5->method_label_hash;
  D.26192 = cfg->orig_method;
  D.26193 = get_debug_sym (D.26192, "", D.26191);
  llvm_acfg.5 = llvm_acfg;
  D.26194 = llvm_acfg.5->assembly_name_sym;
  D.26190 = monoeg_g_strdup_printf ("%s_%s", D.26194, D.26193);
  return D.26190;
  <D.26189>:
  llvm_acfg.5 = llvm_acfg;
  D.26191 = llvm_acfg.5->method_label_hash;
  D.26192 = cfg->orig_method;
  D.26190 = get_debug_sym (D.26192, "", D.26191);
  return D.26190;
}


get_debug_sym (struct MonoMethod * method, const char * prefix, struct GHashTable * cache)
{
  unsigned int D.26196;
  unsigned int D.26197;
  unsigned int len.6;
  unsigned int D.26199;
  unsigned int D.26200;
  unsigned int D.26201;
  unsigned int D.26202;
  const short unsigned int * * D.26203;
  const short unsigned int * D.26204;
  sizetype i.7;
  char * D.26206;
  char D.26207;
  unsigned int D.26208;
  unsigned int D.26209;
  const short unsigned int * D.26210;
  short unsigned int D.26211;
  int D.26212;
  int D.26213;
  int j.8;
  sizetype j.9;
  char * D.26218;
  sizetype D.26223;
  char * D.26224;
  char D.26225;
  sizetype D.26227;
  char * D.26228;
  char D.26229;
  int j.10;
  sizetype j.11;
  char * D.26237;
  char D.26238;
  unsigned char D.26239;
  unsigned char D.26240;
  _Bool D.26241;
  _Bool D.26242;
  _Bool D.26243;
  int j.12;
  sizetype j.13;
  char * D.26249;
  sizetype j.14;
  char * D.26251;
  void * D.26252;
  char * D.26253;
  char * name1;
  char * name2;
  char * cached;
  int i;
  int j;
  int len;
  int count;

  name1 = mono_method_full_name (method, 1);
  D.26196 = strlen (name1);
  len = (int) D.26196;
  D.26197 = strlen (prefix);
  len.6 = (unsigned int) len;
  D.26199 = D.26197 + len.6;
  D.26200 = D.26199 + 16;
  name2 = malloc (D.26200);
  D.26201 = strlen (prefix);
  memcpy (name2, prefix, D.26201);
  D.26202 = strlen (prefix);
  j = (int) D.26202;
  i = 0;
  goto <D.24980>;
  <D.24979>:
  D.26203 = __ctype_b_loc ();
  D.26204 = *D.26203;
  i.7 = (sizetype) i;
  D.26206 = name1 + i.7;
  D.26207 = *D.26206;
  D.26208 = (unsigned int) D.26207;
  D.26209 = D.26208 * 2;
  D.26210 = D.26204 + D.26209;
  D.26211 = *D.26210;
  D.26212 = (int) D.26211;
  D.26213 = D.26212 & 8;
  if (D.26213 != 0) goto <D.26214>; else goto <D.26215>;
  <D.26214>:
  j.8 = j;
  j = j.8 + 1;
  j.9 = (sizetype) j.8;
  D.26218 = name2 + j.9;
  i.7 = (sizetype) i;
  D.26206 = name1 + i.7;
  D.26207 = *D.26206;
  *D.26218 = D.26207;
  goto <D.26219>;
  <D.26215>:
  i.7 = (sizetype) i;
  D.26206 = name1 + i.7;
  D.26207 = *D.26206;
  if (D.26207 == 32) goto <D.26222>; else goto <D.26220>;
  <D.26222>:
  i.7 = (sizetype) i;
  D.26223 = i.7 + 1;
  D.26224 = name1 + D.26223;
  D.26225 = *D.26224;
  if (D.26225 == 40) goto <D.26226>; else goto <D.26220>;
  <D.26226>:
  i.7 = (sizetype) i;
  D.26227 = i.7 + 2;
  D.26228 = name1 + D.26227;
  D.26229 = *D.26228;
  if (D.26229 == 41) goto <D.26230>; else goto <D.26220>;
  <D.26230>:
  i = i + 2;
  goto <D.26221>;
  <D.26220>:
  i.7 = (sizetype) i;
  D.26206 = name1 + i.7;
  D.26207 = *D.26206;
  if (D.26207 == 44) goto <D.26233>; else goto <D.26231>;
  <D.26233>:
  i.7 = (sizetype) i;
  D.26223 = i.7 + 1;
  D.26224 = name1 + D.26223;
  D.26225 = *D.26224;
  if (D.26225 == 32) goto <D.26234>; else goto <D.26231>;
  <D.26234>:
  j.10 = j;
  j = j.10 + 1;
  j.11 = (sizetype) j.10;
  D.26237 = name2 + j.11;
  *D.26237 = 95;
  i = i + 1;
  goto <D.26232>;
  <D.26231>:
  i.7 = (sizetype) i;
  D.26206 = name1 + i.7;
  D.26238 = *D.26206;
  D.26239 = (unsigned char) D.26238;
  D.26240 = D.26239 + 216;
  D.26241 = D.26240 <= 1;
  D.26242 = D.26238 == 62;
  D.26243 = D.26241 | D.26242;
  if (D.26243 != 0) goto <D.26244>; else goto <D.26245>;
  <D.26244>:
  goto <D.26246>;
  <D.26245>:
  j.12 = j;
  j = j.12 + 1;
  j.13 = (sizetype) j.12;
  D.26249 = name2 + j.13;
  *D.26249 = 95;
  <D.26246>:
  <D.26232>:
  <D.26221>:
  <D.26219>:
  i = i + 1;
  <D.24980>:
  if (i < len) goto <D.24979>; else goto <D.24981>;
  <D.24981>:
  j.14 = (sizetype) j;
  D.26251 = name2 + j.14;
  *D.26251 = 0;
  monoeg_g_free (name1);
  count = 0;
  goto <D.24983>;
  <D.24982>:
  j.14 = (sizetype) j;
  D.26251 = name2 + j.14;
  sprintf (D.26251, "_%d", count);
  count = count + 1;
  <D.24983>:
  D.26252 = monoeg_g_hash_table_lookup (cache, name2);
  if (D.26252 != 0B) goto <D.24982>; else goto <D.24984>;
  <D.24984>:
  cached = monoeg_strdup (name2);
  monoeg_g_hash_table_insert_replace (cache, cached, cached, 0);
  D.26253 = name2;
  return D.26253;
}


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

  D.26256 = __builtin_object_size (__dest, 0);
  D.26255 = __builtin___memcpy_chk (__dest, __src, __len, D.26256);
  return D.26255;
}


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

  D.26259 = __builtin_object_size (__s, 1);
  D.26258 = __builtin___sprintf_chk (__s, 1, D.26259, __fmt, __builtin_va_arg_pack ());
  return D.26258;
}


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

  if (str != 0B) goto <D.26261>; else goto <D.26262>;
  <D.26261>:
  D.26263 = __strdup (str);
  return D.26263;
  <D.26262>:
  D.26263 = 0B;
  return D.26263;
}


mono_aot_get_plt_symbol (MonoJumpInfoType type, const void * data)
{
  struct MonoAotCompile * llvm_acfg.15;
  struct MonoMemPool * D.26266;
  int D.26267;
  char * D.26270;
  char * D.26271;
  struct MonoJumpInfo * ji;
  struct MonoPltEntry * plt_entry;

  llvm_acfg.15 = llvm_acfg;
  D.26266 = llvm_acfg.15->mempool;
  ji = mono_mempool_alloc (D.26266, 20);
  ji->type = type;
  ji->data.target = data;
  llvm_acfg.15 = llvm_acfg;
  D.26267 = can_encode_patch (llvm_acfg.15, ji);
  if (D.26267 == 0) goto <D.26268>; else goto <D.26269>;
  <D.26268>:
  D.26270 = 0B;
  return D.26270;
  <D.26269>:
  llvm_acfg.15 = llvm_acfg;
  plt_entry = get_plt_entry (llvm_acfg.15, ji);
  plt_entry->llvm_used = 1;
  D.26271 = plt_entry->llvm_symbol;
  D.26270 = monoeg_g_strdup_printf (D.26271);
  return D.26270;
}


can_encode_patch (struct MonoAotCompile * acfg, struct MonoJumpInfo * patch_info)
{
  <unnamed type> D.26273;
  gboolean D.26274;
  struct MonoClass * D.26275;
  int D.26276;
  struct MonoMethod * D.26279;
  int D.26280;
  struct MonoJumpInfo * D.26283;
  int D.26284;

  D.26273 = patch_info->type;
  switch (D.26273) <default: <D.25506>, case 3: <D.25493>, case 6: <D.25494>, case 11: <D.25500>, case 14: <D.25497>, case 15: <D.25498>, case 23: <D.25501>, case 24: <D.25502>, case 30: <D.25499>, case 35: <D.25504>, case 50: <D.25495>>
  <D.25493>:
  <D.25494>:
  <D.25495>:
  {
    struct MonoMethod * method;

    method = patch_info->data.method;
    D.26274 = can_encode_method (acfg, method);
    return D.26274;
  }
  <D.25497>:
  <D.25498>:
  <D.25499>:
  <D.25500>:
  <D.25501>:
  <D.25502>:
  D.26275 = patch_info->data.klass;
  D.26276 = can_encode_class (acfg, D.26275);
  if (D.26276 == 0) goto <D.26277>; else goto <D.26278>;
  <D.26277>:
  D.26274 = 0;
  return D.26274;
  <D.26278>:
  goto <D.25503>;
  <D.25504>:
  {
    struct MonoJumpInfoRgctxEntry * entry;

    entry = patch_info->data.rgctx_entry;
    D.26279 = entry->method;
    D.26280 = can_encode_method (acfg, D.26279);
    if (D.26280 == 0) goto <D.26281>; else goto <D.26282>;
    <D.26281>:
    D.26274 = 0;
    return D.26274;
    <D.26282>:
    D.26283 = entry->data;
    D.26284 = can_encode_patch (acfg, D.26283);
    if (D.26284 == 0) goto <D.26285>; else goto <D.26286>;
    <D.26285>:
    D.26274 = 0;
    return D.26274;
    <D.26286>:
    goto <D.25503>;
  }
  <D.25506>:
  goto <D.25503>;
  <D.25503>:
  D.26274 = 1;
  return D.26274;
}


can_encode_class (struct MonoAotCompile * acfg, struct MonoClass * klass)
{
  unsigned int D.26289;
  gboolean D.26292;
  unsigned char D.26295;
  _Bool D.26296;
  _Bool D.26297;
  _Bool D.26298;
  unsigned char D.26300;
  unsigned char D.26301;
  struct MonoClass * D.26304;

  D.26289 = klass->type_token;
  if (D.26289 != 0) goto <D.26290>; else goto <D.26291>;
  <D.26290>:
  D.26292 = 1;
  return D.26292;
  <D.26291>:
  D.26295 = klass->byval_arg.type;
  D.26296 = D.26295 == 19;
  D.26297 = D.26295 == 30;
  D.26298 = D.26296 | D.26297;
  if (D.26298 != 0) goto <D.26293>; else goto <D.26299>;
  <D.26299>:
  D.26300 = klass->byval_arg.type;
  if (D.26300 == 15) goto <D.26293>; else goto <D.26294>;
  <D.26293>:
  D.26292 = 1;
  return D.26292;
  <D.26294>:
  D.26301 = klass->rank;
  if (D.26301 != 0) goto <D.26302>; else goto <D.26303>;
  <D.26302>:
  D.26304 = klass->element_class;
  D.26292 = can_encode_class (acfg, D.26304);
  return D.26292;
  <D.26303>:
  D.26292 = 0;
  return D.26292;
}


can_encode_method (struct MonoAotCompile * acfg, struct MonoMethod * method)
{
  unsigned char D.26306;
  unsigned char D.26307;
  <unnamed-unsigned:5> D.26310;
  int D.26311;
  gboolean D.26314;
  unsigned int D.26316;
  struct GHashTable * D.26319;
  void * D.26320;
  struct MonoClass * D.26323;
  unsigned char D.26324;

  D.26306 = BIT_FIELD_REF <*method, 8, 160>;
  D.26307 = D.26306 & 124;
  if (D.26307 != 0) goto <D.26308>; else goto <D.26309>;
  <D.26308>:
  D.26310 = method->wrapper_type;
  D.26311 = (int) D.26310;
  switch (D.26311) <default: <D.25488>, case 0: <D.25465>, case 1: <D.25480>, case 2: <D.25481>, case 3: <D.25482>, case 7: <D.25485>, case 8: <D.25477>, case 9: <D.25466>, case 10: <D.25467>, case 12: <D.25469>, case 13: <D.25468>, case 14: <D.25471>, case 15: <D.25472>, case 16: <D.25483>, case 18: <D.25474>, case 19: <D.25486>, case 20: <D.25475>, case 21: <D.25473>, case 23: <D.25470>, case 24: <D.25479>, case 25: <D.25478>, case 28: <D.25476>>
  <D.25465>:
  <D.25466>:
  <D.25467>:
  <D.25468>:
  <D.25469>:
  <D.25470>:
  <D.25471>:
  <D.25472>:
  <D.25473>:
  <D.25474>:
  <D.25475>:
  <D.25476>:
  <D.25477>:
  <D.25478>:
  <D.25479>:
  <D.25480>:
  <D.25481>:
  <D.25482>:
  <D.25483>:
  goto <D.25484>;
  <D.25485>:
  <D.25486>:
  {
    struct WrapperInfo * info;

    info = mono_marshal_get_wrapper_info (method);
    if (info != 0B) goto <D.26312>; else goto <D.26313>;
    <D.26312>:
    D.26314 = 1;
    return D.26314;
    <D.26313>:
    D.26314 = 0;
    return D.26314;
  }
  <D.25488>:
  D.26314 = 0;
  return D.26314;
  <D.25484>:
  goto <D.26315>;
  <D.26309>:
  D.26316 = method->token;
  if (D.26316 == 0) goto <D.26317>; else goto <D.26318>;
  <D.26317>:
  D.26319 = acfg->token_info_hash;
  D.26320 = monoeg_g_hash_table_lookup (D.26319, method);
  if (D.26320 == 0B) goto <D.26321>; else goto <D.26322>;
  <D.26321>:
  D.26323 = method->klass;
  D.26324 = D.26323->rank;
  if (D.26324 != 0) goto <D.26325>; else goto <D.26326>;
  <D.26325>:
  D.26314 = 1;
  return D.26314;
  <D.26326>:
  D.26314 = 0;
  return D.26314;
  <D.26322>:
  <D.26318>:
  <D.26315>:
  D.26314 = 1;
  return D.26314;
}


get_plt_entry (struct MonoAotCompile * acfg, struct MonoJumpInfo * patch_info)
{
  int D.26330;
  struct MonoPltEntry * D.26333;
  struct GHashTable * * D.26334;
  <unnamed type> D.26335;
  unsigned int D.26336;
  struct GHashTable * * D.26337;
  struct GHashTable * D.26338;
  struct GHashTable * D.26341;
  int D.26342;
  struct MonoMethod * D.26347;
  short unsigned int D.26348;
  int D.26349;
  int D.26350;
  unsigned int D.26355;
  _Bool D.26356;
  long int D.26357;
  long int D.26358;
  struct MonoMemPool * D.26361;
  unsigned int D.26362;
  int D.26363;
  int D.26364;
  char * D.26365;
  int D.26366;
  struct GHashTable * D.26369;
  struct MonoJumpInfo * D.26370;
  char * D.26371;
  char * D.26372;
  char * D.26375;
  gchar * D.26376;
  gchar * D.26378;
  <unnamed type> D.26379;
  unsigned int D.26380;
  struct GHashTable * * D.26381;
  struct GHashTable * D.26382;
  void * D.26383;
  struct GHashTable * D.26384;
  unsigned int D.26385;
  struct MonoPltEntry * res;

  D.26330 = is_plt_patch (patch_info);
  if (D.26330 == 0) goto <D.26331>; else goto <D.26332>;
  <D.26331>:
  D.26333 = 0B;
  return D.26333;
  <D.26332>:
  D.26334 = acfg->patch_to_plt_entry;
  D.26335 = patch_info->type;
  D.26336 = D.26335 * 4;
  D.26337 = D.26334 + D.26336;
  D.26338 = *D.26337;
  if (D.26338 == 0B) goto <D.26339>; else goto <D.26340>;
  <D.26339>:
  D.26334 = acfg->patch_to_plt_entry;
  D.26335 = patch_info->type;
  D.26336 = D.26335 * 4;
  D.26337 = D.26334 + D.26336;
  D.26341 = monoeg_g_hash_table_new (mono_patch_info_hash, mono_patch_info_equal);
  *D.26337 = D.26341;
  <D.26340>:
  D.26334 = acfg->patch_to_plt_entry;
  D.26335 = patch_info->type;
  D.26336 = D.26335 * 4;
  D.26337 = D.26334 + D.26336;
  D.26338 = *D.26337;
  res = monoeg_g_hash_table_lookup (D.26338, patch_info);
  D.26342 = acfg->llvm;
  if (D.26342 == 0) goto <D.26343>; else goto <D.26344>;
  <D.26343>:
  D.26335 = patch_info->type;
  if (D.26335 == 3) goto <D.26345>; else goto <D.26346>;
  <D.26345>:
  D.26347 = patch_info->data.method;
  D.26348 = D.26347->iflags;
  D.26349 = (int) D.26348;
  D.26350 = D.26349 & 32;
  if (D.26350 != 0) goto <D.26351>; else goto <D.26352>;
  <D.26351>:
  res = 0B;
  <D.26352>:
  <D.26346>:
  <D.26344>:
  if (res == 0B) goto <D.26353>; else goto <D.26354>;
  <D.26353>:
  {
    struct MonoJumpInfo * new_ji;

    D.26355 = acfg->final_got_size;
    D.26356 = D.26355 != 0;
    D.26357 = (long int) D.26356;
    D.26358 = __builtin_expect (D.26357, 0);
    if (D.26358 != 0) goto <D.26359>; else goto <D.26360>;
    <D.26359>:
    monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "aot-compiler.c", 2930, "!acfg->final_got_size");
    <D.26360>:
    D.26361 = acfg->mempool;
    new_ji = mono_patch_info_dup_mp (D.26361, patch_info);
    D.26361 = acfg->mempool;
    res = mono_mempool_alloc0 (D.26361, 28);
    D.26362 = acfg->plt_offset;
    D.26363 = (int) D.26362;
    res->plt_offset = D.26363;
    res->ji = new_ji;
    D.26364 = res->plt_offset;
    D.26365 = get_plt_symbol (acfg, D.26364, patch_info);
    res->symbol = D.26365;
    D.26366 = acfg->aot_opts.write_symbols;
    if (D.26366 != 0) goto <D.26367>; else goto <D.26368>;
    <D.26367>:
    D.26369 = acfg->plt_entry_debug_sym_cache;
    D.26370 = res->ji;
    D.26371 = get_plt_entry_debug_sym (acfg, D.26370, D.26369);
    res->debug_sym = D.26371;
    <D.26368>:
    D.26372 = res->debug_sym;
    if (D.26372 != 0B) goto <D.26373>; else goto <D.26374>;
    <D.26373>:
    D.26372 = res->debug_sym;
    D.26375 = res->symbol;
    D.26376 = monoeg_g_strdup_printf ("%s_%s_llvm", D.26375, D.26372);
    res->llvm_symbol = D.26376;
    goto <D.26377>;
    <D.26374>:
    D.26375 = res->symbol;
    D.26378 = monoeg_g_strdup_printf ("%s_llvm", D.26375);
    res->llvm_symbol = D.26378;
    <D.26377>:
    D.26334 = acfg->patch_to_plt_entry;
    D.26379 = new_ji->type;
    D.26380 = D.26379 * 4;
    D.26381 = D.26334 + D.26380;
    D.26382 = *D.26381;
    monoeg_g_hash_table_insert_replace (D.26382, new_ji, res, 0);
    D.26364 = res->plt_offset;
    D.26383 = (void *) D.26364;
    D.26384 = acfg->plt_offset_to_entry;
    monoeg_g_hash_table_insert_replace (D.26384, D.26383, res, 0);
    D.26362 = acfg->plt_offset;
    D.26385 = D.26362 + 1;
    acfg->plt_offset = D.26385;
  }
  <D.26354>:
  D.26333 = res;
  return D.26333;
}


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

  D.26387 = patch_info->type;
  switch (D.26387) <default: <D.24174>, case 3: <D.24164>, case 7: <D.24165>, case 15: <D.24168>, case 31: <D.24167>, case 32: <D.24166>, case 35: <D.24169>, case 36: <D.24170>, case 37: <D.24171>, case 38: <D.24172>, case 41: <D.24173>>
  <D.24164>:
  <D.24165>:
  <D.24166>:
  <D.24167>:
  <D.24168>:
  <D.24169>:
  <D.24170>:
  <D.24171>:
  <D.24172>:
  <D.24173>:
  D.26388 = 1;
  return D.26388;
  <D.24174>:
  D.26388 = 0;
  return D.26388;
}


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

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


get_plt_entry_debug_sym (struct MonoAotCompile * acfg, struct MonoJumpInfo * ji, struct GHashTable * cache)
{
  <unnamed type> D.26393;
  struct MonoMethod * D.26394;
  const char * D.26395;
  struct MonoClass * D.26396;
  struct MonoType * D.26397;
  unsigned int D.26398;
  unsigned int D.26399;
  unsigned int D.26400;
  char * D.26401;
  char * debug_sym;
  char * s;

  debug_sym = 0B;
  D.26393 = ji->type;
  switch (D.26393) <default: <D.25240>, case 3: <D.25231>, case 7: <D.25233>, case 15: <D.25234>, case 31: <D.25236>, case 32: <D.25238>, case 35: <D.25235>, case 36: <D.25239>>
  <D.25231>:
  D.26394 = ji->data.method;
  debug_sym = get_debug_sym (D.26394, "plt_", cache);
  goto <D.25232>;
  <D.25233>:
  D.26395 = ji->data.name;
  debug_sym = monoeg_g_strdup_printf ("plt__jit_icall_%s", D.26395);
  goto <D.25232>;
  <D.25234>:
  D.26396 = ji->data.klass;
  D.26397 = &D.26396->byval_arg;
  s = mono_type_get_name (D.26397);
  debug_sym = monoeg_g_strdup_printf ("plt__class_init_%s", s);
  monoeg_g_free (s);
  goto <D.25232>;
  <D.25235>:
  D.26398 = acfg->label_generator;
  D.26399 = D.26398;
  D.26400 = D.26399 + 1;
  acfg->label_generator = D.26400;
  debug_sym = monoeg_g_strdup_printf ("plt__rgctx_fetch_%d", D.26399);
  goto <D.25232>;
  <D.25236>:
  {
    char * s;

    D.26394 = ji->data.method;
    s = get_debug_sym (D.26394, "", cache);
    debug_sym = monoeg_g_strdup_printf ("plt__icall_native_%s", s);
    monoeg_g_free (s);
    goto <D.25232>;
  }
  <D.25238>:
  D.26395 = ji->data.name;
  debug_sym = monoeg_g_strdup_printf ("plt__jit_icall_native_%s", D.26395);
  goto <D.25232>;
  <D.25239>:
  debug_sym = monoeg_g_strdup_printf ("plt__generic_class_init");
  goto <D.25232>;
  <D.25240>:
  goto <D.25232>;
  <D.25232>:
  D.26401 = sanitize_symbol (acfg, debug_sym);
  return D.26401;
}


sanitize_symbol (struct MonoAotCompile * acfg, char * s)
{
  char * D.26406;
  unsigned int D.26407;
  const short unsigned int * * D.26408;
  const short unsigned int * D.26409;
  sizetype i.16;
  char * D.26411;
  char D.26412;
  unsigned int D.26413;
  unsigned int D.26414;
  const short unsigned int * D.26415;
  short unsigned int D.26416;
  int D.26417;
  int D.26418;
  unsigned int len.17;
  signed char c.18;
  unsigned int D.26431;
  unsigned int D.26432;
  const short unsigned int * D.26433;
  short unsigned int D.26434;
  int D.26435;
  int D.26436;
  char c.19;
  int D.26439;
  int D.26442;
  unsigned char D.26443;
  char * D.26445;
  struct MonoMemPool * D.26446;
  gboolean process;
  int i;
  int len;
  struct GString * gs;
  char * res;

  process = 0;
  if (s == 0B) goto <D.26404>; else goto <D.26405>;
  <D.26404>:
  D.26406 = s;
  return D.26406;
  <D.26405>:
  D.26407 = strlen (s);
  len = (int) D.26407;
  i = 0;
  goto <D.24958>;
  <D.24957>:
  D.26408 = __ctype_b_loc ();
  D.26409 = *D.26408;
  i.16 = (sizetype) i;
  D.26411 = s + i.16;
  D.26412 = *D.26411;
  D.26413 = (unsigned int) D.26412;
  D.26414 = D.26413 * 2;
  D.26415 = D.26409 + D.26414;
  D.26416 = *D.26415;
  D.26417 = (int) D.26416;
  D.26418 = D.26417 & 8;
  if (D.26418 == 0) goto <D.26419>; else goto <D.26420>;
  <D.26419>:
  i.16 = (sizetype) i;
  D.26411 = s + i.16;
  D.26412 = *D.26411;
  if (D.26412 != 95) goto <D.26421>; else goto <D.26422>;
  <D.26421>:
  process = 1;
  <D.26422>:
  <D.26420>:
  i = i + 1;
  <D.24958>:
  if (i < len) goto <D.24957>; else goto <D.24959>;
  <D.24959>:
  if (process == 0) goto <D.26423>; else goto <D.26424>;
  <D.26423>:
  D.26406 = s;
  return D.26406;
  <D.26424>:
  len.17 = (unsigned int) len;
  gs = monoeg_g_string_sized_new (len.17);
  i = 0;
  goto <D.24965>;
  <D.24964>:
  {
    guint8 c;

    i.16 = (sizetype) i;
    D.26411 = s + i.16;
    D.26412 = *D.26411;
    c = (guint8) D.26412;
    c.18 = (signed char) c;
    if (c.18 >= 0) goto <D.26430>; else goto <D.26426>;
    <D.26430>:
    D.26408 = __ctype_b_loc ();
    D.26409 = *D.26408;
    D.26431 = (unsigned int) c;
    D.26432 = D.26431 * 2;
    D.26433 = D.26409 + D.26432;
    D.26434 = *D.26433;
    D.26435 = (int) D.26434;
    D.26436 = D.26435 & 8;
    if (D.26436 != 0) goto <D.26427>; else goto <D.26437>;
    <D.26437>:
    if (c == 95) goto <D.26427>; else goto <D.26426>;
    <D.26427>:
    c.19 = (char) c;
    D.26439 = (int) c.19;
    monoeg_g_string_append_c (gs, D.26439);
    goto <D.26428>;
    <D.26426>:
    c.18 = (signed char) c;
    if (c.18 < 0) goto <D.26440>; else goto <D.26441>;
    <D.26440>:
    D.26442 = (int) c;
    monoeg_g_string_append_printf (gs, "_0x%x", D.26442);
    i = i + 1;
    i.16 = (sizetype) i;
    D.26411 = s + i.16;
    D.26412 = *D.26411;
    c = (guint8) D.26412;
    goto <D.24962>;
    <D.24961>:
    D.26442 = (int) c;
    monoeg_g_string_append_printf (gs, "%x", D.26442);
    i = i + 1;
    i.16 = (sizetype) i;
    D.26411 = s + i.16;
    D.26412 = *D.26411;
    c = (guint8) D.26412;
    <D.24962>:
    D.26443 = c >> 6;
    if (D.26443 == 2) goto <D.24961>; else goto <D.24963>;
    <D.24963>:
    monoeg_g_string_append_printf (gs, "_");
    i = i + -1;
    goto <D.26444>;
    <D.26441>:
    monoeg_g_string_append_c (gs, 95);
    <D.26444>:
    <D.26428>:
  }
  i = i + 1;
  <D.24965>:
  if (i < len) goto <D.24964>; else goto <D.24966>;
  <D.24966>:
  D.26445 = gs->str;
  D.26446 = acfg->mempool;
  res = mono_mempool_strdup (D.26446, D.26445);
  monoeg_g_string_free (gs, 1);
  D.26406 = res;
  return D.26406;
}


mono_aot_get_method_index (struct MonoMethod * method)
{
  struct MonoAotCompile * llvm_acfg.20;
  _Bool D.26449;
  long int D.26450;
  long int D.26451;
  int D.26454;
  unsigned int D.26455;

  llvm_acfg.20 = llvm_acfg;
  D.26449 = llvm_acfg.20 == 0B;
  D.26450 = (long int) D.26449;
  D.26451 = __builtin_expect (D.26450, 0);
  if (D.26451 != 0) goto <D.26452>; else goto <D.26453>;
  <D.26452>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "aot-compiler.c", 6895, "llvm_acfg");
  <D.26453>:
  llvm_acfg.20 = llvm_acfg;
  D.26455 = get_method_index (llvm_acfg.20, method);
  D.26454 = (int) D.26455;
  return D.26454;
}


get_method_index (struct MonoAotCompile * acfg, struct MonoMethod * method)
{
  struct GHashTable * D.26457;
  void * D.26458;
  _Bool D.26459;
  long int D.26460;
  long int D.26461;
  guint32 D.26464;
  int D.26465;
  int index;

  D.26457 = acfg->method_indexes;
  D.26458 = monoeg_g_hash_table_lookup (D.26457, method);
  index = (int) D.26458;
  D.26459 = index == 0;
  D.26460 = (long int) D.26459;
  D.26461 = __builtin_expect (D.26460, 0);
  if (D.26461 != 0) goto <D.26462>; else goto <D.26463>;
  <D.26462>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "aot-compiler.c", 3010, "index");
  <D.26463>:
  D.26465 = index + -1;
  D.26464 = (guint32) D.26465;
  return D.26464;
}


mono_aot_patch_info_dup (struct MonoJumpInfo * ji)
{
  struct MonoAotCompile * llvm_acfg.21;
  union mono_mutex_t * D.26468;
  _Bool D.26471;
  long int D.26472;
  long int D.26473;
  struct MonoMemPool * D.26476;
  _Bool D.26479;
  long int D.26480;
  long int D.26481;
  struct MonoJumpInfo * D.26484;
  struct MonoJumpInfo * res;

  {
    int ret;

    llvm_acfg.21 = llvm_acfg;
    D.26468 = &llvm_acfg.21->mutex.mutex;
    ret = pthread_mutex_lock (D.26468);
    if (ret != 0) goto <D.26469>; else goto <D.26470>;
    <D.26469>:
    monoeg_g_log (0B, 16, "Bad call to mono_mutex_lock result %d", ret);
    <D.26470>:
    D.26471 = ret != 0;
    D.26472 = (long int) D.26471;
    D.26473 = __builtin_expect (D.26472, 0);
    if (D.26473 != 0) goto <D.26474>; else goto <D.26475>;
    <D.26474>:
    monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "aot-compiler.c", 6904, "ret == 0");
    <D.26475>:
  }
  llvm_acfg.21 = llvm_acfg;
  D.26476 = llvm_acfg.21->mempool;
  res = mono_patch_info_dup_mp (D.26476, ji);
  {
    int ret;

    llvm_acfg.21 = llvm_acfg;
    D.26468 = &llvm_acfg.21->mutex.mutex;
    ret = pthread_mutex_unlock (D.26468);
    if (ret != 0) goto <D.26477>; else goto <D.26478>;
    <D.26477>:
    monoeg_g_log (0B, 16, "Bad call to mono_mutex_unlock result %d", ret);
    <D.26478>:
    D.26479 = ret != 0;
    D.26480 = (long int) D.26479;
    D.26481 = __builtin_expect (D.26480, 0);
    if (D.26481 != 0) goto <D.26482>; else goto <D.26483>;
    <D.26482>:
    monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "aot-compiler.c", 6906, "ret == 0");
    <D.26483>:
  }
  D.26484 = res;
  return D.26484;
}


mono_aot_method_hash (struct MonoMethod * method)
{
  unsigned char D.26486;
  unsigned char D.26487;
  short unsigned int D.26490;
  int D.26491;
  int D.26492;
  int iftmp.22;
  <unnamed-unsigned:22> D.26496;
  unsigned int hashes_count.23;
  unsigned int D.26499;
  unsigned char D.26500;
  unsigned char D.26501;
  _Bool D.26502;
  _Bool D.26503;
  _Bool D.26504;
  unsigned char D.26508;
  struct MonoType * D.26511;
  unsigned int D.26512;
  guint32 * D.26513;
  const char * D.26515;
  unsigned int D.26516;
  const char * D.26517;
  unsigned int D.26518;
  unsigned char D.26522;
  _Bool D.26523;
  _Bool D.26524;
  _Bool D.26525;
  guint32 * D.26527;
  const char * D.26528;
  unsigned int D.26529;
  guint32 * D.26530;
  <unnamed-unsigned:5> D.26531;
  unsigned int D.26532;
  guint32 * D.26533;
  struct MonoType * D.26534;
  unsigned int D.26535;
  int hindex.24;
  unsigned int hindex.25;
  unsigned int D.26538;
  guint32 * D.26539;
  struct MonoType * D.26540;
  unsigned int D.26541;
  int hindex.26;
  unsigned int hindex.27;
  unsigned int D.26546;
  guint32 * D.26547;
  struct MonoType * D.26548;
  unsigned int D.26549;
  int D.26550;
  _Bool D.26551;
  long int D.26552;
  long int D.26553;
  unsigned int D.26556;
  unsigned int D.26557;
  unsigned int D.26558;
  unsigned int D.26559;
  unsigned int D.26560;
  unsigned int D.26561;
  unsigned int D.26562;
  unsigned int D.26563;
  unsigned int D.26564;
  unsigned int D.26565;
  unsigned int D.26566;
  unsigned int D.26567;
  unsigned int D.26568;
  unsigned int D.26569;
  unsigned int D.26570;
  unsigned int D.26571;
  guint32 D.26573;
  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.26486 = BIT_FIELD_REF <*method, 8, 168>;
  D.26487 = D.26486 & 16;
  if (D.26487 != 0) goto <D.26488>; else goto <D.26489>;
  <D.26488>:
  ginst = MEM[(struct MonoMethodInflated *)method].context.method_inst;
  <D.26489>:
  D.26490 = sig->param_count;
  D.26491 = (int) D.26490;
  D.26492 = D.26491 + 5;
  if (ginst != 0B) goto <D.26494>; else goto <D.26495>;
  <D.26494>:
  D.26496 = ginst->type_argc;
  iftmp.22 = (int) D.26496;
  goto <D.26497>;
  <D.26495>:
  iftmp.22 = 0;
  <D.26497>:
  hashes_count = D.26492 + iftmp.22;
  hashes_count.23 = (unsigned int) hashes_count;
  D.26499 = hashes_count.23 * 4;
  hashes_start = monoeg_malloc0 (D.26499);
  hashes = hashes_start;
  D.26500 = BIT_FIELD_REF <*method, 8, 160>;
  D.26501 = D.26500 & 124;
  D.26502 = D.26501 == 0;
  D.26503 = D.26501 == 36;
  D.26504 = D.26502 | D.26503;
  if (D.26504 != 0) goto <D.26505>; else goto <D.26506>;
  <D.26505>:
  klass = method->klass;
  goto <D.26507>;
  <D.26506>:
  klass = mono_defaults.object_class;
  <D.26507>:
  D.26500 = BIT_FIELD_REF <*method, 8, 160>;
  D.26508 = D.26500 & 124;
  if (D.26508 == 0) goto <D.26509>; else goto <D.26510>;
  <D.26509>:
  {
    char * full_name;

    D.26511 = &klass->byval_arg;
    full_name = mono_type_full_name (D.26511);
    D.26512 = mono_metadata_str_hash (full_name);
    *hashes = D.26512;
    D.26513 = hashes + 4;
    *D.26513 = 0;
    monoeg_g_free (full_name);
  }
  goto <D.26514>;
  <D.26510>:
  D.26515 = klass->name;
  D.26516 = mono_metadata_str_hash (D.26515);
  *hashes = D.26516;
  D.26513 = hashes + 4;
  D.26517 = klass->name_space;
  D.26518 = mono_metadata_str_hash (D.26517);
  *D.26513 = D.26518;
  <D.26514>:
  D.26500 = BIT_FIELD_REF <*method, 8, 160>;
  D.26522 = D.26500 & 124;
  D.26523 = D.26522 == 52;
  D.26524 = D.26522 == 48;
  D.26525 = D.26523 | D.26524;
  if (D.26525 != 0) goto <D.26519>; else goto <D.26526>;
  <D.26526>:
  D.26500 = BIT_FIELD_REF <*method, 8, 160>;
  D.26508 = D.26500 & 124;
  if (D.26508 == 92) goto <D.26519>; else goto <D.26520>;
  <D.26519>:
  D.26527 = hashes + 8;
  *D.26527 = 0;
  goto <D.26521>;
  <D.26520>:
  D.26527 = hashes + 8;
  D.26528 = method->name;
  D.26529 = mono_metadata_str_hash (D.26528);
  *D.26527 = D.26529;
  <D.26521>:
  D.26530 = hashes + 12;
  D.26531 = method->wrapper_type;
  D.26532 = (unsigned int) D.26531;
  *D.26530 = D.26532;
  D.26533 = hashes + 16;
  D.26534 = sig->ret;
  D.26535 = mono_aot_type_hash (D.26534);
  *D.26533 = D.26535;
  hindex = 5;
  i = 0;
  goto <D.25737>;
  <D.25736>:
  hindex.24 = hindex;
  hindex = hindex.24 + 1;
  hindex.25 = (unsigned int) hindex.24;
  D.26538 = hindex.25 * 4;
  D.26539 = hashes + D.26538;
  D.26540 = sig->params[i];
  D.26541 = mono_aot_type_hash (D.26540);
  *D.26539 = D.26541;
  i = i + 1;
  <D.25737>:
  D.26490 = sig->param_count;
  D.26491 = (int) D.26490;
  if (D.26491 > i) goto <D.25736>; else goto <D.25738>;
  <D.25738>:
  if (ginst != 0B) goto <D.26542>; else goto <D.26543>;
  <D.26542>:
  i = 0;
  goto <D.25740>;
  <D.25739>:
  hindex.26 = hindex;
  hindex = hindex.26 + 1;
  hindex.27 = (unsigned int) hindex.26;
  D.26546 = hindex.27 * 4;
  D.26547 = hashes + D.26546;
  D.26548 = ginst->type_argv[i];
  D.26549 = mono_aot_type_hash (D.26548);
  *D.26547 = D.26549;
  i = i + 1;
  <D.25740>:
  D.26496 = ginst->type_argc;
  D.26550 = (int) D.26496;
  if (D.26550 > i) goto <D.25739>; else goto <D.25741>;
  <D.25741>:
  <D.26543>:
  D.26551 = hindex != hashes_count;
  D.26552 = (long int) D.26551;
  D.26553 = __builtin_expect (D.26552, 0);
  if (D.26553 != 0) goto <D.26554>; else goto <D.26555>;
  <D.26554>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "aot-compiler.c", 7387, "hindex == hashes_count");
  <D.26555>:
  hashes_count.23 = (unsigned int) hashes_count;
  D.26556 = hashes_count.23 << 2;
  c = D.26556 + 3735928559;
  b = c;
  a = b;
  goto <D.25743>;
  <D.25742>:
  D.26557 = *hashes;
  a = D.26557 + a;
  D.26513 = hashes + 4;
  D.26558 = *D.26513;
  b = D.26558 + b;
  D.26527 = hashes + 8;
  D.26559 = *D.26527;
  c = D.26559 + c;
  a = a - c;
  D.26560 = c r>> 28;
  a = D.26560 ^ a;
  c = c + b;
  b = b - a;
  D.26561 = a r>> 26;
  b = D.26561 ^ b;
  a = a + c;
  c = c - b;
  D.26562 = b r>> 24;
  c = D.26562 ^ c;
  b = b + a;
  a = a - c;
  D.26563 = c r>> 16;
  a = D.26563 ^ a;
  c = c + b;
  b = b - a;
  D.26564 = a r>> 13;
  b = D.26564 ^ b;
  a = a + c;
  c = c - b;
  D.26565 = b r>> 28;
  c = D.26565 ^ c;
  b = b + a;
  hashes_count = hashes_count + -3;
  hashes = hashes + 12;
  <D.25743>:
  if (hashes_count > 3) goto <D.25742>; else goto <D.25744>;
  <D.25744>:
  switch (hashes_count) <default: <D.26572>, case 0: <D.25748>, case 1: <D.25747>, case 2: <D.25746>, case 3: <D.25745>>
  <D.25745>:
  D.26527 = hashes + 8;
  D.26559 = *D.26527;
  c = D.26559 + c;
  <D.25746>:
  D.26513 = hashes + 4;
  D.26558 = *D.26513;
  b = D.26558 + b;
  <D.25747>:
  D.26557 = *hashes;
  a = D.26557 + a;
  c = c ^ b;
  D.26566 = b r>> 18;
  c = c - D.26566;
  a = a ^ c;
  D.26567 = c r>> 21;
  a = a - D.26567;
  b = b ^ a;
  D.26568 = a r>> 7;
  b = b - D.26568;
  c = c ^ b;
  D.26569 = b r>> 16;
  c = c - D.26569;
  a = a ^ c;
  D.26560 = c r>> 28;
  a = a - D.26560;
  b = b ^ a;
  D.26570 = a r>> 18;
  b = b - D.26570;
  c = c ^ b;
  D.26571 = b r>> 8;
  c = c - D.26571;
  <D.25748>:
  goto <D.25749>;
  <D.26572>:
  <D.25749>:
  free (hashes_start);
  D.26573 = c;
  return D.26573;
}


mono_aot_type_hash (struct MonoType * t1)
{
  unsigned char D.26575;
  <unnamed-unsigned:1> D.26576;
  int D.26577;
  int D.26578;
  unsigned int D.26579;
  int D.26580;
  guint D.26581;
  unsigned int D.26582;
  unsigned int D.26583;
  struct MonoClass * D.26584;
  const char * D.26585;
  unsigned int D.26586;
  struct MonoType * D.26587;
  unsigned int D.26588;
  struct MonoArrayType * D.26589;
  struct MonoClass * D.26590;
  struct MonoType * D.26591;
  unsigned int D.26592;
  guint hash;

  D.26575 = t1->type;
  hash = (guint) D.26575;
  D.26576 = t1->byref;
  D.26577 = (int) D.26576;
  D.26578 = D.26577 << 6;
  D.26579 = (unsigned int) D.26578;
  hash = D.26579 | hash;
  D.26575 = t1->type;
  D.26580 = (int) D.26575;
  switch (D.26580) <default: <D.25720>, case 15: <D.25717>, case 17: <D.25714>, case 18: <D.25715>, case 20: <D.25718>, case 21: <D.25719>, case 29: <D.25716>>
  <D.25714>:
  <D.25715>:
  <D.25716>:
  D.26582 = hash << 5;
  D.26583 = D.26582 - hash;
  D.26584 = t1->data.klass;
  D.26585 = D.26584->name;
  D.26586 = mono_metadata_str_hash (D.26585);
  D.26581 = D.26583 ^ D.26586;
  return D.26581;
  <D.25717>:
  D.26582 = hash << 5;
  D.26583 = D.26582 - hash;
  D.26587 = t1->data.type;
  D.26588 = mono_metadata_type_hash (D.26587);
  D.26581 = D.26583 ^ D.26588;
  return D.26581;
  <D.25718>:
  D.26582 = hash << 5;
  D.26583 = D.26582 - hash;
  D.26589 = t1->data.array;
  D.26590 = D.26589->eklass;
  D.26591 = &D.26590->byval_arg;
  D.26592 = mono_metadata_type_hash (D.26591);
  D.26581 = D.26583 ^ D.26592;
  return D.26581;
  <D.25719>:
  D.26582 = hash << 5;
  D.26581 = D.26582 - hash;
  return D.26581;
  <D.25720>:
  D.26581 = hash;
  return D.26581;
}


mono_aot_get_array_helper_from_wrapper (struct MonoMethod * method)
{
  const char * D.26594;
  unsigned int D.26595;
  sizetype D.26596;
  const char * D.26597;
  _Bool D.26598;
  long int D.26599;
  long int D.26600;
  int D.25770;
  int iftmp.28;
  int D.25769;
  const char[6] * D.26606;
  unsigned char D.26607;
  int D.26608;
  unsigned char D.26609;
  int D.26610;
  _Bool D.26611;
  _Bool D.26612;
  _Bool D.26613;
  const unsigned char * D.26616;
  unsigned char D.26617;
  int D.26618;
  const unsigned char * D.26619;
  unsigned char D.26620;
  int D.26621;
  _Bool D.26622;
  _Bool D.26623;
  const unsigned char * D.26626;
  unsigned char D.26627;
  int D.26628;
  const unsigned char * D.26629;
  unsigned char D.26630;
  int D.26631;
  _Bool D.26632;
  _Bool D.26633;
  const unsigned char * D.26636;
  unsigned char D.26637;
  int D.26638;
  const unsigned char * D.26639;
  unsigned char D.26640;
  int D.26641;
  struct MonoMethodSignature * D.26646;
  short unsigned int D.26647;
  int D.26648;
  struct MonoClass * D.26649;
  _Bool D.26650;
  long int D.26651;
  long int D.26652;
  unsigned char D.26655;
  unsigned char D.26656;
  struct MonoClass * D.26659;
  struct MonoClass * D.26660;
  struct MonoType * D.26661;
  struct MonoGenericInst * D.26662;
  struct MonoMethod * D.26663;
  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.26594 = method->name;
      D.26595 = strlen (prefix);
      D.26596 = D.26595 + 1;
      D.26597 = D.26594 + D.26596;
      s = monoeg_g_strdup_printf ("%s", D.26597);
      s2 = strstr (s, "`1.");
      D.26598 = s2 == 0B;
      D.26599 = (long int) D.26598;
      D.26600 = __builtin_expect (D.26599, 0);
      if (D.26600 != 0) goto <D.26601>; else goto <D.26602>;
      <D.26601>:
      monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "aot-compiler.c", 7437, "s2");
      <D.26602>:
      *s2 = 0;
      iname = s;
      mname = s2 + 3;
      {
        size_t __s1_len;
        size_t __s2_len;

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

          __s2 = iname;
          D.26606 = "IList";
          D.26607 = MEM[(const unsigned char *)D.26606];
          D.26608 = (int) D.26607;
          D.26609 = *__s2;
          D.26610 = (int) D.26609;
          __result = D.26608 - D.26610;
          {
            D.26611 = __s2_len != 0;
            D.26612 = __result == 0;
            D.26613 = D.26611 & D.26612;
            if (D.26613 != 0) goto <D.26614>; else goto <D.26615>;
            <D.26614>:
            D.26616 = &MEM[(void *)"IList" + 1B];
            D.26617 = *D.26616;
            D.26618 = (int) D.26617;
            D.26619 = __s2 + 1;
            D.26620 = *D.26619;
            D.26621 = (int) D.26620;
            __result = D.26618 - D.26621;
            D.26622 = __s2_len > 1;
            D.26612 = __result == 0;
            D.26623 = D.26622 & D.26612;
            if (D.26623 != 0) goto <D.26624>; else goto <D.26625>;
            <D.26624>:
            D.26626 = &MEM[(void *)"IList" + 2B];
            D.26627 = *D.26626;
            D.26628 = (int) D.26627;
            D.26629 = __s2 + 2;
            D.26630 = *D.26629;
            D.26631 = (int) D.26630;
            __result = D.26628 - D.26631;
            D.26632 = __s2_len > 2;
            D.26612 = __result == 0;
            D.26633 = D.26632 & D.26612;
            if (D.26633 != 0) goto <D.26634>; else goto <D.26635>;
            <D.26634>:
            D.26636 = &MEM[(void *)"IList" + 3B];
            D.26637 = *D.26636;
            D.26638 = (int) D.26637;
            D.26639 = __s2 + 3;
            D.26640 = *D.26639;
            D.26641 = (int) D.26640;
            __result = D.26638 - D.26641;
            <D.26635>:
            <D.26625>:
            <D.26615>:
          }
          D.25769 = __result;
        }
        iftmp.28 = -D.25769;
        goto <D.26642>;
        <D.26605>:
        iftmp.28 = __builtin_strcmp (iname, "IList");
        <D.26642>:
        D.25770 = iftmp.28;
      }
      if (D.25770 == 0) goto <D.26643>; else goto <D.26644>;
      <D.26643>:
      helper_name = monoeg_g_strdup_printf ("InternalArray__%s", mname);
      goto <D.26645>;
      <D.26644>:
      helper_name = monoeg_g_strdup_printf ("InternalArray__%s_%s", iname, mname);
      <D.26645>:
      D.26646 = mono_method_signature (method);
      D.26647 = D.26646->param_count;
      D.26648 = (int) D.26647;
      D.26649 = mono_defaults.array_class;
      m = mono_class_get_method_from_name (D.26649, helper_name, D.26648);
      D.26650 = m == 0B;
      D.26651 = (long int) D.26650;
      D.26652 = __builtin_expect (D.26651, 0);
      if (D.26652 != 0) goto <D.26653>; else goto <D.26654>;
      <D.26653>:
      monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "aot-compiler.c", 7449, "m");
      <D.26654>:
      monoeg_g_free (helper_name);
      monoeg_g_free (s);
      D.26655 = BIT_FIELD_REF <*m, 8, 168>;
      D.26656 = D.26655 & 8;
      if (D.26656 != 0) goto <D.26657>; else goto <D.26658>;
      <D.26657>:
      memset (&ctx, 0, 8);
      D.26659 = method->klass;
      D.26660 = D.26659->element_class;
      D.26661 = &D.26660->byval_arg;
      args[0] = D.26661;
      D.26662 = mono_metadata_get_generic_inst (1, &args);
      ctx.method_inst = D.26662;
      m = mono_class_inflate_generic_method (m, &ctx);
      <D.26658>:
      D.26663 = m;
      return D.26663;
    }
  finally
    {
      ctx = {CLOBBER};
      args = {CLOBBER};
    }
}


memset (void * __dest, int __ch, size_t __len)
{
  int D.26668;
  int D.26673;
  void * D.26675;
  unsigned int D.26676;

  D.26668 = __builtin_constant_p (__len);
  if (D.26668 != 0) goto <D.26669>; else goto <D.26670>;
  <D.26669>:
  if (__len == 0) goto <D.26671>; else goto <D.26672>;
  <D.26671>:
  D.26673 = __builtin_constant_p (__ch);
  if (D.26673 == 0) goto <D.26666>; else goto <D.26674>;
  <D.26674>:
  if (__ch != 0) goto <D.26666>; else goto <D.26667>;
  <D.26666>:
  __warn_memset_zero_len ();
  D.26675 = __dest;
  return D.26675;
  <D.26667>:
  <D.26672>:
  <D.26670>:
  D.26676 = __builtin_object_size (__dest, 0);
  D.26675 = __builtin___memset_chk (__dest, __ch, __len, D.26676);
  return D.26675;
}


mono_compile_assembly (struct MonoAssembly * ass, guint32 opts, const char * aot_options)
{
  unsigned int D.26678;
  struct _IO_FILE * stderr.29;
  char * D.26682;
  struct MonoAotOptions * D.26683;
  gchar * D.26684;
  int D.26685;
  int D.26688;
  int D.26695;
  int D.26698;
  int D.26701;
  <unnamed type> D.26702;
  unsigned int D.26703;
  int mono_use_llvm.30;
  unsigned int D.26707;
  int D.26710;
  unsigned int D.26713;
  guint32 iftmp.31;
  int D.26717;
  guint32 iftmp.32;
  int D.26722;
  guint32 iftmp.33;
  int D.26727;
  unsigned int D.26729;
  unsigned int D.26730;
  guint32 iftmp.34;
  int D.26736;
  const char * D.26738;
  struct MonoImage * D.26739;
  struct MonoAssembly * D.26740;
  const char * D.26741;
  gchar * D.26742;
  const char * D.26743;
  gchar * D.26744;
  gchar * D.26745;
  const short unsigned int * * D.26746;
  const short unsigned int * D.26747;
  char D.26748;
  unsigned int D.26749;
  unsigned int D.26750;
  const short unsigned int * D.26751;
  short unsigned int D.26752;
  int D.26753;
  int D.26754;
  struct GPtrArray * D.26767;
  unsigned int D.26768;
  unsigned int D.26769;
  int D.26770;
  int D.26771;
  unsigned int D.26772;
  unsigned int D.26773;
  void * D.26774;
  struct MonoMemPool * D.26775;
  long long int D.26776;
  long long int D.26777;
  int D.26778;
  int D.26781;
  int D.26783;
  int D.26785;
  char * D.26787;
  char * D.26791;
  struct FILE * D.26792;
  struct FILE * D.26793;
  int * D.26796;
  int D.26797;
  char * D.26798;
  struct MonoImageWriter * D.26799;
  int D.26800;
  char * D.26803;
  struct FILE * D.26804;
  gchar * D.26810;
  gchar * D.26812;
  struct FILE * D.26813;
  char * * D.26815;
  struct FILE * D.26816;
  char * D.26819;
  struct MonoImageWriter * D.26820;
  char * D.26821;
  gchar * D.26822;
  struct MonoCompile * * D.26823;
  unsigned int i.35;
  unsigned int D.26825;
  struct MonoCompile * * D.26826;
  struct MonoCompile * D.26827;
  struct MonoMethod * D.26830;
  unsigned int D.26831;
  char * D.26834;
  gchar * D.26835;
  int D.26837;
  struct GHashTable * D.26840;
  struct MonoMethod * D.26841;
  char * D.26842;
  const char * D.26844;
  gchar * D.26845;
  unsigned int i.36;
  unsigned int D.26847;
  int D.26848;
  int D.26853;
  int D.26858;
  int D.26862;
  int D.26865;
  _Bool D.26866;
  int D.26867;
  struct MonoImageWriter * D.26868;
  struct MonoDwarfWriter * D.26869;
  struct MonoDwarfWriter * D.26870;
  struct GSList * D.26873;
  gchar * D.26874;
  int D.26875;
  int D.26880;
  int D.26883;
  unsigned int D.26888;
  unsigned int D.26889;
  _Bool D.26890;
  long int D.26891;
  long int D.26892;
  int iftmp.37;
  int D.26898;
  int D.26901;
  int D.26902;
  int D.26905;
  unsigned int D.26906;
  int D.26907;
  int D.26908;
  unsigned int D.26909;
  int D.26910;
  int D.26911;
  int D.26912;
  int D.26913;
  int D.26914;
  int iftmp.38;
  int D.26916;
  int D.26919;
  int D.26920;
  int iftmp.39;
  int D.26925;
  int D.26926;
  int iftmp.40;
  int D.26931;
  int D.26932;
  int D.26934;
  int iftmp.41;
  int D.26940;
  int D.26942;
  int iftmp.42;
  int D.26948;
  int D.26950;
  int iftmp.43;
  int D.26956;
  int D.26958;
  int iftmp.44;
  int D.26964;
  char * D.26972;
  int D.26976;
  int D.26979;
  int D.26982;
  const char * D.26983;
  int D.26984;
  int D.26985;
  int D.26986;
  int D.26987;
  int D.26988;
  int D.26989;
  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.26678 = opts & 16777216;
      if (D.26678 != 0) goto <D.26679>; else goto <D.26680>;
      <D.26679>:
      stderr.29 = stderr;
      fprintf (stderr.29, "-O=gsharedvt not supported on this platform.\n");
      exit (1);
      <D.26680>:
      D.26682 = image->name;
      printf ("Mono Ahead of Time compiler - compiling assembly %s\n", D.26682);
      acfg = acfg_create (ass, opts);
      D.26683 = &acfg->aot_opts;
      memset (D.26683, 0, 128);
      acfg->aot_opts.write_symbols = 1;
      acfg->aot_opts.ntrampolines = 1024;
      acfg->aot_opts.nrgctx_trampolines = 1024;
      acfg->aot_opts.nimt_trampolines = 128;
      acfg->aot_opts.nrgctx_fetch_trampolines = 128;
      acfg->aot_opts.ngsharedvt_arg_trampolines = 128;
      D.26684 = monoeg_strdup ("");
      acfg->aot_opts.llvm_path = D.26684;
      D.26683 = &acfg->aot_opts;
      mono_aot_parse_options (aot_options, D.26683);
      D.26685 = acfg->aot_opts.static_link;
      if (D.26685 != 0) goto <D.26686>; else goto <D.26687>;
      <D.26686>:
      acfg->aot_opts.autoreg = 1;
      <D.26687>:
      D.26688 = acfg->aot_opts.direct_pinvoke;
      if (D.26688 != 0) goto <D.26689>; else goto <D.26690>;
      <D.26689>:
      D.26685 = acfg->aot_opts.static_link;
      if (D.26685 == 0) goto <D.26691>; else goto <D.26692>;
      <D.26691>:
      stderr.29 = stderr;
      fprintf (stderr.29, "The \'direct-pinvoke\' AOT option also requires the \'static\' AOT option.\n");
      exit (1);
      <D.26692>:
      <D.26690>:
      D.26685 = acfg->aot_opts.static_link;
      if (D.26685 != 0) goto <D.26693>; else goto <D.26694>;
      <D.26693>:
      acfg->aot_opts.asm_writer = 1;
      <D.26694>:
      D.26695 = acfg->aot_opts.soft_debug;
      if (D.26695 != 0) goto <D.26696>; else goto <D.26697>;
      <D.26696>:
      {
        struct MonoDebugOptions * opt;

        opt = mini_get_debug_options ();
        opt->mdb_optimizations = 1;
        opt->gen_seq_points = 1;
        D.26698 = mono_debug_enabled ();
        if (D.26698 == 0) goto <D.26699>; else goto <D.26700>;
        <D.26699>:
        stderr.29 = stderr;
        fprintf (stderr.29, "The soft-debug AOT option requires the --debug option.\n");
        D.26701 = 1;
        return D.26701;
        <D.26700>:
        D.26702 = acfg->flags;
        D.26703 = D.26702 | 4;
        acfg->flags = D.26703;
      }
      <D.26697>:
      mono_use_llvm.30 = mono_use_llvm;
      if (mono_use_llvm.30 != 0) goto <D.26705>; else goto <D.26706>;
      <D.26705>:
      acfg->llvm = 1;
      acfg->aot_opts.asm_writer = 1;
      D.26702 = acfg->flags;
      D.26707 = D.26702 | 1;
      acfg->flags = D.26707;
      D.26695 = acfg->aot_opts.soft_debug;
      if (D.26695 != 0) goto <D.26708>; else goto <D.26709>;
      <D.26708>:
      stderr.29 = stderr;
      fprintf (stderr.29, "The \'soft-debug\' option is not supported when compiling with LLVM.\n");
      exit (1);
      <D.26709>:
      <D.26706>:
      D.26710 = acfg->aot_opts.full_aot;
      if (D.26710 != 0) goto <D.26711>; else goto <D.26712>;
      <D.26711>:
      D.26702 = acfg->flags;
      D.26713 = D.26702 | 2;
      acfg->flags = D.26713;
      <D.26712>:
      load_profile_files (acfg);
      D.26710 = acfg->aot_opts.full_aot;
      if (D.26710 != 0) goto <D.26715>; else goto <D.26716>;
      <D.26715>:
      D.26717 = acfg->aot_opts.ntrampolines;
      iftmp.31 = (guint32) D.26717;
      goto <D.26718>;
      <D.26716>:
      iftmp.31 = 0;
      <D.26718>:
      acfg->num_trampolines[0] = iftmp.31;
      D.26710 = acfg->aot_opts.full_aot;
      if (D.26710 != 0) goto <D.26720>; else goto <D.26721>;
      <D.26720>:
      D.26722 = acfg->aot_opts.nrgctx_trampolines;
      iftmp.32 = (guint32) D.26722;
      goto <D.26723>;
      <D.26721>:
      iftmp.32 = 0;
      <D.26723>:
      acfg->num_trampolines[1] = iftmp.32;
      D.26710 = acfg->aot_opts.full_aot;
      if (D.26710 != 0) goto <D.26725>; else goto <D.26726>;
      <D.26725>:
      D.26727 = acfg->aot_opts.nimt_trampolines;
      iftmp.33 = (guint32) D.26727;
      goto <D.26728>;
      <D.26726>:
      iftmp.33 = 0;
      <D.26728>:
      acfg->num_trampolines[2] = iftmp.33;
      D.26729 = acfg->opts;
      D.26730 = D.26729 & 16777216;
      if (D.26730 != 0) goto <D.26731>; else goto <D.26732>;
      <D.26731>:
      D.26710 = acfg->aot_opts.full_aot;
      if (D.26710 != 0) goto <D.26734>; else goto <D.26735>;
      <D.26734>:
      D.26736 = acfg->aot_opts.ngsharedvt_arg_trampolines;
      iftmp.34 = (guint32) D.26736;
      goto <D.26737>;
      <D.26735>:
      iftmp.34 = 0;
      <D.26737>:
      acfg->num_trampolines[3] = iftmp.34;
      <D.26732>:
      D.26738 = img_writer_get_temp_label_prefix (0B);
      acfg->temp_prefix = D.26738;
      arch_init (acfg);
      D.26739 = acfg->image;
      D.26740 = D.26739->assembly;
      D.26741 = D.26740->aname.name;
      D.26742 = monoeg_g_strdup_printf ("mono_aot_%s_got", D.26741);
      acfg->got_symbol_base = D.26742;
      D.26739 = acfg->image;
      D.26740 = D.26739->assembly;
      D.26741 = D.26740->aname.name;
      D.26743 = acfg->llvm_label_prefix;
      D.26744 = monoeg_g_strdup_printf ("%smono_aot_%s_plt", D.26743, D.26741);
      acfg->plt_symbol = D.26744;
      D.26739 = acfg->image;
      D.26740 = D.26739->assembly;
      D.26741 = D.26740->aname.name;
      D.26745 = monoeg_strdup (D.26741);
      acfg->assembly_name_sym = D.26745;
      p = acfg->got_symbol_base;
      goto <D.26105>;
      <D.26104>:
      D.26746 = __ctype_b_loc ();
      D.26747 = *D.26746;
      D.26748 = *p;
      D.26749 = (unsigned int) D.26748;
      D.26750 = D.26749 * 2;
      D.26751 = D.26747 + D.26750;
      D.26752 = *D.26751;
      D.26753 = (int) D.26752;
      D.26754 = D.26753 & 8;
      if (D.26754 == 0) goto <D.26755>; else goto <D.26756>;
      <D.26755>:
      D.26748 = *p;
      if (D.26748 != 95) goto <D.26757>; else goto <D.26758>;
      <D.26757>:
      *p = 95;
      <D.26758>:
      <D.26756>:
      p = p + 1;
      <D.26105>:
      D.26748 = *p;
      if (D.26748 != 0) goto <D.26104>; else goto <D.26106>;
      <D.26106>:
      p = acfg->plt_symbol;
      goto <D.26108>;
      <D.26107>:
      D.26746 = __ctype_b_loc ();
      D.26747 = *D.26746;
      D.26748 = *p;
      D.26749 = (unsigned int) D.26748;
      D.26750 = D.26749 * 2;
      D.26751 = D.26747 + D.26750;
      D.26752 = *D.26751;
      D.26753 = (int) D.26752;
      D.26754 = D.26753 & 8;
      if (D.26754 == 0) goto <D.26759>; else goto <D.26760>;
      <D.26759>:
      D.26748 = *p;
      if (D.26748 != 95) goto <D.26761>; else goto <D.26762>;
      <D.26761>:
      *p = 95;
      <D.26762>:
      <D.26760>:
      p = p + 1;
      <D.26108>:
      D.26748 = *p;
      if (D.26748 != 0) goto <D.26107>; else goto <D.26109>;
      <D.26109>:
      p = acfg->assembly_name_sym;
      goto <D.26111>;
      <D.26110>:
      D.26746 = __ctype_b_loc ();
      D.26747 = *D.26746;
      D.26748 = *p;
      D.26749 = (unsigned int) D.26748;
      D.26750 = D.26749 * 2;
      D.26751 = D.26747 + D.26750;
      D.26752 = *D.26751;
      D.26753 = (int) D.26752;
      D.26754 = D.26753 & 8;
      if (D.26754 == 0) goto <D.26763>; else goto <D.26764>;
      <D.26763>:
      D.26748 = *p;
      if (D.26748 != 95) goto <D.26765>; else goto <D.26766>;
      <D.26765>:
      *p = 95;
      <D.26766>:
      <D.26764>:
      p = p + 1;
      <D.26111>:
      D.26748 = *p;
      if (D.26748 != 0) goto <D.26110>; else goto <D.26112>;
      <D.26112>:
      acfg->method_index = 1;
      collect_methods (acfg);
      D.26767 = acfg->methods;
      D.26768 = D.26767->len;
      D.26769 = D.26768 + 32;
      D.26770 = (int) D.26769;
      acfg->cfgs_size = D.26770;
      D.26771 = acfg->cfgs_size;
      D.26772 = (unsigned int) D.26771;
      D.26773 = D.26772 * 4;
      D.26774 = monoeg_malloc0 (D.26773);
      acfg->cfgs = D.26774;
      acfg->plt_offset = 1;
      {
        struct MonoJumpInfo * ji;

        D.26775 = acfg->mempool;
        ji = mono_mempool_alloc0 (D.26775, 1032);
        ji->type = 12;
        D.26739 = acfg->image;
        ji->data.image = D.26739;
        get_got_offset (acfg, ji);
        D.26775 = acfg->mempool;
        ji = mono_mempool_alloc0 (D.26775, 1032);
        ji->type = 39;
        get_got_offset (acfg, ji);
        D.26775 = acfg->mempool;
        ji = mono_mempool_alloc0 (D.26775, 1032);
        ji->type = 42;
        get_got_offset (acfg, ji);
        D.26775 = acfg->mempool;
        ji = mono_mempool_alloc0 (D.26775, 1032);
        ji->type = 47;
        get_got_offset (acfg, ji);
      }
      atv = mono_100ns_ticks ();
      compile_methods (acfg);
      btv = mono_100ns_ticks ();
      D.26776 = btv - atv;
      D.26777 = D.26776 / 10;
      D.26778 = (int) D.26777;
      acfg->stats.jit_time = D.26778;
      atv = mono_100ns_ticks ();
      D.26781 = acfg->aot_opts.asm_only;
      if (D.26781 == 0) goto <D.26782>; else goto <D.26779>;
      <D.26782>:
      D.26783 = acfg->aot_opts.asm_writer;
      if (D.26783 == 0) goto <D.26784>; else goto <D.26779>;
      <D.26784>:
      D.26785 = bin_writer_supported ();
      if (D.26785 != 0) goto <D.26786>; else goto <D.26779>;
      <D.26786>:
      D.26787 = acfg->aot_opts.outfile;
      if (D.26787 != 0B) goto <D.26788>; else goto <D.26789>;
      <D.26788>:
      D.26787 = acfg->aot_opts.outfile;
      outfile_name = monoeg_g_strdup_printf ("%s", D.26787);
      goto <D.26790>;
      <D.26789>:
      D.26739 = acfg->image;
      D.26791 = D.26739->name;
      outfile_name = monoeg_g_strdup_printf ("%s%s", D.26791, ".so");
      <D.26790>:
      tmp_outfile_name = monoeg_g_strdup_printf ("%s.tmp", outfile_name);
      D.26792 = fopen (tmp_outfile_name, "w");
      acfg->fp = D.26792;
      D.26793 = acfg->fp;
      if (D.26793 == 0B) goto <D.26794>; else goto <D.26795>;
      <D.26794>:
      D.26796 = __errno_location ();
      D.26797 = *D.26796;
      D.26798 = strerror (D.26797);
      printf ("Unable to create temporary file \'%s\': %s\n", tmp_outfile_name, D.26798);
      D.26701 = 1;
      return D.26701;
      <D.26795>:
      D.26793 = acfg->fp;
      D.26799 = img_writer_create (D.26793, 1);
      acfg->w = D.26799;
      acfg->use_bin_writer = 1;
      goto <D.26780>;
      <D.26779>:
      D.26800 = acfg->llvm;
      if (D.26800 != 0) goto <D.26801>; else goto <D.26802>;
      <D.26801>:
      D.26803 = acfg->tmpfname;
      D.26804 = fopen (D.26803, "a+");
      acfg->fp = D.26804;
      goto <D.26805>;
      <D.26802>:
      D.26781 = acfg->aot_opts.asm_only;
      if (D.26781 != 0) goto <D.26806>; else goto <D.26807>;
      <D.26806>:
      D.26787 = acfg->aot_opts.outfile;
      if (D.26787 != 0B) goto <D.26808>; else goto <D.26809>;
      <D.26808>:
      D.26787 = acfg->aot_opts.outfile;
      D.26810 = monoeg_g_strdup_printf ("%s", D.26787);
      acfg->tmpfname = D.26810;
      goto <D.26811>;
      <D.26809>:
      D.26739 = acfg->image;
      D.26791 = D.26739->name;
      D.26812 = monoeg_g_strdup_printf ("%s.s", D.26791);
      acfg->tmpfname = D.26812;
      <D.26811>:
      D.26803 = acfg->tmpfname;
      D.26813 = fopen (D.26803, "w+");
      acfg->fp = D.26813;
      goto <D.26814>;
      <D.26807>:
      {
        int i;

        D.26815 = &acfg->tmpfname;
        i = monoeg_g_file_open_tmp ("mono_aot_XXXXXX", D.26815, 0B);
        D.26816 = fdopen (i, "w+");
        acfg->fp = D.26816;
      }
      <D.26814>:
      <D.26805>:
      D.26793 = acfg->fp;
      if (D.26793 == 0B) goto <D.26817>; else goto <D.26818>;
      <D.26817>:
      D.26796 = __errno_location ();
      D.26797 = *D.26796;
      D.26819 = strerror (D.26797);
      D.26803 = acfg->tmpfname;
      stderr.29 = stderr;
      fprintf (stderr.29, "Unable to open file \'%s\': %s\n", D.26803, D.26819);
      D.26701 = 1;
      return D.26701;
      <D.26818>:
      D.26793 = acfg->fp;
      D.26820 = img_writer_create (D.26793, 0);
      acfg->w = D.26820;
      tmp_outfile_name = 0B;
      outfile_name = 0B;
      <D.26780>:
      D.26821 = acfg->got_symbol_base;
      D.26743 = acfg->llvm_label_prefix;
      D.26822 = monoeg_g_strdup_printf ("%s%s", D.26743, D.26821);
      acfg->got_symbol = D.26822;
      i = 0;
      goto <D.26118>;
      <D.26117>:
      D.26823 = acfg->cfgs;
      i.35 = (unsigned int) i;
      D.26825 = i.35 * 4;
      D.26826 = D.26823 + D.26825;
      D.26827 = *D.26826;
      if (D.26827 != 0B) goto <D.26828>; else goto <D.26829>;
      <D.26828>:
      {
        struct MonoCompile * cfg;
        int method_index;

        D.26823 = acfg->cfgs;
        i.35 = (unsigned int) i;
        D.26825 = i.35 * 4;
        D.26826 = D.26823 + D.26825;
        cfg = *D.26826;
        D.26830 = cfg->orig_method;
        D.26831 = get_method_index (acfg, D.26830);
        method_index = (int) D.26831;
        if (0 != 0) goto <D.26832>; else goto <D.26833>;
        <D.26832>:
        D.26834 = cfg->llvm_method_name;
        D.26743 = acfg->llvm_label_prefix;
        D.26835 = monoeg_g_strdup_printf ("%s%s", D.26743, D.26834);
        cfg->asm_symbol = D.26835;
        goto <D.26836>;
        <D.26833>:
        D.26837 = acfg->global_symbols;
        if (D.26837 != 0) goto <D.26838>; else goto <D.26839>;
        <D.26838>:
        D.26840 = acfg->method_label_hash;
        D.26841 = cfg->method;
        D.26842 = get_debug_sym (D.26841, "", D.26840);
        cfg->asm_symbol = D.26842;
        goto <D.26843>;
        <D.26839>:
        D.26743 = acfg->llvm_label_prefix;
        D.26844 = acfg->temp_prefix;
        D.26845 = monoeg_g_strdup_printf ("%s%sm_%x", D.26844, D.26743, method_index);
        cfg->asm_symbol = D.26845;
        <D.26843>:
        <D.26836>:
      }
      <D.26829>:
      i = i + 1;
      <D.26118>:
      i.36 = (unsigned int) i;
      D.26847 = acfg->nmethods;
      if (i.36 < D.26847) goto <D.26117>; else goto <D.26119>;
      <D.26119>:
      D.26848 = acfg->aot_opts.dwarf_debug;
      if (D.26848 != 0) goto <D.26849>; else goto <D.26850>;
      <D.26849>:
      D.26781 = acfg->aot_opts.asm_only;
      if (D.26781 != 0) goto <D.26851>; else goto <D.26852>;
      <D.26851>:
      D.26853 = acfg->aot_opts.gnu_asm;
      if (D.26853 != 0) goto <D.26854>; else goto <D.26855>;
      <D.26854>:
      acfg->gas_line_numbers = 1;
      <D.26855>:
      <D.26852>:
      <D.26850>:
      D.26858 = acfg->aot_opts.nodebug;
      if (D.26858 == 0) goto <D.26856>; else goto <D.26859>;
      <D.26859>:
      D.26848 = acfg->aot_opts.dwarf_debug;
      if (D.26848 != 0) goto <D.26856>; else goto <D.26857>;
      <D.26856>:
      D.26848 = acfg->aot_opts.dwarf_debug;
      if (D.26848 != 0) goto <D.26860>; else goto <D.26861>;
      <D.26860>:
      D.26862 = mono_debug_enabled ();
      if (D.26862 == 0) goto <D.26863>; else goto <D.26864>;
      <D.26863>:
      stderr.29 = stderr;
      fprintf (stderr.29, "The dwarf AOT option requires the --debug option.\n");
      D.26701 = 1;
      return D.26701;
      <D.26864>:
      <D.26861>:
      D.26865 = acfg->gas_line_numbers;
      D.26866 = D.26865 == 0;
      D.26867 = (int) D.26866;
      D.26868 = acfg->w;
      D.26869 = mono_dwarf_writer_create (D.26868, 0B, 0, 0, D.26867);
      acfg->dwarf = D.26869;
      <D.26857>:
      D.26868 = acfg->w;
      img_writer_emit_start (D.26868);
      D.26870 = acfg->dwarf;
      if (D.26870 != 0B) goto <D.26871>; else goto <D.26872>;
      <D.26871>:
      D.26873 = mono_unwind_get_cie_program ();
      D.26739 = acfg->image;
      D.26791 = D.26739->name;
      D.26874 = monoeg_g_path_get_basename (D.26791);
      D.26870 = acfg->dwarf;
      mono_dwarf_writer_emit_base_info (D.26870, D.26874, D.26873);
      <D.26872>:
      D.26875 = acfg->thumb_mixed;
      if (D.26875 != 0) goto <D.26876>; else goto <D.26877>;
      <D.26876>:
      {
        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.26793 = acfg->fp;
            fprintf (D.26793, ".arm\n");
          }
        finally
          {
            symbol = {CLOBBER};
          }
      }
      <D.26877>:
      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.26870 = acfg->dwarf;
      if (D.26870 != 0B) goto <D.26878>; else goto <D.26879>;
      <D.26878>:
      emit_dwarf_info (acfg);
      D.26870 = acfg->dwarf;
      mono_dwarf_writer_close (D.26870);
      <D.26879>:
      emit_mem_end (acfg);
      D.26880 = acfg->need_pt_gnu_stack;
      if (D.26880 != 0) goto <D.26881>; else goto <D.26882>;
      <D.26881>:
      D.26883 = acfg->use_bin_writer;
      if (D.26883 == 0) goto <D.26884>; else goto <D.26885>;
      <D.26884>:
      D.26793 = acfg->fp;
      fprintf (D.26793, "\n.section\t.note.GNU-stack,\"\",@progbits\n");
      <D.26885>:
      <D.26882>:
      btv = mono_100ns_ticks ();
      D.26776 = btv - atv;
      D.26777 = D.26776 / 10;
      D.26778 = (int) D.26777;
      acfg->stats.gen_time = D.26778;
      D.26800 = acfg->llvm;
      if (D.26800 != 0) goto <D.26886>; else goto <D.26887>;
      <D.26886>:
      D.26888 = acfg->got_offset;
      D.26889 = acfg->final_got_size;
      D.26890 = D.26888 > D.26889;
      D.26891 = (long int) D.26890;
      D.26892 = __builtin_expect (D.26891, 0);
      if (D.26892 != 0) goto <D.26893>; else goto <D.26894>;
      <D.26893>:
      monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "aot-compiler.c", 9004, "acfg->got_offset <= acfg->final_got_size");
      <D.26894>:
      <D.26887>:
      D.26800 = acfg->llvm;
      if (D.26800 != 0) goto <D.26895>; else goto <D.26896>;
      <D.26895>:
      D.26898 = acfg->stats.mcount;
      if (D.26898 != 0) goto <D.26899>; else goto <D.26900>;
      <D.26899>:
      D.26901 = acfg->stats.llvm_count;
      D.26902 = D.26901 * 100;
      D.26898 = acfg->stats.mcount;
      iftmp.37 = D.26902 / D.26898;
      goto <D.26903>;
      <D.26900>:
      iftmp.37 = 100;
      <D.26903>:
      D.26901 = acfg->stats.llvm_count;
      sprintf (&llvm_stats_msg, ", LLVM: %d (%d%%)", D.26901, iftmp.37);
      goto <D.26904>;
      <D.26896>:
      strcpy (&llvm_stats_msg, "");
      <D.26904>:
      D.26905 = acfg->stats.offsets_size;
      D.26888 = acfg->got_offset;
      D.26906 = D.26888 * 4;
      D.26907 = (int) D.26906;
      D.26908 = acfg->stats.got_info_size;
      D.26909 = acfg->plt_offset;
      D.26910 = acfg->stats.class_info_size;
      D.26911 = acfg->stats.unwind_info_size;
      D.26912 = acfg->stats.ex_info_size;
      D.26913 = acfg->stats.info_size;
      D.26914 = 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.26914, D.26913, D.26912, D.26911, D.26910, D.26909, D.26908, D.26907, D.26905);
      D.26916 = acfg->stats.all_calls;
      if (D.26916 != 0) goto <D.26917>; else goto <D.26918>;
      <D.26917>:
      D.26919 = acfg->stats.direct_calls;
      D.26920 = D.26919 * 100;
      D.26916 = acfg->stats.all_calls;
      iftmp.38 = D.26920 / D.26916;
      goto <D.26921>;
      <D.26918>:
      iftmp.38 = 100;
      <D.26921>:
      D.26919 = acfg->stats.direct_calls;
      D.26898 = acfg->stats.mcount;
      if (D.26898 != 0) goto <D.26923>; else goto <D.26924>;
      <D.26923>:
      D.26925 = acfg->stats.methods_without_got_slots;
      D.26926 = D.26925 * 100;
      D.26898 = acfg->stats.mcount;
      iftmp.39 = D.26926 / D.26898;
      goto <D.26927>;
      <D.26924>:
      iftmp.39 = 100;
      <D.26927>:
      D.26925 = acfg->stats.methods_without_got_slots;
      D.26898 = acfg->stats.mcount;
      if (D.26898 != 0) goto <D.26929>; else goto <D.26930>;
      <D.26929>:
      D.26931 = acfg->stats.ccount;
      D.26932 = D.26931 * 100;
      D.26898 = acfg->stats.mcount;
      iftmp.40 = D.26932 / D.26898;
      goto <D.26933>;
      <D.26930>:
      iftmp.40 = 100;
      <D.26933>:
      D.26898 = acfg->stats.mcount;
      D.26931 = acfg->stats.ccount;
      printf ("Compiled: %d/%d (%d%%)%s, No GOT slots: %d (%d%%), Direct calls: %d (%d%%)\n", D.26931, D.26898, iftmp.40, &llvm_stats_msg, D.26925, iftmp.39, D.26919, iftmp.38);
      D.26934 = acfg->stats.genericcount;
      if (D.26934 != 0) goto <D.26935>; else goto <D.26936>;
      <D.26935>:
      D.26898 = acfg->stats.mcount;
      if (D.26898 != 0) goto <D.26938>; else goto <D.26939>;
      <D.26938>:
      D.26934 = acfg->stats.genericcount;
      D.26940 = D.26934 * 100;
      D.26898 = acfg->stats.mcount;
      iftmp.41 = D.26940 / D.26898;
      goto <D.26941>;
      <D.26939>:
      iftmp.41 = 100;
      <D.26941>:
      D.26934 = acfg->stats.genericcount;
      printf ("%d methods are generic (%d%%)\n", D.26934, iftmp.41);
      <D.26936>:
      D.26942 = acfg->stats.abscount;
      if (D.26942 != 0) goto <D.26943>; else goto <D.26944>;
      <D.26943>:
      D.26898 = acfg->stats.mcount;
      if (D.26898 != 0) goto <D.26946>; else goto <D.26947>;
      <D.26946>:
      D.26942 = acfg->stats.abscount;
      D.26948 = D.26942 * 100;
      D.26898 = acfg->stats.mcount;
      iftmp.42 = D.26948 / D.26898;
      goto <D.26949>;
      <D.26947>:
      iftmp.42 = 100;
      <D.26949>:
      D.26942 = acfg->stats.abscount;
      printf ("%d methods contain absolute addresses (%d%%)\n", D.26942, iftmp.42);
      <D.26944>:
      D.26950 = acfg->stats.lmfcount;
      if (D.26950 != 0) goto <D.26951>; else goto <D.26952>;
      <D.26951>:
      D.26898 = acfg->stats.mcount;
      if (D.26898 != 0) goto <D.26954>; else goto <D.26955>;
      <D.26954>:
      D.26950 = acfg->stats.lmfcount;
      D.26956 = D.26950 * 100;
      D.26898 = acfg->stats.mcount;
      iftmp.43 = D.26956 / D.26898;
      goto <D.26957>;
      <D.26955>:
      iftmp.43 = 100;
      <D.26957>:
      D.26950 = acfg->stats.lmfcount;
      printf ("%d methods contain lmf pointers (%d%%)\n", D.26950, iftmp.43);
      <D.26952>:
      D.26958 = acfg->stats.ocount;
      if (D.26958 != 0) goto <D.26959>; else goto <D.26960>;
      <D.26959>:
      D.26898 = acfg->stats.mcount;
      if (D.26898 != 0) goto <D.26962>; else goto <D.26963>;
      <D.26962>:
      D.26958 = acfg->stats.ocount;
      D.26964 = D.26958 * 100;
      D.26898 = acfg->stats.mcount;
      iftmp.44 = D.26964 / D.26898;
      goto <D.26965>;
      <D.26963>:
      iftmp.44 = 100;
      <D.26965>:
      D.26958 = acfg->stats.ocount;
      printf ("%d methods have other problems (%d%%)\n", D.26958, iftmp.44);
      <D.26960>:
      atv = mono_100ns_ticks ();
      D.26868 = acfg->w;
      res = img_writer_emit_writeout (D.26868);
      if (res != 0) goto <D.26966>; else goto <D.26967>;
      <D.26966>:
      acfg_free (acfg);
      D.26701 = res;
      return D.26701;
      <D.26967>:
      D.26883 = acfg->use_bin_writer;
      if (D.26883 != 0) goto <D.26968>; else goto <D.26969>;
      <D.26968>:
      {
        int err;

        err = rename (tmp_outfile_name, outfile_name);
        if (err != 0) goto <D.26970>; else goto <D.26971>;
        <D.26970>:
        D.26796 = __errno_location ();
        D.26797 = *D.26796;
        D.26972 = strerror (D.26797);
        printf ("Unable to rename \'%s\' to \'%s\': %s\n", tmp_outfile_name, outfile_name, D.26972);
        D.26701 = 1;
        return D.26701;
        <D.26971>:
      }
      goto <D.26973>;
      <D.26969>:
      res = compile_asm (acfg);
      if (res != 0) goto <D.26974>; else goto <D.26975>;
      <D.26974>:
      acfg_free (acfg);
      D.26701 = res;
      return D.26701;
      <D.26975>:
      <D.26973>:
      btv = mono_100ns_ticks ();
      D.26776 = btv - atv;
      D.26777 = D.26776 / 10;
      D.26778 = (int) D.26777;
      acfg->stats.link_time = D.26778;
      D.26976 = acfg->aot_opts.stats;
      if (D.26976 != 0) goto <D.26977>; else goto <D.26978>;
      <D.26977>:
      {
        int i;

        printf ("GOT slot distribution:\n");
        i = 0;
        goto <D.26124>;
        <D.26123>:
        D.26979 = acfg->stats.got_slot_types[i];
        if (D.26979 != 0) goto <D.26980>; else goto <D.26981>;
        <D.26980>:
        D.26982 = acfg->stats.got_slot_info_sizes[i];
        D.26979 = acfg->stats.got_slot_types[i];
        D.26983 = get_patch_name (i);
        printf ("\t%s: %d (%d)\n", D.26983, D.26979, D.26982);
        <D.26981>:
        i = i + 1;
        <D.26124>:
        if (i <= 50) goto <D.26123>; else goto <D.26125>;
        <D.26125>:
      }
      <D.26978>:
      D.26984 = acfg->stats.link_time;
      D.26985 = D.26984 / 1000;
      D.26986 = acfg->stats.gen_time;
      D.26987 = D.26986 / 1000;
      D.26988 = acfg->stats.jit_time;
      D.26989 = D.26988 / 1000;
      printf ("JIT time: %d ms, Generation time: %d ms, Assembly+Link time: %d ms.\n", D.26989, D.26987, D.26985);
      acfg_free (acfg);
      D.26701 = 0;
      return D.26701;
    }
  finally
    {
      llvm_stats_msg = {CLOBBER};
    }
}


acfg_create (struct MonoAssembly * ass, guint32 opts)
{
  struct GPtrArray * D.26992;
  struct GHashTable * D.26993;
  struct GHashTable * D.26994;
  struct GHashTable * D.26995;
  void * D.26996;
  struct GHashTable * D.26997;
  void * D.26998;
  struct GHashTable * * D.26999;
  unsigned int i.45;
  unsigned int D.27001;
  struct GHashTable * * D.27002;
  struct GHashTable * D.27003;
  struct GPtrArray * D.27004;
  struct GHashTable * D.27005;
  struct GHashTable * D.27006;
  struct GHashTable * D.27007;
  struct GHashTable * D.27008;
  struct GPtrArray * D.27009;
  struct GPtrArray * D.27010;
  unsigned int D.27011;
  struct MonoMemPool * D.27012;
  struct GPtrArray * D.27013;
  struct GHashTable * D.27014;
  struct GPtrArray * D.27015;
  struct GHashTable * D.27016;
  struct GPtrArray * D.27017;
  struct GHashTable * D.27018;
  struct GHashTable * D.27019;
  struct GHashTable * D.27020;
  struct GHashTable * D.27021;
  struct CRITICAL_SECTION * D.27022;
  struct MonoAotCompile * D.27023;
  struct MonoImage * image;
  struct MonoAotCompile * acfg;
  int i;

  image = ass->image;
  acfg = monoeg_malloc0 (1032);
  D.26992 = monoeg_g_ptr_array_new ();
  acfg->methods = D.26992;
  D.26993 = monoeg_g_hash_table_new (0B, 0B);
  acfg->method_indexes = D.26993;
  D.26994 = monoeg_g_hash_table_new (0B, 0B);
  acfg->method_depth = D.26994;
  D.26995 = monoeg_g_hash_table_new (0B, 0B);
  acfg->plt_offset_to_entry = D.26995;
  D.26996 = monoeg_malloc0 (208);
  acfg->patch_to_plt_entry = D.26996;
  D.26997 = monoeg_g_hash_table_new (mono_patch_info_hash, mono_patch_info_equal);
  acfg->patch_to_got_offset = D.26997;
  D.26998 = monoeg_malloc0 (208);
  acfg->patch_to_got_offset_by_type = D.26998;
  i = 0;
  goto <D.26073>;
  <D.26072>:
  D.26999 = acfg->patch_to_got_offset_by_type;
  i.45 = (unsigned int) i;
  D.27001 = i.45 * 4;
  D.27002 = D.26999 + D.27001;
  D.27003 = monoeg_g_hash_table_new (mono_patch_info_hash, mono_patch_info_equal);
  *D.27002 = D.27003;
  i = i + 1;
  <D.26073>:
  if (i <= 51) goto <D.26072>; else goto <D.26074>;
  <D.26074>:
  D.27004 = monoeg_g_ptr_array_new ();
  acfg->got_patches = D.27004;
  D.27005 = monoeg_g_hash_table_new (0B, 0B);
  acfg->method_to_cfg = D.27005;
  D.27006 = monoeg_g_hash_table_new_full (0B, 0B, 0B, monoeg_g_free);
  acfg->token_info_hash = D.27006;
  D.27007 = monoeg_g_hash_table_new_full (0B, 0B, 0B, monoeg_g_free);
  acfg->method_to_pinvoke_import = D.27007;
  D.27008 = monoeg_g_hash_table_new (0B, 0B);
  acfg->image_hash = D.27008;
  D.27009 = monoeg_g_ptr_array_new ();
  acfg->image_table = D.27009;
  D.27010 = monoeg_g_ptr_array_new ();
  acfg->globals = D.27010;
  acfg->image = image;
  acfg->opts = opts;
  D.27011 = mono_arch_cpu_enumerate_simd_versions ();
  acfg->simd_opts = D.27011;
  D.27012 = mono_mempool_new ();
  acfg->mempool = D.27012;
  D.27013 = monoeg_g_ptr_array_new ();
  acfg->extra_methods = D.27013;
  D.27014 = monoeg_g_hash_table_new (0B, 0B);
  acfg->unwind_info_offsets = D.27014;
  D.27015 = monoeg_g_ptr_array_new ();
  acfg->unwind_ops = D.27015;
  D.27016 = monoeg_g_hash_table_new_full (monoeg_g_str_hash, monoeg_g_str_equal, monoeg_g_free, 0B);
  acfg->method_label_hash = D.27016;
  D.27017 = monoeg_g_ptr_array_new ();
  acfg->method_order = D.27017;
  D.27018 = monoeg_g_hash_table_new (0B, 0B);
  acfg->export_names = D.27018;
  D.27019 = monoeg_g_hash_table_new (0B, 0B);
  acfg->klass_blob_hash = D.27019;
  D.27020 = monoeg_g_hash_table_new (0B, 0B);
  acfg->method_blob_hash = D.27020;
  D.27021 = monoeg_g_hash_table_new (monoeg_g_str_hash, monoeg_g_str_equal);
  acfg->plt_entry_debug_sym_cache = D.27021;
  D.27022 = &acfg->mutex;
  InitializeCriticalSection (D.27022);
  D.27023 = acfg;
  return D.27023;
}


mono_aot_parse_options (const char * aot_options, struct MonoAotOptions * opts)
{
  const gchar * iftmp.46;
  int D.27029;
  const gchar * D.27032;
  gchar * D.27033;
  int D.27035;
  int D.27039;
  int D.27043;
  int D.27047;
  int D.27051;
  int D.27055;
  int D.27059;
  int D.27063;
  const char * D.27066;
  int D.27067;
  int D.27069;
  int D.27073;
  int D.27077;
  int D.27081;
  int D.27085;
  int D.27089;
  int D.27093;
  const char * D.27096;
  int D.27097;
  int D.27099;
  const char * D.27102;
  int D.27103;
  int D.27105;
  const char * D.27108;
  int D.27109;
  int D.27111;
  const char * D.27114;
  int D.27115;
  int D.27117;
  int D.27121;
  const gchar * D.27124;
  gchar * D.27125;
  int D.27127;
  int D.27131;
  int D.27135;
  int D.27139;
  int D.27143;
  int D.27147;
  int D.27151;
  int D.27155;
  int D.27159;
  gchar * D.27162;
  int D.27164;
  const gchar * D.27167;
  gchar * D.27168;
  int D.27170;
  const char * D.27173;
  int D.27175;
  int D.27178;
  int D.27184;
  int D.27186;
  struct _IO_FILE * stderr.47;
  gchar * D.27189;
  int D.27190;
  gchar * * args;
  gchar * * ptr;

  if (aot_options != 0B) goto <D.27026>; else goto <D.27027>;
  <D.27026>:
  iftmp.46 = aot_options;
  goto <D.27028>;
  <D.27027>:
  iftmp.46 = "";
  <D.27028>:
  args = monoeg_g_strsplit (iftmp.46, ",", -1);
  ptr = args;
  goto <D.25446>;
  <D.25445>:
  {
    const char * arg;

    arg = *ptr;
    D.27029 = str_begins_with (arg, "outfile=");
    if (D.27029 != 0) goto <D.27030>; else goto <D.27031>;
    <D.27030>:
    D.27032 = arg + 8;
    D.27033 = monoeg_strdup (D.27032);
    opts->outfile = D.27033;
    goto <D.27034>;
    <D.27031>:
    D.27035 = str_begins_with (arg, "save-temps");
    if (D.27035 != 0) goto <D.27036>; else goto <D.27037>;
    <D.27036>:
    opts->save_temps = 1;
    goto <D.27038>;
    <D.27037>:
    D.27039 = str_begins_with (arg, "keep-temps");
    if (D.27039 != 0) goto <D.27040>; else goto <D.27041>;
    <D.27040>:
    opts->save_temps = 1;
    goto <D.27042>;
    <D.27041>:
    D.27043 = str_begins_with (arg, "write-symbols");
    if (D.27043 != 0) goto <D.27044>; else goto <D.27045>;
    <D.27044>:
    opts->write_symbols = 1;
    goto <D.27046>;
    <D.27045>:
    D.27047 = str_begins_with (arg, "no-write-symbols");
    if (D.27047 != 0) goto <D.27048>; else goto <D.27049>;
    <D.27048>:
    opts->write_symbols = 0;
    goto <D.27050>;
    <D.27049>:
    D.27051 = str_begins_with (arg, "metadata-only");
    if (D.27051 != 0) goto <D.27052>; else goto <D.27053>;
    <D.27052>:
    opts->metadata_only = 1;
    goto <D.27054>;
    <D.27053>:
    D.27055 = str_begins_with (arg, "bind-to-runtime-version");
    if (D.27055 != 0) goto <D.27056>; else goto <D.27057>;
    <D.27056>:
    opts->bind_to_runtime_version = 1;
    goto <D.27058>;
    <D.27057>:
    D.27059 = str_begins_with (arg, "full");
    if (D.27059 != 0) goto <D.27060>; else goto <D.27061>;
    <D.27060>:
    opts->full_aot = 1;
    goto <D.27062>;
    <D.27061>:
    D.27063 = str_begins_with (arg, "threads=");
    if (D.27063 != 0) goto <D.27064>; else goto <D.27065>;
    <D.27064>:
    D.27066 = arg + 8;
    D.27067 = atoi (D.27066);
    opts->nthreads = D.27067;
    goto <D.27068>;
    <D.27065>:
    D.27069 = str_begins_with (arg, "static");
    if (D.27069 != 0) goto <D.27070>; else goto <D.27071>;
    <D.27070>:
    opts->static_link = 1;
    opts->no_dlsym = 1;
    goto <D.27072>;
    <D.27071>:
    D.27073 = str_begins_with (arg, "asmonly");
    if (D.27073 != 0) goto <D.27074>; else goto <D.27075>;
    <D.27074>:
    opts->asm_only = 1;
    goto <D.27076>;
    <D.27075>:
    D.27077 = str_begins_with (arg, "asmwriter");
    if (D.27077 != 0) goto <D.27078>; else goto <D.27079>;
    <D.27078>:
    opts->asm_writer = 1;
    goto <D.27080>;
    <D.27079>:
    D.27081 = str_begins_with (arg, "nodebug");
    if (D.27081 != 0) goto <D.27082>; else goto <D.27083>;
    <D.27082>:
    opts->nodebug = 1;
    goto <D.27084>;
    <D.27083>:
    D.27085 = str_begins_with (arg, "dwarfdebug");
    if (D.27085 != 0) goto <D.27086>; else goto <D.27087>;
    <D.27086>:
    opts->dwarf_debug = 1;
    goto <D.27088>;
    <D.27087>:
    D.27089 = str_begins_with (arg, "nopagetrampolines");
    if (D.27089 != 0) goto <D.27090>; else goto <D.27091>;
    <D.27090>:
    opts->use_trampolines_page = 0;
    goto <D.27092>;
    <D.27091>:
    D.27093 = str_begins_with (arg, "ntrampolines=");
    if (D.27093 != 0) goto <D.27094>; else goto <D.27095>;
    <D.27094>:
    D.27096 = arg + 13;
    D.27097 = atoi (D.27096);
    opts->ntrampolines = D.27097;
    goto <D.27098>;
    <D.27095>:
    D.27099 = str_begins_with (arg, "nrgctx-trampolines=");
    if (D.27099 != 0) goto <D.27100>; else goto <D.27101>;
    <D.27100>:
    D.27102 = arg + 19;
    D.27103 = atoi (D.27102);
    opts->nrgctx_trampolines = D.27103;
    goto <D.27104>;
    <D.27101>:
    D.27105 = str_begins_with (arg, "nimt-trampolines=");
    if (D.27105 != 0) goto <D.27106>; else goto <D.27107>;
    <D.27106>:
    D.27108 = arg + 17;
    D.27109 = atoi (D.27108);
    opts->nimt_trampolines = D.27109;
    goto <D.27110>;
    <D.27107>:
    D.27111 = str_begins_with (arg, "ngsharedvt-trampolines=");
    if (D.27111 != 0) goto <D.27112>; else goto <D.27113>;
    <D.27112>:
    D.27114 = arg + 23;
    D.27115 = atoi (D.27114);
    opts->ngsharedvt_arg_trampolines = D.27115;
    goto <D.27116>;
    <D.27113>:
    D.27117 = str_begins_with (arg, "autoreg");
    if (D.27117 != 0) goto <D.27118>; else goto <D.27119>;
    <D.27118>:
    opts->autoreg = 1;
    goto <D.27120>;
    <D.27119>:
    D.27121 = str_begins_with (arg, "tool-prefix=");
    if (D.27121 != 0) goto <D.27122>; else goto <D.27123>;
    <D.27122>:
    D.27124 = arg + 12;
    D.27125 = monoeg_strdup (D.27124);
    opts->tool_prefix = D.27125;
    goto <D.27126>;
    <D.27123>:
    D.27127 = str_begins_with (arg, "soft-debug");
    if (D.27127 != 0) goto <D.27128>; else goto <D.27129>;
    <D.27128>:
    opts->soft_debug = 1;
    goto <D.27130>;
    <D.27129>:
    D.27131 = str_begins_with (arg, "direct-pinvoke");
    if (D.27131 != 0) goto <D.27132>; else goto <D.27133>;
    <D.27132>:
    opts->direct_pinvoke = 1;
    goto <D.27134>;
    <D.27133>:
    D.27135 = str_begins_with (arg, "direct-icalls");
    if (D.27135 != 0) goto <D.27136>; else goto <D.27137>;
    <D.27136>:
    opts->direct_icalls = 1;
    goto <D.27138>;
    <D.27137>:
    D.27139 = str_begins_with (arg, "no-direct-calls");
    if (D.27139 != 0) goto <D.27140>; else goto <D.27141>;
    <D.27140>:
    opts->no_direct_calls = 1;
    goto <D.27142>;
    <D.27141>:
    D.27143 = str_begins_with (arg, "print-skipped");
    if (D.27143 != 0) goto <D.27144>; else goto <D.27145>;
    <D.27144>:
    opts->print_skipped_methods = 1;
    goto <D.27146>;
    <D.27145>:
    D.27147 = str_begins_with (arg, "stats");
    if (D.27147 != 0) goto <D.27148>; else goto <D.27149>;
    <D.27148>:
    opts->stats = 1;
    goto <D.27150>;
    <D.27149>:
    D.27151 = str_begins_with (arg, "no-instances");
    if (D.27151 != 0) goto <D.27152>; else goto <D.27153>;
    <D.27152>:
    opts->no_instances = 1;
    goto <D.27154>;
    <D.27153>:
    D.27155 = str_begins_with (arg, "log-generics");
    if (D.27155 != 0) goto <D.27156>; else goto <D.27157>;
    <D.27156>:
    opts->log_generics = 1;
    goto <D.27158>;
    <D.27157>:
    D.27159 = str_begins_with (arg, "mtriple=");
    if (D.27159 != 0) goto <D.27160>; else goto <D.27161>;
    <D.27160>:
    D.27032 = arg + 8;
    D.27162 = monoeg_strdup (D.27032);
    opts->mtriple = D.27162;
    goto <D.27163>;
    <D.27161>:
    D.27164 = str_begins_with (arg, "llvm-path=");
    if (D.27164 != 0) goto <D.27165>; else goto <D.27166>;
    <D.27165>:
    D.27167 = arg + 10;
    D.27168 = monoeg_strdup (D.27167);
    opts->llvm_path = D.27168;
    goto <D.27169>;
    <D.27166>:
    D.27170 = str_begins_with (arg, "readonly-value=");
    if (D.27170 != 0) goto <D.27171>; else goto <D.27172>;
    <D.27171>:
    D.27173 = arg + 15;
    add_readonly_value (opts, D.27173);
    goto <D.27174>;
    <D.27172>:
    D.27175 = str_begins_with (arg, "info");
    if (D.27175 != 0) goto <D.27176>; else goto <D.27177>;
    <D.27176>:
    printf ("AOT target setup: %s.\n", "X86 (!native client codegen)");
    exit (0);
    <D.27177>:
    D.27178 = str_begins_with (arg, "gc-maps");
    if (D.27178 != 0) goto <D.27179>; else goto <D.27180>;
    <D.27179>:
    mini_gc_enable_gc_maps_for_aot ();
    goto <D.27181>;
    <D.27180>:
    D.27184 = str_begins_with (arg, "help");
    if (D.27184 != 0) goto <D.27182>; else goto <D.27185>;
    <D.27185>:
    D.27186 = str_begins_with (arg, "?");
    if (D.27186 != 0) goto <D.27182>; else goto <D.27183>;
    <D.27182>:
    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.27183>:
    stderr.47 = stderr;
    fprintf (stderr.47, "AOT : Unknown argument \'%s\'.\n", arg);
    exit (1);
    <D.27181>:
    <D.27174>:
    <D.27169>:
    <D.27163>:
    <D.27158>:
    <D.27154>:
    <D.27150>:
    <D.27146>:
    <D.27142>:
    <D.27138>:
    <D.27134>:
    <D.27130>:
    <D.27126>:
    <D.27120>:
    <D.27116>:
    <D.27110>:
    <D.27104>:
    <D.27098>:
    <D.27092>:
    <D.27088>:
    <D.27084>:
    <D.27080>:
    <D.27076>:
    <D.27072>:
    <D.27068>:
    <D.27062>:
    <D.27058>:
    <D.27054>:
    <D.27050>:
    <D.27046>:
    <D.27042>:
    <D.27038>:
    <D.27034>:
  }
  ptr = ptr + 4;
  <D.25446>:
  if (ptr != 0B) goto <D.27188>; else goto <D.25447>;
  <D.27188>:
  D.27189 = *ptr;
  if (D.27189 != 0B) goto <D.25445>; else goto <D.25447>;
  <D.25447>:
  D.27190 = opts->use_trampolines_page;
  if (D.27190 != 0) goto <D.27191>; else goto <D.27192>;
  <D.27191>:
  opts->ntrampolines = 0;
  opts->nrgctx_trampolines = 0;
  opts->nimt_trampolines = 0;
  opts->ngsharedvt_arg_trampolines = 0;
  <D.27192>:
  monoeg_g_strfreev (args);
}


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

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


add_readonly_value (struct MonoAotOptions * opts, const char * val)
{
  struct _IO_FILE * stderr.48;
  int tval.49;
  int val.50;
  int D.27202;
  int D.27203;
  unsigned int D.27204;
  void * D.27205;
  unsigned int D.27206;
  char * D.27207;
  int D.27208;
  int D.27211;
  unsigned char D.27212;
  int D.27214;
  int D.27217;
  short unsigned int D.27218;
  int D.27220;
  int D.27223;
  unsigned int D.27224;
  struct ReadOnlyValue * readonly_values.51;
  struct ReadOnlyValue * rdv;
  const char * fval;
  const char * tval;

  fval = strrchr (val, 47);
  if (fval == 0B) goto <D.27195>; else goto <D.27196>;
  <D.27195>:
  stderr.48 = stderr;
  fprintf (stderr.48, "AOT : invalid format for readonly field \'%s\', missing /.\n", val);
  exit (1);
  <D.27196>:
  tval = strrchr (val, 61);
  if (tval == 0B) goto <D.27198>; else goto <D.27199>;
  <D.27198>:
  stderr.48 = stderr;
  fprintf (stderr.48, "AOT : invalid format for readonly field \'%s\', missing =.\n", val);
  exit (1);
  <D.27199>:
  rdv = monoeg_malloc0 (20);
  tval.49 = (int) tval;
  val.50 = (int) val;
  D.27202 = tval.49 - val.50;
  D.27203 = D.27202 + 1;
  D.27204 = (unsigned int) D.27203;
  D.27205 = monoeg_malloc0 (D.27204);
  rdv->name = D.27205;
  tval.49 = (int) tval;
  val.50 = (int) val;
  D.27202 = tval.49 - val.50;
  D.27206 = (unsigned int) D.27202;
  D.27207 = rdv->name;
  memcpy (D.27207, val, D.27206);
  tval = tval + 1;
  fval = fval + 1;
  D.27208 = strncmp (tval, "i1", 2);
  if (D.27208 == 0) goto <D.27209>; else goto <D.27210>;
  <D.27209>:
  D.27211 = atoi (fval);
  D.27212 = (unsigned char) D.27211;
  rdv->value.i1 = D.27212;
  rdv->type = 4;
  goto <D.27213>;
  <D.27210>:
  D.27214 = strncmp (tval, "i2", 2);
  if (D.27214 == 0) goto <D.27215>; else goto <D.27216>;
  <D.27215>:
  D.27217 = atoi (fval);
  D.27218 = (short unsigned int) D.27217;
  rdv->value.i2 = D.27218;
  rdv->type = 6;
  goto <D.27219>;
  <D.27216>:
  D.27220 = strncmp (tval, "i4", 2);
  if (D.27220 == 0) goto <D.27221>; else goto <D.27222>;
  <D.27221>:
  D.27223 = atoi (fval);
  D.27224 = (unsigned int) D.27223;
  rdv->value.i4 = D.27224;
  rdv->type = 8;
  goto <D.27225>;
  <D.27222>:
  stderr.48 = stderr;
  fprintf (stderr.48, "AOT : unsupported type for readonly field \'%s\'.\n", tval);
  exit (1);
  <D.27225>:
  <D.27219>:
  <D.27213>:
  readonly_values.51 = readonly_values;
  rdv->next = readonly_values.51;
  readonly_values = rdv;
}


str_begins_with (const char * str1, const char * str2)
{
  unsigned int D.27227;
  gboolean D.27228;
  unsigned int len.52;
  int D.27230;
  _Bool D.27231;
  int len;

  D.27227 = strlen (str2);
  len = (int) D.27227;
  len.52 = (unsigned int) len;
  D.27230 = strncmp (str1, str2, len.52);
  D.27231 = D.27230 == 0;
  D.27228 = (gboolean) D.27231;
  return D.27228;
}


load_profile_files (struct MonoAotCompile * acfg)
{
  struct MonoImage * D.27233;
  const char * D.27234;
  const gchar * D.27235;
  int D.27236;
  _Bool D.27239;
  long int D.27240;
  long int D.27241;
  int D.25630;
  int iftmp.53;
  int D.25629;
  const char[7] * D.27250;
  unsigned char D.27251;
  int D.27252;
  unsigned char D.27253;
  int D.27254;
  _Bool D.27255;
  _Bool D.27256;
  _Bool D.27257;
  const unsigned char * D.27260;
  unsigned char D.27261;
  int D.27262;
  const unsigned char * D.27263;
  unsigned char D.27264;
  int D.27265;
  _Bool D.27266;
  _Bool D.27267;
  const unsigned char * D.27270;
  unsigned char D.27271;
  int D.27272;
  const unsigned char * D.27273;
  unsigned char D.27274;
  int D.27275;
  _Bool D.27276;
  _Bool D.27277;
  const unsigned char * D.27280;
  unsigned char D.27281;
  int D.27282;
  const unsigned char * D.27283;
  unsigned char D.27284;
  int D.27285;
  char * D.27287;
  char[1024] * name.54;
  char D.27290;
  unsigned int D.27293;
  unsigned int D.27294;
  unsigned int D.27297;
  unsigned int D.27300;
  unsigned int D.27301;
  struct GPtrArray * D.27302;
  void * * D.27303;
  unsigned int i.55;
  unsigned int D.27305;
  void * * D.27306;
  void * D.27307;
  void * method_index.56;
  unsigned int i.57;
  unsigned int D.27312;
  <unnamed-unsigned:24> D.27320;
  int D.27321;
  void * D.27322;
  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.25640>:
      D.27233 = acfg->image;
      D.27234 = D.27233->assembly_name;
      D.27235 = monoeg_g_get_home_dir ();
      tmp = monoeg_g_strdup_printf ("%s/.mono/aot-profile-data/%s-%d", D.27235, D.27234, file_index);
      D.27236 = monoeg_g_file_test (tmp, 1);
      if (D.27236 == 0) goto <D.27237>; else goto <D.27238>;
      <D.27237>:
      monoeg_g_free (tmp);
      goto <D.25621>;
      <D.27238>:
      infile = fopen (tmp, "r");
      D.27239 = infile == 0B;
      D.27240 = (long int) D.27239;
      D.27241 = __builtin_expect (D.27240, 0);
      if (D.27241 != 0) goto <D.27242>; else goto <D.27243>;
      <D.27242>:
      monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "aot-compiler.c", 6785, "infile");
      <D.27243>:
      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.27244>; else goto <D.27246>;
      <D.27246>:
      {
        size_t __s1_len;
        size_t __s2_len;

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

          __s2 = &ver;
          D.27250 = "#VER:2";
          D.27251 = MEM[(const unsigned char *)D.27250];
          D.27252 = (int) D.27251;
          D.27253 = *__s2;
          D.27254 = (int) D.27253;
          __result = D.27252 - D.27254;
          {
            D.27255 = __s2_len != 0;
            D.27256 = __result == 0;
            D.27257 = D.27255 & D.27256;
            if (D.27257 != 0) goto <D.27258>; else goto <D.27259>;
            <D.27258>:
            D.27260 = &MEM[(void *)"#VER:2" + 1B];
            D.27261 = *D.27260;
            D.27262 = (int) D.27261;
            D.27263 = __s2 + 1;
            D.27264 = *D.27263;
            D.27265 = (int) D.27264;
            __result = D.27262 - D.27265;
            D.27266 = __s2_len > 1;
            D.27256 = __result == 0;
            D.27267 = D.27266 & D.27256;
            if (D.27267 != 0) goto <D.27268>; else goto <D.27269>;
            <D.27268>:
            D.27270 = &MEM[(void *)"#VER:2" + 2B];
            D.27271 = *D.27270;
            D.27272 = (int) D.27271;
            D.27273 = __s2 + 2;
            D.27274 = *D.27273;
            D.27275 = (int) D.27274;
            __result = D.27272 - D.27275;
            D.27276 = __s2_len > 2;
            D.27256 = __result == 0;
            D.27277 = D.27276 & D.27256;
            if (D.27277 != 0) goto <D.27278>; else goto <D.27279>;
            <D.27278>:
            D.27280 = &MEM[(void *)"#VER:2" + 3B];
            D.27281 = *D.27280;
            D.27282 = (int) D.27281;
            D.27283 = __s2 + 3;
            D.27284 = *D.27283;
            D.27285 = (int) D.27284;
            __result = D.27282 - D.27285;
            <D.27279>:
            <D.27269>:
            <D.27259>:
          }
          D.25629 = __result;
        }
        iftmp.53 = -D.25629;
        goto <D.27286>;
        <D.27249>:
        iftmp.53 = __builtin_strcmp (&ver, "#VER:2");
        <D.27286>:
        D.25630 = iftmp.53;
      }
      if (D.25630 != 0) goto <D.27244>; else goto <D.27245>;
      <D.27244>:
      printf ("Profile file has wrong version or invalid.\n");
      fclose (infile);
      // predicted unlikely by continue predictor.
      goto <D.25631>;
      <D.27245>:
      <D.25639>:
      {
        char name[1024];
        struct MonoMethodDesc * desc;
        struct MonoMethod * method;

        try
          {
            D.27287 = fgets (&name, 1023, infile);
            if (D.27287 == 0B) goto <D.25635>; else goto <D.27288>;
            <D.27288>:
            name.54 = &name;
            D.27290 = MEM[(const char *)name.54];
            if (D.27290 != 0) goto <D.27291>; else goto <D.27292>;
            <D.27291>:
            D.27293 = strlen (&name);
            D.27294 = D.27293 + 4294967295;
            name[D.27294] = 0;
            <D.27292>:
            desc = mono_method_desc_new (&name, 1);
            D.27233 = acfg->image;
            method = mono_method_desc_search_in_image (desc, D.27233);
            if (method != 0B) goto <D.27295>; else goto <D.27296>;
            <D.27295>:
            D.27297 = mono_method_get_token (method);
            if (D.27297 != 0) goto <D.27298>; else goto <D.27299>;
            <D.27298>:
            token = mono_method_get_token (method);
            D.27300 = token & 16777215;
            D.27301 = D.27300 + 4294967295;
            method_index = (int) D.27301;
            found = 0;
            i = 0;
            goto <D.25638>;
            <D.25637>:
            D.27302 = acfg->method_order;
            D.27303 = D.27302->pdata;
            i.55 = (unsigned int) i;
            D.27305 = i.55 * 4;
            D.27306 = D.27303 + D.27305;
            D.27307 = *D.27306;
            method_index.56 = (void *) method_index;
            if (D.27307 == method_index.56) goto <D.27309>; else goto <D.27310>;
            <D.27309>:
            found = 1;
            goto <D.25636>;
            <D.27310>:
            i = i + 1;
            <D.25638>:
            i.57 = (unsigned int) i;
            D.27302 = acfg->method_order;
            D.27312 = D.27302->len;
            if (i.57 < D.27312) goto <D.25637>; else goto <D.25636>;
            <D.25636>:
            if (found == 0) goto <D.27313>; else goto <D.27314>;
            <D.27313>:
            method_index.56 = (void *) method_index;
            D.27302 = acfg->method_order;
            monoeg_g_ptr_array_add (D.27302, method_index.56);
            <D.27314>:
            goto <D.27315>;
            <D.27299>:
            <D.27315>:
            <D.27296>:
          }
        finally
          {
            name = {CLOBBER};
          }
      }
      goto <D.25639>;
      <D.25635>:
      fclose (infile);
      <D.25631>:
      goto <D.25640>;
      <D.25621>:
      unordered = 0B;
      method_index = 0;
      goto <D.25645>;
      <D.25644>:
      found = 0;
      i = 0;
      goto <D.25643>;
      <D.25642>:
      D.27302 = acfg->method_order;
      D.27303 = D.27302->pdata;
      i.55 = (unsigned int) i;
      D.27305 = i.55 * 4;
      D.27306 = D.27303 + D.27305;
      D.27307 = *D.27306;
      method_index.56 = (void *) method_index;
      if (D.27307 == method_index.56) goto <D.27316>; else goto <D.27317>;
      <D.27316>:
      found = 1;
      goto <D.25641>;
      <D.27317>:
      i = i + 1;
      <D.25643>:
      i.57 = (unsigned int) i;
      D.27302 = acfg->method_order;
      D.27312 = D.27302->len;
      if (i.57 < D.27312) goto <D.25642>; else goto <D.25641>;
      <D.25641>:
      if (found == 0) goto <D.27318>; else goto <D.27319>;
      <D.27318>:
      method_index.56 = (void *) method_index;
      unordered = monoeg_g_list_prepend (unordered, method_index.56);
      <D.27319>:
      method_index = method_index + 1;
      <D.25645>:
      D.27233 = acfg->image;
      D.27320 = D.27233->tables[6].rows;
      D.27321 = (int) D.27320;
      if (D.27321 > method_index) goto <D.25644>; else goto <D.25646>;
      <D.25646>:
      unordered = monoeg_g_list_reverse (unordered);
      l = unordered;
      goto <D.25648>;
      <D.25647>:
      D.27322 = l->data;
      D.27302 = acfg->method_order;
      monoeg_g_ptr_array_add (D.27302, D.27322);
      l = l->next;
      <D.25648>:
      if (l != 0B) goto <D.25647>; else goto <D.25649>;
      <D.25649>:
    }
  finally
    {
      ver = {CLOBBER};
    }
}


fgets (char * restrict __s, int __n, struct FILE * restrict __stream)
{
  unsigned int D.27325;
  int D.27330;
  char * D.27332;
  unsigned int D.27333;
  unsigned int __n.58;
  unsigned int D.27335;
  unsigned int D.27338;

  D.27325 = __builtin_object_size (__s, 1);
  if (D.27325 != 4294967295) goto <D.27326>; else goto <D.27327>;
  <D.27326>:
  D.27330 = __builtin_constant_p (__n);
  if (D.27330 == 0) goto <D.27328>; else goto <D.27331>;
  <D.27331>:
  if (__n <= 0) goto <D.27328>; else goto <D.27329>;
  <D.27328>:
  D.27333 = __builtin_object_size (__s, 1);
  D.27332 = __fgets_chk (__s, D.27333, __n, __stream);
  return D.27332;
  <D.27329>:
  __n.58 = (unsigned int) __n;
  D.27335 = __builtin_object_size (__s, 1);
  if (__n.58 > D.27335) goto <D.27336>; else goto <D.27337>;
  <D.27336>:
  D.27338 = __builtin_object_size (__s, 1);
  D.27332 = __fgets_chk_warn (__s, D.27338, __n, __stream);
  return D.27332;
  <D.27337>:
  <D.27327>:
  D.27332 = __fgets_alias (__s, __n, __stream);
  return D.27332;
}


arch_init (struct MonoAotCompile * acfg)
{
  struct GString * D.27340;
  struct GString * D.27341;

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


collect_methods (struct MonoAotCompile * acfg)
{
  int D.27342;
  int D.27343;
  struct MonoImage * D.27344;
  char * D.27347;
  struct MonoClass * D.27348;
  int D.27349;
  short unsigned int D.27352;
  int D.27353;
  int D.27354;
  int check_for_pending_exc.59;
  int D.27358;
  int D.27359;
  <unnamed-unsigned:24> D.27360;
  int D.27361;
  int D.27362;
  int D.27363;
  unsigned int D.27364;
  unsigned int D.27365;
  unsigned char D.27372;
  unsigned char D.27373;
  struct MonoClass * D.27375;
  struct MonoGenericContainer * D.27376;
  int mindex;
  int i;
  struct MonoImage * image;

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

    D.27342 = i + 1;
    D.27343 = D.27342 | 100663296;
    token = (guint32) D.27343;
    D.27344 = acfg->image;
    method = mono_get_method (D.27344, token, 0B);
    if (method == 0B) goto <D.27345>; else goto <D.27346>;
    <D.27345>:
    D.27347 = image->name;
    printf ("Failed to load method 0x%x from \'%s\'.\n", token, D.27347);
    exit (1);
    <D.27346>:
    D.27348 = method->klass;
    mono_class_setup_methods (D.27348);
    D.27349 = acfg->aot_opts.full_aot;
    if (D.27349 != 0) goto <D.27350>; else goto <D.27351>;
    <D.27350>:
    D.27352 = method->iflags;
    D.27353 = (int) D.27352;
    D.27354 = D.27353 & 4096;
    if (D.27354 != 0) goto <D.27355>; else goto <D.27356>;
    <D.27355>:
    {
      struct MonoMethod * wrapper;

      check_for_pending_exc.59 = check_for_pending_exc;
      wrapper = mono_marshal_get_native_wrapper (method, check_for_pending_exc.59, 1);
      method = wrapper;
    }
    <D.27356>:
    <D.27351>:
    add_method_with_index (acfg, method, i, 0);
    D.27358 = acfg->method_index;
    D.27359 = D.27358 + 1;
    acfg->method_index = D.27359;
  }
  i = i + 1;
  <D.26021>:
  D.27360 = image->tables[6].rows;
  D.27361 = (int) D.27360;
  if (D.27361 > i) goto <D.26020>; else goto <D.26022>;
  <D.26022>:
  mindex = 0;
  goto <D.26028>;
  <D.26027>:
  {
    struct MonoMethod * method;
    guint32 token;

    D.27362 = mindex + 1;
    D.27363 = D.27362 | 100663296;
    token = (guint32) D.27363;
    D.27364 = acfg->opts;
    D.27365 = D.27364 & 16777216;
    if (D.27365 == 0) goto <D.27366>; else goto <D.27367>;
    <D.27366>:
    // predicted unlikely by continue predictor.
    goto <D.26025>;
    <D.27367>:
    D.27344 = acfg->image;
    method = mono_get_method (D.27344, token, 0B);
    if (method == 0B) goto <D.27368>; else goto <D.27369>;
    <D.27368>:
    // predicted unlikely by continue predictor.
    goto <D.26025>;
    <D.27369>:
    D.27372 = BIT_FIELD_REF <*method, 8, 168>;
    D.27373 = D.27372 & 8;
    if (D.27373 != 0) goto <D.27370>; else goto <D.27374>;
    <D.27374>:
    D.27375 = method->klass;
    D.27376 = D.27375->generic_container;
    if (D.27376 != 0B) goto <D.27370>; else goto <D.27371>;
    <D.27370>:
    {
      struct MonoMethod * gshared;

      gshared = mini_get_shared_method_full (method, 1, 1);
      add_extra_method (acfg, gshared);
    }
    <D.27371>:
  }
  <D.26025>:
  mindex = mindex + 1;
  <D.26028>:
  D.27360 = image->tables[6].rows;
  D.27361 = (int) D.27360;
  if (D.27361 > mindex) goto <D.26027>; else goto <D.26029>;
  <D.26029>:
  add_generic_instances (acfg);
  D.27349 = acfg->aot_opts.full_aot;
  if (D.27349 != 0) goto <D.27377>; else goto <D.27378>;
  <D.27377>:
  add_wrappers (acfg);
  <D.27378>:
}


add_method_with_index (struct MonoAotCompile * acfg, struct MonoMethod * method, int index, gboolean extra)
{
  _Bool D.27379;
  long int D.27380;
  long int D.27381;
  struct GHashTable * D.27384;
  void * D.27385;
  struct GPtrArray * D.27388;
  int D.27389;
  void * D.27390;
  unsigned int D.27391;
  unsigned int D.27392;
  unsigned char D.27395;
  unsigned char D.27396;
  struct GPtrArray * D.27398;

  D.27379 = method == 0B;
  D.27380 = (long int) D.27379;
  D.27381 = __builtin_expect (D.27380, 0);
  if (D.27381 != 0) goto <D.27382>; else goto <D.27383>;
  <D.27382>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "aot-compiler.c", 2994, "method");
  <D.27383>:
  D.27384 = acfg->method_indexes;
  D.27385 = monoeg_g_hash_table_lookup (D.27384, method);
  if (D.27385 == 0B) goto <D.27386>; else goto <D.27387>;
  <D.27386>:
  D.27388 = acfg->methods;
  monoeg_g_ptr_array_add (D.27388, method);
  D.27389 = index + 1;
  D.27390 = (void *) D.27389;
  D.27384 = acfg->method_indexes;
  monoeg_g_hash_table_insert_replace (D.27384, method, D.27390, 0);
  D.27388 = acfg->methods;
  D.27391 = D.27388->len;
  D.27392 = D.27391 + 1;
  acfg->nmethods = D.27392;
  <D.27387>:
  D.27395 = BIT_FIELD_REF <*method, 8, 160>;
  D.27396 = D.27395 & 124;
  if (D.27396 != 0) goto <D.27393>; else goto <D.27397>;
  <D.27397>:
  if (extra != 0) goto <D.27393>; else goto <D.27394>;
  <D.27393>:
  D.27398 = acfg->extra_methods;
  monoeg_g_ptr_array_add (D.27398, method);
  <D.27394>:
}


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.27399;
  int D.27402;
  char * D.27405;

  D.27399 = mono_method_is_generic_sharable_full (method, 0, 1, 0);
  if (D.27399 != 0) goto <D.27400>; else goto <D.27401>;
  <D.27400>:
  method = mini_get_shared_method (method);
  <D.27401>:
  D.27402 = acfg->aot_opts.log_generics;
  if (D.27402 != 0) goto <D.27403>; else goto <D.27404>;
  <D.27403>:
  D.27405 = mono_method_full_name (method, 1);
  printf ("%*sAdding method %s.\n", depth, "", D.27405);
  <D.27404>:
  add_method_full (acfg, method, 1, depth);
}


add_method_full (struct MonoAotCompile * acfg, struct MonoMethod * method, gboolean extra, int depth)
{
  struct GHashTable * D.27406;
  void * D.27407;
  int D.27410;
  void * index.60;
  struct GPtrArray * D.27412;
  void * depth.61;
  struct GHashTable * D.27414;
  int D.27415;
  int D.27416;
  int index;

  D.27406 = acfg->method_indexes;
  D.27407 = monoeg_g_hash_table_lookup (D.27406, method);
  index = (int) D.27407;
  if (index != 0) goto <D.27408>; else goto <D.27409>;
  <D.27408>:
  D.27410 = index + -1;
  return D.27410;
  <D.27409>:
  index = acfg->method_index;
  add_method_with_index (acfg, method, index, extra);
  index.60 = (void *) index;
  D.27412 = acfg->method_order;
  monoeg_g_ptr_array_add (D.27412, index.60);
  depth.61 = (void *) depth;
  D.27414 = acfg->method_depth;
  monoeg_g_hash_table_insert_replace (D.27414, method, depth.61, 0);
  D.27415 = acfg->method_index;
  D.27416 = D.27415 + 1;
  acfg->method_index = D.27416;
  D.27410 = index;
  return D.27410;
}


add_generic_instances (struct MonoAotCompile * acfg)
{
  int D.27418;
  int D.27421;
  int D.27422;
  struct MonoImage * D.27423;
  struct MonoClass * D.27426;
  struct MonoImage * D.27427;
  struct MonoGenericInst * D.27432;
  unsigned char D.27435;
  unsigned char D.27436;
  struct MonoGenericInst * D.27441;
  unsigned char D.27444;
  unsigned char D.27445;
  struct MonoType * D.27452;
  int D.27453;
  unsigned char D.27455;
  int D.27457;
  <unnamed-unsigned:22> D.27460;
  int D.27461;
  int D.27466;
  int D.27469;
  unsigned int D.27476;
  unsigned int D.27477;
  int D.27481;
  unsigned int i.62;
  unsigned int D.27485;
  struct MonoType * * D.27486;
  struct MonoClass * D.27487;
  struct MonoType * D.27488;
  struct MonoGenericInst * D.27489;
  int D.27495;
  struct MonoGenericInst * D.27498;
  unsigned char D.27502;
  unsigned char D.27503;
  struct MonoGenericContainer * D.27505;
  int D.27506;
  <unnamed-unsigned:24> D.27509;
  int D.27510;
  int D.27511;
  unsigned char D.27515;
  <unnamed-unsigned:24> D.27516;
  int D.27517;
  struct GPtrArray * D.27518;
  void * * D.27519;
  unsigned int i.63;
  unsigned int D.27521;
  void * * D.27522;
  unsigned int i.64;
  unsigned int D.27524;
  struct MonoImage * D.27525;
  int ninsts.65;
  struct MonoClass * D.27529;
  struct MonoType * D.27530;
  int ninsts.66;
  struct MonoClass * D.27532;
  struct MonoType * D.27533;
  int ninsts.67;
  struct MonoClass * D.27535;
  struct MonoType * D.27536;
  int ninsts.68;
  struct MonoClass * D.27538;
  struct MonoType * D.27539;
  int ninsts.69;
  struct MonoClass * D.27541;
  struct MonoType * D.27542;
  int ninsts.70;
  struct MonoClass * D.27544;
  struct MonoType * D.27545;
  int ninsts.71;
  struct MonoClass * D.27547;
  struct MonoType * D.27548;
  int ninsts.72;
  struct MonoClass * D.27550;
  struct MonoType * D.27551;
  int ninsts.73;
  struct MonoClass * D.27553;
  struct MonoType * D.27554;
  int ninsts.74;
  struct MonoClass * D.27556;
  struct MonoType * D.27557;
  int ninsts.75;
  struct MonoClass * D.27559;
  struct MonoType * D.27560;
  int ninsts.76;
  struct MonoClass * D.27562;
  struct MonoType * D.27563;
  struct MonoClass * D.27574;
  struct MonoGenericInst * D.27577;
  struct MonoMethod * D.27578;
  struct MonoMethod * D.27579;
  int D.24790;
  int iftmp.77;
  int D.24789;
  const char[16] * D.27585;
  unsigned char D.27586;
  int D.27587;
  unsigned char D.27588;
  int D.27589;
  _Bool D.27590;
  _Bool D.27591;
  _Bool D.27592;
  const unsigned char * D.27595;
  unsigned char D.27596;
  int D.27597;
  const unsigned char * D.27598;
  unsigned char D.27599;
  int D.27600;
  _Bool D.27601;
  _Bool D.27602;
  const unsigned char * D.27605;
  unsigned char D.27606;
  int D.27607;
  const unsigned char * D.27608;
  unsigned char D.27609;
  int D.27610;
  _Bool D.27611;
  _Bool D.27612;
  const unsigned char * D.27615;
  unsigned char D.27616;
  int D.27617;
  const unsigned char * D.27618;
  unsigned char D.27619;
  int D.27620;
  const char * D.27622;
  int D.24799;
  int iftmp.78;
  int D.24798;
  const char[9] * D.27627;
  unsigned char D.27628;
  int D.27629;
  unsigned char D.27630;
  int D.27631;
  _Bool D.27632;
  _Bool D.27633;
  _Bool D.27634;
  const unsigned char * D.27637;
  unsigned char D.27638;
  int D.27639;
  const unsigned char * D.27640;
  unsigned char D.27641;
  int D.27642;
  _Bool D.27643;
  _Bool D.27644;
  const unsigned char * D.27647;
  unsigned char D.27648;
  int D.27649;
  const unsigned char * D.27650;
  unsigned char D.27651;
  int D.27652;
  _Bool D.27653;
  _Bool D.27654;
  const unsigned char * D.27657;
  unsigned char D.27658;
  int D.27659;
  const unsigned char * D.27660;
  unsigned char D.27661;
  int D.27662;
  unsigned char D.27664;
  unsigned char D.27665;
  struct MonoGenericInst * D.27668;
  struct MonoMethod * D.27669;
  struct MonoMethod * D.27670;
  int D.24816;
  int iftmp.79;
  int D.24815;
  const char[5] * D.27678;
  unsigned char D.27679;
  int D.27680;
  unsigned char D.27681;
  int D.27682;
  _Bool D.27683;
  _Bool D.27684;
  _Bool D.27685;
  const unsigned char * D.27688;
  unsigned char D.27689;
  int D.27690;
  const unsigned char * D.27691;
  unsigned char D.27692;
  int D.27693;
  _Bool D.27694;
  _Bool D.27695;
  const unsigned char * D.27698;
  unsigned char D.27699;
  int D.27700;
  const unsigned char * D.27701;
  unsigned char D.27702;
  int D.27703;
  _Bool D.27704;
  _Bool D.27705;
  const unsigned char * D.27708;
  unsigned char D.27709;
  int D.27710;
  const unsigned char * D.27711;
  unsigned char D.27712;
  int D.27713;
  const char * D.27715;
  int D.24825;
  int iftmp.80;
  int D.24824;
  const char[6] * D.27720;
  unsigned char D.27721;
  int D.27722;
  unsigned char D.27723;
  int D.27724;
  _Bool D.27725;
  _Bool D.27726;
  _Bool D.27727;
  const unsigned char * D.27730;
  unsigned char D.27731;
  int D.27732;
  const unsigned char * D.27733;
  unsigned char D.27734;
  int D.27735;
  _Bool D.27736;
  _Bool D.27737;
  const unsigned char * D.27740;
  unsigned char D.27741;
  int D.27742;
  const unsigned char * D.27743;
  unsigned char D.27744;
  int D.27745;
  _Bool D.27746;
  _Bool D.27747;
  const unsigned char * D.27750;
  unsigned char D.27751;
  int D.27752;
  const unsigned char * D.27753;
  unsigned char D.27754;
  int D.27755;
  unsigned char D.27757;
  unsigned char D.27758;
  struct MonoGenericInst * D.27761;
  struct MonoMethod * D.27762;
  struct MonoMethod * D.27763;
  int i;
  guint32 token;
  struct MonoMethod * method;
  struct MonoGenericContext * context;

  D.27418 = acfg->aot_opts.no_instances;
  if (D.27418 != 0) goto <D.27419>; else goto <D.27420>;
  <D.27419>:
  return;
  <D.27420>:
  i = 0;
  goto <D.24760>;
  <D.24759>:
  D.27421 = i + 1;
  D.27422 = D.27421 | 721420288;
  token = (guint32) D.27422;
  D.27423 = acfg->image;
  method = mono_get_method (D.27423, token, 0B);
  if (method == 0B) goto <D.27424>; else goto <D.27425>;
  <D.27424>:
  // predicted unlikely by continue predictor.
  goto <D.24738>;
  <D.27425>:
  D.27426 = method->klass;
  D.27427 = D.27426->image;
  D.27423 = acfg->image;
  if (D.27427 != D.27423) goto <D.27428>; else goto <D.27429>;
  <D.27428>:
  // predicted unlikely by continue predictor.
  goto <D.24738>;
  <D.27429>:
  context = mono_method_get_context (method);
  if (context != 0B) goto <D.27430>; else goto <D.27431>;
  <D.27430>:
  D.27432 = context->class_inst;
  if (D.27432 != 0B) goto <D.27433>; else goto <D.27434>;
  <D.27433>:
  D.27432 = context->class_inst;
  D.27435 = BIT_FIELD_REF <*D.27432, 8, 48>;
  D.27436 = D.27435 & 64;
  if (D.27436 != 0) goto <D.27437>; else goto <D.27438>;
  <D.27437>:
  // predicted unlikely by continue predictor.
  goto <D.24738>;
  <D.27438>:
  <D.27434>:
  <D.27431>:
  if (context != 0B) goto <D.27439>; else goto <D.27440>;
  <D.27439>:
  D.27441 = context->method_inst;
  if (D.27441 != 0B) goto <D.27442>; else goto <D.27443>;
  <D.27442>:
  D.27441 = context->method_inst;
  D.27444 = BIT_FIELD_REF <*D.27441, 8, 48>;
  D.27445 = D.27444 & 64;
  if (D.27445 != 0) goto <D.27446>; else goto <D.27447>;
  <D.27446>:
  {
    struct MonoGenericContext shared_context;
    struct MonoGenericInst * inst;
    struct MonoType * * type_argv;
    int i;
    struct MonoMethod * declaring_method;
    gboolean supported;

    try
      {
        supported = 1;
        D.27432 = context->class_inst;
        if (D.27432 != 0B) goto <D.27448>; else goto <D.27449>;
        <D.27448>:
        inst = context->class_inst;
        i = 0;
        goto <D.24747>;
        <D.24746>:
        D.27452 = inst->type_argv[i];
        D.27453 = mono_type_is_reference (D.27452);
        if (D.27453 != 0) goto <D.27450>; else goto <D.27454>;
        <D.27454>:
        D.27452 = inst->type_argv[i];
        D.27455 = D.27452->type;
        if (D.27455 == 19) goto <D.27450>; else goto <D.27456>;
        <D.27456>:
        D.27452 = inst->type_argv[i];
        D.27455 = D.27452->type;
        if (D.27455 == 30) goto <D.27450>; else goto <D.27451>;
        <D.27450>:
        // predicted unlikely by continue predictor.
        goto <D.24745>;
        <D.27451>:
        D.27452 = inst->type_argv[i];
        D.27457 = mono_class_is_open_constructed_type (D.27452);
        if (D.27457 != 0) goto <D.27458>; else goto <D.27459>;
        <D.27458>:
        supported = 0;
        <D.27459>:
        <D.24745>:
        i = i + 1;
        <D.24747>:
        D.27460 = inst->type_argc;
        D.27461 = (int) D.27460;
        if (D.27461 > i) goto <D.24746>; else goto <D.24748>;
        <D.24748>:
        <D.27449>:
        D.27441 = context->method_inst;
        if (D.27441 != 0B) goto <D.27462>; else goto <D.27463>;
        <D.27462>:
        inst = context->method_inst;
        i = 0;
        goto <D.24751>;
        <D.24750>:
        D.27452 = inst->type_argv[i];
        D.27466 = mono_type_is_reference (D.27452);
        if (D.27466 != 0) goto <D.27464>; else goto <D.27467>;
        <D.27467>:
        D.27452 = inst->type_argv[i];
        D.27455 = D.27452->type;
        if (D.27455 == 19) goto <D.27464>; else goto <D.27468>;
        <D.27468>:
        D.27452 = inst->type_argv[i];
        D.27455 = D.27452->type;
        if (D.27455 == 30) goto <D.27464>; else goto <D.27465>;
        <D.27464>:
        // predicted unlikely by continue predictor.
        goto <D.24749>;
        <D.27465>:
        D.27452 = inst->type_argv[i];
        D.27469 = mono_class_is_open_constructed_type (D.27452);
        if (D.27469 != 0) goto <D.27470>; else goto <D.27471>;
        <D.27470>:
        supported = 0;
        <D.27471>:
        <D.24749>:
        i = i + 1;
        <D.24751>:
        D.27460 = inst->type_argc;
        D.27461 = (int) D.27460;
        if (D.27461 > i) goto <D.24750>; else goto <D.24752>;
        <D.24752>:
        <D.27463>:
        if (supported == 0) goto <D.27472>; else goto <D.27473>;
        <D.27472>:
        // predicted unlikely by continue predictor.
        goto <D.24738>;
        <D.27473>:
        memset (&shared_context, 0, 8);
        inst = context->class_inst;
        if (inst != 0B) goto <D.27474>; else goto <D.27475>;
        <D.27474>:
        D.27460 = inst->type_argc;
        D.27476 = (unsigned int) D.27460;
        D.27477 = D.27476 * 4;
        type_argv = monoeg_malloc0 (D.27477);
        i = 0;
        goto <D.24754>;
        <D.24753>:
        D.27452 = inst->type_argv[i];
        D.27481 = mono_type_is_reference (D.27452);
        if (D.27481 != 0) goto <D.27478>; else goto <D.27482>;
        <D.27482>:
        D.27452 = inst->type_argv[i];
        D.27455 = D.27452->type;
        if (D.27455 == 19) goto <D.27478>; else goto <D.27483>;
        <D.27483>:
        D.27452 = inst->type_argv[i];
        D.27455 = D.27452->type;
        if (D.27455 == 30) goto <D.27478>; else goto <D.27479>;
        <D.27478>:
        i.62 = (unsigned int) i;
        D.27485 = i.62 * 4;
        D.27486 = type_argv + D.27485;
        D.27487 = mono_defaults.object_class;
        D.27488 = &D.27487->byval_arg;
        *D.27486 = D.27488;
        goto <D.27480>;
        <D.27479>:
        i.62 = (unsigned int) i;
        D.27485 = i.62 * 4;
        D.27486 = type_argv + D.27485;
        D.27452 = inst->type_argv[i];
        *D.27486 = D.27452;
        <D.27480>:
        i = i + 1;
        <D.24754>:
        D.27460 = inst->type_argc;
        D.27461 = (int) D.27460;
        if (D.27461 > i) goto <D.24753>; else goto <D.24755>;
        <D.24755>:
        D.27460 = inst->type_argc;
        D.27461 = (int) D.27460;
        D.27489 = mono_metadata_get_generic_inst (D.27461, type_argv);
        shared_context.class_inst = D.27489;
        monoeg_g_free (type_argv);
        <D.27475>:
        inst = context->method_inst;
        if (inst != 0B) goto <D.27490>; else goto <D.27491>;
        <D.27490>:
        D.27460 = inst->type_argc;
        D.27476 = (unsigned int) D.27460;
        D.27477 = D.27476 * 4;
        type_argv = monoeg_malloc0 (D.27477);
        i = 0;
        goto <D.24757>;
        <D.24756>:
        D.27452 = inst->type_argv[i];
        D.27495 = mono_type_is_reference (D.27452);
        if (D.27495 != 0) goto <D.27492>; else goto <D.27496>;
        <D.27496>:
        D.27452 = inst->type_argv[i];
        D.27455 = D.27452->type;
        if (D.27455 == 19) goto <D.27492>; else goto <D.27497>;
        <D.27497>:
        D.27452 = inst->type_argv[i];
        D.27455 = D.27452->type;
        if (D.27455 == 30) goto <D.27492>; else goto <D.27493>;
        <D.27492>:
        i.62 = (unsigned int) i;
        D.27485 = i.62 * 4;
        D.27486 = type_argv + D.27485;
        D.27487 = mono_defaults.object_class;
        D.27488 = &D.27487->byval_arg;
        *D.27486 = D.27488;
        goto <D.27494>;
        <D.27493>:
        i.62 = (unsigned int) i;
        D.27485 = i.62 * 4;
        D.27486 = type_argv + D.27485;
        D.27452 = inst->type_argv[i];
        *D.27486 = D.27452;
        <D.27494>:
        i = i + 1;
        <D.24757>:
        D.27460 = inst->type_argc;
        D.27461 = (int) D.27460;
        if (D.27461 > i) goto <D.24756>; else goto <D.24758>;
        <D.24758>:
        D.27460 = inst->type_argc;
        D.27461 = (int) D.27460;
        D.27498 = mono_metadata_get_generic_inst (D.27461, type_argv);
        shared_context.method_inst = D.27498;
        monoeg_g_free (type_argv);
        <D.27491>:
        D.27502 = BIT_FIELD_REF <*method, 8, 168>;
        D.27503 = D.27502 & 8;
        if (D.27503 != 0) goto <D.27499>; else goto <D.27504>;
        <D.27504>:
        D.27426 = method->klass;
        D.27505 = D.27426->generic_container;
        if (D.27505 != 0B) goto <D.27499>; else goto <D.27500>;
        <D.27499>:
        declaring_method = method;
        goto <D.27501>;
        <D.27500>:
        declaring_method = mono_method_get_declaring_generic_method (method);
        <D.27501>:
        method = mono_class_inflate_generic_method (declaring_method, &shared_context);
      }
    finally
      {
        shared_context = {CLOBBER};
      }
  }
  <D.27447>:
  <D.27443>:
  <D.27440>:
  D.27506 = mono_method_is_generic_sharable_full (method, 0, 0, 0);
  if (D.27506 != 0) goto <D.27507>; else goto <D.27508>;
  <D.27507>:
  // predicted unlikely by continue predictor.
  goto <D.24738>;
  <D.27508>:
  add_extra_method (acfg, method);
  <D.24738>:
  i = i + 1;
  <D.24760>:
  D.27423 = acfg->image;
  D.27509 = D.27423->tables[43].rows;
  D.27510 = (int) D.27509;
  if (D.27510 > i) goto <D.24759>; else goto <D.24761>;
  <D.24761>:
  i = 0;
  goto <D.24765>;
  <D.24764>:
  {
    struct MonoClass * klass;

    D.27421 = i + 1;
    D.27511 = D.27421 | 452984832;
    token = (guint32) D.27511;
    D.27423 = acfg->image;
    klass = mono_class_get (D.27423, token);
    if (klass == 0B) goto <D.27512>; else goto <D.27514>;
    <D.27514>:
    D.27515 = klass->rank;
    if (D.27515 != 0) goto <D.27512>; else goto <D.27513>;
    <D.27512>:
    mono_loader_clear_error ();
    // predicted unlikely by continue predictor.
    goto <D.24763>;
    <D.27513>:
    add_generic_class (acfg, klass, 0, "typespec");
  }
  <D.24763>:
  i = i + 1;
  <D.24765>:
  D.27423 = acfg->image;
  D.27516 = D.27423->tables[27].rows;
  D.27517 = (int) D.27516;
  if (D.27517 > i) goto <D.24764>; else goto <D.24766>;
  <D.24766>:
  i = 0;
  goto <D.24768>;
  <D.24767>:
  D.27518 = acfg->methods;
  D.27519 = D.27518->pdata;
  i.63 = (unsigned int) i;
  D.27521 = i.63 * 4;
  D.27522 = D.27519 + D.27521;
  method = *D.27522;
  add_types_from_method_header (acfg, method);
  i = i + 1;
  <D.24768>:
  i.64 = (unsigned int) i;
  D.27518 = acfg->methods;
  D.27524 = D.27518->len;
  if (i.64 < D.27524) goto <D.24767>; else goto <D.24769>;
  <D.24769>:
  D.27423 = acfg->image;
  D.27525 = mono_defaults.corlib;
  if (D.27423 == D.27525) goto <D.27526>; else goto <D.27527>;
  <D.27526>:
  {
    struct MonoClass * klass;
    struct MonoType * insts[256];
    int ninsts;

    try
      {
        ninsts = 0;
        ninsts.65 = ninsts;
        ninsts = ninsts.65 + 1;
        D.27529 = mono_defaults.byte_class;
        D.27530 = &D.27529->byval_arg;
        insts[ninsts.65] = D.27530;
        ninsts.66 = ninsts;
        ninsts = ninsts.66 + 1;
        D.27532 = mono_defaults.sbyte_class;
        D.27533 = &D.27532->byval_arg;
        insts[ninsts.66] = D.27533;
        ninsts.67 = ninsts;
        ninsts = ninsts.67 + 1;
        D.27535 = mono_defaults.int16_class;
        D.27536 = &D.27535->byval_arg;
        insts[ninsts.67] = D.27536;
        ninsts.68 = ninsts;
        ninsts = ninsts.68 + 1;
        D.27538 = mono_defaults.uint16_class;
        D.27539 = &D.27538->byval_arg;
        insts[ninsts.68] = D.27539;
        ninsts.69 = ninsts;
        ninsts = ninsts.69 + 1;
        D.27541 = mono_defaults.int32_class;
        D.27542 = &D.27541->byval_arg;
        insts[ninsts.69] = D.27542;
        ninsts.70 = ninsts;
        ninsts = ninsts.70 + 1;
        D.27544 = mono_defaults.uint32_class;
        D.27545 = &D.27544->byval_arg;
        insts[ninsts.70] = D.27545;
        ninsts.71 = ninsts;
        ninsts = ninsts.71 + 1;
        D.27547 = mono_defaults.int64_class;
        D.27548 = &D.27547->byval_arg;
        insts[ninsts.71] = D.27548;
        ninsts.72 = ninsts;
        ninsts = ninsts.72 + 1;
        D.27550 = mono_defaults.uint64_class;
        D.27551 = &D.27550->byval_arg;
        insts[ninsts.72] = D.27551;
        ninsts.73 = ninsts;
        ninsts = ninsts.73 + 1;
        D.27553 = mono_defaults.single_class;
        D.27554 = &D.27553->byval_arg;
        insts[ninsts.73] = D.27554;
        ninsts.74 = ninsts;
        ninsts = ninsts.74 + 1;
        D.27556 = mono_defaults.double_class;
        D.27557 = &D.27556->byval_arg;
        insts[ninsts.74] = D.27557;
        ninsts.75 = ninsts;
        ninsts = ninsts.75 + 1;
        D.27559 = mono_defaults.char_class;
        D.27560 = &D.27559->byval_arg;
        insts[ninsts.75] = D.27560;
        ninsts.76 = ninsts;
        ninsts = ninsts.76 + 1;
        D.27562 = mono_defaults.boolean_class;
        D.27563 = &D.27562->byval_arg;
        insts[ninsts.76] = D.27563;
        D.27423 = acfg->image;
        klass = mono_class_from_name (D.27423, "System.Collections.Generic", "GenericComparer`1");
        if (klass != 0B) goto <D.27564>; else goto <D.27565>;
        <D.27564>:
        add_instances_of (acfg, klass, &insts, ninsts, 1);
        <D.27565>:
        D.27423 = acfg->image;
        klass = mono_class_from_name (D.27423, "System.Collections.Generic", "GenericEqualityComparer`1");
        if (klass != 0B) goto <D.27566>; else goto <D.27567>;
        <D.27566>:
        add_instances_of (acfg, klass, &insts, ninsts, 1);
        <D.27567>:
        D.27423 = acfg->image;
        klass = mono_class_from_name (D.27423, "System.Collections.Generic", "ICollection`1");
        if (klass != 0B) goto <D.27568>; else goto <D.27569>;
        <D.27568>:
        add_instances_of (acfg, klass, &insts, ninsts, 1);
        <D.27569>:
        D.27423 = acfg->image;
        klass = mono_class_from_name (D.27423, "System.Collections.Generic", "IList`1");
        if (klass != 0B) goto <D.27570>; else goto <D.27571>;
        <D.27570>:
        add_instances_of (acfg, klass, &insts, ninsts, 1);
        <D.27571>:
        D.27423 = acfg->image;
        klass = mono_class_from_name (D.27423, "System.Collections.Generic", "IEnumerable`1");
        if (klass != 0B) goto <D.27572>; else goto <D.27573>;
        <D.27572>:
        add_instances_of (acfg, klass, &insts, ninsts, 1);
        <D.27573>:
        {
          struct MonoGenericContext ctx;
          struct MonoType * args[16];
          struct MonoMethod * get_method;
          struct MonoClass * array_klass;

          try
            {
              D.27487 = mono_defaults.object_class;
              D.27574 = mono_array_class_get (D.27487, 1);
              array_klass = D.27574->parent;
              get_method = mono_class_get_method_from_name (array_klass, "GetGenericValueImpl", 2);
              if (get_method != 0B) goto <D.27575>; else goto <D.27576>;
              <D.27575>:
              memset (&ctx, 0, 8);
              D.27487 = mono_defaults.object_class;
              D.27488 = &D.27487->byval_arg;
              args[0] = D.27488;
              D.27577 = mono_metadata_get_generic_inst (1, &args);
              ctx.method_inst = D.27577;
              D.27578 = mono_class_inflate_generic_method (get_method, &ctx);
              D.27579 = mono_marshal_get_native_wrapper (D.27578, 1, 1);
              add_extra_method (acfg, D.27579);
              <D.27576>:
            }
          finally
            {
              ctx = {CLOBBER};
              args = {CLOBBER};
            }
        }
        {
          struct MonoGenericContext ctx;
          struct MonoType * args[16];
          struct MonoMethod * m;
          struct MonoClass * interlocked_klass;
          void * iter;

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

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

                  __s2 = m->name;
                  D.27585 = "CompareExchange";
                  D.27586 = MEM[(const unsigned char *)D.27585];
                  D.27587 = (int) D.27586;
                  D.27588 = *__s2;
                  D.27589 = (int) D.27588;
                  __result = D.27587 - D.27589;
                  {
                    D.27590 = __s2_len != 0;
                    D.27591 = __result == 0;
                    D.27592 = D.27590 & D.27591;
                    if (D.27592 != 0) goto <D.27593>; else goto <D.27594>;
                    <D.27593>:
                    D.27595 = &MEM[(void *)"CompareExchange" + 1B];
                    D.27596 = *D.27595;
                    D.27597 = (int) D.27596;
                    D.27598 = __s2 + 1;
                    D.27599 = *D.27598;
                    D.27600 = (int) D.27599;
                    __result = D.27597 - D.27600;
                    D.27601 = __s2_len > 1;
                    D.27591 = __result == 0;
                    D.27602 = D.27601 & D.27591;
                    if (D.27602 != 0) goto <D.27603>; else goto <D.27604>;
                    <D.27603>:
                    D.27605 = &MEM[(void *)"CompareExchange" + 2B];
                    D.27606 = *D.27605;
                    D.27607 = (int) D.27606;
                    D.27608 = __s2 + 2;
                    D.27609 = *D.27608;
                    D.27610 = (int) D.27609;
                    __result = D.27607 - D.27610;
                    D.27611 = __s2_len > 2;
                    D.27591 = __result == 0;
                    D.27612 = D.27611 & D.27591;
                    if (D.27612 != 0) goto <D.27613>; else goto <D.27614>;
                    <D.27613>:
                    D.27615 = &MEM[(void *)"CompareExchange" + 3B];
                    D.27616 = *D.27615;
                    D.27617 = (int) D.27616;
                    D.27618 = __s2 + 3;
                    D.27619 = *D.27618;
                    D.27620 = (int) D.27619;
                    __result = D.27617 - D.27620;
                    <D.27614>:
                    <D.27604>:
                    <D.27594>:
                  }
                  D.24789 = __result;
                }
                iftmp.77 = -D.24789;
                goto <D.27621>;
                <D.27584>:
                D.27622 = m->name;
                iftmp.77 = __builtin_strcmp (D.27622, "CompareExchange");
                <D.27621>:
                D.24790 = iftmp.77;
              }
              if (D.24790 == 0) goto <D.27580>; else goto <D.27623>;
              <D.27623>:
              {
                size_t __s1_len;
                size_t __s2_len;

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

                  __s2 = m->name;
                  D.27627 = "Exchange";
                  D.27628 = MEM[(const unsigned char *)D.27627];
                  D.27629 = (int) D.27628;
                  D.27630 = *__s2;
                  D.27631 = (int) D.27630;
                  __result = D.27629 - D.27631;
                  {
                    D.27632 = __s2_len != 0;
                    D.27633 = __result == 0;
                    D.27634 = D.27632 & D.27633;
                    if (D.27634 != 0) goto <D.27635>; else goto <D.27636>;
                    <D.27635>:
                    D.27637 = &MEM[(void *)"Exchange" + 1B];
                    D.27638 = *D.27637;
                    D.27639 = (int) D.27638;
                    D.27640 = __s2 + 1;
                    D.27641 = *D.27640;
                    D.27642 = (int) D.27641;
                    __result = D.27639 - D.27642;
                    D.27643 = __s2_len > 1;
                    D.27633 = __result == 0;
                    D.27644 = D.27643 & D.27633;
                    if (D.27644 != 0) goto <D.27645>; else goto <D.27646>;
                    <D.27645>:
                    D.27647 = &MEM[(void *)"Exchange" + 2B];
                    D.27648 = *D.27647;
                    D.27649 = (int) D.27648;
                    D.27650 = __s2 + 2;
                    D.27651 = *D.27650;
                    D.27652 = (int) D.27651;
                    __result = D.27649 - D.27652;
                    D.27653 = __s2_len > 2;
                    D.27633 = __result == 0;
                    D.27654 = D.27653 & D.27633;
                    if (D.27654 != 0) goto <D.27655>; else goto <D.27656>;
                    <D.27655>:
                    D.27657 = &MEM[(void *)"Exchange" + 3B];
                    D.27658 = *D.27657;
                    D.27659 = (int) D.27658;
                    D.27660 = __s2 + 3;
                    D.27661 = *D.27660;
                    D.27662 = (int) D.27661;
                    __result = D.27659 - D.27662;
                    <D.27656>:
                    <D.27646>:
                    <D.27636>:
                  }
                  D.24798 = __result;
                }
                iftmp.78 = -D.24798;
                goto <D.27663>;
                <D.27626>:
                D.27622 = m->name;
                iftmp.78 = __builtin_strcmp (D.27622, "Exchange");
                <D.27663>:
                D.24799 = iftmp.78;
              }
              if (D.24799 == 0) goto <D.27580>; else goto <D.27581>;
              <D.27580>:
              D.27664 = BIT_FIELD_REF <*m, 8, 168>;
              D.27665 = D.27664 & 8;
              if (D.27665 != 0) goto <D.27666>; else goto <D.27667>;
              <D.27666>:
              memset (&ctx, 0, 8);
              D.27487 = mono_defaults.object_class;
              D.27488 = &D.27487->byval_arg;
              args[0] = D.27488;
              D.27668 = mono_metadata_get_generic_inst (1, &args);
              ctx.method_inst = D.27668;
              D.27669 = mono_class_inflate_generic_method (m, &ctx);
              D.27670 = mono_marshal_get_native_wrapper (D.27669, 1, 1);
              add_extra_method (acfg, D.27670);
              <D.27667>:
              <D.27581>:
              <D.24801>:
              m = mono_class_get_methods (interlocked_klass, &iter);
              if (m != 0B) goto <D.24800>; else goto <D.24802>;
              <D.24802>:
            }
          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.27525 = mono_defaults.corlib;
              volatile_klass = mono_class_from_name (D.27525, "System.Threading", "Volatile");
              iter = 0B;
              if (volatile_klass != 0B) goto <D.27671>; else goto <D.27672>;
              <D.27671>:
              goto <D.24827>;
              <D.24826>:
              {
                size_t __s1_len;
                size_t __s2_len;

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

                  __s2 = m->name;
                  D.27678 = "Read";
                  D.27679 = MEM[(const unsigned char *)D.27678];
                  D.27680 = (int) D.27679;
                  D.27681 = *__s2;
                  D.27682 = (int) D.27681;
                  __result = D.27680 - D.27682;
                  {
                    D.27683 = __s2_len != 0;
                    D.27684 = __result == 0;
                    D.27685 = D.27683 & D.27684;
                    if (D.27685 != 0) goto <D.27686>; else goto <D.27687>;
                    <D.27686>:
                    D.27688 = &MEM[(void *)"Read" + 1B];
                    D.27689 = *D.27688;
                    D.27690 = (int) D.27689;
                    D.27691 = __s2 + 1;
                    D.27692 = *D.27691;
                    D.27693 = (int) D.27692;
                    __result = D.27690 - D.27693;
                    D.27694 = __s2_len > 1;
                    D.27684 = __result == 0;
                    D.27695 = D.27694 & D.27684;
                    if (D.27695 != 0) goto <D.27696>; else goto <D.27697>;
                    <D.27696>:
                    D.27698 = &MEM[(void *)"Read" + 2B];
                    D.27699 = *D.27698;
                    D.27700 = (int) D.27699;
                    D.27701 = __s2 + 2;
                    D.27702 = *D.27701;
                    D.27703 = (int) D.27702;
                    __result = D.27700 - D.27703;
                    D.27704 = __s2_len > 2;
                    D.27684 = __result == 0;
                    D.27705 = D.27704 & D.27684;
                    if (D.27705 != 0) goto <D.27706>; else goto <D.27707>;
                    <D.27706>:
                    D.27708 = &MEM[(void *)"Read" + 3B];
                    D.27709 = *D.27708;
                    D.27710 = (int) D.27709;
                    D.27711 = __s2 + 3;
                    D.27712 = *D.27711;
                    D.27713 = (int) D.27712;
                    __result = D.27710 - D.27713;
                    <D.27707>:
                    <D.27697>:
                    <D.27687>:
                  }
                  D.24815 = __result;
                }
                iftmp.79 = -D.24815;
                goto <D.27714>;
                <D.27677>:
                D.27715 = m->name;
                iftmp.79 = __builtin_strcmp (D.27715, "Read");
                <D.27714>:
                D.24816 = iftmp.79;
              }
              if (D.24816 == 0) goto <D.27673>; else goto <D.27716>;
              <D.27716>:
              {
                size_t __s1_len;
                size_t __s2_len;

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

                  __s2 = m->name;
                  D.27720 = "Write";
                  D.27721 = MEM[(const unsigned char *)D.27720];
                  D.27722 = (int) D.27721;
                  D.27723 = *__s2;
                  D.27724 = (int) D.27723;
                  __result = D.27722 - D.27724;
                  {
                    D.27725 = __s2_len != 0;
                    D.27726 = __result == 0;
                    D.27727 = D.27725 & D.27726;
                    if (D.27727 != 0) goto <D.27728>; else goto <D.27729>;
                    <D.27728>:
                    D.27730 = &MEM[(void *)"Write" + 1B];
                    D.27731 = *D.27730;
                    D.27732 = (int) D.27731;
                    D.27733 = __s2 + 1;
                    D.27734 = *D.27733;
                    D.27735 = (int) D.27734;
                    __result = D.27732 - D.27735;
                    D.27736 = __s2_len > 1;
                    D.27726 = __result == 0;
                    D.27737 = D.27736 & D.27726;
                    if (D.27737 != 0) goto <D.27738>; else goto <D.27739>;
                    <D.27738>:
                    D.27740 = &MEM[(void *)"Write" + 2B];
                    D.27741 = *D.27740;
                    D.27742 = (int) D.27741;
                    D.27743 = __s2 + 2;
                    D.27744 = *D.27743;
                    D.27745 = (int) D.27744;
                    __result = D.27742 - D.27745;
                    D.27746 = __s2_len > 2;
                    D.27726 = __result == 0;
                    D.27747 = D.27746 & D.27726;
                    if (D.27747 != 0) goto <D.27748>; else goto <D.27749>;
                    <D.27748>:
                    D.27750 = &MEM[(void *)"Write" + 3B];
                    D.27751 = *D.27750;
                    D.27752 = (int) D.27751;
                    D.27753 = __s2 + 3;
                    D.27754 = *D.27753;
                    D.27755 = (int) D.27754;
                    __result = D.27752 - D.27755;
                    <D.27749>:
                    <D.27739>:
                    <D.27729>:
                  }
                  D.24824 = __result;
                }
                iftmp.80 = -D.24824;
                goto <D.27756>;
                <D.27719>:
                D.27715 = m->name;
                iftmp.80 = __builtin_strcmp (D.27715, "Write");
                <D.27756>:
                D.24825 = iftmp.80;
              }
              if (D.24825 == 0) goto <D.27673>; else goto <D.27674>;
              <D.27673>:
              D.27757 = BIT_FIELD_REF <*m, 8, 168>;
              D.27758 = D.27757 & 8;
              if (D.27758 != 0) goto <D.27759>; else goto <D.27760>;
              <D.27759>:
              memset (&ctx, 0, 8);
              D.27487 = mono_defaults.object_class;
              D.27488 = &D.27487->byval_arg;
              args[0] = D.27488;
              D.27761 = mono_metadata_get_generic_inst (1, &args);
              ctx.method_inst = D.27761;
              D.27762 = mono_class_inflate_generic_method (m, &ctx);
              D.27763 = mono_marshal_get_native_wrapper (D.27762, 1, 1);
              add_extra_method (acfg, D.27763);
              <D.27760>:
              <D.27674>:
              <D.24827>:
              m = mono_class_get_methods (volatile_klass, &iter);
              if (m != 0B) goto <D.24826>; else goto <D.24828>;
              <D.24828>:
              <D.27672>:
            }
          finally
            {
              ctx = {CLOBBER};
              args = {CLOBBER};
              iter = {CLOBBER};
            }
        }
      }
    finally
      {
        insts = {CLOBBER};
      }
  }
  <D.27527>:
}


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

  D.27767 = acfg->aot_opts.full_aot;
  D.27768 = D.27767 | force;
  if (D.27768 == 0) goto <D.27769>; else goto <D.27770>;
  <D.27769>:
  return;
  <D.27770>:
  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.27772;
  struct GHashTable * D.27775;
  struct MonoGenericClass * D.27776;
  struct MonoGenericInst * D.27779;
  unsigned char D.27780;
  unsigned char D.27781;
  int D.27784;
  unsigned char D.27789;
  unsigned char D.27792;
  struct GHashTable * D.27797;
  void * D.27798;
  struct MonoType * D.27801;
  int D.27802;
  int D.27805;
  char * D.27808;
  unsigned int D.27811;
  unsigned int D.27812;
  struct MonoImage * D.27815;
  struct MonoImage * D.27816;
  int D.27823;
  int D.24540;
  int iftmp.81;
  int D.24539;
  const char[13] * D.27829;
  unsigned char D.27830;
  int D.27831;
  unsigned char D.27832;
  int D.27833;
  _Bool D.27834;
  _Bool D.27835;
  _Bool D.27836;
  const unsigned char * D.27839;
  unsigned char D.27840;
  int D.27841;
  const unsigned char * D.27842;
  unsigned char D.27843;
  int D.27844;
  _Bool D.27845;
  _Bool D.27846;
  const unsigned char * D.27849;
  unsigned char D.27850;
  int D.27851;
  const unsigned char * D.27852;
  unsigned char D.27853;
  int D.27854;
  _Bool D.27855;
  _Bool D.27856;
  const unsigned char * D.27859;
  unsigned char D.27860;
  int D.27861;
  const unsigned char * D.27862;
  unsigned char D.27863;
  int D.27864;
  const char * D.27866;
  int D.24549;
  int iftmp.82;
  int D.24548;
  const char[7] * D.27871;
  unsigned char D.27872;
  int D.27873;
  unsigned char D.27874;
  int D.27875;
  _Bool D.27876;
  _Bool D.27877;
  _Bool D.27878;
  const unsigned char * D.27881;
  unsigned char D.27882;
  int D.27883;
  const unsigned char * D.27884;
  unsigned char D.27885;
  int D.27886;
  _Bool D.27887;
  _Bool D.27888;
  const unsigned char * D.27891;
  unsigned char D.27892;
  int D.27893;
  const unsigned char * D.27894;
  unsigned char D.27895;
  int D.27896;
  _Bool D.27897;
  _Bool D.27898;
  const unsigned char * D.27901;
  unsigned char D.27902;
  int D.27903;
  const unsigned char * D.27904;
  unsigned char D.27905;
  int D.27906;
  unsigned char D.27910;
  unsigned char D.27911;
  struct MonoGenericContext * D.27914;
  struct MonoGenericInst * D.27915;
  int D.27918;
  unsigned char D.27921;
  int D.27924;
  struct MonoType * D.27925;
  unsigned char D.27926;
  struct MonoClass * D.27929;
  unsigned char D.27930;
  unsigned char D.27931;
  char * D.27936;
  struct MonoClass * D.27937;
  int D.24564;
  int iftmp.83;
  int D.24563;
  const char[27] * 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.24573;
  int iftmp.84;
  int D.24572;
  const char[14] * D.27990;
  unsigned char D.27991;
  int D.27992;
  unsigned char D.27993;
  int D.27994;
  _Bool D.27995;
  _Bool D.27996;
  _Bool D.27997;
  const unsigned char * D.28000;
  unsigned char D.28001;
  int D.28002;
  const unsigned char * D.28003;
  unsigned char D.28004;
  int D.28005;
  _Bool D.28006;
  _Bool D.28007;
  const unsigned char * D.28010;
  unsigned char D.28011;
  int D.28012;
  const unsigned char * D.28013;
  unsigned char D.28014;
  int D.28015;
  _Bool D.28016;
  _Bool D.28017;
  const unsigned char * D.28020;
  unsigned char D.28021;
  int D.28022;
  const unsigned char * D.28023;
  unsigned char D.28024;
  int D.28025;
  int D.24582;
  int iftmp.85;
  int D.24581;
  const char[14] * D.28031;
  unsigned char D.28032;
  int D.28033;
  unsigned char D.28034;
  int D.28035;
  _Bool D.28036;
  _Bool D.28037;
  _Bool D.28038;
  const unsigned char * D.28041;
  unsigned char D.28042;
  int D.28043;
  const unsigned char * D.28044;
  unsigned char D.28045;
  int D.28046;
  _Bool D.28047;
  _Bool D.28048;
  const unsigned char * D.28051;
  unsigned char D.28052;
  int D.28053;
  const unsigned char * D.28054;
  unsigned char D.28055;
  int D.28056;
  _Bool D.28057;
  _Bool D.28058;
  const unsigned char * D.28061;
  unsigned char D.28062;
  int D.28063;
  const unsigned char * D.28064;
  unsigned char D.28065;
  int D.28066;
  int D.24591;
  int iftmp.86;
  int D.24590;
  const char[8] * D.28072;
  unsigned char D.28073;
  int D.28074;
  unsigned char D.28075;
  int D.28076;
  _Bool D.28077;
  _Bool D.28078;
  _Bool D.28079;
  const unsigned char * D.28082;
  unsigned char D.28083;
  int D.28084;
  const unsigned char * D.28085;
  unsigned char D.28086;
  int 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;
  int D.24600;
  int iftmp.87;
  int D.24599;
  const char[14] * D.28113;
  unsigned char D.28114;
  int D.28115;
  unsigned char D.28116;
  int D.28117;
  _Bool D.28118;
  _Bool D.28119;
  _Bool D.28120;
  const unsigned char * D.28123;
  unsigned char D.28124;
  int D.28125;
  const unsigned char * D.28126;
  unsigned char D.28127;
  int D.28128;
  _Bool D.28129;
  _Bool D.28130;
  const unsigned char * D.28133;
  unsigned char D.28134;
  int D.28135;
  const unsigned char * D.28136;
  unsigned char D.28137;
  int D.28138;
  _Bool D.28139;
  _Bool D.28140;
  const unsigned char * D.28143;
  unsigned char D.28144;
  int D.28145;
  const unsigned char * D.28146;
  unsigned char D.28147;
  int D.28148;
  int D.24609;
  int iftmp.88;
  int D.24608;
  const char[16] * D.28154;
  unsigned char D.28155;
  int D.28156;
  unsigned char D.28157;
  int D.28158;
  _Bool D.28159;
  _Bool D.28160;
  _Bool D.28161;
  const unsigned char * D.28164;
  unsigned char D.28165;
  int D.28166;
  const unsigned char * D.28167;
  unsigned char D.28168;
  int D.28169;
  _Bool D.28170;
  _Bool D.28171;
  const unsigned char * D.28174;
  unsigned char D.28175;
  int D.28176;
  const unsigned char * D.28177;
  unsigned char D.28178;
  int D.28179;
  _Bool D.28180;
  _Bool D.28181;
  const unsigned char * D.28184;
  unsigned char D.28185;
  int D.28186;
  const unsigned char * D.28187;
  unsigned char D.28188;
  int D.28189;
  struct MonoType * D.28191;
  int D.24622;
  int iftmp.89;
  int D.24621;
  unsigned char D.28195;
  int D.28196;
  _Bool D.28197;
  _Bool D.28198;
  _Bool D.28199;
  const unsigned char * D.28202;
  unsigned char D.28203;
  int D.28204;
  _Bool D.28205;
  _Bool D.28206;
  const unsigned char * D.28209;
  unsigned char D.28210;
  int D.28211;
  _Bool D.28212;
  _Bool D.28213;
  const unsigned char * D.28216;
  unsigned char D.28217;
  int D.28218;
  int D.24631;
  int iftmp.90;
  int D.24630;
  unsigned char D.28228;
  int D.28229;
  _Bool D.28230;
  _Bool D.28231;
  _Bool D.28232;
  const unsigned char * D.28235;
  unsigned char D.28236;
  int D.28237;
  _Bool D.28238;
  _Bool D.28239;
  const unsigned char * D.28242;
  unsigned char D.28243;
  int D.28244;
  _Bool D.28245;
  _Bool D.28246;
  const unsigned char * D.28249;
  unsigned char D.28250;
  int D.28251;
  int D.24640;
  int iftmp.91;
  int D.24639;
  unsigned char D.28257;
  int D.28258;
  _Bool D.28259;
  _Bool D.28260;
  _Bool D.28261;
  const unsigned char * D.28264;
  unsigned char D.28265;
  int D.28266;
  _Bool D.28267;
  _Bool D.28268;
  const unsigned char * D.28271;
  unsigned char D.28272;
  int D.28273;
  _Bool D.28274;
  _Bool D.28275;
  const unsigned char * D.28278;
  unsigned char D.28279;
  int D.28280;
  int D.24650;
  int iftmp.92;
  int D.24649;
  const char[21] * D.28285;
  unsigned char D.28286;
  int D.28287;
  unsigned char D.28288;
  int D.28289;
  _Bool D.28290;
  _Bool D.28291;
  _Bool D.28292;
  const unsigned char * D.28295;
  unsigned char D.28296;
  int D.28297;
  const unsigned char * D.28298;
  unsigned char D.28299;
  int D.28300;
  _Bool D.28301;
  _Bool D.28302;
  const unsigned char * D.28305;
  unsigned char D.28306;
  int D.28307;
  const unsigned char * D.28308;
  unsigned char D.28309;
  int D.28310;
  _Bool D.28311;
  _Bool D.28312;
  const unsigned char * D.28315;
  unsigned char D.28316;
  int D.28317;
  const unsigned char * D.28318;
  unsigned char D.28319;
  int D.28320;
  const char * D.28322;
  struct MonoClass * D.28324;
  _Bool D.28325;
  long int D.28326;
  long int D.28327;
  struct MonoGenericContext * D.28330;
  const char * D.28331;
  char * D.28332;
  int D.24666;
  int iftmp.93;
  int D.24665;
  unsigned char D.28340;
  int D.28341;
  _Bool D.28342;
  _Bool D.28343;
  _Bool D.28344;
  const unsigned char * D.28347;
  unsigned char D.28348;
  int D.28349;
  _Bool D.28350;
  _Bool D.28351;
  const unsigned char * D.28354;
  unsigned char D.28355;
  int D.28356;
  _Bool D.28357;
  _Bool D.28358;
  const unsigned char * D.28361;
  unsigned char D.28362;
  int D.28363;
  int D.24675;
  int iftmp.94;
  int D.24674;
  const char[11] * D.28370;
  unsigned char D.28371;
  int D.28372;
  unsigned char D.28373;
  int D.28374;
  _Bool D.28375;
  _Bool D.28376;
  _Bool D.28377;
  const unsigned char * D.28380;
  unsigned char D.28381;
  int D.28382;
  const unsigned char * D.28383;
  unsigned char D.28384;
  int D.28385;
  _Bool D.28386;
  _Bool D.28387;
  const unsigned char * D.28390;
  unsigned char D.28391;
  int D.28392;
  const unsigned char * D.28393;
  unsigned char D.28394;
  int D.28395;
  _Bool D.28396;
  _Bool D.28397;
  const unsigned char * D.28400;
  unsigned char D.28401;
  int D.28402;
  const unsigned char * D.28403;
  unsigned char D.28404;
  int D.28405;
  _Bool D.28409;
  long int D.28410;
  long int D.28411;
  struct MonoType * D.28414;
  struct MonoGenericInst * D.28415;
  struct MonoClass * D.28416;
  int D.28417;
  _Bool D.28420;
  long int D.28421;
  long int D.28422;
  struct MonoClass * D.28425;
  int D.24689;
  int iftmp.95;
  int D.24688;
  unsigned char D.28431;
  int D.28432;
  _Bool D.28433;
  _Bool D.28434;
  _Bool D.28435;
  const unsigned char * D.28438;
  unsigned char D.28439;
  int D.28440;
  _Bool D.28441;
  _Bool D.28442;
  const unsigned char * D.28445;
  unsigned char D.28446;
  int D.28447;
  _Bool D.28448;
  _Bool D.28449;
  const unsigned char * D.28452;
  unsigned char D.28453;
  int D.28454;
  int D.24698;
  int iftmp.96;
  int D.24697;
  const char[19] * D.28461;
  unsigned char D.28462;
  int D.28463;
  unsigned char D.28464;
  int D.28465;
  _Bool D.28466;
  _Bool D.28467;
  _Bool D.28468;
  const unsigned char * D.28471;
  unsigned char D.28472;
  int D.28473;
  const unsigned char * D.28474;
  unsigned char D.28475;
  int D.28476;
  _Bool D.28477;
  _Bool D.28478;
  const unsigned char * D.28481;
  unsigned char D.28482;
  int D.28483;
  const unsigned char * D.28484;
  unsigned char D.28485;
  int D.28486;
  _Bool D.28487;
  _Bool D.28488;
  const unsigned char * D.28491;
  unsigned char D.28492;
  int D.28493;
  const unsigned char * D.28494;
  unsigned char D.28495;
  int D.28496;
  _Bool D.28500;
  long int D.28501;
  long int D.28502;
  struct MonoType * D.28505;
  struct MonoGenericInst * D.28506;
  struct MonoClass * D.28507;
  int D.28508;
  _Bool D.28511;
  long int D.28512;
  long int D.28513;
  struct MonoClass * D.28516;
  struct MonoMethod * method;
  struct MonoClassField * field;
  void * iter;
  gboolean use_gsharedvt;

  try
    {
      use_gsharedvt = 0;
      D.27772 = acfg->ginst_hash;
      if (D.27772 == 0B) goto <D.27773>; else goto <D.27774>;
      <D.27773>:
      D.27775 = monoeg_g_hash_table_new (0B, 0B);
      acfg->ginst_hash = D.27775;
      <D.27774>:
      mono_class_init (klass);
      D.27776 = klass->generic_class;
      if (D.27776 != 0B) goto <D.27777>; else goto <D.27778>;
      <D.27777>:
      D.27776 = klass->generic_class;
      D.27779 = D.27776->context.class_inst;
      D.27780 = BIT_FIELD_REF <*D.27779, 8, 48>;
      D.27781 = D.27780 & 64;
      if (D.27781 != 0) goto <D.27782>; else goto <D.27783>;
      <D.27782>:
      return;
      <D.27783>:
      <D.27778>:
      D.27784 = has_type_vars (klass);
      if (D.27784 != 0) goto <D.27785>; else goto <D.27786>;
      <D.27785>:
      return;
      <D.27786>:
      D.27776 = klass->generic_class;
      if (D.27776 == 0B) goto <D.27787>; else goto <D.27788>;
      <D.27787>:
      D.27789 = klass->rank;
      if (D.27789 == 0) goto <D.27790>; else goto <D.27791>;
      <D.27790>:
      return;
      <D.27791>:
      <D.27788>:
      D.27792 = klass->exception_type;
      if (D.27792 != 0) goto <D.27793>; else goto <D.27794>;
      <D.27793>:
      return;
      <D.27794>:
      D.27772 = acfg->ginst_hash;
      if (D.27772 == 0B) goto <D.27795>; else goto <D.27796>;
      <D.27795>:
      D.27797 = monoeg_g_hash_table_new (0B, 0B);
      acfg->ginst_hash = D.27797;
      <D.27796>:
      D.27772 = acfg->ginst_hash;
      D.27798 = monoeg_g_hash_table_lookup (D.27772, klass);
      if (D.27798 != 0B) goto <D.27799>; else goto <D.27800>;
      <D.27799>:
      return;
      <D.27800>:
      D.27801 = &klass->byval_arg;
      D.27802 = check_type_depth (D.27801, 0);
      if (D.27802 != 0) goto <D.27803>; else goto <D.27804>;
      <D.27803>:
      return;
      <D.27804>:
      D.27805 = acfg->aot_opts.log_generics;
      if (D.27805 != 0) goto <D.27806>; else goto <D.27807>;
      <D.27806>:
      D.27801 = &klass->byval_arg;
      D.27808 = mono_type_full_name (D.27801);
      printf ("%*sAdding generic instance %s [%s].\n", depth, "", D.27808, ref);
      <D.27807>:
      D.27772 = acfg->ginst_hash;
      monoeg_g_hash_table_insert_replace (D.27772, klass, klass, 0);
      D.27811 = acfg->opts;
      D.27812 = D.27811 & 16777216;
      if (D.27812 != 0) goto <D.27813>; else goto <D.27814>;
      <D.27813>:
      D.27815 = klass->image;
      D.27816 = mono_defaults.corlib;
      if (D.27815 == D.27816) goto <D.27817>; else goto <D.27818>;
      <D.27817>:
      D.27776 = klass->generic_class;
      if (D.27776 != 0B) goto <D.27819>; else goto <D.27820>;
      <D.27819>:
      D.27776 = klass->generic_class;
      D.27779 = D.27776->context.class_inst;
      if (D.27779 != 0B) goto <D.27821>; else goto <D.27822>;
      <D.27821>:
      D.27776 = klass->generic_class;
      D.27779 = D.27776->context.class_inst;
      D.27823 = is_vt_inst (D.27779);
      if (D.27823 != 0) goto <D.27824>; else goto <D.27825>;
      <D.27824>:
      {
        size_t __s1_len;
        size_t __s2_len;

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

          __s2 = klass->name;
          D.27829 = "Dictionary`2";
          D.27830 = MEM[(const unsigned char *)D.27829];
          D.27831 = (int) D.27830;
          D.27832 = *__s2;
          D.27833 = (int) D.27832;
          __result = D.27831 - D.27833;
          {
            D.27834 = __s2_len != 0;
            D.27835 = __result == 0;
            D.27836 = D.27834 & D.27835;
            if (D.27836 != 0) goto <D.27837>; else goto <D.27838>;
            <D.27837>:
            D.27839 = &MEM[(void *)"Dictionary`2" + 1B];
            D.27840 = *D.27839;
            D.27841 = (int) D.27840;
            D.27842 = __s2 + 1;
            D.27843 = *D.27842;
            D.27844 = (int) D.27843;
            __result = D.27841 - D.27844;
            D.27845 = __s2_len > 1;
            D.27835 = __result == 0;
            D.27846 = D.27845 & D.27835;
            if (D.27846 != 0) goto <D.27847>; else goto <D.27848>;
            <D.27847>:
            D.27849 = &MEM[(void *)"Dictionary`2" + 2B];
            D.27850 = *D.27849;
            D.27851 = (int) D.27850;
            D.27852 = __s2 + 2;
            D.27853 = *D.27852;
            D.27854 = (int) D.27853;
            __result = D.27851 - D.27854;
            D.27855 = __s2_len > 2;
            D.27835 = __result == 0;
            D.27856 = D.27855 & D.27835;
            if (D.27856 != 0) goto <D.27857>; else goto <D.27858>;
            <D.27857>:
            D.27859 = &MEM[(void *)"Dictionary`2" + 3B];
            D.27860 = *D.27859;
            D.27861 = (int) D.27860;
            D.27862 = __s2 + 3;
            D.27863 = *D.27862;
            D.27864 = (int) D.27863;
            __result = D.27861 - D.27864;
            <D.27858>:
            <D.27848>:
            <D.27838>:
          }
          D.24539 = __result;
        }
        iftmp.81 = -D.24539;
        goto <D.27865>;
        <D.27828>:
        D.27866 = klass->name;
        iftmp.81 = __builtin_strcmp (D.27866, "Dictionary`2");
        <D.27865>:
        D.24540 = iftmp.81;
      }
      if (D.24540 == 0) goto <D.27809>; else goto <D.27867>;
      <D.27867>:
      {
        size_t __s1_len;
        size_t __s2_len;

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

          __s2 = klass->name;
          D.27871 = "List`1";
          D.27872 = MEM[(const unsigned char *)D.27871];
          D.27873 = (int) D.27872;
          D.27874 = *__s2;
          D.27875 = (int) D.27874;
          __result = D.27873 - D.27875;
          {
            D.27876 = __s2_len != 0;
            D.27877 = __result == 0;
            D.27878 = D.27876 & D.27877;
            if (D.27878 != 0) goto <D.27879>; else goto <D.27880>;
            <D.27879>:
            D.27881 = &MEM[(void *)"List`1" + 1B];
            D.27882 = *D.27881;
            D.27883 = (int) D.27882;
            D.27884 = __s2 + 1;
            D.27885 = *D.27884;
            D.27886 = (int) D.27885;
            __result = D.27883 - D.27886;
            D.27887 = __s2_len > 1;
            D.27877 = __result == 0;
            D.27888 = D.27887 & D.27877;
            if (D.27888 != 0) goto <D.27889>; else goto <D.27890>;
            <D.27889>:
            D.27891 = &MEM[(void *)"List`1" + 2B];
            D.27892 = *D.27891;
            D.27893 = (int) D.27892;
            D.27894 = __s2 + 2;
            D.27895 = *D.27894;
            D.27896 = (int) D.27895;
            __result = D.27893 - D.27896;
            D.27897 = __s2_len > 2;
            D.27877 = __result == 0;
            D.27898 = D.27897 & D.27877;
            if (D.27898 != 0) goto <D.27899>; else goto <D.27900>;
            <D.27899>:
            D.27901 = &MEM[(void *)"List`1" + 3B];
            D.27902 = *D.27901;
            D.27903 = (int) D.27902;
            D.27904 = __s2 + 3;
            D.27905 = *D.27904;
            D.27906 = (int) D.27905;
            __result = D.27903 - D.27906;
            <D.27900>:
            <D.27890>:
            <D.27880>:
          }
          D.24548 = __result;
        }
        iftmp.82 = -D.24548;
        goto <D.27907>;
        <D.27870>:
        D.27866 = klass->name;
        iftmp.82 = __builtin_strcmp (D.27866, "List`1");
        <D.27907>:
        D.24549 = iftmp.82;
      }
      if (D.24549 == 0) goto <D.27809>; else goto <D.27810>;
      <D.27809>:
      use_gsharedvt = 1;
      <D.27810>:
      <D.27825>:
      <D.27822>:
      <D.27820>:
      <D.27818>:
      <D.27814>:
      iter = 0B;
      goto <D.24550>;
      <D.24551>:
      D.27811 = acfg->opts;
      D.27812 = D.27811 & 16777216;
      if (D.27812 != 0) goto <D.27908>; else goto <D.27909>;
      <D.27908>:
      D.27910 = BIT_FIELD_REF <*method, 8, 168>;
      D.27911 = D.27910 & 16;
      if (D.27911 != 0) goto <D.27912>; else goto <D.27913>;
      <D.27912>:
      D.27914 = mono_method_get_context (method);
      D.27915 = D.27914->method_inst;
      if (D.27915 != 0B) goto <D.27916>; else goto <D.27917>;
      <D.27916>:
      // predicted unlikely by continue predictor.
      goto <D.24550>;
      <D.27917>:
      <D.27913>:
      <D.27909>:
      D.27918 = mono_method_is_generic_sharable_full (method, 0, 0, use_gsharedvt);
      if (D.27918 != 0) goto <D.27919>; else goto <D.27920>;
      <D.27919>:
      add_types_from_method_header (acfg, method);
      // predicted unlikely by continue predictor.
      goto <D.24550>;
      <D.27920>:
      D.27910 = BIT_FIELD_REF <*method, 8, 168>;
      D.27921 = D.27910 & 8;
      if (D.27921 != 0) goto <D.27922>; else goto <D.27923>;
      <D.27922>:
      // predicted unlikely by continue predictor.
      goto <D.24550>;
      <D.27923>:
      D.27924 = depth + 1;
      add_extra_method_with_depth (acfg, method, D.27924);
      <D.24550>:
      method = mono_class_get_methods (klass, &iter);
      if (method != 0B) goto <D.24551>; else goto <D.24552>;
      <D.24552>:
      iter = 0B;
      goto <D.24554>;
      <D.24553>:
      D.27925 = field->type;
      D.27926 = D.27925->type;
      if (D.27926 == 21) goto <D.27927>; else goto <D.27928>;
      <D.27927>:
      D.27924 = depth + 1;
      D.27925 = field->type;
      D.27929 = mono_class_from_mono_type (D.27925);
      add_generic_class_with_depth (acfg, D.27929, D.27924, "field");
      <D.27928>:
      <D.24554>:
      field = mono_class_get_fields (klass, &iter);
      if (field != 0B) goto <D.24553>; else goto <D.24555>;
      <D.24555>:
      D.27930 = BIT_FIELD_REF <*klass, 8, 184>;
      D.27931 = D.27930 & 1;
      if (D.27931 != 0) goto <D.27932>; else goto <D.27933>;
      <D.27932>:
      method = mono_get_delegate_invoke (klass);
      method = mono_marshal_get_delegate_invoke (method, 0B);
      D.27805 = acfg->aot_opts.log_generics;
      if (D.27805 != 0) goto <D.27934>; else goto <D.27935>;
      <D.27934>:
      D.27936 = mono_method_full_name (method, 1);
      printf ("%*sAdding method %s.\n", depth, "", D.27936);
      <D.27935>:
      add_method (acfg, method);
      <D.27933>:
      D.27937 = klass->parent;
      if (D.27937 != 0B) goto <D.27938>; else goto <D.27939>;
      <D.27938>:
      D.27937 = klass->parent;
      add_generic_class_with_depth (acfg, D.27937, depth, "parent");
      <D.27939>:
      D.27815 = klass->image;
      D.27816 = mono_defaults.corlib;
      if (D.27815 == D.27816) goto <D.27942>; else goto <D.27943>;
      <D.27942>:
      {
        size_t __s1_len;
        size_t __s2_len;

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

          __s2 = klass->name_space;
          D.27947 = "System.Collections.Generic";
          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 *)"System.Collections.Generic" + 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 *)"System.Collections.Generic" + 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 *)"System.Collections.Generic" + 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.24563 = __result;
        }
        iftmp.83 = -D.24563;
        goto <D.27983>;
        <D.27946>:
        D.27984 = klass->name_space;
        iftmp.83 = __builtin_strcmp (D.27984, "System.Collections.Generic");
        <D.27983>:
        D.24564 = iftmp.83;
      }
      if (D.24564 == 0) goto <D.27985>; else goto <D.27986>;
      <D.27985>:
      {
        size_t __s1_len;
        size_t __s2_len;

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

          __s2 = klass->name;
          D.27990 = "ICollection`1";
          D.27991 = MEM[(const unsigned char *)D.27990];
          D.27992 = (int) D.27991;
          D.27993 = *__s2;
          D.27994 = (int) D.27993;
          __result = D.27992 - D.27994;
          {
            D.27995 = __s2_len != 0;
            D.27996 = __result == 0;
            D.27997 = D.27995 & D.27996;
            if (D.27997 != 0) goto <D.27998>; else goto <D.27999>;
            <D.27998>:
            D.28000 = &MEM[(void *)"ICollection`1" + 1B];
            D.28001 = *D.28000;
            D.28002 = (int) D.28001;
            D.28003 = __s2 + 1;
            D.28004 = *D.28003;
            D.28005 = (int) D.28004;
            __result = D.28002 - D.28005;
            D.28006 = __s2_len > 1;
            D.27996 = __result == 0;
            D.28007 = D.28006 & D.27996;
            if (D.28007 != 0) goto <D.28008>; else goto <D.28009>;
            <D.28008>:
            D.28010 = &MEM[(void *)"ICollection`1" + 2B];
            D.28011 = *D.28010;
            D.28012 = (int) D.28011;
            D.28013 = __s2 + 2;
            D.28014 = *D.28013;
            D.28015 = (int) D.28014;
            __result = D.28012 - D.28015;
            D.28016 = __s2_len > 2;
            D.27996 = __result == 0;
            D.28017 = D.28016 & D.27996;
            if (D.28017 != 0) goto <D.28018>; else goto <D.28019>;
            <D.28018>:
            D.28020 = &MEM[(void *)"ICollection`1" + 3B];
            D.28021 = *D.28020;
            D.28022 = (int) D.28021;
            D.28023 = __s2 + 3;
            D.28024 = *D.28023;
            D.28025 = (int) D.28024;
            __result = D.28022 - D.28025;
            <D.28019>:
            <D.28009>:
            <D.27999>:
          }
          D.24572 = __result;
        }
        iftmp.84 = -D.24572;
        goto <D.28026>;
        <D.27989>:
        D.27866 = klass->name;
        iftmp.84 = __builtin_strcmp (D.27866, "ICollection`1");
        <D.28026>:
        D.24573 = iftmp.84;
      }
      if (D.24573 == 0) goto <D.27940>; else goto <D.28027>;
      <D.28027>:
      {
        size_t __s1_len;
        size_t __s2_len;

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

          __s2 = klass->name;
          D.28031 = "IEnumerable`1";
          D.28032 = MEM[(const unsigned char *)D.28031];
          D.28033 = (int) D.28032;
          D.28034 = *__s2;
          D.28035 = (int) D.28034;
          __result = D.28033 - D.28035;
          {
            D.28036 = __s2_len != 0;
            D.28037 = __result == 0;
            D.28038 = D.28036 & D.28037;
            if (D.28038 != 0) goto <D.28039>; else goto <D.28040>;
            <D.28039>:
            D.28041 = &MEM[(void *)"IEnumerable`1" + 1B];
            D.28042 = *D.28041;
            D.28043 = (int) D.28042;
            D.28044 = __s2 + 1;
            D.28045 = *D.28044;
            D.28046 = (int) D.28045;
            __result = D.28043 - D.28046;
            D.28047 = __s2_len > 1;
            D.28037 = __result == 0;
            D.28048 = D.28047 & D.28037;
            if (D.28048 != 0) goto <D.28049>; else goto <D.28050>;
            <D.28049>:
            D.28051 = &MEM[(void *)"IEnumerable`1" + 2B];
            D.28052 = *D.28051;
            D.28053 = (int) D.28052;
            D.28054 = __s2 + 2;
            D.28055 = *D.28054;
            D.28056 = (int) D.28055;
            __result = D.28053 - D.28056;
            D.28057 = __s2_len > 2;
            D.28037 = __result == 0;
            D.28058 = D.28057 & D.28037;
            if (D.28058 != 0) goto <D.28059>; else goto <D.28060>;
            <D.28059>:
            D.28061 = &MEM[(void *)"IEnumerable`1" + 3B];
            D.28062 = *D.28061;
            D.28063 = (int) D.28062;
            D.28064 = __s2 + 3;
            D.28065 = *D.28064;
            D.28066 = (int) D.28065;
            __result = D.28063 - D.28066;
            <D.28060>:
            <D.28050>:
            <D.28040>:
          }
          D.24581 = __result;
        }
        iftmp.85 = -D.24581;
        goto <D.28067>;
        <D.28030>:
        D.27866 = klass->name;
        iftmp.85 = __builtin_strcmp (D.27866, "IEnumerable`1");
        <D.28067>:
        D.24582 = iftmp.85;
      }
      if (D.24582 == 0) goto <D.27940>; else goto <D.28068>;
      <D.28068>:
      {
        size_t __s1_len;
        size_t __s2_len;

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

          __s2 = klass->name;
          D.28072 = "IList`1";
          D.28073 = MEM[(const unsigned char *)D.28072];
          D.28074 = (int) D.28073;
          D.28075 = *__s2;
          D.28076 = (int) D.28075;
          __result = D.28074 - D.28076;
          {
            D.28077 = __s2_len != 0;
            D.28078 = __result == 0;
            D.28079 = D.28077 & D.28078;
            if (D.28079 != 0) goto <D.28080>; else goto <D.28081>;
            <D.28080>:
            D.28082 = &MEM[(void *)"IList`1" + 1B];
            D.28083 = *D.28082;
            D.28084 = (int) D.28083;
            D.28085 = __s2 + 1;
            D.28086 = *D.28085;
            D.28087 = (int) D.28086;
            __result = D.28084 - D.28087;
            D.28088 = __s2_len > 1;
            D.28078 = __result == 0;
            D.28089 = D.28088 & D.28078;
            if (D.28089 != 0) goto <D.28090>; else goto <D.28091>;
            <D.28090>:
            D.28092 = &MEM[(void *)"IList`1" + 2B];
            D.28093 = *D.28092;
            D.28094 = (int) D.28093;
            D.28095 = __s2 + 2;
            D.28096 = *D.28095;
            D.28097 = (int) D.28096;
            __result = D.28094 - D.28097;
            D.28098 = __s2_len > 2;
            D.28078 = __result == 0;
            D.28099 = D.28098 & D.28078;
            if (D.28099 != 0) goto <D.28100>; else goto <D.28101>;
            <D.28100>:
            D.28102 = &MEM[(void *)"IList`1" + 3B];
            D.28103 = *D.28102;
            D.28104 = (int) D.28103;
            D.28105 = __s2 + 3;
            D.28106 = *D.28105;
            D.28107 = (int) D.28106;
            __result = D.28104 - D.28107;
            <D.28101>:
            <D.28091>:
            <D.28081>:
          }
          D.24590 = __result;
        }
        iftmp.86 = -D.24590;
        goto <D.28108>;
        <D.28071>:
        D.27866 = klass->name;
        iftmp.86 = __builtin_strcmp (D.27866, "IList`1");
        <D.28108>:
        D.24591 = iftmp.86;
      }
      if (D.24591 == 0) goto <D.27940>; else goto <D.28109>;
      <D.28109>:
      {
        size_t __s1_len;
        size_t __s2_len;

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

          __s2 = klass->name;
          D.28113 = "IEnumerator`1";
          D.28114 = MEM[(const unsigned char *)D.28113];
          D.28115 = (int) D.28114;
          D.28116 = *__s2;
          D.28117 = (int) D.28116;
          __result = D.28115 - D.28117;
          {
            D.28118 = __s2_len != 0;
            D.28119 = __result == 0;
            D.28120 = D.28118 & D.28119;
            if (D.28120 != 0) goto <D.28121>; else goto <D.28122>;
            <D.28121>:
            D.28123 = &MEM[(void *)"IEnumerator`1" + 1B];
            D.28124 = *D.28123;
            D.28125 = (int) D.28124;
            D.28126 = __s2 + 1;
            D.28127 = *D.28126;
            D.28128 = (int) D.28127;
            __result = D.28125 - D.28128;
            D.28129 = __s2_len > 1;
            D.28119 = __result == 0;
            D.28130 = D.28129 & D.28119;
            if (D.28130 != 0) goto <D.28131>; else goto <D.28132>;
            <D.28131>:
            D.28133 = &MEM[(void *)"IEnumerator`1" + 2B];
            D.28134 = *D.28133;
            D.28135 = (int) D.28134;
            D.28136 = __s2 + 2;
            D.28137 = *D.28136;
            D.28138 = (int) D.28137;
            __result = D.28135 - D.28138;
            D.28139 = __s2_len > 2;
            D.28119 = __result == 0;
            D.28140 = D.28139 & D.28119;
            if (D.28140 != 0) goto <D.28141>; else goto <D.28142>;
            <D.28141>:
            D.28143 = &MEM[(void *)"IEnumerator`1" + 3B];
            D.28144 = *D.28143;
            D.28145 = (int) D.28144;
            D.28146 = __s2 + 3;
            D.28147 = *D.28146;
            D.28148 = (int) D.28147;
            __result = D.28145 - D.28148;
            <D.28142>:
            <D.28132>:
            <D.28122>:
          }
          D.24599 = __result;
        }
        iftmp.87 = -D.24599;
        goto <D.28149>;
        <D.28112>:
        D.27866 = klass->name;
        iftmp.87 = __builtin_strcmp (D.27866, "IEnumerator`1");
        <D.28149>:
        D.24600 = iftmp.87;
      }
      if (D.24600 == 0) goto <D.27940>; else goto <D.28150>;
      <D.28150>:
      {
        size_t __s1_len;
        size_t __s2_len;

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

          __s2 = klass->name;
          D.28154 = "IReadOnlyList`1";
          D.28155 = MEM[(const unsigned char *)D.28154];
          D.28156 = (int) D.28155;
          D.28157 = *__s2;
          D.28158 = (int) D.28157;
          __result = D.28156 - D.28158;
          {
            D.28159 = __s2_len != 0;
            D.28160 = __result == 0;
            D.28161 = D.28159 & D.28160;
            if (D.28161 != 0) goto <D.28162>; else goto <D.28163>;
            <D.28162>:
            D.28164 = &MEM[(void *)"IReadOnlyList`1" + 1B];
            D.28165 = *D.28164;
            D.28166 = (int) D.28165;
            D.28167 = __s2 + 1;
            D.28168 = *D.28167;
            D.28169 = (int) D.28168;
            __result = D.28166 - D.28169;
            D.28170 = __s2_len > 1;
            D.28160 = __result == 0;
            D.28171 = D.28170 & D.28160;
            if (D.28171 != 0) goto <D.28172>; else goto <D.28173>;
            <D.28172>:
            D.28174 = &MEM[(void *)"IReadOnlyList`1" + 2B];
            D.28175 = *D.28174;
            D.28176 = (int) D.28175;
            D.28177 = __s2 + 2;
            D.28178 = *D.28177;
            D.28179 = (int) D.28178;
            __result = D.28176 - D.28179;
            D.28180 = __s2_len > 2;
            D.28160 = __result == 0;
            D.28181 = D.28180 & D.28160;
            if (D.28181 != 0) goto <D.28182>; else goto <D.28183>;
            <D.28182>:
            D.28184 = &MEM[(void *)"IReadOnlyList`1" + 3B];
            D.28185 = *D.28184;
            D.28186 = (int) D.28185;
            D.28187 = __s2 + 3;
            D.28188 = *D.28187;
            D.28189 = (int) D.28188;
            __result = D.28186 - D.28189;
            <D.28183>:
            <D.28173>:
            <D.28163>:
          }
          D.24608 = __result;
        }
        iftmp.88 = -D.24608;
        goto <D.28190>;
        <D.28153>:
        D.27866 = klass->name;
        iftmp.88 = __builtin_strcmp (D.27866, "IReadOnlyList`1");
        <D.28190>:
        D.24609 = iftmp.88;
      }
      if (D.24609 == 0) goto <D.27940>; else goto <D.27941>;
      <D.27940>:
      {
        struct MonoClass * tclass;
        struct MonoClass * array_class;
        void * iter;
        char * name_prefix;

        try
          {
            D.27776 = klass->generic_class;
            D.27779 = D.27776->context.class_inst;
            D.28191 = D.27779->type_argv[0];
            tclass = mono_class_from_mono_type (D.28191);
            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.28193>; else goto <D.28194>;
              <D.28193>:
              {
                const unsigned char * __s2;
                int __result;

                __s2 = klass->name;
                D.28113 = "IEnumerator`1";
                D.28114 = MEM[(const unsigned char *)D.28113];
                D.28115 = (int) D.28114;
                D.28195 = *__s2;
                D.28196 = (int) D.28195;
                __result = D.28115 - D.28196;
                {
                  D.28197 = __s2_len != 0;
                  D.28198 = __result == 0;
                  D.28199 = D.28197 & D.28198;
                  if (D.28199 != 0) goto <D.28200>; else goto <D.28201>;
                  <D.28200>:
                  D.28123 = &MEM[(void *)"IEnumerator`1" + 1B];
                  D.28124 = *D.28123;
                  D.28125 = (int) D.28124;
                  D.28202 = __s2 + 1;
                  D.28203 = *D.28202;
                  D.28204 = (int) D.28203;
                  __result = D.28125 - D.28204;
                  D.28205 = __s2_len > 1;
                  D.28198 = __result == 0;
                  D.28206 = D.28205 & D.28198;
                  if (D.28206 != 0) goto <D.28207>; else goto <D.28208>;
                  <D.28207>:
                  D.28133 = &MEM[(void *)"IEnumerator`1" + 2B];
                  D.28134 = *D.28133;
                  D.28135 = (int) D.28134;
                  D.28209 = __s2 + 2;
                  D.28210 = *D.28209;
                  D.28211 = (int) D.28210;
                  __result = D.28135 - D.28211;
                  D.28212 = __s2_len > 2;
                  D.28198 = __result == 0;
                  D.28213 = D.28212 & D.28198;
                  if (D.28213 != 0) goto <D.28214>; else goto <D.28215>;
                  <D.28214>:
                  D.28143 = &MEM[(void *)"IEnumerator`1" + 3B];
                  D.28144 = *D.28143;
                  D.28145 = (int) D.28144;
                  D.28216 = __s2 + 3;
                  D.28217 = *D.28216;
                  D.28218 = (int) D.28217;
                  __result = D.28145 - D.28218;
                  <D.28215>:
                  <D.28208>:
                  <D.28201>:
                }
                D.24621 = __result;
              }
              iftmp.89 = -D.24621;
              goto <D.28219>;
              <D.28194>:
              D.27866 = klass->name;
              iftmp.89 = __builtin_strcmp (D.27866, "IEnumerator`1");
              <D.28219>:
              D.24622 = iftmp.89;
            }
            if (D.24622 == 0) goto <D.28220>; else goto <D.28221>;
            <D.28220>:
            D.27984 = klass->name_space;
            name_prefix = monoeg_g_strdup_printf ("%s.%s", D.27984, "IEnumerable`1");
            goto <D.28222>;
            <D.28221>:
            D.27866 = klass->name;
            D.27984 = klass->name_space;
            name_prefix = monoeg_g_strdup_printf ("%s.%s", D.27984, D.27866);
            <D.28222>:
            {
              size_t __s1_len;
              size_t __s2_len;

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

                __s2 = klass->name;
                D.28031 = "IEnumerable`1";
                D.28032 = MEM[(const unsigned char *)D.28031];
                D.28033 = (int) D.28032;
                D.28228 = *__s2;
                D.28229 = (int) D.28228;
                __result = D.28033 - D.28229;
                {
                  D.28230 = __s2_len != 0;
                  D.28231 = __result == 0;
                  D.28232 = D.28230 & D.28231;
                  if (D.28232 != 0) goto <D.28233>; else goto <D.28234>;
                  <D.28233>:
                  D.28041 = &MEM[(void *)"IEnumerable`1" + 1B];
                  D.28042 = *D.28041;
                  D.28043 = (int) D.28042;
                  D.28235 = __s2 + 1;
                  D.28236 = *D.28235;
                  D.28237 = (int) D.28236;
                  __result = D.28043 - D.28237;
                  D.28238 = __s2_len > 1;
                  D.28231 = __result == 0;
                  D.28239 = D.28238 & D.28231;
                  if (D.28239 != 0) goto <D.28240>; else goto <D.28241>;
                  <D.28240>:
                  D.28051 = &MEM[(void *)"IEnumerable`1" + 2B];
                  D.28052 = *D.28051;
                  D.28053 = (int) D.28052;
                  D.28242 = __s2 + 2;
                  D.28243 = *D.28242;
                  D.28244 = (int) D.28243;
                  __result = D.28053 - D.28244;
                  D.28245 = __s2_len > 2;
                  D.28231 = __result == 0;
                  D.28246 = D.28245 & D.28231;
                  if (D.28246 != 0) goto <D.28247>; else goto <D.28248>;
                  <D.28247>:
                  D.28061 = &MEM[(void *)"IEnumerable`1" + 3B];
                  D.28062 = *D.28061;
                  D.28063 = (int) D.28062;
                  D.28249 = __s2 + 3;
                  D.28250 = *D.28249;
                  D.28251 = (int) D.28250;
                  __result = D.28063 - D.28251;
                  <D.28248>:
                  <D.28241>:
                  <D.28234>:
                }
                D.24630 = __result;
              }
              iftmp.90 = -D.24630;
              goto <D.28252>;
              <D.28227>:
              D.27866 = klass->name;
              iftmp.90 = __builtin_strcmp (D.27866, "IEnumerable`1");
              <D.28252>:
              D.24631 = iftmp.90;
            }
            if (D.24631 == 0) goto <D.28223>; else goto <D.28253>;
            <D.28253>:
            {
              size_t __s1_len;
              size_t __s2_len;

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

                __s2 = klass->name;
                D.28113 = "IEnumerator`1";
                D.28114 = MEM[(const unsigned char *)D.28113];
                D.28115 = (int) D.28114;
                D.28257 = *__s2;
                D.28258 = (int) D.28257;
                __result = D.28115 - D.28258;
                {
                  D.28259 = __s2_len != 0;
                  D.28260 = __result == 0;
                  D.28261 = D.28259 & D.28260;
                  if (D.28261 != 0) goto <D.28262>; else goto <D.28263>;
                  <D.28262>:
                  D.28123 = &MEM[(void *)"IEnumerator`1" + 1B];
                  D.28124 = *D.28123;
                  D.28125 = (int) D.28124;
                  D.28264 = __s2 + 1;
                  D.28265 = *D.28264;
                  D.28266 = (int) D.28265;
                  __result = D.28125 - D.28266;
                  D.28267 = __s2_len > 1;
                  D.28260 = __result == 0;
                  D.28268 = D.28267 & D.28260;
                  if (D.28268 != 0) goto <D.28269>; else goto <D.28270>;
                  <D.28269>:
                  D.28133 = &MEM[(void *)"IEnumerator`1" + 2B];
                  D.28134 = *D.28133;
                  D.28135 = (int) D.28134;
                  D.28271 = __s2 + 2;
                  D.28272 = *D.28271;
                  D.28273 = (int) D.28272;
                  __result = D.28135 - D.28273;
                  D.28274 = __s2_len > 2;
                  D.28260 = __result == 0;
                  D.28275 = D.28274 & D.28260;
                  if (D.28275 != 0) goto <D.28276>; else goto <D.28277>;
                  <D.28276>:
                  D.28143 = &MEM[(void *)"IEnumerator`1" + 3B];
                  D.28144 = *D.28143;
                  D.28145 = (int) D.28144;
                  D.28278 = __s2 + 3;
                  D.28279 = *D.28278;
                  D.28280 = (int) D.28279;
                  __result = D.28145 - D.28280;
                  <D.28277>:
                  <D.28270>:
                  <D.28263>:
                }
                D.24639 = __result;
              }
              iftmp.91 = -D.24639;
              goto <D.28281>;
              <D.28256>:
              D.27866 = klass->name;
              iftmp.91 = __builtin_strcmp (D.27866, "IEnumerator`1");
              <D.28281>:
              D.24640 = iftmp.91;
            }
            if (D.24640 == 0) goto <D.28223>; else goto <D.28224>;
            <D.28223>:
            {
              struct MonoClass * nclass;

              iter = 0B;
              goto <D.24653>;
              <D.24652>:
              {
                size_t __s1_len;
                size_t __s2_len;

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

                  __s2 = nclass->name;
                  D.28285 = "InternalEnumerator`1";
                  D.28286 = MEM[(const unsigned char *)D.28285];
                  D.28287 = (int) D.28286;
                  D.28288 = *__s2;
                  D.28289 = (int) D.28288;
                  __result = D.28287 - D.28289;
                  {
                    D.28290 = __s2_len != 0;
                    D.28291 = __result == 0;
                    D.28292 = D.28290 & D.28291;
                    if (D.28292 != 0) goto <D.28293>; else goto <D.28294>;
                    <D.28293>:
                    D.28295 = &MEM[(void *)"InternalEnumerator`1" + 1B];
                    D.28296 = *D.28295;
                    D.28297 = (int) D.28296;
                    D.28298 = __s2 + 1;
                    D.28299 = *D.28298;
                    D.28300 = (int) D.28299;
                    __result = D.28297 - D.28300;
                    D.28301 = __s2_len > 1;
                    D.28291 = __result == 0;
                    D.28302 = D.28301 & D.28291;
                    if (D.28302 != 0) goto <D.28303>; else goto <D.28304>;
                    <D.28303>:
                    D.28305 = &MEM[(void *)"InternalEnumerator`1" + 2B];
                    D.28306 = *D.28305;
                    D.28307 = (int) D.28306;
                    D.28308 = __s2 + 2;
                    D.28309 = *D.28308;
                    D.28310 = (int) D.28309;
                    __result = D.28307 - D.28310;
                    D.28311 = __s2_len > 2;
                    D.28291 = __result == 0;
                    D.28312 = D.28311 & D.28291;
                    if (D.28312 != 0) goto <D.28313>; else goto <D.28314>;
                    <D.28313>:
                    D.28315 = &MEM[(void *)"InternalEnumerator`1" + 3B];
                    D.28316 = *D.28315;
                    D.28317 = (int) D.28316;
                    D.28318 = __s2 + 3;
                    D.28319 = *D.28318;
                    D.28320 = (int) D.28319;
                    __result = D.28317 - D.28320;
                    <D.28314>:
                    <D.28304>:
                    <D.28294>:
                  }
                  D.24649 = __result;
                }
                iftmp.92 = -D.24649;
                goto <D.28321>;
                <D.28284>:
                D.28322 = nclass->name;
                iftmp.92 = __builtin_strcmp (D.28322, "InternalEnumerator`1");
                <D.28321>:
                D.24650 = iftmp.92;
              }
              if (D.24650 == 0) goto <D.24651>; else goto <D.28323>;
              <D.28323>:
              <D.24653>:
              D.28324 = array_class->parent;
              nclass = mono_class_get_nested_types (D.28324, &iter);
              if (nclass != 0B) goto <D.24652>; else goto <D.24651>;
              <D.24651>:
              D.28325 = nclass == 0B;
              D.28326 = (long int) D.28325;
              D.28327 = __builtin_expect (D.28326, 0);
              if (D.28327 != 0) goto <D.28328>; else goto <D.28329>;
              <D.28328>:
              monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "aot-compiler.c", 3948, "nclass");
              <D.28329>:
              D.27776 = klass->generic_class;
              D.28330 = mono_generic_class_get_context (D.27776);
              nclass = mono_class_inflate_generic_class (nclass, D.28330);
              add_generic_class (acfg, nclass, 0, "ICollection<T>");
            }
            <D.28224>:
            iter = 0B;
            goto <D.24656>;
            <D.24655>:
            D.28331 = method->name;
            D.28332 = strstr (D.28331, name_prefix);
            if (D.28332 != 0B) goto <D.28333>; else goto <D.28334>;
            <D.28333>:
            {
              struct MonoMethod * m;

              m = mono_aot_get_array_helper_from_wrapper (method);
              add_extra_method_with_depth (acfg, m, depth);
            }
            <D.28334>:
            <D.24656>:
            method = mono_class_get_methods (array_class, &iter);
            if (method != 0B) goto <D.24655>; else goto <D.24657>;
            <D.24657>:
            monoeg_g_free (name_prefix);
          }
        finally
          {
            iter = {CLOBBER};
          }
      }
      <D.27941>:
      <D.27986>:
      <D.27943>:
      D.27815 = klass->image;
      D.27816 = mono_defaults.corlib;
      if (D.27815 == D.27816) goto <D.28335>; else goto <D.28336>;
      <D.28335>:
      {
        size_t __s1_len;
        size_t __s2_len;

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

          __s2 = klass->name_space;
          D.27947 = "System.Collections.Generic";
          D.27948 = MEM[(const unsigned char *)D.27947];
          D.27949 = (int) D.27948;
          D.28340 = *__s2;
          D.28341 = (int) D.28340;
          __result = D.27949 - D.28341;
          {
            D.28342 = __s2_len != 0;
            D.28343 = __result == 0;
            D.28344 = D.28342 & D.28343;
            if (D.28344 != 0) goto <D.28345>; else goto <D.28346>;
            <D.28345>:
            D.27957 = &MEM[(void *)"System.Collections.Generic" + 1B];
            D.27958 = *D.27957;
            D.27959 = (int) D.27958;
            D.28347 = __s2 + 1;
            D.28348 = *D.28347;
            D.28349 = (int) D.28348;
            __result = D.27959 - D.28349;
            D.28350 = __s2_len > 1;
            D.28343 = __result == 0;
            D.28351 = D.28350 & D.28343;
            if (D.28351 != 0) goto <D.28352>; else goto <D.28353>;
            <D.28352>:
            D.27967 = &MEM[(void *)"System.Collections.Generic" + 2B];
            D.27968 = *D.27967;
            D.27969 = (int) D.27968;
            D.28354 = __s2 + 2;
            D.28355 = *D.28354;
            D.28356 = (int) D.28355;
            __result = D.27969 - D.28356;
            D.28357 = __s2_len > 2;
            D.28343 = __result == 0;
            D.28358 = D.28357 & D.28343;
            if (D.28358 != 0) goto <D.28359>; else goto <D.28360>;
            <D.28359>:
            D.27977 = &MEM[(void *)"System.Collections.Generic" + 3B];
            D.27978 = *D.27977;
            D.27979 = (int) D.27978;
            D.28361 = __s2 + 3;
            D.28362 = *D.28361;
            D.28363 = (int) D.28362;
            __result = D.27979 - D.28363;
            <D.28360>:
            <D.28353>:
            <D.28346>:
          }
          D.24665 = __result;
        }
        iftmp.93 = -D.24665;
        goto <D.28364>;
        <D.28339>:
        D.27984 = klass->name_space;
        iftmp.93 = __builtin_strcmp (D.27984, "System.Collections.Generic");
        <D.28364>:
        D.24666 = iftmp.93;
      }
      if (D.24666 == 0) goto <D.28365>; else goto <D.28366>;
      <D.28365>:
      {
        size_t __s1_len;
        size_t __s2_len;

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

          __s2 = klass->name;
          D.28370 = "Comparer`1";
          D.28371 = MEM[(const unsigned char *)D.28370];
          D.28372 = (int) D.28371;
          D.28373 = *__s2;
          D.28374 = (int) D.28373;
          __result = D.28372 - D.28374;
          {
            D.28375 = __s2_len != 0;
            D.28376 = __result == 0;
            D.28377 = D.28375 & D.28376;
            if (D.28377 != 0) goto <D.28378>; else goto <D.28379>;
            <D.28378>:
            D.28380 = &MEM[(void *)"Comparer`1" + 1B];
            D.28381 = *D.28380;
            D.28382 = (int) D.28381;
            D.28383 = __s2 + 1;
            D.28384 = *D.28383;
            D.28385 = (int) D.28384;
            __result = D.28382 - D.28385;
            D.28386 = __s2_len > 1;
            D.28376 = __result == 0;
            D.28387 = D.28386 & D.28376;
            if (D.28387 != 0) goto <D.28388>; else goto <D.28389>;
            <D.28388>:
            D.28390 = &MEM[(void *)"Comparer`1" + 2B];
            D.28391 = *D.28390;
            D.28392 = (int) D.28391;
            D.28393 = __s2 + 2;
            D.28394 = *D.28393;
            D.28395 = (int) D.28394;
            __result = D.28392 - D.28395;
            D.28396 = __s2_len > 2;
            D.28376 = __result == 0;
            D.28397 = D.28396 & D.28376;
            if (D.28397 != 0) goto <D.28398>; else goto <D.28399>;
            <D.28398>:
            D.28400 = &MEM[(void *)"Comparer`1" + 3B];
            D.28401 = *D.28400;
            D.28402 = (int) D.28401;
            D.28403 = __s2 + 3;
            D.28404 = *D.28403;
            D.28405 = (int) D.28404;
            __result = D.28402 - D.28405;
            <D.28399>:
            <D.28389>:
            <D.28379>:
          }
          D.24674 = __result;
        }
        iftmp.94 = -D.24674;
        goto <D.28406>;
        <D.28369>:
        D.27866 = klass->name;
        iftmp.94 = __builtin_strcmp (D.27866, "Comparer`1");
        <D.28406>:
        D.24675 = iftmp.94;
      }
      if (D.24675 == 0) goto <D.28407>; else goto <D.28408>;
      <D.28407>:
      {
        struct MonoClass * tclass;
        struct MonoClass * icomparable;
        struct MonoClass * gcomparer;
        struct MonoGenericContext ctx;
        struct MonoType * args[16];

        try
          {
            D.27776 = klass->generic_class;
            D.27779 = D.27776->context.class_inst;
            D.28191 = D.27779->type_argv[0];
            tclass = mono_class_from_mono_type (D.28191);
            memset (&ctx, 0, 8);
            D.27816 = mono_defaults.corlib;
            icomparable = mono_class_from_name (D.27816, "System", "IComparable`1");
            D.28409 = icomparable == 0B;
            D.28410 = (long int) D.28409;
            D.28411 = __builtin_expect (D.28410, 0);
            if (D.28411 != 0) goto <D.28412>; else goto <D.28413>;
            <D.28412>:
            monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "aot-compiler.c", 3975, "icomparable");
            <D.28413>:
            D.28414 = &tclass->byval_arg;
            args[0] = D.28414;
            D.28415 = mono_metadata_get_generic_inst (1, &args);
            ctx.class_inst = D.28415;
            D.28416 = mono_class_inflate_generic_class (icomparable, &ctx);
            D.28417 = mono_class_is_assignable_from (D.28416, tclass);
            if (D.28417 != 0) goto <D.28418>; else goto <D.28419>;
            <D.28418>:
            D.27816 = mono_defaults.corlib;
            gcomparer = mono_class_from_name (D.27816, "System.Collections.Generic", "GenericComparer`1");
            D.28420 = gcomparer == 0B;
            D.28421 = (long int) D.28420;
            D.28422 = __builtin_expect (D.28421, 0);
            if (D.28422 != 0) goto <D.28423>; else goto <D.28424>;
            <D.28423>:
            monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "aot-compiler.c", 3981, "gcomparer");
            <D.28424>:
            D.28425 = mono_class_inflate_generic_class (gcomparer, &ctx);
            add_generic_class (acfg, D.28425, 0, "Comparer<T>");
            <D.28419>:
          }
        finally
          {
            ctx = {CLOBBER};
            args = {CLOBBER};
          }
      }
      <D.28408>:
      <D.28366>:
      <D.28336>:
      D.27815 = klass->image;
      D.27816 = mono_defaults.corlib;
      if (D.27815 == D.27816) goto <D.28426>; else goto <D.28427>;
      <D.28426>:
      {
        size_t __s1_len;
        size_t __s2_len;

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

          __s2 = klass->name_space;
          D.27947 = "System.Collections.Generic";
          D.27948 = MEM[(const unsigned char *)D.27947];
          D.27949 = (int) D.27948;
          D.28431 = *__s2;
          D.28432 = (int) D.28431;
          __result = D.27949 - D.28432;
          {
            D.28433 = __s2_len != 0;
            D.28434 = __result == 0;
            D.28435 = D.28433 & D.28434;
            if (D.28435 != 0) goto <D.28436>; else goto <D.28437>;
            <D.28436>:
            D.27957 = &MEM[(void *)"System.Collections.Generic" + 1B];
            D.27958 = *D.27957;
            D.27959 = (int) D.27958;
            D.28438 = __s2 + 1;
            D.28439 = *D.28438;
            D.28440 = (int) D.28439;
            __result = D.27959 - D.28440;
            D.28441 = __s2_len > 1;
            D.28434 = __result == 0;
            D.28442 = D.28441 & D.28434;
            if (D.28442 != 0) goto <D.28443>; else goto <D.28444>;
            <D.28443>:
            D.27967 = &MEM[(void *)"System.Collections.Generic" + 2B];
            D.27968 = *D.27967;
            D.27969 = (int) D.27968;
            D.28445 = __s2 + 2;
            D.28446 = *D.28445;
            D.28447 = (int) D.28446;
            __result = D.27969 - D.28447;
            D.28448 = __s2_len > 2;
            D.28434 = __result == 0;
            D.28449 = D.28448 & D.28434;
            if (D.28449 != 0) goto <D.28450>; else goto <D.28451>;
            <D.28450>:
            D.27977 = &MEM[(void *)"System.Collections.Generic" + 3B];
            D.27978 = *D.27977;
            D.27979 = (int) D.27978;
            D.28452 = __s2 + 3;
            D.28453 = *D.28452;
            D.28454 = (int) D.28453;
            __result = D.27979 - D.28454;
            <D.28451>:
            <D.28444>:
            <D.28437>:
          }
          D.24688 = __result;
        }
        iftmp.95 = -D.24688;
        goto <D.28455>;
        <D.28430>:
        D.27984 = klass->name_space;
        iftmp.95 = __builtin_strcmp (D.27984, "System.Collections.Generic");
        <D.28455>:
        D.24689 = iftmp.95;
      }
      if (D.24689 == 0) goto <D.28456>; else goto <D.28457>;
      <D.28456>:
      {
        size_t __s1_len;
        size_t __s2_len;

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

          __s2 = klass->name;
          D.28461 = "EqualityComparer`1";
          D.28462 = MEM[(const unsigned char *)D.28461];
          D.28463 = (int) D.28462;
          D.28464 = *__s2;
          D.28465 = (int) D.28464;
          __result = D.28463 - D.28465;
          {
            D.28466 = __s2_len != 0;
            D.28467 = __result == 0;
            D.28468 = D.28466 & D.28467;
            if (D.28468 != 0) goto <D.28469>; else goto <D.28470>;
            <D.28469>:
            D.28471 = &MEM[(void *)"EqualityComparer`1" + 1B];
            D.28472 = *D.28471;
            D.28473 = (int) D.28472;
            D.28474 = __s2 + 1;
            D.28475 = *D.28474;
            D.28476 = (int) D.28475;
            __result = D.28473 - D.28476;
            D.28477 = __s2_len > 1;
            D.28467 = __result == 0;
            D.28478 = D.28477 & D.28467;
            if (D.28478 != 0) goto <D.28479>; else goto <D.28480>;
            <D.28479>:
            D.28481 = &MEM[(void *)"EqualityComparer`1" + 2B];
            D.28482 = *D.28481;
            D.28483 = (int) D.28482;
            D.28484 = __s2 + 2;
            D.28485 = *D.28484;
            D.28486 = (int) D.28485;
            __result = D.28483 - D.28486;
            D.28487 = __s2_len > 2;
            D.28467 = __result == 0;
            D.28488 = D.28487 & D.28467;
            if (D.28488 != 0) goto <D.28489>; else goto <D.28490>;
            <D.28489>:
            D.28491 = &MEM[(void *)"EqualityComparer`1" + 3B];
            D.28492 = *D.28491;
            D.28493 = (int) D.28492;
            D.28494 = __s2 + 3;
            D.28495 = *D.28494;
            D.28496 = (int) D.28495;
            __result = D.28493 - D.28496;
            <D.28490>:
            <D.28480>:
            <D.28470>:
          }
          D.24697 = __result;
        }
        iftmp.96 = -D.24697;
        goto <D.28497>;
        <D.28460>:
        D.27866 = klass->name;
        iftmp.96 = __builtin_strcmp (D.27866, "EqualityComparer`1");
        <D.28497>:
        D.24698 = iftmp.96;
      }
      if (D.24698 == 0) goto <D.28498>; else goto <D.28499>;
      <D.28498>:
      {
        struct MonoClass * tclass;
        struct MonoClass * iface;
        struct MonoClass * gcomparer;
        struct MonoGenericContext ctx;
        struct MonoType * args[16];

        try
          {
            D.27776 = klass->generic_class;
            D.27779 = D.27776->context.class_inst;
            D.28191 = D.27779->type_argv[0];
            tclass = mono_class_from_mono_type (D.28191);
            memset (&ctx, 0, 8);
            D.27816 = mono_defaults.corlib;
            iface = mono_class_from_name (D.27816, "System", "IEquatable`1");
            D.28500 = iface == 0B;
            D.28501 = (long int) D.28500;
            D.28502 = __builtin_expect (D.28501, 0);
            if (D.28502 != 0) goto <D.28503>; else goto <D.28504>;
            <D.28503>:
            monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "aot-compiler.c", 3996, "iface");
            <D.28504>:
            D.28505 = &tclass->byval_arg;
            args[0] = D.28505;
            D.28506 = mono_metadata_get_generic_inst (1, &args);
            ctx.class_inst = D.28506;
            D.28507 = mono_class_inflate_generic_class (iface, &ctx);
            D.28508 = mono_class_is_assignable_from (D.28507, tclass);
            if (D.28508 != 0) goto <D.28509>; else goto <D.28510>;
            <D.28509>:
            D.27816 = mono_defaults.corlib;
            gcomparer = mono_class_from_name (D.27816, "System.Collections.Generic", "GenericEqualityComparer`1");
            D.28511 = gcomparer == 0B;
            D.28512 = (long int) D.28511;
            D.28513 = __builtin_expect (D.28512, 0);
            if (D.28513 != 0) goto <D.28514>; else goto <D.28515>;
            <D.28514>:
            monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "aot-compiler.c", 4002, "gcomparer");
            <D.28515>:
            D.28516 = mono_class_inflate_generic_class (gcomparer, &ctx);
            add_generic_class (acfg, D.28516, 0, "EqualityComparer<T>");
            <D.28510>:
          }
        finally
          {
            ctx = {CLOBBER};
            args = {CLOBBER};
          }
      }
      <D.28499>:
      <D.28457>:
      <D.28427>:
    }
  finally
    {
      iter = {CLOBBER};
    }
}


has_type_vars (struct MonoClass * klass)
{
  unsigned char D.28520;
  _Bool D.28521;
  _Bool D.28522;
  _Bool D.28523;
  gboolean D.28526;
  unsigned char D.28527;
  struct MonoClass * D.28530;
  struct MonoGenericClass * D.28531;
  struct MonoGenericInst * D.28534;
  struct MonoType * D.28537;
  struct MonoClass * D.28538;
  int D.28539;
  <unnamed-unsigned:22> D.28542;
  int D.28543;
  struct MonoGenericContainer * D.28544;

  D.28520 = klass->byval_arg.type;
  D.28521 = D.28520 == 19;
  D.28522 = D.28520 == 30;
  D.28523 = D.28521 | D.28522;
  if (D.28523 != 0) goto <D.28524>; else goto <D.28525>;
  <D.28524>:
  D.28526 = 1;
  return D.28526;
  <D.28525>:
  D.28527 = klass->rank;
  if (D.28527 != 0) goto <D.28528>; else goto <D.28529>;
  <D.28528>:
  D.28530 = klass->element_class;
  D.28526 = has_type_vars (D.28530);
  return D.28526;
  <D.28529>:
  D.28531 = klass->generic_class;
  if (D.28531 != 0B) goto <D.28532>; else goto <D.28533>;
  <D.28532>:
  {
    struct MonoGenericContext * context;

    D.28531 = klass->generic_class;
    context = &D.28531->context;
    D.28534 = context->class_inst;
    if (D.28534 != 0B) goto <D.28535>; else goto <D.28536>;
    <D.28535>:
    {
      int i;

      i = 0;
      goto <D.24477>;
      <D.24476>:
      D.28534 = context->class_inst;
      D.28537 = D.28534->type_argv[i];
      D.28538 = mono_class_from_mono_type (D.28537);
      D.28539 = has_type_vars (D.28538);
      if (D.28539 != 0) goto <D.28540>; else goto <D.28541>;
      <D.28540>:
      D.28526 = 1;
      return D.28526;
      <D.28541>:
      i = i + 1;
      <D.24477>:
      D.28534 = context->class_inst;
      D.28542 = D.28534->type_argc;
      D.28543 = (int) D.28542;
      if (D.28543 > i) goto <D.24476>; else goto <D.24478>;
      <D.24478>:
    }
    <D.28536>:
  }
  <D.28533>:
  D.28544 = klass->generic_container;
  if (D.28544 != 0B) goto <D.28545>; else goto <D.28546>;
  <D.28545>:
  D.28526 = 1;
  return D.28526;
  <D.28546>:
  D.28526 = 0;
  return D.28526;
}


check_type_depth (struct MonoType * t, int depth)
{
  gboolean D.28550;
  unsigned char D.28551;
  int D.28552;
  int D.28555;
  struct MonoType * D.28556;
  int D.28557;
  <unnamed-unsigned:22> D.28560;
  int D.28561;
  int i;

  if (depth > 8) goto <D.28548>; else goto <D.28549>;
  <D.28548>:
  D.28550 = 1;
  return D.28550;
  <D.28549>:
  D.28551 = t->type;
  D.28552 = (int) D.28551;
  switch (D.28552) <default: <D.24518>, case 21: <D.24511>>
  <D.24511>:
  {
    struct MonoGenericClass * gklass;
    struct MonoGenericInst * ginst;

    gklass = t->data.generic_class;
    ginst = gklass->context.class_inst;
    if (ginst != 0B) goto <D.28553>; else goto <D.28554>;
    <D.28553>:
    i = 0;
    goto <D.24515>;
    <D.24514>:
    D.28555 = depth + 1;
    D.28556 = ginst->type_argv[i];
    D.28557 = check_type_depth (D.28556, D.28555);
    if (D.28557 != 0) goto <D.28558>; else goto <D.28559>;
    <D.28558>:
    D.28550 = 1;
    return D.28550;
    <D.28559>:
    i = i + 1;
    <D.24515>:
    D.28560 = ginst->type_argc;
    D.28561 = (int) D.28560;
    if (D.28561 > i) goto <D.24514>; else goto <D.24516>;
    <D.24516>:
    <D.28554>:
    goto <D.24517>;
  }
  <D.24518>:
  goto <D.24517>;
  <D.24517>:
  D.28550 = 0;
  return D.28550;
}


is_vt_inst (struct MonoGenericInst * inst)
{
  unsigned char D.28564;
  gboolean D.28567;
  <unnamed-unsigned:22> D.28568;
  int D.28569;
  int i;

  i = 0;
  goto <D.24485>;
  <D.24484>:
  {
    struct MonoType * t;

    t = inst->type_argv[i];
    D.28564 = t->type;
    if (D.28564 == 17) goto <D.28565>; else goto <D.28566>;
    <D.28565>:
    D.28567 = 1;
    return D.28567;
    <D.28566>:
  }
  i = i + 1;
  <D.24485>:
  D.28568 = inst->type_argc;
  D.28569 = (int) D.28568;
  if (D.28569 > i) goto <D.24484>; else goto <D.24486>;
  <D.24486>:
  D.28567 = 0;
  return D.28567;
}


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

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


add_types_from_method_header (struct MonoAotCompile * acfg, struct MonoMethod * method)
{
  struct GHashTable * D.28573;
  void * D.28574;
  struct MonoType * D.28577;
  unsigned char D.28578;
  int D.28581;
  struct MonoClass * D.28582;
  short unsigned int D.28583;
  int D.28584;
  struct MonoType * D.28587;
  unsigned char D.28588;
  struct MonoClass * D.28591;
  short unsigned int D.28592;
  int D.28593;
  struct MonoMethodHeader * header;
  struct MonoMethodSignature * sig;
  int j;
  int depth;

  D.28573 = acfg->method_depth;
  D.28574 = monoeg_g_hash_table_lookup (D.28573, method);
  depth = (int) D.28574;
  sig = mono_method_signature (method);
  if (sig != 0B) goto <D.28575>; else goto <D.28576>;
  <D.28575>:
  j = 0;
  goto <D.24726>;
  <D.24725>:
  D.28577 = sig->params[j];
  D.28578 = D.28577->type;
  if (D.28578 == 21) goto <D.28579>; else goto <D.28580>;
  <D.28579>:
  D.28581 = depth + 1;
  D.28577 = sig->params[j];
  D.28582 = mono_class_from_mono_type (D.28577);
  add_generic_class_with_depth (acfg, D.28582, D.28581, "arg");
  <D.28580>:
  j = j + 1;
  <D.24726>:
  D.28583 = sig->param_count;
  D.28584 = (int) D.28583;
  if (D.28584 > j) goto <D.24725>; else goto <D.24727>;
  <D.24727>:
  <D.28576>:
  header = mono_method_get_header (method);
  if (header != 0B) goto <D.28585>; else goto <D.28586>;
  <D.28585>:
  j = 0;
  goto <D.24729>;
  <D.24728>:
  D.28587 = header->locals[j];
  D.28588 = D.28587->type;
  if (D.28588 == 21) goto <D.28589>; else goto <D.28590>;
  <D.28589>:
  D.28581 = depth + 1;
  D.28587 = header->locals[j];
  D.28591 = mono_class_from_mono_type (D.28587);
  add_generic_class_with_depth (acfg, D.28591, D.28581, "local");
  <D.28590>:
  j = j + 1;
  <D.24729>:
  D.28592 = header->num_locals;
  D.28593 = (int) D.28592;
  if (D.28593 > j) goto <D.24728>; else goto <D.24730>;
  <D.24730>:
  goto <D.28594>;
  <D.28586>:
  mono_loader_clear_error ();
  <D.28594>:
}


add_instances_of (struct MonoAotCompile * acfg, struct MonoClass * klass, struct MonoType * * insts, int ninsts, gboolean force)
{
  int D.28595;
  unsigned int i.97;
  unsigned int D.28599;
  struct MonoType * * D.28600;
  struct MonoType * D.28601;
  struct MonoGenericInst * D.28602;
  struct MonoClass * D.28603;
  int i;
  struct MonoGenericContext ctx;
  struct MonoType * args[16];

  try
    {
      D.28595 = acfg->aot_opts.no_instances;
      if (D.28595 != 0) goto <D.28596>; else goto <D.28597>;
      <D.28596>:
      return;
      <D.28597>:
      memset (&ctx, 0, 8);
      i = 0;
      goto <D.24715>;
      <D.24714>:
      i.97 = (unsigned int) i;
      D.28599 = i.97 * 4;
      D.28600 = insts + D.28599;
      D.28601 = *D.28600;
      args[0] = D.28601;
      D.28602 = mono_metadata_get_generic_inst (1, &args);
      ctx.class_inst = D.28602;
      D.28603 = mono_class_inflate_generic_class (klass, &ctx);
      add_generic_class (acfg, D.28603, force, "");
      i = i + 1;
      <D.24715>:
      if (i < ninsts) goto <D.24714>; else goto <D.24716>;
      <D.24716>:
    }
  finally
    {
      ctx = {CLOBBER};
      args = {CLOBBER};
    }
}


add_wrappers (struct MonoAotCompile * acfg)
{
  int D.28607;
  int D.28608;
  struct MonoImage * D.28609;
  short unsigned int D.28612;
  int D.28613;
  int D.28614;
  short unsigned int D.28616;
  int D.28617;
  int D.28618;
  int D.28620;
  struct MonoType * D.28623;
  unsigned char D.28624;
  _Bool D.28625;
  _Bool D.28626;
  _Bool D.28627;
  int D.28630;
  struct MonoType * D.28633;
  unsigned char D.28634;
  int D.28637;
  short unsigned int D.28640;
  int D.28641;
  struct MonoMethod * D.28644;
  <unnamed-unsigned:24> D.28645;
  int D.28646;
  int D.24349;
  int iftmp.98;
  int D.24348;
  struct MonoAssembly * D.28650;
  const char[9] * D.28651;
  unsigned char D.28652;
  int D.28653;
  unsigned char D.28654;
  int D.28655;
  _Bool D.28656;
  _Bool D.28657;
  _Bool D.28658;
  const unsigned char * D.28661;
  unsigned char D.28662;
  int D.28663;
  const unsigned char * D.28664;
  unsigned char D.28665;
  int D.28666;
  _Bool D.28667;
  _Bool D.28668;
  const unsigned char * D.28671;
  unsigned char D.28672;
  int D.28673;
  const unsigned char * D.28674;
  unsigned char D.28675;
  int D.28676;
  _Bool D.28677;
  _Bool D.28678;
  const unsigned char * D.28681;
  unsigned char D.28682;
  int D.28683;
  const unsigned char * D.28684;
  unsigned char D.28685;
  int D.28686;
  const char * D.28688;
  struct MonoImage * D.28691;
  struct MonoClass * D.28692;
  struct MonoType * D.28693;
  struct MonoMethod * D.28694;
  struct MonoMethod * D.28695;
  struct MonoClass * D.28696;
  struct MonoType * D.28697;
  struct MonoMethod * D.28698;
  struct MonoMethod * D.28699;
  struct MonoMethod * D.28700;
  struct MonoClass * D.28701;
  struct MonoType * D.28702;
  struct MonoMethod * D.28703;
  struct MonoClass * D.28704;
  struct MonoType * D.28705;
  struct MonoClass * D.28706;
  struct MonoType * D.28707;
  struct MonoMethod * D.28708;
  struct MonoClass * D.28709;
  struct MonoMethod * D.28710;
  struct MonoMethod * D.28711;
  struct MonoMethod * D.28714;
  struct MonoMethod * D.28715;
  int D.28716;
  unsigned int D.28719;
  struct MonoClass * D.28722;
  _Bool D.28727;
  long int D.28728;
  long int D.28729;
  unsigned int i.99;
  unsigned int D.28735;
  struct MonoMethod * * D.28736;
  struct MonoMethod * D.28737;
  int nwrappers.100;
  struct MonoMethod * D.28739;
  struct MonoMethod * D.28740;
  struct GHashTable * D.28745;
  int D.28746;
  unsigned char D.28751;
  unsigned char D.28752;
  struct MonoClass * D.28754;
  struct MonoClass * D.28756;
  struct MonoGenericContainer * D.28757;
  struct MonoMethod * D.28762;
  struct MonoMethod * D.28765;
  struct MonoMethod * D.28768;
  int D.24375;
  int iftmp.101;
  int D.24374;
  struct MonoClass * D.28774;
  const char[35] * D.28775;
  unsigned char D.28776;
  int D.28777;
  unsigned char D.28778;
  int D.28779;
  _Bool D.28780;
  _Bool D.28781;
  _Bool D.28782;
  const unsigned char * D.28785;
  unsigned char D.28786;
  int D.28787;
  const unsigned char * D.28788;
  unsigned char D.28789;
  int D.28790;
  _Bool D.28791;
  _Bool D.28792;
  const unsigned char * D.28795;
  unsigned char D.28796;
  int D.28797;
  const unsigned char * D.28798;
  unsigned char D.28799;
  int D.28800;
  _Bool D.28801;
  _Bool D.28802;
  const unsigned char * D.28805;
  unsigned char D.28806;
  int D.28807;
  const unsigned char * D.28808;
  unsigned char D.28809;
  int D.28810;
  const char * D.28812;
  int D.24384;
  int iftmp.102;
  int D.24383;
  const char[34] * D.28817;
  unsigned char D.28818;
  int D.28819;
  unsigned char D.28820;
  int D.28821;
  _Bool D.28822;
  _Bool D.28823;
  _Bool D.28824;
  const unsigned char * D.28827;
  unsigned char D.28828;
  int D.28829;
  const unsigned char * D.28830;
  unsigned char D.28831;
  int D.28832;
  _Bool D.28833;
  _Bool D.28834;
  const unsigned char * D.28837;
  unsigned char D.28838;
  int D.28839;
  const unsigned char * D.28840;
  unsigned char D.28841;
  int D.28842;
  _Bool D.28843;
  _Bool D.28844;
  const unsigned char * D.28847;
  unsigned char D.28848;
  int D.28849;
  const unsigned char * D.28850;
  unsigned char D.28851;
  int D.28852;
  int D.28855;
  struct MonoMethod * D.28858;
  unsigned int D.28860;
  unsigned int D.28861;
  unsigned char D.28866;
  unsigned char D.28867;
  _Bool D.28868;
  long int D.28869;
  long int D.28870;
  <unnamed-unsigned:24> D.28877;
  int D.28878;
  int D.28879;
  unsigned char D.28882;
  struct MonoClass * D.28885;
  unsigned char D.28886;
  unsigned char D.28887;
  unsigned char D.28890;
  unsigned char D.28891;
  _Bool D.28892;
  unsigned char D.28893;
  _Bool D.28894;
  _Bool D.28895;
  _Bool D.28898;
  long int D.28899;
  long int D.28900;
  struct MonoMethod * D.28903;
  struct MonoMethod * D.28906;
  <unnamed-unsigned:24> D.28907;
  int D.28908;
  short unsigned int D.28909;
  int D.28910;
  int D.28911;
  unsigned char D.28914;
  unsigned char D.28915;
  struct MonoClass * D.28919;
  struct MonoGenericContainer * D.28920;
  unsigned char D.28923;
  unsigned char D.28924;
  _Bool D.28925;
  long int D.28926;
  long int D.28927;
  struct MonoMethod * D.28931;
  short unsigned int D.28934;
  int D.28935;
  int D.28936;
  short unsigned int D.28938;
  int D.28939;
  int D.28940;
  struct MonoMethod * D.28941;
  struct MonoMethod * D.28944;
  int D.24425;
  int iftmp.103;
  int D.24424;
  struct MonoClass * D.28950;
  const char[29] * D.28951;
  unsigned char D.28952;
  int D.28953;
  unsigned char D.28954;
  int D.28955;
  _Bool D.28956;
  _Bool D.28957;
  _Bool D.28958;
  const unsigned char * D.28961;
  unsigned char D.28962;
  int D.28963;
  const unsigned char * D.28964;
  unsigned char D.28965;
  int D.28966;
  _Bool D.28967;
  _Bool D.28968;
  const unsigned char * D.28971;
  unsigned char D.28972;
  int D.28973;
  const unsigned char * D.28974;
  unsigned char D.28975;
  int D.28976;
  _Bool D.28977;
  _Bool D.28978;
  const unsigned char * D.28981;
  unsigned char D.28982;
  int D.28983;
  const unsigned char * D.28984;
  unsigned char D.28985;
  int D.28986;
  const char * D.28988;
  int D.28990;
  struct MonoMethod * D.28993;
  const mono_byte * p.104;
  short unsigned int D.28995;
  int D.28996;
  int D.28997;
  char * D.29000;
  short unsigned int D.29001;
  _Bool D.29002;
  long int D.29003;
  long int D.29004;
  int iftmp.105;
  struct MonoType * D.29011;
  unsigned char D.29012;
  int D.24450;
  int iftmp.106;
  int D.24449;
  struct MonoClass * D.29017;
  const char[5] * D.29018;
  unsigned char D.29019;
  int D.29020;
  unsigned char D.29021;
  int D.29022;
  _Bool D.29023;
  _Bool D.29024;
  _Bool D.29025;
  const unsigned char * D.29028;
  unsigned char D.29029;
  int D.29030;
  const unsigned char * D.29031;
  unsigned char D.29032;
  int D.29033;
  _Bool D.29034;
  _Bool D.29035;
  const unsigned char * D.29038;
  unsigned char D.29039;
  int D.29040;
  const unsigned char * D.29041;
  unsigned char D.29042;
  int D.29043;
  _Bool D.29044;
  _Bool D.29045;
  const unsigned char * D.29048;
  unsigned char D.29049;
  int D.29050;
  const unsigned char * D.29051;
  unsigned char D.29052;
  int D.29053;
  struct MonoClass * D.29055;
  const char * D.29056;
  _Bool D.29057;
  long int D.29058;
  long int D.29059;
  const char * p.107;
  const char * p.108;
  unsigned int D.29064;
  int D.29065;
  unsigned int D.29066;
  sizetype slen.109;
  char * D.29068;
  _Bool D.29069;
  long int D.29070;
  long int D.29071;
  struct MonoClass * D.29074;
  _Bool D.29075;
  long int D.29076;
  long int D.29077;
  const char * p.110;
  short unsigned int D.29081;
  _Bool D.29082;
  long int D.29083;
  long int D.29084;
  const char * named.111;
  char D.29090;
  const char * named.112;
  unsigned int D.29092;
  int D.29093;
  unsigned int D.29094;
  unsigned int name_len.113;
  sizetype name_len.114;
  char * D.29097;
  const char * named.115;
  _Bool D.29099;
  long int D.29100;
  long int D.29101;
  int D.24462;
  int iftmp.116;
  int D.24461;
  const char[13] * D.29107;
  unsigned char D.29108;
  int D.29109;
  unsigned char D.29110;
  int D.29111;
  _Bool D.29112;
  _Bool D.29113;
  _Bool D.29114;
  const unsigned char * D.29117;
  unsigned char D.29118;
  int D.29119;
  const unsigned char * D.29120;
  unsigned char D.29121;
  int D.29122;
  _Bool D.29123;
  _Bool D.29124;
  const unsigned char * D.29127;
  unsigned char D.29128;
  int D.29129;
  const unsigned char * D.29130;
  unsigned char D.29131;
  int D.29132;
  _Bool D.29133;
  _Bool D.29134;
  const unsigned char * D.29137;
  unsigned char D.29138;
  int D.29139;
  const unsigned char * D.29140;
  unsigned char D.29141;
  int D.29142;
  _Bool D.29144;
  long int D.29145;
  long int D.29146;
  _Bool D.29149;
  long int D.29150;
  long int D.29151;
  unsigned int D.29154;
  unsigned int D.29155;
  unsigned int slen.117;
  char * D.29157;
  const char * named.118;
  struct GHashTable * D.29161;
  int D.29164;
  short unsigned int D.29166;
  int D.29167;
  int D.29168;
  struct MonoMethod * D.29169;
  unsigned char D.29174;
  unsigned char D.29175;
  struct MonoGenericContainer * D.29178;
  int D.29181;
  struct MonoClass * D.29184;
  const char * D.29186;
  char * D.29187;
  struct MonoMethod * D.29188;
  struct MonoMethod * D.29189;
  struct MonoMethod * method;
  struct MonoMethod * m;
  int i;
  int j;
  struct MonoMethodSignature * sig;
  struct MonoMethodSignature * csig;
  guint32 token;

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

    D.28607 = i + 1;
    D.28608 = D.28607 | 100663296;
    token = (guint32) D.28608;
    skip = 0;
    D.28609 = acfg->image;
    method = mono_get_method (D.28609, token, 0B);
    D.28612 = method->flags;
    D.28613 = (int) D.28612;
    D.28614 = D.28613 & 8192;
    if (D.28614 != 0) goto <D.28610>; else goto <D.28615>;
    <D.28615>:
    D.28616 = method->iflags;
    D.28617 = (int) D.28616;
    D.28618 = D.28617 & 3;
    if (D.28618 != 0) goto <D.28610>; else goto <D.28619>;
    <D.28619>:
    D.28612 = method->flags;
    D.28613 = (int) D.28612;
    D.28620 = D.28613 & 1024;
    if (D.28620 != 0) goto <D.28610>; else goto <D.28611>;
    <D.28610>:
    skip = 1;
    <D.28611>:
    sig = mono_method_signature (method);
    if (sig == 0B) goto <D.28621>; else goto <D.28622>;
    <D.28621>:
    // predicted unlikely by continue predictor.
    goto <D.24334>;
    <D.28622>:
    D.28623 = sig->ret;
    D.28624 = D.28623->type;
    D.28625 = D.28624 == 15;
    D.28626 = D.28624 == 22;
    D.28627 = D.28625 | D.28626;
    if (D.28627 != 0) goto <D.28628>; else goto <D.28629>;
    <D.28628>:
    skip = 1;
    <D.28629>:
    D.28623 = sig->ret;
    D.28630 = mono_class_is_open_constructed_type (D.28623);
    if (D.28630 != 0) goto <D.28631>; else goto <D.28632>;
    <D.28631>:
    skip = 1;
    <D.28632>:
    j = 0;
    goto <D.24336>;
    <D.24335>:
    D.28633 = sig->params[j];
    D.28634 = D.28633->type;
    if (D.28634 == 22) goto <D.28635>; else goto <D.28636>;
    <D.28635>:
    skip = 1;
    <D.28636>:
    D.28633 = sig->params[j];
    D.28637 = mono_class_is_open_constructed_type (D.28633);
    if (D.28637 != 0) goto <D.28638>; else goto <D.28639>;
    <D.28638>:
    skip = 1;
    <D.28639>:
    j = j + 1;
    <D.24336>:
    D.28640 = sig->param_count;
    D.28641 = (int) D.28640;
    if (D.28641 > j) goto <D.24335>; else goto <D.24337>;
    <D.24337>:
    if (skip == 0) goto <D.28642>; else goto <D.28643>;
    <D.28642>:
    D.28644 = mono_marshal_get_runtime_invoke (method, 0);
    add_method (acfg, D.28644);
    <D.28643>:
  }
  <D.24334>:
  i = i + 1;
  <D.24339>:
  D.28609 = acfg->image;
  D.28645 = D.28609->tables[6].rows;
  D.28646 = (int) D.28645;
  if (D.28646 > i) goto <D.24338>; else goto <D.24340>;
  <D.24340>:
  {
    size_t __s1_len;
    size_t __s2_len;

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

      D.28609 = acfg->image;
      D.28650 = D.28609->assembly;
      __s2 = D.28650->aname.name;
      D.28651 = "mscorlib";
      D.28652 = MEM[(const unsigned char *)D.28651];
      D.28653 = (int) D.28652;
      D.28654 = *__s2;
      D.28655 = (int) D.28654;
      __result = D.28653 - D.28655;
      {
        D.28656 = __s2_len != 0;
        D.28657 = __result == 0;
        D.28658 = D.28656 & D.28657;
        if (D.28658 != 0) goto <D.28659>; else goto <D.28660>;
        <D.28659>:
        D.28661 = &MEM[(void *)"mscorlib" + 1B];
        D.28662 = *D.28661;
        D.28663 = (int) D.28662;
        D.28664 = __s2 + 1;
        D.28665 = *D.28664;
        D.28666 = (int) D.28665;
        __result = D.28663 - D.28666;
        D.28667 = __s2_len > 1;
        D.28657 = __result == 0;
        D.28668 = D.28667 & D.28657;
        if (D.28668 != 0) goto <D.28669>; else goto <D.28670>;
        <D.28669>:
        D.28671 = &MEM[(void *)"mscorlib" + 2B];
        D.28672 = *D.28671;
        D.28673 = (int) D.28672;
        D.28674 = __s2 + 2;
        D.28675 = *D.28674;
        D.28676 = (int) D.28675;
        __result = D.28673 - D.28676;
        D.28677 = __s2_len > 2;
        D.28657 = __result == 0;
        D.28678 = D.28677 & D.28657;
        if (D.28678 != 0) goto <D.28679>; else goto <D.28680>;
        <D.28679>:
        D.28681 = &MEM[(void *)"mscorlib" + 3B];
        D.28682 = *D.28681;
        D.28683 = (int) D.28682;
        D.28684 = __s2 + 3;
        D.28685 = *D.28684;
        D.28686 = (int) D.28685;
        __result = D.28683 - D.28686;
        <D.28680>:
        <D.28670>:
        <D.28660>:
      }
      D.24348 = __result;
    }
    iftmp.98 = -D.24348;
    goto <D.28687>;
    <D.28649>:
    D.28609 = acfg->image;
    D.28650 = D.28609->assembly;
    D.28688 = D.28650->aname.name;
    iftmp.98 = __builtin_strcmp (D.28688, "mscorlib");
    <D.28687>:
    D.24349 = iftmp.98;
  }
  if (D.24349 == 0) goto <D.28689>; else goto <D.28690>;
  <D.28689>:
  {
    struct MonoMethodDesc * desc;
    struct MonoMethod * orig_method;
    int nallocators;

    D.28691 = mono_defaults.corlib;
    csig = mono_metadata_signature_alloc (D.28691, 0);
    D.28692 = mono_defaults.void_class;
    D.28693 = &D.28692->byval_arg;
    csig->ret = D.28693;
    D.28694 = get_runtime_invoke_sig (csig);
    add_method (acfg, D.28694);
    D.28691 = mono_defaults.corlib;
    csig = mono_metadata_signature_alloc (D.28691, 0);
    csig->hasthis = 1;
    D.28692 = mono_defaults.void_class;
    D.28693 = &D.28692->byval_arg;
    csig->ret = D.28693;
    D.28695 = get_runtime_invoke_sig (csig);
    add_method (acfg, D.28695);
    D.28691 = mono_defaults.corlib;
    csig = mono_metadata_signature_alloc (D.28691, 1);
    csig->hasthis = 1;
    D.28692 = mono_defaults.void_class;
    D.28693 = &D.28692->byval_arg;
    csig->ret = D.28693;
    D.28696 = mono_defaults.string_class;
    D.28697 = &D.28696->byval_arg;
    csig->params[0] = D.28697;
    D.28698 = get_runtime_invoke_sig (csig);
    add_method (acfg, D.28698);
    D.28691 = mono_defaults.corlib;
    csig = mono_metadata_signature_alloc (D.28691, 2);
    csig->hasthis = 1;
    D.28692 = mono_defaults.void_class;
    D.28693 = &D.28692->byval_arg;
    csig->ret = D.28693;
    D.28696 = mono_defaults.string_class;
    D.28697 = &D.28696->byval_arg;
    csig->params[0] = D.28697;
    D.28696 = mono_defaults.string_class;
    D.28697 = &D.28696->byval_arg;
    csig->params[1] = D.28697;
    D.28699 = get_runtime_invoke_sig (csig);
    add_method (acfg, D.28699);
    D.28691 = mono_defaults.corlib;
    csig = mono_metadata_signature_alloc (D.28691, 0);
    csig->hasthis = 1;
    D.28696 = mono_defaults.string_class;
    D.28697 = &D.28696->byval_arg;
    csig->ret = D.28697;
    D.28700 = get_runtime_invoke_sig (csig);
    add_method (acfg, D.28700);
    D.28691 = mono_defaults.corlib;
    csig = mono_metadata_signature_alloc (D.28691, 2);
    csig->hasthis = 1;
    D.28692 = mono_defaults.void_class;
    D.28693 = &D.28692->byval_arg;
    csig->ret = D.28693;
    D.28696 = mono_defaults.string_class;
    D.28697 = &D.28696->byval_arg;
    csig->params[0] = D.28697;
    D.28701 = mono_defaults.exception_class;
    D.28702 = &D.28701->byval_arg;
    csig->params[1] = D.28702;
    D.28703 = get_runtime_invoke_sig (csig);
    add_method (acfg, D.28703);
    D.28691 = mono_defaults.corlib;
    csig = mono_metadata_signature_alloc (D.28691, 2);
    csig->hasthis = 1;
    D.28691 = mono_defaults.corlib;
    D.28704 = mono_class_from_name (D.28691, "System.Reflection", "Assembly");
    D.28705 = &D.28704->byval_arg;
    csig->ret = D.28705;
    D.28696 = mono_defaults.string_class;
    D.28697 = &D.28696->byval_arg;
    csig->params[0] = D.28697;
    D.28706 = mono_defaults.boolean_class;
    D.28707 = &D.28706->byval_arg;
    csig->params[1] = D.28707;
    D.28708 = get_runtime_invoke_sig (csig);
    add_method (acfg, D.28708);
    D.28709 = mono_defaults.object_class;
    D.28710 = mono_class_get_method_from_name_flags (D.28709, "Finalize", 0, 0);
    D.28711 = mono_marshal_get_runtime_invoke (D.28710, 1);
    add_method (acfg, D.28711);
    method = mono_get_context_capture_method ();
    if (method != 0B) goto <D.28712>; else goto <D.28713>;
    <D.28712>:
    D.28714 = mono_marshal_get_runtime_invoke (method, 0);
    add_method (acfg, D.28714);
    <D.28713>:
    D.28715 = mono_marshal_get_stelemref ();
    add_method (acfg, D.28715);
    D.28716 = mono_x86_have_tls_get ();
    if (D.28716 != 0) goto <D.28717>; else goto <D.28718>;
    <D.28717>:
    D.28719 = mono_gc_get_managed_allocator_types ();
    nallocators = (int) D.28719;
    i = 0;
    goto <D.24354>;
    <D.24353>:
    m = mono_gc_get_managed_allocator_by_type (i);
    if (m != 0B) goto <D.28720>; else goto <D.28721>;
    <D.28720>:
    add_method (acfg, m);
    <D.28721>:
    i = i + 1;
    <D.24354>:
    if (i < nallocators) goto <D.24353>; else goto <D.24355>;
    <D.24355>:
    desc = mono_method_desc_new ("Monitor:Enter(object,bool&)", 0);
    D.28722 = mono_defaults.monitor_class;
    orig_method = mono_method_desc_search_in_class (desc, D.28722);
    if (orig_method != 0B) goto <D.28723>; else goto <D.28724>;
    <D.28723>:
    method = mono_monitor_get_fast_path (orig_method);
    if (method != 0B) goto <D.28725>; else goto <D.28726>;
    <D.28725>:
    add_method (acfg, method);
    <D.28726>:
    <D.28724>:
    mono_method_desc_free (desc);
    desc = mono_method_desc_new ("Monitor:Exit(object)", 0);
    D.28722 = mono_defaults.monitor_class;
    orig_method = mono_method_desc_search_in_class (desc, D.28722);
    D.28727 = orig_method == 0B;
    D.28728 = (long int) D.28727;
    D.28729 = __builtin_expect (D.28728, 0);
    if (D.28729 != 0) goto <D.28730>; else goto <D.28731>;
    <D.28730>:
    monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "aot-compiler.c", 3370, "orig_method");
    <D.28731>:
    mono_method_desc_free (desc);
    method = mono_monitor_get_fast_path (orig_method);
    if (method != 0B) goto <D.28732>; else goto <D.28733>;
    <D.28732>:
    add_method (acfg, method);
    <D.28733>:
    <D.28718>:
    {
      struct MonoMethod * * wrappers;
      int nwrappers;

      try
        {
          wrappers = mono_marshal_get_virtual_stelemref_wrappers (&nwrappers);
          i = 0;
          goto <D.24359>;
          <D.24358>:
          i.99 = (unsigned int) i;
          D.28735 = i.99 * 4;
          D.28736 = wrappers + D.28735;
          D.28737 = *D.28736;
          add_method (acfg, D.28737);
          i = i + 1;
          <D.24359>:
          nwrappers.100 = nwrappers;
          if (i < nwrappers.100) goto <D.24358>; else goto <D.24360>;
          <D.24360>:
          monoeg_g_free (wrappers);
        }
      finally
        {
          nwrappers = {CLOBBER};
        }
    }
    D.28739 = mono_marshal_get_castclass_with_cache ();
    add_method (acfg, D.28739);
    D.28740 = mono_marshal_get_isinst_with_cache ();
    add_method (acfg, D.28740);
    {
      struct MonoMethodDesc * desc;
      struct MonoMethod * m;

      desc = mono_method_desc_new ("Monitor:Enter(object,bool&)", 0);
      D.28722 = mono_defaults.monitor_class;
      m = mono_method_desc_search_in_class (desc, D.28722);
      mono_method_desc_free (desc);
      if (m != 0B) goto <D.28741>; else goto <D.28742>;
      <D.28741>:
      m = mono_monitor_get_fast_path (m);
      if (m != 0B) goto <D.28743>; else goto <D.28744>;
      <D.28743>:
      add_method (acfg, m);
      <D.28744>:
      <D.28742>:
    }
    D.28745 = mono_get_jit_icall_info ();
    monoeg_g_hash_table_foreach (D.28745, add_jit_icall_wrapper, acfg);
  }
  <D.28690>:
  i = 0;
  goto <D.24392>;
  <D.24391>:
  {
    struct MonoClass * klass;
    struct MonoCustomAttrInfo * cattr;

    D.28607 = i + 1;
    D.28746 = D.28607 | 33554432;
    token = (guint32) D.28746;
    D.28609 = acfg->image;
    klass = mono_class_get (D.28609, token);
    if (klass == 0B) goto <D.28747>; else goto <D.28748>;
    <D.28747>:
    mono_loader_clear_error ();
    // predicted unlikely by continue predictor.
    goto <D.24365>;
    <D.28748>:
    D.28751 = BIT_FIELD_REF <*klass, 8, 184>;
    D.28752 = D.28751 & 1;
    if (D.28752 == 0) goto <D.28749>; else goto <D.28753>;
    <D.28753>:
    D.28754 = mono_defaults.delegate_class;
    if (D.28754 == klass) goto <D.28749>; else goto <D.28755>;
    <D.28755>:
    D.28756 = mono_defaults.multicastdelegate_class;
    if (D.28756 == klass) goto <D.28749>; else goto <D.28750>;
    <D.28749>:
    // predicted unlikely by continue predictor.
    goto <D.24365>;
    <D.28750>:
    D.28757 = klass->generic_container;
    if (D.28757 == 0B) goto <D.28758>; else goto <D.28759>;
    <D.28758>:
    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.28760>; else goto <D.28761>;
    <D.28760>:
    D.28762 = mono_marshal_get_delegate_begin_invoke (method);
    add_method (acfg, D.28762);
    <D.28761>:
    method = mono_class_get_method_from_name_flags (klass, "EndInvoke", -1, 0);
    if (method != 0B) goto <D.28763>; else goto <D.28764>;
    <D.28763>:
    D.28765 = mono_marshal_get_delegate_end_invoke (method);
    add_method (acfg, D.28765);
    <D.28764>:
    cattr = mono_custom_attrs_from_class (klass);
    if (cattr != 0B) goto <D.28766>; else goto <D.28767>;
    <D.28766>:
    {
      int j;

      j = 0;
      goto <D.24387>;
      <D.24386>:
      D.28768 = cattr->attrs[j].ctor;
      if (D.28768 != 0B) goto <D.28769>; else goto <D.28770>;
      <D.28769>:
      {
        size_t __s1_len;
        size_t __s2_len;

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

          D.28768 = cattr->attrs[j].ctor;
          D.28774 = D.28768->klass;
          __s2 = D.28774->name;
          D.28775 = "MonoNativeFunctionWrapperAttribute";
          D.28776 = MEM[(const unsigned char *)D.28775];
          D.28777 = (int) D.28776;
          D.28778 = *__s2;
          D.28779 = (int) D.28778;
          __result = D.28777 - D.28779;
          {
            D.28780 = __s2_len != 0;
            D.28781 = __result == 0;
            D.28782 = D.28780 & D.28781;
            if (D.28782 != 0) goto <D.28783>; else goto <D.28784>;
            <D.28783>:
            D.28785 = &MEM[(void *)"MonoNativeFunctionWrapperAttribute" + 1B];
            D.28786 = *D.28785;
            D.28787 = (int) D.28786;
            D.28788 = __s2 + 1;
            D.28789 = *D.28788;
            D.28790 = (int) D.28789;
            __result = D.28787 - D.28790;
            D.28791 = __s2_len > 1;
            D.28781 = __result == 0;
            D.28792 = D.28791 & D.28781;
            if (D.28792 != 0) goto <D.28793>; else goto <D.28794>;
            <D.28793>:
            D.28795 = &MEM[(void *)"MonoNativeFunctionWrapperAttribute" + 2B];
            D.28796 = *D.28795;
            D.28797 = (int) D.28796;
            D.28798 = __s2 + 2;
            D.28799 = *D.28798;
            D.28800 = (int) D.28799;
            __result = D.28797 - D.28800;
            D.28801 = __s2_len > 2;
            D.28781 = __result == 0;
            D.28802 = D.28801 & D.28781;
            if (D.28802 != 0) goto <D.28803>; else goto <D.28804>;
            <D.28803>:
            D.28805 = &MEM[(void *)"MonoNativeFunctionWrapperAttribute" + 3B];
            D.28806 = *D.28805;
            D.28807 = (int) D.28806;
            D.28808 = __s2 + 3;
            D.28809 = *D.28808;
            D.28810 = (int) D.28809;
            __result = D.28807 - D.28810;
            <D.28804>:
            <D.28794>:
            <D.28784>:
          }
          D.24374 = __result;
        }
        iftmp.101 = -D.24374;
        goto <D.28811>;
        <D.28773>:
        D.28768 = cattr->attrs[j].ctor;
        D.28774 = D.28768->klass;
        D.28812 = D.28774->name;
        iftmp.101 = __builtin_strcmp (D.28812, "MonoNativeFunctionWrapperAttribute");
        <D.28811>:
        D.24375 = iftmp.101;
      }
      if (D.24375 == 0) goto <D.24385>; else goto <D.28813>;
      <D.28813>:
      {
        size_t __s1_len;
        size_t __s2_len;

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

          D.28768 = cattr->attrs[j].ctor;
          D.28774 = D.28768->klass;
          __s2 = D.28774->name;
          D.28817 = "UnmanagedFunctionPointerAttribute";
          D.28818 = MEM[(const unsigned char *)D.28817];
          D.28819 = (int) D.28818;
          D.28820 = *__s2;
          D.28821 = (int) D.28820;
          __result = D.28819 - D.28821;
          {
            D.28822 = __s2_len != 0;
            D.28823 = __result == 0;
            D.28824 = D.28822 & D.28823;
            if (D.28824 != 0) goto <D.28825>; else goto <D.28826>;
            <D.28825>:
            D.28827 = &MEM[(void *)"UnmanagedFunctionPointerAttribute" + 1B];
            D.28828 = *D.28827;
            D.28829 = (int) D.28828;
            D.28830 = __s2 + 1;
            D.28831 = *D.28830;
            D.28832 = (int) D.28831;
            __result = D.28829 - D.28832;
            D.28833 = __s2_len > 1;
            D.28823 = __result == 0;
            D.28834 = D.28833 & D.28823;
            if (D.28834 != 0) goto <D.28835>; else goto <D.28836>;
            <D.28835>:
            D.28837 = &MEM[(void *)"UnmanagedFunctionPointerAttribute" + 2B];
            D.28838 = *D.28837;
            D.28839 = (int) D.28838;
            D.28840 = __s2 + 2;
            D.28841 = *D.28840;
            D.28842 = (int) D.28841;
            __result = D.28839 - D.28842;
            D.28843 = __s2_len > 2;
            D.28823 = __result == 0;
            D.28844 = D.28843 & D.28823;
            if (D.28844 != 0) goto <D.28845>; else goto <D.28846>;
            <D.28845>:
            D.28847 = &MEM[(void *)"UnmanagedFunctionPointerAttribute" + 3B];
            D.28848 = *D.28847;
            D.28849 = (int) D.28848;
            D.28850 = __s2 + 3;
            D.28851 = *D.28850;
            D.28852 = (int) D.28851;
            __result = D.28849 - D.28852;
            <D.28846>:
            <D.28836>:
            <D.28826>:
          }
          D.24383 = __result;
        }
        iftmp.102 = -D.24383;
        goto <D.28853>;
        <D.28816>:
        D.28768 = cattr->attrs[j].ctor;
        D.28774 = D.28768->klass;
        D.28812 = D.28774->name;
        iftmp.102 = __builtin_strcmp (D.28812, "UnmanagedFunctionPointerAttribute");
        <D.28853>:
        D.24384 = iftmp.102;
      }
      if (D.24384 == 0) goto <D.24385>; else goto <D.28854>;
      <D.28854>:
      <D.28770>:
      j = j + 1;
      <D.24387>:
      D.28855 = cattr->num_attrs;
      if (D.28855 > j) goto <D.24386>; else goto <D.24385>;
      <D.24385>:
      D.28855 = cattr->num_attrs;
      if (D.28855 > j) goto <D.28856>; else goto <D.28857>;
      <D.28856>:
      D.28858 = mono_marshal_get_native_func_wrapper_aot (klass);
      add_method (acfg, D.28858);
      <D.28857>:
    }
    <D.28767>:
    goto <D.28859>;
    <D.28759>:
    D.28860 = acfg->opts;
    D.28861 = D.28860 & 16777216;
    if (D.28861 != 0) goto <D.28862>; else goto <D.28863>;
    <D.28862>:
    D.28757 = klass->generic_container;
    if (D.28757 != 0B) goto <D.28864>; else goto <D.28865>;
    <D.28864>:
    {
      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.28866 = BIT_FIELD_REF <*m, 8, 168>;
          D.28867 = D.28866 & 16;
          D.28868 = D.28867 == 0;
          D.28869 = (long int) D.28868;
          D.28870 = __builtin_expect (D.28869, 0);
          if (D.28870 != 0) goto <D.28871>; else goto <D.28872>;
          <D.28871>:
          monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "aot-compiler.c", 3493, "m->is_inflated");
          <D.28872>:
          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.28866 = BIT_FIELD_REF <*m, 8, 168>;
          D.28867 = D.28866 & 16;
          D.28868 = D.28867 == 0;
          D.28869 = (long int) D.28868;
          D.28870 = __builtin_expect (D.28869, 0);
          if (D.28870 != 0) goto <D.28873>; else goto <D.28874>;
          <D.28873>:
          monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "aot-compiler.c", 3505, "m->is_inflated");
          <D.28874>:
          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.28866 = BIT_FIELD_REF <*m, 8, 168>;
          D.28867 = D.28866 & 16;
          D.28868 = D.28867 == 0;
          D.28869 = (long int) D.28868;
          D.28870 = __builtin_expect (D.28869, 0);
          if (D.28870 != 0) goto <D.28875>; else goto <D.28876>;
          <D.28875>:
          monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "aot-compiler.c", 3517, "m->is_inflated");
          <D.28876>:
          gshared = mini_get_shared_method_full (m, 0, 1);
          add_extra_method (acfg, gshared);
        }
      finally
        {
          ctx = {CLOBBER};
        }
    }
    <D.28865>:
    <D.28863>:
    <D.28859>:
  }
  <D.24365>:
  i = i + 1;
  <D.24392>:
  D.28609 = acfg->image;
  D.28877 = D.28609->tables[2].rows;
  D.28878 = (int) D.28877;
  if (D.28878 > i) goto <D.24391>; else goto <D.24393>;
  <D.24393>:
  i = 0;
  goto <D.24399>;
  <D.24398>:
  {
    struct MonoClass * klass;

    D.28607 = i + 1;
    D.28879 = D.28607 | 452984832;
    token = (guint32) D.28879;
    D.28609 = acfg->image;
    klass = mono_class_get (D.28609, token);
    if (klass == 0B) goto <D.28880>; else goto <D.28881>;
    <D.28880>:
    mono_loader_clear_error ();
    // predicted unlikely by continue predictor.
    goto <D.24395>;
    <D.28881>:
    D.28882 = klass->rank;
    if (D.28882 != 0) goto <D.28883>; else goto <D.28884>;
    <D.28883>:
    D.28885 = klass->element_class;
    D.28886 = BIT_FIELD_REF <*D.28885, 8, 1080>;
    D.28887 = D.28886 & 64;
    if (D.28887 == 0) goto <D.28888>; else goto <D.28889>;
    <D.28888>:
    D.28885 = klass->element_class;
    D.28890 = D.28885->byval_arg.type;
    D.28891 = D.28890 + 254;
    D.28892 = D.28891 <= 11;
    D.28893 = D.28890 + 232;
    D.28894 = D.28893 <= 1;
    D.28895 = D.28892 | D.28894;
    if (D.28895 != 0) goto <D.28896>; else goto <D.28897>;
    <D.28896>:
    {
      struct MonoMethod * m;
      struct MonoMethod * wrapper;

      m = mono_class_get_method_from_name (klass, "Get", -1);
      D.28898 = m == 0B;
      D.28899 = (long int) D.28898;
      D.28900 = __builtin_expect (D.28899, 0);
      if (D.28900 != 0) goto <D.28901>; else goto <D.28902>;
      <D.28901>:
      monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "aot-compiler.c", 3543, "m");
      <D.28902>:
      wrapper = mono_marshal_get_array_accessor_wrapper (m);
      add_extra_method (acfg, wrapper);
      D.28903 = mono_marshal_get_runtime_invoke (wrapper, 0);
      add_extra_method (acfg, D.28903);
      m = mono_class_get_method_from_name (klass, "Set", -1);
      D.28898 = m == 0B;
      D.28899 = (long int) D.28898;
      D.28900 = __builtin_expect (D.28899, 0);
      if (D.28900 != 0) goto <D.28904>; else goto <D.28905>;
      <D.28904>:
      monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "aot-compiler.c", 3549, "m");
      <D.28905>:
      wrapper = mono_marshal_get_array_accessor_wrapper (m);
      add_extra_method (acfg, wrapper);
      D.28906 = mono_marshal_get_runtime_invoke (wrapper, 0);
      add_extra_method (acfg, D.28906);
    }
    <D.28897>:
    <D.28889>:
    <D.28884>:
  }
  <D.24395>:
  i = i + 1;
  <D.24399>:
  D.28609 = acfg->image;
  D.28907 = D.28609->tables[27].rows;
  D.28908 = (int) D.28907;
  if (D.28908 > i) goto <D.24398>; else goto <D.24400>;
  <D.24400>:
  i = 0;
  goto <D.24406>;
  <D.24405>:
  D.28607 = i + 1;
  D.28608 = D.28607 | 100663296;
  token = (guint32) D.28608;
  D.28609 = acfg->image;
  method = mono_get_method (D.28609, token, 0B);
  D.28909 = method->iflags;
  D.28910 = (int) D.28909;
  D.28911 = D.28910 & 32;
  if (D.28911 != 0) goto <D.28912>; else goto <D.28913>;
  <D.28912>:
  D.28914 = BIT_FIELD_REF <*method, 8, 168>;
  D.28915 = D.28914 & 8;
  if (D.28915 != 0) goto <D.28916>; else goto <D.28917>;
  <D.28916>:
  goto <D.28918>;
  <D.28917>:
  D.28919 = method->klass;
  D.28920 = D.28919->generic_container;
  if (D.28920 != 0B) goto <D.28921>; else goto <D.28922>;
  <D.28921>:
  {
    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.28923 = BIT_FIELD_REF <*m, 8, 168>;
        D.28924 = D.28923 & 16;
        D.28925 = D.28924 == 0;
        D.28926 = (long int) D.28925;
        D.28927 = __builtin_expect (D.28926, 0);
        if (D.28927 != 0) goto <D.28928>; else goto <D.28929>;
        <D.28928>:
        monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "aot-compiler.c", 3574, "m->is_inflated");
        <D.28929>:
        gshared = mini_get_shared_method_full (m, 0, 1);
        add_method (acfg, gshared);
      }
    finally
      {
        ctx = {CLOBBER};
      }
  }
  goto <D.28930>;
  <D.28922>:
  D.28931 = mono_marshal_get_synchronized_wrapper (method);
  add_method (acfg, D.28931);
  <D.28930>:
  <D.28918>:
  <D.28913>:
  i = i + 1;
  <D.24406>:
  D.28609 = acfg->image;
  D.28645 = D.28609->tables[6].rows;
  D.28646 = (int) D.28645;
  if (D.28646 > i) goto <D.24405>; else goto <D.24407>;
  <D.24407>:
  i = 0;
  goto <D.24411>;
  <D.24410>:
  {
    struct MonoMethod * method;
    guint32 token;

    D.28607 = i + 1;
    D.28608 = D.28607 | 100663296;
    token = (guint32) D.28608;
    D.28609 = acfg->image;
    method = mono_get_method (D.28609, token, 0B);
    D.28934 = method->flags;
    D.28935 = (int) D.28934;
    D.28936 = D.28935 & 8192;
    if (D.28936 != 0) goto <D.28932>; else goto <D.28937>;
    <D.28937>:
    D.28938 = method->iflags;
    D.28939 = (int) D.28938;
    D.28940 = D.28939 & 4096;
    if (D.28940 != 0) goto <D.28932>; else goto <D.28933>;
    <D.28932>:
    D.28941 = mono_marshal_get_native_wrapper (method, 1, 1);
    add_method (acfg, D.28941);
    <D.28933>:
  }
  i = i + 1;
  <D.24411>:
  D.28609 = acfg->image;
  D.28645 = D.28609->tables[6].rows;
  D.28646 = (int) D.28645;
  if (D.28646 > i) goto <D.24410>; else goto <D.24412>;
  <D.24412>:
  i = 0;
  goto <D.24464>;
  <D.24463>:
  {
    struct MonoMethod * method;
    guint32 token;
    struct MonoCustomAttrInfo * cattr;
    int j;

    D.28607 = i + 1;
    D.28608 = D.28607 | 100663296;
    token = (guint32) D.28608;
    D.28609 = acfg->image;
    method = mono_get_method (D.28609, token, 0B);
    cattr = mono_custom_attrs_from_method (method);
    if (cattr != 0B) goto <D.28942>; else goto <D.28943>;
    <D.28942>:
    j = 0;
    goto <D.24428>;
    <D.24427>:
    D.28944 = cattr->attrs[j].ctor;
    if (D.28944 != 0B) goto <D.28945>; else goto <D.28946>;
    <D.28945>:
    {
      size_t __s1_len;
      size_t __s2_len;

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

        D.28944 = cattr->attrs[j].ctor;
        D.28950 = D.28944->klass;
        __s2 = D.28950->name;
        D.28951 = "MonoPInvokeCallbackAttribute";
        D.28952 = MEM[(const unsigned char *)D.28951];
        D.28953 = (int) D.28952;
        D.28954 = *__s2;
        D.28955 = (int) D.28954;
        __result = D.28953 - D.28955;
        {
          D.28956 = __s2_len != 0;
          D.28957 = __result == 0;
          D.28958 = D.28956 & D.28957;
          if (D.28958 != 0) goto <D.28959>; else goto <D.28960>;
          <D.28959>:
          D.28961 = &MEM[(void *)"MonoPInvokeCallbackAttribute" + 1B];
          D.28962 = *D.28961;
          D.28963 = (int) D.28962;
          D.28964 = __s2 + 1;
          D.28965 = *D.28964;
          D.28966 = (int) D.28965;
          __result = D.28963 - D.28966;
          D.28967 = __s2_len > 1;
          D.28957 = __result == 0;
          D.28968 = D.28967 & D.28957;
          if (D.28968 != 0) goto <D.28969>; else goto <D.28970>;
          <D.28969>:
          D.28971 = &MEM[(void *)"MonoPInvokeCallbackAttribute" + 2B];
          D.28972 = *D.28971;
          D.28973 = (int) D.28972;
          D.28974 = __s2 + 2;
          D.28975 = *D.28974;
          D.28976 = (int) D.28975;
          __result = D.28973 - D.28976;
          D.28977 = __s2_len > 2;
          D.28957 = __result == 0;
          D.28978 = D.28977 & D.28957;
          if (D.28978 != 0) goto <D.28979>; else goto <D.28980>;
          <D.28979>:
          D.28981 = &MEM[(void *)"MonoPInvokeCallbackAttribute" + 3B];
          D.28982 = *D.28981;
          D.28983 = (int) D.28982;
          D.28984 = __s2 + 3;
          D.28985 = *D.28984;
          D.28986 = (int) D.28985;
          __result = D.28983 - D.28986;
          <D.28980>:
          <D.28970>:
          <D.28960>:
        }
        D.24424 = __result;
      }
      iftmp.103 = -D.24424;
      goto <D.28987>;
      <D.28949>:
      D.28944 = cattr->attrs[j].ctor;
      D.28950 = D.28944->klass;
      D.28988 = D.28950->name;
      iftmp.103 = __builtin_strcmp (D.28988, "MonoPInvokeCallbackAttribute");
      <D.28987>:
      D.24425 = iftmp.103;
    }
    if (D.24425 == 0) goto <D.24426>; else goto <D.28989>;
    <D.28989>:
    <D.28946>:
    j = j + 1;
    <D.24428>:
    D.28990 = cattr->num_attrs;
    if (D.28990 > j) goto <D.24427>; else goto <D.24426>;
    <D.24426>:
    D.28990 = cattr->num_attrs;
    if (D.28990 > j) goto <D.28991>; else goto <D.28992>;
    <D.28991>:
    {
      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.28993 = e->ctor;
          sig = mono_method_signature (D.28993);
          p.104 = e->data;
          p = p.104;
          export_name = 0B;
          D.28995 = method->flags;
          D.28996 = (int) D.28995;
          D.28997 = D.28996 & 16;
          if (D.28997 == 0) goto <D.28998>; else goto <D.28999>;
          <D.28998>:
          D.29000 = 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.29000);
          exit (1);
          <D.28999>:
          D.29001 = sig->param_count;
          D.29002 = D.29001 != 1;
          D.29003 = (long int) D.29002;
          D.29004 = __builtin_expect (D.29003, 0);
          if (D.29004 != 0) goto <D.29005>; else goto <D.29006>;
          <D.29005>:
          monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "aot-compiler.c", 3635, "sig->param_count == 1");
          <D.29006>:
          D.29011 = sig->params[0];
          D.29012 = D.29011->type;
          if (D.29012 != 18) goto <D.29008>; else goto <D.29013>;
          <D.29013>:
          {
            size_t __s1_len;
            size_t __s2_len;

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

              D.29011 = sig->params[0];
              D.29017 = mono_class_from_mono_type (D.29011);
              __s2 = D.29017->name;
              D.29018 = "Type";
              D.29019 = MEM[(const unsigned char *)D.29018];
              D.29020 = (int) D.29019;
              D.29021 = *__s2;
              D.29022 = (int) D.29021;
              __result = D.29020 - D.29022;
              {
                D.29023 = __s2_len != 0;
                D.29024 = __result == 0;
                D.29025 = D.29023 & D.29024;
                if (D.29025 != 0) goto <D.29026>; else goto <D.29027>;
                <D.29026>:
                D.29028 = &MEM[(void *)"Type" + 1B];
                D.29029 = *D.29028;
                D.29030 = (int) D.29029;
                D.29031 = __s2 + 1;
                D.29032 = *D.29031;
                D.29033 = (int) D.29032;
                __result = D.29030 - D.29033;
                D.29034 = __s2_len > 1;
                D.29024 = __result == 0;
                D.29035 = D.29034 & D.29024;
                if (D.29035 != 0) goto <D.29036>; else goto <D.29037>;
                <D.29036>:
                D.29038 = &MEM[(void *)"Type" + 2B];
                D.29039 = *D.29038;
                D.29040 = (int) D.29039;
                D.29041 = __s2 + 2;
                D.29042 = *D.29041;
                D.29043 = (int) D.29042;
                __result = D.29040 - D.29043;
                D.29044 = __s2_len > 2;
                D.29024 = __result == 0;
                D.29045 = D.29044 & D.29024;
                if (D.29045 != 0) goto <D.29046>; else goto <D.29047>;
                <D.29046>:
                D.29048 = &MEM[(void *)"Type" + 3B];
                D.29049 = *D.29048;
                D.29050 = (int) D.29049;
                D.29051 = __s2 + 3;
                D.29052 = *D.29051;
                D.29053 = (int) D.29052;
                __result = D.29050 - D.29053;
                <D.29047>:
                <D.29037>:
                <D.29027>:
              }
              D.24449 = __result;
            }
            iftmp.106 = -D.24449;
            goto <D.29054>;
            <D.29016>:
            D.29011 = sig->params[0];
            D.29055 = mono_class_from_mono_type (D.29011);
            D.29056 = D.29055->name;
            iftmp.106 = __builtin_strcmp (D.29056, "Type");
            <D.29054>:
            D.24450 = iftmp.106;
          }
          if (D.24450 != 0) goto <D.29008>; else goto <D.29009>;
          <D.29008>:
          iftmp.105 = 1;
          goto <D.29010>;
          <D.29009>:
          iftmp.105 = 0;
          <D.29010>:
          D.29057 = iftmp.105 != 0;
          D.29058 = (long int) D.29057;
          D.29059 = __builtin_expect (D.29058, 0);
          if (D.29059 != 0) goto <D.29060>; else goto <D.29061>;
          <D.29060>:
          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.29061>:
          p.107 = p;
          p.108 = p.107 + 2;
          p = p.108;
          p.107 = p;
          D.29064 = mono_metadata_decode_value (p.107, &p);
          slen = (int) D.29064;
          D.29065 = slen + 1;
          D.29066 = (unsigned int) D.29065;
          p.107 = p;
          n = monoeg_g_memdup (p.107, D.29066);
          slen.109 = (sizetype) slen;
          D.29068 = n + slen.109;
          *D.29068 = 0;
          D.28609 = acfg->image;
          t = mono_reflection_type_from_name (n, D.28609);
          D.29069 = t == 0B;
          D.29070 = (long int) D.29069;
          D.29071 = __builtin_expect (D.29070, 0);
          if (D.29071 != 0) goto <D.29072>; else goto <D.29073>;
          <D.29072>:
          monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "aot-compiler.c", 3651, "t");
          <D.29073>:
          monoeg_g_free (n);
          klass = mono_class_from_mono_type (t);
          D.29074 = klass->parent;
          D.28756 = mono_defaults.multicastdelegate_class;
          D.29075 = D.29074 != D.28756;
          D.29076 = (long int) D.29075;
          D.29077 = __builtin_expect (D.29076, 0);
          if (D.29077 != 0) goto <D.29078>; else goto <D.29079>;
          <D.29078>:
          monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "aot-compiler.c", 3655, "klass->parent == mono_defaults.multicastdelegate_class");
          <D.29079>:
          p.107 = p;
          slen.109 = (sizetype) slen;
          p.110 = p.107 + slen.109;
          p = p.110;
          p.107 = p;
          D.29081 = MEM[(const guint16 *)p.107];
          num_named = (int) D.29081;
          p.107 = p;
          p.108 = p.107 + 2;
          p = p.108;
          D.29082 = num_named > 1;
          D.29083 = (long int) D.29082;
          D.29084 = __builtin_expect (D.29083, 0);
          if (D.29084 != 0) goto <D.29085>; else goto <D.29086>;
          <D.29085>:
          monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "aot-compiler.c", 3662, "num_named < 2");
          <D.29086>:
          if (num_named == 1) goto <D.29087>; else goto <D.29088>;
          <D.29087>:
          {
            int name_len;
            char * name;
            struct MonoType * prop_type;

            p.107 = p;
            named = p.107;
            named.111 = named;
            D.29090 = *named.111;
            named_type = (int) D.29090;
            named.111 = named;
            named.112 = named.111 + 1;
            named = named.112;
            named.111 = named;
            D.29090 = *named.111;
            data_type = (int) D.29090;
            named.111 = named;
            named.112 = named.111 + 1;
            named = named.112;
            named.111 = named;
            D.29092 = mono_metadata_decode_blob_size (named.111, &named);
            name_len = (int) D.29092;
            D.29093 = name_len + 1;
            D.29094 = (unsigned int) D.29093;
            name = monoeg_malloc (D.29094);
            name_len.113 = (unsigned int) name_len;
            named.111 = named;
            memcpy (name, named.111, name_len.113);
            name_len.114 = (sizetype) name_len;
            D.29097 = name + name_len.114;
            *D.29097 = 0;
            named.111 = named;
            name_len.114 = (sizetype) name_len;
            named.115 = named.111 + name_len.114;
            named = named.115;
            D.29099 = named_type != 84;
            D.29100 = (long int) D.29099;
            D.29101 = __builtin_expect (D.29100, 0);
            if (D.29101 != 0) goto <D.29102>; else goto <D.29103>;
            <D.29102>:
            monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "aot-compiler.c", 3681, "named_type == 0x54");
            <D.29103>:
            {
              size_t __s1_len;
              size_t __s2_len;

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

                __s2 = name;
                D.29107 = "ExportSymbol";
                D.29108 = MEM[(const unsigned char *)D.29107];
                D.29109 = (int) D.29108;
                D.29110 = *__s2;
                D.29111 = (int) D.29110;
                __result = D.29109 - D.29111;
                {
                  D.29112 = __s2_len != 0;
                  D.29113 = __result == 0;
                  D.29114 = D.29112 & D.29113;
                  if (D.29114 != 0) goto <D.29115>; else goto <D.29116>;
                  <D.29115>:
                  D.29117 = &MEM[(void *)"ExportSymbol" + 1B];
                  D.29118 = *D.29117;
                  D.29119 = (int) D.29118;
                  D.29120 = __s2 + 1;
                  D.29121 = *D.29120;
                  D.29122 = (int) D.29121;
                  __result = D.29119 - D.29122;
                  D.29123 = __s2_len > 1;
                  D.29113 = __result == 0;
                  D.29124 = D.29123 & D.29113;
                  if (D.29124 != 0) goto <D.29125>; else goto <D.29126>;
                  <D.29125>:
                  D.29127 = &MEM[(void *)"ExportSymbol" + 2B];
                  D.29128 = *D.29127;
                  D.29129 = (int) D.29128;
                  D.29130 = __s2 + 2;
                  D.29131 = *D.29130;
                  D.29132 = (int) D.29131;
                  __result = D.29129 - D.29132;
                  D.29133 = __s2_len > 2;
                  D.29113 = __result == 0;
                  D.29134 = D.29133 & D.29113;
                  if (D.29134 != 0) goto <D.29135>; else goto <D.29136>;
                  <D.29135>:
                  D.29137 = &MEM[(void *)"ExportSymbol" + 3B];
                  D.29138 = *D.29137;
                  D.29139 = (int) D.29138;
                  D.29140 = __s2 + 3;
                  D.29141 = *D.29140;
                  D.29142 = (int) D.29141;
                  __result = D.29139 - D.29142;
                  <D.29136>:
                  <D.29126>:
                  <D.29116>:
                }
                D.24461 = __result;
              }
              iftmp.116 = -D.24461;
              goto <D.29143>;
              <D.29106>:
              iftmp.116 = __builtin_strcmp (name, "ExportSymbol");
              <D.29143>:
              D.24462 = iftmp.116;
            }
            D.29144 = D.24462 != 0;
            D.29145 = (long int) D.29144;
            D.29146 = __builtin_expect (D.29145, 0);
            if (D.29146 != 0) goto <D.29147>; else goto <D.29148>;
            <D.29147>:
            monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "aot-compiler.c", 3682, "!strcmp (name, \"ExportSymbol\")");
            <D.29148>:
            D.28696 = mono_defaults.string_class;
            prop_type = &D.28696->byval_arg;
            named.111 = named;
            D.29090 = *named.111;
            D.29149 = D.29090 == -1;
            D.29150 = (long int) D.29149;
            D.29151 = __builtin_expect (D.29150, 0);
            if (D.29151 != 0) goto <D.29152>; else goto <D.29153>;
            <D.29152>:
            monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "aot-compiler.c", 3687, "*named != (char)0xff");
            <D.29153>:
            named.111 = named;
            D.29154 = mono_metadata_decode_value (named.111, &named);
            slen = (int) D.29154;
            D.29065 = slen + 1;
            D.29155 = (unsigned int) D.29065;
            export_name = monoeg_malloc (D.29155);
            slen.117 = (unsigned int) slen;
            named.111 = named;
            memcpy (export_name, named.111, slen.117);
            slen.109 = (sizetype) slen;
            D.29157 = export_name + slen.109;
            *D.29157 = 0;
            named.111 = named;
            slen.109 = (sizetype) slen;
            named.118 = named.111 + slen.109;
            named = named.118;
          }
          <D.29088>:
          wrapper = mono_marshal_get_managed_wrapper (method, klass, 0);
          add_method (acfg, wrapper);
          if (export_name != 0B) goto <D.29159>; else goto <D.29160>;
          <D.29159>:
          D.29161 = acfg->export_names;
          monoeg_g_hash_table_insert_replace (D.29161, wrapper, export_name, 0);
          <D.29160>:
        }
      finally
        {
          p = {CLOBBER};
          named = {CLOBBER};
        }
    }
    <D.28992>:
    <D.28943>:
    D.28995 = method->flags;
    D.28996 = (int) D.28995;
    D.29164 = D.28996 & 8192;
    if (D.29164 != 0) goto <D.29162>; else goto <D.29165>;
    <D.29165>:
    D.29166 = method->iflags;
    D.29167 = (int) D.29166;
    D.29168 = D.29167 & 4096;
    if (D.29168 != 0) goto <D.29162>; else goto <D.29163>;
    <D.29162>:
    D.29169 = mono_marshal_get_native_wrapper (method, 1, 1);
    add_method (acfg, D.29169);
    <D.29163>:
  }
  i = i + 1;
  <D.24464>:
  D.28609 = acfg->image;
  D.28645 = D.28609->tables[6].rows;
  D.28646 = (int) D.28645;
  if (D.28646 > i) goto <D.24463>; else goto <D.24465>;
  <D.24465>:
  i = 0;
  goto <D.24469>;
  <D.24468>:
  {
    struct MonoClass * klass;

    D.28607 = i + 1;
    D.28746 = D.28607 | 33554432;
    token = (guint32) D.28746;
    D.28609 = acfg->image;
    klass = mono_class_get (D.28609, token);
    if (klass == 0B) goto <D.29170>; else goto <D.29171>;
    <D.29170>:
    mono_loader_clear_error ();
    // predicted unlikely by continue predictor.
    goto <D.24467>;
    <D.29171>:
    D.29174 = BIT_FIELD_REF <*klass, 8, 160>;
    D.29175 = D.29174 & 8;
    if (D.29175 != 0) goto <D.29176>; else goto <D.29177>;
    <D.29176>:
    D.29178 = klass->generic_container;
    if (D.29178 == 0B) goto <D.29179>; else goto <D.29180>;
    <D.29179>:
    D.29181 = can_marshal_struct (klass);
    if (D.29181 != 0) goto <D.29182>; else goto <D.29183>;
    <D.29182>:
    D.29184 = klass->nested_in;
    if (D.29184 == 0B) goto <D.29172>; else goto <D.29185>;
    <D.29185>:
    D.29184 = klass->nested_in;
    D.29186 = D.29184->name;
    D.29187 = strstr (D.29186, "<PrivateImplementationDetails>");
    D.29184 = klass->nested_in;
    D.29186 = D.29184->name;
    if (D.29187 != D.29186) goto <D.29172>; else goto <D.29173>;
    <D.29172>:
    D.29188 = mono_marshal_get_struct_to_ptr (klass);
    add_method (acfg, D.29188);
    D.29189 = mono_marshal_get_ptr_to_struct (klass);
    add_method (acfg, D.29189);
    <D.29173>:
    <D.29183>:
    <D.29180>:
    <D.29177>:
  }
  <D.24467>:
  i = i + 1;
  <D.24469>:
  D.28609 = acfg->image;
  D.28877 = D.28609->tables[2].rows;
  D.28878 = (int) D.28877;
  if (D.28878 > i) goto <D.24468>; else goto <D.24470>;
  <D.24470>:
}


add_jit_icall_wrapper (void * key, void * value, void * user_data)
{
  struct MonoMethodSignature * D.29190;
  const char * D.29193;
  int check_for_pending_exc.119;
  const void * D.29195;
  struct MonoAotCompile * acfg;
  struct MonoJitICallInfo * callinfo;
  struct MonoMethod * wrapper;
  char * name;

  acfg = user_data;
  callinfo = value;
  D.29190 = callinfo->sig;
  if (D.29190 == 0B) goto <D.29191>; else goto <D.29192>;
  <D.29191>:
  return;
  <D.29192>:
  D.29193 = callinfo->name;
  name = monoeg_g_strdup_printf ("__icall_wrapper_%s", D.29193);
  check_for_pending_exc.119 = check_for_pending_exc;
  D.29195 = callinfo->func;
  D.29190 = callinfo->sig;
  wrapper = mono_marshal_get_icall_wrapper (D.29190, name, D.29195, check_for_pending_exc.119);
  monoeg_g_free (name);
  add_method (acfg, wrapper);
}


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

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


create_gsharedvt_inst (struct MonoAotCompile * acfg, struct MonoMethod * method, struct MonoGenericContext * ctx)
{
  struct MonoClass * D.29200;
  struct MonoGenericContainer * D.29201;
  <unnamed-unsigned:22> D.29204;
  unsigned int D.29205;
  unsigned int D.29206;
  unsigned int i.120;
  unsigned int D.29208;
  struct MonoType * * D.29209;
  struct MonoClass * D.29210;
  struct MonoType * D.29211;
  int D.29212;
  struct MonoGenericInst * D.29213;
  unsigned char D.29214;
  unsigned char D.29215;
  struct MonoGenericParamFull * D.29218;
  unsigned int D.29219;
  struct MonoGenericParamFull * D.29220;
  struct MonoClass * * D.29223;
  struct MonoClass * D.29228;
  struct MonoImage * D.29231;
  struct MonoImage * D.29232;
  int D.24314;
  int iftmp.121;
  int D.24313;
  const char[10] * D.29237;
  unsigned char D.29238;
  int D.29239;
  unsigned char D.29240;
  int D.29241;
  _Bool D.29242;
  _Bool D.29243;
  _Bool D.29244;
  const unsigned char * D.29247;
  unsigned char D.29248;
  int D.29249;
  const unsigned char * D.29250;
  unsigned char D.29251;
  int D.29252;
  _Bool D.29253;
  _Bool D.29254;
  const unsigned char * D.29257;
  unsigned char D.29258;
  int D.29259;
  const unsigned char * D.29260;
  unsigned char D.29261;
  int D.29262;
  _Bool D.29263;
  _Bool D.29264;
  const unsigned char * D.29267;
  unsigned char D.29268;
  int D.29269;
  const unsigned char * D.29270;
  unsigned char D.29271;
  int D.29272;
  const char * D.29274;
  struct MonoClass * D.29275;
  struct MonoType * D.29278;
  <unnamed-signed:31> D.29280;
  int D.29281;
  struct MonoGenericInst * D.29282;
  struct MonoGenericContext shared_context;
  struct MonoType * * args;
  struct MonoGenericInst * inst;
  struct MonoGenericContainer * container;
  struct MonoClass * * constraints;
  int i;

  try
    {
      memset (ctx, 0, 8);
      D.29200 = method->klass;
      D.29201 = D.29200->generic_container;
      if (D.29201 != 0B) goto <D.29202>; else goto <D.29203>;
      <D.29202>:
      D.29200 = method->klass;
      D.29201 = D.29200->generic_container;
      shared_context = D.29201->context;
      inst = shared_context.class_inst;
      D.29204 = inst->type_argc;
      D.29205 = (unsigned int) D.29204;
      D.29206 = D.29205 * 4;
      args = monoeg_malloc0 (D.29206);
      i = 0;
      goto <D.24301>;
      <D.24300>:
      i.120 = (unsigned int) i;
      D.29208 = i.120 * 4;
      D.29209 = args + D.29208;
      D.29210 = mono_defaults.int_class;
      D.29211 = &D.29210->byval_arg;
      *D.29209 = D.29211;
      i = i + 1;
      <D.24301>:
      D.29204 = inst->type_argc;
      D.29212 = (int) D.29204;
      if (D.29212 > i) goto <D.24300>; else goto <D.24302>;
      <D.24302>:
      D.29204 = inst->type_argc;
      D.29212 = (int) D.29204;
      D.29213 = mono_metadata_get_generic_inst (D.29212, args);
      ctx->class_inst = D.29213;
      <D.29203>:
      D.29214 = BIT_FIELD_REF <*method, 8, 168>;
      D.29215 = D.29214 & 8;
      if (D.29215 != 0) goto <D.29216>; else goto <D.29217>;
      <D.29216>:
      container = mono_method_get_generic_container (method);
      shared_context = container->context;
      inst = shared_context.method_inst;
      D.29204 = inst->type_argc;
      D.29205 = (unsigned int) D.29204;
      D.29206 = D.29205 * 4;
      args = monoeg_malloc0 (D.29206);
      i = 0;
      goto <D.24319>;
      <D.24318>:
      {
        struct MonoGenericParamInfo * info;
        gboolean ref_only;

        D.29218 = container->type_params;
        i.120 = (unsigned int) i;
        D.29219 = i.120 * 32;
        D.29220 = D.29218 + D.29219;
        info = &D.29220->info;
        ref_only = 0;
        if (info != 0B) goto <D.29221>; else goto <D.29222>;
        <D.29221>:
        D.29223 = info->constraints;
        if (D.29223 != 0B) goto <D.29224>; else goto <D.29225>;
        <D.29224>:
        constraints = info->constraints;
        goto <D.24316>;
        <D.24315>:
        {
          struct MonoClass * cklass;

          cklass = *constraints;
          D.29228 = mono_defaults.object_class;
          if (D.29228 != cklass) goto <D.29229>; else goto <D.29230>;
          <D.29229>:
          D.29231 = cklass->image;
          D.29232 = mono_defaults.corlib;
          if (D.29231 != D.29232) goto <D.29226>; else goto <D.29233>;
          <D.29233>:
          {
            size_t __s1_len;
            size_t __s2_len;

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

              __s2 = cklass->name;
              D.29237 = "ValueType";
              D.29238 = MEM[(const unsigned char *)D.29237];
              D.29239 = (int) D.29238;
              D.29240 = *__s2;
              D.29241 = (int) D.29240;
              __result = D.29239 - D.29241;
              {
                D.29242 = __s2_len != 0;
                D.29243 = __result == 0;
                D.29244 = D.29242 & D.29243;
                if (D.29244 != 0) goto <D.29245>; else goto <D.29246>;
                <D.29245>:
                D.29247 = &MEM[(void *)"ValueType" + 1B];
                D.29248 = *D.29247;
                D.29249 = (int) D.29248;
                D.29250 = __s2 + 1;
                D.29251 = *D.29250;
                D.29252 = (int) D.29251;
                __result = D.29249 - D.29252;
                D.29253 = __s2_len > 1;
                D.29243 = __result == 0;
                D.29254 = D.29253 & D.29243;
                if (D.29254 != 0) goto <D.29255>; else goto <D.29256>;
                <D.29255>:
                D.29257 = &MEM[(void *)"ValueType" + 2B];
                D.29258 = *D.29257;
                D.29259 = (int) D.29258;
                D.29260 = __s2 + 2;
                D.29261 = *D.29260;
                D.29262 = (int) D.29261;
                __result = D.29259 - D.29262;
                D.29263 = __s2_len > 2;
                D.29243 = __result == 0;
                D.29264 = D.29263 & D.29243;
                if (D.29264 != 0) goto <D.29265>; else goto <D.29266>;
                <D.29265>:
                D.29267 = &MEM[(void *)"ValueType" + 3B];
                D.29268 = *D.29267;
                D.29269 = (int) D.29268;
                D.29270 = __s2 + 3;
                D.29271 = *D.29270;
                D.29272 = (int) D.29271;
                __result = D.29269 - D.29272;
                <D.29266>:
                <D.29256>:
                <D.29246>:
              }
              D.24313 = __result;
            }
            iftmp.121 = -D.24313;
            goto <D.29273>;
            <D.29236>:
            D.29274 = cklass->name;
            iftmp.121 = __builtin_strcmp (D.29274, "ValueType");
            <D.29273>:
            D.24314 = iftmp.121;
          }
          if (D.24314 != 0) goto <D.29226>; else goto <D.29227>;
          <D.29226>:
          ref_only = 1;
          <D.29227>:
          <D.29230>:
          constraints = constraints + 4;
        }
        <D.24316>:
        D.29275 = *constraints;
        if (D.29275 != 0B) goto <D.24315>; else goto <D.24317>;
        <D.24317>:
        <D.29225>:
        <D.29222>:
        if (ref_only != 0) goto <D.29276>; else goto <D.29277>;
        <D.29276>:
        i.120 = (unsigned int) i;
        D.29208 = i.120 * 4;
        D.29209 = args + D.29208;
        D.29228 = mono_defaults.object_class;
        D.29278 = &D.29228->byval_arg;
        *D.29209 = D.29278;
        goto <D.29279>;
        <D.29277>:
        i.120 = (unsigned int) i;
        D.29208 = i.120 * 4;
        D.29209 = args + D.29208;
        D.29210 = mono_defaults.int_class;
        D.29211 = &D.29210->byval_arg;
        *D.29209 = D.29211;
        <D.29279>:
      }
      i = i + 1;
      <D.24319>:
      D.29280 = container->type_argc;
      D.29281 = (int) D.29280;
      if (D.29281 > i) goto <D.24318>; else goto <D.24320>;
      <D.24320>:
      D.29204 = inst->type_argc;
      D.29212 = (int) D.29204;
      D.29282 = mono_metadata_get_generic_inst (D.29212, args);
      ctx->method_inst = D.29282;
      <D.29217>:
    }
  finally
    {
      shared_context = {CLOBBER};
    }
}


can_marshal_struct (struct MonoClass * klass)
{
  unsigned int D.29283;
  unsigned int D.29284;
  gboolean D.29287;
  struct MonoType * D.29288;
  short unsigned int D.29289;
  int D.29290;
  int D.29291;
  unsigned char D.29294;
  int D.29295;
  struct MonoClass * D.29296;
  unsigned char D.29297;
  unsigned char D.29298;
  struct MonoClass * D.29301;
  int D.29302;
  struct MonoClassField * D.29307;
  struct MonoMarshalSpec * D.29310;
  unsigned int i.122;
  unsigned int D.29314;
  int D.24279;
  int iftmp.123;
  int D.24278;
  const char[43] * D.29320;
  unsigned char D.29321;
  int D.29322;
  unsigned char D.29323;
  int D.29324;
  _Bool D.29325;
  _Bool D.29326;
  _Bool D.29327;
  const unsigned char * D.29330;
  unsigned char D.29331;
  int D.29332;
  const unsigned char * D.29333;
  unsigned char D.29334;
  int D.29335;
  _Bool D.29336;
  _Bool D.29337;
  const unsigned char * D.29340;
  unsigned char D.29341;
  int D.29342;
  const unsigned char * D.29343;
  unsigned char D.29344;
  int D.29345;
  _Bool D.29346;
  _Bool D.29347;
  const unsigned char * D.29350;
  unsigned char D.29351;
  int D.29352;
  const unsigned char * D.29353;
  unsigned char D.29354;
  int D.29355;
  const char * D.29357;
  int D.24288;
  int iftmp.124;
  int D.24287;
  const char[12] * D.29363;
  unsigned char D.29364;
  int D.29365;
  unsigned char D.29366;
  int D.29367;
  _Bool D.29368;
  _Bool D.29369;
  _Bool D.29370;
  const unsigned char * D.29373;
  unsigned char D.29374;
  int D.29375;
  const unsigned char * D.29376;
  unsigned char D.29377;
  int D.29378;
  _Bool D.29379;
  _Bool D.29380;
  const unsigned char * D.29383;
  unsigned char D.29384;
  int D.29385;
  const unsigned char * D.29386;
  unsigned char D.29387;
  int D.29388;
  _Bool D.29389;
  _Bool D.29390;
  const unsigned char * D.29393;
  unsigned char D.29394;
  int D.29395;
  const unsigned char * D.29396;
  unsigned char D.29397;
  int D.29398;
  const char * D.29400;
  struct MonoClassField * field;
  gboolean can_marshal;
  void * iter;
  struct MonoMarshalType * info;
  int i;

  try
    {
      can_marshal = 1;
      iter = 0B;
      D.29283 = klass->flags;
      D.29284 = D.29283 & 24;
      if (D.29284 == 0) goto <D.29285>; else goto <D.29286>;
      <D.29285>:
      D.29287 = 0;
      return D.29287;
      <D.29286>:
      info = mono_marshal_load_type_info (klass);
      goto <D.24244>;
      <D.24269>:
      D.29288 = field->type;
      D.29289 = D.29288->attrs;
      D.29290 = (int) D.29289;
      D.29291 = D.29290 & 16;
      if (D.29291 != 0) goto <D.29292>; else goto <D.29293>;
      <D.29292>:
      // predicted unlikely by continue predictor.
      goto <D.24244>;
      <D.29293>:
      D.29288 = field->type;
      D.29294 = D.29288->type;
      D.29295 = (int) D.29294;
      switch (D.29295) <default: <D.24268>, case 2: <D.24249>, case 3: <D.24252>, case 4: <D.24247>, case 5: <D.24248>, case 6: <D.24250>, case 7: <D.24251>, case 8: <D.24245>, case 9: <D.24246>, case 10: <D.24253>, case 11: <D.24254>, case 12: <D.24258>, case 13: <D.24259>, case 14: <D.24260>, case 15: <D.24257>, case 17: <D.24262>, case 24: <D.24255>, case 25: <D.24256>, case 29: <D.24263>>
      <D.24245>:
      <D.24246>:
      <D.24247>:
      <D.24248>:
      <D.24249>:
      <D.24250>:
      <D.24251>:
      <D.24252>:
      <D.24253>:
      <D.24254>:
      <D.24255>:
      <D.24256>:
      <D.24257>:
      <D.24258>:
      <D.24259>:
      <D.24260>:
      goto <D.24261>;
      <D.24262>:
      D.29288 = field->type;
      D.29296 = mono_class_from_mono_type (D.29288);
      D.29297 = BIT_FIELD_REF <*D.29296, 8, 160>;
      D.29298 = D.29297 & 16;
      if (D.29298 == 0) goto <D.29299>; else goto <D.29300>;
      <D.29299>:
      D.29288 = field->type;
      D.29301 = mono_class_from_mono_type (D.29288);
      D.29302 = can_marshal_struct (D.29301);
      if (D.29302 == 0) goto <D.29303>; else goto <D.29304>;
      <D.29303>:
      can_marshal = 0;
      <D.29304>:
      <D.29300>:
      goto <D.24261>;
      <D.24263>:
      {
        gboolean has_mspec;

        has_mspec = 0;
        if (info != 0B) goto <D.29305>; else goto <D.29306>;
        <D.29305>:
        i = 0;
        goto <D.24266>;
        <D.24265>:
        D.29307 = info->fields[i].field;
        if (D.29307 == field) goto <D.29308>; else goto <D.29309>;
        <D.29308>:
        D.29310 = info->fields[i].mspec;
        if (D.29310 != 0B) goto <D.29311>; else goto <D.29312>;
        <D.29311>:
        has_mspec = 1;
        <D.29312>:
        <D.29309>:
        i = i + 1;
        <D.24266>:
        i.122 = (unsigned int) i;
        D.29314 = info->num_fields;
        if (i.122 < D.29314) goto <D.24265>; else goto <D.24267>;
        <D.24267>:
        <D.29306>:
        if (has_mspec == 0) goto <D.29315>; else goto <D.29316>;
        <D.29315>:
        can_marshal = 0;
        <D.29316>:
        goto <D.24261>;
      }
      <D.24268>:
      can_marshal = 0;
      goto <D.24261>;
      <D.24261>:
      <D.24244>:
      field = mono_class_get_fields (klass, &iter);
      if (field != 0B) goto <D.24269>; else goto <D.24270>;
      <D.24270>:
      {
        size_t __s1_len;
        size_t __s2_len;

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

          __s2 = klass->name_space;
          D.29320 = "System.Net.NetworkInformation.MacOsStructs";
          D.29321 = MEM[(const unsigned char *)D.29320];
          D.29322 = (int) D.29321;
          D.29323 = *__s2;
          D.29324 = (int) D.29323;
          __result = D.29322 - D.29324;
          {
            D.29325 = __s2_len != 0;
            D.29326 = __result == 0;
            D.29327 = D.29325 & D.29326;
            if (D.29327 != 0) goto <D.29328>; else goto <D.29329>;
            <D.29328>:
            D.29330 = &MEM[(void *)"System.Net.NetworkInformation.MacOsStructs" + 1B];
            D.29331 = *D.29330;
            D.29332 = (int) D.29331;
            D.29333 = __s2 + 1;
            D.29334 = *D.29333;
            D.29335 = (int) D.29334;
            __result = D.29332 - D.29335;
            D.29336 = __s2_len > 1;
            D.29326 = __result == 0;
            D.29337 = D.29336 & D.29326;
            if (D.29337 != 0) goto <D.29338>; else goto <D.29339>;
            <D.29338>:
            D.29340 = &MEM[(void *)"System.Net.NetworkInformation.MacOsStructs" + 2B];
            D.29341 = *D.29340;
            D.29342 = (int) D.29341;
            D.29343 = __s2 + 2;
            D.29344 = *D.29343;
            D.29345 = (int) D.29344;
            __result = D.29342 - D.29345;
            D.29346 = __s2_len > 2;
            D.29326 = __result == 0;
            D.29347 = D.29346 & D.29326;
            if (D.29347 != 0) goto <D.29348>; else goto <D.29349>;
            <D.29348>:
            D.29350 = &MEM[(void *)"System.Net.NetworkInformation.MacOsStructs" + 3B];
            D.29351 = *D.29350;
            D.29352 = (int) D.29351;
            D.29353 = __s2 + 3;
            D.29354 = *D.29353;
            D.29355 = (int) D.29354;
            __result = D.29352 - D.29355;
            <D.29349>:
            <D.29339>:
            <D.29329>:
          }
          D.24278 = __result;
        }
        iftmp.123 = -D.24278;
        goto <D.29356>;
        <D.29319>:
        D.29357 = klass->name_space;
        iftmp.123 = __builtin_strcmp (D.29357, "System.Net.NetworkInformation.MacOsStructs");
        <D.29356>:
        D.24279 = iftmp.123;
      }
      if (D.24279 == 0) goto <D.29358>; else goto <D.29359>;
      <D.29358>:
      {
        size_t __s1_len;
        size_t __s2_len;

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

          __s2 = klass->name;
          D.29363 = "sockaddr_dl";
          D.29364 = MEM[(const unsigned char *)D.29363];
          D.29365 = (int) D.29364;
          D.29366 = *__s2;
          D.29367 = (int) D.29366;
          __result = D.29365 - D.29367;
          {
            D.29368 = __s2_len != 0;
            D.29369 = __result == 0;
            D.29370 = D.29368 & D.29369;
            if (D.29370 != 0) goto <D.29371>; else goto <D.29372>;
            <D.29371>:
            D.29373 = &MEM[(void *)"sockaddr_dl" + 1B];
            D.29374 = *D.29373;
            D.29375 = (int) D.29374;
            D.29376 = __s2 + 1;
            D.29377 = *D.29376;
            D.29378 = (int) D.29377;
            __result = D.29375 - D.29378;
            D.29379 = __s2_len > 1;
            D.29369 = __result == 0;
            D.29380 = D.29379 & D.29369;
            if (D.29380 != 0) goto <D.29381>; else goto <D.29382>;
            <D.29381>:
            D.29383 = &MEM[(void *)"sockaddr_dl" + 2B];
            D.29384 = *D.29383;
            D.29385 = (int) D.29384;
            D.29386 = __s2 + 2;
            D.29387 = *D.29386;
            D.29388 = (int) D.29387;
            __result = D.29385 - D.29388;
            D.29389 = __s2_len > 2;
            D.29369 = __result == 0;
            D.29390 = D.29389 & D.29369;
            if (D.29390 != 0) goto <D.29391>; else goto <D.29392>;
            <D.29391>:
            D.29393 = &MEM[(void *)"sockaddr_dl" + 3B];
            D.29394 = *D.29393;
            D.29395 = (int) D.29394;
            D.29396 = __s2 + 3;
            D.29397 = *D.29396;
            D.29398 = (int) D.29397;
            __result = D.29395 - D.29398;
            <D.29392>:
            <D.29382>:
            <D.29372>:
          }
          D.24287 = __result;
        }
        iftmp.124 = -D.24287;
        goto <D.29399>;
        <D.29362>:
        D.29400 = klass->name;
        iftmp.124 = __builtin_strcmp (D.29400, "sockaddr_dl");
        <D.29399>:
        D.24288 = iftmp.124;
      }
      if (D.24288 != 0) goto <D.29401>; else goto <D.29402>;
      <D.29401>:
      D.29287 = 1;
      return D.29287;
      <D.29402>:
      <D.29359>:
      D.29287 = can_marshal;
      return D.29287;
    }
  finally
    {
      iter = {CLOBBER};
    }
}


compile_methods (struct MonoAotCompile * acfg)
{
  int D.29406;
  struct GPtrArray * D.29409;
  unsigned int D.29410;
  unsigned int D.29411;
  unsigned int D.29412;
  _Bool D.29413;
  long int D.29414;
  long int D.29415;
  unsigned int methods_len.125;
  unsigned int D.29419;
  unsigned int i.126;
  unsigned int D.29421;
  struct MonoMethod * * D.29422;
  void * * D.29423;
  void * * D.29424;
  void * D.29425;
  struct MonoMethod * D.29428;
  struct MonoDomain * D.29429;
  void * * D.29430;
  void * * D.29431;
  void * * D.29432;
  void * * D.29433;
  void * D.29434;
  unsigned int i.127;
  unsigned int D.29436;
  int i;
  int methods_len;

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

    D.29409 = acfg->methods;
    D.29410 = D.29409->len;
    methods_len = (int) D.29410;
    D.29409 = acfg->methods;
    D.29410 = D.29409->len;
    D.29406 = acfg->aot_opts.nthreads;
    D.29411 = (unsigned int) D.29406;
    D.29412 = D.29410 / D.29411;
    len = (int) D.29412;
    D.29413 = len <= 0;
    D.29414 = (long int) D.29413;
    D.29415 = __builtin_expect (D.29414, 0);
    if (D.29415 != 0) goto <D.29416>; else goto <D.29417>;
    <D.29416>:
    monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "aot-compiler.c", 8377, "len > 0");
    <D.29417>:
    threads = monoeg_g_ptr_array_new ();
    methods_len.125 = (unsigned int) methods_len;
    D.29419 = methods_len.125 * 4;
    methods = monoeg_malloc0 (D.29419);
    i = 0;
    goto <D.26043>;
    <D.26042>:
    i.126 = (unsigned int) i;
    D.29421 = i.126 * 4;
    D.29422 = methods + D.29421;
    D.29409 = acfg->methods;
    D.29423 = D.29409->pdata;
    i.126 = (unsigned int) i;
    D.29421 = i.126 * 4;
    D.29424 = D.29423 + D.29421;
    D.29425 = *D.29424;
    *D.29422 = D.29425;
    i = i + 1;
    <D.26043>:
    if (i < methods_len) goto <D.26042>; else goto <D.26044>;
    <D.26044>:
    i = 0;
    goto <D.26049>;
    <D.26048>:
    frag = monoeg_g_ptr_array_new ();
    j = 0;
    goto <D.26046>;
    <D.26045>:
    if (i < methods_len) goto <D.29426>; else goto <D.29427>;
    <D.29426>:
    i.126 = (unsigned int) i;
    D.29421 = i.126 * 4;
    D.29422 = methods + D.29421;
    D.29428 = *D.29422;
    monoeg_g_ptr_array_add (frag, D.29428);
    i = i + 1;
    <D.29427>:
    j = j + 1;
    <D.26046>:
    if (j < len) goto <D.26045>; else goto <D.26047>;
    <D.26047>:
    user_data = monoeg_malloc0 (12);
    D.29429 = mono_domain_get ();
    *user_data = D.29429;
    D.29430 = user_data + 4;
    *D.29430 = acfg;
    D.29431 = user_data + 8;
    *D.29431 = frag;
    handle = mono_threads_create_thread (compile_thread_main, user_data, 0, 0, 0B);
    monoeg_g_ptr_array_add (threads, handle);
    <D.26049>:
    if (i < methods_len) goto <D.26048>; else goto <D.26050>;
    <D.26050>:
    monoeg_g_free (methods);
    i = 0;
    goto <D.26052>;
    <D.26051>:
    D.29432 = threads->pdata;
    i.126 = (unsigned int) i;
    D.29421 = i.126 * 4;
    D.29433 = D.29432 + D.29421;
    D.29434 = *D.29433;
    WaitForSingleObjectEx (D.29434, 4294967295, 0);
    i = i + 1;
    <D.26052>:
    i.127 = (unsigned int) i;
    D.29436 = threads->len;
    if (i.127 < D.29436) goto <D.26051>; else goto <D.26053>;
    <D.26053>:
  }
  goto <D.29437>;
  <D.29408>:
  methods_len = 0;
  <D.29437>:
  i = methods_len;
  goto <D.26055>;
  <D.26054>:
  D.29409 = acfg->methods;
  D.29423 = D.29409->pdata;
  i.126 = (unsigned int) i;
  D.29421 = i.126 * 4;
  D.29424 = D.29423 + D.29421;
  D.29425 = *D.29424;
  compile_method (acfg, D.29425);
  i = i + 1;
  <D.26055>:
  i.127 = (unsigned int) i;
  D.29409 = acfg->methods;
  D.29410 = D.29409->len;
  if (i.127 < D.29410) goto <D.26054>; else goto <D.26056>;
  <D.26056>:
}


compile_thread_main (void * * user_data)
{
  void * * D.29438;
  unsigned int i.128;
  unsigned int D.29440;
  void * * D.29441;
  void * D.29442;
  unsigned int i.129;
  unsigned int D.29444;
  struct MonoDomain * domain;
  struct MonoAotCompile * acfg;
  struct GPtrArray * methods;
  int i;

  domain = *user_data;
  acfg = MEM[(void * *)user_data + 4B];
  methods = MEM[(void * *)user_data + 8B];
  mono_thread_attach (domain);
  i = 0;
  goto <D.25605>;
  <D.25604>:
  D.29438 = methods->pdata;
  i.128 = (unsigned int) i;
  D.29440 = i.128 * 4;
  D.29441 = D.29438 + D.29440;
  D.29442 = *D.29441;
  compile_method (acfg, D.29442);
  i = i + 1;
  <D.25605>:
  i.129 = (unsigned int) i;
  D.29444 = methods->len;
  if (i.129 < D.29444) goto <D.25604>; else goto <D.25606>;
  <D.25606>:
}


compile_method (struct MonoAotCompile * acfg, struct MonoMethod * method)
{
  int D.29445;
  union mono_mutex_t * D.29448;
  _Bool D.29451;
  long int D.29452;
  long int D.29453;
  unsigned int D.29456;
  _Bool D.29459;
  long int D.29460;
  long int D.29461;
  short unsigned int D.29466;
  int D.29467;
  int D.29468;
  short unsigned int D.29470;
  int D.29471;
  int D.29472;
  int D.29474;
  int D.29475;
  short unsigned int D.29480;
  int D.29481;
  int D.29482;
  unsigned char D.29485;
  unsigned char D.29486;
  unsigned char D.29489;
  unsigned char D.29490;
  int * D.29493;
  JitFlags iftmp.130;
  int D.29495;
  struct MonoDomain * D.29499;
  unsigned int D.29500;
  unsigned int D.29501;
  int D.29504;
  char * D.29507;
  char * D.29508;
  int * D.29509;
  char * D.29514;
  unsigned char D.29515;
  unsigned char D.29516;
  char * D.29521;
  int * D.29522;
  unsigned int index.131;
  <unnamed type> D.29524;
  _Bool D.29527;
  long int D.29528;
  long int D.29529;
  struct GHashTable * D.29532;
  _Bool D.29535;
  long int D.29536;
  long int D.29537;
  char * D.29544;
  int * D.29545;
  _Bool D.29548;
  long int D.29549;
  long int D.29550;
  int D.29553;
  char * D.29560;
  int D.29561;
  int D.29562;
  _Bool D.29565;
  long int D.29566;
  long int D.29567;
  struct GHashTable * D.29570;
  void * D.29571;
  int D.29572;
  unsigned char D.29577;
  unsigned char D.29578;
  struct MonoClass * D.29583;
  int D.29584;
  int D.29586;
  int D.29587;
  short unsigned int D.29590;
  int D.29591;
  int D.29592;
  int D.29597;
  struct MonoMethod * D.29598;
  int D.29600;
  unsigned char D.29601;
  unsigned char D.29602;
  int D.25549;
  int iftmp.132;
  int D.25548;
  const char[12] * D.29608;
  unsigned char D.29609;
  int D.29610;
  unsigned char D.29611;
  int D.29612;
  _Bool D.29613;
  _Bool D.29614;
  _Bool D.29615;
  const unsigned char * D.29618;
  unsigned char D.29619;
  int D.29620;
  const unsigned char * D.29621;
  unsigned char D.29622;
  int D.29623;
  _Bool D.29624;
  _Bool D.29625;
  const unsigned char * D.29628;
  unsigned char D.29629;
  int D.29630;
  const unsigned char * D.29631;
  unsigned char D.29632;
  int D.29633;
  _Bool D.29634;
  _Bool D.29635;
  const unsigned char * D.29638;
  unsigned char D.29639;
  int D.29640;
  const unsigned char * D.29641;
  unsigned char D.29642;
  int D.29643;
  const char * D.29645;
  struct MonoGenericClass * D.29648;
  int D.29651;
  struct MonoClassField * D.29654;
  struct MonoGenericClass * D.29655;
  struct MonoGenericContext * D.29658;
  int D.29659;
  struct MonoMethod * D.29662;
  struct MonoMethod * D.29665;
  struct MonoImage * D.29666;
  struct MonoImage * D.29667;
  int D.29670;
  unsigned char D.29673;
  unsigned char D.29674;
  int * D.29677;
  struct MonoMemPool * D.29678;
  void * D.29682;
  struct GSList * D.29683;
  short unsigned int D.29684;
  int D.29685;
  <unnamed-unsigned:1> D.29686;
  int D.29687;
  int D.29688;
  unsigned int D.29689;
  unsigned int D.29690;
  unsigned int i.133;
  unsigned int D.29692;
  struct MonoInst * * D.29693;
  void * D.29694;
  struct MonoInst * * D.29695;
  struct MonoInst * * D.29696;
  struct MonoInst * D.29697;
  struct MonoInst * D.29698;
  short unsigned int D.29699;
  unsigned int D.29700;
  unsigned int D.29701;
  struct MonoInst * * D.29702;
  void * D.29703;
  struct MonoInst * * D.29704;
  struct MonoInst * * D.29705;
  struct MonoInst * D.29706;
  struct MonoInst * D.29707;
  int D.29708;
  struct MonoMemPool * D.29709;
  struct MonoInst * * D.29710;
  struct MonoMethodVar * D.29711;
  struct MonoRegState * D.29712;
  int D.29715;
  unsigned int new_size.134;
  unsigned int D.29717;
  unsigned int D.29718;
  unsigned int D.29719;
  struct MonoCompile * * D.29720;
  unsigned int index.135;
  unsigned int D.29722;
  struct MonoCompile * * D.29723;
  struct MonoMethod * D.29724;
  struct GHashTable * D.29725;
  _Bool D.29728;
  long int D.29729;
  long int D.29730;
  int * D.29733;
  struct MonoCompile * cfg;
  struct MonoJumpInfo * patch_info;
  gboolean skip;
  int index;
  int depth;
  struct MonoMethod * wrapped;

  D.29445 = acfg->aot_opts.metadata_only;
  if (D.29445 != 0) goto <D.29446>; else goto <D.29447>;
  <D.29446>:
  return;
  <D.29447>:
  {
    int ret;

    D.29448 = &acfg->mutex.mutex;
    ret = pthread_mutex_lock (D.29448);
    if (ret != 0) goto <D.29449>; else goto <D.29450>;
    <D.29449>:
    monoeg_g_log (0B, 16, "Bad call to mono_mutex_lock result %d", ret);
    <D.29450>:
    D.29451 = ret != 0;
    D.29452 = (long int) D.29451;
    D.29453 = __builtin_expect (D.29452, 0);
    if (D.29453 != 0) goto <D.29454>; else goto <D.29455>;
    <D.29454>:
    monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "aot-compiler.c", 6458, "ret == 0");
    <D.29455>:
  }
  D.29456 = get_method_index (acfg, method);
  index = (int) D.29456;
  {
    int ret;

    D.29448 = &acfg->mutex.mutex;
    ret = pthread_mutex_unlock (D.29448);
    if (ret != 0) goto <D.29457>; else goto <D.29458>;
    <D.29457>:
    monoeg_g_log (0B, 16, "Bad call to mono_mutex_unlock result %d", ret);
    <D.29458>:
    D.29459 = ret != 0;
    D.29460 = (long int) D.29459;
    D.29461 = __builtin_expect (D.29460, 0);
    if (D.29461 != 0) goto <D.29462>; else goto <D.29463>;
    <D.29462>:
    monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "aot-compiler.c", 6460, "ret == 0");
    <D.29463>:
  }
  D.29466 = method->flags;
  D.29467 = (int) D.29466;
  D.29468 = D.29467 & 8192;
  if (D.29468 != 0) goto <D.29464>; else goto <D.29469>;
  <D.29469>:
  D.29470 = method->iflags;
  D.29471 = (int) D.29470;
  D.29472 = D.29471 & 3;
  if (D.29472 != 0) goto <D.29464>; else goto <D.29473>;
  <D.29473>:
  D.29466 = method->flags;
  D.29467 = (int) D.29466;
  D.29474 = D.29467 & 1024;
  if (D.29474 != 0) goto <D.29464>; else goto <D.29465>;
  <D.29464>:
  return;
  <D.29465>:
  D.29470 = method->iflags;
  D.29471 = (int) D.29470;
  D.29475 = D.29471 & 4096;
  if (D.29475 != 0) goto <D.29476>; else goto <D.29477>;
  <D.29476>:
  return;
  <D.29477>:
  wrapped = mono_marshal_method_from_wrapper (method);
  if (wrapped != 0B) goto <D.29478>; else goto <D.29479>;
  <D.29478>:
  D.29480 = wrapped->iflags;
  D.29481 = (int) D.29480;
  D.29482 = D.29481 & 4096;
  if (D.29482 != 0) goto <D.29483>; else goto <D.29484>;
  <D.29483>:
  D.29485 = BIT_FIELD_REF <*wrapped, 8, 168>;
  D.29486 = D.29485 & 8;
  if (D.29486 != 0) goto <D.29487>; else goto <D.29488>;
  <D.29487>:
  return;
  <D.29488>:
  <D.29484>:
  <D.29479>:
  D.29489 = BIT_FIELD_REF <*method, 8, 160>;
  D.29490 = D.29489 & 124;
  if (D.29490 == 108) goto <D.29491>; else goto <D.29492>;
  <D.29491>:
  return;
  <D.29492>:
  D.29493 = &acfg->stats.mcount;
  InterlockedIncrement (D.29493);
  D.29495 = acfg->aot_opts.full_aot;
  if (D.29495 != 0) goto <D.29496>; else goto <D.29497>;
  <D.29496>:
  iftmp.130 = 6;
  goto <D.29498>;
  <D.29497>:
  iftmp.130 = 2;
  <D.29498>:
  D.29499 = mono_get_root_domain ();
  D.29500 = acfg->opts;
  cfg = mini_method_compile (method, D.29500, D.29499, iftmp.130, 0);
  mono_loader_clear_error ();
  D.29501 = cfg->exception_type;
  if (D.29501 == 11) goto <D.29502>; else goto <D.29503>;
  <D.29502>:
  D.29504 = acfg->aot_opts.print_skipped_methods;
  if (D.29504 != 0) goto <D.29505>; else goto <D.29506>;
  <D.29505>:
  D.29507 = cfg->exception_message;
  D.29508 = mono_method_full_name (method, 1);
  printf ("Skip (gshared failure): %s (%s)\n", D.29508, D.29507);
  <D.29506>:
  D.29509 = &acfg->stats.genericcount;
  InterlockedIncrement (D.29509);
  return;
  <D.29503>:
  D.29501 = cfg->exception_type;
  if (D.29501 != 0) goto <D.29510>; else goto <D.29511>;
  <D.29510>:
  D.29504 = acfg->aot_opts.print_skipped_methods;
  if (D.29504 != 0) goto <D.29512>; else goto <D.29513>;
  <D.29512>:
  D.29514 = mono_method_full_name (method, 1);
  printf ("Skip (JIT failure): %s\n", D.29514);
  <D.29513>:
  return;
  <D.29511>:
  D.29515 = BIT_FIELD_REF <*cfg, 8, 3392>;
  D.29516 = D.29515 & 1;
  if (D.29516 != 0) goto <D.29517>; else goto <D.29518>;
  <D.29517>:
  D.29504 = acfg->aot_opts.print_skipped_methods;
  if (D.29504 != 0) goto <D.29519>; else goto <D.29520>;
  <D.29519>:
  D.29521 = mono_method_full_name (method, 1);
  printf ("Skip (disabled): %s\n", D.29521);
  <D.29520>:
  D.29522 = &acfg->stats.ocount;
  InterlockedIncrement (D.29522);
  mono_destroy_compile (cfg);
  return;
  <D.29518>:
  index.131 = (unsigned int) index;
  cfg->method_index = index.131;
  patch_info = cfg->patch_info;
  goto <D.25524>;
  <D.25523>:
  D.29524 = patch_info->type;
  switch (D.29524) <default: <D.25522>, case 0: <D.25520>, case 2: <D.25519>>
  <D.25519>:
  <D.25520>:
  patch_info->type = 51;
  goto <D.25521>;
  <D.25522>:
  goto <D.25521>;
  <D.25521>:
  patch_info = patch_info->next;
  <D.25524>:
  if (patch_info != 0B) goto <D.25523>; else goto <D.25525>;
  <D.25525>:
  {
    int ret;

    D.29448 = &acfg->mutex.mutex;
    ret = pthread_mutex_lock (D.29448);
    if (ret != 0) goto <D.29525>; else goto <D.29526>;
    <D.29525>:
    monoeg_g_log (0B, 16, "Bad call to mono_mutex_lock result %d", ret);
    <D.29526>:
    D.29527 = ret != 0;
    D.29528 = (long int) D.29527;
    D.29529 = __builtin_expect (D.29528, 0);
    if (D.29529 != 0) goto <D.29530>; else goto <D.29531>;
    <D.29530>:
    monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "aot-compiler.c", 6536, "ret == 0");
    <D.29531>:
  }
  D.29532 = cfg->token_info_hash;
  monoeg_g_hash_table_foreach (D.29532, add_token_info_hash, acfg);
  {
    int ret;

    D.29448 = &acfg->mutex.mutex;
    ret = pthread_mutex_unlock (D.29448);
    if (ret != 0) goto <D.29533>; else goto <D.29534>;
    <D.29533>:
    monoeg_g_log (0B, 16, "Bad call to mono_mutex_unlock result %d", ret);
    <D.29534>:
    D.29535 = ret != 0;
    D.29536 = (long int) D.29535;
    D.29537 = __builtin_expect (D.29536, 0);
    if (D.29537 != 0) goto <D.29538>; else goto <D.29539>;
    <D.29538>:
    monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "aot-compiler.c", 6538, "ret == 0");
    <D.29539>:
  }
  skip = 0;
  patch_info = cfg->patch_info;
  goto <D.25532>;
  <D.25531>:
  D.29524 = patch_info->type;
  switch (D.29524) <default: <D.25530>, case 1: <D.25528>>
  <D.25528>:
  skip = 1;
  goto <D.25529>;
  <D.25530>:
  goto <D.25529>;
  <D.25529>:
  patch_info = patch_info->next;
  <D.25532>:
  if (patch_info != 0B) goto <D.25531>; else goto <D.25533>;
  <D.25533>:
  if (skip != 0) goto <D.29540>; else goto <D.29541>;
  <D.29540>:
  D.29504 = acfg->aot_opts.print_skipped_methods;
  if (D.29504 != 0) goto <D.29542>; else goto <D.29543>;
  <D.29542>:
  D.29544 = mono_method_full_name (method, 1);
  printf ("Skip (abs call): %s\n", D.29544);
  <D.29543>:
  D.29545 = &acfg->stats.abscount;
  InterlockedIncrement (D.29545);
  mono_destroy_compile (cfg);
  return;
  <D.29541>:
  {
    int ret;

    D.29448 = &acfg->mutex.mutex;
    ret = pthread_mutex_lock (D.29448);
    if (ret != 0) goto <D.29546>; else goto <D.29547>;
    <D.29546>:
    monoeg_g_log (0B, 16, "Bad call to mono_mutex_lock result %d", ret);
    <D.29547>:
    D.29548 = ret != 0;
    D.29549 = (long int) D.29548;
    D.29550 = __builtin_expect (D.29549, 0);
    if (D.29550 != 0) goto <D.29551>; else goto <D.29552>;
    <D.29551>:
    monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "aot-compiler.c", 6564, "ret == 0");
    <D.29552>:
  }
  skip = 0;
  patch_info = cfg->patch_info;
  goto <D.25536>;
  <D.25535>:
  D.29553 = can_encode_patch (acfg, patch_info);
  if (D.29553 == 0) goto <D.29554>; else goto <D.29555>;
  <D.29554>:
  skip = 1;
  <D.29555>:
  patch_info = patch_info->next;
  <D.25536>:
  if (patch_info != 0B) goto <D.25535>; else goto <D.25537>;
  <D.25537>:
  if (skip != 0) goto <D.29556>; else goto <D.29557>;
  <D.29556>:
  D.29504 = acfg->aot_opts.print_skipped_methods;
  if (D.29504 != 0) goto <D.29558>; else goto <D.29559>;
  <D.29558>:
  D.29560 = mono_method_full_name (method, 1);
  printf ("Skip (patches): %s\n", D.29560);
  <D.29559>:
  D.29561 = acfg->stats.ocount;
  D.29562 = D.29561 + 1;
  acfg->stats.ocount = D.29562;
  mono_destroy_compile (cfg);
  {
    int ret;

    D.29448 = &acfg->mutex.mutex;
    ret = pthread_mutex_unlock (D.29448);
    if (ret != 0) goto <D.29563>; else goto <D.29564>;
    <D.29563>:
    monoeg_g_log (0B, 16, "Bad call to mono_mutex_unlock result %d", ret);
    <D.29564>:
    D.29565 = ret != 0;
    D.29566 = (long int) D.29565;
    D.29567 = __builtin_expect (D.29566, 0);
    if (D.29567 != 0) goto <D.29568>; else goto <D.29569>;
    <D.29568>:
    monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "aot-compiler.c", 6580, "ret == 0");
    <D.29569>:
  }
  return;
  <D.29557>:
  D.29570 = acfg->method_depth;
  D.29571 = monoeg_g_hash_table_lookup (D.29570, method);
  depth = (int) D.29571;
  D.29572 = acfg->aot_opts.no_instances;
  if (D.29572 == 0) goto <D.29573>; else goto <D.29574>;
  <D.29573>:
  if (depth <= 31) goto <D.29575>; else goto <D.29576>;
  <D.29575>:
  patch_info = cfg->patch_info;
  goto <D.25557>;
  <D.25556>:
  D.29524 = patch_info->type;
  switch (D.29524) <default: <D.25555>, case 3: <D.25539>, case 14: <D.25551>, case 16: <D.25553>>
  <D.25539>:
  {
    struct MonoMethod * m;

    m = patch_info->data.method;
    D.29577 = BIT_FIELD_REF <*m, 8, 168>;
    D.29578 = D.29577 & 16;
    if (D.29578 != 0) goto <D.29579>; else goto <D.29580>;
    <D.29579>:
    D.29583 = m->klass;
    D.29584 = mono_class_generic_sharing_enabled (D.29583);
    if (D.29584 == 0) goto <D.29581>; else goto <D.29585>;
    <D.29585>:
    D.29586 = mono_method_is_generic_sharable_full (m, 0, 0, 0);
    if (D.29586 == 0) goto <D.29581>; else goto <D.29582>;
    <D.29581>:
    D.29587 = method_has_type_vars (m);
    if (D.29587 == 0) goto <D.29588>; else goto <D.29589>;
    <D.29588>:
    D.29590 = m->iflags;
    D.29591 = (int) D.29590;
    D.29592 = D.29591 & 4096;
    if (D.29592 != 0) goto <D.29593>; else goto <D.29594>;
    <D.29593>:
    D.29495 = acfg->aot_opts.full_aot;
    if (D.29495 != 0) goto <D.29595>; else goto <D.29596>;
    <D.29595>:
    D.29597 = depth + 1;
    D.29598 = mono_marshal_get_native_wrapper (m, 1, 1);
    add_extra_method_with_depth (acfg, D.29598, D.29597);
    <D.29596>:
    goto <D.29599>;
    <D.29594>:
    D.29597 = depth + 1;
    add_extra_method_with_depth (acfg, m, D.29597);
    add_types_from_method_header (acfg, m);
    <D.29599>:
    <D.29589>:
    <D.29582>:
    D.29600 = depth + 5;
    D.29583 = m->klass;
    add_generic_class_with_depth (acfg, D.29583, D.29600, "method");
    <D.29580>:
    D.29601 = BIT_FIELD_REF <*m, 8, 160>;
    D.29602 = D.29601 & 124;
    if (D.29602 == 28) goto <D.29603>; else goto <D.29604>;
    <D.29603>:
    {
      size_t __s1_len;
      size_t __s2_len;

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

        __s2 = m->name;
        D.29608 = "ElementAddr";
        D.29609 = MEM[(const unsigned char *)D.29608];
        D.29610 = (int) D.29609;
        D.29611 = *__s2;
        D.29612 = (int) D.29611;
        __result = D.29610 - D.29612;
        {
          D.29613 = __s2_len != 0;
          D.29614 = __result == 0;
          D.29615 = D.29613 & D.29614;
          if (D.29615 != 0) goto <D.29616>; else goto <D.29617>;
          <D.29616>:
          D.29618 = &MEM[(void *)"ElementAddr" + 1B];
          D.29619 = *D.29618;
          D.29620 = (int) D.29619;
          D.29621 = __s2 + 1;
          D.29622 = *D.29621;
          D.29623 = (int) D.29622;
          __result = D.29620 - D.29623;
          D.29624 = __s2_len > 1;
          D.29614 = __result == 0;
          D.29625 = D.29624 & D.29614;
          if (D.29625 != 0) goto <D.29626>; else goto <D.29627>;
          <D.29626>:
          D.29628 = &MEM[(void *)"ElementAddr" + 2B];
          D.29629 = *D.29628;
          D.29630 = (int) D.29629;
          D.29631 = __s2 + 2;
          D.29632 = *D.29631;
          D.29633 = (int) D.29632;
          __result = D.29630 - D.29633;
          D.29634 = __s2_len > 2;
          D.29614 = __result == 0;
          D.29635 = D.29634 & D.29614;
          if (D.29635 != 0) goto <D.29636>; else goto <D.29637>;
          <D.29636>:
          D.29638 = &MEM[(void *)"ElementAddr" + 3B];
          D.29639 = *D.29638;
          D.29640 = (int) D.29639;
          D.29641 = __s2 + 3;
          D.29642 = *D.29641;
          D.29643 = (int) D.29642;
          __result = D.29640 - D.29643;
          <D.29637>:
          <D.29627>:
          <D.29617>:
        }
        D.25548 = __result;
      }
      iftmp.132 = -D.25548;
      goto <D.29644>;
      <D.29607>:
      D.29645 = m->name;
      iftmp.132 = __builtin_strcmp (D.29645, "ElementAddr");
      <D.29644>:
      D.25549 = iftmp.132;
    }
    if (D.25549 == 0) goto <D.29646>; else goto <D.29647>;
    <D.29646>:
    D.29597 = depth + 1;
    add_extra_method_with_depth (acfg, m, D.29597);
    <D.29647>:
    <D.29604>:
    goto <D.25550>;
  }
  <D.25551>:
  {
    struct MonoClass * klass;

    klass = patch_info->data.klass;
    D.29648 = klass->generic_class;
    if (D.29648 != 0B) goto <D.29649>; else goto <D.29650>;
    <D.29649>:
    D.29651 = mini_class_is_generic_sharable (klass);
    if (D.29651 == 0) goto <D.29652>; else goto <D.29653>;
    <D.29652>:
    D.29600 = depth + 5;
    add_generic_class_with_depth (acfg, klass, D.29600, "vtable");
    <D.29653>:
    <D.29650>:
    goto <D.25550>;
  }
  <D.25553>:
  {
    struct MonoClass * klass;

    D.29654 = patch_info->data.field;
    klass = D.29654->parent;
    D.29655 = klass->generic_class;
    if (D.29655 != 0B) goto <D.29656>; else goto <D.29657>;
    <D.29656>:
    D.29655 = klass->generic_class;
    D.29658 = &D.29655->context;
    D.29659 = mono_generic_context_is_sharable (D.29658, 0);
    if (D.29659 == 0) goto <D.29660>; else goto <D.29661>;
    <D.29660>:
    D.29662 = mono_class_get_cctor (klass);
    if (D.29662 != 0B) goto <D.29663>; else goto <D.29664>;
    <D.29663>:
    D.29597 = depth + 1;
    D.29665 = mono_class_get_cctor (klass);
    add_extra_method_with_depth (acfg, D.29665, D.29597);
    <D.29664>:
    <D.29661>:
    <D.29657>:
    goto <D.25550>;
  }
  <D.25555>:
  goto <D.25550>;
  <D.25550>:
  patch_info = patch_info->next;
  <D.25557>:
  if (patch_info != 0B) goto <D.25556>; else goto <D.25558>;
  <D.25558>:
  <D.29576>:
  <D.29574>:
  patch_info = cfg->patch_info;
  goto <D.25566>;
  <D.25565>:
  D.29524 = patch_info->type;
  switch (D.29524) <default: <D.25564>, case 12: <D.25563>, case 27: <D.25559>, case 42: <D.25561>, case 51: <D.25560>>
  <D.25559>:
  <D.25560>:
  <D.25561>:
  goto <D.25562>;
  <D.25563>:
  D.29666 = patch_info->data.image;
  D.29667 = acfg->image;
  if (D.29666 != D.29667) goto <D.29668>; else goto <D.29669>;
  <D.29668>:
  cfg->has_got_slots = 1;
  <D.29669>:
  goto <D.25562>;
  <D.25564>:
  D.29670 = is_plt_patch (patch_info);
  if (D.29670 == 0) goto <D.29671>; else goto <D.29672>;
  <D.29671>:
  cfg->has_got_slots = 1;
  <D.29672>:
  goto <D.25562>;
  <D.25562>:
  patch_info = patch_info->next;
  <D.25566>:
  if (patch_info != 0B) goto <D.25565>; else goto <D.25567>;
  <D.25567>:
  D.29673 = BIT_FIELD_REF <*cfg, 8, 3424>;
  D.29674 = D.29673 & 1;
  if (D.29674 == 0) goto <D.29675>; else goto <D.29676>;
  <D.29675>:
  D.29677 = &acfg->stats.methods_without_got_slots;
  InterlockedIncrement (D.29677);
  <D.29676>:
  {
    struct MonoJumpInfo * patches;
    struct MonoJumpInfo * patches_end;

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

      D.29678 = acfg->mempool;
      new_patch_info = mono_patch_info_dup_mp (D.29678, patch_info);
      if (patches == 0B) goto <D.29679>; else goto <D.29680>;
      <D.29679>:
      patches = new_patch_info;
      goto <D.29681>;
      <D.29680>:
      patches_end->next = new_patch_info;
      <D.29681>:
      patches_end = new_patch_info;
    }
    patch_info = patch_info->next;
    <D.25572>:
    if (patch_info != 0B) goto <D.25571>; else goto <D.25573>;
    <D.25573>:
    cfg->patch_info = patches;
  }
  {
    struct GSList * l;
    struct GSList * unwind_ops;
    struct MonoUnwindOp * op;

    unwind_ops = 0B;
    l = cfg->unwind_ops;
    goto <D.25578>;
    <D.25577>:
    D.29678 = acfg->mempool;
    op = mono_mempool_alloc (D.29678, 12);
    D.29682 = l->data;
    memcpy (op, D.29682, 12);
    D.29678 = acfg->mempool;
    unwind_ops = g_slist_prepend_mempool (D.29678, unwind_ops, op);
    l = l->next;
    <D.25578>:
    if (l != 0B) goto <D.25577>; else goto <D.25579>;
    <D.25579>:
    D.29683 = monoeg_g_slist_reverse (unwind_ops);
    cfg->unwind_ops = D.29683;
  }
  {
    struct MonoInst * * args;
    struct MonoInst * * locals;
    struct MonoMethodSignature * sig;
    struct MonoMethodHeader * header;
    int i;

    sig = mono_method_signature (method);
    D.29684 = sig->param_count;
    D.29685 = (int) D.29684;
    D.29686 = sig->hasthis;
    D.29687 = (int) D.29686;
    D.29688 = D.29685 + D.29687;
    D.29689 = (unsigned int) D.29688;
    D.29690 = D.29689 * 4;
    D.29678 = acfg->mempool;
    args = mono_mempool_alloc (D.29678, D.29690);
    i = 0;
    goto <D.25586>;
    <D.25585>:
    i.133 = (unsigned int) i;
    D.29692 = i.133 * 4;
    D.29693 = args + D.29692;
    D.29678 = acfg->mempool;
    D.29694 = mono_mempool_alloc (D.29678, 48);
    *D.29693 = D.29694;
    D.29695 = cfg->args;
    i.133 = (unsigned int) i;
    D.29692 = i.133 * 4;
    D.29696 = D.29695 + D.29692;
    D.29697 = *D.29696;
    i.133 = (unsigned int) i;
    D.29692 = i.133 * 4;
    D.29693 = args + D.29692;
    D.29698 = *D.29693;
    memcpy (D.29698, D.29697, 48);
    i = i + 1;
    <D.25586>:
    D.29684 = sig->param_count;
    D.29685 = (int) D.29684;
    D.29686 = sig->hasthis;
    D.29687 = (int) D.29686;
    D.29688 = D.29685 + D.29687;
    if (D.29688 > i) goto <D.25585>; else goto <D.25587>;
    <D.25587>:
    cfg->args = args;
    header = mono_method_get_header (method);
    D.29699 = header->num_locals;
    D.29700 = (unsigned int) D.29699;
    D.29701 = D.29700 * 4;
    D.29678 = acfg->mempool;
    locals = mono_mempool_alloc (D.29678, D.29701);
    i = 0;
    goto <D.25589>;
    <D.25588>:
    i.133 = (unsigned int) i;
    D.29692 = i.133 * 4;
    D.29702 = locals + D.29692;
    D.29678 = acfg->mempool;
    D.29703 = mono_mempool_alloc (D.29678, 48);
    *D.29702 = D.29703;
    D.29704 = cfg->locals;
    i.133 = (unsigned int) i;
    D.29692 = i.133 * 4;
    D.29705 = D.29704 + D.29692;
    D.29706 = *D.29705;
    i.133 = (unsigned int) i;
    D.29692 = i.133 * 4;
    D.29702 = locals + D.29692;
    D.29707 = *D.29702;
    memcpy (D.29707, D.29706, 48);
    i = i + 1;
    <D.25589>:
    D.29699 = header->num_locals;
    D.29708 = (int) D.29699;
    if (D.29708 > i) goto <D.25588>; else goto <D.25590>;
    <D.25590>:
    cfg->locals = locals;
  }
  D.29709 = cfg->mempool;
  mono_mempool_destroy (D.29709);
  cfg->mempool = 0B;
  D.29710 = cfg->varinfo;
  monoeg_g_free (D.29710);
  cfg->varinfo = 0B;
  D.29711 = cfg->vars;
  monoeg_g_free (D.29711);
  cfg->vars = 0B;
  D.29712 = cfg->rs;
  if (D.29712 != 0B) goto <D.29713>; else goto <D.29714>;
  <D.29713>:
  D.29712 = cfg->rs;
  mono_regstate_free (D.29712);
  cfg->rs = 0B;
  <D.29714>:
  goto <D.25594>;
  <D.25593>:
  {
    struct MonoCompile * * new_cfgs;
    int new_size;

    D.29715 = acfg->cfgs_size;
    new_size = D.29715 * 2;
    new_size.134 = (unsigned int) new_size;
    D.29717 = new_size.134 * 4;
    new_cfgs = monoeg_malloc0 (D.29717);
    D.29715 = acfg->cfgs_size;
    D.29718 = (unsigned int) D.29715;
    D.29719 = D.29718 * 4;
    D.29720 = acfg->cfgs;
    memcpy (new_cfgs, D.29720, D.29719);
    D.29720 = acfg->cfgs;
    monoeg_g_free (D.29720);
    acfg->cfgs = new_cfgs;
    acfg->cfgs_size = new_size;
  }
  <D.25594>:
  D.29715 = acfg->cfgs_size;
  if (D.29715 <= index) goto <D.25593>; else goto <D.25595>;
  <D.25595>:
  D.29720 = acfg->cfgs;
  index.135 = (unsigned int) index;
  D.29722 = index.135 * 4;
  D.29723 = D.29720 + D.29722;
  *D.29723 = cfg;
  D.29724 = cfg->orig_method;
  D.29725 = acfg->method_to_cfg;
  monoeg_g_hash_table_insert_replace (D.29725, D.29724, cfg, 0);
  {
    int ret;

    D.29448 = &acfg->mutex.mutex;
    ret = pthread_mutex_unlock (D.29448);
    if (ret != 0) goto <D.29726>; else goto <D.29727>;
    <D.29726>:
    monoeg_g_log (0B, 16, "Bad call to mono_mutex_unlock result %d", ret);
    <D.29727>:
    D.29728 = ret != 0;
    D.29729 = (long int) D.29728;
    D.29730 = __builtin_expect (D.29729, 0);
    if (D.29730 != 0) goto <D.29731>; else goto <D.29732>;
    <D.29731>:
    monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "aot-compiler.c", 6745, "ret == 0");
    <D.29732>:
  }
  D.29733 = &acfg->stats.ccount;
  InterlockedIncrement (D.29733);
}


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

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


method_has_type_vars (struct MonoMethod * method)
{
  struct MonoClass * D.29742;
  int D.29743;
  gboolean D.29746;
  unsigned char D.29747;
  unsigned char D.29748;
  struct MonoGenericInst * D.29751;
  struct MonoType * D.29754;
  struct MonoClass * D.29755;
  int D.29756;
  <unnamed-unsigned:22> D.29759;
  int D.29760;

  D.29742 = method->klass;
  D.29743 = has_type_vars (D.29742);
  if (D.29743 != 0) goto <D.29744>; else goto <D.29745>;
  <D.29744>:
  D.29746 = 1;
  return D.29746;
  <D.29745>:
  D.29747 = BIT_FIELD_REF <*method, 8, 168>;
  D.29748 = D.29747 & 16;
  if (D.29748 != 0) goto <D.29749>; else goto <D.29750>;
  <D.29749>:
  {
    struct MonoGenericContext * context;

    context = mono_method_get_context (method);
    D.29751 = context->method_inst;
    if (D.29751 != 0B) goto <D.29752>; else goto <D.29753>;
    <D.29752>:
    {
      int i;

      i = 0;
      goto <D.24493>;
      <D.24492>:
      D.29751 = context->method_inst;
      D.29754 = D.29751->type_argv[i];
      D.29755 = mono_class_from_mono_type (D.29754);
      D.29756 = has_type_vars (D.29755);
      if (D.29756 != 0) goto <D.29757>; else goto <D.29758>;
      <D.29757>:
      D.29746 = 1;
      return D.29746;
      <D.29758>:
      i = i + 1;
      <D.24493>:
      D.29751 = context->method_inst;
      D.29759 = D.29751->type_argc;
      D.29760 = (int) D.29759;
      if (D.29760 > i) goto <D.24492>; else goto <D.24494>;
      <D.24494>:
    }
    <D.29753>:
  }
  <D.29750>:
  D.29746 = 0;
  return D.29746;
}


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

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


InterlockedIncrement (volatile gint32 * val)
{
  gint32 D.29764;
  unsigned int D.29765;

  D.29765 = __sync_add_and_fetch_4 (val, 1);
  D.29764 = (gint32) D.29765;
  return D.29764;
}


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

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


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

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


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

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


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

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


emit_code (struct MonoAotCompile * acfg)
{
  int D.29771;
  struct MonoCompile * * D.29774;
  unsigned int i.136;
  unsigned int D.29776;
  struct MonoCompile * * D.29777;
  struct MonoCompile * D.29778;
  unsigned char D.29781;
  unsigned char D.29782;
  char * D.29785;
  gchar * D.29786;
  unsigned int i.137;
  unsigned int D.29788;
  char * D.29789;
  gchar * D.29792;
  struct GPtrArray * D.29793;
  void * * D.29794;
  unsigned int oindex.138;
  unsigned int D.29796;
  void * * D.29797;
  void * D.29798;
  int D.29801;
  struct MonoMethod * D.29804;
  struct MonoClass * D.29805;
  unsigned char D.29806;
  unsigned char D.29807;
  unsigned int D.29810;
  int D.29811;
  unsigned char D.29814;
  unsigned char D.29815;
  struct FILE * D.29818;
  char * D.29819;
  int D.29826;
  int D.29827;
  unsigned int oindex.139;
  unsigned int D.29830;
  int D.29833;
  int D.29840;
  unsigned int D.29841;
  unsigned int D.29842;
  unsigned int D.29843;
  int D.29844;
  int D.29848;
  struct MonoMethod * D.29856;
  struct MonoClass * D.29857;
  unsigned char D.29858;
  unsigned char D.29859;
  unsigned int D.29862;
  unsigned char D.29868;
  unsigned char D.29869;
  _Bool D.29872;
  long int D.29873;
  long int D.29874;
  int oindex;
  int i;
  int prev_index;
  char symbol[256];

  try
    {
      emit_section_change (acfg, ".text", 0);
      emit_alignment (acfg, 8);
      D.29771 = acfg->llvm;
      if (D.29771 != 0) goto <D.29772>; else goto <D.29773>;
      <D.29772>:
      i = 0;
      goto <D.25680>;
      <D.25679>:
      D.29774 = acfg->cfgs;
      i.136 = (unsigned int) i;
      D.29776 = i.136 * 4;
      D.29777 = D.29774 + D.29776;
      D.29778 = *D.29777;
      if (D.29778 != 0B) goto <D.29779>; else goto <D.29780>;
      <D.29779>:
      D.29774 = acfg->cfgs;
      i.136 = (unsigned int) i;
      D.29776 = i.136 * 4;
      D.29777 = D.29774 + D.29776;
      D.29778 = *D.29777;
      D.29781 = BIT_FIELD_REF <*D.29778, 8, 3400>;
      D.29782 = D.29781 & 1;
      if (D.29782 != 0) goto <D.29783>; else goto <D.29784>;
      <D.29783>:
      D.29774 = acfg->cfgs;
      i.136 = (unsigned int) i;
      D.29776 = i.136 * 4;
      D.29777 = D.29774 + D.29776;
      D.29778 = *D.29777;
      D.29785 = D.29778->asm_symbol;
      D.29786 = monoeg_strdup (D.29785);
      acfg->methods_symbol = D.29786;
      goto <D.25678>;
      <D.29784>:
      <D.29780>:
      i = i + 1;
      <D.25680>:
      i.137 = (unsigned int) i;
      D.29788 = acfg->nmethods;
      if (i.137 < D.29788) goto <D.25679>; else goto <D.25678>;
      <D.25678>:
      <D.29773>:
      D.29789 = acfg->methods_symbol;
      if (D.29789 == 0B) goto <D.29790>; else goto <D.29791>;
      <D.29790>:
      sprintf (&symbol, "methods");
      emit_label (acfg, &symbol);
      D.29792 = monoeg_strdup (&symbol);
      acfg->methods_symbol = D.29792;
      <D.29791>:
      emit_zero_bytes (acfg, 16);
      oindex = 0;
      goto <D.25685>;
      <D.25684>:
      {
        struct MonoCompile * cfg;
        struct MonoMethod * method;

        D.29793 = acfg->method_order;
        D.29794 = D.29793->pdata;
        oindex.138 = (unsigned int) oindex;
        D.29796 = oindex.138 * 4;
        D.29797 = D.29794 + D.29796;
        D.29798 = *D.29797;
        i = (int) D.29798;
        D.29774 = acfg->cfgs;
        i.136 = (unsigned int) i;
        D.29776 = i.136 * 4;
        D.29777 = D.29774 + D.29776;
        cfg = *D.29777;
        if (cfg == 0B) goto <D.29799>; else goto <D.29800>;
        <D.29799>:
        // predicted unlikely by continue predictor.
        goto <D.25683>;
        <D.29800>:
        method = cfg->orig_method;
        D.29801 = acfg->aot_opts.full_aot;
        if (D.29801 != 0) goto <D.29802>; else goto <D.29803>;
        <D.29802>:
        D.29804 = cfg->orig_method;
        D.29805 = D.29804->klass;
        D.29806 = BIT_FIELD_REF <*D.29805, 8, 160>;
        D.29807 = D.29806 & 8;
        if (D.29807 != 0) goto <D.29808>; else goto <D.29809>;
        <D.29808>:
        D.29810 = get_method_index (acfg, method);
        sprintf (&symbol, "ut_%d", D.29810);
        emit_section_change (acfg, ".text", 0);
        D.29811 = acfg->thumb_mixed;
        if (D.29811 != 0) goto <D.29812>; else goto <D.29813>;
        <D.29812>:
        D.29814 = BIT_FIELD_REF <*cfg, 8, 3400>;
        D.29815 = D.29814 & 1;
        if (D.29815 != 0) goto <D.29816>; else goto <D.29817>;
        <D.29816>:
        emit_set_thumb_mode (acfg);
        D.29818 = acfg->fp;
        fprintf (D.29818, "\n.thumb_func\n");
        <D.29817>:
        <D.29813>:
        emit_label (acfg, &symbol);
        D.29819 = cfg->asm_symbol;
        D.29804 = cfg->orig_method;
        arch_emit_unbox_trampoline (acfg, cfg, D.29804, D.29819);
        D.29811 = acfg->thumb_mixed;
        if (D.29811 != 0) goto <D.29820>; else goto <D.29821>;
        <D.29820>:
        D.29814 = BIT_FIELD_REF <*cfg, 8, 3400>;
        D.29815 = D.29814 & 1;
        if (D.29815 != 0) goto <D.29822>; else goto <D.29823>;
        <D.29822>:
        emit_set_arm_mode (acfg);
        <D.29823>:
        <D.29821>:
        <D.29809>:
        <D.29803>:
        D.29814 = BIT_FIELD_REF <*cfg, 8, 3400>;
        D.29815 = D.29814 & 1;
        if (D.29815 != 0) goto <D.29824>; else goto <D.29825>;
        <D.29824>:
        D.29826 = acfg->stats.llvm_count;
        D.29827 = D.29826 + 1;
        acfg->stats.llvm_count = D.29827;
        goto <D.29828>;
        <D.29825>:
        emit_method_code (acfg, cfg);
        <D.29828>:
      }
      <D.25683>:
      oindex = oindex + 1;
      <D.25685>:
      oindex.139 = (unsigned int) oindex;
      D.29793 = acfg->method_order;
      D.29830 = D.29793->len;
      if (oindex.139 < D.29830) goto <D.25684>; else goto <D.25686>;
      <D.25686>:
      sprintf (&symbol, "methods_end");
      emit_section_change (acfg, ".text", 0);
      emit_alignment (acfg, 8);
      emit_label (acfg, &symbol);
      emit_int32 (acfg, 0);
      D.29771 = acfg->llvm;
      if (D.29771 != 0) goto <D.29831>; else goto <D.29832>;
      <D.29831>:
      D.29833 = acfg->need_no_dead_strip;
      if (D.29833 != 0) goto <D.29834>; else goto <D.29835>;
      <D.29834>:
      D.29818 = acfg->fp;
      fprintf (D.29818, "\n");
      i = 0;
      goto <D.25688>;
      <D.25687>:
      D.29774 = acfg->cfgs;
      i.136 = (unsigned int) i;
      D.29776 = i.136 * 4;
      D.29777 = D.29774 + D.29776;
      D.29778 = *D.29777;
      if (D.29778 != 0B) goto <D.29836>; else goto <D.29837>;
      <D.29836>:
      D.29774 = acfg->cfgs;
      i.136 = (unsigned int) i;
      D.29776 = i.136 * 4;
      D.29777 = D.29774 + D.29776;
      D.29778 = *D.29777;
      D.29781 = BIT_FIELD_REF <*D.29778, 8, 3400>;
      D.29782 = D.29781 & 1;
      if (D.29782 != 0) goto <D.29838>; else goto <D.29839>;
      <D.29838>:
      D.29774 = acfg->cfgs;
      i.136 = (unsigned int) i;
      D.29776 = i.136 * 4;
      D.29777 = D.29774 + D.29776;
      D.29778 = *D.29777;
      D.29785 = D.29778->asm_symbol;
      D.29818 = acfg->fp;
      fprintf (D.29818, ".no_dead_strip %s\n", D.29785);
      <D.29839>:
      <D.29837>:
      i = i + 1;
      <D.25688>:
      i.137 = (unsigned int) i;
      D.29788 = acfg->nmethods;
      if (i.137 < D.29788) goto <D.25687>; else goto <D.25689>;
      <D.25689>:
      <D.29835>:
      <D.29832>:
      sprintf (&symbol, "code_offsets");
      emit_section_change (acfg, ".rodata", 1);
      emit_alignment (acfg, 8);
      emit_label (acfg, &symbol);
      D.29840 = acfg->stats.offsets_size;
      D.29841 = (unsigned int) D.29840;
      D.29788 = acfg->nmethods;
      D.29842 = D.29788 * 4;
      D.29843 = D.29841 + D.29842;
      D.29844 = (int) D.29843;
      acfg->stats.offsets_size = D.29844;
      i = 0;
      goto <D.25691>;
      <D.25690>:
      D.29774 = acfg->cfgs;
      i.136 = (unsigned int) i;
      D.29776 = i.136 * 4;
      D.29777 = D.29774 + D.29776;
      D.29778 = *D.29777;
      if (D.29778 != 0B) goto <D.29845>; else goto <D.29846>;
      <D.29845>:
      D.29789 = acfg->methods_symbol;
      D.29774 = acfg->cfgs;
      i.136 = (unsigned int) i;
      D.29776 = i.136 * 4;
      D.29777 = D.29774 + D.29776;
      D.29778 = *D.29777;
      D.29785 = D.29778->asm_symbol;
      emit_symbol_diff (acfg, D.29785, D.29789, 0);
      goto <D.29847>;
      <D.29846>:
      emit_int32 (acfg, -1);
      <D.29847>:
      i = i + 1;
      <D.25691>:
      i.137 = (unsigned int) i;
      D.29788 = acfg->nmethods;
      if (i.137 < D.29788) goto <D.25690>; else goto <D.25692>;
      <D.25692>:
      emit_line (acfg);
      sprintf (&symbol, "unbox_trampolines");
      D.29848 = acfg->direct_method_addresses;
      if (D.29848 != 0) goto <D.29849>; else goto <D.29850>;
      <D.29849>:
      emit_section_change (acfg, ".text", 0);
      goto <D.29851>;
      <D.29850>:
      emit_section_change (acfg, ".rodata", 0);
      <D.29851>:
      emit_alignment (acfg, 8);
      emit_label (acfg, &symbol);
      prev_index = -1;
      i = 0;
      goto <D.25698>;
      <D.25697>:
      {
        struct MonoCompile * cfg;
        struct MonoMethod * method;
        int index;

        D.29774 = acfg->cfgs;
        i.136 = (unsigned int) i;
        D.29776 = i.136 * 4;
        D.29777 = D.29774 + D.29776;
        cfg = *D.29777;
        if (cfg == 0B) goto <D.29852>; else goto <D.29853>;
        <D.29852>:
        // predicted unlikely by continue predictor.
        goto <D.25696>;
        <D.29853>:
        method = cfg->orig_method;
        D.29801 = acfg->aot_opts.full_aot;
        if (D.29801 != 0) goto <D.29854>; else goto <D.29855>;
        <D.29854>:
        D.29856 = cfg->orig_method;
        D.29857 = D.29856->klass;
        D.29858 = BIT_FIELD_REF <*D.29857, 8, 160>;
        D.29859 = D.29858 & 8;
        if (D.29859 != 0) goto <D.29860>; else goto <D.29861>;
        <D.29860>:
        D.29862 = get_method_index (acfg, method);
        index = (int) D.29862;
        sprintf (&symbol, "ut_%d", index);
        emit_int32 (acfg, index);
        D.29848 = acfg->direct_method_addresses;
        if (D.29848 != 0) goto <D.29863>; else goto <D.29864>;
        <D.29863>:
        emit_unset_mode (acfg);
        D.29811 = acfg->thumb_mixed;
        if (D.29811 != 0) goto <D.29867>; else goto <D.29865>;
        <D.29867>:
        D.29868 = BIT_FIELD_REF <*cfg, 8, 3400>;
        D.29869 = D.29868 & 1;
        if (D.29869 != 0) goto <D.29870>; else goto <D.29865>;
        <D.29870>:
        D.29818 = acfg->fp;
        fprintf (D.29818, "\n\tblx %s\n", &symbol);
        goto <D.29866>;
        <D.29865>:
        D.29818 = acfg->fp;
        fprintf (D.29818, "\n\tbl %s\n", &symbol);
        <D.29866>:
        goto <D.29871>;
        <D.29864>:
        D.29789 = acfg->methods_symbol;
        emit_symbol_diff (acfg, &symbol, D.29789, 0);
        <D.29871>:
        D.29872 = index <= prev_index;
        D.29873 = (long int) D.29872;
        D.29874 = __builtin_expect (D.29873, 0);
        if (D.29874 != 0) goto <D.29875>; else goto <D.29876>;
        <D.29875>:
        monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "aot-compiler.c", 7246, "index > prev_index");
        <D.29876>:
        prev_index = index;
        <D.29861>:
        <D.29855>:
      }
      <D.25696>:
      i = i + 1;
      <D.25698>:
      i.137 = (unsigned int) i;
      D.29788 = acfg->nmethods;
      if (i.137 < D.29788) goto <D.25697>; else goto <D.25699>;
      <D.25699>:
      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.29877;

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


arch_emit_unbox_trampoline (struct MonoAotCompile * acfg, struct MonoCompile * cfg, struct MonoMethod * method, const char * call_target)
{
  guint8 * code.140;
  guint8 * code.141;
  guint8 * code.142;
  unsigned int this_pos.143;
  unsigned int D.29889;
  guint8 * code.144;
  guint8 * code.145;
  unsigned char D.29894;
  guint8 * code.146;
  guint8 * code.147;
  guint8 * code.148;
  unsigned char D.29899;
  guint8 * code.149;
  unsigned char D.29901;
  guint8 * code.150;
  unsigned char D.29903;
  guint8 * code.151;
  unsigned char D.29905;
  guint8 * code.152;
  guint8 * code.153;
  guint8 * code.154;
  guint8 * code.155;
  unsigned char D.29915;
  guint8 * code.156;
  unsigned char D.29917;
  guint8 * code.157;
  unsigned char D.29919;
  guint8 * code.158;
  unsigned char D.29921;
  guint8 * code.159;
  guint8 * code.160;
  guint8 * code.161;
  guint8 * code.162;
  guint8 * code.163;
  guint8 * code.164;
  guint8 * code.165;
  guint8 * code.166;
  unsigned char D.29939;
  guint8 * code.167;
  unsigned char D.29941;
  guint8 * code.168;
  unsigned char D.29943;
  guint8 * code.169;
  unsigned char D.29945;
  guint8 * code.170;
  guint8 * code.171;
  guint8 * code.172;
  guint8 * code.173;
  unsigned char D.29955;
  guint8 * code.174;
  unsigned char D.29957;
  guint8 * code.175;
  unsigned char D.29959;
  guint8 * code.176;
  unsigned char D.29961;
  guint8 * code.177;
  unsigned char D.29963;
  guint8 * code.178;
  unsigned char D.29965;
  guint8 * code.179;
  unsigned char D.29967;
  guint8 * code.180;
  unsigned char D.29969;
  int code.181;
  int buf.182;
  int D.29972;
  guint8 buf[32];
  guint8 * code;
  int this_pos;

  try
    {
      this_pos = 4;
      code = &buf;
      if (1 != 0) goto <D.29878>; else goto <D.29879>;
      <D.29878>:
      code.140 = code;
      code = code.140 + 1;
      *code.140 = 131;
      if (1 != 0) goto <D.29881>; else goto <D.29882>;
      <D.29881>:
      if (this_pos == 0) goto <D.29883>; else goto <D.29884>;
      <D.29883>:
      code.141 = code;
      code = code.141 + 1;
      *code.141 = 4;
      code.142 = code;
      code = code.142 + 1;
      *code.142 = 36;
      goto <D.29887>;
      <D.29884>:
      this_pos.143 = (unsigned int) this_pos;
      D.29889 = this_pos.143 + 128;
      if (D.29889 <= 255) goto <D.29890>; else goto <D.29891>;
      <D.29890>:
      code.144 = code;
      code = code.144 + 1;
      *code.144 = 68;
      code.145 = code;
      code = code.145 + 1;
      *code.145 = 36;
      D.29894 = (unsigned char) this_pos;
      *code = D.29894;
      code = code + 1;
      goto <D.29895>;
      <D.29891>:
      code.146 = code;
      code = code.146 + 1;
      *code.146 = 132;
      code.147 = code;
      code = code.147 + 1;
      *code.147 = 36;
      {
        union x86_imm_buf imb;

        try
          {
            imb.val = this_pos;
            code.148 = code;
            code = code.148 + 1;
            D.29899 = imb.b[0];
            *code.148 = D.29899;
            code.149 = code;
            code = code.149 + 1;
            D.29901 = imb.b[1];
            *code.149 = D.29901;
            code.150 = code;
            code = code.150 + 1;
            D.29903 = imb.b[2];
            *code.150 = D.29903;
            code.151 = code;
            code = code.151 + 1;
            D.29905 = imb.b[3];
            *code.151 = D.29905;
          }
        finally
          {
            imb = {CLOBBER};
          }
      }
      <D.29895>:
      <D.29887>:
      goto <D.23692>;
      <D.29882>:
      if (this_pos == 0) goto <D.29906>; else goto <D.29907>;
      <D.29906>:
      code.152 = code;
      code = code.152 + 1;
      *code.152 = 4;
      goto <D.23692>;
      <D.29907>:
      this_pos.143 = (unsigned int) this_pos;
      D.29889 = this_pos.143 + 128;
      if (D.29889 <= 255) goto <D.29909>; else goto <D.29910>;
      <D.29909>:
      code.153 = code;
      code = code.153 + 1;
      *code.153 = 68;
      D.29894 = (unsigned char) this_pos;
      *code = D.29894;
      code = code + 1;
      goto <D.29912>;
      <D.29910>:
      code.154 = code;
      code = code.154 + 1;
      *code.154 = 132;
      {
        union x86_imm_buf imb;

        try
          {
            imb.val = this_pos;
            code.155 = code;
            code = code.155 + 1;
            D.29915 = imb.b[0];
            *code.155 = D.29915;
            code.156 = code;
            code = code.156 + 1;
            D.29917 = imb.b[1];
            *code.156 = D.29917;
            code.157 = code;
            code = code.157 + 1;
            D.29919 = imb.b[2];
            *code.157 = D.29919;
            code.158 = code;
            code = code.158 + 1;
            D.29921 = imb.b[3];
            *code.158 = D.29921;
          }
        finally
          {
            imb = {CLOBBER};
          }
      }
      <D.29912>:
      <D.23692>:
      *code = 8;
      code = code + 1;
      goto <D.29922>;
      <D.29879>:
      code.159 = code;
      code = code.159 + 1;
      *code.159 = 129;
      if (1 != 0) goto <D.29924>; else goto <D.29925>;
      <D.29924>:
      if (this_pos == 0) goto <D.29926>; else goto <D.29927>;
      <D.29926>:
      code.160 = code;
      code = code.160 + 1;
      *code.160 = 4;
      code.161 = code;
      code = code.161 + 1;
      *code.161 = 36;
      goto <D.29930>;
      <D.29927>:
      this_pos.143 = (unsigned int) this_pos;
      D.29889 = this_pos.143 + 128;
      if (D.29889 <= 255) goto <D.29931>; else goto <D.29932>;
      <D.29931>:
      code.162 = code;
      code = code.162 + 1;
      *code.162 = 68;
      code.163 = code;
      code = code.163 + 1;
      *code.163 = 36;
      D.29894 = (unsigned char) this_pos;
      *code = D.29894;
      code = code + 1;
      goto <D.29935>;
      <D.29932>:
      code.164 = code;
      code = code.164 + 1;
      *code.164 = 132;
      code.165 = code;
      code = code.165 + 1;
      *code.165 = 36;
      {
        union x86_imm_buf imb;

        try
          {
            imb.val = this_pos;
            code.166 = code;
            code = code.166 + 1;
            D.29939 = imb.b[0];
            *code.166 = D.29939;
            code.167 = code;
            code = code.167 + 1;
            D.29941 = imb.b[1];
            *code.167 = D.29941;
            code.168 = code;
            code = code.168 + 1;
            D.29943 = imb.b[2];
            *code.168 = D.29943;
            code.169 = code;
            code = code.169 + 1;
            D.29945 = imb.b[3];
            *code.169 = D.29945;
          }
        finally
          {
            imb = {CLOBBER};
          }
      }
      <D.29935>:
      <D.29930>:
      goto <D.23695>;
      <D.29925>:
      if (this_pos == 0) goto <D.29946>; else goto <D.29947>;
      <D.29946>:
      code.170 = code;
      code = code.170 + 1;
      *code.170 = 4;
      goto <D.23695>;
      <D.29947>:
      this_pos.143 = (unsigned int) this_pos;
      D.29889 = this_pos.143 + 128;
      if (D.29889 <= 255) goto <D.29949>; else goto <D.29950>;
      <D.29949>:
      code.171 = code;
      code = code.171 + 1;
      *code.171 = 68;
      D.29894 = (unsigned char) this_pos;
      *code = D.29894;
      code = code + 1;
      goto <D.29952>;
      <D.29950>:
      code.172 = code;
      code = code.172 + 1;
      *code.172 = 132;
      {
        union x86_imm_buf imb;

        try
          {
            imb.val = this_pos;
            code.173 = code;
            code = code.173 + 1;
            D.29955 = imb.b[0];
            *code.173 = D.29955;
            code.174 = code;
            code = code.174 + 1;
            D.29957 = imb.b[1];
            *code.174 = D.29957;
            code.175 = code;
            code = code.175 + 1;
            D.29959 = imb.b[2];
            *code.175 = D.29959;
            code.176 = code;
            code = code.176 + 1;
            D.29961 = imb.b[3];
            *code.176 = D.29961;
          }
        finally
          {
            imb = {CLOBBER};
          }
      }
      <D.29952>:
      <D.23695>:
      {
        union x86_imm_buf imb;

        try
          {
            imb.val = 8;
            code.177 = code;
            code = code.177 + 1;
            D.29963 = imb.b[0];
            *code.177 = D.29963;
            code.178 = code;
            code = code.178 + 1;
            D.29965 = imb.b[1];
            *code.178 = D.29965;
            code.179 = code;
            code = code.179 + 1;
            D.29967 = imb.b[2];
            *code.179 = D.29967;
            code.180 = code;
            code = code.180 + 1;
            D.29969 = imb.b[3];
            *code.180 = D.29969;
          }
        finally
          {
            imb = {CLOBBER};
          }
      }
      <D.29922>:
      code.181 = (int) code;
      buf.182 = (int) &buf;
      D.29972 = code.181 - buf.182;
      emit_bytes (acfg, &buf, D.29972);
      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.29973;

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


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

  D.29974 = (int) val;
  D.29975 = acfg->w;
  img_writer_emit_byte (D.29975, D.29974);
}


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

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


emit_method_code (struct MonoAotCompile * acfg, struct MonoCompile * cfg)
{
  unsigned int D.29977;
  const char * D.29978;
  int D.29979;
  int D.29982;
  char * D.29985;
  struct FILE * D.29986;
  int D.29987;
  struct GHashTable * D.29992;
  struct GHashTable * D.29995;
  unsigned int D.29998;
  char * D.30001;
  int D.30002;
  unsigned int D.30003;
  unsigned int D.30004;
  unsigned int D.30005;
  int D.30006;
  struct MonoCompile * * D.30007;
  unsigned int method_index.183;
  unsigned int D.30009;
  struct MonoCompile * * D.30010;
  struct MonoCompile * D.30011;
  unsigned int D.30012;
  struct MonoDomain * D.30013;
  struct MonoJitInfo * D.30014;
  struct MonoMethod * D.30015;
  struct MonoDebugMethodJitInfo * D.30016;
  struct MonoJumpInfo * D.30017;
  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.29977 = get_method_index (acfg, method);
  method_index = (int) D.29977;
  D.29978 = acfg->temp_prefix;
  symbol = monoeg_g_strdup_printf ("%sme_%x", D.29978, method_index);
  emit_section_change (acfg, ".text", 0);
  emit_alignment (acfg, func_alignment);
  D.29979 = acfg->global_symbols;
  if (D.29979 != 0) goto <D.29980>; else goto <D.29981>;
  <D.29980>:
  D.29982 = acfg->need_no_dead_strip;
  if (D.29982 != 0) goto <D.29983>; else goto <D.29984>;
  <D.29983>:
  D.29985 = cfg->asm_symbol;
  D.29986 = acfg->fp;
  fprintf (D.29986, "\t.no_dead_strip %s\n", D.29985);
  <D.29984>:
  <D.29981>:
  D.29985 = cfg->asm_symbol;
  emit_label (acfg, D.29985);
  D.29987 = acfg->aot_opts.write_symbols;
  if (D.29987 != 0) goto <D.29988>; else goto <D.29989>;
  <D.29988>:
  D.29979 = acfg->global_symbols;
  if (D.29979 == 0) goto <D.29990>; else goto <D.29991>;
  <D.29990>:
  D.29992 = acfg->method_label_hash;
  debug_sym = get_debug_sym (method, "", D.29992);
  D.29982 = acfg->need_no_dead_strip;
  if (D.29982 != 0) goto <D.29993>; else goto <D.29994>;
  <D.29993>:
  D.29986 = acfg->fp;
  fprintf (D.29986, "\t.no_dead_strip %s\n", debug_sym);
  <D.29994>:
  emit_local_symbol (acfg, debug_sym, symbol, 1);
  emit_label (acfg, debug_sym);
  <D.29991>:
  <D.29989>:
  D.29995 = acfg->export_names;
  export_name = monoeg_g_hash_table_lookup (D.29995, method);
  if (export_name != 0B) goto <D.29996>; else goto <D.29997>;
  <D.29996>:
  emit_global_inner (acfg, export_name, 1);
  emit_label (acfg, export_name);
  <D.29997>:
  D.29998 = cfg->verbose_level;
  if (D.29998 != 0) goto <D.29999>; else goto <D.30000>;
  <D.29999>:
  D.29985 = cfg->asm_symbol;
  D.30001 = mono_method_full_name (method, 1);
  monoeg_g_print ("Method %s emitted as %s\n", D.30001, D.29985);
  <D.30000>:
  D.30002 = acfg->stats.code_size;
  D.30003 = (unsigned int) D.30002;
  D.30004 = cfg->code_len;
  D.30005 = D.30003 + D.30004;
  D.30006 = (int) D.30005;
  acfg->stats.code_size = D.30006;
  D.30007 = acfg->cfgs;
  method_index.183 = (unsigned int) method_index;
  D.30009 = method_index.183 * 4;
  D.30010 = D.30007 + D.30009;
  D.30011 = *D.30010;
  D.30012 = acfg->got_offset;
  D.30011->got_offset = D.30012;
  D.30013 = mono_domain_get ();
  D.30014 = cfg->jit_info;
  D.30015 = D.30014->d.method;
  D.30016 = mono_debug_find_method (D.30015, D.30013);
  D.30017 = cfg->patch_info;
  D.30004 = cfg->code_len;
  emit_and_reloc_code (acfg, method, code, D.30004, D.30017, 0, D.30016);
  emit_line (acfg);
  D.29987 = acfg->aot_opts.write_symbols;
  if (D.29987 != 0) goto <D.30018>; else goto <D.30019>;
  <D.30018>:
  emit_symbol_size (acfg, debug_sym, ".");
  monoeg_g_free (debug_sym);
  <D.30019>:
  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.30020;

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


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

  D.30021 = acfg->w;
  img_writer_emit_global (D.30021, 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.30024;
  int D.30025;
  _Bool D.30028;
  _Bool D.30029;
  _Bool D.30030;
  int code_len.184;
  struct FILE * D.30036;
  void * * D.30037;
  unsigned int pindex.185;
  unsigned int D.30039;
  void * * D.30040;
  int D.30041;
  unsigned int pindex.186;
  unsigned int D.30044;
  unsigned int i.187;
  unsigned int D.30048;
  struct MonoDebugSourceLocation * * D.30049;
  struct MonoDebugSourceLocation * D.30050;
  char * D.30053;
  unsigned int D.30054;
  <unnamed type> D.30061;
  sizetype i.188;
  guint8 * D.30063;
  int code_size.189;
  int D.30065;
  struct GHashTable * D.30066;
  struct GHashTable * D.30069;
  struct GPtrArray * D.30070;
  struct GPtrArray * D.30073;
  void * D.30074;
  const void * D.30078;
  int D.30079;
  void * D.30080;
  int D.30081;
  int D.30082;
  int code_size.190;
  int D.30084;
  struct MonoMethod * D.30088;
  struct MonoClass * D.30089;
  struct MonoImage * D.30090;
  struct MonoImage * D.30091;
  int D.30095;
  struct GHashTable * D.30098;
  int D.30099;
  int D.30100;
  int D.30101;
  int D.30102;
  int D.30107;
  short unsigned int D.30110;
  int D.30111;
  int D.30112;
  unsigned int D.30118;
  _Bool D.30119;
  long int D.30120;
  long int D.30121;
  const char * D.30124;
  const char * D.30128;
  _Bool D.30129;
  _Bool D.30130;
  _Bool D.30131;
  int D.30134;
  unsigned int D.30137;
  _Bool D.30138;
  long int D.30139;
  long int D.30140;
  _Bool D.30146;
  _Bool D.30147;
  const void * D.30152;
  const void * D.30153;
  unsigned int D.30156;
  _Bool D.30157;
  long int D.30158;
  long int D.30159;
  int D.30164;
  int call_size.191;
  int D.30172;
  int got_slot.192;
  int code_size.193;
  int D.30176;
  unsigned int limit.194;
  unsigned int D.30187;
  struct MonoDebugSourceLocation * * D.30188;
  struct MonoDebugSourceLocation * D.30189;
  int D.30191;
  const guint8 * D.30192;
  unsigned int i.195;
  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.30022>; else goto <D.30023>;
  <D.30022>:
  header = mono_method_get_header (method);
  D.30024 = get_method_index (acfg, method);
  method_index = (int) D.30024;
  <D.30023>:
  D.30025 = acfg->gas_line_numbers;
  if (D.30025 != 0) goto <D.30026>; else goto <D.30027>;
  <D.30026>:
  D.30028 = method != 0B;
  D.30029 = debug_info != 0B;
  D.30030 = D.30028 & D.30029;
  if (D.30030 != 0) goto <D.30031>; else goto <D.30032>;
  <D.30031>:
  code_len.184 = (int) code_len;
  locs = compute_line_numbers (method, code_len.184, debug_info);
  if (locs == 0B) goto <D.30034>; else goto <D.30035>;
  <D.30034>:
  {
    int findex;

    findex = get_file_index (acfg, "<unknown>");
    emit_unset_mode (acfg);
    D.30036 = acfg->fp;
    fprintf (D.30036, ".loc %d %d 0\n", findex, 1);
  }
  <D.30035>:
  <D.30032>:
  <D.30027>:
  patches = monoeg_g_ptr_array_new ();
  patch_info = relocs;
  goto <D.24915>;
  <D.24914>:
  monoeg_g_ptr_array_add (patches, patch_info);
  patch_info = patch_info->next;
  <D.24915>:
  if (patch_info != 0B) goto <D.24914>; else goto <D.24916>;
  <D.24916>:
  monoeg_g_ptr_array_sort (patches, compare_patches);
  start_index = 0;
  i = 0;
  goto <D.24946>;
  <D.24945>:
  patch_info = 0B;
  pindex = start_index;
  goto <D.24919>;
  <D.24918>:
  D.30037 = patches->pdata;
  pindex.185 = (unsigned int) pindex;
  D.30039 = pindex.185 * 4;
  D.30040 = D.30037 + D.30039;
  patch_info = *D.30040;
  D.30041 = patch_info->ip.i;
  if (D.30041 >= i) goto <D.24917>; else goto <D.30042>;
  <D.30042>:
  pindex = pindex + 1;
  <D.24919>:
  pindex.186 = (unsigned int) pindex;
  D.30044 = patches->len;
  if (pindex.186 < D.30044) goto <D.24918>; else goto <D.24917>;
  <D.24917>:
  if (locs != 0B) goto <D.30045>; else goto <D.30046>;
  <D.30045>:
  i.187 = (unsigned int) i;
  D.30048 = i.187 * 4;
  D.30049 = locs + D.30048;
  D.30050 = *D.30049;
  if (D.30050 != 0B) goto <D.30051>; else goto <D.30052>;
  <D.30051>:
  {
    struct MonoDebugSourceLocation * loc;
    int findex;

    i.187 = (unsigned int) i;
    D.30048 = i.187 * 4;
    D.30049 = locs + D.30048;
    loc = *D.30049;
    D.30053 = loc->source_file;
    findex = get_file_index (acfg, D.30053);
    emit_unset_mode (acfg);
    D.30054 = loc->row;
    D.30036 = acfg->fp;
    fprintf (D.30036, ".loc %d %d 0\n", findex, D.30054);
    mono_debug_symfile_free_location (loc);
  }
  <D.30052>:
  <D.30046>:
  skip = 0;
  if (patch_info != 0B) goto <D.30055>; else goto <D.30056>;
  <D.30055>:
  D.30041 = patch_info->ip.i;
  if (D.30041 == i) goto <D.30057>; else goto <D.30058>;
  <D.30057>:
  pindex.186 = (unsigned int) pindex;
  D.30044 = patches->len;
  if (pindex.186 < D.30044) goto <D.30059>; else goto <D.30060>;
  <D.30059>:
  start_index = pindex;
  D.30061 = patch_info->type;
  switch (D.30061) <default: <D.24930>, case 27: <D.24924>, case 49: <D.24926>, case 51: <D.24922>>
  <D.24922>:
  goto <D.24923>;
  <D.24924>:
  {
    int code_size;

    try
      {
        i.188 = (sizetype) i;
        D.30063 = code + i.188;
        arch_emit_got_offset (acfg, D.30063, &code_size);
        code_size.189 = code_size;
        D.30065 = code_size.189 + -1;
        i = D.30065 + i;
        skip = 1;
        patch_info->type = 51;
        goto <D.24923>;
      }
    finally
      {
        code_size = {CLOBBER};
      }
  }
  <D.24926>:
  {
    int code_size;
    int index;
    char * selector;

    try
      {
        selector = patch_info->data.target;
        D.30066 = acfg->objc_selector_to_index;
        if (D.30066 == 0B) goto <D.30067>; else goto <D.30068>;
        <D.30067>:
        D.30069 = monoeg_g_hash_table_new (monoeg_g_str_hash, monoeg_g_str_equal);
        acfg->objc_selector_to_index = D.30069;
        <D.30068>:
        D.30070 = acfg->objc_selectors;
        if (D.30070 == 0B) goto <D.30071>; else goto <D.30072>;
        <D.30071>:
        D.30073 = monoeg_g_ptr_array_new ();
        acfg->objc_selectors = D.30073;
        <D.30072>:
        D.30066 = acfg->objc_selector_to_index;
        D.30074 = monoeg_g_hash_table_lookup (D.30066, selector);
        index = (int) D.30074;
        if (index != 0) goto <D.30075>; else goto <D.30076>;
        <D.30075>:
        index = index + -1;
        goto <D.30077>;
        <D.30076>:
        index = acfg->objc_selector_index;
        D.30078 = patch_info->data.target;
        D.30070 = acfg->objc_selectors;
        monoeg_g_ptr_array_add (D.30070, D.30078);
        D.30079 = index + 1;
        D.30080 = (void *) D.30079;
        D.30066 = acfg->objc_selector_to_index;
        monoeg_g_hash_table_insert_replace (D.30066, selector, D.30080, 0);
        D.30081 = acfg->objc_selector_index;
        D.30082 = D.30081 + 1;
        acfg->objc_selector_index = D.30082;
        <D.30077>:
        i.188 = (sizetype) i;
        D.30063 = code + i.188;
        arch_emit_objc_selector_ref (acfg, D.30063, index, &code_size);
        code_size.190 = code_size;
        D.30084 = code_size.190 + -1;
        i = D.30084 + i;
        skip = 1;
        patch_info->type = 51;
        goto <D.24923>;
      }
    finally
      {
        code_size = {CLOBBER};
      }
  }
  <D.24930>:
  direct_call = 0;
  external_call = 0;
  D.30061 = patch_info->type;
  if (D.30061 == 3) goto <D.30087>; else goto <D.30085>;
  <D.30087>:
  D.30088 = patch_info->data.method;
  D.30089 = D.30088->klass;
  D.30090 = D.30089->image;
  D.30091 = acfg->image;
  if (D.30090 == D.30091) goto <D.30092>; else goto <D.30085>;
  <D.30092>:
  if (got_only == 0) goto <D.30093>; else goto <D.30094>;
  <D.30093>:
  D.30095 = is_direct_callable (acfg, method, patch_info);
  if (D.30095 != 0) goto <D.30096>; else goto <D.30097>;
  <D.30096>:
  {
    struct MonoCompile * callee_cfg;

    D.30088 = patch_info->data.method;
    D.30098 = acfg->method_to_cfg;
    callee_cfg = monoeg_g_hash_table_lookup (D.30098, D.30088);
    direct_call = 1;
    direct_call_target = callee_cfg->asm_symbol;
    patch_info->type = 51;
    D.30099 = acfg->stats.direct_calls;
    D.30100 = D.30099 + 1;
    acfg->stats.direct_calls = D.30100;
  }
  <D.30097>:
  <D.30094>:
  D.30101 = acfg->stats.all_calls;
  D.30102 = D.30101 + 1;
  acfg->stats.all_calls = D.30102;
  goto <D.30086>;
  <D.30085>:
  D.30061 = patch_info->type;
  if (D.30061 == 31) goto <D.30103>; else goto <D.30104>;
  <D.30103>:
  if (got_only == 0) goto <D.30105>; else goto <D.30106>;
  <D.30105>:
  D.30107 = is_direct_callable (acfg, method, patch_info);
  if (D.30107 != 0) goto <D.30108>; else goto <D.30109>;
  <D.30108>:
  D.30088 = patch_info->data.method;
  D.30110 = D.30088->flags;
  D.30111 = (int) D.30110;
  D.30112 = D.30111 & 8192;
  if (D.30112 == 0) goto <D.30113>; else goto <D.30114>;
  <D.30113>:
  D.30088 = patch_info->data.method;
  direct_pinvoke = mono_lookup_icall_symbol (D.30088);
  goto <D.30115>;
  <D.30114>:
  D.30088 = patch_info->data.method;
  direct_pinvoke = get_pinvoke_import (acfg, D.30088);
  <D.30115>:
  if (direct_pinvoke != 0B) goto <D.30116>; else goto <D.30117>;
  <D.30116>:
  direct_call = 1;
  D.30118 = strlen (direct_pinvoke);
  D.30119 = D.30118 > 999;
  D.30120 = (long int) D.30119;
  D.30121 = __builtin_expect (D.30120, 0);
  if (D.30121 != 0) goto <D.30122>; else goto <D.30123>;
  <D.30122>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "aot-compiler.c", 4615, "strlen (direct_pinvoke) < 1000");
  <D.30123>:
  D.30124 = acfg->user_symbol_prefix;
  direct_call_target = monoeg_g_strdup_printf ("%s%s", D.30124, direct_pinvoke);
  <D.30117>:
  <D.30109>:
  <D.30106>:
  goto <D.30125>;
  <D.30104>:
  D.30061 = patch_info->type;
  if (D.30061 == 32) goto <D.30126>; else goto <D.30127>;
  <D.30126>:
  {
    const char * sym;

    D.30128 = patch_info->data.name;
    sym = mono_lookup_jit_icall_symbol (D.30128);
    D.30129 = got_only == 0;
    D.30130 = sym != 0B;
    D.30131 = D.30129 & D.30130;
    if (D.30131 != 0) goto <D.30132>; else goto <D.30133>;
    <D.30132>:
    D.30134 = acfg->aot_opts.direct_icalls;
    if (D.30134 != 0) goto <D.30135>; else goto <D.30136>;
    <D.30135>:
    direct_call = 1;
    external_call = 1;
    D.30137 = strlen (sym);
    D.30138 = D.30137 > 999;
    D.30139 = (long int) D.30138;
    D.30140 = __builtin_expect (D.30139, 0);
    if (D.30140 != 0) goto <D.30141>; else goto <D.30142>;
    <D.30141>:
    monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "aot-compiler.c", 4625, "strlen (sym) < 1000");
    <D.30142>:
    D.30124 = acfg->user_symbol_prefix;
    direct_call_target = monoeg_g_strdup_printf ("%s%s", D.30124, sym);
    <D.30136>:
    <D.30133>:
  }
  goto <D.30143>;
  <D.30127>:
  D.30061 = patch_info->type;
  if (D.30061 == 7) goto <D.30144>; else goto <D.30145>;
  <D.30144>:
  {
    struct MonoJitICallInfo * info;
    const char * sym;

    D.30128 = patch_info->data.name;
    info = mono_find_jit_icall_by_name (D.30128);
    D.30128 = patch_info->data.name;
    sym = mono_lookup_jit_icall_symbol (D.30128);
    D.30129 = got_only == 0;
    D.30146 = sym != 0B;
    D.30147 = D.30129 & D.30146;
    if (D.30147 != 0) goto <D.30148>; else goto <D.30149>;
    <D.30148>:
    D.30134 = acfg->aot_opts.direct_icalls;
    if (D.30134 != 0) goto <D.30150>; else goto <D.30151>;
    <D.30150>:
    D.30152 = info->func;
    D.30153 = info->wrapper;
    if (D.30152 == D.30153) goto <D.30154>; else goto <D.30155>;
    <D.30154>:
    direct_call = 1;
    external_call = 1;
    D.30156 = strlen (sym);
    D.30157 = D.30156 > 999;
    D.30158 = (long int) D.30157;
    D.30159 = __builtin_expect (D.30158, 0);
    if (D.30159 != 0) goto <D.30160>; else goto <D.30161>;
    <D.30160>:
    monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "aot-compiler.c", 4635, "strlen (sym) < 1000");
    <D.30161>:
    D.30124 = acfg->user_symbol_prefix;
    direct_call_target = monoeg_g_strdup_printf ("%s%s", D.30124, sym);
    <D.30155>:
    <D.30151>:
    <D.30149>:
  }
  <D.30145>:
  <D.30143>:
  <D.30125>:
  <D.30086>:
  if (direct_call != 0) goto <D.30162>; else goto <D.30163>;
  <D.30162>:
  patch_info->type = 51;
  D.30099 = acfg->stats.direct_calls;
  D.30100 = D.30099 + 1;
  acfg->stats.direct_calls = D.30100;
  <D.30163>:
  D.30164 = got_only | direct_call;
  if (D.30164 == 0) goto <D.30165>; else goto <D.30166>;
  <D.30165>:
  {
    struct MonoPltEntry * plt_entry;

    plt_entry = get_plt_entry (acfg, patch_info);
    if (plt_entry != 0B) goto <D.30167>; else goto <D.30168>;
    <D.30167>:
    direct_call = 1;
    direct_call_target = plt_entry->symbol;
    patch_info->type = 51;
    plt_entry->jit_used = 1;
    <D.30168>:
  }
  <D.30166>:
  if (direct_call != 0) goto <D.30169>; else goto <D.30170>;
  <D.30169>:
  {
    int call_size;

    try
      {
        arch_emit_direct_call (acfg, direct_call_target, external_call, patch_info, &call_size);
        call_size.191 = call_size;
        D.30172 = call_size.191 + -1;
        i = D.30172 + i;
      }
    finally
      {
        call_size = {CLOBBER};
      }
  }
  goto <D.30173>;
  <D.30170>:
  {
    int code_size;

    try
      {
        got_slot = get_got_offset (acfg, patch_info);
        got_slot.192 = (int) got_slot;
        i.188 = (sizetype) i;
        D.30063 = code + i.188;
        arch_emit_got_access (acfg, D.30063, got_slot.192, &code_size);
        code_size.193 = code_size;
        D.30176 = code_size.193 + -1;
        i = D.30176 + i;
      }
    finally
      {
        code_size = {CLOBBER};
      }
  }
  <D.30173>:
  skip = 1;
  <D.24923>:
  <D.30060>:
  <D.30058>:
  <D.30056>:
  if (skip == 0) goto <D.30177>; else goto <D.30178>;
  <D.30177>:
  patch_info = 0B;
  pindex = start_index;
  goto <D.24940>;
  <D.24939>:
  D.30037 = patches->pdata;
  pindex.185 = (unsigned int) pindex;
  D.30039 = pindex.185 * 4;
  D.30040 = D.30037 + D.30039;
  patch_info = *D.30040;
  D.30041 = patch_info->ip.i;
  if (D.30041 >= i) goto <D.24938>; else goto <D.30179>;
  <D.30179>:
  pindex = pindex + 1;
  <D.24940>:
  pindex.186 = (unsigned int) pindex;
  D.30044 = patches->len;
  if (pindex.186 < D.30044) goto <D.24939>; else goto <D.24938>;
  <D.24938>:
  pindex.186 = (unsigned int) pindex;
  D.30044 = patches->len;
  if (pindex.186 < D.30044) goto <D.30182>; else goto <D.30180>;
  <D.30182>:
  D.30041 = patch_info->ip.i;
  if (D.30041 > i) goto <D.30183>; else goto <D.30180>;
  <D.30183>:
  {
    int limit;

    limit = i + 1;
    goto <D.24944>;
    <D.24943>:
    if (locs != 0B) goto <D.30184>; else goto <D.30185>;
    <D.30184>:
    limit.194 = (unsigned int) limit;
    D.30187 = limit.194 * 4;
    D.30188 = locs + D.30187;
    D.30189 = *D.30188;
    if (D.30189 != 0B) goto <D.24942>; else goto <D.30190>;
    <D.30190>:
    <D.30185>:
    limit = limit + 1;
    <D.24944>:
    D.30041 = patch_info->ip.i;
    if (D.30041 > limit) goto <D.24943>; else goto <D.24942>;
    <D.24942>:
    D.30191 = limit - i;
    i.188 = (sizetype) i;
    D.30192 = code + i.188;
    emit_bytes (acfg, D.30192, D.30191);
    i = limit + -1;
  }
  goto <D.30181>;
  <D.30180>:
  i.188 = (sizetype) i;
  D.30192 = code + i.188;
  emit_bytes (acfg, D.30192, 1);
  <D.30181>:
  <D.30178>:
  i = i + 1;
  <D.24946>:
  i.195 = (unsigned int) i;
  if (i.195 < code_len) goto <D.24945>; else goto <D.24947>;
  <D.24947>:
  monoeg_g_free (locs);
}


compare_patches (const void * a, const void * b)
{
  struct MonoJumpInfo * D.30197;
  struct MonoJumpInfo * D.30198;
  gint D.30201;
  int i;
  int j;

  D.30197 = MEM[(struct MonoJumpInfo * *)a];
  i = D.30197->ip.i;
  D.30198 = MEM[(struct MonoJumpInfo * *)b];
  j = D.30198->ip.i;
  if (i < j) goto <D.30199>; else goto <D.30200>;
  <D.30199>:
  D.30201 = -1;
  return D.30201;
  <D.30200>:
  if (i > j) goto <D.30202>; else goto <D.30203>;
  <D.30202>:
  D.30201 = 1;
  return D.30201;
  <D.30203>:
  D.30201 = 0;
  return D.30201;
}


compute_line_numbers (struct MonoMethod * method, int code_size, struct MonoDebugMethodJitInfo * debug_info)
{
  struct MonoDebugSourceLocation * * D.30207;
  unsigned int D.30208;
  unsigned int code_size.196;
  _Bool D.30212;
  long int D.30213;
  long int D.30214;
  unsigned int D.30217;
  unsigned int D.30218;
  unsigned int D.30219;
  struct MonoDebugLineNumberEntry * D.30220;
  int D.30221;
  unsigned int D.30222;
  unsigned int D.30223;
  unsigned int i.197;
  unsigned int D.30225;
  unsigned int j.198;
  unsigned int D.30229;
  int * D.30230;
  unsigned int j.199;
  unsigned int D.30232;
  unsigned int i.200;
  unsigned int D.30234;
  sizetype i.201;
  sizetype D.30238;
  sizetype D.30239;
  unsigned int D.30240;
  int D.30241;
  unsigned int D.30242;
  unsigned int code_size.202;
  unsigned int D.30245;
  unsigned int D.30246;
  int * D.30247;
  _Bool D.30248;
  _Bool D.30249;
  _Bool D.30250;
  unsigned int il_offset.203;
  char * D.30257;
  unsigned int D.30258;
  unsigned int prev_line.204;
  struct MonoDebugSourceLocation * * D.30265;
  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.30205>; else goto <D.30206>;
  <D.30205>:
  D.30207 = 0B;
  return D.30207;
  <D.30206>:
  D.30208 = debug_info->code_size;
  code_size.196 = (unsigned int) code_size;
  if (D.30208 != code_size.196) goto <D.30210>; else goto <D.30211>;
  <D.30210>:
  D.30207 = 0B;
  return D.30207;
  <D.30211>:
  D.30212 = code_size == 0;
  D.30213 = (long int) D.30212;
  D.30214 = __builtin_expect (D.30213, 0);
  if (D.30214 != 0) goto <D.30215>; else goto <D.30216>;
  <D.30215>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "aot-compiler.c", 4403, "code_size");
  <D.30216>:
  D.30217 = debug_info->num_line_numbers;
  D.30218 = D.30217 * 8;
  ln_array = monoeg_malloc0 (D.30218);
  D.30217 = debug_info->num_line_numbers;
  D.30219 = D.30217 * 8;
  D.30220 = debug_info->line_numbers;
  memcpy (ln_array, D.30220, D.30219);
  D.30217 = debug_info->num_line_numbers;
  qsort (ln_array, D.30217, 8, compare_lne);
  D.30221 = code_size + 1;
  D.30222 = (unsigned int) D.30221;
  D.30223 = D.30222 * 4;
  native_to_il_offset = monoeg_malloc0 (D.30223);
  i = 0;
  goto <D.24878>;
  <D.24877>:
  {
    int j;
    struct MonoDebugLineNumberEntry * lne;

    i.197 = (unsigned int) i;
    D.30225 = i.197 * 8;
    lne = ln_array + D.30225;
    if (i == 0) goto <D.30226>; else goto <D.30227>;
    <D.30226>:
    j = 0;
    goto <D.24868>;
    <D.24867>:
    j.198 = (unsigned int) j;
    D.30229 = j.198 * 4;
    D.30230 = native_to_il_offset + D.30229;
    *D.30230 = -1;
    j = j + 1;
    <D.24868>:
    j.199 = (unsigned int) j;
    D.30232 = lne->native_offset;
    if (j.199 < D.30232) goto <D.24867>; else goto <D.24869>;
    <D.24869>:
    <D.30227>:
    i.200 = (unsigned int) i;
    D.30217 = debug_info->num_line_numbers;
    D.30234 = D.30217 + 4294967295;
    if (i.200 < D.30234) goto <D.30235>; else goto <D.30236>;
    <D.30235>:
    {
      struct MonoDebugLineNumberEntry * lne_next;

      i.201 = (sizetype) i;
      D.30238 = i.201 + 1;
      D.30239 = D.30238 * 8;
      lne_next = ln_array + D.30239;
      D.30232 = lne->native_offset;
      j = (int) D.30232;
      goto <D.24872>;
      <D.24871>:
      j.198 = (unsigned int) j;
      D.30229 = j.198 * 4;
      D.30230 = native_to_il_offset + D.30229;
      D.30240 = lne->il_offset;
      D.30241 = (int) D.30240;
      *D.30230 = D.30241;
      j = j + 1;
      <D.24872>:
      j.199 = (unsigned int) j;
      D.30242 = lne_next->native_offset;
      if (j.199 < D.30242) goto <D.24871>; else goto <D.24873>;
      <D.24873>:
    }
    goto <D.30243>;
    <D.30236>:
    D.30232 = lne->native_offset;
    j = (int) D.30232;
    goto <D.24875>;
    <D.24874>:
    j.198 = (unsigned int) j;
    D.30229 = j.198 * 4;
    D.30230 = native_to_il_offset + D.30229;
    D.30240 = lne->il_offset;
    D.30241 = (int) D.30240;
    *D.30230 = D.30241;
    j = j + 1;
    <D.24875>:
    if (j < code_size) goto <D.24874>; else goto <D.24876>;
    <D.24876>:
    <D.30243>:
  }
  i = i + 1;
  <D.24878>:
  i.200 = (unsigned int) i;
  D.30217 = debug_info->num_line_numbers;
  if (i.200 < D.30217) goto <D.24877>; else goto <D.24879>;
  <D.24879>:
  monoeg_g_free (ln_array);
  code_size.202 = (unsigned int) code_size;
  D.30245 = code_size.202 * 4;
  res = monoeg_malloc0 (D.30245);
  prev_il_offset = -1;
  prev_line = -1;
  first = 1;
  i = 0;
  goto <D.24883>;
  <D.24882>:
  {
    int il_offset;

    i.197 = (unsigned int) i;
    D.30246 = i.197 * 4;
    D.30247 = native_to_il_offset + D.30246;
    il_offset = *D.30247;
    D.30248 = il_offset == -1;
    D.30249 = il_offset == prev_il_offset;
    D.30250 = D.30248 | D.30249;
    if (D.30250 != 0) goto <D.30251>; else goto <D.30252>;
    <D.30251>:
    // predicted unlikely by continue predictor.
    goto <D.24881>;
    <D.30252>:
    prev_il_offset = il_offset;
    il_offset.203 = (unsigned int) il_offset;
    loc = mono_debug_symfile_lookup_location (minfo, il_offset.203);
    if (loc == 0B) goto <D.30254>; else goto <D.30256>;
    <D.30256>:
    D.30257 = loc->source_file;
    if (D.30257 == 0B) goto <D.30254>; else goto <D.30255>;
    <D.30254>:
    // predicted unlikely by continue predictor.
    goto <D.24881>;
    <D.30255>:
    D.30258 = loc->row;
    prev_line.204 = (unsigned int) prev_line;
    if (D.30258 == prev_line.204) goto <D.30260>; else goto <D.30261>;
    <D.30260>:
    mono_debug_symfile_free_location (loc);
    // predicted unlikely by continue predictor.
    goto <D.24881>;
    <D.30261>:
    D.30258 = loc->row;
    prev_line = (int) D.30258;
    if (first != 0) goto <D.30262>; else goto <D.30263>;
    <D.30262>:
    *res = loc;
    goto <D.30264>;
    <D.30263>:
    i.197 = (unsigned int) i;
    D.30246 = i.197 * 4;
    D.30265 = res + D.30246;
    *D.30265 = loc;
    <D.30264>:
    first = 0;
  }
  <D.24881>:
  i = i + 1;
  <D.24883>:
  if (i < code_size) goto <D.24882>; else goto <D.24884>;
  <D.24884>:
  D.30207 = res;
  return D.30207;
}


compare_lne (struct MonoDebugLineNumberEntry * a, struct MonoDebugLineNumberEntry * b)
{
  unsigned int D.30267;
  unsigned int D.30268;
  gint D.30271;
  unsigned int D.30272;
  unsigned int D.30273;
  unsigned int D.30274;
  unsigned int D.30275;

  D.30267 = a->native_offset;
  D.30268 = b->native_offset;
  if (D.30267 == D.30268) goto <D.30269>; else goto <D.30270>;
  <D.30269>:
  D.30272 = a->il_offset;
  D.30273 = b->il_offset;
  D.30274 = D.30272 - D.30273;
  D.30271 = (gint) D.30274;
  return D.30271;
  <D.30270>:
  D.30267 = a->native_offset;
  D.30268 = b->native_offset;
  D.30275 = D.30267 - D.30268;
  D.30271 = (gint) D.30275;
  return D.30271;
}


get_file_index (struct MonoAotCompile * acfg, const char * source_file)
{
  struct GHashTable * D.30277;
  struct GHashTable * D.30280;
  void * D.30281;
  unsigned int D.30284;
  unsigned int D.30285;
  void * findex.205;
  gchar * D.30287;
  char * D.30288;
  struct FILE * D.30289;
  int D.30290;
  int findex;

  D.30277 = acfg->dwarf_ln_filenames;
  if (D.30277 == 0B) goto <D.30278>; else goto <D.30279>;
  <D.30278>:
  D.30280 = monoeg_g_hash_table_new (monoeg_g_str_hash, monoeg_g_str_equal);
  acfg->dwarf_ln_filenames = D.30280;
  <D.30279>:
  D.30277 = acfg->dwarf_ln_filenames;
  D.30281 = monoeg_g_hash_table_lookup (D.30277, source_file);
  findex = (int) D.30281;
  if (findex == 0) goto <D.30282>; else goto <D.30283>;
  <D.30282>:
  D.30277 = acfg->dwarf_ln_filenames;
  D.30284 = monoeg_g_hash_table_size (D.30277);
  D.30285 = D.30284 + 1;
  findex = (int) D.30285;
  findex.205 = (void *) findex;
  D.30287 = monoeg_strdup (source_file);
  D.30277 = acfg->dwarf_ln_filenames;
  monoeg_g_hash_table_insert_replace (D.30277, D.30287, findex.205, 0);
  emit_unset_mode (acfg);
  D.30288 = mono_dwarf_escape_path (source_file);
  D.30289 = acfg->fp;
  fprintf (D.30289, ".file %d \"%s\"\n", findex, D.30288);
  <D.30283>:
  D.30290 = findex;
  return D.30290;
}


arch_emit_got_offset (struct MonoAotCompile * acfg, guint8 * code, int * code_size)
{
  int offset.206;
  char * D.30293;
  unsigned int D.30294;
  int D.30295;
  guint32 offset;

  offset = mono_arch_get_patch_offset (code);
  offset.206 = (int) offset;
  emit_bytes (acfg, code, offset.206);
  offset.206 = (int) offset;
  D.30293 = acfg->got_symbol;
  emit_symbol_diff (acfg, D.30293, ".", offset.206);
  D.30294 = offset + 4;
  D.30295 = (int) D.30294;
  *code_size = D.30295;
}


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.30298;
  struct MonoMethod * D.30300;
  struct MonoClass * D.30301;
  struct MonoImage * D.30302;
  struct MonoImage * D.30303;
  struct GHashTable * D.30305;
  unsigned char D.30312;
  unsigned char D.30313;
  struct MonoMethod * D.30315;
  struct MonoClass * D.30316;
  unsigned int D.30317;
  unsigned int D.30318;
  short unsigned int D.30321;
  int D.30322;
  int D.30323;
  unsigned char D.30327;
  unsigned char D.30328;
  int D.30331;
  int D.30333;
  unsigned char D.30334;
  unsigned char D.30335;
  gboolean D.30340;
  short unsigned int D.30344;
  int D.30345;
  int D.30346;
  int D.30348;
  int D.30353;

  D.30298 = patch_info->type;
  if (D.30298 == 3) goto <D.30299>; else goto <D.30296>;
  <D.30299>:
  D.30300 = patch_info->data.method;
  D.30301 = D.30300->klass;
  D.30302 = D.30301->image;
  D.30303 = acfg->image;
  if (D.30302 == D.30303) goto <D.30304>; else goto <D.30296>;
  <D.30304>:
  {
    struct MonoCompile * callee_cfg;

    D.30300 = patch_info->data.method;
    D.30305 = acfg->method_to_cfg;
    callee_cfg = monoeg_g_hash_table_lookup (D.30305, D.30300);
    if (callee_cfg != 0B) goto <D.30306>; else goto <D.30307>;
    <D.30306>:
    {
      gboolean direct_callable;

      direct_callable = 1;
      if (direct_callable != 0) goto <D.30310>; else goto <D.30311>;
      <D.30310>:
      D.30312 = BIT_FIELD_REF <*callee_cfg, 8, 3424>;
      D.30313 = D.30312 & 1;
      if (D.30313 != 0) goto <D.30308>; else goto <D.30314>;
      <D.30314>:
      D.30315 = callee_cfg->method;
      D.30316 = D.30315->klass;
      D.30317 = D.30316->flags;
      D.30318 = D.30317 & 1048576;
      if (D.30318 == 0) goto <D.30308>; else goto <D.30309>;
      <D.30308>:
      direct_callable = 0;
      <D.30309>:
      <D.30311>:
      D.30315 = callee_cfg->method;
      D.30321 = D.30315->iflags;
      D.30322 = (int) D.30321;
      D.30323 = D.30322 & 32;
      if (D.30323 != 0) goto <D.30324>; else goto <D.30325>;
      <D.30324>:
      if (method == 0B) goto <D.30319>; else goto <D.30326>;
      <D.30326>:
      D.30327 = BIT_FIELD_REF <*method, 8, 160>;
      D.30328 = D.30327 & 124;
      if (D.30328 != 64) goto <D.30319>; else goto <D.30320>;
      <D.30319>:
      direct_callable = 0;
      <D.30320>:
      <D.30325>:
      D.30331 = acfg->aot_opts.soft_debug;
      if (D.30331 != 0) goto <D.30329>; else goto <D.30332>;
      <D.30332>:
      D.30333 = acfg->aot_opts.no_direct_calls;
      if (D.30333 != 0) goto <D.30329>; else goto <D.30330>;
      <D.30329>:
      direct_callable = 0;
      <D.30330>:
      D.30315 = callee_cfg->method;
      D.30334 = BIT_FIELD_REF <*D.30315, 8, 160>;
      D.30335 = D.30334 & 124;
      if (D.30335 == 112) goto <D.30336>; else goto <D.30337>;
      <D.30336>:
      direct_callable = 0;
      <D.30337>:
      if (direct_callable != 0) goto <D.30338>; else goto <D.30339>;
      <D.30338>:
      D.30340 = 1;
      return D.30340;
      <D.30339>:
    }
    <D.30307>:
  }
  goto <D.30297>;
  <D.30296>:
  D.30298 = patch_info->type;
  if (D.30298 == 31) goto <D.30343>; else goto <D.30341>;
  <D.30343>:
  D.30300 = patch_info->data.method;
  D.30344 = D.30300->flags;
  D.30345 = (int) D.30344;
  D.30346 = D.30345 & 8192;
  if (D.30346 != 0) goto <D.30347>; else goto <D.30341>;
  <D.30347>:
  D.30348 = acfg->aot_opts.direct_pinvoke;
  if (D.30348 != 0) goto <D.30349>; else goto <D.30350>;
  <D.30349>:
  D.30340 = 1;
  return D.30340;
  <D.30350>:
  goto <D.30342>;
  <D.30341>:
  D.30298 = patch_info->type;
  if (D.30298 == 31) goto <D.30351>; else goto <D.30352>;
  <D.30351>:
  D.30353 = acfg->aot_opts.direct_icalls;
  if (D.30353 != 0) goto <D.30354>; else goto <D.30355>;
  <D.30354>:
  D.30340 = 1;
  return D.30340;
  <D.30355>:
  D.30340 = 0;
  return D.30340;
  <D.30352>:
  <D.30342>:
  <D.30297>:
  D.30340 = 0;
  return D.30340;
}


get_pinvoke_import (struct MonoAotCompile * acfg, struct MonoMethod * method)
{
  struct MonoClass * D.30357;
  struct GHashTable * D.30358;
  const char * D.30361;
  short unsigned int D.30364;
  int D.30366;
  <unnamed-unsigned:24> D.30367;
  int D.30368;
  int D.30369;
  unsigned int D.30372;
  <unnamed-unsigned:24> D.30374;
  unsigned int D.30375;
  unsigned int D.30376;
  const char * D.30377;
  struct MonoImage * image;
  struct MonoMethodPInvoke * piinfo;
  struct MonoTableInfo * tables;
  struct MonoTableInfo * im;
  struct MonoTableInfo * mr;
  guint32 im_cols[4];
  char * import;

  try
    {
      D.30357 = method->klass;
      image = D.30357->image;
      piinfo = method;
      tables = &image->tables;
      im = tables + 336;
      mr = tables + 312;
      D.30358 = acfg->method_to_pinvoke_import;
      import = monoeg_g_hash_table_lookup (D.30358, method);
      if (import != 0B) goto <D.30359>; else goto <D.30360>;
      <D.30359>:
      D.30361 = import;
      return D.30361;
      <D.30360>:
      D.30364 = piinfo->implmap_idx;
      if (D.30364 == 0) goto <D.30362>; else goto <D.30365>;
      <D.30365>:
      D.30364 = piinfo->implmap_idx;
      D.30366 = (int) D.30364;
      D.30367 = im->rows;
      D.30368 = (int) D.30367;
      if (D.30366 > D.30368) goto <D.30362>; else goto <D.30363>;
      <D.30362>:
      D.30361 = 0B;
      return D.30361;
      <D.30363>:
      D.30364 = piinfo->implmap_idx;
      D.30366 = (int) D.30364;
      D.30369 = D.30366 + -1;
      mono_metadata_decode_row (im, D.30369, &im_cols, 4);
      D.30372 = im_cols[3];
      if (D.30372 == 0) goto <D.30370>; else goto <D.30373>;
      <D.30373>:
      D.30372 = im_cols[3];
      D.30374 = mr->rows;
      D.30375 = (unsigned int) D.30374;
      if (D.30372 > D.30375) goto <D.30370>; else goto <D.30371>;
      <D.30370>:
      D.30361 = 0B;
      return D.30361;
      <D.30371>:
      D.30376 = im_cols[2];
      D.30377 = mono_metadata_string_heap (image, D.30376);
      import = monoeg_g_strdup_printf ("%s", D.30377);
      D.30358 = acfg->method_to_pinvoke_import;
      monoeg_g_hash_table_insert_replace (D.30358, method, import, 0);
      D.30361 = import;
      return D.30361;
    }
  finally
    {
      im_cols = {CLOBBER};
    }
}


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

  if (external != 0) goto <D.30382>; else goto <D.30380>;
  <D.30382>:
  D.30383 = acfg->use_bin_writer;
  if (D.30383 == 0) goto <D.30384>; else goto <D.30380>;
  <D.30384>:
  emit_unset_mode (acfg);
  D.30385 = acfg->fp;
  fprintf (D.30385, "call %s\n", target);
  goto <D.30381>;
  <D.30380>:
  emit_byte (acfg, 232);
  emit_symbol_diff (acfg, target, ".", -4);
  <D.30381>:
  *call_size = 5;
}


arch_emit_got_access (struct MonoAotCompile * acfg, guint8 * code, int got_slot, int * code_size)
{
  unsigned int D.30386;
  int D.30387;
  unsigned int got_slot.207;
  unsigned int D.30389;
  int D.30390;
  unsigned int D.30391;
  unsigned int D.30392;
  int D.30393;

  D.30386 = mono_arch_get_patch_offset (code);
  D.30387 = (int) D.30386;
  emit_bytes (acfg, code, D.30387);
  got_slot.207 = (unsigned int) got_slot;
  D.30389 = got_slot.207 * 4;
  D.30390 = (int) D.30389;
  emit_int32 (acfg, D.30390);
  D.30391 = mono_arch_get_patch_offset (code);
  D.30392 = D.30391 + 4;
  D.30393 = (int) D.30392;
  *code_size = D.30393;
}


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

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


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

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


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

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


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

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


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

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


emit_info (struct MonoAotCompile * acfg)
{
  unsigned int D.30399;
  unsigned int D.30400;
  struct GPtrArray * D.30401;
  void * * D.30402;
  unsigned int oindex.208;
  unsigned int D.30404;
  void * * D.30405;
  void * D.30406;
  struct MonoCompile * * D.30407;
  unsigned int i.209;
  unsigned int D.30409;
  struct MonoCompile * * D.30410;
  struct MonoCompile * D.30411;
  gint32 * D.30414;
  unsigned int D.30415;
  int D.30416;
  unsigned int oindex.210;
  unsigned int D.30419;
  int D.30420;
  unsigned int D.30421;
  int D.30422;
  unsigned int D.30423;
  unsigned int D.30424;
  int D.30425;
  int oindex;
  int i;
  char symbol[256];
  gint32 * offsets;

  try
    {
      D.30399 = acfg->nmethods;
      D.30400 = D.30399 * 4;
      offsets = monoeg_malloc0 (D.30400);
      oindex = 0;
      goto <D.25708>;
      <D.25707>:
      D.30401 = acfg->method_order;
      D.30402 = D.30401->pdata;
      oindex.208 = (unsigned int) oindex;
      D.30404 = oindex.208 * 4;
      D.30405 = D.30402 + D.30404;
      D.30406 = *D.30405;
      i = (int) D.30406;
      D.30407 = acfg->cfgs;
      i.209 = (unsigned int) i;
      D.30409 = i.209 * 4;
      D.30410 = D.30407 + D.30409;
      D.30411 = *D.30410;
      if (D.30411 != 0B) goto <D.30412>; else goto <D.30413>;
      <D.30412>:
      D.30407 = acfg->cfgs;
      i.209 = (unsigned int) i;
      D.30409 = i.209 * 4;
      D.30410 = D.30407 + D.30409;
      D.30411 = *D.30410;
      emit_method_info (acfg, D.30411);
      i.209 = (unsigned int) i;
      D.30409 = i.209 * 4;
      D.30414 = offsets + D.30409;
      D.30407 = acfg->cfgs;
      i.209 = (unsigned int) i;
      D.30409 = i.209 * 4;
      D.30410 = D.30407 + D.30409;
      D.30411 = *D.30410;
      D.30415 = D.30411->method_info_offset;
      D.30416 = (int) D.30415;
      *D.30414 = D.30416;
      goto <D.30417>;
      <D.30413>:
      i.209 = (unsigned int) i;
      D.30409 = i.209 * 4;
      D.30414 = offsets + D.30409;
      *D.30414 = 0;
      <D.30417>:
      oindex = oindex + 1;
      <D.25708>:
      oindex.210 = (unsigned int) oindex;
      D.30401 = acfg->method_order;
      D.30419 = D.30401->len;
      if (oindex.210 < D.30419) goto <D.25707>; else goto <D.25709>;
      <D.25709>:
      sprintf (&symbol, "method_info_offsets");
      emit_section_change (acfg, ".rodata", 1);
      emit_alignment (acfg, 8);
      emit_label (acfg, &symbol);
      D.30399 = acfg->nmethods;
      D.30420 = (int) D.30399;
      D.30421 = emit_offset_table (acfg, D.30420, 10, offsets);
      D.30422 = acfg->stats.offsets_size;
      D.30423 = (unsigned int) D.30422;
      D.30424 = D.30423 + D.30421;
      D.30425 = (int) D.30424;
      acfg->stats.offsets_size = D.30425;
      monoeg_g_free (offsets);
    }
  finally
    {
      symbol = {CLOBBER};
    }
}


emit_method_info (struct MonoAotCompile * acfg, struct MonoCompile * cfg)
{
  struct MonoCompile * * D.30426;
  unsigned int D.30427;
  struct MonoCompile * * D.30428;
  struct MonoCompile * D.30429;
  int iftmp.211;
  unsigned int D.30431;
  unsigned int D.30434;
  unsigned int D.30435;
  unsigned int buf_size.212;
  struct MonoClass * D.30438;
  struct MonoMethod * D.30439;
  guint8 * p.213;
  unsigned int D.30444;
  unsigned int D.30445;
  struct GList * D.30448;
  unsigned int D.30449;
  int D.30450;
  void * D.30451;
  int D.30452;
  _Bool D.30454;
  long int D.30455;
  long int D.30456;
  void * * D.30459;
  unsigned int pindex.214;
  unsigned int D.30461;
  void * * D.30462;
  <unnamed type> D.30463;
  _Bool D.30464;
  _Bool D.30465;
  _Bool D.30466;
  <unnamed type> D.30469;
  struct MonoImage * D.30472;
  struct MonoImage * D.30473;
  int D.30478;
  unsigned int pindex.215;
  unsigned char D.30484;
  unsigned char D.30485;
  _Bool D.30486;
  long int D.30487;
  long int D.30488;
  int first_got_offset.216;
  int D.30492;
  int p.217;
  int buf.218;
  int D.30495;
  int D.30496;
  _Bool D.30497;
  long int D.30498;
  long int D.30499;
  unsigned int D.30502;
  unsigned int D.30503;
  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.25105>;
      <D.25104>:
      monoeg_g_ptr_array_add (patches, patch_info);
      patch_info = patch_info->next;
      <D.25105>:
      if (patch_info != 0B) goto <D.25104>; else goto <D.25106>;
      <D.25106>:
      monoeg_g_ptr_array_sort (patches, compare_patches);
      D.30426 = acfg->cfgs;
      D.30427 = method_index * 4;
      D.30428 = D.30426 + D.30427;
      D.30429 = *D.30428;
      first_got_offset = D.30429->got_offset;
      D.30431 = patches->len;
      if (D.30431 > 999) goto <D.30432>; else goto <D.30433>;
      <D.30432>:
      D.30431 = patches->len;
      D.30434 = D.30431 + 640;
      D.30435 = D.30434 * 64;
      iftmp.211 = (int) D.30435;
      goto <D.30436>;
      <D.30433>:
      iftmp.211 = 40960;
      <D.30436>:
      buf_size = iftmp.211;
      buf_size.212 = (unsigned int) buf_size;
      buf = monoeg_malloc (buf_size.212);
      p = buf;
      D.30438 = method->klass;
      D.30439 = mono_class_get_cctor (D.30438);
      if (D.30439 != 0B) goto <D.30440>; else goto <D.30441>;
      <D.30440>:
      p.213 = p;
      D.30438 = method->klass;
      encode_klass_ref (acfg, D.30438, p.213, &p);
      goto <D.30443>;
      <D.30441>:
      p.213 = p;
      encode_value (0, p.213, &p);
      <D.30443>:
      D.30444 = cfg->opt;
      D.30445 = D.30444 & 512;
      if (D.30445 != 0) goto <D.30446>; else goto <D.30447>;
      <D.30446>:
      p.213 = p;
      D.30448 = cfg->ldstr_list;
      D.30449 = monoeg_g_list_length (D.30448);
      D.30450 = (int) D.30449;
      encode_value (D.30450, p.213, &p);
      l = cfg->ldstr_list;
      goto <D.25108>;
      <D.25107>:
      p.213 = p;
      D.30451 = l->data;
      D.30452 = (int) D.30451;
      encode_value (D.30452, p.213, &p);
      l = l->next;
      <D.25108>:
      if (l != 0B) goto <D.25107>; else goto <D.25109>;
      <D.25109>:
      goto <D.30453>;
      <D.30447>:
      D.30448 = cfg->ldstr_list;
      D.30454 = D.30448 != 0B;
      D.30455 = (long int) D.30454;
      D.30456 = __builtin_expect (D.30455, 0);
      if (D.30456 != 0) goto <D.30457>; else goto <D.30458>;
      <D.30457>:
      monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "aot-compiler.c", 5129, "!cfg->ldstr_list");
      <D.30458>:
      <D.30453>:
      n_patches = 0;
      pindex = 0;
      goto <D.25112>;
      <D.25111>:
      D.30459 = patches->pdata;
      pindex.214 = (unsigned int) pindex;
      D.30461 = pindex.214 * 4;
      D.30462 = D.30459 + D.30461;
      patch_info = *D.30462;
      D.30463 = patch_info->type;
      D.30464 = D.30463 == 27;
      D.30465 = D.30463 == 51;
      D.30466 = D.30464 | D.30465;
      if (D.30466 != 0) goto <D.30467>; else goto <D.30468>;
      <D.30467>:
      patch_info->type = 51;
      // predicted unlikely by continue predictor.
      goto <D.25110>;
      <D.30468>:
      D.30469 = patch_info->type;
      if (D.30469 == 12) goto <D.30470>; else goto <D.30471>;
      <D.30470>:
      D.30472 = patch_info->data.image;
      D.30473 = acfg->image;
      if (D.30472 == D.30473) goto <D.30474>; else goto <D.30475>;
      <D.30474>:
      patch_info->type = 51;
      // predicted unlikely by continue predictor.
      goto <D.25110>;
      <D.30475>:
      <D.30471>:
      D.30469 = patch_info->type;
      if (D.30469 == 42) goto <D.30476>; else goto <D.30477>;
      <D.30476>:
      patch_info->type = 51;
      // predicted unlikely by continue predictor.
      goto <D.25110>;
      <D.30477>:
      D.30478 = is_plt_patch (patch_info);
      if (D.30478 != 0) goto <D.30479>; else goto <D.30480>;
      <D.30479>:
      patch_info->type = 51;
      // predicted unlikely by continue predictor.
      goto <D.25110>;
      <D.30480>:
      n_patches = n_patches + 1;
      <D.25110>:
      pindex = pindex + 1;
      <D.25112>:
      pindex.215 = (unsigned int) pindex;
      D.30431 = patches->len;
      if (pindex.215 < D.30431) goto <D.25111>; else goto <D.25113>;
      <D.25113>:
      if (n_patches != 0) goto <D.30482>; else goto <D.30483>;
      <D.30482>:
      D.30484 = BIT_FIELD_REF <*cfg, 8, 3424>;
      D.30485 = D.30484 & 1;
      D.30486 = D.30485 == 0;
      D.30487 = (long int) D.30486;
      D.30488 = __builtin_expect (D.30487, 0);
      if (D.30488 != 0) goto <D.30489>; else goto <D.30490>;
      <D.30489>:
      monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "aot-compiler.c", 5164, "cfg->has_got_slots");
      <D.30490>:
      <D.30483>:
      p.213 = p;
      first_got_offset.216 = (int) first_got_offset;
      encode_patch_list (acfg, patches, n_patches, first_got_offset.216, p.213, &p);
      D.30492 = acfg->stats.info_size;
      p.213 = p;
      p.217 = (int) p.213;
      buf.218 = (int) buf;
      D.30495 = p.217 - buf.218;
      D.30496 = D.30492 + D.30495;
      acfg->stats.info_size = D.30496;
      p.213 = p;
      p.217 = (int) p.213;
      buf.218 = (int) buf;
      D.30495 = p.217 - buf.218;
      D.30497 = D.30495 >= buf_size;
      D.30498 = (long int) D.30497;
      D.30499 = __builtin_expect (D.30498, 0);
      if (D.30499 != 0) goto <D.30500>; else goto <D.30501>;
      <D.30500>:
      monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "aot-compiler.c", 5170, "p - buf < buf_size");
      <D.30501>:
      p.213 = p;
      p.217 = (int) p.213;
      buf.218 = (int) buf;
      D.30495 = p.217 - buf.218;
      D.30502 = (unsigned int) D.30495;
      D.30503 = add_to_blob (acfg, buf, D.30502);
      cfg->method_info_offset = D.30503;
      monoeg_g_free (buf);
    }
  finally
    {
      p = {CLOBBER};
    }
}


encode_klass_ref (struct MonoAotCompile * acfg, struct MonoClass * klass, guint8 * buf, guint8 * * endbuf)
{
  struct MonoGenericClass * D.30504;
  unsigned int D.30507;
  _Bool D.30508;
  long int D.30509;
  long int D.30510;
  unsigned char D.30516;
  _Bool D.30517;
  _Bool D.30518;
  _Bool D.30519;
  struct GHashTable * D.30524;
  void * D.30525;
  guint8 * p.219;
  int p.220;
  int buf2.221;
  int D.30531;
  _Bool D.30532;
  long int D.30533;
  long int D.30534;
  unsigned int D.30537;
  unsigned int D.30538;
  void * D.30539;
  int offset.222;
  gboolean shared;

  shared = 0;
  D.30504 = klass->generic_class;
  if (D.30504 != 0B) goto <D.30505>; else goto <D.30506>;
  <D.30505>:
  {
    guint32 token;

    D.30507 = klass->type_token;
    D.30508 = D.30507 == 0;
    D.30509 = (long int) D.30508;
    D.30510 = __builtin_expect (D.30509, 0);
    if (D.30510 != 0) goto <D.30511>; else goto <D.30512>;
    <D.30511>:
    monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "aot-compiler.c", 2354, "klass->type_token");
    <D.30512>:
    token = find_typespec_for_class (acfg, klass);
    if (token == 0) goto <D.30513>; else goto <D.30514>;
    <D.30513>:
    shared = 1;
    <D.30514>:
  }
  goto <D.30515>;
  <D.30506>:
  D.30516 = klass->byval_arg.type;
  D.30517 = D.30516 == 19;
  D.30518 = D.30516 == 30;
  D.30519 = D.30517 | D.30518;
  if (D.30519 != 0) goto <D.30520>; else goto <D.30521>;
  <D.30520>:
  shared = 1;
  <D.30521>:
  <D.30515>:
  if (shared != 0) goto <D.30522>; else goto <D.30523>;
  <D.30522>:
  {
    guint offset;
    guint8 * buf2;
    guint8 * p;

    try
      {
        D.30524 = acfg->klass_blob_hash;
        D.30525 = monoeg_g_hash_table_lookup (D.30524, klass);
        offset = (guint) D.30525;
        if (offset == 0) goto <D.30526>; else goto <D.30527>;
        <D.30526>:
        buf2 = monoeg_malloc (1024);
        p = buf2;
        p.219 = p;
        encode_klass_ref_inner (acfg, klass, p.219, &p);
        p.219 = p;
        p.220 = (int) p.219;
        buf2.221 = (int) buf2;
        D.30531 = p.220 - buf2.221;
        D.30532 = D.30531 > 1023;
        D.30533 = (long int) D.30532;
        D.30534 = __builtin_expect (D.30533, 0);
        if (D.30534 != 0) goto <D.30535>; else goto <D.30536>;
        <D.30535>:
        monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "aot-compiler.c", 2373, "p - buf2 < 1024");
        <D.30536>:
        p.219 = p;
        p.220 = (int) p.219;
        buf2.221 = (int) buf2;
        D.30531 = p.220 - buf2.221;
        D.30537 = (unsigned int) D.30531;
        offset = add_to_blob (acfg, buf2, D.30537);
        monoeg_g_free (buf2);
        D.30538 = offset + 1;
        D.30539 = (void *) D.30538;
        D.30524 = acfg->klass_blob_hash;
        monoeg_g_hash_table_insert_replace (D.30524, klass, D.30539, 0);
        goto <D.30540>;
        <D.30527>:
        offset = offset + 4294967295;
        <D.30540>:
        p = buf;
        p.219 = p;
        encode_value (7, p.219, &p);
        p.219 = p;
        offset.222 = (int) offset;
        encode_value (offset.222, p.219, &p);
        p.219 = p;
        *endbuf = p.219;
        return;
      }
    finally
      {
        p = {CLOBBER};
      }
  }
  <D.30523>:
  encode_klass_ref_inner (acfg, klass, buf, endbuf);
}


find_typespec_for_class (struct MonoAotCompile * acfg, struct MonoClass * klass)
{
  struct MonoImage * D.30544;
  <unnamed-unsigned:24> D.30545;
  struct MonoClass * * D.30546;
  unsigned int len.223;
  unsigned int D.30550;
  struct MonoMemPool * D.30551;
  void * D.30552;
  unsigned int i.224;
  unsigned int D.30554;
  struct MonoClass * * D.30555;
  int D.30556;
  int D.30557;
  unsigned int D.30558;
  struct MonoClass * D.30559;
  struct MonoClass * D.30560;
  guint32 D.30564;
  int i;
  int len;

  D.30544 = acfg->image;
  D.30545 = D.30544->tables[27].rows;
  len = (int) D.30545;
  D.30546 = acfg->typespec_classes;
  if (D.30546 == 0B) goto <D.30547>; else goto <D.30548>;
  <D.30547>:
  len.223 = (unsigned int) len;
  D.30550 = len.223 * 4;
  D.30551 = acfg->mempool;
  D.30552 = mono_mempool_alloc0 (D.30551, D.30550);
  acfg->typespec_classes = D.30552;
  i = 0;
  goto <D.23918>;
  <D.23917>:
  D.30546 = acfg->typespec_classes;
  i.224 = (unsigned int) i;
  D.30554 = i.224 * 4;
  D.30555 = D.30546 + D.30554;
  D.30556 = i + 1;
  D.30557 = D.30556 | 452984832;
  D.30558 = (unsigned int) D.30557;
  D.30544 = acfg->image;
  D.30559 = mono_class_get_full (D.30544, D.30558, 0B);
  *D.30555 = D.30559;
  i = i + 1;
  <D.23918>:
  if (i < len) goto <D.23917>; else goto <D.23919>;
  <D.23919>:
  <D.30548>:
  i = 0;
  goto <D.23922>;
  <D.23921>:
  D.30546 = acfg->typespec_classes;
  i.224 = (unsigned int) i;
  D.30554 = i.224 * 4;
  D.30555 = D.30546 + D.30554;
  D.30560 = *D.30555;
  if (D.30560 == klass) goto <D.23920>; else goto <D.30561>;
  <D.30561>:
  i = i + 1;
  <D.23922>:
  if (i < len) goto <D.23921>; else goto <D.23920>;
  <D.23920>:
  if (i < len) goto <D.30562>; else goto <D.30563>;
  <D.30562>:
  D.30556 = i + 1;
  D.30557 = D.30556 | 452984832;
  D.30564 = (guint32) D.30557;
  return D.30564;
  <D.30563>:
  D.30564 = 0;
  return D.30564;
}


encode_klass_ref_inner (struct MonoAotCompile * acfg, struct MonoClass * klass, guint8 * buf, guint8 * * endbuf)
{
  struct MonoGenericClass * D.30566;
  unsigned int D.30569;
  _Bool D.30570;
  long int D.30571;
  long int D.30572;
  guint8 * p.225;
  int token.226;
  int p.227;
  int p1.228;
  int D.30582;
  int count.229;
  int count.230;
  struct MonoImage * D.30588;
  unsigned int D.30589;
  unsigned int D.30590;
  _Bool D.30591;
  long int D.30592;
  long int D.30593;
  unsigned int D.30598;
  int D.30599;
  unsigned int D.30601;
  int D.30602;
  unsigned char D.30604;
  _Bool D.30605;
  _Bool D.30606;
  _Bool D.30607;
  struct MonoGenericParam * D.30610;
  unsigned char D.30611;
  int D.30612;
  short unsigned int D.30613;
  int D.30614;
  _Bool D.30615;
  int D.30616;
  <unnamed-signed:1> D.30619;
  int D.30620;
  short unsigned int D.30621;
  _Bool D.30622;
  long int D.30623;
  long int D.30624;
  unsigned char D.30627;
  unsigned char D.30628;
  struct MonoMethod * D.30631;
  struct MonoClass * D.30633;
  int D.30635;
  struct MonoType * D.30639;
  unsigned char D.30641;
  _Bool D.30642;
  long int D.30643;
  long int D.30644;
  int D.30647;
  struct MonoClass * D.30648;
  guint8 * p;

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

        D.30569 = klass->type_token;
        D.30570 = D.30569 == 0;
        D.30571 = (long int) D.30570;
        D.30572 = __builtin_expect (D.30571, 0);
        if (D.30572 != 0) goto <D.30573>; else goto <D.30574>;
        <D.30573>:
        monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "aot-compiler.c", 2275, "klass->type_token");
        <D.30574>:
        token = find_typespec_for_class (acfg, klass);
        if (token != 0) goto <D.30575>; else goto <D.30576>;
        <D.30575>:
        p.225 = p;
        encode_value (3, p.225, &p);
        p.225 = p;
        token.226 = (int) token;
        encode_value (token.226, p.225, &p);
        goto <D.30579>;
        <D.30576>:
        {
          struct MonoClass * gclass;
          struct MonoGenericInst * inst;
          static int count = 0;
          guint8 * p1;

          D.30566 = klass->generic_class;
          gclass = D.30566->container_class;
          D.30566 = klass->generic_class;
          inst = D.30566->context.class_inst;
          p1 = p;
          p.225 = p;
          encode_value (4, p.225, &p);
          p.225 = p;
          encode_klass_ref (acfg, gclass, p.225, &p);
          p.225 = p;
          encode_ginst (acfg, inst, p.225, &p);
          p.225 = p;
          p.227 = (int) p.225;
          p1.228 = (int) p1;
          D.30582 = p.227 - p1.228;
          count.229 = count;
          count.230 = D.30582 + count.229;
          count = count.230;
        }
        <D.30579>:
      }
      goto <D.30585>;
      <D.30568>:
      D.30569 = klass->type_token;
      if (D.30569 != 0) goto <D.30586>; else goto <D.30587>;
      <D.30586>:
      {
        int iindex;

        D.30588 = klass->image;
        D.30589 = get_image_index (acfg, D.30588);
        iindex = (int) D.30589;
        D.30569 = klass->type_token;
        D.30590 = D.30569 & 4278190080;
        D.30591 = D.30590 != 33554432;
        D.30592 = (long int) D.30591;
        D.30593 = __builtin_expect (D.30592, 0);
        if (D.30593 != 0) goto <D.30594>; else goto <D.30595>;
        <D.30594>:
        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.30595>:
        if (iindex == 0) goto <D.30596>; else goto <D.30597>;
        <D.30596>:
        p.225 = p;
        encode_value (1, p.225, &p);
        p.225 = p;
        D.30569 = klass->type_token;
        D.30598 = D.30569 + 4261412864;
        D.30599 = (int) D.30598;
        encode_value (D.30599, p.225, &p);
        goto <D.30600>;
        <D.30597>:
        p.225 = p;
        encode_value (2, p.225, &p);
        p.225 = p;
        D.30569 = klass->type_token;
        D.30598 = D.30569 + 4261412864;
        D.30599 = (int) D.30598;
        encode_value (D.30599, p.225, &p);
        p.225 = p;
        D.30588 = klass->image;
        D.30601 = get_image_index (acfg, D.30588);
        D.30602 = (int) D.30601;
        encode_value (D.30602, p.225, &p);
        <D.30600>:
      }
      goto <D.30603>;
      <D.30587>:
      D.30604 = klass->byval_arg.type;
      D.30605 = D.30604 == 19;
      D.30606 = D.30604 == 30;
      D.30607 = D.30605 | D.30606;
      if (D.30607 != 0) goto <D.30608>; else goto <D.30609>;
      <D.30608>:
      {
        struct MonoGenericContainer * container;
        struct MonoGenericParam * par;

        D.30610 = klass->byval_arg.data.generic_param;
        container = D.30610->owner;
        par = klass->byval_arg.data.generic_param;
        p.225 = p;
        encode_value (5, p.225, &p);
        p.225 = p;
        D.30611 = klass->byval_arg.type;
        D.30612 = (int) D.30611;
        encode_value (D.30612, p.225, &p);
        p.225 = p;
        D.30610 = klass->byval_arg.data.generic_param;
        D.30613 = D.30610->num;
        D.30614 = (int) D.30613;
        encode_value (D.30614, p.225, &p);
        p.225 = p;
        D.30615 = container != 0B;
        D.30616 = (int) D.30615;
        encode_value (D.30616, p.225, &p);
        if (container != 0B) goto <D.30617>; else goto <D.30618>;
        <D.30617>:
        p.225 = p;
        D.30619 = container->is_method;
        D.30620 = (int) D.30619;
        encode_value (D.30620, p.225, &p);
        D.30621 = par->serial;
        D.30622 = D.30621 != 0;
        D.30623 = (long int) D.30622;
        D.30624 = __builtin_expect (D.30623, 0);
        if (D.30624 != 0) goto <D.30625>; else goto <D.30626>;
        <D.30625>:
        monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "aot-compiler.c", 2317, "par->serial == 0");
        <D.30626>:
        D.30627 = BIT_FIELD_REF <*container, 8, 152>;
        D.30628 = D.30627 & 128;
        if (D.30628 != 0) goto <D.30629>; else goto <D.30630>;
        <D.30629>:
        p.225 = p;
        D.30631 = container->owner.method;
        encode_method_ref (acfg, D.30631, p.225, &p);
        goto <D.30632>;
        <D.30630>:
        p.225 = p;
        D.30633 = container->owner.klass;
        encode_klass_ref (acfg, D.30633, p.225, &p);
        <D.30632>:
        goto <D.30634>;
        <D.30618>:
        p.225 = p;
        D.30621 = par->serial;
        D.30635 = (int) D.30621;
        encode_value (D.30635, p.225, &p);
        <D.30634>:
      }
      goto <D.30636>;
      <D.30609>:
      D.30611 = klass->byval_arg.type;
      if (D.30611 == 15) goto <D.30637>; else goto <D.30638>;
      <D.30637>:
      p.225 = p;
      encode_value (8, p.225, &p);
      p.225 = p;
      D.30639 = &klass->byval_arg;
      encode_type (acfg, D.30639, p.225, &p);
      goto <D.30640>;
      <D.30638>:
      D.30641 = klass->rank;
      D.30642 = D.30641 == 0;
      D.30643 = (long int) D.30642;
      D.30644 = __builtin_expect (D.30643, 0);
      if (D.30644 != 0) goto <D.30645>; else goto <D.30646>;
      <D.30645>:
      monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "aot-compiler.c", 2330, "klass->rank > 0");
      <D.30646>:
      p.225 = p;
      encode_value (6, p.225, &p);
      p.225 = p;
      D.30641 = klass->rank;
      D.30647 = (int) D.30641;
      encode_value (D.30647, p.225, &p);
      p.225 = p;
      D.30648 = klass->element_class;
      encode_klass_ref (acfg, D.30648, p.225, &p);
      <D.30640>:
      <D.30636>:
      <D.30603>:
      <D.30585>:
      p.225 = p;
      *endbuf = p.225;
    }
  finally
    {
      p = {CLOBBER};
    }
}


encode_ginst (struct MonoAotCompile * acfg, struct MonoGenericInst * inst, guint8 * buf, guint8 * * endbuf)
{
  guint8 * p.231;
  <unnamed-unsigned:22> D.30650;
  int D.30651;
  struct MonoType * D.30652;
  struct MonoClass * D.30653;
  int D.30654;
  guint8 * p;
  int i;

  try
    {
      p = buf;
      p.231 = p;
      D.30650 = inst->type_argc;
      D.30651 = (int) D.30650;
      encode_value (D.30651, p.231, &p);
      i = 0;
      goto <D.23986>;
      <D.23985>:
      p.231 = p;
      D.30652 = inst->type_argv[i];
      D.30653 = mono_class_from_mono_type (D.30652);
      encode_klass_ref (acfg, D.30653, p.231, &p);
      i = i + 1;
      <D.23986>:
      D.30650 = inst->type_argc;
      D.30654 = (int) D.30650;
      if (D.30654 > i) goto <D.23985>; else goto <D.23987>;
      <D.23987>:
      p.231 = p;
      *endbuf = p.231;
    }
  finally
    {
      p = {CLOBBER};
    }
}


get_image_index (struct MonoAotCompile * cfg, struct MonoImage * image)
{
  struct GHashTable * D.30655;
  void * D.30656;
  guint32 D.30659;
  unsigned int D.30660;
  void * D.30661;
  struct GPtrArray * D.30662;
  guint32 index;

  D.30655 = cfg->image_hash;
  D.30656 = monoeg_g_hash_table_lookup (D.30655, image);
  index = (guint32) D.30656;
  if (index != 0) goto <D.30657>; else goto <D.30658>;
  <D.30657>:
  D.30659 = index + 4294967295;
  return D.30659;
  <D.30658>:
  D.30655 = cfg->image_hash;
  index = monoeg_g_hash_table_size (D.30655);
  D.30660 = index + 1;
  D.30661 = (void *) D.30660;
  D.30655 = cfg->image_hash;
  monoeg_g_hash_table_insert_replace (D.30655, image, D.30661, 0);
  D.30662 = cfg->image_table;
  monoeg_g_ptr_array_add (D.30662, image);
  D.30659 = index;
  return D.30659;
}


encode_method_ref (struct MonoAotCompile * acfg, struct MonoMethod * method, guint8 * buf, guint8 * * endbuf)
{
  struct MonoClass * D.30664;
  struct MonoImage * D.30665;
  unsigned char D.30669;
  unsigned char D.30670;
  short unsigned int D.30672;
  int D.30673;
  int D.30674;
  short unsigned int D.30675;
  int D.30676;
  int D.30677;
  guint8 * p.232;
  unsigned char D.30679;
  unsigned char D.30680;
  <unnamed-unsigned:5> D.30683;
  int D.30684;
  int D.30685;
  _Bool D.30686;
  long int D.30687;
  long int D.30688;
  int D.30691;
  _Bool D.30692;
  long int D.30693;
  long int D.30694;
  _Bool D.30697;
  long int D.30698;
  long int D.30699;
  <unnamed type> D.30702;
  int D.30703;
  int D.30706;
  _Bool D.30707;
  long int D.30708;
  long int D.30709;
  <unnamed type> D.30712;
  int D.30713;
  unsigned int D.30714;
  struct MonoMethod * D.30720;
  struct MonoMethod * D.30724;
  _Bool D.30725;
  long int D.30726;
  long int D.30727;
  <unnamed type> D.30730;
  int D.30731;
  const char * D.30734;
  unsigned int D.30735;
  sizetype D.30736;
  guint8 * p.233;
  struct MonoMethod * D.30741;
  _Bool D.30743;
  long int D.30744;
  long int D.30745;
  _Bool D.30748;
  long int D.30749;
  long int D.30750;
  _Bool D.30753;
  long int D.30754;
  long int D.30755;
  _Bool D.30758;
  long int D.30759;
  long int D.30760;
  <unnamed type> D.30763;
  int D.30764;
  unsigned int D.30767;
  int D.30768;
  unsigned int D.30769;
  int D.30770;
  struct MonoMethod * D.30774;
  _Bool D.30776;
  long int D.30777;
  long int D.30778;
  <unnamed type> D.30781;
  int D.30782;
  _Bool D.30783;
  long int D.30784;
  long int D.30785;
  <unnamed type> D.30788;
  int D.30789;
  unsigned int D.30790;
  struct MonoMethod * D.30793;
  struct MonoMethodSignature * D.30797;
  unsigned char D.30798;
  gint32 iftmp.234;
  <unnamed type> D.30807;
  _Bool D.30809;
  long int D.30810;
  long int D.30811;
  struct MonoMethod * D.30814;
  struct MonoClass * D.30815;
  struct MonoMethodSignature * D.30817;
  unsigned char D.30818;
  unsigned char D.30819;
  struct GHashTable * D.30822;
  struct MonoImage * D.30825;
  _Bool D.30826;
  long int D.30827;
  long int D.30828;
  int image_index.235;
  int token.236;
  _Bool D.30834;
  long int D.30835;
  long int D.30836;
  unsigned int D.30841;
  _Bool D.30842;
  long int D.30843;
  long int D.30844;
  unsigned int D.30847;
  _Bool D.30848;
  long int D.30849;
  long int D.30850;
  unsigned char D.30861;
  _Bool D.30862;
  long int D.30863;
  long int D.30864;
  int D.24111;
  int iftmp.237;
  int D.24110;
  const char[6] * D.30872;
  unsigned char D.30873;
  int D.30874;
  unsigned char D.30875;
  int D.30876;
  _Bool D.30877;
  _Bool D.30878;
  _Bool D.30879;
  const unsigned char * D.30882;
  unsigned char D.30883;
  int D.30884;
  const unsigned char * D.30885;
  unsigned char D.30886;
  int D.30887;
  _Bool D.30888;
  _Bool D.30889;
  const unsigned char * D.30892;
  unsigned char D.30893;
  int D.30894;
  const unsigned char * D.30895;
  unsigned char D.30896;
  int D.30897;
  _Bool D.30898;
  _Bool D.30899;
  const unsigned char * D.30902;
  unsigned char D.30903;
  int D.30904;
  const unsigned char * D.30905;
  unsigned char D.30906;
  int D.30907;
  struct MonoMethodSignature * D.30910;
  short unsigned int D.30911;
  short unsigned int D.30912;
  int D.24120;
  int iftmp.238;
  int D.24119;
  unsigned char D.30919;
  int D.30920;
  _Bool D.30921;
  _Bool D.30922;
  _Bool D.30923;
  const unsigned char * D.30926;
  unsigned char D.30927;
  int D.30928;
  _Bool D.30929;
  _Bool D.30930;
  const unsigned char * D.30933;
  unsigned char D.30934;
  int D.30935;
  _Bool D.30936;
  _Bool D.30937;
  const unsigned char * D.30940;
  unsigned char D.30941;
  int D.30942;
  struct MonoMethodSignature * D.30945;
  short unsigned int D.30946;
  int D.30947;
  int D.30948;
  int D.30949;
  int D.24129;
  int iftmp.239;
  int D.24128;
  const char[4] * D.30954;
  unsigned char D.30955;
  int D.30956;
  unsigned char D.30957;
  int D.30958;
  _Bool D.30959;
  _Bool D.30960;
  _Bool D.30961;
  const unsigned char * D.30964;
  unsigned char D.30965;
  int D.30966;
  const unsigned char * D.30967;
  unsigned char D.30968;
  int D.30969;
  _Bool D.30970;
  _Bool D.30971;
  const unsigned char * D.30974;
  unsigned char D.30975;
  int D.30976;
  const unsigned char * D.30977;
  unsigned char D.30978;
  int D.30979;
  _Bool D.30980;
  _Bool D.30981;
  const unsigned char * D.30984;
  unsigned char D.30985;
  int D.30986;
  const unsigned char * D.30987;
  unsigned char D.30988;
  int D.30989;
  int D.24138;
  int iftmp.240;
  int D.24137;
  const char[8] * D.30997;
  unsigned char D.30998;
  int D.30999;
  unsigned char D.31000;
  int D.31001;
  _Bool D.31002;
  _Bool D.31003;
  _Bool D.31004;
  const unsigned char * D.31007;
  unsigned char D.31008;
  int D.31009;
  const unsigned char * D.31010;
  unsigned char D.31011;
  int D.31012;
  _Bool D.31013;
  _Bool D.31014;
  const unsigned char * D.31017;
  unsigned char D.31018;
  int D.31019;
  const unsigned char * D.31020;
  unsigned char D.31021;
  int D.31022;
  _Bool D.31023;
  _Bool D.31024;
  const unsigned char * D.31027;
  unsigned char D.31028;
  int D.31029;
  const unsigned char * D.31030;
  unsigned char D.31031;
  int D.31032;
  int D.24147;
  int iftmp.241;
  int D.24146;
  const char[4] * D.31040;
  unsigned char D.31041;
  int D.31042;
  unsigned char D.31043;
  int D.31044;
  _Bool D.31045;
  _Bool D.31046;
  _Bool D.31047;
  const unsigned char * D.31050;
  unsigned char D.31051;
  int D.31052;
  const unsigned char * D.31053;
  unsigned char D.31054;
  int D.31055;
  _Bool D.31056;
  _Bool D.31057;
  const unsigned char * D.31060;
  unsigned char D.31061;
  int D.31062;
  const unsigned char * D.31063;
  unsigned char D.31064;
  int D.31065;
  _Bool D.31066;
  _Bool D.31067;
  const unsigned char * D.31070;
  unsigned char D.31071;
  int D.31072;
  const unsigned char * D.31073;
  unsigned char D.31074;
  int D.31075;
  int D.31085;
  unsigned int D.31087;
  unsigned int D.31088;
  unsigned int D.31089;
  int D.31090;
  guint32 image_index;
  guint32 token;
  struct MonoJumpInfoToken * ji;
  guint8 * p;

  try
    {
      D.30664 = method->klass;
      D.30665 = D.30664->image;
      image_index = get_image_index (acfg, D.30665);
      token = method->token;
      p = buf;
      D.30669 = BIT_FIELD_REF <*method, 8, 168>;
      D.30670 = D.30669 & 8;
      if (D.30670 != 0) goto <D.30671>; else goto <D.30666>;
      <D.30671>:
      D.30672 = method->flags;
      D.30673 = (int) D.30672;
      D.30674 = D.30673 & 64;
      if (D.30674 != 0) goto <D.30667>; else goto <D.30666>;
      <D.30666>:
      D.30675 = method->iflags;
      D.30676 = (int) D.30675;
      D.30677 = D.30676 & 32;
      if (D.30677 != 0) goto <D.30667>; else goto <D.30668>;
      <D.30667>:
      p.232 = p;
      encode_value (-83886080, p.232, &p);
      <D.30668>:
      D.30679 = BIT_FIELD_REF <*method, 8, 160>;
      D.30680 = D.30679 & 124;
      if (D.30680 != 0) goto <D.30681>; else goto <D.30682>;
      <D.30681>:
      p.232 = p;
      encode_value (-67108864, p.232, &p);
      p.232 = p;
      D.30683 = method->wrapper_type;
      D.30684 = (int) D.30683;
      encode_value (D.30684, p.232, &p);
      D.30683 = method->wrapper_type;
      D.30685 = (int) D.30683;
      switch (D.30685) <default: <D.24100>, case 1: <D.24093>, case 2: <D.24094>, case 3: <D.24095>, case 4: <D.24091>, case 5: <D.24098>, case 6: <D.24083>, case 7: <D.24087>, case 8: <D.24063>, case 9: <D.24064>, case 10: <D.24065>, case 12: <D.24069>, case 13: <D.24071>, case 14: <D.24074>, case 15: <D.24075>, case 16: <D.24085>, case 18: <D.24072>, case 19: <D.24089>, case 20: <D.24068>, case 21: <D.24079>, case 23: <D.24070>, case 24: <D.24078>, case 25: <D.24081>, case 28: <D.24076>>
      <D.24063>:
      <D.24064>:
      <D.24065>:
      {
        struct MonoMethod * m;

        m = mono_marshal_method_from_wrapper (method);
        D.30686 = m == 0B;
        D.30687 = (long int) D.30686;
        D.30688 = __builtin_expect (D.30687, 0);
        if (D.30688 != 0) goto <D.30689>; else goto <D.30690>;
        <D.30689>:
        monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "aot-compiler.c", 2595, "m");
        <D.30690>:
        p.232 = p;
        encode_method_ref (acfg, m, p.232, &p);
        goto <D.24067>;
      }
      <D.24068>:
      <D.24069>:
      <D.24070>:
      <D.24071>:
      <D.24072>:
      {
        struct MonoClass * proxy_class;

        proxy_class = mono_marshal_get_wrapper_info (method);
        p.232 = p;
        encode_klass_ref (acfg, proxy_class, p.232, &p);
        goto <D.24067>;
      }
      <D.24074>:
      <D.24075>:
      goto <D.24067>;
      <D.24076>:
      {
        struct AllocatorWrapperInfo * info;

        info = mono_marshal_get_wrapper_info (method);
        D.30691 = info->alloc_type;
        D.30692 = D.30691 == -1;
        D.30693 = (long int) D.30692;
        D.30694 = __builtin_expect (D.30693, 0);
        if (D.30694 != 0) goto <D.30695>; else goto <D.30696>;
        <D.30695>:
        monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "aot-compiler.c", 2615, "info->alloc_type != -1");
        <D.30696>:
        p.232 = p;
        D.30691 = info->alloc_type;
        encode_value (D.30691, p.232, &p);
        goto <D.24067>;
      }
      <D.24078>:
      goto <D.24067>;
      <D.24079>:
      {
        struct WrapperInfo * info;

        info = mono_marshal_get_wrapper_info (method);
        D.30697 = info == 0B;
        D.30698 = (long int) D.30697;
        D.30699 = __builtin_expect (D.30698, 0);
        if (D.30699 != 0) goto <D.30700>; else goto <D.30701>;
        <D.30700>:
        monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "aot-compiler.c", 2624, "info");
        <D.30701>:
        p.232 = p;
        D.30702 = info->subtype;
        D.30703 = (int) D.30702;
        encode_value (D.30703, p.232, &p);
        D.30702 = info->subtype;
        if (D.30702 == 3) goto <D.30704>; else goto <D.30705>;
        <D.30704>:
        p.232 = p;
        D.30706 = info->d.virtual_stelemref.kind;
        encode_value (D.30706, p.232, &p);
        <D.30705>:
        goto <D.24067>;
      }
      <D.24081>:
      {
        struct WrapperInfo * info;

        info = mono_marshal_get_wrapper_info (method);
        D.30707 = info == 0B;
        D.30708 = (long int) D.30707;
        D.30709 = __builtin_expect (D.30708, 0);
        if (D.30709 != 0) goto <D.30710>; else goto <D.30711>;
        <D.30710>:
        monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "aot-compiler.c", 2633, "info");
        <D.30711>:
        p.232 = p;
        D.30712 = info->subtype;
        D.30713 = (int) D.30712;
        encode_value (D.30713, p.232, &p);
        D.30712 = info->subtype;
        D.30714 = D.30712 + 4294967289;
        if (D.30714 <= 1) goto <D.30715>; else goto <D.30716>;
        <D.30715>:
        p.232 = p;
        D.30664 = method->klass;
        encode_klass_ref (acfg, D.30664, p.232, &p);
        goto <D.30717>;
        <D.30716>:
        D.30712 = info->subtype;
        if (D.30712 == 17) goto <D.30718>; else goto <D.30719>;
        <D.30718>:
        p.232 = p;
        D.30720 = info->d.synchronized_inner.method;
        encode_method_ref (acfg, D.30720, p.232, &p);
        goto <D.30721>;
        <D.30719>:
        D.30712 = info->subtype;
        if (D.30712 == 20) goto <D.30722>; else goto <D.30723>;
        <D.30722>:
        p.232 = p;
        D.30724 = info->d.array_accessor.method;
        encode_method_ref (acfg, D.30724, p.232, &p);
        <D.30723>:
        <D.30721>:
        <D.30717>:
        goto <D.24067>;
      }
      <D.24083>:
      {
        struct WrapperInfo * info;

        info = mono_marshal_get_wrapper_info (method);
        D.30725 = info == 0B;
        D.30726 = (long int) D.30725;
        D.30727 = __builtin_expect (D.30726, 0);
        if (D.30727 != 0) goto <D.30728>; else goto <D.30729>;
        <D.30728>:
        monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "aot-compiler.c", 2647, "info");
        <D.30729>:
        p.232 = p;
        D.30730 = info->subtype;
        D.30731 = (int) D.30730;
        encode_value (D.30731, p.232, &p);
        D.30730 = info->subtype;
        if (D.30730 == 15) goto <D.30732>; else goto <D.30733>;
        <D.30732>:
        D.30734 = method->name;
        p.232 = p;
        strcpy (p.232, D.30734);
        p.232 = p;
        D.30734 = method->name;
        D.30735 = strlen (D.30734);
        D.30736 = D.30735 + 1;
        p.233 = p.232 + D.30736;
        p = p.233;
        goto <D.30738>;
        <D.30733>:
        D.30730 = info->subtype;
        if (D.30730 == 16) goto <D.30739>; else goto <D.30740>;
        <D.30739>:
        p.232 = p;
        D.30741 = info->d.managed_to_native.method;
        encode_method_ref (acfg, D.30741, p.232, &p);
        goto <D.30742>;
        <D.30740>:
        D.30730 = info->subtype;
        D.30743 = D.30730 != 0;
        D.30744 = (long int) D.30743;
        D.30745 = __builtin_expect (D.30744, 0);
        if (D.30745 != 0) goto <D.30746>; else goto <D.30747>;
        <D.30746>:
        monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "aot-compiler.c", 2655, "info->subtype == WRAPPER_SUBTYPE_NONE");
        <D.30747>:
        p.232 = p;
        D.30741 = info->d.managed_to_native.method;
        encode_method_ref (acfg, D.30741, p.232, &p);
        <D.30742>:
        <D.30738>:
        goto <D.24067>;
      }
      <D.24085>:
      {
        struct MonoMethod * m;

        m = mono_marshal_method_from_wrapper (method);
        D.30748 = m == 0B;
        D.30749 = (long int) D.30748;
        D.30750 = __builtin_expect (D.30749, 0);
        if (D.30750 != 0) goto <D.30751>; else goto <D.30752>;
        <D.30751>:
        monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "aot-compiler.c", 2664, "m");
        <D.30752>:
        D.30753 = m == method;
        D.30754 = (long int) D.30753;
        D.30755 = __builtin_expect (D.30754, 0);
        if (D.30755 != 0) goto <D.30756>; else goto <D.30757>;
        <D.30756>:
        monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "aot-compiler.c", 2665, "m != method");
        <D.30757>:
        p.232 = p;
        encode_method_ref (acfg, m, p.232, &p);
        goto <D.24067>;
      }
      <D.24087>:
      {
        struct WrapperInfo * info;

        info = mono_marshal_get_wrapper_info (method);
        D.30758 = info == 0B;
        D.30759 = (long int) D.30758;
        D.30760 = __builtin_expect (D.30759, 0);
        if (D.30760 != 0) goto <D.30761>; else goto <D.30762>;
        <D.30761>:
        monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "aot-compiler.c", 2672, "info");
        <D.30762>:
        p.232 = p;
        D.30763 = info->subtype;
        D.30764 = (int) D.30763;
        encode_value (D.30764, p.232, &p);
        D.30763 = info->subtype;
        if (D.30763 == 1) goto <D.30765>; else goto <D.30766>;
        <D.30765>:
        p.232 = p;
        D.30767 = info->d.element_addr.rank;
        D.30768 = (int) D.30767;
        encode_value (D.30768, p.232, &p);
        p.232 = p;
        D.30769 = info->d.element_addr.elem_size;
        D.30770 = (int) D.30769;
        encode_value (D.30770, p.232, &p);
        goto <D.30771>;
        <D.30766>:
        D.30763 = info->subtype;
        if (D.30763 == 2) goto <D.30772>; else goto <D.30773>;
        <D.30772>:
        p.232 = p;
        D.30774 = info->d.string_ctor.method;
        encode_method_ref (acfg, D.30774, p.232, &p);
        goto <D.30775>;
        <D.30773>:
        monoeg_assertion_message ("* Assertion: should not be reached at %s:%d\n", "aot-compiler.c", 2681);
        <D.30775>:
        <D.30771>:
        goto <D.24067>;
      }
      <D.24089>:
      {
        struct WrapperInfo * info;

        info = mono_marshal_get_wrapper_info (method);
        D.30776 = info == 0B;
        D.30777 = (long int) D.30776;
        D.30778 = __builtin_expect (D.30777, 0);
        if (D.30778 != 0) goto <D.30779>; else goto <D.30780>;
        <D.30779>:
        monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "aot-compiler.c", 2688, "info");
        <D.30780>:
        p.232 = p;
        D.30781 = info->subtype;
        D.30782 = (int) D.30781;
        encode_value (D.30782, p.232, &p);
        goto <D.24067>;
      }
      <D.24091>:
      {
        struct WrapperInfo * info;

        info = mono_marshal_get_wrapper_info (method);
        D.30783 = info == 0B;
        D.30784 = (long int) D.30783;
        D.30785 = __builtin_expect (D.30784, 0);
        if (D.30785 != 0) goto <D.30786>; else goto <D.30787>;
        <D.30786>:
        monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "aot-compiler.c", 2695, "info");
        <D.30787>:
        p.232 = p;
        D.30788 = info->subtype;
        D.30789 = (int) D.30788;
        encode_value (D.30789, p.232, &p);
        D.30788 = info->subtype;
        D.30790 = D.30788 + 4294967283;
        if (D.30790 <= 1) goto <D.30791>; else goto <D.30792>;
        <D.30791>:
        p.232 = p;
        D.30793 = info->d.runtime_invoke.method;
        encode_method_ref (acfg, D.30793, p.232, &p);
        goto <D.30794>;
        <D.30792>:
        D.30788 = info->subtype;
        if (D.30788 == 11) goto <D.30795>; else goto <D.30796>;
        <D.30795>:
        p.232 = p;
        D.30797 = info->d.runtime_invoke.sig;
        encode_signature (acfg, D.30797, p.232, &p);
        <D.30796>:
        <D.30794>:
        goto <D.24067>;
      }
      <D.24093>:
      <D.24094>:
      <D.24095>:
      D.30669 = BIT_FIELD_REF <*method, 8, 168>;
      D.30798 = D.30669 & 16;
      if (D.30798 != 0) goto <D.30799>; else goto <D.30800>;
      <D.30799>:
      p.232 = p;
      encode_value (1, p.232, &p);
      p.232 = p;
      D.30664 = method->klass;
      encode_klass_ref (acfg, D.30664, p.232, &p);
      goto <D.30801>;
      <D.30800>:
      {
        struct MonoMethodSignature * sig;
        struct WrapperInfo * info;

        sig = mono_method_signature (method);
        info = mono_marshal_get_wrapper_info (method);
        p.232 = p;
        encode_value (0, p.232, &p);
        D.30679 = BIT_FIELD_REF <*method, 8, 160>;
        D.30680 = D.30679 & 124;
        if (D.30680 == 4) goto <D.30802>; else goto <D.30803>;
        <D.30802>:
        p.232 = p;
        if (info != 0B) goto <D.30805>; else goto <D.30806>;
        <D.30805>:
        D.30807 = info->subtype;
        iftmp.234 = (gint32) D.30807;
        goto <D.30808>;
        <D.30806>:
        iftmp.234 = 0;
        <D.30808>:
        encode_value (iftmp.234, p.232, &p);
        <D.30803>:
        p.232 = p;
        encode_signature (acfg, sig, p.232, &p);
      }
      <D.30801>:
      goto <D.24067>;
      <D.24098>:
      {
        struct WrapperInfo * info;

        info = mono_marshal_get_wrapper_info (method);
        D.30809 = info == 0B;
        D.30810 = (long int) D.30809;
        D.30811 = __builtin_expect (D.30810, 0);
        if (D.30811 != 0) goto <D.30812>; else goto <D.30813>;
        <D.30812>:
        monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "aot-compiler.c", 2724, "info");
        <D.30813>:
        p.232 = p;
        D.30814 = info->d.native_to_managed.method;
        encode_method_ref (acfg, D.30814, p.232, &p);
        p.232 = p;
        D.30815 = info->d.native_to_managed.klass;
        encode_klass_ref (acfg, D.30815, p.232, &p);
        goto <D.24067>;
      }
      <D.24100>:
      monoeg_assertion_message ("* Assertion: should not be reached at %s:%d\n", "aot-compiler.c", 2730);
      <D.24067>:
      goto <D.30816>;
      <D.30682>:
      D.30817 = mono_method_signature (method);
      D.30818 = BIT_FIELD_REF <*D.30817, 8, 88>;
      D.30819 = D.30818 & 2;
      if (D.30819 != 0) goto <D.30820>; else goto <D.30821>;
      <D.30820>:
      D.30822 = acfg->token_info_hash;
      ji = monoeg_g_hash_table_lookup (D.30822, method);
      if (ji != 0B) goto <D.30823>; else goto <D.30824>;
      <D.30823>:
      D.30825 = ji->image;
      image_index = get_image_index (acfg, D.30825);
      D.30826 = image_index > 249;
      D.30827 = (long int) D.30826;
      D.30828 = __builtin_expect (D.30827, 0);
      if (D.30828 != 0) goto <D.30829>; else goto <D.30830>;
      <D.30829>:
      monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "aot-compiler.c", 2741, "image_index < MAX_IMAGE_INDEX");
      <D.30830>:
      token = ji->token;
      p.232 = p;
      encode_value (-33554432, p.232, &p);
      p.232 = p;
      image_index.235 = (int) image_index;
      encode_value (image_index.235, p.232, &p);
      p.232 = p;
      token.236 = (int) token;
      encode_value (token.236, p.232, &p);
      goto <D.30833>;
      <D.30824>:
      {
        struct MonoMethod * declaring;
        struct MonoGenericContext * context;

        context = mono_method_get_context (method);
        D.30669 = BIT_FIELD_REF <*method, 8, 168>;
        D.30798 = D.30669 & 16;
        D.30834 = D.30798 == 0;
        D.30835 = (long int) D.30834;
        D.30836 = __builtin_expect (D.30835, 0);
        if (D.30836 != 0) goto <D.30837>; else goto <D.30838>;
        <D.30837>:
        monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "aot-compiler.c", 2751, "method->is_inflated");
        <D.30838>:
        declaring = MEM[(struct MonoMethodInflated *)method].declaring;
        p.232 = p;
        encode_value (-50331648, p.232, &p);
        p.232 = p;
        D.30664 = method->klass;
        encode_klass_ref (acfg, D.30664, p.232, &p);
        D.30664 = method->klass;
        D.30665 = D.30664->image;
        image_index = get_image_index (acfg, D.30665);
        D.30826 = image_index > 249;
        D.30827 = (long int) D.30826;
        D.30828 = __builtin_expect (D.30827, 0);
        if (D.30828 != 0) goto <D.30839>; else goto <D.30840>;
        <D.30839>:
        monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "aot-compiler.c", 2764, "image_index < MAX_IMAGE_INDEX");
        <D.30840>:
        D.30841 = declaring->token;
        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", 2765, "declaring->token");
        <D.30846>:
        token = declaring->token;
        D.30847 = token >> 24;
        D.30848 = D.30847 != 6;
        D.30849 = (long int) D.30848;
        D.30850 = __builtin_expect (D.30849, 0);
        if (D.30850 != 0) goto <D.30851>; else goto <D.30852>;
        <D.30851>:
        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.30852>:
        p.232 = p;
        image_index.235 = (int) image_index;
        encode_value (image_index.235, p.232, &p);
        p.232 = p;
        token.236 = (int) token;
        encode_value (token.236, p.232, &p);
        p.232 = p;
        encode_generic_context (acfg, context, p.232, &p);
      }
      <D.30833>:
      goto <D.30853>;
      <D.30821>:
      if (token == 0) goto <D.30854>; else goto <D.30855>;
      <D.30854>:
      D.30822 = acfg->token_info_hash;
      ji = monoeg_g_hash_table_lookup (D.30822, method);
      if (ji != 0B) goto <D.30856>; else goto <D.30857>;
      <D.30856>:
      D.30825 = ji->image;
      image_index = get_image_index (acfg, D.30825);
      D.30826 = image_index > 249;
      D.30827 = (long int) D.30826;
      D.30828 = __builtin_expect (D.30827, 0);
      if (D.30828 != 0) goto <D.30858>; else goto <D.30859>;
      <D.30858>:
      monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "aot-compiler.c", 2778, "image_index < MAX_IMAGE_INDEX");
      <D.30859>:
      token = ji->token;
      p.232 = p;
      encode_value (-33554432, p.232, &p);
      p.232 = p;
      image_index.235 = (int) image_index;
      encode_value (image_index.235, p.232, &p);
      p.232 = p;
      token.236 = (int) token;
      encode_value (token.236, p.232, &p);
      goto <D.30860>;
      <D.30857>:
      D.30664 = method->klass;
      D.30861 = D.30664->rank;
      D.30862 = D.30861 == 0;
      D.30863 = (long int) D.30862;
      D.30864 = __builtin_expect (D.30863, 0);
      if (D.30864 != 0) goto <D.30865>; else goto <D.30866>;
      <D.30865>:
      monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "aot-compiler.c", 2786, "method->klass->rank");
      <D.30866>:
      p.232 = p;
      encode_value (-100663296, p.232, &p);
      p.232 = p;
      D.30664 = method->klass;
      encode_klass_ref (acfg, D.30664, p.232, &p);
      {
        size_t __s1_len;
        size_t __s2_len;

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

          __s2 = method->name;
          D.30872 = ".ctor";
          D.30873 = MEM[(const unsigned char *)D.30872];
          D.30874 = (int) D.30873;
          D.30875 = *__s2;
          D.30876 = (int) D.30875;
          __result = D.30874 - D.30876;
          {
            D.30877 = __s2_len != 0;
            D.30878 = __result == 0;
            D.30879 = D.30877 & D.30878;
            if (D.30879 != 0) goto <D.30880>; else goto <D.30881>;
            <D.30880>:
            D.30882 = &MEM[(void *)".ctor" + 1B];
            D.30883 = *D.30882;
            D.30884 = (int) D.30883;
            D.30885 = __s2 + 1;
            D.30886 = *D.30885;
            D.30887 = (int) D.30886;
            __result = D.30884 - D.30887;
            D.30888 = __s2_len > 1;
            D.30878 = __result == 0;
            D.30889 = D.30888 & D.30878;
            if (D.30889 != 0) goto <D.30890>; else goto <D.30891>;
            <D.30890>:
            D.30892 = &MEM[(void *)".ctor" + 2B];
            D.30893 = *D.30892;
            D.30894 = (int) D.30893;
            D.30895 = __s2 + 2;
            D.30896 = *D.30895;
            D.30897 = (int) D.30896;
            __result = D.30894 - D.30897;
            D.30898 = __s2_len > 2;
            D.30878 = __result == 0;
            D.30899 = D.30898 & D.30878;
            if (D.30899 != 0) goto <D.30900>; else goto <D.30901>;
            <D.30900>:
            D.30902 = &MEM[(void *)".ctor" + 3B];
            D.30903 = *D.30902;
            D.30904 = (int) D.30903;
            D.30905 = __s2 + 3;
            D.30906 = *D.30905;
            D.30907 = (int) D.30906;
            __result = D.30904 - D.30907;
            <D.30901>:
            <D.30891>:
            <D.30881>:
          }
          D.24110 = __result;
        }
        iftmp.237 = -D.24110;
        goto <D.30908>;
        <D.30871>:
        D.30734 = method->name;
        iftmp.237 = __builtin_strcmp (D.30734, ".ctor");
        <D.30908>:
        D.24111 = iftmp.237;
      }
      if (D.24111 == 0) goto <D.30909>; else goto <D.30867>;
      <D.30909>:
      D.30910 = mono_method_signature (method);
      D.30911 = D.30910->param_count;
      D.30664 = method->klass;
      D.30861 = D.30664->rank;
      D.30912 = (short unsigned int) D.30861;
      if (D.30911 == D.30912) goto <D.30913>; else goto <D.30867>;
      <D.30913>:
      p.232 = p;
      encode_value (0, p.232, &p);
      goto <D.30868>;
      <D.30867>:
      {
        size_t __s1_len;
        size_t __s2_len;

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

          __s2 = method->name;
          D.30872 = ".ctor";
          D.30873 = MEM[(const unsigned char *)D.30872];
          D.30874 = (int) D.30873;
          D.30919 = *__s2;
          D.30920 = (int) D.30919;
          __result = D.30874 - D.30920;
          {
            D.30921 = __s2_len != 0;
            D.30922 = __result == 0;
            D.30923 = D.30921 & D.30922;
            if (D.30923 != 0) goto <D.30924>; else goto <D.30925>;
            <D.30924>:
            D.30882 = &MEM[(void *)".ctor" + 1B];
            D.30883 = *D.30882;
            D.30884 = (int) D.30883;
            D.30926 = __s2 + 1;
            D.30927 = *D.30926;
            D.30928 = (int) D.30927;
            __result = D.30884 - D.30928;
            D.30929 = __s2_len > 1;
            D.30922 = __result == 0;
            D.30930 = D.30929 & D.30922;
            if (D.30930 != 0) goto <D.30931>; else goto <D.30932>;
            <D.30931>:
            D.30892 = &MEM[(void *)".ctor" + 2B];
            D.30893 = *D.30892;
            D.30894 = (int) D.30893;
            D.30933 = __s2 + 2;
            D.30934 = *D.30933;
            D.30935 = (int) D.30934;
            __result = D.30894 - D.30935;
            D.30936 = __s2_len > 2;
            D.30922 = __result == 0;
            D.30937 = D.30936 & D.30922;
            if (D.30937 != 0) goto <D.30938>; else goto <D.30939>;
            <D.30938>:
            D.30902 = &MEM[(void *)".ctor" + 3B];
            D.30903 = *D.30902;
            D.30904 = (int) D.30903;
            D.30940 = __s2 + 3;
            D.30941 = *D.30940;
            D.30942 = (int) D.30941;
            __result = D.30904 - D.30942;
            <D.30939>:
            <D.30932>:
            <D.30925>:
          }
          D.24119 = __result;
        }
        iftmp.238 = -D.24119;
        goto <D.30943>;
        <D.30918>:
        D.30734 = method->name;
        iftmp.238 = __builtin_strcmp (D.30734, ".ctor");
        <D.30943>:
        D.24120 = iftmp.238;
      }
      if (D.24120 == 0) goto <D.30944>; else goto <D.30914>;
      <D.30944>:
      D.30945 = mono_method_signature (method);
      D.30946 = D.30945->param_count;
      D.30947 = (int) D.30946;
      D.30664 = method->klass;
      D.30861 = D.30664->rank;
      D.30948 = (int) D.30861;
      D.30949 = D.30948 * 2;
      if (D.30947 == D.30949) goto <D.30950>; else goto <D.30914>;
      <D.30950>:
      p.232 = p;
      encode_value (1, p.232, &p);
      goto <D.30915>;
      <D.30914>:
      {
        size_t __s1_len;
        size_t __s2_len;

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

          __s2 = method->name;
          D.30954 = "Get";
          D.30955 = MEM[(const unsigned char *)D.30954];
          D.30956 = (int) D.30955;
          D.30957 = *__s2;
          D.30958 = (int) D.30957;
          __result = D.30956 - D.30958;
          {
            D.30959 = __s2_len != 0;
            D.30960 = __result == 0;
            D.30961 = D.30959 & D.30960;
            if (D.30961 != 0) goto <D.30962>; else goto <D.30963>;
            <D.30962>:
            D.30964 = &MEM[(void *)"Get" + 1B];
            D.30965 = *D.30964;
            D.30966 = (int) D.30965;
            D.30967 = __s2 + 1;
            D.30968 = *D.30967;
            D.30969 = (int) D.30968;
            __result = D.30966 - D.30969;
            D.30970 = __s2_len > 1;
            D.30960 = __result == 0;
            D.30971 = D.30970 & D.30960;
            if (D.30971 != 0) goto <D.30972>; else goto <D.30973>;
            <D.30972>:
            D.30974 = &MEM[(void *)"Get" + 2B];
            D.30975 = *D.30974;
            D.30976 = (int) D.30975;
            D.30977 = __s2 + 2;
            D.30978 = *D.30977;
            D.30979 = (int) D.30978;
            __result = D.30976 - D.30979;
            D.30980 = __s2_len > 2;
            D.30960 = __result == 0;
            D.30981 = D.30980 & D.30960;
            if (D.30981 != 0) goto <D.30982>; else goto <D.30983>;
            <D.30982>:
            D.30984 = &MEM[(void *)"Get" + 3B];
            D.30985 = *D.30984;
            D.30986 = (int) D.30985;
            D.30987 = __s2 + 3;
            D.30988 = *D.30987;
            D.30989 = (int) D.30988;
            __result = D.30986 - D.30989;
            <D.30983>:
            <D.30973>:
            <D.30963>:
          }
          D.24128 = __result;
        }
        iftmp.239 = -D.24128;
        goto <D.30990>;
        <D.30953>:
        D.30734 = method->name;
        iftmp.239 = __builtin_strcmp (D.30734, "Get");
        <D.30990>:
        D.24129 = iftmp.239;
      }
      if (D.24129 == 0) goto <D.30991>; else goto <D.30992>;
      <D.30991>:
      p.232 = p;
      encode_value (2, p.232, &p);
      goto <D.30993>;
      <D.30992>:
      {
        size_t __s1_len;
        size_t __s2_len;

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

          __s2 = method->name;
          D.30997 = "Address";
          D.30998 = MEM[(const unsigned char *)D.30997];
          D.30999 = (int) D.30998;
          D.31000 = *__s2;
          D.31001 = (int) D.31000;
          __result = D.30999 - D.31001;
          {
            D.31002 = __s2_len != 0;
            D.31003 = __result == 0;
            D.31004 = D.31002 & D.31003;
            if (D.31004 != 0) goto <D.31005>; else goto <D.31006>;
            <D.31005>:
            D.31007 = &MEM[(void *)"Address" + 1B];
            D.31008 = *D.31007;
            D.31009 = (int) D.31008;
            D.31010 = __s2 + 1;
            D.31011 = *D.31010;
            D.31012 = (int) D.31011;
            __result = D.31009 - D.31012;
            D.31013 = __s2_len > 1;
            D.31003 = __result == 0;
            D.31014 = D.31013 & D.31003;
            if (D.31014 != 0) goto <D.31015>; else goto <D.31016>;
            <D.31015>:
            D.31017 = &MEM[(void *)"Address" + 2B];
            D.31018 = *D.31017;
            D.31019 = (int) D.31018;
            D.31020 = __s2 + 2;
            D.31021 = *D.31020;
            D.31022 = (int) D.31021;
            __result = D.31019 - D.31022;
            D.31023 = __s2_len > 2;
            D.31003 = __result == 0;
            D.31024 = D.31023 & D.31003;
            if (D.31024 != 0) goto <D.31025>; else goto <D.31026>;
            <D.31025>:
            D.31027 = &MEM[(void *)"Address" + 3B];
            D.31028 = *D.31027;
            D.31029 = (int) D.31028;
            D.31030 = __s2 + 3;
            D.31031 = *D.31030;
            D.31032 = (int) D.31031;
            __result = D.31029 - D.31032;
            <D.31026>:
            <D.31016>:
            <D.31006>:
          }
          D.24137 = __result;
        }
        iftmp.240 = -D.24137;
        goto <D.31033>;
        <D.30996>:
        D.30734 = method->name;
        iftmp.240 = __builtin_strcmp (D.30734, "Address");
        <D.31033>:
        D.24138 = iftmp.240;
      }
      if (D.24138 == 0) goto <D.31034>; else goto <D.31035>;
      <D.31034>:
      p.232 = p;
      encode_value (3, p.232, &p);
      goto <D.31036>;
      <D.31035>:
      {
        size_t __s1_len;
        size_t __s2_len;

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

          __s2 = method->name;
          D.31040 = "Set";
          D.31041 = MEM[(const unsigned char *)D.31040];
          D.31042 = (int) D.31041;
          D.31043 = *__s2;
          D.31044 = (int) D.31043;
          __result = D.31042 - D.31044;
          {
            D.31045 = __s2_len != 0;
            D.31046 = __result == 0;
            D.31047 = D.31045 & D.31046;
            if (D.31047 != 0) goto <D.31048>; else goto <D.31049>;
            <D.31048>:
            D.31050 = &MEM[(void *)"Set" + 1B];
            D.31051 = *D.31050;
            D.31052 = (int) D.31051;
            D.31053 = __s2 + 1;
            D.31054 = *D.31053;
            D.31055 = (int) D.31054;
            __result = D.31052 - D.31055;
            D.31056 = __s2_len > 1;
            D.31046 = __result == 0;
            D.31057 = D.31056 & D.31046;
            if (D.31057 != 0) goto <D.31058>; else goto <D.31059>;
            <D.31058>:
            D.31060 = &MEM[(void *)"Set" + 2B];
            D.31061 = *D.31060;
            D.31062 = (int) D.31061;
            D.31063 = __s2 + 2;
            D.31064 = *D.31063;
            D.31065 = (int) D.31064;
            __result = D.31062 - D.31065;
            D.31066 = __s2_len > 2;
            D.31046 = __result == 0;
            D.31067 = D.31066 & D.31046;
            if (D.31067 != 0) goto <D.31068>; else goto <D.31069>;
            <D.31068>:
            D.31070 = &MEM[(void *)"Set" + 3B];
            D.31071 = *D.31070;
            D.31072 = (int) D.31071;
            D.31073 = __s2 + 3;
            D.31074 = *D.31073;
            D.31075 = (int) D.31074;
            __result = D.31072 - D.31075;
            <D.31069>:
            <D.31059>:
            <D.31049>:
          }
          D.24146 = __result;
        }
        iftmp.241 = -D.24146;
        goto <D.31076>;
        <D.31039>:
        D.30734 = method->name;
        iftmp.241 = __builtin_strcmp (D.30734, "Set");
        <D.31076>:
        D.24147 = iftmp.241;
      }
      if (D.24147 == 0) goto <D.31077>; else goto <D.31078>;
      <D.31077>:
      p.232 = p;
      encode_value (4, p.232, &p);
      goto <D.31079>;
      <D.31078>:
      monoeg_assertion_message ("* Assertion: should not be reached at %s:%d\n", "aot-compiler.c", 2802);
      <D.31079>:
      <D.31036>:
      <D.30993>:
      <D.30915>:
      <D.30868>:
      <D.30860>:
      goto <D.31080>;
      <D.30855>:
      D.30847 = token >> 24;
      D.30848 = D.30847 != 6;
      D.30849 = (long int) D.30848;
      D.30850 = __builtin_expect (D.30849, 0);
      if (D.30850 != 0) goto <D.31081>; else goto <D.31082>;
      <D.31081>:
      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.31082>:
      if (image_index > 239) goto <D.31083>; else goto <D.31084>;
      <D.31083>:
      p.232 = p;
      encode_value (-117440512, p.232, &p);
      p.232 = p;
      image_index.235 = (int) image_index;
      encode_value (image_index.235, p.232, &p);
      p.232 = p;
      token.236 = (int) token;
      D.31085 = token.236 & 16777215;
      encode_value (D.31085, p.232, &p);
      goto <D.31086>;
      <D.31084>:
      p.232 = p;
      D.31087 = image_index << 24;
      D.31088 = token & 16777215;
      D.31089 = D.31087 | D.31088;
      D.31090 = (int) D.31089;
      encode_value (D.31090, p.232, &p);
      <D.31086>:
      <D.31080>:
      <D.30853>:
      <D.30816>:
      p.232 = p;
      *endbuf = p.232;
    }
  finally
    {
      p = {CLOBBER};
    }
}


encode_signature (struct MonoAotCompile * acfg, struct MonoMethodSignature * sig, guint8 * buf, guint8 * * endbuf)
{
  short unsigned int D.31093;
  unsigned char D.31096;
  unsigned char D.31097;
  unsigned char D.31100;
  <unnamed-unsigned:6> D.31103;
  unsigned int D.31104;
  unsigned int D.31105;
  guint8 * p.242;
  unsigned char D.31107;
  guint8 * p.243;
  int D.31111;
  short unsigned int D.31112;
  int D.31113;
  struct MonoType * D.31114;
  short int D.31115;
  int D.31116;
  struct MonoType * D.31119;
  int D.31120;
  guint8 * p;
  guint32 flags;
  int i;

  try
    {
      p = buf;
      flags = 0;
      D.31093 = sig->generic_param_count;
      if (D.31093 != 0) goto <D.31094>; else goto <D.31095>;
      <D.31094>:
      flags = flags | 16;
      <D.31095>:
      D.31096 = BIT_FIELD_REF <*sig, 8, 80>;
      D.31097 = D.31096 & 64;
      if (D.31097 != 0) goto <D.31098>; else goto <D.31099>;
      <D.31098>:
      flags = flags | 32;
      <D.31099>:
      D.31096 = BIT_FIELD_REF <*sig, 8, 80>;
      D.31100 = D.31096 & 128;
      if (D.31100 != 0) goto <D.31101>; else goto <D.31102>;
      <D.31101>:
      flags = flags | 64;
      <D.31102>:
      D.31103 = sig->call_convention;
      D.31104 = (unsigned int) D.31103;
      D.31105 = D.31104 & 15;
      flags = D.31105 | flags;
      p.242 = p;
      D.31107 = (unsigned char) flags;
      *p.242 = D.31107;
      p.242 = p;
      p.243 = p.242 + 1;
      p = p.243;
      D.31093 = sig->generic_param_count;
      if (D.31093 != 0) goto <D.31109>; else goto <D.31110>;
      <D.31109>:
      p.242 = p;
      D.31093 = sig->generic_param_count;
      D.31111 = (int) D.31093;
      encode_value (D.31111, p.242, &p);
      <D.31110>:
      p.242 = p;
      D.31112 = sig->param_count;
      D.31113 = (int) D.31112;
      encode_value (D.31113, p.242, &p);
      p.242 = p;
      D.31114 = sig->ret;
      encode_type (acfg, D.31114, p.242, &p);
      i = 0;
      goto <D.24051>;
      <D.24050>:
      D.31115 = sig->sentinelpos;
      D.31116 = (int) D.31115;
      if (D.31116 == i) goto <D.31117>; else goto <D.31118>;
      <D.31117>:
      p.242 = p;
      *p.242 = 65;
      p.242 = p;
      p.243 = p.242 + 1;
      p = p.243;
      <D.31118>:
      p.242 = p;
      D.31119 = sig->params[i];
      encode_type (acfg, D.31119, p.242, &p);
      i = i + 1;
      <D.24051>:
      D.31112 = sig->param_count;
      D.31120 = (int) D.31112;
      if (D.31120 > i) goto <D.24050>; else goto <D.24052>;
      <D.24052>:
      p.242 = p;
      *endbuf = p.242;
    }
  finally
    {
      p = {CLOBBER};
    }
}


encode_generic_context (struct MonoAotCompile * acfg, struct MonoGenericContext * context, guint8 * buf, guint8 * * endbuf)
{
  unsigned int D.31123;
  unsigned int D.31124;
  _Bool D.31125;
  long int D.31126;
  long int D.31127;
  guint8 * p.244;
  guint8 * p;
  struct MonoGenericInst * inst;

  try
    {
      p = buf;
      inst = context->class_inst;
      if (inst != 0B) goto <D.31121>; else goto <D.31122>;
      <D.31121>:
      D.31123 = BIT_FIELD_REF <*inst, 32, 32>;
      D.31124 = D.31123 & 4194303;
      D.31125 = D.31124 == 0;
      D.31126 = (long int) D.31125;
      D.31127 = __builtin_expect (D.31126, 0);
      if (D.31127 != 0) goto <D.31128>; else goto <D.31129>;
      <D.31128>:
      monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "aot-compiler.c", 2425, "inst->type_argc");
      <D.31129>:
      p.244 = p;
      encode_ginst (acfg, inst, p.244, &p);
      goto <D.31131>;
      <D.31122>:
      p.244 = p;
      encode_value (0, p.244, &p);
      <D.31131>:
      inst = context->method_inst;
      if (inst != 0B) goto <D.31132>; else goto <D.31133>;
      <D.31132>:
      D.31123 = BIT_FIELD_REF <*inst, 32, 32>;
      D.31124 = D.31123 & 4194303;
      D.31125 = D.31124 == 0;
      D.31126 = (long int) D.31125;
      D.31127 = __builtin_expect (D.31126, 0);
      if (D.31127 != 0) goto <D.31134>; else goto <D.31135>;
      <D.31134>:
      monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "aot-compiler.c", 2432, "inst->type_argc");
      <D.31135>:
      p.244 = p;
      encode_ginst (acfg, inst, p.244, &p);
      goto <D.31136>;
      <D.31133>:
      p.244 = p;
      encode_value (0, p.244, &p);
      <D.31136>:
      p.244 = p;
      *endbuf = p.244;
    }
  finally
    {
      p = {CLOBBER};
    }
}


encode_type (struct MonoAotCompile * acfg, struct MonoType * t, guint8 * buf, guint8 * * endbuf)
{
  unsigned char D.31137;
  unsigned char D.31138;
  _Bool D.31139;
  long int D.31140;
  long int D.31141;
  unsigned char D.31144;
  guint8 * p.245;
  guint8 * p.246;
  unsigned char D.31149;
  unsigned char D.31152;
  int D.31153;
  struct MonoClass * D.31154;
  struct MonoClass * D.31155;
  struct MonoType * D.31156;
  struct MonoGenericClass * D.31157;
  struct MonoClass * D.31158;
  unsigned char D.31159;
  int D.31160;
  unsigned char D.31161;
  int D.31162;
  int * D.31163;
  unsigned int i.247;
  unsigned int D.31165;
  int * D.31166;
  int D.31167;
  int D.31168;
  unsigned char D.31169;
  int D.31170;
  int * D.31171;
  int * D.31172;
  int D.31173;
  int D.31174;
  struct MonoClass * D.31175;
  guint8 * p;

  try
    {
      p = buf;
      D.31137 = BIT_FIELD_REF <*t, 8, 56>;
      D.31138 = D.31137 & 63;
      D.31139 = D.31138 != 0;
      D.31140 = (long int) D.31139;
      D.31141 = __builtin_expect (D.31140, 0);
      if (D.31141 != 0) goto <D.31142>; else goto <D.31143>;
      <D.31142>:
      monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "aot-compiler.c", 2445, "t->num_mods == 0");
      <D.31143>:
      D.31137 = BIT_FIELD_REF <*t, 8, 56>;
      D.31144 = D.31137 & 128;
      if (D.31144 != 0) goto <D.31145>; else goto <D.31146>;
      <D.31145>:
      p.245 = p;
      *p.245 = 69;
      p.245 = p;
      p.246 = p.245 + 1;
      p = p.246;
      <D.31146>:
      D.31137 = BIT_FIELD_REF <*t, 8, 56>;
      D.31149 = D.31137 & 64;
      if (D.31149 != 0) goto <D.31150>; else goto <D.31151>;
      <D.31150>:
      p.245 = p;
      *p.245 = 16;
      p.245 = p;
      p.246 = p.245 + 1;
      p = p.246;
      <D.31151>:
      p.245 = p;
      D.31152 = t->type;
      *p.245 = D.31152;
      p.245 = p;
      p.246 = p.245 + 1;
      p = p.246;
      D.31152 = t->type;
      D.31153 = (int) D.31152;
      switch (D.31153) <default: <D.24040>, case 1: <D.24003>, case 2: <D.24004>, case 3: <D.24005>, case 4: <D.24006>, case 5: <D.24007>, case 6: <D.24008>, case 7: <D.24009>, case 8: <D.24010>, case 9: <D.24011>, case 10: <D.24012>, case 11: <D.24013>, case 12: <D.24014>, case 13: <D.24015>, case 14: <D.24018>, case 15: <D.24025>, case 17: <D.24022>, case 18: <D.24023>, case 19: <D.24038>, case 20: <D.24029>, case 21: <D.24026>, case 22: <D.24020>, case 24: <D.24016>, case 25: <D.24017>, case 28: <D.24019>, case 29: <D.24024>, case 30: <D.24039>>
      <D.24003>:
      <D.24004>:
      <D.24005>:
      <D.24006>:
      <D.24007>:
      <D.24008>:
      <D.24009>:
      <D.24010>:
      <D.24011>:
      <D.24012>:
      <D.24013>:
      <D.24014>:
      <D.24015>:
      <D.24016>:
      <D.24017>:
      <D.24018>:
      <D.24019>:
      <D.24020>:
      goto <D.24021>;
      <D.24022>:
      <D.24023>:
      p.245 = p;
      D.31154 = mono_class_from_mono_type (t);
      encode_klass_ref (acfg, D.31154, p.245, &p);
      goto <D.24021>;
      <D.24024>:
      p.245 = p;
      D.31155 = t->data.klass;
      encode_klass_ref (acfg, D.31155, p.245, &p);
      goto <D.24021>;
      <D.24025>:
      p.245 = p;
      D.31156 = t->data.type;
      encode_type (acfg, D.31156, p.245, &p);
      goto <D.24021>;
      <D.24026>:
      {
        struct MonoClass * gclass;
        struct MonoGenericInst * inst;

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

        array = t->data.array;
        p.245 = p;
        D.31158 = array->eklass;
        encode_klass_ref (acfg, D.31158, p.245, &p);
        p.245 = p;
        D.31159 = array->rank;
        D.31160 = (int) D.31159;
        encode_value (D.31160, p.245, &p);
        p.245 = p;
        D.31161 = array->numsizes;
        D.31162 = (int) D.31161;
        encode_value (D.31162, p.245, &p);
        i = 0;
        goto <D.24033>;
        <D.24032>:
        p.245 = p;
        D.31163 = array->sizes;
        i.247 = (unsigned int) i;
        D.31165 = i.247 * 4;
        D.31166 = D.31163 + D.31165;
        D.31167 = *D.31166;
        encode_value (D.31167, p.245, &p);
        i = i + 1;
        <D.24033>:
        D.31161 = array->numsizes;
        D.31168 = (int) D.31161;
        if (D.31168 > i) goto <D.24032>; else goto <D.24034>;
        <D.24034>:
        p.245 = p;
        D.31169 = array->numlobounds;
        D.31170 = (int) D.31169;
        encode_value (D.31170, p.245, &p);
        i = 0;
        goto <D.24036>;
        <D.24035>:
        p.245 = p;
        D.31171 = array->lobounds;
        i.247 = (unsigned int) i;
        D.31165 = i.247 * 4;
        D.31172 = D.31171 + D.31165;
        D.31173 = *D.31172;
        encode_value (D.31173, p.245, &p);
        i = i + 1;
        <D.24036>:
        D.31169 = array->numlobounds;
        D.31174 = (int) D.31169;
        if (D.31174 > i) goto <D.24035>; else goto <D.24037>;
        <D.24037>:
        goto <D.24021>;
      }
      <D.24038>:
      <D.24039>:
      p.245 = p;
      D.31175 = mono_class_from_mono_type (t);
      encode_klass_ref (acfg, D.31175, p.245, &p);
      goto <D.24021>;
      <D.24040>:
      monoeg_assertion_message ("* Assertion: should not be reached at %s:%d\n", "aot-compiler.c", 2518);
      <D.24021>:
      p.245 = p;
      *endbuf = p.245;
    }
  finally
    {
      p = {CLOBBER};
    }
}


encode_value (gint32 value, guint8 * buf, guint8 * * endbuf)
{
  unsigned int value.248;
  guint8 * p.249;
  unsigned char D.31181;
  int D.31185;
  signed char D.31186;
  signed char D.31187;
  unsigned char D.31188;
  guint8 * D.31189;
  unsigned char D.31190;
  int D.31194;
  signed char D.31195;
  signed char D.31196;
  unsigned char D.31197;
  int D.31198;
  unsigned char D.31199;
  guint8 * D.31200;
  unsigned char D.31201;
  guint8 * D.31202;
  unsigned int D.31204;
  unsigned char D.31205;
  guint8 * D.31206;
  guint8 * p;

  p = buf;
  value.248 = (unsigned int) value;
  if (value.248 <= 127) goto <D.31178>; else goto <D.31179>;
  <D.31178>:
  p.249 = p;
  p = p.249 + 1;
  D.31181 = (unsigned char) value;
  *p.249 = D.31181;
  goto <D.31182>;
  <D.31179>:
  value.248 = (unsigned int) value;
  if (value.248 <= 16383) goto <D.31183>; else goto <D.31184>;
  <D.31183>:
  D.31185 = value >> 8;
  D.31186 = (signed char) D.31185;
  D.31187 = D.31186 | -128;
  D.31188 = (unsigned char) D.31187;
  *p = D.31188;
  D.31189 = p + 1;
  D.31190 = (unsigned char) value;
  *D.31189 = D.31190;
  p = p + 2;
  goto <D.31191>;
  <D.31184>:
  value.248 = (unsigned int) value;
  if (value.248 <= 536870911) goto <D.31192>; else goto <D.31193>;
  <D.31192>:
  D.31194 = value >> 24;
  D.31195 = (signed char) D.31194;
  D.31196 = D.31195 | -64;
  D.31197 = (unsigned char) D.31196;
  *p = D.31197;
  D.31189 = p + 1;
  D.31198 = value >> 16;
  D.31199 = (unsigned char) D.31198;
  *D.31189 = D.31199;
  D.31200 = p + 2;
  D.31185 = value >> 8;
  D.31201 = (unsigned char) D.31185;
  *D.31200 = D.31201;
  D.31202 = p + 3;
  D.31190 = (unsigned char) value;
  *D.31202 = D.31190;
  p = p + 4;
  goto <D.31203>;
  <D.31193>:
  *p = 255;
  D.31189 = p + 1;
  value.248 = (unsigned int) value;
  D.31204 = value.248 >> 24;
  D.31205 = (unsigned char) D.31204;
  *D.31189 = D.31205;
  D.31200 = p + 2;
  D.31198 = value >> 16;
  D.31199 = (unsigned char) D.31198;
  *D.31200 = D.31199;
  D.31202 = p + 3;
  D.31185 = value >> 8;
  D.31201 = (unsigned char) D.31185;
  *D.31202 = D.31201;
  D.31206 = p + 4;
  D.31190 = (unsigned char) value;
  *D.31206 = D.31190;
  p = p + 5;
  <D.31203>:
  <D.31191>:
  <D.31182>:
  if (endbuf != 0B) goto <D.31207>; else goto <D.31208>;
  <D.31207>:
  *endbuf = p;
  <D.31208>:
}


encode_patch_list (struct MonoAotCompile * acfg, struct GPtrArray * patches, int n_patches, int first_got_offset, guint8 * buf, guint8 * * endbuf)
{
  guint8 * p.250;
  void * * D.31210;
  unsigned int D.31211;
  void * * D.31212;
  <unnamed type> D.31213;
  _Bool D.31214;
  _Bool D.31215;
  _Bool D.31216;
  int offset.251;
  unsigned int D.31220;
  guint8 * p;
  guint32 pindex;
  guint32 offset;
  struct MonoJumpInfo * patch_info;

  try
    {
      p = buf;
      p.250 = p;
      encode_value (n_patches, p.250, &p);
      pindex = 0;
      goto <D.25086>;
      <D.25085>:
      D.31210 = patches->pdata;
      D.31211 = pindex * 4;
      D.31212 = D.31210 + D.31211;
      patch_info = *D.31212;
      D.31213 = patch_info->type;
      D.31214 = D.31213 == 51;
      D.31215 = D.31213 == 0;
      D.31216 = D.31214 | D.31215;
      if (D.31216 != 0) goto <D.31217>; else goto <D.31218>;
      <D.31217>:
      // predicted unlikely by continue predictor.
      goto <D.25084>;
      <D.31218>:
      offset = get_got_offset (acfg, patch_info);
      p.250 = p;
      offset.251 = (int) offset;
      encode_value (offset.251, p.250, &p);
      <D.25084>:
      pindex = pindex + 1;
      <D.25086>:
      D.31220 = patches->len;
      if (D.31220 > pindex) goto <D.25085>; else goto <D.25087>;
      <D.25087>:
      p.250 = p;
      *endbuf = p.250;
    }
  finally
    {
      p = {CLOBBER};
    }
}


add_to_blob (struct MonoAotCompile * acfg, const guint8 * data, guint32 data_len)
{
  unsigned int D.31221;
  struct MonoDynamicStream * D.31224;
  guint32 D.31225;

  D.31221 = acfg->blob.alloc_size;
  if (D.31221 == 0) goto <D.31222>; else goto <D.31223>;
  <D.31222>:
  D.31224 = &acfg->blob;
  stream_init (D.31224);
  <D.31223>:
  D.31224 = &acfg->blob;
  D.31225 = add_stream_data (D.31224, data, data_len);
  return D.31225;
}


stream_init (struct MonoDynamicStream * sh)
{
  void * D.31227;
  char * D.31228;
  unsigned int D.31229;
  unsigned int D.31230;

  sh->index = 0;
  sh->alloc_size = 4096;
  D.31227 = monoeg_malloc (4096);
  sh->data = D.31227;
  D.31228 = sh->data;
  *D.31228 = 0;
  D.31229 = sh->index;
  D.31230 = D.31229 + 1;
  sh->index = D.31230;
}


add_stream_data (struct MonoDynamicStream * stream, const char * data, guint32 len)
{
  unsigned int D.31231;
  unsigned int D.31232;
  int D.31233;
  char * D.31234;
  char * D.31235;
  guint32 D.31236;
  guint32 idx;

  D.31231 = stream->index;
  D.31232 = D.31231 + len;
  D.31233 = (int) D.31232;
  make_room_in_stream (stream, D.31233);
  D.31234 = stream->data;
  D.31231 = stream->index;
  D.31235 = D.31234 + D.31231;
  memcpy (D.31235, data, len);
  idx = stream->index;
  D.31231 = stream->index;
  D.31232 = D.31231 + len;
  stream->index = D.31232;
  D.31236 = idx;
  return D.31236;
}


make_room_in_stream (struct MonoDynamicStream * stream, int size)
{
  unsigned int size.252;
  unsigned int D.31239;
  unsigned int D.31245;
  char * D.31246;
  void * D.31247;

  size.252 = (unsigned int) size;
  D.31239 = stream->alloc_size;
  if (size.252 <= D.31239) goto <D.31240>; else goto <D.31241>;
  <D.31240>:
  return;
  <D.31241>:
  goto <D.23865>;
  <D.23864>:
  D.31239 = stream->alloc_size;
  if (D.31239 <= 4095) goto <D.31242>; else goto <D.31243>;
  <D.31242>:
  stream->alloc_size = 4096;
  goto <D.31244>;
  <D.31243>:
  D.31239 = stream->alloc_size;
  D.31245 = D.31239 * 2;
  stream->alloc_size = D.31245;
  <D.31244>:
  <D.23865>:
  D.31239 = stream->alloc_size;
  size.252 = (unsigned int) size;
  if (D.31239 <= size.252) goto <D.23864>; else goto <D.23866>;
  <D.23866>:
  D.31239 = stream->alloc_size;
  D.31246 = stream->data;
  D.31247 = monoeg_realloc (D.31246, D.31239);
  stream->data = D.31247;
}


emit_offset_table (struct MonoAotCompile * acfg, int noffsets, int group_size, gint32 * offsets)
{
  int D.31249;
  int D.31250;
  unsigned int ngroups.253;
  unsigned int D.31252;
  unsigned int buf_size.254;
  int D.31254;
  int D.31257;
  unsigned int D.31258;
  unsigned int D.31259;
  guint32 * D.31260;
  guint8 * p.255;
  int p.256;
  int buf.257;
  int D.31264;
  unsigned int D.31265;
  unsigned int i.258;
  unsigned int D.31267;
  gint32 * D.31268;
  int D.31269;
  int D.31271;
  sizetype ngroups.259;
  sizetype D.31276;
  sizetype D.31277;
  guint32 * D.31278;
  unsigned int D.31279;
  guint32 * D.31283;
  unsigned int D.31284;
  int D.31285;
  guint32 D.31287;
  int D.31288;
  int D.31289;
  gint32 current_offset;
  int i;
  int buf_size;
  int ngroups;
  int index_entry_size;
  guint8 * p;
  guint8 * buf;
  guint32 * index_offsets;

  try
    {
      D.31249 = group_size + -1;
      D.31250 = D.31249 + noffsets;
      ngroups = D.31250 / group_size;
      ngroups.253 = (unsigned int) ngroups;
      D.31252 = ngroups.253 * 4;
      index_offsets = monoeg_malloc0 (D.31252);
      buf_size = noffsets * 4;
      buf_size.254 = (unsigned int) buf_size;
      buf = monoeg_malloc0 (buf_size.254);
      p = buf;
      current_offset = 0;
      i = 0;
      goto <D.23901>;
      <D.23900>:
      D.31254 = i % group_size;
      if (D.31254 == 0) goto <D.31255>; else goto <D.31256>;
      <D.31255>:
      D.31257 = i / group_size;
      D.31258 = (unsigned int) D.31257;
      D.31259 = D.31258 * 4;
      D.31260 = index_offsets + D.31259;
      p.255 = p;
      p.256 = (int) p.255;
      buf.257 = (int) buf;
      D.31264 = p.256 - buf.257;
      D.31265 = (unsigned int) D.31264;
      *D.31260 = D.31265;
      p.255 = p;
      i.258 = (unsigned int) i;
      D.31267 = i.258 * 4;
      D.31268 = offsets + D.31267;
      D.31269 = *D.31268;
      encode_value (D.31269, p.255, &p);
      goto <D.31270>;
      <D.31256>:
      p.255 = p;
      i.258 = (unsigned int) i;
      D.31267 = i.258 * 4;
      D.31268 = offsets + D.31267;
      D.31269 = *D.31268;
      D.31271 = D.31269 - current_offset;
      encode_value (D.31271, p.255, &p);
      <D.31270>:
      i.258 = (unsigned int) i;
      D.31267 = i.258 * 4;
      D.31268 = offsets + D.31267;
      current_offset = *D.31268;
      i = i + 1;
      <D.23901>:
      if (i < noffsets) goto <D.23900>; else goto <D.23902>;
      <D.23902>:
      if (ngroups != 0) goto <D.31274>; else goto <D.31272>;
      <D.31274>:
      ngroups.259 = (sizetype) ngroups;
      D.31276 = ngroups.259 + 1073741823;
      D.31277 = D.31276 * 4;
      D.31278 = index_offsets + D.31277;
      D.31279 = *D.31278;
      if (D.31279 <= 64999) goto <D.31280>; else goto <D.31272>;
      <D.31280>:
      index_entry_size = 2;
      goto <D.31273>;
      <D.31272>:
      index_entry_size = 4;
      <D.31273>:
      emit_int32 (acfg, noffsets);
      emit_int32 (acfg, group_size);
      emit_int32 (acfg, ngroups);
      emit_int32 (acfg, index_entry_size);
      i = 0;
      goto <D.23904>;
      <D.23903>:
      if (index_entry_size == 2) goto <D.31281>; else goto <D.31282>;
      <D.31281>:
      i.258 = (unsigned int) i;
      D.31267 = i.258 * 4;
      D.31283 = index_offsets + D.31267;
      D.31284 = *D.31283;
      D.31285 = (int) D.31284;
      emit_int16 (acfg, D.31285);
      goto <D.31286>;
      <D.31282>:
      i.258 = (unsigned int) i;
      D.31267 = i.258 * 4;
      D.31283 = index_offsets + D.31267;
      D.31284 = *D.31283;
      D.31285 = (int) D.31284;
      emit_int32 (acfg, D.31285);
      <D.31286>:
      i = i + 1;
      <D.23904>:
      if (i < ngroups) goto <D.23903>; else goto <D.23905>;
      <D.23905>:
      p.255 = p;
      p.256 = (int) p.255;
      buf.257 = (int) buf;
      D.31264 = p.256 - buf.257;
      emit_bytes (acfg, buf, D.31264);
      p.255 = p;
      p.256 = (int) p.255;
      buf.257 = (int) buf;
      D.31264 = p.256 - buf.257;
      D.31288 = ngroups * 4;
      D.31289 = D.31264 + D.31288;
      D.31287 = (guint32) D.31289;
      return D.31287;
    }
  finally
    {
      p = {CLOBBER};
    }
}


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

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


emit_extra_methods (struct MonoAotCompile * acfg)
{
  struct GPtrArray * D.31293;
  unsigned int D.31294;
  unsigned int D.31295;
  void * * D.31296;
  unsigned int i.260;
  unsigned int D.31298;
  void * * D.31299;
  struct GHashTable * D.31300;
  unsigned int buf_size.261;
  guint8 * p.262;
  int p.263;
  int buf.264;
  int D.31307;
  _Bool D.31308;
  long int D.31309;
  long int D.31310;
  guint32 * D.31313;
  unsigned int D.31314;
  unsigned int D.31315;
  unsigned int i.265;
  double D.31317;
  double D.31318;
  int D.31319;
  unsigned int D.31320;
  unsigned int D.31321;
  unsigned int table_size.266;
  unsigned int table_size.267;
  unsigned int D.31324;
  unsigned int D.31327;
  unsigned int table_size.268;
  unsigned int D.31329;
  int * D.31330;
  int D.31331;
  int D.31332;
  struct MonoMemPool * D.31333;
  void * * D.31334;
  void * * D.31335;
  struct HashEntry * D.31339;
  unsigned int D.31340;
  void * * D.31341;
  unsigned int D.31345;
  int D.31346;
  unsigned int D.31347;
  int D.31348;
  struct HashEntry * D.31349;
  unsigned int D.31352;
  int D.31353;
  int D.31355;
  unsigned int D.31356;
  int D.31357;
  unsigned int D.31358;
  int D.31359;
  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.31293 = acfg->extra_methods;
      D.31294 = D.31293->len;
      D.31295 = D.31294 * 4;
      info_offsets = monoeg_malloc0 (D.31295);
      nmethods = 0;
      i = 0;
      goto <D.25798>;
      <D.25797>:
      {
        struct MonoMethod * method;
        struct MonoCompile * cfg;

        D.31293 = acfg->extra_methods;
        D.31296 = D.31293->pdata;
        i.260 = (unsigned int) i;
        D.31298 = i.260 * 4;
        D.31299 = D.31296 + D.31298;
        method = *D.31299;
        D.31300 = acfg->method_to_cfg;
        cfg = monoeg_g_hash_table_lookup (D.31300, method);
        if (cfg == 0B) goto <D.31301>; else goto <D.31302>;
        <D.31301>:
        // predicted unlikely by continue predictor.
        goto <D.25796>;
        <D.31302>:
        buf_size = 10240;
        buf_size.261 = (unsigned int) buf_size;
        buf = monoeg_malloc (buf_size.261);
        p = buf;
        nmethods = nmethods + 1;
        method = cfg->method_to_register;
        p.262 = p;
        encode_method_ref (acfg, method, p.262, &p);
        p.262 = p;
        p.263 = (int) p.262;
        buf.264 = (int) buf;
        D.31307 = p.263 - buf.264;
        D.31308 = D.31307 >= buf_size;
        D.31309 = (long int) D.31308;
        D.31310 = __builtin_expect (D.31309, 0);
        if (D.31310 != 0) goto <D.31311>; else goto <D.31312>;
        <D.31311>:
        monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "aot-compiler.c", 7508, "(p - buf) < buf_size");
        <D.31312>:
        i.260 = (unsigned int) i;
        D.31298 = i.260 * 4;
        D.31313 = info_offsets + D.31298;
        p.262 = p;
        p.263 = (int) p.262;
        buf.264 = (int) buf;
        D.31307 = p.263 - buf.264;
        D.31314 = (unsigned int) D.31307;
        D.31315 = add_to_blob (acfg, buf, D.31314);
        *D.31313 = D.31315;
        monoeg_g_free (buf);
      }
      <D.25796>:
      i = i + 1;
      <D.25798>:
      i.265 = (unsigned int) i;
      D.31293 = acfg->extra_methods;
      D.31294 = D.31293->len;
      if (i.265 < D.31294) goto <D.25797>; else goto <D.25799>;
      <D.25799>:
      D.31317 = (double) nmethods;
      D.31318 = D.31317 * 1.5e+0;
      D.31319 = (int) D.31318;
      D.31320 = (unsigned int) D.31319;
      D.31321 = monoeg_g_spaced_primes_closest (D.31320);
      table_size = (int) D.31321;
      table_size.266 = (unsigned int) table_size;
      table = monoeg_g_ptr_array_sized_new (table_size.266);
      i = 0;
      goto <D.25801>;
      <D.25800>:
      monoeg_g_ptr_array_add (table, 0B);
      i = i + 1;
      <D.25801>:
      if (i < table_size) goto <D.25800>; else goto <D.25802>;
      <D.25802>:
      table_size.267 = (unsigned int) table_size;
      D.31324 = table_size.267 * 4;
      chain_lengths = monoeg_malloc0 (D.31324);
      max_chain_length = 0;
      i = 0;
      goto <D.25812>;
      <D.25811>:
      {
        struct MonoMethod * method;
        struct MonoCompile * cfg;
        guint32 key;
        guint32 value;

        D.31293 = acfg->extra_methods;
        D.31296 = D.31293->pdata;
        i.260 = (unsigned int) i;
        D.31298 = i.260 * 4;
        D.31299 = D.31296 + D.31298;
        method = *D.31299;
        D.31300 = acfg->method_to_cfg;
        cfg = monoeg_g_hash_table_lookup (D.31300, method);
        if (cfg == 0B) goto <D.31325>; else goto <D.31326>;
        <D.31325>:
        // predicted unlikely by continue predictor.
        goto <D.25807>;
        <D.31326>:
        i.260 = (unsigned int) i;
        D.31298 = i.260 * 4;
        D.31313 = info_offsets + D.31298;
        key = *D.31313;
        value = get_method_index (acfg, method);
        D.31327 = mono_aot_method_hash (method);
        table_size.268 = (unsigned int) table_size;
        hash = D.31327 % table_size.268;
        D.31329 = hash * 4;
        D.31330 = chain_lengths + D.31329;
        D.31331 = *D.31330;
        D.31332 = D.31331 + 1;
        *D.31330 = D.31332;
        D.31329 = hash * 4;
        D.31330 = chain_lengths + D.31329;
        D.31331 = *D.31330;
        max_chain_length = MAX_EXPR <D.31331, max_chain_length>;
        D.31333 = acfg->mempool;
        new_entry = mono_mempool_alloc0 (D.31333, 16);
        new_entry->key = key;
        new_entry->value = value;
        D.31334 = table->pdata;
        D.31329 = hash * 4;
        D.31335 = D.31334 + D.31329;
        entry = *D.31335;
        if (entry == 0B) goto <D.31336>; else goto <D.31337>;
        <D.31336>:
        new_entry->index = hash;
        D.31334 = table->pdata;
        D.31329 = hash * 4;
        D.31335 = D.31334 + D.31329;
        *D.31335 = new_entry;
        goto <D.31338>;
        <D.31337>:
        goto <D.25809>;
        <D.25808>:
        entry = entry->next;
        <D.25809>:
        D.31339 = entry->next;
        if (D.31339 != 0B) goto <D.25808>; else goto <D.25810>;
        <D.25810>:
        entry->next = new_entry;
        D.31340 = table->len;
        new_entry->index = D.31340;
        monoeg_g_ptr_array_add (table, new_entry);
        <D.31338>:
      }
      <D.25807>:
      i = i + 1;
      <D.25812>:
      i.265 = (unsigned int) i;
      D.31293 = acfg->extra_methods;
      D.31294 = D.31293->len;
      if (i.265 < D.31294) goto <D.25811>; else goto <D.25813>;
      <D.25813>:
      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.25816>;
      <D.25815>:
      {
        struct HashEntry * entry;

        D.31334 = table->pdata;
        i.260 = (unsigned int) i;
        D.31298 = i.260 * 4;
        D.31341 = D.31334 + D.31298;
        entry = *D.31341;
        if (entry == 0B) goto <D.31342>; else goto <D.31343>;
        <D.31342>:
        emit_int32 (acfg, 0);
        emit_int32 (acfg, 0);
        emit_int32 (acfg, 0);
        goto <D.31344>;
        <D.31343>:
        D.31345 = entry->key;
        D.31346 = (int) D.31345;
        emit_int32 (acfg, D.31346);
        D.31347 = entry->value;
        D.31348 = (int) D.31347;
        emit_int32 (acfg, D.31348);
        D.31349 = entry->next;
        if (D.31349 != 0B) goto <D.31350>; else goto <D.31351>;
        <D.31350>:
        D.31349 = entry->next;
        D.31352 = D.31349->index;
        D.31353 = (int) D.31352;
        emit_int32 (acfg, D.31353);
        goto <D.31354>;
        <D.31351>:
        emit_int32 (acfg, 0);
        <D.31354>:
        <D.31344>:
      }
      i = i + 1;
      <D.25816>:
      i.265 = (unsigned int) i;
      D.31340 = table->len;
      if (i.265 < D.31340) goto <D.25815>; else goto <D.25817>;
      <D.25817>:
      sprintf (&symbol, "extra_method_info_offsets");
      emit_section_change (acfg, ".rodata", 0);
      emit_alignment (acfg, 8);
      emit_label (acfg, &symbol);
      D.31293 = acfg->extra_methods;
      D.31294 = D.31293->len;
      D.31355 = (int) D.31294;
      emit_int32 (acfg, D.31355);
      i = 0;
      goto <D.25820>;
      <D.25819>:
      {
        struct MonoMethod * method;

        D.31293 = acfg->extra_methods;
        D.31296 = D.31293->pdata;
        i.260 = (unsigned int) i;
        D.31298 = i.260 * 4;
        D.31299 = D.31296 + D.31298;
        method = *D.31299;
        D.31356 = get_method_index (acfg, method);
        D.31357 = (int) D.31356;
        emit_int32 (acfg, D.31357);
        i.260 = (unsigned int) i;
        D.31298 = i.260 * 4;
        D.31313 = info_offsets + D.31298;
        D.31358 = *D.31313;
        D.31359 = (int) D.31358;
        emit_int32 (acfg, D.31359);
      }
      i = i + 1;
      <D.25820>:
      i.265 = (unsigned int) i;
      D.31293 = acfg->extra_methods;
      D.31294 = D.31293->len;
      if (i.265 < D.31294) goto <D.25819>; else goto <D.25821>;
      <D.25821>:
    }
  finally
    {
      symbol = {CLOBBER};
      p = {CLOBBER};
    }
}


emit_trampolines (struct MonoAotCompile * acfg)
{
  int D.31360;
  struct MonoImage * D.31363;
  struct MonoAssembly * D.31364;
  _Bool D.31365;
  long int D.31366;
  long int D.31367;
  int D.25310;
  int iftmp.269;
  int D.25309;
  const char[9] * D.31373;
  unsigned char D.31374;
  int D.31375;
  unsigned char D.31376;
  int D.31377;
  _Bool D.31378;
  _Bool D.31379;
  _Bool D.31380;
  const unsigned char * D.31383;
  unsigned char D.31384;
  int D.31385;
  const unsigned char * D.31386;
  unsigned char D.31387;
  int D.31388;
  _Bool D.31389;
  _Bool D.31390;
  const unsigned char * D.31393;
  unsigned char D.31394;
  int D.31395;
  const unsigned char * D.31396;
  unsigned char D.31397;
  int D.31398;
  _Bool D.31399;
  _Bool D.31400;
  const unsigned char * D.31403;
  unsigned char D.31404;
  int D.31405;
  const unsigned char * D.31406;
  unsigned char D.31407;
  int D.31408;
  const char * D.31410;
  int iftmp.270;
  int D.31414;
  <unnamed type> tramp_type.271;
  struct MonoTrampInfo * info.272;
  unsigned int D.31420;
  int D.31421;
  gchar * D.31424;
  unsigned int offset.273;
  unsigned int i.274;
  unsigned int D.31427;
  int D.31428;
  int D.31429;
  unsigned int tramp_got_offset.275;
  unsigned int D.31433;
  int tramp_size.276;
  _Bool D.31437;
  long int D.31438;
  long int D.31439;
  unsigned int tramp_size.277;
  unsigned int i.278;
  unsigned int D.31444;
  unsigned int D.31445;
  unsigned int D.31446;
  unsigned int D.31447;
  char symbol[256];
  char end_symbol[256];
  int i;
  int tramp_got_offset;
  MonoAotTrampoline ntype;
  int tramp_type;

  try
    {
      D.31360 = acfg->aot_opts.full_aot;
      if (D.31360 == 0) goto <D.31361>; else goto <D.31362>;
      <D.31361>:
      return;
      <D.31362>:
      D.31363 = acfg->image;
      D.31364 = D.31363->assembly;
      D.31365 = D.31364 == 0B;
      D.31366 = (long int) D.31365;
      D.31367 = __builtin_expect (D.31366, 0);
      if (D.31367 != 0) goto <D.31368>; else goto <D.31369>;
      <D.31368>:
      monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "aot-compiler.c", 5896, "acfg->image->assembly");
      <D.31369>:
      {
        size_t __s1_len;
        size_t __s2_len;

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

          D.31363 = acfg->image;
          D.31364 = D.31363->assembly;
          __s2 = D.31364->aname.name;
          D.31373 = "mscorlib";
          D.31374 = MEM[(const unsigned char *)D.31373];
          D.31375 = (int) D.31374;
          D.31376 = *__s2;
          D.31377 = (int) D.31376;
          __result = D.31375 - D.31377;
          {
            D.31378 = __s2_len != 0;
            D.31379 = __result == 0;
            D.31380 = D.31378 & D.31379;
            if (D.31380 != 0) goto <D.31381>; else goto <D.31382>;
            <D.31381>:
            D.31383 = &MEM[(void *)"mscorlib" + 1B];
            D.31384 = *D.31383;
            D.31385 = (int) D.31384;
            D.31386 = __s2 + 1;
            D.31387 = *D.31386;
            D.31388 = (int) D.31387;
            __result = D.31385 - D.31388;
            D.31389 = __s2_len > 1;
            D.31379 = __result == 0;
            D.31390 = D.31389 & D.31379;
            if (D.31390 != 0) goto <D.31391>; else goto <D.31392>;
            <D.31391>:
            D.31393 = &MEM[(void *)"mscorlib" + 2B];
            D.31394 = *D.31393;
            D.31395 = (int) D.31394;
            D.31396 = __s2 + 2;
            D.31397 = *D.31396;
            D.31398 = (int) D.31397;
            __result = D.31395 - D.31398;
            D.31399 = __s2_len > 2;
            D.31379 = __result == 0;
            D.31400 = D.31399 & D.31379;
            if (D.31400 != 0) goto <D.31401>; else goto <D.31402>;
            <D.31401>:
            D.31403 = &MEM[(void *)"mscorlib" + 3B];
            D.31404 = *D.31403;
            D.31405 = (int) D.31404;
            D.31406 = __s2 + 3;
            D.31407 = *D.31406;
            D.31408 = (int) D.31407;
            __result = D.31405 - D.31408;
            <D.31402>:
            <D.31392>:
            <D.31382>:
          }
          D.25309 = __result;
        }
        iftmp.269 = -D.25309;
        goto <D.31409>;
        <D.31372>:
        D.31363 = acfg->image;
        D.31364 = D.31363->assembly;
        D.31410 = D.31364->aname.name;
        iftmp.269 = __builtin_strcmp (D.31410, "mscorlib");
        <D.31409>:
        D.25310 = iftmp.269;
      }
      if (D.25310 == 0) goto <D.31411>; else goto <D.31412>;
      <D.31411>:
      {
        struct MonoTrampInfo * info;

        try
          {
            tramp_type = 0;
            goto <D.25313>;
            <D.25312>:
            D.31414 = acfg->aot_opts.use_trampolines_page;
            if (D.31414 != 0) goto <D.31415>; else goto <D.31416>;
            <D.31415>:
            iftmp.270 = 2;
            goto <D.31417>;
            <D.31416>:
            iftmp.270 = 1;
            <D.31417>:
            tramp_type.271 = (<unnamed type>) tramp_type;
            mono_arch_create_generic_trampoline (tramp_type.271, &info, iftmp.270);
            info.272 = info;
            D.31420 = acfg->got_offset;
            D.31421 = (int) D.31420;
            emit_trampoline (acfg, D.31421, info.272);
            tramp_type = tramp_type + 1;
            <D.25313>:
            if (tramp_type <= 13) goto <D.25312>; else goto <D.25314>;
            <D.25314>:
            mono_arch_get_nullified_class_init_trampoline (&info);
            info.272 = info;
            D.31420 = acfg->got_offset;
            D.31421 = (int) D.31420;
            emit_trampoline (acfg, D.31421, info.272);
            mono_arch_create_monitor_enter_trampoline (&info, 1);
            info.272 = info;
            D.31420 = acfg->got_offset;
            D.31421 = (int) D.31420;
            emit_trampoline (acfg, D.31421, info.272);
            mono_arch_create_monitor_exit_trampoline (&info, 1);
            info.272 = info;
            D.31420 = acfg->got_offset;
            D.31421 = (int) D.31420;
            emit_trampoline (acfg, D.31421, info.272);
            mono_arch_create_generic_class_init_trampoline (&info, 1);
            info.272 = info;
            D.31420 = acfg->got_offset;
            D.31421 = (int) D.31420;
            emit_trampoline (acfg, D.31421, info.272);
            mono_arch_get_restore_context (&info, 1);
            info.272 = info;
            D.31420 = acfg->got_offset;
            D.31421 = (int) D.31420;
            emit_trampoline (acfg, D.31421, info.272);
            mono_arch_get_call_filter (&info, 1);
            info.272 = info;
            D.31420 = acfg->got_offset;
            D.31421 = (int) D.31420;
            emit_trampoline (acfg, D.31421, info.272);
            mono_arch_get_throw_exception (&info, 1);
            info.272 = info;
            D.31420 = acfg->got_offset;
            D.31421 = (int) D.31420;
            emit_trampoline (acfg, D.31421, info.272);
            mono_arch_get_rethrow_exception (&info, 1);
            info.272 = info;
            D.31420 = acfg->got_offset;
            D.31421 = (int) D.31420;
            emit_trampoline (acfg, D.31421, info.272);
            mono_arch_get_throw_corlib_exception (&info, 1);
            info.272 = info;
            D.31420 = acfg->got_offset;
            D.31421 = (int) D.31420;
            emit_trampoline (acfg, D.31421, info.272);
            mono_arch_get_gsharedvt_trampoline (&info, 1);
            info.272 = info;
            if (info.272 != 0B) goto <D.31422>; else goto <D.31423>;
            <D.31422>:
            info.272 = info;
            D.31420 = acfg->got_offset;
            D.31421 = (int) D.31420;
            emit_trampoline_full (acfg, D.31421, info.272, 1);
            info.272 = info;
            D.31424 = monoeg_strdup ("gsharedvt_out_trampoline");
            info.272->name = D.31424;
            info.272 = info;
            D.31420 = acfg->got_offset;
            D.31421 = (int) D.31420;
            emit_trampoline_full (acfg, D.31421, info.272, 1);
            <D.31423>:
            {
              struct GSList * l;

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

                info = l->data;
                D.31420 = acfg->got_offset;
                D.31421 = (int) D.31420;
                emit_trampoline (acfg, D.31421, info);
                l = l->next;
              }
              <D.25318>:
              if (l != 0B) goto <D.25317>; else goto <D.25319>;
              <D.25319>:
            }
            i = 0;
            goto <D.25322>;
            <D.25321>:
            {
              int offset;

              offset = i;
              offset.273 = (unsigned int) offset;
              mono_arch_create_rgctx_lazy_fetch_trampoline (offset.273, &info, 1);
              info.272 = info;
              D.31420 = acfg->got_offset;
              D.31421 = (int) D.31420;
              emit_trampoline (acfg, D.31421, info.272);
              i.274 = (unsigned int) i;
              D.31427 = i.274 | 2147483648;
              offset = (int) D.31427;
              offset.273 = (unsigned int) offset;
              mono_arch_create_rgctx_lazy_fetch_trampoline (offset.273, &info, 1);
              info.272 = info;
              D.31420 = acfg->got_offset;
              D.31421 = (int) D.31420;
              emit_trampoline (acfg, D.31421, info.272);
            }
            i = i + 1;
            <D.25322>:
            D.31428 = acfg->aot_opts.nrgctx_fetch_trampolines;
            if (D.31428 > i) goto <D.25321>; else goto <D.25323>;
            <D.25323>:
            mono_arch_create_general_rgctx_lazy_fetch_trampoline (&info, 1);
            info.272 = info;
            D.31420 = acfg->got_offset;
            D.31421 = (int) D.31420;
            emit_trampoline (acfg, D.31421, info.272);
            {
              struct GSList * l;

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

                info = l->data;
                D.31420 = acfg->got_offset;
                D.31421 = (int) D.31420;
                emit_trampoline (acfg, D.31421, info);
                l = l->next;
              }
              <D.25327>:
              if (l != 0B) goto <D.25326>; else goto <D.25328>;
              <D.25328>:
            }
            emit_section_change (acfg, ".text", 0);
            D.31420 = acfg->got_offset;
            tramp_got_offset = (int) D.31420;
            ntype = 0;
            goto <D.25346>;
            <D.25345>:
            switch (ntype) <default: <D.25334>, case 0: <D.25329>, case 1: <D.25331>, case 2: <D.25332>, case 3: <D.25333>>
            <D.25329>:
            sprintf (&symbol, "specific_trampolines");
            goto <D.25330>;
            <D.25331>:
            sprintf (&symbol, "static_rgctx_trampolines");
            goto <D.25330>;
            <D.25332>:
            sprintf (&symbol, "imt_thunks");
            goto <D.25330>;
            <D.25333>:
            sprintf (&symbol, "gsharedvt_arg_trampolines");
            goto <D.25330>;
            <D.25334>:
            monoeg_assertion_message ("* Assertion: should not be reached at %s:%d\n", "aot-compiler.c", 6053);
            <D.25330>:
            sprintf (&end_symbol, "%s_e", &symbol);
            D.31429 = acfg->aot_opts.write_symbols;
            if (D.31429 != 0) goto <D.31430>; else goto <D.31431>;
            <D.31430>:
            emit_local_symbol (acfg, &symbol, &end_symbol, 1);
            <D.31431>:
            emit_alignment (acfg, 16);
            emit_label (acfg, &symbol);
            tramp_got_offset.275 = (unsigned int) tramp_got_offset;
            acfg->trampoline_got_offset_base[ntype] = tramp_got_offset.275;
            i = 0;
            goto <D.25343>;
            <D.25342>:
            {
              int tramp_size;

              try
                {
                  tramp_size = 0;
                  switch (ntype) <default: <D.25341>, case 0: <D.25336>, case 1: <D.25338>, case 2: <D.25339>, case 3: <D.25340>>
                  <D.25336>:
                  arch_emit_specific_trampoline (acfg, tramp_got_offset, &tramp_size);
                  tramp_got_offset = tramp_got_offset + 2;
                  goto <D.25337>;
                  <D.25338>:
                  arch_emit_static_rgctx_trampoline (acfg, tramp_got_offset, &tramp_size);
                  tramp_got_offset = tramp_got_offset + 2;
                  goto <D.25337>;
                  <D.25339>:
                  arch_emit_imt_thunk (acfg, tramp_got_offset, &tramp_size);
                  tramp_got_offset = tramp_got_offset + 1;
                  goto <D.25337>;
                  <D.25340>:
                  arch_emit_gsharedvt_arg_trampoline (acfg, tramp_got_offset, &tramp_size);
                  tramp_got_offset = tramp_got_offset + 2;
                  goto <D.25337>;
                  <D.25341>:
                  monoeg_assertion_message ("* Assertion: should not be reached at %s:%d\n", "aot-compiler.c", 6087);
                  <D.25337>:
                  D.31433 = acfg->trampoline_size[ntype];
                  if (D.31433 == 0) goto <D.31434>; else goto <D.31435>;
                  <D.31434>:
                  tramp_size.276 = tramp_size;
                  D.31437 = tramp_size.276 == 0;
                  D.31438 = (long int) D.31437;
                  D.31439 = __builtin_expect (D.31438, 0);
                  if (D.31439 != 0) goto <D.31440>; else goto <D.31441>;
                  <D.31440>:
                  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "aot-compiler.c", 6095, "tramp_size");
                  <D.31441>:
                  tramp_size.276 = tramp_size;
                  tramp_size.277 = (unsigned int) tramp_size.276;
                  acfg->trampoline_size[ntype] = tramp_size.277;
                  <D.31435>:
                }
              finally
                {
                  tramp_size = {CLOBBER};
                }
            }
            i = i + 1;
            <D.25343>:
            i.278 = (unsigned int) i;
            D.31444 = acfg->num_trampolines[ntype];
            if (i.278 < D.31444) goto <D.25342>; else goto <D.25344>;
            <D.25344>:
            emit_label (acfg, &end_symbol);
            emit_int32 (acfg, 0);
            ntype = ntype + 1;
            <D.25346>:
            if (ntype <= 3) goto <D.25345>; else goto <D.25347>;
            <D.25347>:
            arch_emit_specific_trampoline_pages (acfg);
            tramp_got_offset.275 = (unsigned int) tramp_got_offset;
            D.31420 = acfg->got_offset;
            D.31445 = tramp_got_offset.275 - D.31420;
            acfg->num_trampoline_got_entries = D.31445;
          }
        finally
          {
            info = {CLOBBER};
          }
      }
      <D.31412>:
      D.31420 = acfg->got_offset;
      D.31446 = acfg->num_trampoline_got_entries;
      D.31447 = D.31420 + D.31446;
      acfg->got_offset = D.31447;
    }
  finally
    {
      symbol = {CLOBBER};
      end_symbol = {CLOBBER};
    }
}


emit_trampoline_full (struct MonoAotCompile * acfg, int got_offset, struct MonoTrampInfo * info, gboolean emit_tinfo)
{
  _Bool D.31451;
  long int D.31452;
  long int D.31453;
  const char * D.31456;
  const char * D.31457;
  <unnamed type> D.31460;
  unsigned int D.31463;
  unsigned int D.31464;
  guint8 * p.279;
  int D.31466;
  int p.280;
  int buf.281;
  int D.31469;
  unsigned int D.31470;
  _Bool D.31471;
  long int D.31472;
  long int D.31473;
  int info_offset.282;
  struct GSList * D.31479;
  unsigned int encoded_len.283;
  int uw_offset.284;
  struct MonoDwarfWriter * D.31484;
  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.31451 = info == 0B;
      D.31452 = (long int) D.31451;
      D.31453 = __builtin_expect (D.31452, 0);
      if (D.31453 != 0) goto <D.31454>; else goto <D.31455>;
      <D.31454>:
      monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "aot-compiler.c", 5785, "info");
      <D.31455>:
      name = info->name;
      code = info->code;
      code_size = info->code_size;
      ji = info->ji;
      unwind_ops = info->unwind_ops;
      D.31456 = acfg->user_symbol_prefix;
      sprintf (&start_symbol, "%s%s", D.31456, name);
      emit_section_change (acfg, ".text", 0);
      emit_global (acfg, &start_symbol, 1);
      emit_alignment (acfg, 16);
      emit_label (acfg, &start_symbol);
      D.31457 = acfg->temp_prefix;
      sprintf (&symbol, "%snamed_%s", D.31457, 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.31458>; else goto <D.31459>;
      <D.31458>:
      D.31457 = acfg->temp_prefix;
      sprintf (&end_symbol, "%snamede_%s", D.31457, name);
      emit_label (acfg, &end_symbol);
      <D.31459>:
      patches = monoeg_g_ptr_array_new ();
      patch_info = ji;
      goto <D.25282>;
      <D.25281>:
      D.31460 = patch_info->type;
      if (D.31460 != 51) goto <D.31461>; else goto <D.31462>;
      <D.31461>:
      monoeg_g_ptr_array_add (patches, patch_info);
      <D.31462>:
      patch_info = patch_info->next;
      <D.25282>:
      if (patch_info != 0B) goto <D.25281>; else goto <D.25283>;
      <D.25283>:
      monoeg_g_ptr_array_sort (patches, compare_patches);
      D.31463 = patches->len;
      D.31464 = D.31463 + 1;
      buf_size = D.31464 * 128;
      buf = monoeg_malloc (buf_size);
      p = buf;
      p.279 = p;
      D.31463 = patches->len;
      D.31466 = (int) D.31463;
      encode_patch_list (acfg, patches, D.31466, got_offset, p.279, &p);
      p.279 = p;
      p.280 = (int) p.279;
      buf.281 = (int) buf;
      D.31469 = p.280 - buf.281;
      D.31470 = (unsigned int) D.31469;
      D.31471 = D.31470 >= buf_size;
      D.31472 = (long int) D.31471;
      D.31473 = __builtin_expect (D.31472, 0);
      if (D.31473 != 0) goto <D.31474>; else goto <D.31475>;
      <D.31474>:
      monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "aot-compiler.c", 5836, "p - buf < buf_size");
      <D.31475>:
      D.31456 = acfg->user_symbol_prefix;
      sprintf (&symbol, "%s%s_p", D.31456, name);
      p.279 = p;
      p.280 = (int) p.279;
      buf.281 = (int) buf;
      D.31469 = p.280 - buf.281;
      D.31470 = (unsigned int) D.31469;
      info_offset = add_to_blob (acfg, buf, D.31470);
      emit_section_change (acfg, ".rodata", 0);
      emit_global (acfg, &symbol, 0);
      emit_label (acfg, &symbol);
      info_offset.282 = (int) info_offset;
      emit_int32 (acfg, info_offset.282);
      if (emit_tinfo != 0) goto <D.31477>; else goto <D.31478>;
      <D.31477>:
      {
        guint8 * encoded;
        guint32 encoded_len;
        guint32 uw_offset;

        try
          {
            D.31479 = info->unwind_ops;
            encoded = mono_unwind_ops_encode (D.31479, &encoded_len);
            encoded_len.283 = encoded_len;
            uw_offset = get_unwind_info_offset (acfg, encoded, encoded_len.283);
            monoeg_g_free (encoded);
            emit_symbol_diff (acfg, &end_symbol, &start_symbol, 0);
            uw_offset.284 = (int) uw_offset;
            emit_int32 (acfg, uw_offset.284);
          }
        finally
          {
            encoded_len = {CLOBBER};
          }
      }
      <D.31478>:
      if (unwind_ops != 0B) goto <D.31482>; else goto <D.31483>;
      <D.31482>:
      {
        char symbol2[256];

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


emit_global (struct MonoAotCompile * acfg, const char * name, gboolean func)
{
  int D.31487;
  gchar * D.31490;
  struct GPtrArray * D.31491;
  struct MonoImageWriter * D.31492;

  D.31487 = acfg->aot_opts.no_dlsym;
  if (D.31487 != 0) goto <D.31488>; else goto <D.31489>;
  <D.31488>:
  D.31490 = monoeg_strdup (name);
  D.31491 = acfg->globals;
  monoeg_g_ptr_array_add (D.31491, D.31490);
  D.31492 = acfg->w;
  img_writer_emit_local_symbol (D.31492, name, 0B, func);
  goto <D.31493>;
  <D.31489>:
  D.31492 = acfg->w;
  img_writer_emit_global (D.31492, name, func);
  <D.31493>:
}


get_unwind_info_offset (struct MonoAotCompile * acfg, guint8 * encoded, guint32 encoded_len)
{
  unsigned int D.31494;
  const void * D.31495;
  struct GHashTable * D.31496;
  void * D.31497;
  guint32 D.31500;
  unsigned int D.31501;
  void * D.31502;
  void * D.31503;
  void * cache_index.285;
  struct GPtrArray * D.31505;
  guint8 * p.286;
  int encoded_len.287;
  unsigned int D.31508;
  int p.288;
  int buf.289;
  int D.31511;
  unsigned int D.31512;
  unsigned int D.31513;
  unsigned int D.31514;
  guint32 cache_index;
  guint32 offset;

  cache_index = mono_cache_unwind_info (encoded, encoded_len);
  D.31494 = cache_index + 1;
  D.31495 = (const void *) D.31494;
  D.31496 = acfg->unwind_info_offsets;
  D.31497 = monoeg_g_hash_table_lookup (D.31496, D.31495);
  offset = (guint32) D.31497;
  if (offset != 0) goto <D.31498>; else goto <D.31499>;
  <D.31498>:
  D.31500 = offset + 4294967295;
  return D.31500;
  <D.31499>:
  {
    guint8 buf[16];
    guint8 * p;

    try
      {
        offset = acfg->unwind_info_offset;
        D.31501 = offset + 1;
        D.31502 = (void *) D.31501;
        D.31494 = cache_index + 1;
        D.31503 = (void *) D.31494;
        D.31496 = acfg->unwind_info_offsets;
        monoeg_g_hash_table_insert_replace (D.31496, D.31503, D.31502, 0);
        cache_index.285 = (void *) cache_index;
        D.31505 = acfg->unwind_ops;
        monoeg_g_ptr_array_add (D.31505, cache_index.285);
        p = &buf;
        p.286 = p;
        encoded_len.287 = (int) encoded_len;
        encode_value (encoded_len.287, p.286, &p);
        D.31508 = acfg->unwind_info_offset;
        p.286 = p;
        p.288 = (int) p.286;
        buf.289 = (int) &buf;
        D.31511 = p.288 - buf.289;
        D.31512 = (unsigned int) D.31511;
        D.31513 = D.31512 + encoded_len;
        D.31514 = D.31508 + D.31513;
        acfg->unwind_info_offset = D.31514;
        D.31500 = offset;
        return D.31500;
      }
    finally
      {
        buf = {CLOBBER};
        p = {CLOBBER};
      }
  }
}


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


arch_emit_specific_trampoline (struct MonoAotCompile * acfg, int offset, int * tramp_size)
{
  guint8 * code.290;
  guint8 * code.291;
  guint8 * code.292;
  guint8 * code.293;
  guint8 * code.294;
  guint8 * code.295;
  guint8 * code.296;
  guint8 * code.297;
  guint8 * code.298;
  guint8 * code.299;
  unsigned char D.31537;
  guint8 * code.300;
  unsigned char D.31539;
  guint8 * code.301;
  unsigned char D.31541;
  guint8 * code.302;
  unsigned char D.31543;
  guint8 * code.303;
  guint8 * code.304;
  guint8 * code.305;
  guint8 * code.306;
  unsigned char D.31553;
  guint8 * code.307;
  unsigned char D.31555;
  guint8 * code.308;
  unsigned char D.31557;
  guint8 * code.309;
  unsigned char D.31559;
  guint8 * code.310;
  int D.31563;
  unsigned int D.31564;
  unsigned int D.31565;
  guint8 * code.311;
  guint8 * code.312;
  int D.31573;
  guint8 * code.313;
  guint8 * code.314;
  unsigned char D.31578;
  unsigned char D.31579;
  guint8 * code.315;
  guint8 * code.316;
  guint8 * code.317;
  unsigned char D.31583;
  guint8 * code.318;
  unsigned char D.31585;
  guint8 * code.319;
  unsigned char D.31587;
  guint8 * code.320;
  unsigned char D.31589;
  guint8 * code.321;
  guint8 * code.322;
  guint8 * code.323;
  guint8 * code.324;
  unsigned char D.31600;
  guint8 * code.325;
  unsigned char D.31602;
  guint8 * code.326;
  unsigned char D.31604;
  guint8 * code.327;
  unsigned char D.31606;
  guint8 * code.328;
  guint8 * code.329;
  guint8 * code.330;
  unsigned int offset.331;
  unsigned int D.31613;
  guint8 * code.332;
  guint8 * code.333;
  int D.31621;
  guint8 * code.334;
  guint8 * code.335;
  unsigned char D.31626;
  unsigned char D.31627;
  guint8 * code.336;
  guint8 * code.337;
  guint8 * code.338;
  unsigned char D.31631;
  guint8 * code.339;
  unsigned char D.31633;
  guint8 * code.340;
  unsigned char D.31635;
  guint8 * code.341;
  unsigned char D.31637;
  guint8 * code.342;
  guint8 * code.343;
  guint8 * code.344;
  guint8 * code.345;
  unsigned char D.31648;
  guint8 * code.346;
  unsigned char D.31650;
  guint8 * code.347;
  unsigned char D.31652;
  guint8 * code.348;
  unsigned char D.31654;
  guint8 * code.349;
  guint8 * code.350;
  int code.351;
  int buf.352;
  int D.31659;
  int D.31660;
  _Bool D.31661;
  long int D.31662;
  long int D.31663;
  guint8 buf[128];
  guint8 * code;
  static const char __PRETTY_FUNCTION__[30] = "arch_emit_specific_trampoline";

  try
    {
      if (0 != 0) goto <D.31517>; else goto <D.31518>;
      <D.31517>:
      monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "aot-compiler.c", 1348, "MONO_ARCH_MONITOR_OBJECT_REG != X86_ECX");
      <D.31518>:
      code = &buf;
      switch (4) <default: <D.23666>, case 1: <D.23662>, case 2: <D.23664>, case 4: <D.23665>>
      <D.23662>:
      code.290 = code;
      code = code.290 + 1;
      *code.290 = 138;
      goto <D.23663>;
      <D.23664>:
      code.291 = code;
      code = code.291 + 1;
      *code.291 = 102;
      <D.23665>:
      code.292 = code;
      code = code.292 + 1;
      *code.292 = 139;
      goto <D.23663>;
      <D.23666>:
      __assert_fail ("0", "aot-compiler.c", 1353, &__PRETTY_FUNCTION__);
      <D.23663>:
      if (0 != 0) goto <D.31522>; else goto <D.31523>;
      <D.31522>:
      if (0 != 0) goto <D.31524>; else goto <D.31525>;
      <D.31524>:
      code.293 = code;
      code = code.293 + 1;
      *code.293 = 12;
      code.294 = code;
      code = code.294 + 1;
      *code.294 = 36;
      goto <D.31528>;
      <D.31525>:
      if (1 != 0) goto <D.31529>; else goto <D.31530>;
      <D.31529>:
      code.295 = code;
      code = code.295 + 1;
      *code.295 = 76;
      code.296 = code;
      code = code.296 + 1;
      *code.296 = 36;
      *code = 4;
      code = code + 1;
      goto <D.31533>;
      <D.31530>:
      code.297 = code;
      code = code.297 + 1;
      *code.297 = 140;
      code.298 = code;
      code = code.298 + 1;
      *code.298 = 36;
      {
        union x86_imm_buf imb;

        try
          {
            imb.val = 4;
            code.299 = code;
            code = code.299 + 1;
            D.31537 = imb.b[0];
            *code.299 = D.31537;
            code.300 = code;
            code = code.300 + 1;
            D.31539 = imb.b[1];
            *code.300 = D.31539;
            code.301 = code;
            code = code.301 + 1;
            D.31541 = imb.b[2];
            *code.301 = D.31541;
            code.302 = code;
            code = code.302 + 1;
            D.31543 = imb.b[3];
            *code.302 = D.31543;
          }
        finally
          {
            imb = {CLOBBER};
          }
      }
      <D.31533>:
      <D.31528>:
      goto <D.23669>;
      <D.31523>:
      if (0 != 0) goto <D.31544>; else goto <D.31545>;
      <D.31544>:
      code.303 = code;
      code = code.303 + 1;
      *code.303 = 11;
      goto <D.23669>;
      <D.31545>:
      if (1 != 0) goto <D.31547>; else goto <D.31548>;
      <D.31547>:
      code.304 = code;
      code = code.304 + 1;
      *code.304 = 75;
      *code = 4;
      code = code + 1;
      goto <D.31550>;
      <D.31548>:
      code.305 = code;
      code = code.305 + 1;
      *code.305 = 139;
      {
        union x86_imm_buf imb;

        try
          {
            imb.val = 4;
            code.306 = code;
            code = code.306 + 1;
            D.31553 = imb.b[0];
            *code.306 = D.31553;
            code.307 = code;
            code = code.307 + 1;
            D.31555 = imb.b[1];
            *code.307 = D.31555;
            code.308 = code;
            code = code.308 + 1;
            D.31557 = imb.b[2];
            *code.308 = D.31557;
            code.309 = code;
            code = code.309 + 1;
            D.31559 = imb.b[3];
            *code.309 = D.31559;
          }
        finally
          {
            imb = {CLOBBER};
          }
      }
      <D.31550>:
      <D.23669>:
      code.310 = code;
      code = code.310 + 1;
      *code.310 = 255;
      if (0 != 0) goto <D.31561>; else goto <D.31562>;
      <D.31561>:
      D.31563 = offset + 1;
      D.31564 = (unsigned int) D.31563;
      D.31565 = D.31564 * 4;
      if (D.31565 == 0) goto <D.31566>; else goto <D.31567>;
      <D.31566>:
      code.311 = code;
      code = code.311 + 1;
      *code.311 = 52;
      code.312 = code;
      code = code.312 + 1;
      *code.312 = 36;
      goto <D.31570>;
      <D.31567>:
      D.31563 = offset + 1;
      D.31564 = (unsigned int) D.31563;
      D.31565 = D.31564 * 4;
      D.31573 = (int) D.31565;
      if (D.31573 >= -128) goto <D.31574>; else goto <D.31571>;
      <D.31574>:
      D.31563 = offset + 1;
      D.31564 = (unsigned int) D.31563;
      D.31565 = D.31564 * 4;
      D.31573 = (int) D.31565;
      if (D.31573 <= 127) goto <D.31575>; else goto <D.31571>;
      <D.31575>:
      code.313 = code;
      code = code.313 + 1;
      *code.313 = 116;
      code.314 = code;
      code = code.314 + 1;
      *code.314 = 36;
      D.31563 = offset + 1;
      D.31578 = (unsigned char) D.31563;
      D.31579 = D.31578 * 4;
      *code = D.31579;
      code = code + 1;
      goto <D.31572>;
      <D.31571>:
      code.315 = code;
      code = code.315 + 1;
      *code.315 = 180;
      code.316 = code;
      code = code.316 + 1;
      *code.316 = 36;
      {
        union x86_imm_buf imb;

        try
          {
            D.31563 = offset + 1;
            D.31564 = (unsigned int) D.31563;
            D.31565 = D.31564 * 4;
            D.31573 = (int) D.31565;
            imb.val = D.31573;
            code.317 = code;
            code = code.317 + 1;
            D.31583 = imb.b[0];
            *code.317 = D.31583;
            code.318 = code;
            code = code.318 + 1;
            D.31585 = imb.b[1];
            *code.318 = D.31585;
            code.319 = code;
            code = code.319 + 1;
            D.31587 = imb.b[2];
            *code.319 = D.31587;
            code.320 = code;
            code = code.320 + 1;
            D.31589 = imb.b[3];
            *code.320 = D.31589;
          }
        finally
          {
            imb = {CLOBBER};
          }
      }
      <D.31572>:
      <D.31570>:
      goto <D.23672>;
      <D.31562>:
      D.31563 = offset + 1;
      D.31564 = (unsigned int) D.31563;
      D.31565 = D.31564 * 4;
      if (D.31565 == 0) goto <D.31590>; else goto <D.31591>;
      <D.31590>:
      code.321 = code;
      code = code.321 + 1;
      *code.321 = 49;
      goto <D.23672>;
      <D.31591>:
      D.31563 = offset + 1;
      D.31564 = (unsigned int) D.31563;
      D.31565 = D.31564 * 4;
      D.31573 = (int) D.31565;
      if (D.31573 >= -128) goto <D.31595>; else goto <D.31593>;
      <D.31595>:
      D.31563 = offset + 1;
      D.31564 = (unsigned int) D.31563;
      D.31565 = D.31564 * 4;
      D.31573 = (int) D.31565;
      if (D.31573 <= 127) goto <D.31596>; else goto <D.31593>;
      <D.31596>:
      code.322 = code;
      code = code.322 + 1;
      *code.322 = 113;
      D.31563 = offset + 1;
      D.31578 = (unsigned char) D.31563;
      D.31579 = D.31578 * 4;
      *code = D.31579;
      code = code + 1;
      goto <D.31594>;
      <D.31593>:
      code.323 = code;
      code = code.323 + 1;
      *code.323 = 177;
      {
        union x86_imm_buf imb;

        try
          {
            D.31563 = offset + 1;
            D.31564 = (unsigned int) D.31563;
            D.31565 = D.31564 * 4;
            D.31573 = (int) D.31565;
            imb.val = D.31573;
            code.324 = code;
            code = code.324 + 1;
            D.31600 = imb.b[0];
            *code.324 = D.31600;
            code.325 = code;
            code = code.325 + 1;
            D.31602 = imb.b[1];
            *code.325 = D.31602;
            code.326 = code;
            code = code.326 + 1;
            D.31604 = imb.b[2];
            *code.326 = D.31604;
            code.327 = code;
            code = code.327 + 1;
            D.31606 = imb.b[3];
            *code.327 = D.31606;
          }
        finally
          {
            imb = {CLOBBER};
          }
      }
      <D.31594>:
      <D.23672>:
      switch (4) <default: <D.23678>, case 1: <D.23674>, case 2: <D.23676>, case 4: <D.23677>>
      <D.23674>:
      code.328 = code;
      code = code.328 + 1;
      *code.328 = 138;
      goto <D.23675>;
      <D.23676>:
      code.329 = code;
      code = code.329 + 1;
      *code.329 = 102;
      <D.23677>:
      code.330 = code;
      code = code.330 + 1;
      *code.330 = 139;
      goto <D.23675>;
      <D.23678>:
      __assert_fail ("0", "aot-compiler.c", 1357, &__PRETTY_FUNCTION__);
      <D.23675>:
      if (0 != 0) goto <D.31610>; else goto <D.31611>;
      <D.31610>:
      offset.331 = (unsigned int) offset;
      D.31613 = offset.331 * 4;
      if (D.31613 == 0) goto <D.31614>; else goto <D.31615>;
      <D.31614>:
      code.332 = code;
      code = code.332 + 1;
      *code.332 = 12;
      code.333 = code;
      code = code.333 + 1;
      *code.333 = 36;
      goto <D.31618>;
      <D.31615>:
      offset.331 = (unsigned int) offset;
      D.31613 = offset.331 * 4;
      D.31621 = (int) D.31613;
      if (D.31621 >= -128) goto <D.31622>; else goto <D.31619>;
      <D.31622>:
      offset.331 = (unsigned int) offset;
      D.31613 = offset.331 * 4;
      D.31621 = (int) D.31613;
      if (D.31621 <= 127) goto <D.31623>; else goto <D.31619>;
      <D.31623>:
      code.334 = code;
      code = code.334 + 1;
      *code.334 = 76;
      code.335 = code;
      code = code.335 + 1;
      *code.335 = 36;
      D.31626 = (unsigned char) offset;
      D.31627 = D.31626 * 4;
      *code = D.31627;
      code = code + 1;
      goto <D.31620>;
      <D.31619>:
      code.336 = code;
      code = code.336 + 1;
      *code.336 = 140;
      code.337 = code;
      code = code.337 + 1;
      *code.337 = 36;
      {
        union x86_imm_buf imb;

        try
          {
            offset.331 = (unsigned int) offset;
            D.31613 = offset.331 * 4;
            D.31621 = (int) D.31613;
            imb.val = D.31621;
            code.338 = code;
            code = code.338 + 1;
            D.31631 = imb.b[0];
            *code.338 = D.31631;
            code.339 = code;
            code = code.339 + 1;
            D.31633 = imb.b[1];
            *code.339 = D.31633;
            code.340 = code;
            code = code.340 + 1;
            D.31635 = imb.b[2];
            *code.340 = D.31635;
            code.341 = code;
            code = code.341 + 1;
            D.31637 = imb.b[3];
            *code.341 = D.31637;
          }
        finally
          {
            imb = {CLOBBER};
          }
      }
      <D.31620>:
      <D.31618>:
      goto <D.23680>;
      <D.31611>:
      offset.331 = (unsigned int) offset;
      D.31613 = offset.331 * 4;
      if (D.31613 == 0) goto <D.31638>; else goto <D.31639>;
      <D.31638>:
      code.342 = code;
      code = code.342 + 1;
      *code.342 = 9;
      goto <D.23680>;
      <D.31639>:
      offset.331 = (unsigned int) offset;
      D.31613 = offset.331 * 4;
      D.31621 = (int) D.31613;
      if (D.31621 >= -128) goto <D.31643>; else goto <D.31641>;
      <D.31643>:
      offset.331 = (unsigned int) offset;
      D.31613 = offset.331 * 4;
      D.31621 = (int) D.31613;
      if (D.31621 <= 127) goto <D.31644>; else goto <D.31641>;
      <D.31644>:
      code.343 = code;
      code = code.343 + 1;
      *code.343 = 73;
      D.31626 = (unsigned char) offset;
      D.31627 = D.31626 * 4;
      *code = D.31627;
      code = code + 1;
      goto <D.31642>;
      <D.31641>:
      code.344 = code;
      code = code.344 + 1;
      *code.344 = 137;
      {
        union x86_imm_buf imb;

        try
          {
            offset.331 = (unsigned int) offset;
            D.31613 = offset.331 * 4;
            D.31621 = (int) D.31613;
            imb.val = D.31621;
            code.345 = code;
            code = code.345 + 1;
            D.31648 = imb.b[0];
            *code.345 = D.31648;
            code.346 = code;
            code = code.346 + 1;
            D.31650 = imb.b[1];
            *code.346 = D.31650;
            code.347 = code;
            code = code.347 + 1;
            D.31652 = imb.b[2];
            *code.347 = D.31652;
            code.348 = code;
            code = code.348 + 1;
            D.31654 = imb.b[3];
            *code.348 = D.31654;
          }
        finally
          {
            imb = {CLOBBER};
          }
      }
      <D.31642>:
      <D.23680>:
      code.349 = code;
      code = code.349 + 1;
      *code.349 = 255;
      code.350 = code;
      code = code.350 + 1;
      *code.350 = 225;
      code.351 = (int) code;
      buf.352 = (int) &buf;
      D.31659 = code.351 - buf.352;
      emit_bytes (acfg, &buf, D.31659);
      *tramp_size = 17;
      code.351 = (int) code;
      buf.352 = (int) &buf;
      D.31659 = code.351 - buf.352;
      D.31660 = *tramp_size;
      D.31661 = D.31659 != D.31660;
      D.31662 = (long int) D.31661;
      D.31663 = __builtin_expect (D.31662, 0);
      if (D.31663 != 0) goto <D.31664>; else goto <D.31665>;
      <D.31664>:
      monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "aot-compiler.c", 1371, "code - buf == *tramp_size");
      <D.31665>:
    }
  finally
    {
      buf = {CLOBBER};
    }
}


arch_emit_static_rgctx_trampoline (struct MonoAotCompile * acfg, int offset, int * tramp_size)
{
  guint8 * code.353;
  guint8 * code.354;
  guint8 * code.355;
  guint8 * code.356;
  guint8 * code.357;
  guint8 * code.358;
  guint8 * code.359;
  guint8 * code.360;
  guint8 * code.361;
  guint8 * code.362;
  unsigned char D.31686;
  guint8 * code.363;
  unsigned char D.31688;
  guint8 * code.364;
  unsigned char D.31690;
  guint8 * code.365;
  unsigned char D.31692;
  guint8 * code.366;
  guint8 * code.367;
  guint8 * code.368;
  guint8 * code.369;
  unsigned char D.31702;
  guint8 * code.370;
  unsigned char D.31704;
  guint8 * code.371;
  unsigned char D.31706;
  guint8 * code.372;
  unsigned char D.31708;
  guint8 * code.373;
  guint8 * code.374;
  guint8 * code.375;
  unsigned int offset.376;
  unsigned int D.31715;
  guint8 * code.377;
  guint8 * code.378;
  int D.31723;
  guint8 * code.379;
  guint8 * code.380;
  unsigned char D.31728;
  unsigned char D.31729;
  guint8 * code.381;
  guint8 * code.382;
  guint8 * code.383;
  unsigned char D.31733;
  guint8 * code.384;
  unsigned char D.31735;
  guint8 * code.385;
  unsigned char D.31737;
  guint8 * code.386;
  unsigned char D.31739;
  guint8 * code.387;
  guint8 * code.388;
  guint8 * code.389;
  guint8 * code.390;
  unsigned char D.31750;
  guint8 * code.391;
  unsigned char D.31752;
  guint8 * code.392;
  unsigned char D.31754;
  guint8 * code.393;
  unsigned char D.31756;
  guint8 * code.394;
  int D.31760;
  unsigned int D.31761;
  unsigned int D.31762;
  guint8 * code.395;
  guint8 * code.396;
  int D.31770;
  guint8 * code.397;
  guint8 * code.398;
  unsigned char D.31775;
  unsigned char D.31776;
  guint8 * code.399;
  guint8 * code.400;
  guint8 * code.401;
  unsigned char D.31780;
  guint8 * code.402;
  unsigned char D.31782;
  guint8 * code.403;
  unsigned char D.31784;
  guint8 * code.404;
  unsigned char D.31786;
  guint8 * code.405;
  guint8 * code.406;
  guint8 * code.407;
  guint8 * code.408;
  unsigned char D.31797;
  guint8 * code.409;
  unsigned char D.31799;
  guint8 * code.410;
  unsigned char D.31801;
  guint8 * code.411;
  unsigned char D.31803;
  int code.412;
  int buf.413;
  int D.31806;
  int D.31807;
  _Bool D.31808;
  long int D.31809;
  long int D.31810;
  guint8 buf[128];
  guint8 * code;
  static const char __PRETTY_FUNCTION__[34] = "arch_emit_static_rgctx_trampoline";

  try
    {
      if (0 != 0) goto <D.31666>; else goto <D.31667>;
      <D.31666>:
      monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "aot-compiler.c", 1577, "MONO_ARCH_RGCTX_REG != X86_ECX");
      <D.31667>:
      code = &buf;
      switch (4) <default: <D.23709>, case 1: <D.23705>, case 2: <D.23707>, case 4: <D.23708>>
      <D.23705>:
      code.353 = code;
      code = code.353 + 1;
      *code.353 = 138;
      goto <D.23706>;
      <D.23707>:
      code.354 = code;
      code = code.354 + 1;
      *code.354 = 102;
      <D.23708>:
      code.355 = code;
      code = code.355 + 1;
      *code.355 = 139;
      goto <D.23706>;
      <D.23709>:
      __assert_fail ("0", "aot-compiler.c", 1581, &__PRETTY_FUNCTION__);
      <D.23706>:
      if (0 != 0) goto <D.31671>; else goto <D.31672>;
      <D.31671>:
      if (0 != 0) goto <D.31673>; else goto <D.31674>;
      <D.31673>:
      code.356 = code;
      code = code.356 + 1;
      *code.356 = 12;
      code.357 = code;
      code = code.357 + 1;
      *code.357 = 36;
      goto <D.31677>;
      <D.31674>:
      if (1 != 0) goto <D.31678>; else goto <D.31679>;
      <D.31678>:
      code.358 = code;
      code = code.358 + 1;
      *code.358 = 76;
      code.359 = code;
      code = code.359 + 1;
      *code.359 = 36;
      *code = 4;
      code = code + 1;
      goto <D.31682>;
      <D.31679>:
      code.360 = code;
      code = code.360 + 1;
      *code.360 = 140;
      code.361 = code;
      code = code.361 + 1;
      *code.361 = 36;
      {
        union x86_imm_buf imb;

        try
          {
            imb.val = 4;
            code.362 = code;
            code = code.362 + 1;
            D.31686 = imb.b[0];
            *code.362 = D.31686;
            code.363 = code;
            code = code.363 + 1;
            D.31688 = imb.b[1];
            *code.363 = D.31688;
            code.364 = code;
            code = code.364 + 1;
            D.31690 = imb.b[2];
            *code.364 = D.31690;
            code.365 = code;
            code = code.365 + 1;
            D.31692 = imb.b[3];
            *code.365 = D.31692;
          }
        finally
          {
            imb = {CLOBBER};
          }
      }
      <D.31682>:
      <D.31677>:
      goto <D.23712>;
      <D.31672>:
      if (0 != 0) goto <D.31693>; else goto <D.31694>;
      <D.31693>:
      code.366 = code;
      code = code.366 + 1;
      *code.366 = 11;
      goto <D.23712>;
      <D.31694>:
      if (1 != 0) goto <D.31696>; else goto <D.31697>;
      <D.31696>:
      code.367 = code;
      code = code.367 + 1;
      *code.367 = 75;
      *code = 4;
      code = code + 1;
      goto <D.31699>;
      <D.31697>:
      code.368 = code;
      code = code.368 + 1;
      *code.368 = 139;
      {
        union x86_imm_buf imb;

        try
          {
            imb.val = 4;
            code.369 = code;
            code = code.369 + 1;
            D.31702 = imb.b[0];
            *code.369 = D.31702;
            code.370 = code;
            code = code.370 + 1;
            D.31704 = imb.b[1];
            *code.370 = D.31704;
            code.371 = code;
            code = code.371 + 1;
            D.31706 = imb.b[2];
            *code.371 = D.31706;
            code.372 = code;
            code = code.372 + 1;
            D.31708 = imb.b[3];
            *code.372 = D.31708;
          }
        finally
          {
            imb = {CLOBBER};
          }
      }
      <D.31699>:
      <D.23712>:
      switch (4) <default: <D.23718>, case 1: <D.23714>, case 2: <D.23716>, case 4: <D.23717>>
      <D.23714>:
      code.373 = code;
      code = code.373 + 1;
      *code.373 = 138;
      goto <D.23715>;
      <D.23716>:
      code.374 = code;
      code = code.374 + 1;
      *code.374 = 102;
      <D.23717>:
      code.375 = code;
      code = code.375 + 1;
      *code.375 = 139;
      goto <D.23715>;
      <D.23718>:
      __assert_fail ("0", "aot-compiler.c", 1583, &__PRETTY_FUNCTION__);
      <D.23715>:
      if (0 != 0) goto <D.31712>; else goto <D.31713>;
      <D.31712>:
      offset.376 = (unsigned int) offset;
      D.31715 = offset.376 * 4;
      if (D.31715 == 0) goto <D.31716>; else goto <D.31717>;
      <D.31716>:
      code.377 = code;
      code = code.377 + 1;
      *code.377 = 20;
      code.378 = code;
      code = code.378 + 1;
      *code.378 = 36;
      goto <D.31720>;
      <D.31717>:
      offset.376 = (unsigned int) offset;
      D.31715 = offset.376 * 4;
      D.31723 = (int) D.31715;
      if (D.31723 >= -128) goto <D.31724>; else goto <D.31721>;
      <D.31724>:
      offset.376 = (unsigned int) offset;
      D.31715 = offset.376 * 4;
      D.31723 = (int) D.31715;
      if (D.31723 <= 127) goto <D.31725>; else goto <D.31721>;
      <D.31725>:
      code.379 = code;
      code = code.379 + 1;
      *code.379 = 84;
      code.380 = code;
      code = code.380 + 1;
      *code.380 = 36;
      D.31728 = (unsigned char) offset;
      D.31729 = D.31728 * 4;
      *code = D.31729;
      code = code + 1;
      goto <D.31722>;
      <D.31721>:
      code.381 = code;
      code = code.381 + 1;
      *code.381 = 148;
      code.382 = code;
      code = code.382 + 1;
      *code.382 = 36;
      {
        union x86_imm_buf imb;

        try
          {
            offset.376 = (unsigned int) offset;
            D.31715 = offset.376 * 4;
            D.31723 = (int) D.31715;
            imb.val = D.31723;
            code.383 = code;
            code = code.383 + 1;
            D.31733 = imb.b[0];
            *code.383 = D.31733;
            code.384 = code;
            code = code.384 + 1;
            D.31735 = imb.b[1];
            *code.384 = D.31735;
            code.385 = code;
            code = code.385 + 1;
            D.31737 = imb.b[2];
            *code.385 = D.31737;
            code.386 = code;
            code = code.386 + 1;
            D.31739 = imb.b[3];
            *code.386 = D.31739;
          }
        finally
          {
            imb = {CLOBBER};
          }
      }
      <D.31722>:
      <D.31720>:
      goto <D.23720>;
      <D.31713>:
      offset.376 = (unsigned int) offset;
      D.31715 = offset.376 * 4;
      if (D.31715 == 0) goto <D.31740>; else goto <D.31741>;
      <D.31740>:
      code.387 = code;
      code = code.387 + 1;
      *code.387 = 17;
      goto <D.23720>;
      <D.31741>:
      offset.376 = (unsigned int) offset;
      D.31715 = offset.376 * 4;
      D.31723 = (int) D.31715;
      if (D.31723 >= -128) goto <D.31745>; else goto <D.31743>;
      <D.31745>:
      offset.376 = (unsigned int) offset;
      D.31715 = offset.376 * 4;
      D.31723 = (int) D.31715;
      if (D.31723 <= 127) goto <D.31746>; else goto <D.31743>;
      <D.31746>:
      code.388 = code;
      code = code.388 + 1;
      *code.388 = 81;
      D.31728 = (unsigned char) offset;
      D.31729 = D.31728 * 4;
      *code = D.31729;
      code = code + 1;
      goto <D.31744>;
      <D.31743>:
      code.389 = code;
      code = code.389 + 1;
      *code.389 = 145;
      {
        union x86_imm_buf imb;

        try
          {
            offset.376 = (unsigned int) offset;
            D.31715 = offset.376 * 4;
            D.31723 = (int) D.31715;
            imb.val = D.31723;
            code.390 = code;
            code = code.390 + 1;
            D.31750 = imb.b[0];
            *code.390 = D.31750;
            code.391 = code;
            code = code.391 + 1;
            D.31752 = imb.b[1];
            *code.391 = D.31752;
            code.392 = code;
            code = code.392 + 1;
            D.31754 = imb.b[2];
            *code.392 = D.31754;
            code.393 = code;
            code = code.393 + 1;
            D.31756 = imb.b[3];
            *code.393 = D.31756;
          }
        finally
          {
            imb = {CLOBBER};
          }
      }
      <D.31744>:
      <D.23720>:
      code.394 = code;
      code = code.394 + 1;
      *code.394 = 255;
      if (0 != 0) goto <D.31758>; else goto <D.31759>;
      <D.31758>:
      D.31760 = offset + 1;
      D.31761 = (unsigned int) D.31760;
      D.31762 = D.31761 * 4;
      if (D.31762 == 0) goto <D.31763>; else goto <D.31764>;
      <D.31763>:
      code.395 = code;
      code = code.395 + 1;
      *code.395 = 36;
      code.396 = code;
      code = code.396 + 1;
      *code.396 = 36;
      goto <D.31767>;
      <D.31764>:
      D.31760 = offset + 1;
      D.31761 = (unsigned int) D.31760;
      D.31762 = D.31761 * 4;
      D.31770 = (int) D.31762;
      if (D.31770 >= -128) goto <D.31771>; else goto <D.31768>;
      <D.31771>:
      D.31760 = offset + 1;
      D.31761 = (unsigned int) D.31760;
      D.31762 = D.31761 * 4;
      D.31770 = (int) D.31762;
      if (D.31770 <= 127) goto <D.31772>; else goto <D.31768>;
      <D.31772>:
      code.397 = code;
      code = code.397 + 1;
      *code.397 = 100;
      code.398 = code;
      code = code.398 + 1;
      *code.398 = 36;
      D.31760 = offset + 1;
      D.31775 = (unsigned char) D.31760;
      D.31776 = D.31775 * 4;
      *code = D.31776;
      code = code + 1;
      goto <D.31769>;
      <D.31768>:
      code.399 = code;
      code = code.399 + 1;
      *code.399 = 164;
      code.400 = code;
      code = code.400 + 1;
      *code.400 = 36;
      {
        union x86_imm_buf imb;

        try
          {
            D.31760 = offset + 1;
            D.31761 = (unsigned int) D.31760;
            D.31762 = D.31761 * 4;
            D.31770 = (int) D.31762;
            imb.val = D.31770;
            code.401 = code;
            code = code.401 + 1;
            D.31780 = imb.b[0];
            *code.401 = D.31780;
            code.402 = code;
            code = code.402 + 1;
            D.31782 = imb.b[1];
            *code.402 = D.31782;
            code.403 = code;
            code = code.403 + 1;
            D.31784 = imb.b[2];
            *code.403 = D.31784;
            code.404 = code;
            code = code.404 + 1;
            D.31786 = imb.b[3];
            *code.404 = D.31786;
          }
        finally
          {
            imb = {CLOBBER};
          }
      }
      <D.31769>:
      <D.31767>:
      goto <D.23723>;
      <D.31759>:
      D.31760 = offset + 1;
      D.31761 = (unsigned int) D.31760;
      D.31762 = D.31761 * 4;
      if (D.31762 == 0) goto <D.31787>; else goto <D.31788>;
      <D.31787>:
      code.405 = code;
      code = code.405 + 1;
      *code.405 = 33;
      goto <D.23723>;
      <D.31788>:
      D.31760 = offset + 1;
      D.31761 = (unsigned int) D.31760;
      D.31762 = D.31761 * 4;
      D.31770 = (int) D.31762;
      if (D.31770 >= -128) goto <D.31792>; else goto <D.31790>;
      <D.31792>:
      D.31760 = offset + 1;
      D.31761 = (unsigned int) D.31760;
      D.31762 = D.31761 * 4;
      D.31770 = (int) D.31762;
      if (D.31770 <= 127) goto <D.31793>; else goto <D.31790>;
      <D.31793>:
      code.406 = code;
      code = code.406 + 1;
      *code.406 = 97;
      D.31760 = offset + 1;
      D.31775 = (unsigned char) D.31760;
      D.31776 = D.31775 * 4;
      *code = D.31776;
      code = code + 1;
      goto <D.31791>;
      <D.31790>:
      code.407 = code;
      code = code.407 + 1;
      *code.407 = 161;
      {
        union x86_imm_buf imb;

        try
          {
            D.31760 = offset + 1;
            D.31761 = (unsigned int) D.31760;
            D.31762 = D.31761 * 4;
            D.31770 = (int) D.31762;
            imb.val = D.31770;
            code.408 = code;
            code = code.408 + 1;
            D.31797 = imb.b[0];
            *code.408 = D.31797;
            code.409 = code;
            code = code.409 + 1;
            D.31799 = imb.b[1];
            *code.409 = D.31799;
            code.410 = code;
            code = code.410 + 1;
            D.31801 = imb.b[2];
            *code.410 = D.31801;
            code.411 = code;
            code = code.411 + 1;
            D.31803 = imb.b[3];
            *code.411 = D.31803;
          }
        finally
          {
            imb = {CLOBBER};
          }
      }
      <D.31791>:
      <D.23723>:
      code.412 = (int) code;
      buf.413 = (int) &buf;
      D.31806 = code.412 - buf.413;
      emit_bytes (acfg, &buf, D.31806);
      *tramp_size = 15;
      code.412 = (int) code;
      buf.413 = (int) &buf;
      D.31806 = code.412 - buf.413;
      D.31807 = *tramp_size;
      D.31808 = D.31806 != D.31807;
      D.31809 = (long int) D.31808;
      D.31810 = __builtin_expect (D.31809, 0);
      if (D.31810 != 0) goto <D.31811>; else goto <D.31812>;
      <D.31811>:
      monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "aot-compiler.c", 1598, "code - buf == *tramp_size");
      <D.31812>:
    }
  finally
    {
      buf = {CLOBBER};
    }
}


arch_emit_imt_thunk (struct MonoAotCompile * acfg, int offset, int * tramp_size)
{
  guint8 * code.414;
  guint8 * code.415;
  guint8 * code.416;
  guint8 * code.417;
  guint8 * code.418;
  guint8 * code.419;
  guint8 * code.420;
  guint8 * code.421;
  guint8 * code.422;
  guint8 * code.423;
  guint8 * code.424;
  guint8 * code.425;
  unsigned char D.31833;
  guint8 * code.426;
  unsigned char D.31835;
  guint8 * code.427;
  unsigned char D.31837;
  guint8 * code.428;
  unsigned char D.31839;
  guint8 * code.429;
  guint8 * code.430;
  guint8 * code.431;
  guint8 * code.432;
  unsigned char D.31849;
  guint8 * code.433;
  unsigned char D.31851;
  guint8 * code.434;
  unsigned char D.31853;
  guint8 * code.435;
  unsigned char D.31855;
  guint8 * code.436;
  guint8 * code.437;
  guint8 * code.438;
  unsigned int offset.439;
  unsigned int D.31862;
  guint8 * code.440;
  guint8 * code.441;
  int D.31870;
  guint8 * code.442;
  guint8 * code.443;
  unsigned char D.31875;
  unsigned char D.31876;
  guint8 * code.444;
  guint8 * code.445;
  guint8 * code.446;
  unsigned char D.31880;
  guint8 * code.447;
  unsigned char D.31882;
  guint8 * code.448;
  unsigned char D.31884;
  guint8 * code.449;
  unsigned char D.31886;
  guint8 * code.450;
  guint8 * code.451;
  guint8 * code.452;
  guint8 * code.453;
  unsigned char D.31897;
  guint8 * code.454;
  unsigned char D.31899;
  guint8 * code.455;
  unsigned char D.31901;
  guint8 * code.456;
  unsigned char D.31903;
  guint8 * code.457;
  guint8 * code.458;
  guint8 * code.459;
  guint8 * code.460;
  guint8 * code.461;
  guint8 * code.462;
  guint8 * code.463;
  guint8 * code.464;
  unsigned char D.31922;
  guint8 * code.465;
  unsigned char D.31924;
  guint8 * code.466;
  unsigned char D.31926;
  guint8 * code.467;
  unsigned char D.31928;
  guint8 * code.468;
  guint8 * code.469;
  guint8 * code.470;
  guint8 * code.471;
  unsigned char D.31938;
  guint8 * code.472;
  unsigned char D.31940;
  guint8 * code.473;
  unsigned char D.31942;
  guint8 * code.474;
  unsigned char D.31944;
  guint8 * code.475;
  guint8 * code.476;
  guint8 * code.477;
  guint8 * code.478;
  guint8 * code.479;
  guint8 * code.480;
  guint8 * code.481;
  guint8 * code.482;
  unsigned char D.31962;
  guint8 * code.483;
  unsigned char D.31964;
  guint8 * code.484;
  unsigned char D.31966;
  guint8 * code.485;
  unsigned char D.31968;
  guint8 * code.486;
  guint8 * code.487;
  guint8 * code.488;
  guint8 * code.489;
  unsigned char D.31978;
  guint8 * code.490;
  unsigned char D.31980;
  guint8 * code.491;
  unsigned char D.31982;
  guint8 * code.492;
  unsigned char D.31984;
  guint8 * code.493;
  unsigned char D.31986;
  guint8 * code.494;
  unsigned char D.31988;
  guint8 * code.495;
  unsigned char D.31990;
  guint8 * code.496;
  unsigned char D.31992;
  guint8 * code.497;
  unsigned char D.31996;
  guint8 * code.498;
  unsigned char D.31999;
  guint8 * code.499;
  guint8 * code.500;
  guint8 * code.501;
  guint8 * code.502;
  guint8 * code.503;
  guint8 * code.504;
  guint8 * code.505;
  guint8 * code.506;
  unsigned char D.32016;
  guint8 * code.507;
  unsigned char D.32018;
  guint8 * code.508;
  unsigned char D.32020;
  guint8 * code.509;
  unsigned char D.32022;
  guint8 * code.510;
  guint8 * code.511;
  guint8 * code.512;
  guint8 * code.513;
  unsigned char D.32032;
  guint8 * code.514;
  unsigned char D.32034;
  guint8 * code.515;
  unsigned char D.32036;
  guint8 * code.516;
  unsigned char D.32038;
  guint8 * code.517;
  guint8 * code.518;
  guint8 * code.519;
  guint8 * code.520;
  unsigned char D.32048;
  guint8 * code.521;
  unsigned char D.32050;
  guint8 * code.522;
  unsigned char D.32052;
  guint8 * code.523;
  unsigned char D.32054;
  guint8 * code.524;
  guint8 * code.525;
  guint8 * code.526;
  guint8 * code.527;
  guint8 * code.528;
  unsigned char D.32063;
  guint8 * code.529;
  unsigned char D.32065;
  guint8 * code.530;
  unsigned char D.32067;
  guint8 * code.531;
  unsigned char D.32069;
  guint8 * D.32070;
  int D.32071;
  int code.532;
  int D.32073;
  unsigned int t.533;
  unsigned int D.32075;
  guint8 * code.534;
  unsigned char D.32079;
  guint8 * code.535;
  guint8 * code.536;
  unsigned char D.32083;
  guint8 * code.537;
  unsigned char D.32085;
  guint8 * code.538;
  unsigned char D.32087;
  guint8 * code.539;
  unsigned char D.32089;
  guint8 * D.32090;
  guint8 * code.540;
  guint8 * code.541;
  guint8 * code.542;
  guint8 * code.543;
  guint8 * code.544;
  guint8 * code.545;
  guint8 * code.546;
  guint8 * code.547;
  guint8 * code.548;
  guint8 * code.549;
  unsigned char D.32109;
  guint8 * code.550;
  unsigned char D.32111;
  guint8 * code.551;
  unsigned char D.32113;
  guint8 * code.552;
  unsigned char D.32115;
  guint8 * code.553;
  guint8 * code.554;
  guint8 * code.555;
  guint8 * code.556;
  unsigned char D.32125;
  guint8 * code.557;
  unsigned char D.32127;
  guint8 * code.558;
  unsigned char D.32129;
  guint8 * code.559;
  unsigned char D.32131;
  guint8 * code.560;
  guint8 * code.561;
  guint8 * code.562;
  guint8 * code.563;
  guint8 * code.564;
  guint8 * code.565;
  guint8 * code.566;
  guint8 * code.567;
  guint8 * code.568;
  guint8 * code.569;
  unsigned char D.32150;
  guint8 * code.570;
  unsigned char D.32152;
  guint8 * code.571;
  unsigned char D.32154;
  guint8 * code.572;
  unsigned char D.32156;
  guint8 * code.573;
  guint8 * code.574;
  guint8 * code.575;
  guint8 * code.576;
  unsigned char D.32166;
  guint8 * code.577;
  unsigned char D.32168;
  guint8 * code.578;
  unsigned char D.32170;
  guint8 * code.579;
  unsigned char D.32172;
  guint8 * code.580;
  guint8 * code.581;
  guint8 * code.582;
  guint8 * code.583;
  guint8 * code.584;
  guint8 * code.585;
  guint8 * code.586;
  guint8 * code.587;
  guint8 * code.588;
  guint8 * code.589;
  unsigned char D.32191;
  guint8 * code.590;
  unsigned char D.32193;
  guint8 * code.591;
  unsigned char D.32195;
  guint8 * code.592;
  unsigned char D.32197;
  guint8 * code.593;
  guint8 * code.594;
  guint8 * code.595;
  guint8 * code.596;
  unsigned char D.32207;
  guint8 * code.597;
  unsigned char D.32209;
  guint8 * code.598;
  unsigned char D.32211;
  guint8 * code.599;
  unsigned char D.32213;
  guint8 * code.600;
  guint8 * code.601;
  guint8 * D.32216;
  guint8 * code.602;
  guint8 * code.603;
  guint8 * code.604;
  guint8 * code.605;
  guint8 * code.606;
  guint8 * code.607;
  guint8 * code.608;
  guint8 * code.609;
  guint8 * code.610;
  guint8 * code.611;
  unsigned char D.32235;
  guint8 * code.612;
  unsigned char D.32237;
  guint8 * code.613;
  unsigned char D.32239;
  guint8 * code.614;
  unsigned char D.32241;
  guint8 * code.615;
  guint8 * code.616;
  guint8 * code.617;
  guint8 * code.618;
  unsigned char D.32251;
  guint8 * code.619;
  unsigned char D.32253;
  guint8 * code.620;
  unsigned char D.32255;
  guint8 * code.621;
  unsigned char D.32257;
  guint8 * code.622;
  guint8 * code.623;
  guint8 * code.624;
  guint8 * code.625;
  guint8 * code.626;
  guint8 * code.627;
  guint8 * code.628;
  guint8 * code.629;
  unsigned char D.32276;
  guint8 * code.630;
  unsigned char D.32278;
  guint8 * code.631;
  unsigned char D.32280;
  guint8 * code.632;
  unsigned char D.32282;
  guint8 * code.633;
  guint8 * code.634;
  guint8 * code.635;
  guint8 * code.636;
  unsigned char D.32292;
  guint8 * code.637;
  unsigned char D.32294;
  guint8 * code.638;
  unsigned char D.32296;
  guint8 * code.639;
  unsigned char D.32298;
  guint8 * code.640;
  guint8 * code.641;
  guint8 * code.642;
  guint8 * code.643;
  guint8 * code.644;
  guint8 * code.645;
  guint8 * code.646;
  guint8 * code.647;
  unsigned char D.32316;
  guint8 * code.648;
  unsigned char D.32318;
  guint8 * code.649;
  unsigned char D.32320;
  guint8 * code.650;
  unsigned char D.32322;
  guint8 * code.651;
  guint8 * code.652;
  guint8 * code.653;
  guint8 * code.654;
  unsigned char D.32332;
  guint8 * code.655;
  unsigned char D.32334;
  guint8 * code.656;
  unsigned char D.32336;
  guint8 * code.657;
  unsigned char D.32338;
  guint8 * code.658;
  unsigned char D.32340;
  guint8 * code.659;
  unsigned char D.32342;
  guint8 * code.660;
  unsigned char D.32344;
  guint8 * code.661;
  unsigned char D.32346;
  guint8 * code.662;
  guint8 * code.663;
  guint8 * code.664;
  guint8 * code.665;
  guint8 * code.666;
  guint8 * code.667;
  guint8 * code.668;
  guint8 * code.669;
  guint8 * code.670;
  guint8 * code.671;
  guint8 * code.672;
  guint8 * code.673;
  unsigned char D.32370;
  guint8 * code.674;
  unsigned char D.32372;
  guint8 * code.675;
  unsigned char D.32374;
  guint8 * code.676;
  unsigned char D.32376;
  guint8 * code.677;
  guint8 * code.678;
  guint8 * code.679;
  guint8 * code.680;
  unsigned char D.32386;
  guint8 * code.681;
  unsigned char D.32388;
  guint8 * code.682;
  unsigned char D.32390;
  guint8 * code.683;
  unsigned char D.32392;
  guint8 * code.684;
  guint8 * code.685;
  guint8 * D.32395;
  guint8 * code.686;
  int buf.687;
  int D.32398;
  guint8 * buf;
  guint8 * code;
  guint8 * labels[16];
  static const char __PRETTY_FUNCTION__[20] = "arch_emit_imt_thunk";

  try
    {
      buf = monoeg_malloc (256);
      code = buf;
      code.414 = code;
      code = code.414 + 1;
      *code.414 = 80;
      code.415 = code;
      code = code.415 + 1;
      *code.415 = 80;
      switch (4) <default: <D.23737>, case 1: <D.23733>, case 2: <D.23735>, case 4: <D.23736>>
      <D.23733>:
      code.416 = code;
      code = code.416 + 1;
      *code.416 = 138;
      goto <D.23734>;
      <D.23735>:
      code.417 = code;
      code = code.417 + 1;
      *code.417 = 102;
      <D.23736>:
      code.418 = code;
      code = code.418 + 1;
      *code.418 = 139;
      goto <D.23734>;
      <D.23737>:
      __assert_fail ("0", "aot-compiler.c", 1718, &__PRETTY_FUNCTION__);
      <D.23734>:
      if (0 != 0) goto <D.31818>; else goto <D.31819>;
      <D.31818>:
      if (0 != 0) goto <D.31820>; else goto <D.31821>;
      <D.31820>:
      code.419 = code;
      code = code.419 + 1;
      *code.419 = 4;
      code.420 = code;
      code = code.420 + 1;
      *code.420 = 36;
      goto <D.31824>;
      <D.31821>:
      if (1 != 0) goto <D.31825>; else goto <D.31826>;
      <D.31825>:
      code.421 = code;
      code = code.421 + 1;
      *code.421 = 68;
      code.422 = code;
      code = code.422 + 1;
      *code.422 = 36;
      *code = 4;
      code = code + 1;
      goto <D.31829>;
      <D.31826>:
      code.423 = code;
      code = code.423 + 1;
      *code.423 = 132;
      code.424 = code;
      code = code.424 + 1;
      *code.424 = 36;
      {
        union x86_imm_buf imb;

        try
          {
            imb.val = 4;
            code.425 = code;
            code = code.425 + 1;
            D.31833 = imb.b[0];
            *code.425 = D.31833;
            code.426 = code;
            code = code.426 + 1;
            D.31835 = imb.b[1];
            *code.426 = D.31835;
            code.427 = code;
            code = code.427 + 1;
            D.31837 = imb.b[2];
            *code.427 = D.31837;
            code.428 = code;
            code = code.428 + 1;
            D.31839 = imb.b[3];
            *code.428 = D.31839;
          }
        finally
          {
            imb = {CLOBBER};
          }
      }
      <D.31829>:
      <D.31824>:
      goto <D.23740>;
      <D.31819>:
      if (0 != 0) goto <D.31840>; else goto <D.31841>;
      <D.31840>:
      code.429 = code;
      code = code.429 + 1;
      *code.429 = 3;
      goto <D.23740>;
      <D.31841>:
      if (1 != 0) goto <D.31843>; else goto <D.31844>;
      <D.31843>:
      code.430 = code;
      code = code.430 + 1;
      *code.430 = 67;
      *code = 4;
      code = code + 1;
      goto <D.31846>;
      <D.31844>:
      code.431 = code;
      code = code.431 + 1;
      *code.431 = 131;
      {
        union x86_imm_buf imb;

        try
          {
            imb.val = 4;
            code.432 = code;
            code = code.432 + 1;
            D.31849 = imb.b[0];
            *code.432 = D.31849;
            code.433 = code;
            code = code.433 + 1;
            D.31851 = imb.b[1];
            *code.433 = D.31851;
            code.434 = code;
            code = code.434 + 1;
            D.31853 = imb.b[2];
            *code.434 = D.31853;
            code.435 = code;
            code = code.435 + 1;
            D.31855 = imb.b[3];
            *code.435 = D.31855;
          }
        finally
          {
            imb = {CLOBBER};
          }
      }
      <D.31846>:
      <D.23740>:
      switch (4) <default: <D.23746>, case 1: <D.23742>, case 2: <D.23744>, case 4: <D.23745>>
      <D.23742>:
      code.436 = code;
      code = code.436 + 1;
      *code.436 = 138;
      goto <D.23743>;
      <D.23744>:
      code.437 = code;
      code = code.437 + 1;
      *code.437 = 102;
      <D.23745>:
      code.438 = code;
      code = code.438 + 1;
      *code.438 = 139;
      goto <D.23743>;
      <D.23746>:
      __assert_fail ("0", "aot-compiler.c", 1720, &__PRETTY_FUNCTION__);
      <D.23743>:
      if (0 != 0) goto <D.31859>; else goto <D.31860>;
      <D.31859>:
      offset.439 = (unsigned int) offset;
      D.31862 = offset.439 * 4;
      if (D.31862 == 0) goto <D.31863>; else goto <D.31864>;
      <D.31863>:
      code.440 = code;
      code = code.440 + 1;
      *code.440 = 4;
      code.441 = code;
      code = code.441 + 1;
      *code.441 = 36;
      goto <D.31867>;
      <D.31864>:
      offset.439 = (unsigned int) offset;
      D.31862 = offset.439 * 4;
      D.31870 = (int) D.31862;
      if (D.31870 >= -128) goto <D.31871>; else goto <D.31868>;
      <D.31871>:
      offset.439 = (unsigned int) offset;
      D.31862 = offset.439 * 4;
      D.31870 = (int) D.31862;
      if (D.31870 <= 127) goto <D.31872>; else goto <D.31868>;
      <D.31872>:
      code.442 = code;
      code = code.442 + 1;
      *code.442 = 68;
      code.443 = code;
      code = code.443 + 1;
      *code.443 = 36;
      D.31875 = (unsigned char) offset;
      D.31876 = D.31875 * 4;
      *code = D.31876;
      code = code + 1;
      goto <D.31869>;
      <D.31868>:
      code.444 = code;
      code = code.444 + 1;
      *code.444 = 132;
      code.445 = code;
      code = code.445 + 1;
      *code.445 = 36;
      {
        union x86_imm_buf imb;

        try
          {
            offset.439 = (unsigned int) offset;
            D.31862 = offset.439 * 4;
            D.31870 = (int) D.31862;
            imb.val = D.31870;
            code.446 = code;
            code = code.446 + 1;
            D.31880 = imb.b[0];
            *code.446 = D.31880;
            code.447 = code;
            code = code.447 + 1;
            D.31882 = imb.b[1];
            *code.447 = D.31882;
            code.448 = code;
            code = code.448 + 1;
            D.31884 = imb.b[2];
            *code.448 = D.31884;
            code.449 = code;
            code = code.449 + 1;
            D.31886 = imb.b[3];
            *code.449 = D.31886;
          }
        finally
          {
            imb = {CLOBBER};
          }
      }
      <D.31869>:
      <D.31867>:
      goto <D.23748>;
      <D.31860>:
      offset.439 = (unsigned int) offset;
      D.31862 = offset.439 * 4;
      if (D.31862 == 0) goto <D.31887>; else goto <D.31888>;
      <D.31887>:
      code.450 = code;
      code = code.450 + 1;
      *code.450 = 0;
      goto <D.23748>;
      <D.31888>:
      offset.439 = (unsigned int) offset;
      D.31862 = offset.439 * 4;
      D.31870 = (int) D.31862;
      if (D.31870 >= -128) goto <D.31892>; else goto <D.31890>;
      <D.31892>:
      offset.439 = (unsigned int) offset;
      D.31862 = offset.439 * 4;
      D.31870 = (int) D.31862;
      if (D.31870 <= 127) goto <D.31893>; else goto <D.31890>;
      <D.31893>:
      code.451 = code;
      code = code.451 + 1;
      *code.451 = 64;
      D.31875 = (unsigned char) offset;
      D.31876 = D.31875 * 4;
      *code = D.31876;
      code = code + 1;
      goto <D.31891>;
      <D.31890>:
      code.452 = code;
      code = code.452 + 1;
      *code.452 = 128;
      {
        union x86_imm_buf imb;

        try
          {
            offset.439 = (unsigned int) offset;
            D.31862 = offset.439 * 4;
            D.31870 = (int) D.31862;
            imb.val = D.31870;
            code.453 = code;
            code = code.453 + 1;
            D.31897 = imb.b[0];
            *code.453 = D.31897;
            code.454 = code;
            code = code.454 + 1;
            D.31899 = imb.b[1];
            *code.454 = D.31899;
            code.455 = code;
            code = code.455 + 1;
            D.31901 = imb.b[2];
            *code.455 = D.31901;
            code.456 = code;
            code = code.456 + 1;
            D.31903 = imb.b[3];
            *code.456 = D.31903;
          }
        finally
          {
            imb = {CLOBBER};
          }
      }
      <D.31891>:
      <D.23748>:
      labels[0] = code;
      if (1 != 0) goto <D.31904>; else goto <D.31905>;
      <D.31904>:
      code.457 = code;
      code = code.457 + 1;
      *code.457 = 131;
      if (0 != 0) goto <D.31907>; else goto <D.31908>;
      <D.31907>:
      if (1 != 0) goto <D.31909>; else goto <D.31910>;
      <D.31909>:
      code.458 = code;
      code = code.458 + 1;
      *code.458 = 60;
      code.459 = code;
      code = code.459 + 1;
      *code.459 = 36;
      goto <D.31913>;
      <D.31910>:
      if (1 != 0) goto <D.31914>; else goto <D.31915>;
      <D.31914>:
      code.460 = code;
      code = code.460 + 1;
      *code.460 = 124;
      code.461 = code;
      code = code.461 + 1;
      *code.461 = 36;
      *code = 0;
      code = code + 1;
      goto <D.31918>;
      <D.31915>:
      code.462 = code;
      code = code.462 + 1;
      *code.462 = 188;
      code.463 = code;
      code = code.463 + 1;
      *code.463 = 36;
      {
        union x86_imm_buf imb;

        try
          {
            imb.val = 0;
            code.464 = code;
            code = code.464 + 1;
            D.31922 = imb.b[0];
            *code.464 = D.31922;
            code.465 = code;
            code = code.465 + 1;
            D.31924 = imb.b[1];
            *code.465 = D.31924;
            code.466 = code;
            code = code.466 + 1;
            D.31926 = imb.b[2];
            *code.466 = D.31926;
            code.467 = code;
            code = code.467 + 1;
            D.31928 = imb.b[3];
            *code.467 = D.31928;
          }
        finally
          {
            imb = {CLOBBER};
          }
      }
      <D.31918>:
      <D.31913>:
      goto <D.23751>;
      <D.31908>:
      if (1 != 0) goto <D.31929>; else goto <D.31930>;
      <D.31929>:
      code.468 = code;
      code = code.468 + 1;
      *code.468 = 56;
      goto <D.23751>;
      <D.31930>:
      if (1 != 0) goto <D.31932>; else goto <D.31933>;
      <D.31932>:
      code.469 = code;
      code = code.469 + 1;
      *code.469 = 120;
      *code = 0;
      code = code + 1;
      goto <D.31935>;
      <D.31933>:
      code.470 = code;
      code = code.470 + 1;
      *code.470 = 184;
      {
        union x86_imm_buf imb;

        try
          {
            imb.val = 0;
            code.471 = code;
            code = code.471 + 1;
            D.31938 = imb.b[0];
            *code.471 = D.31938;
            code.472 = code;
            code = code.472 + 1;
            D.31940 = imb.b[1];
            *code.472 = D.31940;
            code.473 = code;
            code = code.473 + 1;
            D.31942 = imb.b[2];
            *code.473 = D.31942;
            code.474 = code;
            code = code.474 + 1;
            D.31944 = imb.b[3];
            *code.474 = D.31944;
          }
        finally
          {
            imb = {CLOBBER};
          }
      }
      <D.31935>:
      <D.23751>:
      *code = 0;
      code = code + 1;
      goto <D.31945>;
      <D.31905>:
      code.475 = code;
      code = code.475 + 1;
      *code.475 = 129;
      if (0 != 0) goto <D.31947>; else goto <D.31948>;
      <D.31947>:
      if (1 != 0) goto <D.31949>; else goto <D.31950>;
      <D.31949>:
      code.476 = code;
      code = code.476 + 1;
      *code.476 = 60;
      code.477 = code;
      code = code.477 + 1;
      *code.477 = 36;
      goto <D.31953>;
      <D.31950>:
      if (1 != 0) goto <D.31954>; else goto <D.31955>;
      <D.31954>:
      code.478 = code;
      code = code.478 + 1;
      *code.478 = 124;
      code.479 = code;
      code = code.479 + 1;
      *code.479 = 36;
      *code = 0;
      code = code + 1;
      goto <D.31958>;
      <D.31955>:
      code.480 = code;
      code = code.480 + 1;
      *code.480 = 188;
      code.481 = code;
      code = code.481 + 1;
      *code.481 = 36;
      {
        union x86_imm_buf imb;

        try
          {
            imb.val = 0;
            code.482 = code;
            code = code.482 + 1;
            D.31962 = imb.b[0];
            *code.482 = D.31962;
            code.483 = code;
            code = code.483 + 1;
            D.31964 = imb.b[1];
            *code.483 = D.31964;
            code.484 = code;
            code = code.484 + 1;
            D.31966 = imb.b[2];
            *code.484 = D.31966;
            code.485 = code;
            code = code.485 + 1;
            D.31968 = imb.b[3];
            *code.485 = D.31968;
          }
        finally
          {
            imb = {CLOBBER};
          }
      }
      <D.31958>:
      <D.31953>:
      goto <D.23754>;
      <D.31948>:
      if (1 != 0) goto <D.31969>; else goto <D.31970>;
      <D.31969>:
      code.486 = code;
      code = code.486 + 1;
      *code.486 = 56;
      goto <D.23754>;
      <D.31970>:
      if (1 != 0) goto <D.31972>; else goto <D.31973>;
      <D.31972>:
      code.487 = code;
      code = code.487 + 1;
      *code.487 = 120;
      *code = 0;
      code = code + 1;
      goto <D.31975>;
      <D.31973>:
      code.488 = code;
      code = code.488 + 1;
      *code.488 = 184;
      {
        union x86_imm_buf imb;

        try
          {
            imb.val = 0;
            code.489 = code;
            code = code.489 + 1;
            D.31978 = imb.b[0];
            *code.489 = D.31978;
            code.490 = code;
            code = code.490 + 1;
            D.31980 = imb.b[1];
            *code.490 = D.31980;
            code.491 = code;
            code = code.491 + 1;
            D.31982 = imb.b[2];
            *code.491 = D.31982;
            code.492 = code;
            code = code.492 + 1;
            D.31984 = imb.b[3];
            *code.492 = D.31984;
          }
        finally
          {
            imb = {CLOBBER};
          }
      }
      <D.31975>:
      <D.23754>:
      {
        union x86_imm_buf imb;

        try
          {
            imb.val = 0;
            code.493 = code;
            code = code.493 + 1;
            D.31986 = imb.b[0];
            *code.493 = D.31986;
            code.494 = code;
            code = code.494 + 1;
            D.31988 = imb.b[1];
            *code.494 = D.31988;
            code.495 = code;
            code = code.495 + 1;
            D.31990 = imb.b[2];
            *code.495 = D.31990;
            code.496 = code;
            code = code.496 + 1;
            D.31992 = imb.b[3];
            *code.496 = D.31992;
          }
        finally
          {
            imb = {CLOBBER};
          }
      }
      <D.31945>:
      labels[1] = code;
      if (0 != 0) goto <D.31993>; else goto <D.31994>;
      <D.31993>:
      code.497 = code;
      code = code.497 + 1;
      D.31996 = 116;
      *code.497 = D.31996;
      goto <D.31997>;
      <D.31994>:
      code.498 = code;
      code = code.498 + 1;
      D.31999 = 116;
      *code.498 = D.31999;
      <D.31997>:
      *code = 0;
      code = code + 1;
      code.499 = code;
      code = code.499 + 1;
      *code.499 = 57;
      if (0 != 0) goto <D.32001>; else goto <D.32002>;
      <D.32001>:
      if (1 != 0) goto <D.32003>; else goto <D.32004>;
      <D.32003>:
      code.500 = code;
      code = code.500 + 1;
      *code.500 = 20;
      code.501 = code;
      code = code.501 + 1;
      *code.501 = 36;
      goto <D.32007>;
      <D.32004>:
      if (1 != 0) goto <D.32008>; else goto <D.32009>;
      <D.32008>:
      code.502 = code;
      code = code.502 + 1;
      *code.502 = 84;
      code.503 = code;
      code = code.503 + 1;
      *code.503 = 36;
      *code = 0;
      code = code + 1;
      goto <D.32012>;
      <D.32009>:
      code.504 = code;
      code = code.504 + 1;
      *code.504 = 148;
      code.505 = code;
      code = code.505 + 1;
      *code.505 = 36;
      {
        union x86_imm_buf imb;

        try
          {
            imb.val = 0;
            code.506 = code;
            code = code.506 + 1;
            D.32016 = imb.b[0];
            *code.506 = D.32016;
            code.507 = code;
            code = code.507 + 1;
            D.32018 = imb.b[1];
            *code.507 = D.32018;
            code.508 = code;
            code = code.508 + 1;
            D.32020 = imb.b[2];
            *code.508 = D.32020;
            code.509 = code;
            code = code.509 + 1;
            D.32022 = imb.b[3];
            *code.509 = D.32022;
          }
        finally
          {
            imb = {CLOBBER};
          }
      }
      <D.32012>:
      <D.32007>:
      goto <D.23758>;
      <D.32002>:
      if (1 != 0) goto <D.32023>; else goto <D.32024>;
      <D.32023>:
      code.510 = code;
      code = code.510 + 1;
      *code.510 = 16;
      goto <D.23758>;
      <D.32024>:
      if (1 != 0) goto <D.32026>; else goto <D.32027>;
      <D.32026>:
      code.511 = code;
      code = code.511 + 1;
      *code.511 = 80;
      *code = 0;
      code = code + 1;
      goto <D.32029>;
      <D.32027>:
      code.512 = code;
      code = code.512 + 1;
      *code.512 = 144;
      {
        union x86_imm_buf imb;

        try
          {
            imb.val = 0;
            code.513 = code;
            code = code.513 + 1;
            D.32032 = imb.b[0];
            *code.513 = D.32032;
            code.514 = code;
            code = code.514 + 1;
            D.32034 = imb.b[1];
            *code.514 = D.32034;
            code.515 = code;
            code = code.515 + 1;
            D.32036 = imb.b[2];
            *code.515 = D.32036;
            code.516 = code;
            code = code.516 + 1;
            D.32038 = imb.b[3];
            *code.516 = D.32038;
          }
        finally
          {
            imb = {CLOBBER};
          }
      }
      <D.32029>:
      <D.23758>:
      labels[2] = code;
      if (0 != 0) goto <D.32039>; else goto <D.32040>;
      <D.32039>:
      code.517 = code;
      code = code.517 + 1;
      D.31996 = 116;
      *code.517 = D.31996;
      goto <D.32042>;
      <D.32040>:
      code.518 = code;
      code = code.518 + 1;
      D.31999 = 116;
      *code.518 = D.31999;
      <D.32042>:
      *code = 0;
      code = code + 1;
      if (1 != 0) goto <D.32044>; else goto <D.32045>;
      <D.32044>:
      code.519 = code;
      code = code.519 + 1;
      *code.519 = 5;
      {
        union x86_imm_buf imb;

        try
          {
            imb.val = 8;
            code.520 = code;
            code = code.520 + 1;
            D.32048 = imb.b[0];
            *code.520 = D.32048;
            code.521 = code;
            code = code.521 + 1;
            D.32050 = imb.b[1];
            *code.521 = D.32050;
            code.522 = code;
            code = code.522 + 1;
            D.32052 = imb.b[2];
            *code.522 = D.32052;
            code.523 = code;
            code = code.523 + 1;
            D.32054 = imb.b[3];
            *code.523 = D.32054;
          }
        finally
          {
            imb = {CLOBBER};
          }
      }
      goto <D.23761>;
      <D.32045>:
      if (1 != 0) goto <D.32055>; else goto <D.32056>;
      <D.32055>:
      code.524 = code;
      code = code.524 + 1;
      *code.524 = 131;
      code.525 = code;
      code = code.525 + 1;
      *code.525 = 192;
      *code = 8;
      code = code + 1;
      goto <D.32059>;
      <D.32056>:
      code.526 = code;
      code = code.526 + 1;
      *code.526 = 129;
      code.527 = code;
      code = code.527 + 1;
      *code.527 = 192;
      {
        union x86_imm_buf imb;

        try
          {
            imb.val = 8;
            code.528 = code;
            code = code.528 + 1;
            D.32063 = imb.b[0];
            *code.528 = D.32063;
            code.529 = code;
            code = code.529 + 1;
            D.32065 = imb.b[1];
            *code.529 = D.32065;
            code.530 = code;
            code = code.530 + 1;
            D.32067 = imb.b[2];
            *code.530 = D.32067;
            code.531 = code;
            code = code.531 + 1;
            D.32069 = imb.b[3];
            *code.531 = D.32069;
          }
        finally
          {
            imb = {CLOBBER};
          }
      }
      <D.32059>:
      <D.23761>:
      {
        int t;

        D.32070 = labels[0];
        D.32071 = (int) D.32070;
        code.532 = (int) code;
        D.32073 = D.32071 - code.532;
        t = D.32073 + -2;
        t.533 = (unsigned int) t;
        D.32075 = t.533 + 128;
        if (D.32075 <= 255) goto <D.32076>; else goto <D.32077>;
        <D.32076>:
        code.534 = code;
        code = code.534 + 1;
        *code.534 = 235;
        D.32079 = (unsigned char) t;
        *code = D.32079;
        code = code + 1;
        goto <D.32080>;
        <D.32077>:
        D.32070 = labels[0];
        D.32071 = (int) D.32070;
        code.532 = (int) code;
        D.32073 = D.32071 - code.532;
        t = D.32073 + -5;
        code.535 = code;
        code = code.535 + 1;
        *code.535 = 233;
        {
          union x86_imm_buf imb;

          try
            {
              imb.val = t;
              code.536 = code;
              code = code.536 + 1;
              D.32083 = imb.b[0];
              *code.536 = D.32083;
              code.537 = code;
              code = code.537 + 1;
              D.32085 = imb.b[1];
              *code.537 = D.32085;
              code.538 = code;
              code = code.538 + 1;
              D.32087 = imb.b[2];
              *code.538 = D.32087;
              code.539 = code;
              code = code.539 + 1;
              D.32089 = imb.b[3];
              *code.539 = D.32089;
            }
          finally
            {
              imb = {CLOBBER};
            }
        }
        <D.32080>:
      }
      D.32090 = labels[2];
      mono_x86_patch (D.32090, code);
      switch (4) <default: <D.23769>, case 1: <D.23765>, case 2: <D.23767>, case 4: <D.23768>>
      <D.23765>:
      code.540 = code;
      code = code.540 + 1;
      *code.540 = 138;
      goto <D.23766>;
      <D.23767>:
      code.541 = code;
      code = code.541 + 1;
      *code.541 = 102;
      <D.23768>:
      code.542 = code;
      code = code.542 + 1;
      *code.542 = 139;
      goto <D.23766>;
      <D.23769>:
      __assert_fail ("0", "aot-compiler.c", 1738, &__PRETTY_FUNCTION__);
      <D.23766>:
      if (0 != 0) goto <D.32094>; else goto <D.32095>;
      <D.32094>:
      if (0 != 0) goto <D.32096>; else goto <D.32097>;
      <D.32096>:
      code.543 = code;
      code = code.543 + 1;
      *code.543 = 4;
      code.544 = code;
      code = code.544 + 1;
      *code.544 = 36;
      goto <D.32100>;
      <D.32097>:
      if (1 != 0) goto <D.32101>; else goto <D.32102>;
      <D.32101>:
      code.545 = code;
      code = code.545 + 1;
      *code.545 = 68;
      code.546 = code;
      code = code.546 + 1;
      *code.546 = 36;
      *code = 4;
      code = code + 1;
      goto <D.32105>;
      <D.32102>:
      code.547 = code;
      code = code.547 + 1;
      *code.547 = 132;
      code.548 = code;
      code = code.548 + 1;
      *code.548 = 36;
      {
        union x86_imm_buf imb;

        try
          {
            imb.val = 4;
            code.549 = code;
            code = code.549 + 1;
            D.32109 = imb.b[0];
            *code.549 = D.32109;
            code.550 = code;
            code = code.550 + 1;
            D.32111 = imb.b[1];
            *code.550 = D.32111;
            code.551 = code;
            code = code.551 + 1;
            D.32113 = imb.b[2];
            *code.551 = D.32113;
            code.552 = code;
            code = code.552 + 1;
            D.32115 = imb.b[3];
            *code.552 = D.32115;
          }
        finally
          {
            imb = {CLOBBER};
          }
      }
      <D.32105>:
      <D.32100>:
      goto <D.23771>;
      <D.32095>:
      if (0 != 0) goto <D.32116>; else goto <D.32117>;
      <D.32116>:
      code.553 = code;
      code = code.553 + 1;
      *code.553 = 0;
      goto <D.23771>;
      <D.32117>:
      if (1 != 0) goto <D.32119>; else goto <D.32120>;
      <D.32119>:
      code.554 = code;
      code = code.554 + 1;
      *code.554 = 64;
      *code = 4;
      code = code + 1;
      goto <D.32122>;
      <D.32120>:
      code.555 = code;
      code = code.555 + 1;
      *code.555 = 128;
      {
        union x86_imm_buf imb;

        try
          {
            imb.val = 4;
            code.556 = code;
            code = code.556 + 1;
            D.32125 = imb.b[0];
            *code.556 = D.32125;
            code.557 = code;
            code = code.557 + 1;
            D.32127 = imb.b[1];
            *code.557 = D.32127;
            code.558 = code;
            code = code.558 + 1;
            D.32129 = imb.b[2];
            *code.558 = D.32129;
            code.559 = code;
            code = code.559 + 1;
            D.32131 = imb.b[3];
            *code.559 = D.32131;
          }
        finally
          {
            imb = {CLOBBER};
          }
      }
      <D.32122>:
      <D.23771>:
      switch (4) <default: <D.23777>, case 1: <D.23773>, case 2: <D.23775>, case 4: <D.23776>>
      <D.23773>:
      code.560 = code;
      code = code.560 + 1;
      *code.560 = 138;
      goto <D.23774>;
      <D.23775>:
      code.561 = code;
      code = code.561 + 1;
      *code.561 = 102;
      <D.23776>:
      code.562 = code;
      code = code.562 + 1;
      *code.562 = 139;
      goto <D.23774>;
      <D.23777>:
      __assert_fail ("0", "aot-compiler.c", 1739, &__PRETTY_FUNCTION__);
      <D.23774>:
      if (0 != 0) goto <D.32135>; else goto <D.32136>;
      <D.32135>:
      if (1 != 0) goto <D.32137>; else goto <D.32138>;
      <D.32137>:
      code.563 = code;
      code = code.563 + 1;
      *code.563 = 4;
      code.564 = code;
      code = code.564 + 1;
      *code.564 = 36;
      goto <D.32141>;
      <D.32138>:
      if (1 != 0) goto <D.32142>; else goto <D.32143>;
      <D.32142>:
      code.565 = code;
      code = code.565 + 1;
      *code.565 = 68;
      code.566 = code;
      code = code.566 + 1;
      *code.566 = 36;
      *code = 0;
      code = code + 1;
      goto <D.32146>;
      <D.32143>:
      code.567 = code;
      code = code.567 + 1;
      *code.567 = 132;
      code.568 = code;
      code = code.568 + 1;
      *code.568 = 36;
      {
        union x86_imm_buf imb;

        try
          {
            imb.val = 0;
            code.569 = code;
            code = code.569 + 1;
            D.32150 = imb.b[0];
            *code.569 = D.32150;
            code.570 = code;
            code = code.570 + 1;
            D.32152 = imb.b[1];
            *code.570 = D.32152;
            code.571 = code;
            code = code.571 + 1;
            D.32154 = imb.b[2];
            *code.571 = D.32154;
            code.572 = code;
            code = code.572 + 1;
            D.32156 = imb.b[3];
            *code.572 = D.32156;
          }
        finally
          {
            imb = {CLOBBER};
          }
      }
      <D.32146>:
      <D.32141>:
      goto <D.23779>;
      <D.32136>:
      if (1 != 0) goto <D.32157>; else goto <D.32158>;
      <D.32157>:
      code.573 = code;
      code = code.573 + 1;
      *code.573 = 0;
      goto <D.23779>;
      <D.32158>:
      if (1 != 0) goto <D.32160>; else goto <D.32161>;
      <D.32160>:
      code.574 = code;
      code = code.574 + 1;
      *code.574 = 64;
      *code = 0;
      code = code + 1;
      goto <D.32163>;
      <D.32161>:
      code.575 = code;
      code = code.575 + 1;
      *code.575 = 128;
      {
        union x86_imm_buf imb;

        try
          {
            imb.val = 0;
            code.576 = code;
            code = code.576 + 1;
            D.32166 = imb.b[0];
            *code.576 = D.32166;
            code.577 = code;
            code = code.577 + 1;
            D.32168 = imb.b[1];
            *code.577 = D.32168;
            code.578 = code;
            code = code.578 + 1;
            D.32170 = imb.b[2];
            *code.578 = D.32170;
            code.579 = code;
            code = code.579 + 1;
            D.32172 = imb.b[3];
            *code.579 = D.32172;
          }
        finally
          {
            imb = {CLOBBER};
          }
      }
      <D.32163>:
      <D.23779>:
      switch (4) <default: <D.23785>, case 1: <D.23781>, case 2: <D.23783>, case 4: <D.23784>>
      <D.23781>:
      code.580 = code;
      code = code.580 + 1;
      *code.580 = 136;
      goto <D.23782>;
      <D.23783>:
      code.581 = code;
      code = code.581 + 1;
      *code.581 = 102;
      <D.23784>:
      code.582 = code;
      code = code.582 + 1;
      *code.582 = 137;
      goto <D.23782>;
      <D.23785>:
      __assert_fail ("0", "aot-compiler.c", 1741, &__PRETTY_FUNCTION__);
      <D.23782>:
      if (1 != 0) goto <D.32176>; else goto <D.32177>;
      <D.32176>:
      if (0 != 0) goto <D.32178>; else goto <D.32179>;
      <D.32178>:
      code.583 = code;
      code = code.583 + 1;
      *code.583 = 4;
      code.584 = code;
      code = code.584 + 1;
      *code.584 = 36;
      goto <D.32182>;
      <D.32179>:
      if (1 != 0) goto <D.32183>; else goto <D.32184>;
      <D.32183>:
      code.585 = code;
      code = code.585 + 1;
      *code.585 = 68;
      code.586 = code;
      code = code.586 + 1;
      *code.586 = 36;
      *code = 4;
      code = code + 1;
      goto <D.32187>;
      <D.32184>:
      code.587 = code;
      code = code.587 + 1;
      *code.587 = 132;
      code.588 = code;
      code = code.588 + 1;
      *code.588 = 36;
      {
        union x86_imm_buf imb;

        try
          {
            imb.val = 4;
            code.589 = code;
            code = code.589 + 1;
            D.32191 = imb.b[0];
            *code.589 = D.32191;
            code.590 = code;
            code = code.590 + 1;
            D.32193 = imb.b[1];
            *code.590 = D.32193;
            code.591 = code;
            code = code.591 + 1;
            D.32195 = imb.b[2];
            *code.591 = D.32195;
            code.592 = code;
            code = code.592 + 1;
            D.32197 = imb.b[3];
            *code.592 = D.32197;
          }
        finally
          {
            imb = {CLOBBER};
          }
      }
      <D.32187>:
      <D.32182>:
      goto <D.23787>;
      <D.32177>:
      if (0 != 0) goto <D.32198>; else goto <D.32199>;
      <D.32198>:
      code.593 = code;
      code = code.593 + 1;
      *code.593 = 4;
      goto <D.23787>;
      <D.32199>:
      if (1 != 0) goto <D.32201>; else goto <D.32202>;
      <D.32201>:
      code.594 = code;
      code = code.594 + 1;
      *code.594 = 68;
      *code = 4;
      code = code + 1;
      goto <D.32204>;
      <D.32202>:
      code.595 = code;
      code = code.595 + 1;
      *code.595 = 132;
      {
        union x86_imm_buf imb;

        try
          {
            imb.val = 4;
            code.596 = code;
            code = code.596 + 1;
            D.32207 = imb.b[0];
            *code.596 = D.32207;
            code.597 = code;
            code = code.597 + 1;
            D.32209 = imb.b[1];
            *code.597 = D.32209;
            code.598 = code;
            code = code.598 + 1;
            D.32211 = imb.b[2];
            *code.598 = D.32211;
            code.599 = code;
            code = code.599 + 1;
            D.32213 = imb.b[3];
            *code.599 = D.32213;
          }
        finally
          {
            imb = {CLOBBER};
          }
      }
      <D.32204>:
      <D.23787>:
      code.600 = code;
      code = code.600 + 1;
      *code.600 = 88;
      code.601 = code;
      code = code.601 + 1;
      *code.601 = 195;
      D.32216 = labels[1];
      mono_x86_patch (D.32216, code);
      switch (4) <default: <D.23793>, case 1: <D.23789>, case 2: <D.23791>, case 4: <D.23792>>
      <D.23789>:
      code.602 = code;
      code = code.602 + 1;
      *code.602 = 138;
      goto <D.23790>;
      <D.23791>:
      code.603 = code;
      code = code.603 + 1;
      *code.603 = 102;
      <D.23792>:
      code.604 = code;
      code = code.604 + 1;
      *code.604 = 139;
      goto <D.23790>;
      <D.23793>:
      __assert_fail ("0", "aot-compiler.c", 1750, &__PRETTY_FUNCTION__);
      <D.23790>:
      if (0 != 0) goto <D.32220>; else goto <D.32221>;
      <D.32220>:
      if (0 != 0) goto <D.32222>; else goto <D.32223>;
      <D.32222>:
      code.605 = code;
      code = code.605 + 1;
      *code.605 = 4;
      code.606 = code;
      code = code.606 + 1;
      *code.606 = 36;
      goto <D.32226>;
      <D.32223>:
      if (1 != 0) goto <D.32227>; else goto <D.32228>;
      <D.32227>:
      code.607 = code;
      code = code.607 + 1;
      *code.607 = 68;
      code.608 = code;
      code = code.608 + 1;
      *code.608 = 36;
      *code = 4;
      code = code + 1;
      goto <D.32231>;
      <D.32228>:
      code.609 = code;
      code = code.609 + 1;
      *code.609 = 132;
      code.610 = code;
      code = code.610 + 1;
      *code.610 = 36;
      {
        union x86_imm_buf imb;

        try
          {
            imb.val = 4;
            code.611 = code;
            code = code.611 + 1;
            D.32235 = imb.b[0];
            *code.611 = D.32235;
            code.612 = code;
            code = code.612 + 1;
            D.32237 = imb.b[1];
            *code.612 = D.32237;
            code.613 = code;
            code = code.613 + 1;
            D.32239 = imb.b[2];
            *code.613 = D.32239;
            code.614 = code;
            code = code.614 + 1;
            D.32241 = imb.b[3];
            *code.614 = D.32241;
          }
        finally
          {
            imb = {CLOBBER};
          }
      }
      <D.32231>:
      <D.32226>:
      goto <D.23795>;
      <D.32221>:
      if (0 != 0) goto <D.32242>; else goto <D.32243>;
      <D.32242>:
      code.615 = code;
      code = code.615 + 1;
      *code.615 = 0;
      goto <D.23795>;
      <D.32243>:
      if (1 != 0) goto <D.32245>; else goto <D.32246>;
      <D.32245>:
      code.616 = code;
      code = code.616 + 1;
      *code.616 = 64;
      *code = 4;
      code = code + 1;
      goto <D.32248>;
      <D.32246>:
      code.617 = code;
      code = code.617 + 1;
      *code.617 = 128;
      {
        union x86_imm_buf imb;

        try
          {
            imb.val = 4;
            code.618 = code;
            code = code.618 + 1;
            D.32251 = imb.b[0];
            *code.618 = D.32251;
            code.619 = code;
            code = code.619 + 1;
            D.32253 = imb.b[1];
            *code.619 = D.32253;
            code.620 = code;
            code = code.620 + 1;
            D.32255 = imb.b[2];
            *code.620 = D.32255;
            code.621 = code;
            code = code.621 + 1;
            D.32257 = imb.b[3];
            *code.621 = D.32257;
          }
        finally
          {
            imb = {CLOBBER};
          }
      }
      <D.32248>:
      <D.23795>:
      if (1 != 0) goto <D.32258>; else goto <D.32259>;
      <D.32258>:
      code.622 = code;
      code = code.622 + 1;
      *code.622 = 131;
      if (0 != 0) goto <D.32261>; else goto <D.32262>;
      <D.32261>:
      if (1 != 0) goto <D.32263>; else goto <D.32264>;
      <D.32263>:
      code.623 = code;
      code = code.623 + 1;
      *code.623 = 60;
      code.624 = code;
      code = code.624 + 1;
      *code.624 = 36;
      goto <D.32267>;
      <D.32264>:
      if (1 != 0) goto <D.32268>; else goto <D.32269>;
      <D.32268>:
      code.625 = code;
      code = code.625 + 1;
      *code.625 = 124;
      code.626 = code;
      code = code.626 + 1;
      *code.626 = 36;
      *code = 0;
      code = code + 1;
      goto <D.32272>;
      <D.32269>:
      code.627 = code;
      code = code.627 + 1;
      *code.627 = 188;
      code.628 = code;
      code = code.628 + 1;
      *code.628 = 36;
      {
        union x86_imm_buf imb;

        try
          {
            imb.val = 0;
            code.629 = code;
            code = code.629 + 1;
            D.32276 = imb.b[0];
            *code.629 = D.32276;
            code.630 = code;
            code = code.630 + 1;
            D.32278 = imb.b[1];
            *code.630 = D.32278;
            code.631 = code;
            code = code.631 + 1;
            D.32280 = imb.b[2];
            *code.631 = D.32280;
            code.632 = code;
            code = code.632 + 1;
            D.32282 = imb.b[3];
            *code.632 = D.32282;
          }
        finally
          {
            imb = {CLOBBER};
          }
      }
      <D.32272>:
      <D.32267>:
      goto <D.23798>;
      <D.32262>:
      if (1 != 0) goto <D.32283>; else goto <D.32284>;
      <D.32283>:
      code.633 = code;
      code = code.633 + 1;
      *code.633 = 56;
      goto <D.23798>;
      <D.32284>:
      if (1 != 0) goto <D.32286>; else goto <D.32287>;
      <D.32286>:
      code.634 = code;
      code = code.634 + 1;
      *code.634 = 120;
      *code = 0;
      code = code + 1;
      goto <D.32289>;
      <D.32287>:
      code.635 = code;
      code = code.635 + 1;
      *code.635 = 184;
      {
        union x86_imm_buf imb;

        try
          {
            imb.val = 0;
            code.636 = code;
            code = code.636 + 1;
            D.32292 = imb.b[0];
            *code.636 = D.32292;
            code.637 = code;
            code = code.637 + 1;
            D.32294 = imb.b[1];
            *code.637 = D.32294;
            code.638 = code;
            code = code.638 + 1;
            D.32296 = imb.b[2];
            *code.638 = D.32296;
            code.639 = code;
            code = code.639 + 1;
            D.32298 = imb.b[3];
            *code.639 = D.32298;
          }
        finally
          {
            imb = {CLOBBER};
          }
      }
      <D.32289>:
      <D.23798>:
      *code = 0;
      code = code + 1;
      goto <D.32299>;
      <D.32259>:
      code.640 = code;
      code = code.640 + 1;
      *code.640 = 129;
      if (0 != 0) goto <D.32301>; else goto <D.32302>;
      <D.32301>:
      if (1 != 0) goto <D.32303>; else goto <D.32304>;
      <D.32303>:
      code.641 = code;
      code = code.641 + 1;
      *code.641 = 60;
      code.642 = code;
      code = code.642 + 1;
      *code.642 = 36;
      goto <D.32307>;
      <D.32304>:
      if (1 != 0) goto <D.32308>; else goto <D.32309>;
      <D.32308>:
      code.643 = code;
      code = code.643 + 1;
      *code.643 = 124;
      code.644 = code;
      code = code.644 + 1;
      *code.644 = 36;
      *code = 0;
      code = code + 1;
      goto <D.32312>;
      <D.32309>:
      code.645 = code;
      code = code.645 + 1;
      *code.645 = 188;
      code.646 = code;
      code = code.646 + 1;
      *code.646 = 36;
      {
        union x86_imm_buf imb;

        try
          {
            imb.val = 0;
            code.647 = code;
            code = code.647 + 1;
            D.32316 = imb.b[0];
            *code.647 = D.32316;
            code.648 = code;
            code = code.648 + 1;
            D.32318 = imb.b[1];
            *code.648 = D.32318;
            code.649 = code;
            code = code.649 + 1;
            D.32320 = imb.b[2];
            *code.649 = D.32320;
            code.650 = code;
            code = code.650 + 1;
            D.32322 = imb.b[3];
            *code.650 = D.32322;
          }
        finally
          {
            imb = {CLOBBER};
          }
      }
      <D.32312>:
      <D.32307>:
      goto <D.23801>;
      <D.32302>:
      if (1 != 0) goto <D.32323>; else goto <D.32324>;
      <D.32323>:
      code.651 = code;
      code = code.651 + 1;
      *code.651 = 56;
      goto <D.23801>;
      <D.32324>:
      if (1 != 0) goto <D.32326>; else goto <D.32327>;
      <D.32326>:
      code.652 = code;
      code = code.652 + 1;
      *code.652 = 120;
      *code = 0;
      code = code + 1;
      goto <D.32329>;
      <D.32327>:
      code.653 = code;
      code = code.653 + 1;
      *code.653 = 184;
      {
        union x86_imm_buf imb;

        try
          {
            imb.val = 0;
            code.654 = code;
            code = code.654 + 1;
            D.32332 = imb.b[0];
            *code.654 = D.32332;
            code.655 = code;
            code = code.655 + 1;
            D.32334 = imb.b[1];
            *code.655 = D.32334;
            code.656 = code;
            code = code.656 + 1;
            D.32336 = imb.b[2];
            *code.656 = D.32336;
            code.657 = code;
            code = code.657 + 1;
            D.32338 = imb.b[3];
            *code.657 = D.32338;
          }
        finally
          {
            imb = {CLOBBER};
          }
      }
      <D.32329>:
      <D.23801>:
      {
        union x86_imm_buf imb;

        try
          {
            imb.val = 0;
            code.658 = code;
            code = code.658 + 1;
            D.32340 = imb.b[0];
            *code.658 = D.32340;
            code.659 = code;
            code = code.659 + 1;
            D.32342 = imb.b[1];
            *code.659 = D.32342;
            code.660 = code;
            code = code.660 + 1;
            D.32344 = imb.b[2];
            *code.660 = D.32344;
            code.661 = code;
            code = code.661 + 1;
            D.32346 = imb.b[3];
            *code.661 = D.32346;
          }
        finally
          {
            imb = {CLOBBER};
          }
      }
      <D.32299>:
      labels[3] = code;
      if (0 != 0) goto <D.32347>; else goto <D.32348>;
      <D.32347>:
      code.662 = code;
      code = code.662 + 1;
      D.31996 = 116;
      *code.662 = D.31996;
      goto <D.32350>;
      <D.32348>:
      code.663 = code;
      code = code.663 + 1;
      D.31999 = 116;
      *code.663 = D.31999;
      <D.32350>:
      *code = 0;
      code = code + 1;
      switch (4) <default: <D.23808>, case 1: <D.23804>, case 2: <D.23806>, case 4: <D.23807>>
      <D.23804>:
      code.664 = code;
      code = code.664 + 1;
      *code.664 = 136;
      goto <D.23805>;
      <D.23806>:
      code.665 = code;
      code = code.665 + 1;
      *code.665 = 102;
      <D.23807>:
      code.666 = code;
      code = code.666 + 1;
      *code.666 = 137;
      goto <D.23805>;
      <D.23808>:
      __assert_fail ("0", "aot-compiler.c", 1755, &__PRETTY_FUNCTION__);
      <D.23805>:
      if (1 != 0) goto <D.32355>; else goto <D.32356>;
      <D.32355>:
      if (0 != 0) goto <D.32357>; else goto <D.32358>;
      <D.32357>:
      code.667 = code;
      code = code.667 + 1;
      *code.667 = 4;
      code.668 = code;
      code = code.668 + 1;
      *code.668 = 36;
      goto <D.32361>;
      <D.32358>:
      if (1 != 0) goto <D.32362>; else goto <D.32363>;
      <D.32362>:
      code.669 = code;
      code = code.669 + 1;
      *code.669 = 68;
      code.670 = code;
      code = code.670 + 1;
      *code.670 = 36;
      *code = 4;
      code = code + 1;
      goto <D.32366>;
      <D.32363>:
      code.671 = code;
      code = code.671 + 1;
      *code.671 = 132;
      code.672 = code;
      code = code.672 + 1;
      *code.672 = 36;
      {
        union x86_imm_buf imb;

        try
          {
            imb.val = 4;
            code.673 = code;
            code = code.673 + 1;
            D.32370 = imb.b[0];
            *code.673 = D.32370;
            code.674 = code;
            code = code.674 + 1;
            D.32372 = imb.b[1];
            *code.674 = D.32372;
            code.675 = code;
            code = code.675 + 1;
            D.32374 = imb.b[2];
            *code.675 = D.32374;
            code.676 = code;
            code = code.676 + 1;
            D.32376 = imb.b[3];
            *code.676 = D.32376;
          }
        finally
          {
            imb = {CLOBBER};
          }
      }
      <D.32366>:
      <D.32361>:
      goto <D.23810>;
      <D.32356>:
      if (0 != 0) goto <D.32377>; else goto <D.32378>;
      <D.32377>:
      code.677 = code;
      code = code.677 + 1;
      *code.677 = 4;
      goto <D.23810>;
      <D.32378>:
      if (1 != 0) goto <D.32380>; else goto <D.32381>;
      <D.32380>:
      code.678 = code;
      code = code.678 + 1;
      *code.678 = 68;
      *code = 4;
      code = code + 1;
      goto <D.32383>;
      <D.32381>:
      code.679 = code;
      code = code.679 + 1;
      *code.679 = 132;
      {
        union x86_imm_buf imb;

        try
          {
            imb.val = 4;
            code.680 = code;
            code = code.680 + 1;
            D.32386 = imb.b[0];
            *code.680 = D.32386;
            code.681 = code;
            code = code.681 + 1;
            D.32388 = imb.b[1];
            *code.681 = D.32388;
            code.682 = code;
            code = code.682 + 1;
            D.32390 = imb.b[2];
            *code.682 = D.32390;
            code.683 = code;
            code = code.683 + 1;
            D.32392 = imb.b[3];
            *code.683 = D.32392;
          }
        finally
          {
            imb = {CLOBBER};
          }
      }
      <D.32383>:
      <D.23810>:
      code.684 = code;
      code = code.684 + 1;
      *code.684 = 88;
      code.685 = code;
      code = code.685 + 1;
      *code.685 = 195;
      D.32395 = labels[3];
      mono_x86_patch (D.32395, code);
      code.686 = code;
      code = code.686 + 1;
      *code.686 = 204;
      code.532 = (int) code;
      buf.687 = (int) buf;
      D.32398 = code.532 - buf.687;
      emit_bytes (acfg, buf, D.32398);
      code.532 = (int) code;
      buf.687 = (int) buf;
      D.32398 = code.532 - buf.687;
      *tramp_size = D.32398;
      monoeg_g_free (buf);
    }
  finally
    {
      labels = {CLOBBER};
    }
}


arch_emit_gsharedvt_arg_trampoline (struct MonoAotCompile * acfg, int offset, int * tramp_size)
{
  guint8 * code.688;
  guint8 * code.689;
  guint8 * code.690;
  guint8 * code.691;
  guint8 * code.692;
  guint8 * code.693;
  guint8 * code.694;
  guint8 * code.695;
  guint8 * code.696;
  guint8 * code.697;
  unsigned char D.32419;
  guint8 * code.698;
  unsigned char D.32421;
  guint8 * code.699;
  unsigned char D.32423;
  guint8 * code.700;
  unsigned char D.32425;
  guint8 * code.701;
  guint8 * code.702;
  guint8 * code.703;
  guint8 * code.704;
  unsigned char D.32435;
  guint8 * code.705;
  unsigned char D.32437;
  guint8 * code.706;
  unsigned char D.32439;
  guint8 * code.707;
  unsigned char D.32441;
  guint8 * code.708;
  guint8 * code.709;
  guint8 * code.710;
  unsigned int offset.711;
  unsigned int D.32448;
  guint8 * code.712;
  guint8 * code.713;
  int D.32456;
  guint8 * code.714;
  guint8 * code.715;
  unsigned char D.32461;
  unsigned char D.32462;
  guint8 * code.716;
  guint8 * code.717;
  guint8 * code.718;
  unsigned char D.32466;
  guint8 * code.719;
  unsigned char D.32468;
  guint8 * code.720;
  unsigned char D.32470;
  guint8 * code.721;
  unsigned char D.32472;
  guint8 * code.722;
  guint8 * code.723;
  guint8 * code.724;
  guint8 * code.725;
  unsigned char D.32483;
  guint8 * code.726;
  unsigned char D.32485;
  guint8 * code.727;
  unsigned char D.32487;
  guint8 * code.728;
  unsigned char D.32489;
  guint8 * code.729;
  int D.32493;
  unsigned int D.32494;
  unsigned int D.32495;
  guint8 * code.730;
  guint8 * code.731;
  int D.32503;
  guint8 * code.732;
  guint8 * code.733;
  unsigned char D.32508;
  unsigned char D.32509;
  guint8 * code.734;
  guint8 * code.735;
  guint8 * code.736;
  unsigned char D.32513;
  guint8 * code.737;
  unsigned char D.32515;
  guint8 * code.738;
  unsigned char D.32517;
  guint8 * code.739;
  unsigned char D.32519;
  guint8 * code.740;
  guint8 * code.741;
  guint8 * code.742;
  guint8 * code.743;
  unsigned char D.32530;
  guint8 * code.744;
  unsigned char D.32532;
  guint8 * code.745;
  unsigned char D.32534;
  guint8 * code.746;
  unsigned char D.32536;
  int code.747;
  int buf.748;
  int D.32539;
  int D.32540;
  _Bool D.32541;
  long int D.32542;
  long int D.32543;
  guint8 buf[128];
  guint8 * code;
  static const char __PRETTY_FUNCTION__[35] = "arch_emit_gsharedvt_arg_trampoline";

  try
    {
      if (0 != 0) goto <D.32399>; else goto <D.32400>;
      <D.32399>:
      monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "aot-compiler.c", 1906, "MONO_ARCH_RGCTX_REG != X86_ECX");
      <D.32400>:
      code = &buf;
      switch (4) <default: <D.23823>, case 1: <D.23819>, case 2: <D.23821>, case 4: <D.23822>>
      <D.23819>:
      code.688 = code;
      code = code.688 + 1;
      *code.688 = 138;
      goto <D.23820>;
      <D.23821>:
      code.689 = code;
      code = code.689 + 1;
      *code.689 = 102;
      <D.23822>:
      code.690 = code;
      code = code.690 + 1;
      *code.690 = 139;
      goto <D.23820>;
      <D.23823>:
      __assert_fail ("0", "aot-compiler.c", 1910, &__PRETTY_FUNCTION__);
      <D.23820>:
      if (0 != 0) goto <D.32404>; else goto <D.32405>;
      <D.32404>:
      if (0 != 0) goto <D.32406>; else goto <D.32407>;
      <D.32406>:
      code.691 = code;
      code = code.691 + 1;
      *code.691 = 12;
      code.692 = code;
      code = code.692 + 1;
      *code.692 = 36;
      goto <D.32410>;
      <D.32407>:
      if (1 != 0) goto <D.32411>; else goto <D.32412>;
      <D.32411>:
      code.693 = code;
      code = code.693 + 1;
      *code.693 = 76;
      code.694 = code;
      code = code.694 + 1;
      *code.694 = 36;
      *code = 4;
      code = code + 1;
      goto <D.32415>;
      <D.32412>:
      code.695 = code;
      code = code.695 + 1;
      *code.695 = 140;
      code.696 = code;
      code = code.696 + 1;
      *code.696 = 36;
      {
        union x86_imm_buf imb;

        try
          {
            imb.val = 4;
            code.697 = code;
            code = code.697 + 1;
            D.32419 = imb.b[0];
            *code.697 = D.32419;
            code.698 = code;
            code = code.698 + 1;
            D.32421 = imb.b[1];
            *code.698 = D.32421;
            code.699 = code;
            code = code.699 + 1;
            D.32423 = imb.b[2];
            *code.699 = D.32423;
            code.700 = code;
            code = code.700 + 1;
            D.32425 = imb.b[3];
            *code.700 = D.32425;
          }
        finally
          {
            imb = {CLOBBER};
          }
      }
      <D.32415>:
      <D.32410>:
      goto <D.23826>;
      <D.32405>:
      if (0 != 0) goto <D.32426>; else goto <D.32427>;
      <D.32426>:
      code.701 = code;
      code = code.701 + 1;
      *code.701 = 11;
      goto <D.23826>;
      <D.32427>:
      if (1 != 0) goto <D.32429>; else goto <D.32430>;
      <D.32429>:
      code.702 = code;
      code = code.702 + 1;
      *code.702 = 75;
      *code = 4;
      code = code + 1;
      goto <D.32432>;
      <D.32430>:
      code.703 = code;
      code = code.703 + 1;
      *code.703 = 139;
      {
        union x86_imm_buf imb;

        try
          {
            imb.val = 4;
            code.704 = code;
            code = code.704 + 1;
            D.32435 = imb.b[0];
            *code.704 = D.32435;
            code.705 = code;
            code = code.705 + 1;
            D.32437 = imb.b[1];
            *code.705 = D.32437;
            code.706 = code;
            code = code.706 + 1;
            D.32439 = imb.b[2];
            *code.706 = D.32439;
            code.707 = code;
            code = code.707 + 1;
            D.32441 = imb.b[3];
            *code.707 = D.32441;
          }
        finally
          {
            imb = {CLOBBER};
          }
      }
      <D.32432>:
      <D.23826>:
      switch (4) <default: <D.23832>, case 1: <D.23828>, case 2: <D.23830>, case 4: <D.23831>>
      <D.23828>:
      code.708 = code;
      code = code.708 + 1;
      *code.708 = 138;
      goto <D.23829>;
      <D.23830>:
      code.709 = code;
      code = code.709 + 1;
      *code.709 = 102;
      <D.23831>:
      code.710 = code;
      code = code.710 + 1;
      *code.710 = 139;
      goto <D.23829>;
      <D.23832>:
      __assert_fail ("0", "aot-compiler.c", 1912, &__PRETTY_FUNCTION__);
      <D.23829>:
      if (0 != 0) goto <D.32445>; else goto <D.32446>;
      <D.32445>:
      offset.711 = (unsigned int) offset;
      D.32448 = offset.711 * 4;
      if (D.32448 == 0) goto <D.32449>; else goto <D.32450>;
      <D.32449>:
      code.712 = code;
      code = code.712 + 1;
      *code.712 = 4;
      code.713 = code;
      code = code.713 + 1;
      *code.713 = 36;
      goto <D.32453>;
      <D.32450>:
      offset.711 = (unsigned int) offset;
      D.32448 = offset.711 * 4;
      D.32456 = (int) D.32448;
      if (D.32456 >= -128) goto <D.32457>; else goto <D.32454>;
      <D.32457>:
      offset.711 = (unsigned int) offset;
      D.32448 = offset.711 * 4;
      D.32456 = (int) D.32448;
      if (D.32456 <= 127) goto <D.32458>; else goto <D.32454>;
      <D.32458>:
      code.714 = code;
      code = code.714 + 1;
      *code.714 = 68;
      code.715 = code;
      code = code.715 + 1;
      *code.715 = 36;
      D.32461 = (unsigned char) offset;
      D.32462 = D.32461 * 4;
      *code = D.32462;
      code = code + 1;
      goto <D.32455>;
      <D.32454>:
      code.716 = code;
      code = code.716 + 1;
      *code.716 = 132;
      code.717 = code;
      code = code.717 + 1;
      *code.717 = 36;
      {
        union x86_imm_buf imb;

        try
          {
            offset.711 = (unsigned int) offset;
            D.32448 = offset.711 * 4;
            D.32456 = (int) D.32448;
            imb.val = D.32456;
            code.718 = code;
            code = code.718 + 1;
            D.32466 = imb.b[0];
            *code.718 = D.32466;
            code.719 = code;
            code = code.719 + 1;
            D.32468 = imb.b[1];
            *code.719 = D.32468;
            code.720 = code;
            code = code.720 + 1;
            D.32470 = imb.b[2];
            *code.720 = D.32470;
            code.721 = code;
            code = code.721 + 1;
            D.32472 = imb.b[3];
            *code.721 = D.32472;
          }
        finally
          {
            imb = {CLOBBER};
          }
      }
      <D.32455>:
      <D.32453>:
      goto <D.23834>;
      <D.32446>:
      offset.711 = (unsigned int) offset;
      D.32448 = offset.711 * 4;
      if (D.32448 == 0) goto <D.32473>; else goto <D.32474>;
      <D.32473>:
      code.722 = code;
      code = code.722 + 1;
      *code.722 = 1;
      goto <D.23834>;
      <D.32474>:
      offset.711 = (unsigned int) offset;
      D.32448 = offset.711 * 4;
      D.32456 = (int) D.32448;
      if (D.32456 >= -128) goto <D.32478>; else goto <D.32476>;
      <D.32478>:
      offset.711 = (unsigned int) offset;
      D.32448 = offset.711 * 4;
      D.32456 = (int) D.32448;
      if (D.32456 <= 127) goto <D.32479>; else goto <D.32476>;
      <D.32479>:
      code.723 = code;
      code = code.723 + 1;
      *code.723 = 65;
      D.32461 = (unsigned char) offset;
      D.32462 = D.32461 * 4;
      *code = D.32462;
      code = code + 1;
      goto <D.32477>;
      <D.32476>:
      code.724 = code;
      code = code.724 + 1;
      *code.724 = 129;
      {
        union x86_imm_buf imb;

        try
          {
            offset.711 = (unsigned int) offset;
            D.32448 = offset.711 * 4;
            D.32456 = (int) D.32448;
            imb.val = D.32456;
            code.725 = code;
            code = code.725 + 1;
            D.32483 = imb.b[0];
            *code.725 = D.32483;
            code.726 = code;
            code = code.726 + 1;
            D.32485 = imb.b[1];
            *code.726 = D.32485;
            code.727 = code;
            code = code.727 + 1;
            D.32487 = imb.b[2];
            *code.727 = D.32487;
            code.728 = code;
            code = code.728 + 1;
            D.32489 = imb.b[3];
            *code.728 = D.32489;
          }
        finally
          {
            imb = {CLOBBER};
          }
      }
      <D.32477>:
      <D.23834>:
      code.729 = code;
      code = code.729 + 1;
      *code.729 = 255;
      if (0 != 0) goto <D.32491>; else goto <D.32492>;
      <D.32491>:
      D.32493 = offset + 1;
      D.32494 = (unsigned int) D.32493;
      D.32495 = D.32494 * 4;
      if (D.32495 == 0) goto <D.32496>; else goto <D.32497>;
      <D.32496>:
      code.730 = code;
      code = code.730 + 1;
      *code.730 = 36;
      code.731 = code;
      code = code.731 + 1;
      *code.731 = 36;
      goto <D.32500>;
      <D.32497>:
      D.32493 = offset + 1;
      D.32494 = (unsigned int) D.32493;
      D.32495 = D.32494 * 4;
      D.32503 = (int) D.32495;
      if (D.32503 >= -128) goto <D.32504>; else goto <D.32501>;
      <D.32504>:
      D.32493 = offset + 1;
      D.32494 = (unsigned int) D.32493;
      D.32495 = D.32494 * 4;
      D.32503 = (int) D.32495;
      if (D.32503 <= 127) goto <D.32505>; else goto <D.32501>;
      <D.32505>:
      code.732 = code;
      code = code.732 + 1;
      *code.732 = 100;
      code.733 = code;
      code = code.733 + 1;
      *code.733 = 36;
      D.32493 = offset + 1;
      D.32508 = (unsigned char) D.32493;
      D.32509 = D.32508 * 4;
      *code = D.32509;
      code = code + 1;
      goto <D.32502>;
      <D.32501>:
      code.734 = code;
      code = code.734 + 1;
      *code.734 = 164;
      code.735 = code;
      code = code.735 + 1;
      *code.735 = 36;
      {
        union x86_imm_buf imb;

        try
          {
            D.32493 = offset + 1;
            D.32494 = (unsigned int) D.32493;
            D.32495 = D.32494 * 4;
            D.32503 = (int) D.32495;
            imb.val = D.32503;
            code.736 = code;
            code = code.736 + 1;
            D.32513 = imb.b[0];
            *code.736 = D.32513;
            code.737 = code;
            code = code.737 + 1;
            D.32515 = imb.b[1];
            *code.737 = D.32515;
            code.738 = code;
            code = code.738 + 1;
            D.32517 = imb.b[2];
            *code.738 = D.32517;
            code.739 = code;
            code = code.739 + 1;
            D.32519 = imb.b[3];
            *code.739 = D.32519;
          }
        finally
          {
            imb = {CLOBBER};
          }
      }
      <D.32502>:
      <D.32500>:
      goto <D.23837>;
      <D.32492>:
      D.32493 = offset + 1;
      D.32494 = (unsigned int) D.32493;
      D.32495 = D.32494 * 4;
      if (D.32495 == 0) goto <D.32520>; else goto <D.32521>;
      <D.32520>:
      code.740 = code;
      code = code.740 + 1;
      *code.740 = 33;
      goto <D.23837>;
      <D.32521>:
      D.32493 = offset + 1;
      D.32494 = (unsigned int) D.32493;
      D.32495 = D.32494 * 4;
      D.32503 = (int) D.32495;
      if (D.32503 >= -128) goto <D.32525>; else goto <D.32523>;
      <D.32525>:
      D.32493 = offset + 1;
      D.32494 = (unsigned int) D.32493;
      D.32495 = D.32494 * 4;
      D.32503 = (int) D.32495;
      if (D.32503 <= 127) goto <D.32526>; else goto <D.32523>;
      <D.32526>:
      code.741 = code;
      code = code.741 + 1;
      *code.741 = 97;
      D.32493 = offset + 1;
      D.32508 = (unsigned char) D.32493;
      D.32509 = D.32508 * 4;
      *code = D.32509;
      code = code + 1;
      goto <D.32524>;
      <D.32523>:
      code.742 = code;
      code = code.742 + 1;
      *code.742 = 161;
      {
        union x86_imm_buf imb;

        try
          {
            D.32493 = offset + 1;
            D.32494 = (unsigned int) D.32493;
            D.32495 = D.32494 * 4;
            D.32503 = (int) D.32495;
            imb.val = D.32503;
            code.743 = code;
            code = code.743 + 1;
            D.32530 = imb.b[0];
            *code.743 = D.32530;
            code.744 = code;
            code = code.744 + 1;
            D.32532 = imb.b[1];
            *code.744 = D.32532;
            code.745 = code;
            code = code.745 + 1;
            D.32534 = imb.b[2];
            *code.745 = D.32534;
            code.746 = code;
            code = code.746 + 1;
            D.32536 = imb.b[3];
            *code.746 = D.32536;
          }
        finally
          {
            imb = {CLOBBER};
          }
      }
      <D.32524>:
      <D.23837>:
      code.747 = (int) code;
      buf.748 = (int) &buf;
      D.32539 = code.747 - buf.748;
      emit_bytes (acfg, &buf, D.32539);
      *tramp_size = 15;
      code.747 = (int) code;
      buf.748 = (int) &buf;
      D.32539 = code.747 - buf.748;
      D.32540 = *tramp_size;
      D.32541 = D.32539 != D.32540;
      D.32542 = (long int) D.32541;
      D.32543 = __builtin_expect (D.32542, 0);
      if (D.32543 != 0) goto <D.32544>; else goto <D.32545>;
      <D.32544>:
      monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "aot-compiler.c", 1927, "code - buf == *tramp_size");
      <D.32545>:
    }
  finally
    {
      buf = {CLOBBER};
    }
}


arch_emit_specific_trampoline_pages (struct MonoAotCompile * acfg)
{

}


emit_class_name_table (struct MonoAotCompile * acfg)
{
  struct MonoImage * D.32546;
  <unnamed-unsigned:24> D.32547;
  int D.32548;
  double D.32549;
  double D.32550;
  int D.32551;
  unsigned int D.32552;
  unsigned int D.32553;
  unsigned int table_size.749;
  int D.32555;
  int D.32556;
  struct MonoType * D.32559;
  unsigned int D.32560;
  void * * D.32561;
  unsigned int D.32562;
  void * * D.32563;
  struct ClassNameTableEntry * D.32567;
  unsigned int D.32568;
  _Bool D.32569;
  long int D.32570;
  long int D.32571;
  _Bool D.32574;
  long int D.32575;
  long int D.32576;
  unsigned int i.750;
  unsigned int D.32580;
  void * * D.32581;
  unsigned int D.32585;
  int D.32586;
  int D.32587;
  struct ClassNameTableEntry * D.32588;
  unsigned int D.32591;
  int D.32592;
  unsigned int i.751;
  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.32546 = acfg->image;
      D.32547 = D.32546->tables[2].rows;
      D.32548 = (int) D.32547;
      D.32549 = (double) D.32548;
      D.32550 = D.32549 * 1.5e+0;
      D.32551 = (int) D.32550;
      D.32552 = (unsigned int) D.32551;
      D.32553 = monoeg_g_spaced_primes_closest (D.32552);
      table_size = (int) D.32553;
      table_size.749 = (unsigned int) table_size;
      table = monoeg_g_ptr_array_sized_new (table_size.749);
      i = 0;
      goto <D.25872>;
      <D.25871>:
      monoeg_g_ptr_array_add (table, 0B);
      i = i + 1;
      <D.25872>:
      if (i < table_size) goto <D.25871>; else goto <D.25873>;
      <D.25873>:
      i = 0;
      goto <D.25879>;
      <D.25878>:
      D.32555 = i + 1;
      D.32556 = D.32555 | 33554432;
      token = (guint32) D.32556;
      D.32546 = acfg->image;
      klass = mono_class_get (D.32546, token);
      if (klass == 0B) goto <D.32557>; else goto <D.32558>;
      <D.32557>:
      mono_loader_clear_error ();
      // predicted unlikely by continue predictor.
      goto <D.25874>;
      <D.32558>:
      D.32559 = mono_class_get_type (klass);
      full_name = mono_type_get_name_full (D.32559, 2);
      D.32560 = mono_metadata_str_hash (full_name);
      table_size.749 = (unsigned int) table_size;
      hash = D.32560 % table_size.749;
      monoeg_g_free (full_name);
      new_entry = monoeg_malloc0 (12);
      new_entry->token = token;
      D.32561 = table->pdata;
      D.32562 = hash * 4;
      D.32563 = D.32561 + D.32562;
      entry = *D.32563;
      if (entry == 0B) goto <D.32564>; else goto <D.32565>;
      <D.32564>:
      new_entry->index = hash;
      D.32561 = table->pdata;
      D.32562 = hash * 4;
      D.32563 = D.32561 + D.32562;
      *D.32563 = new_entry;
      goto <D.32566>;
      <D.32565>:
      goto <D.25876>;
      <D.25875>:
      entry = entry->next;
      <D.25876>:
      D.32567 = entry->next;
      if (D.32567 != 0B) goto <D.25875>; else goto <D.25877>;
      <D.25877>:
      entry->next = new_entry;
      D.32568 = table->len;
      new_entry->index = D.32568;
      monoeg_g_ptr_array_add (table, new_entry);
      <D.32566>:
      <D.25874>:
      i = i + 1;
      <D.25879>:
      D.32546 = acfg->image;
      D.32547 = D.32546->tables[2].rows;
      D.32548 = (int) D.32547;
      if (D.32548 > i) goto <D.25878>; else goto <D.25880>;
      <D.25880>:
      sprintf (&symbol, "class_name_table");
      emit_section_change (acfg, ".rodata", 0);
      emit_alignment (acfg, 8);
      emit_label (acfg, &symbol);
      D.32569 = table_size > 64999;
      D.32570 = (long int) D.32569;
      D.32571 = __builtin_expect (D.32570, 0);
      if (D.32571 != 0) goto <D.32572>; else goto <D.32573>;
      <D.32572>:
      monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "aot-compiler.c", 7744, "table_size < 65000");
      <D.32573>:
      emit_int16 (acfg, table_size);
      D.32568 = table->len;
      D.32574 = D.32568 > 64999;
      D.32575 = (long int) D.32574;
      D.32576 = __builtin_expect (D.32575, 0);
      if (D.32576 != 0) goto <D.32577>; else goto <D.32578>;
      <D.32577>:
      monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "aot-compiler.c", 7746, "table->len < 65000");
      <D.32578>:
      i = 0;
      goto <D.25883>;
      <D.25882>:
      {
        struct ClassNameTableEntry * entry;

        D.32561 = table->pdata;
        i.750 = (unsigned int) i;
        D.32580 = i.750 * 4;
        D.32581 = D.32561 + D.32580;
        entry = *D.32581;
        if (entry == 0B) goto <D.32582>; else goto <D.32583>;
        <D.32582>:
        emit_int16 (acfg, 0);
        emit_int16 (acfg, 0);
        goto <D.32584>;
        <D.32583>:
        D.32585 = entry->token;
        D.32586 = (int) D.32585;
        D.32587 = D.32586 & 16777215;
        emit_int16 (acfg, D.32587);
        D.32588 = entry->next;
        if (D.32588 != 0B) goto <D.32589>; else goto <D.32590>;
        <D.32589>:
        D.32588 = entry->next;
        D.32591 = D.32588->index;
        D.32592 = (int) D.32591;
        emit_int16 (acfg, D.32592);
        goto <D.32593>;
        <D.32590>:
        emit_int16 (acfg, 0);
        <D.32593>:
        <D.32584>:
      }
      i = i + 1;
      <D.25883>:
      i.751 = (unsigned int) i;
      D.32568 = table->len;
      if (i.751 < D.32568) goto <D.25882>; else goto <D.25884>;
      <D.25884>:
    }
  finally
    {
      symbol = {CLOBBER};
    }
}


emit_got_info (struct MonoAotCompile * acfg)
{
  unsigned int D.32595;
  struct GPtrArray * D.32596;
  unsigned int D.32597;
  const void * i.752;
  struct GHashTable * D.32599;
  struct MonoJumpInfo * D.32600;
  <unnamed type> D.32601;
  int D.32602;
  int D.32603;
  unsigned int i.753;
  unsigned int D.32605;
  unsigned int D.32606;
  unsigned int D.32607;
  unsigned int buf_size.754;
  struct MonoMemPool * D.32609;
  unsigned int D.32610;
  unsigned int D.32611;
  void * D.32612;
  guint32 * D.32615;
  void * * D.32616;
  unsigned int i.755;
  unsigned int D.32618;
  void * * D.32619;
  guint8 * p.756;
  <unnamed type> D.32621;
  int D.32622;
  int D.32623;
  int p.757;
  int p2.758;
  int D.32626;
  int D.32627;
  int buf.759;
  int D.32629;
  _Bool D.32630;
  long int D.32631;
  long int D.32632;
  guint32 * D.32635;
  unsigned int D.32636;
  unsigned int D.32637;
  int D.32640;
  sizetype D.32641;
  sizetype D.32642;
  sizetype D.32643;
  guint32 * D.32644;
  unsigned int D.32645;
  int D.32646;
  int D.32647;
  unsigned int i.760;
  unsigned int D.32649;
  int D.32650;
  unsigned int D.32651;
  unsigned int D.32652;
  int D.32653;
  char symbol[256];
  int i;
  int first_plt_got_patch;
  int buf_size;
  guint8 * p;
  guint8 * buf;
  guint32 * got_info_offsets;

  try
    {
      D.32595 = acfg->got_offset;
      acfg->plt_got_offset_base = D.32595;
      D.32596 = acfg->got_patches;
      D.32597 = D.32596->len;
      first_plt_got_patch = (int) D.32597;
      i = 1;
      goto <D.25907>;
      <D.25906>:
      {
        struct MonoPltEntry * plt_entry;

        i.752 = (const void *) i;
        D.32599 = acfg->plt_offset_to_entry;
        plt_entry = monoeg_g_hash_table_lookup (D.32599, i.752);
        D.32600 = plt_entry->ji;
        D.32596 = acfg->got_patches;
        monoeg_g_ptr_array_add (D.32596, D.32600);
        D.32600 = plt_entry->ji;
        D.32601 = D.32600->type;
        D.32602 = acfg->stats.got_slot_types[D.32601];
        D.32603 = D.32602 + 1;
        acfg->stats.got_slot_types[D.32601] = D.32603;
      }
      i = i + 1;
      <D.25907>:
      i.753 = (unsigned int) i;
      D.32605 = acfg->plt_offset;
      if (i.753 < D.32605) goto <D.25906>; else goto <D.25908>;
      <D.25908>:
      D.32595 = acfg->got_offset;
      D.32605 = acfg->plt_offset;
      D.32606 = D.32595 + D.32605;
      acfg->got_offset = D.32606;
      D.32596 = acfg->got_patches;
      D.32597 = D.32596->len;
      D.32607 = D.32597 * 128;
      buf_size = (int) D.32607;
      buf_size.754 = (unsigned int) buf_size;
      D.32609 = acfg->mempool;
      buf = mono_mempool_alloc (D.32609, buf_size.754);
      p = buf;
      D.32596 = acfg->got_patches;
      D.32597 = D.32596->len;
      D.32610 = D.32597 * 4;
      D.32609 = acfg->mempool;
      got_info_offsets = mono_mempool_alloc (D.32609, D.32610);
      D.32605 = acfg->plt_offset;
      D.32611 = D.32605 * 4;
      D.32609 = acfg->mempool;
      D.32612 = mono_mempool_alloc (D.32609, D.32611);
      acfg->plt_got_info_offsets = D.32612;
      D.32605 = acfg->plt_offset;
      if (D.32605 != 0) goto <D.32613>; else goto <D.32614>;
      <D.32613>:
      D.32615 = acfg->plt_got_info_offsets;
      *D.32615 = 0;
      <D.32614>:
      i = 0;
      goto <D.25912>;
      <D.25911>:
      {
        struct MonoJumpInfo * ji;
        guint8 * p2;

        D.32596 = acfg->got_patches;
        D.32616 = D.32596->pdata;
        i.755 = (unsigned int) i;
        D.32618 = i.755 * 4;
        D.32619 = D.32616 + D.32618;
        ji = *D.32619;
        p = buf;
        p.756 = p;
        D.32621 = ji->type;
        D.32622 = (int) D.32621;
        encode_value (D.32622, p.756, &p);
        p2 = p;
        p.756 = p;
        encode_patch (acfg, ji, p.756, &p);
        D.32621 = ji->type;
        D.32621 = ji->type;
        D.32623 = acfg->stats.got_slot_info_sizes[D.32621];
        p.756 = p;
        p.757 = (int) p.756;
        p2.758 = (int) p2;
        D.32626 = p.757 - p2.758;
        D.32627 = D.32623 + D.32626;
        acfg->stats.got_slot_info_sizes[D.32621] = D.32627;
        p.756 = p;
        p.757 = (int) p.756;
        buf.759 = (int) buf;
        D.32629 = p.757 - buf.759;
        D.32630 = D.32629 > buf_size;
        D.32631 = (long int) D.32630;
        D.32632 = __builtin_expect (D.32631, 0);
        if (D.32632 != 0) goto <D.32633>; else goto <D.32634>;
        <D.32633>:
        monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "aot-compiler.c", 7851, "p - buf <= buf_size");
        <D.32634>:
        i.755 = (unsigned int) i;
        D.32618 = i.755 * 4;
        D.32635 = got_info_offsets + D.32618;
        p.756 = p;
        p.757 = (int) p.756;
        buf.759 = (int) buf;
        D.32629 = p.757 - buf.759;
        D.32636 = (unsigned int) D.32629;
        D.32637 = add_to_blob (acfg, buf, D.32636);
        *D.32635 = D.32637;
        if (i >= first_plt_got_patch) goto <D.32638>; else goto <D.32639>;
        <D.32638>:
        D.32615 = acfg->plt_got_info_offsets;
        D.32640 = i - first_plt_got_patch;
        D.32641 = (sizetype) D.32640;
        D.32642 = D.32641 + 1;
        D.32643 = D.32642 * 4;
        D.32644 = D.32615 + D.32643;
        i.755 = (unsigned int) i;
        D.32618 = i.755 * 4;
        D.32635 = got_info_offsets + D.32618;
        D.32645 = *D.32635;
        *D.32644 = D.32645;
        <D.32639>:
        D.32646 = acfg->stats.got_info_size;
        p.756 = p;
        p.757 = (int) p.756;
        buf.759 = (int) buf;
        D.32629 = p.757 - buf.759;
        D.32647 = D.32646 + D.32629;
        acfg->stats.got_info_size = D.32647;
      }
      i = i + 1;
      <D.25912>:
      i.760 = (unsigned int) i;
      D.32596 = acfg->got_patches;
      D.32597 = D.32596->len;
      if (i.760 < D.32597) goto <D.25911>; else goto <D.25913>;
      <D.25913>:
      sprintf (&symbol, "got_info_offsets");
      emit_section_change (acfg, ".rodata", 1);
      emit_alignment (acfg, 8);
      emit_label (acfg, &symbol);
      D.32649 = emit_offset_table (acfg, first_plt_got_patch, 10, got_info_offsets);
      D.32650 = acfg->stats.offsets_size;
      D.32651 = (unsigned int) D.32650;
      D.32652 = D.32651 + D.32649;
      D.32653 = (int) D.32652;
      acfg->stats.offsets_size = D.32653;
    }
  finally
    {
      symbol = {CLOBBER};
      p = {CLOBBER};
    }
}


encode_patch (struct MonoAotCompile * acfg, struct MonoJumpInfo * patch_info, guint8 * buf, guint8 * * endbuf)
{
  <unnamed type> D.32654;
  guint8 * p.761;
  struct MonoImage * D.32656;
  unsigned int D.32657;
  int D.32658;
  int D.32659;
  struct MonoJumpInfoBBTable * D.32660;
  int D.32661;
  unsigned int k.762;
  unsigned int D.32663;
  void * * D.32664;
  void * D.32665;
  int D.32666;
  struct MonoMethod * D.32667;
  const char * D.32668;
  int len.763;
  guint8 * p.764;
  guint8 * p.765;
  guint8 * p.766;
  struct MonoJumpInfoToken * D.32673;
  struct MonoImage * D.32674;
  unsigned int D.32675;
  _Bool D.32676;
  long int D.32677;
  long int D.32678;
  int image_index.767;
  unsigned int D.32682;
  unsigned int D.32683;
  int D.32684;
  unsigned int D.32685;
  int D.32686;
  int D.32687;
  int D.32688;
  struct MonoGenericContext * D.32691;
  const void * D.32692;
  struct MonoClass * D.32693;
  struct MonoImage * D.32694;
  _Bool D.32695;
  long int D.32696;
  long int D.32697;
  unsigned int D.32700;
  int D.32701;
  guint32 * D.32702;
  unsigned int D.32703;
  int D.32704;
  struct MonoClass * D.32705;
  struct MonoClassField * D.32706;
  struct MonoMethod * D.32707;
  struct GHashTable * D.32708;
  void * D.32709;
  guint8 * p2.768;
  int p2.769;
  int buf2.770;
  int D.32715;
  _Bool D.32716;
  long int D.32717;
  long int D.32718;
  unsigned int D.32721;
  unsigned int D.32722;
  void * D.32723;
  int offset.771;
  <unnamed type> D.32726;
  int D.32727;
  _Bool D.32728;
  long int D.32729;
  long int D.32730;
  struct MonoJumpInfo * D.32733;
  <unnamed type> D.32734;
  _Bool D.32735;
  long int D.32736;
  long int D.32737;
  unsigned int iftmp.772;
  int D.32741;
  unsigned int D.32745;
  unsigned int D.32746;
  unsigned int D.32747;
  unsigned int D.32748;
  int D.32749;
  struct MonoJumpInfoImtTramp * D.32750;
  struct MonoMethod * D.32751;
  int D.32752;
  int D.32753;
  struct MonoJumpInfoGSharedVtCall * D.32754;
  struct MonoMethodSignature * D.32755;
  struct MonoMethod * D.32756;
  struct MonoMethod * D.32757;
  struct GPtrArray * D.32758;
  unsigned int D.32759;
  int D.32760;
  void * * D.32761;
  unsigned int i.773;
  unsigned int D.32763;
  void * * D.32764;
  <unnamed type> D.32765;
  int D.32766;
  <unnamed type> D.32767;
  void * D.32768;
  struct MonoClass * D.32769;
  unsigned int i.774;
  guint8 * p;

  try
    {
      p = buf;
      D.32654 = patch_info->type;
      switch (D.32654) <default: <D.25071>, case 3: <D.25019>, case 4: <D.25020>, case 5: <D.25011>, case 6: <D.25018>, case 7: <D.25024>, case 8: <D.25012>, case 10: <D.25034>, case 11: <D.25039>, case 12: <D.25006>, case 13: <D.25044>, case 14: <D.25038>, case 15: <D.25042>, case 16: <D.25045>, case 17: <D.25027>, case 18: <D.25032>, case 19: <D.25033>, case 20: <D.25036>, case 21: <D.25037>, case 23: <D.25040>, case 24: <D.25041>, case 28: <D.25031>, case 29: <D.25030>, case 30: <D.25043>, case 31: <D.25021>, case 32: <D.25025>, case 33: <D.25046>, case 34: <D.25022>, case 35: <D.25047>, case 36: <D.25052>, case 37: <D.25053>, case 38: <D.25054>, case 39: <D.25007>, case 40: <D.25055>, case 41: <D.25056>, case 42: <D.25009>, case 43: <D.25010>, case 44: <D.25057>, case 45: <D.25059>, case 46: <D.25060>, case 47: <D.25008>, case 48: <D.25058>, case 50: <D.25023>, case 51: <D.25004>>
      <D.25004>:
      goto <D.25005>;
      <D.25006>:
      p.761 = p;
      D.32656 = patch_info->data.image;
      D.32657 = get_image_index (acfg, D.32656);
      D.32658 = (int) D.32657;
      encode_value (D.32658, p.761, &p);
      goto <D.25005>;
      <D.25007>:
      <D.25008>:
      <D.25009>:
      <D.25010>:
      goto <D.25005>;
      <D.25011>:
      p.761 = p;
      D.32659 = patch_info->data.offset;
      encode_value (D.32659, p.761, &p);
      goto <D.25005>;
      <D.25012>:
      {
        void * * table;
        int k;

        D.32660 = patch_info->data.table;
        table = D.32660->table;
        p.761 = p;
        D.32660 = patch_info->data.table;
        D.32661 = D.32660->table_size;
        encode_value (D.32661, p.761, &p);
        k = 0;
        goto <D.25016>;
        <D.25015>:
        p.761 = p;
        k.762 = (unsigned int) k;
        D.32663 = k.762 * 4;
        D.32664 = table + D.32663;
        D.32665 = *D.32664;
        D.32666 = (int) D.32665;
        encode_value (D.32666, p.761, &p);
        k = k + 1;
        <D.25016>:
        D.32660 = patch_info->data.table;
        D.32661 = D.32660->table_size;
        if (D.32661 > k) goto <D.25015>; else goto <D.25017>;
        <D.25017>:
        goto <D.25005>;
      }
      <D.25018>:
      <D.25019>:
      <D.25020>:
      <D.25021>:
      <D.25022>:
      <D.25023>:
      p.761 = p;
      D.32667 = patch_info->data.method;
      encode_method_ref (acfg, D.32667, p.761, &p);
      goto <D.25005>;
      <D.25024>:
      <D.25025>:
      {
        guint32 len;

        D.32668 = patch_info->data.name;
        len = strlen (D.32668);
        p.761 = p;
        len.763 = (int) len;
        encode_value (len.763, p.761, &p);
        D.32668 = patch_info->data.name;
        p.761 = p;
        memcpy (p.761, D.32668, len);
        p.761 = p;
        p.764 = p.761 + len;
        p = p.764;
        p.761 = p;
        p.765 = p.761;
        p.766 = p.765 + 1;
        p = p.766;
        *p.765 = 0;
        goto <D.25005>;
      }
      <D.25027>:
      {
        guint32 image_index;
        guint32 token;

        D.32673 = patch_info->data.token;
        D.32674 = D.32673->image;
        image_index = get_image_index (acfg, D.32674);
        D.32673 = patch_info->data.token;
        token = D.32673->token;
        D.32675 = token & 4278190080;
        D.32676 = D.32675 != 1879048192;
        D.32677 = (long int) D.32676;
        D.32678 = __builtin_expect (D.32677, 0);
        if (D.32678 != 0) goto <D.32679>; else goto <D.32680>;
        <D.32679>:
        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.32680>:
        p.761 = p;
        image_index.767 = (int) image_index;
        encode_value (image_index.767, p.761, &p);
        p.761 = p;
        D.32673 = patch_info->data.token;
        D.32682 = D.32673->token;
        D.32683 = D.32682 + 2415919104;
        D.32684 = (int) D.32683;
        encode_value (D.32684, p.761, &p);
        goto <D.25005>;
      }
      <D.25030>:
      <D.25031>:
      <D.25032>:
      <D.25033>:
      p.761 = p;
      D.32673 = patch_info->data.token;
      D.32674 = D.32673->image;
      D.32685 = get_image_index (acfg, D.32674);
      D.32686 = (int) D.32685;
      encode_value (D.32686, p.761, &p);
      p.761 = p;
      D.32673 = patch_info->data.token;
      D.32682 = D.32673->token;
      D.32687 = (int) D.32682;
      encode_value (D.32687, p.761, &p);
      p.761 = p;
      D.32673 = patch_info->data.token;
      D.32688 = D.32673->has_context;
      encode_value (D.32688, p.761, &p);
      D.32673 = patch_info->data.token;
      D.32688 = D.32673->has_context;
      if (D.32688 != 0) goto <D.32689>; else goto <D.32690>;
      <D.32689>:
      p.761 = p;
      D.32673 = patch_info->data.token;
      D.32691 = &D.32673->context;
      encode_generic_context (acfg, D.32691, p.761, &p);
      <D.32690>:
      goto <D.25005>;
      <D.25034>:
      {
        struct MonoClass * ex_class;

        D.32692 = patch_info->data.target;
        D.32693 = mono_defaults.exception_class;
        D.32694 = D.32693->image;
        ex_class = mono_class_from_name (D.32694, "System", D.32692);
        D.32695 = ex_class == 0B;
        D.32696 = (long int) D.32695;
        D.32697 = __builtin_expect (D.32696, 0);
        if (D.32697 != 0) goto <D.32698>; else goto <D.32699>;
        <D.32698>:
        monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "aot-compiler.c", 4948, "ex_class");
        <D.32699>:
        p.761 = p;
        encode_klass_ref (acfg, ex_class, p.761, &p);
        goto <D.25005>;
      }
      <D.25036>:
      p.761 = p;
      D.32692 = patch_info->data.target;
      D.32700 = MEM[(guint32 *)D.32692];
      D.32701 = (int) D.32700;
      encode_value (D.32701, p.761, &p);
      goto <D.25005>;
      <D.25037>:
      p.761 = p;
      D.32692 = patch_info->data.target;
      D.32700 = MEM[(guint32 *)D.32692];
      D.32701 = (int) D.32700;
      encode_value (D.32701, p.761, &p);
      p.761 = p;
      D.32692 = patch_info->data.target;
      D.32702 = D.32692 + 4;
      D.32703 = *D.32702;
      D.32704 = (int) D.32703;
      encode_value (D.32704, p.761, &p);
      goto <D.25005>;
      <D.25038>:
      <D.25039>:
      <D.25040>:
      <D.25041>:
      p.761 = p;
      D.32705 = patch_info->data.klass;
      encode_klass_ref (acfg, D.32705, p.761, &p);
      goto <D.25005>;
      <D.25042>:
      <D.25043>:
      p.761 = p;
      D.32705 = patch_info->data.klass;
      encode_klass_ref (acfg, D.32705, p.761, &p);
      goto <D.25005>;
      <D.25044>:
      <D.25045>:
      p.761 = p;
      D.32706 = patch_info->data.field;
      encode_field_info (acfg, D.32706, p.761, &p);
      goto <D.25005>;
      <D.25046>:
      goto <D.25005>;
      <D.25047>:
      {
        struct MonoJumpInfoRgctxEntry * entry;
        guint32 offset;
        guint8 * buf2;
        guint8 * p2;

        try
          {
            entry = patch_info->data.rgctx_entry;
            D.32707 = entry->method;
            D.32708 = acfg->method_blob_hash;
            D.32709 = monoeg_g_hash_table_lookup (D.32708, D.32707);
            offset = (guint32) D.32709;
            if (offset == 0) goto <D.32710>; else goto <D.32711>;
            <D.32710>:
            buf2 = monoeg_malloc (1024);
            p2 = buf2;
            p2.768 = p2;
            D.32707 = entry->method;
            encode_method_ref (acfg, D.32707, p2.768, &p2);
            p2.768 = p2;
            p2.769 = (int) p2.768;
            buf2.770 = (int) buf2;
            D.32715 = p2.769 - buf2.770;
            D.32716 = D.32715 > 1023;
            D.32717 = (long int) D.32716;
            D.32718 = __builtin_expect (D.32717, 0);
            if (D.32718 != 0) goto <D.32719>; else goto <D.32720>;
            <D.32719>:
            monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "aot-compiler.c", 4990, "p2 - buf2 < 1024");
            <D.32720>:
            p2.768 = p2;
            p2.769 = (int) p2.768;
            buf2.770 = (int) buf2;
            D.32715 = p2.769 - buf2.770;
            D.32721 = (unsigned int) D.32715;
            offset = add_to_blob (acfg, buf2, D.32721);
            monoeg_g_free (buf2);
            D.32722 = offset + 1;
            D.32723 = (void *) D.32722;
            D.32707 = entry->method;
            D.32708 = acfg->method_blob_hash;
            monoeg_g_hash_table_insert_replace (D.32708, D.32707, D.32723, 0);
            goto <D.32724>;
            <D.32711>:
            offset = offset + 4294967295;
            <D.32724>:
            p.761 = p;
            offset.771 = (int) offset;
            encode_value (offset.771, p.761, &p);
            D.32726 = entry->info_type;
            D.32727 = (int) D.32726;
            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", 5001, "(int)entry->info_type < 256");
            <D.32732>:
            D.32733 = entry->data;
            D.32734 = D.32733->type;
            D.32735 = D.32734 > 255;
            D.32736 = (long int) D.32735;
            D.32737 = __builtin_expect (D.32736, 0);
            if (D.32737 != 0) goto <D.32738>; else goto <D.32739>;
            <D.32738>:
            monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "aot-compiler.c", 5002, "entry->data->type < 256");
            <D.32739>:
            p.761 = p;
            D.32741 = entry->in_mrgctx;
            if (D.32741 != 0) goto <D.32742>; else goto <D.32743>;
            <D.32742>:
            iftmp.772 = 1;
            goto <D.32744>;
            <D.32743>:
            iftmp.772 = 0;
            <D.32744>:
            D.32726 = entry->info_type;
            D.32745 = D.32726 << 1;
            D.32746 = iftmp.772 | D.32745;
            D.32733 = entry->data;
            D.32734 = D.32733->type;
            D.32747 = D.32734 << 9;
            D.32748 = D.32746 | D.32747;
            D.32749 = (int) D.32748;
            encode_value (D.32749, p.761, &p);
            p.761 = p;
            D.32733 = entry->data;
            encode_patch (acfg, D.32733, p.761, &p);
            goto <D.25005>;
          }
        finally
          {
            p2 = {CLOBBER};
          }
      }
      <D.25052>:
      <D.25053>:
      <D.25054>:
      <D.25055>:
      goto <D.25005>;
      <D.25056>:
      p.761 = p;
      D.32750 = patch_info->data.imt_tramp;
      D.32751 = D.32750->method;
      encode_method_ref (acfg, D.32751, p.761, &p);
      p.761 = p;
      D.32750 = patch_info->data.imt_tramp;
      D.32752 = D.32750->vt_offset;
      encode_value (D.32752, p.761, &p);
      goto <D.25005>;
      <D.25057>:
      p.761 = p;
      D.32692 = patch_info->data.target;
      encode_signature (acfg, D.32692, p.761, &p);
      goto <D.25005>;
      <D.25058>:
      p.761 = p;
      D.32692 = patch_info->data.target;
      D.32753 = (int) D.32692;
      encode_value (D.32753, p.761, &p);
      goto <D.25005>;
      <D.25059>:
      p.761 = p;
      D.32754 = patch_info->data.gsharedvt;
      D.32755 = D.32754->sig;
      encode_signature (acfg, D.32755, p.761, &p);
      p.761 = p;
      D.32754 = patch_info->data.gsharedvt;
      D.32756 = D.32754->method;
      encode_method_ref (acfg, D.32756, p.761, &p);
      goto <D.25005>;
      <D.25060>:
      {
        struct MonoGSharedVtMethodInfo * info;
        int i;

        info = patch_info->data.gsharedvt_method;
        p.761 = p;
        D.32757 = info->method;
        encode_method_ref (acfg, D.32757, p.761, &p);
        p.761 = p;
        D.32758 = info->entries;
        D.32759 = D.32758->len;
        D.32760 = (int) D.32759;
        encode_value (D.32760, p.761, &p);
        i = 0;
        goto <D.25069>;
        <D.25068>:
        {
          struct MonoRuntimeGenericContextInfoTemplate * template;

          D.32758 = info->entries;
          D.32761 = D.32758->pdata;
          i.773 = (unsigned int) i;
          D.32763 = i.773 * 4;
          D.32764 = D.32761 + D.32763;
          template = *D.32764;
          p.761 = p;
          D.32765 = template->info_type;
          D.32766 = (int) D.32765;
          encode_value (D.32766, p.761, &p);
          D.32765 = template->info_type;
          D.32767 = mini_rgctx_info_type_to_patch_info_type (D.32765);
          switch (D.32767) <default: <D.25067>, case 11: <D.25064>, case 13: <D.25066>>
          <D.25064>:
          p.761 = p;
          D.32768 = template->data;
          D.32769 = mono_class_from_mono_type (D.32768);
          encode_klass_ref (acfg, D.32769, p.761, &p);
          goto <D.25065>;
          <D.25066>:
          p.761 = p;
          D.32768 = template->data;
          encode_field_info (acfg, D.32768, p.761, &p);
          goto <D.25065>;
          <D.25067>:
          monoeg_assertion_message ("* Assertion: should not be reached at %s:%d\n", "aot-compiler.c", 5044);
          <D.25065>:
        }
        i = i + 1;
        <D.25069>:
        i.774 = (unsigned int) i;
        D.32758 = info->entries;
        D.32759 = D.32758->len;
        if (i.774 < D.32759) goto <D.25068>; else goto <D.25070>;
        <D.25070>:
        goto <D.25005>;
      }
      <D.25071>:
      D.32654 = patch_info->type;
      monoeg_g_log (0B, 16, "unable to handle jump info %d", D.32654);
      monoeg_assertion_message ("* Assertion: should not be reached at %s:%d\n", "aot-compiler.c", 5052);
      <D.25005>:
      p.761 = p;
      *endbuf = p.761;
    }
  finally
    {
      p = {CLOBBER};
    }
}


encode_field_info (struct MonoAotCompile * cfg, struct MonoClassField * field, guint8 * buf, guint8 * * endbuf)
{
  guint8 * p.775;
  struct MonoClass * D.32774;
  unsigned int D.32775;
  _Bool D.32776;
  long int D.32777;
  long int D.32778;
  unsigned int D.32781;
  int D.32782;
  guint32 token;
  guint8 * p;

  try
    {
      token = mono_get_field_token (field);
      p = buf;
      p.775 = p;
      D.32774 = field->parent;
      encode_klass_ref (cfg, D.32774, p.775, &p);
      D.32775 = token & 4278190080;
      D.32776 = D.32775 != 67108864;
      D.32777 = (long int) D.32776;
      D.32778 = __builtin_expect (D.32777, 0);
      if (D.32778 != 0) goto <D.32779>; else goto <D.32780>;
      <D.32779>:
      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.32780>:
      p.775 = p;
      D.32781 = token + 4227858432;
      D.32782 = (int) D.32781;
      encode_value (D.32782, p.775, &p);
      p.775 = p;
      *endbuf = p.775;
    }
  finally
    {
      p = {CLOBBER};
    }
}


mono_get_field_token (struct MonoClassField * field)
{
  struct MonoClassField * D.32783;
  unsigned int i.776;
  unsigned int D.32785;
  struct MonoClassField * D.32786;
  guint32 D.32789;
  unsigned int D.32790;
  unsigned int i.777;
  unsigned int D.32792;
  unsigned int D.32793;
  unsigned int D.32794;
  struct MonoClass * klass;
  int i;

  klass = field->parent;
  i = 0;
  goto <D.23849>;
  <D.23848>:
  D.32783 = klass->fields;
  i.776 = (unsigned int) i;
  D.32785 = i.776 * 16;
  D.32786 = D.32783 + D.32785;
  if (D.32786 == field) goto <D.32787>; else goto <D.32788>;
  <D.32787>:
  D.32790 = klass->field.first;
  i.777 = (unsigned int) i;
  D.32792 = D.32790 + i.777;
  D.32793 = D.32792 + 1;
  D.32789 = D.32793 | 67108864;
  return D.32789;
  <D.32788>:
  i = i + 1;
  <D.23849>:
  i.777 = (unsigned int) i;
  D.32794 = klass->field.count;
  if (i.777 < D.32794) goto <D.23848>; else goto <D.23850>;
  <D.23850>:
  monoeg_assertion_message ("* Assertion: should not be reached at %s:%d\n", "aot-compiler.c", 2035);
  D.32789 = 0;
  return D.32789;
}


emit_exception_info (struct MonoAotCompile * acfg)
{
  unsigned int D.32796;
  unsigned int D.32797;
  struct MonoCompile * * D.32798;
  unsigned int i.778;
  unsigned int D.32800;
  struct MonoCompile * * D.32801;
  struct MonoCompile * D.32802;
  gint32 * D.32805;
  unsigned int D.32806;
  int D.32807;
  unsigned int i.779;
  int D.32810;
  unsigned int D.32811;
  int D.32812;
  unsigned int D.32813;
  unsigned int D.32814;
  int D.32815;
  int i;
  char symbol[256];
  gint32 * offsets;

  try
    {
      D.32796 = acfg->nmethods;
      D.32797 = D.32796 * 4;
      offsets = monoeg_malloc0 (D.32797);
      i = 0;
      goto <D.25829>;
      <D.25828>:
      D.32798 = acfg->cfgs;
      i.778 = (unsigned int) i;
      D.32800 = i.778 * 4;
      D.32801 = D.32798 + D.32800;
      D.32802 = *D.32801;
      if (D.32802 != 0B) goto <D.32803>; else goto <D.32804>;
      <D.32803>:
      D.32798 = acfg->cfgs;
      i.778 = (unsigned int) i;
      D.32800 = i.778 * 4;
      D.32801 = D.32798 + D.32800;
      D.32802 = *D.32801;
      emit_exception_debug_info (acfg, D.32802);
      i.778 = (unsigned int) i;
      D.32800 = i.778 * 4;
      D.32805 = offsets + D.32800;
      D.32798 = acfg->cfgs;
      i.778 = (unsigned int) i;
      D.32800 = i.778 * 4;
      D.32801 = D.32798 + D.32800;
      D.32802 = *D.32801;
      D.32806 = D.32802->ex_info_offset;
      D.32807 = (int) D.32806;
      *D.32805 = D.32807;
      goto <D.32808>;
      <D.32804>:
      i.778 = (unsigned int) i;
      D.32800 = i.778 * 4;
      D.32805 = offsets + D.32800;
      *D.32805 = 0;
      <D.32808>:
      i = i + 1;
      <D.25829>:
      i.779 = (unsigned int) i;
      D.32796 = acfg->nmethods;
      if (i.779 < D.32796) goto <D.25828>; else goto <D.25830>;
      <D.25830>:
      sprintf (&symbol, "ex_info_offsets");
      emit_section_change (acfg, ".rodata", 1);
      emit_alignment (acfg, 8);
      emit_label (acfg, &symbol);
      D.32796 = acfg->nmethods;
      D.32810 = (int) D.32796;
      D.32811 = emit_offset_table (acfg, D.32810, 10, offsets);
      D.32812 = acfg->stats.offsets_size;
      D.32813 = (unsigned int) D.32812;
      D.32814 = D.32813 + D.32811;
      D.32815 = (int) D.32814;
      acfg->stats.offsets_size = D.32815;
      monoeg_g_free (offsets);
    }
  finally
    {
      symbol = {CLOBBER};
    }
}


emit_exception_debug_info (struct MonoAotCompile * acfg, struct MonoCompile * cfg)
{
  unsigned int D.32816;
  int D.32817;
  <unnamed-unsigned:15> D.32821;
  int D.32822;
  int D.32823;
  unsigned int D.32824;
  unsigned int debug_info_size.780;
  unsigned int D.32826;
  guint32 iftmp.781;
  int D.32830;
  int D.32831;
  unsigned int D.32833;
  unsigned int D.32834;
  unsigned int D.32835;
  unsigned int D.32836;
  unsigned int buf_size.782;
  struct GSList * D.32838;
  _Bool D.32839;
  unsigned char D.32840;
  unsigned char D.32841;
  _Bool D.32842;
  int D.32843;
  int iftmp.783;
  int D.32848;
  int iftmp.784;
  short unsigned int D.32850;
  short unsigned int D.32851;
  int D.32855;
  int iftmp.785;
  int D.32860;
  int iftmp.786;
  unsigned char D.32862;
  unsigned char D.32863;
  int D.32867;
  int iftmp.787;
  unsigned char D.32869;
  int D.32873;
  int iftmp.788;
  guint8 * D.32875;
  int D.32879;
  int iftmp.789;
  unsigned char D.32881;
  int D.32885;
  guint8 * p.790;
  int flags.791;
  unsigned int encoded_len.792;
  unsigned int D.32891;
  int D.32892;
  unsigned int D.32894;
  int D.32895;
  short unsigned int D.32898;
  int D.32899;
  int D.32904;
  struct MonoExceptionClause * D.32905;
  unsigned int k.793;
  unsigned int D.32907;
  unsigned int D.32908;
  int D.32909;
  struct MonoClass * D.32910;
  unsigned int cindex1.794;
  unsigned int D.32915;
  unsigned int cindex2.795;
  unsigned int D.32917;
  unsigned int D.32920;
  unsigned int D.32921;
  unsigned int D.32924;
  unsigned int D.32925;
  short unsigned int D.32929;
  short unsigned int D.32930;
  <unnamed-unsigned:15> D.32933;
  int D.32934;
  unsigned int D.32935;
  int D.32936;
  int D.32937;
  unsigned int D.32938;
  void * D.32941;
  int D.32942;
  int code.796;
  int D.32944;
  struct MonoClass * D.32946;
  guint8 * p2.797;
  int p2.798;
  int buf2.799;
  _Bool D.32952;
  long int D.32953;
  long int D.32954;
  unsigned int len.800;
  int D.32958;
  sizetype D.32959;
  guint8 * p.801;
  void * D.32962;
  int D.32963;
  int D.32964;
  void * D.32965;
  int D.32966;
  int D.32967;
  void * D.32968;
  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;
  unsigned int i.802;
  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.803;
  struct MonoMethod * D.33022;
  int p2.804;
  int buf2.805;
  _Bool D.33025;
  long int D.33026;
  long int D.33027;
  unsigned int len.806;
  int D.33031;
  sizetype D.33032;
  guint8 * p.807;
  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;
  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;
  unsigned int j.808;
  unsigned int D.33072;
  int * D.33073;
  int D.33074;
  unsigned int buf_size.809;
  _Bool D.33076;
  long int D.33077;
  long int D.33078;
  int debug_info_size.810;
  guint8 * debug_info.811;
  guint8 * p.812;
  int D.33088;
  guint8 * p.813;
  unsigned int p.814;
  unsigned int D.33091;
  guint8 * p.815;
  int D.33093;
  int p.816;
  int buf.817;
  int D.33096;
  int D.33097;
  _Bool D.33098;
  long int D.33099;
  long int D.33100;
  guint32 iftmp.818;
  unsigned int D.33107;
  unsigned int D.33108;
  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.32816 = get_method_index (acfg, method);
      method_index = (int) D.32816;
      D.32817 = acfg->aot_opts.nodebug;
      if (D.32817 == 0) goto <D.32818>; else goto <D.32819>;
      <D.32818>:
      mono_debug_serialize_debug_info (cfg, &debug_info, &debug_info_size);
      goto <D.32820>;
      <D.32819>:
      debug_info = 0B;
      debug_info_size = 0;
      <D.32820>:
      seq_points = cfg->seq_point_info;
      D.32821 = header->num_clauses;
      D.32822 = (int) D.32821;
      D.32823 = D.32822 * 256;
      D.32824 = (unsigned int) D.32823;
      debug_info_size.780 = debug_info_size;
      D.32826 = D.32824 + debug_info_size.780;
      if (seq_points != 0B) goto <D.32828>; else goto <D.32829>;
      <D.32828>:
      D.32830 = seq_points->len;
      D.32831 = D.32830 * 128;
      iftmp.781 = (guint32) D.32831;
      goto <D.32832>;
      <D.32829>:
      iftmp.781 = 0;
      <D.32832>:
      D.32833 = D.32826 + iftmp.781;
      D.32834 = cfg->gc_map_size;
      D.32835 = D.32833 + D.32834;
      D.32836 = D.32835 + 2048;
      buf_size = (int) D.32836;
      buf_size.782 = (unsigned int) buf_size;
      buf = monoeg_malloc (buf_size.782);
      p = buf;
      D.32838 = cfg->unwind_ops;
      D.32839 = D.32838 != 0B;
      use_unwind_ops = (gboolean) D.32839;
      D.32840 = BIT_FIELD_REF <*jinfo, 8, 176>;
      D.32841 = D.32840 & 2;
      D.32842 = D.32841 != 0;
      D.32843 = (int) D.32842;
      if (use_unwind_ops != 0) goto <D.32845>; else goto <D.32846>;
      <D.32845>:
      iftmp.783 = 2;
      goto <D.32847>;
      <D.32846>:
      iftmp.783 = 0;
      <D.32847>:
      D.32848 = D.32843 | iftmp.783;
      D.32850 = BIT_FIELD_REF <*header, 16, 80>;
      D.32851 = D.32850 & 32767;
      if (D.32851 != 0) goto <D.32852>; else goto <D.32853>;
      <D.32852>:
      iftmp.784 = 4;
      goto <D.32854>;
      <D.32853>:
      iftmp.784 = 0;
      <D.32854>:
      D.32855 = D.32848 | iftmp.784;
      if (seq_points != 0B) goto <D.32857>; else goto <D.32858>;
      <D.32857>:
      iftmp.785 = 8;
      goto <D.32859>;
      <D.32858>:
      iftmp.785 = 0;
      <D.32859>:
      D.32860 = D.32855 | iftmp.785;
      D.32862 = BIT_FIELD_REF <*cfg, 8, 3400>;
      D.32863 = D.32862 & 1;
      if (D.32863 != 0) goto <D.32864>; else goto <D.32865>;
      <D.32864>:
      iftmp.786 = 16;
      goto <D.32866>;
      <D.32865>:
      iftmp.786 = 0;
      <D.32866>:
      D.32867 = D.32860 | iftmp.786;
      D.32840 = BIT_FIELD_REF <*jinfo, 8, 176>;
      D.32869 = D.32840 & 4;
      if (D.32869 != 0) goto <D.32870>; else goto <D.32871>;
      <D.32870>:
      iftmp.787 = 32;
      goto <D.32872>;
      <D.32871>:
      iftmp.787 = 0;
      <D.32872>:
      D.32873 = D.32867 | iftmp.787;
      D.32875 = cfg->gc_map;
      if (D.32875 != 0B) goto <D.32876>; else goto <D.32877>;
      <D.32876>:
      iftmp.788 = 64;
      goto <D.32878>;
      <D.32877>:
      iftmp.788 = 0;
      <D.32878>:
      D.32879 = D.32873 | iftmp.788;
      D.32840 = BIT_FIELD_REF <*jinfo, 8, 176>;
      D.32881 = D.32840 & 8;
      if (D.32881 != 0) goto <D.32882>; else goto <D.32883>;
      <D.32882>:
      iftmp.789 = 128;
      goto <D.32884>;
      <D.32883>:
      iftmp.789 = 0;
      <D.32884>:
      D.32885 = D.32879 | iftmp.789;
      flags = (guint32) D.32885;
      p.790 = p;
      flags.791 = (int) flags;
      encode_value (flags.791, p.790, &p);
      if (use_unwind_ops != 0) goto <D.32888>; else goto <D.32889>;
      <D.32888>:
      {
        guint32 encoded_len;
        guint8 * encoded;

        try
          {
            D.32838 = cfg->unwind_ops;
            encoded = mono_unwind_ops_encode (D.32838, &encoded_len);
            p.790 = p;
            encoded_len.792 = encoded_len;
            D.32891 = get_unwind_info_offset (acfg, encoded, encoded_len.792);
            D.32892 = (int) D.32891;
            encode_value (D.32892, p.790, &p);
            monoeg_g_free (encoded);
          }
        finally
          {
            encoded_len = {CLOBBER};
          }
      }
      goto <D.32893>;
      <D.32889>:
      p.790 = p;
      D.32894 = jinfo->used_regs;
      D.32895 = (int) D.32894;
      encode_value (D.32895, p.790, &p);
      <D.32893>:
      D.32840 = BIT_FIELD_REF <*jinfo, 8, 176>;
      D.32869 = D.32840 & 4;
      if (D.32869 != 0) goto <D.32896>; else goto <D.32897>;
      <D.32896>:
      {
        struct MonoTryBlockHoleTableJitInfo * table;

        table = mono_jit_info_get_try_block_hole_table_info (jinfo);
        p.790 = p;
        D.32898 = table->num_holes;
        D.32899 = (int) D.32898;
        encode_value (D.32899, p.790, &p);
      }
      <D.32897>:
      D.32862 = BIT_FIELD_REF <*cfg, 8, 3400>;
      D.32863 = D.32862 & 1;
      if (D.32863 != 0) goto <D.32900>; else goto <D.32901>;
      <D.32900>:
      D.32850 = BIT_FIELD_REF <*header, 16, 80>;
      D.32851 = D.32850 & 32767;
      if (D.32851 != 0) goto <D.32902>; else goto <D.32903>;
      <D.32902>:
      p.790 = p;
      D.32821 = header->num_clauses;
      D.32904 = (int) D.32821;
      encode_value (D.32904, p.790, &p);
      <D.32903>:
      k = 0;
      goto <D.25154>;
      <D.25153>:
      {
        struct MonoExceptionClause * clause;

        D.32905 = header->clauses;
        k.793 = (unsigned int) k;
        D.32907 = k.793 * 24;
        clause = D.32905 + D.32907;
        p.790 = p;
        D.32908 = clause->flags;
        D.32909 = (int) D.32908;
        encode_value (D.32909, p.790, &p);
        D.32910 = clause->data.catch_class;
        if (D.32910 != 0B) goto <D.32911>; else goto <D.32912>;
        <D.32911>:
        p.790 = p;
        encode_value (1, p.790, &p);
        p.790 = p;
        D.32910 = clause->data.catch_class;
        encode_klass_ref (acfg, D.32910, p.790, &p);
        goto <D.32913>;
        <D.32912>:
        p.790 = p;
        encode_value (0, p.790, &p);
        <D.32913>:
        i = 0;
        goto <D.25151>;
        <D.25150>:
        {
          gint32 cindex1;
          struct MonoExceptionClause * clause1;
          gint32 cindex2;
          struct MonoExceptionClause * clause2;

          cindex1 = k;
          D.32905 = header->clauses;
          cindex1.794 = (unsigned int) cindex1;
          D.32915 = cindex1.794 * 24;
          clause1 = D.32905 + D.32915;
          cindex2 = i;
          D.32905 = header->clauses;
          cindex2.795 = (unsigned int) cindex2;
          D.32917 = cindex2.795 * 24;
          clause2 = D.32905 + D.32917;
          if (cindex1 != cindex2) goto <D.32918>; else goto <D.32919>;
          <D.32918>:
          D.32920 = clause1->try_offset;
          D.32921 = clause2->try_offset;
          if (D.32920 >= D.32921) goto <D.32922>; else goto <D.32923>;
          <D.32922>:
          D.32924 = clause1->handler_offset;
          D.32925 = clause2->handler_offset;
          if (D.32924 <= D.32925) goto <D.32926>; else goto <D.32927>;
          <D.32926>:
          p.790 = p;
          encode_value (i, p.790, &p);
          <D.32927>:
          <D.32923>:
          <D.32919>:
        }
        i = i + 1;
        <D.25151>:
        D.32821 = header->num_clauses;
        D.32822 = (int) D.32821;
        if (D.32822 > i) goto <D.25150>; else goto <D.25152>;
        <D.25152>:
        p.790 = p;
        encode_value (-1, p.790, &p);
      }
      k = k + 1;
      <D.25154>:
      D.32821 = header->num_clauses;
      D.32822 = (int) D.32821;
      if (D.32822 > k) goto <D.25153>; else goto <D.25155>;
      <D.25155>:
      goto <D.32928>;
      <D.32901>:
      D.32929 = BIT_FIELD_REF <*jinfo, 16, 160>;
      D.32930 = D.32929 & 32767;
      if (D.32930 != 0) goto <D.32931>; else goto <D.32932>;
      <D.32931>:
      p.790 = p;
      D.32933 = jinfo->num_clauses;
      D.32934 = (int) D.32933;
      encode_value (D.32934, p.790, &p);
      <D.32932>:
      k = 0;
      goto <D.25161>;
      <D.25160>:
      {
        struct MonoJitExceptionInfo * ei;

        ei = &jinfo->clauses[k];
        p.790 = p;
        D.32935 = ei->flags;
        D.32936 = (int) D.32935;
        encode_value (D.32936, p.790, &p);
        p.790 = p;
        D.32937 = ei->exvar_offset;
        encode_value (D.32937, p.790, &p);
        D.32935 = ei->flags;
        D.32938 = D.32935 + 4294967295;
        if (D.32938 <= 1) goto <D.32939>; else goto <D.32940>;
        <D.32939>:
        p.790 = p;
        D.32941 = ei->data.filter;
        D.32942 = (int) D.32941;
        code.796 = (int) code;
        D.32944 = D.32942 - code.796;
        encode_value (D.32944, p.790, &p);
        goto <D.32945>;
        <D.32940>:
        D.32946 = ei->data.catch_class;
        if (D.32946 != 0B) goto <D.32947>; else goto <D.32948>;
        <D.32947>:
        {
          guint8 * buf2;
          guint8 * p2;
          int len;

          try
            {
              buf2 = monoeg_malloc (4096);
              p2 = buf2;
              p2.797 = p2;
              D.32946 = ei->data.catch_class;
              encode_klass_ref (acfg, D.32946, p2.797, &p2);
              p2.797 = p2;
              p2.798 = (int) p2.797;
              buf2.799 = (int) buf2;
              len = p2.798 - buf2.799;
              D.32952 = len > 4095;
              D.32953 = (long int) D.32952;
              D.32954 = __builtin_expect (D.32953, 0);
              if (D.32954 != 0) goto <D.32955>; else goto <D.32956>;
              <D.32955>:
              monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "aot-compiler.c", 5325, "len < 4096");
              <D.32956>:
              p.790 = p;
              encode_value (len, p.790, &p);
              len.800 = (unsigned int) len;
              p.790 = p;
              memcpy (p.790, buf2, len.800);
              p.790 = p;
              p2.797 = p2;
              p2.798 = (int) p2.797;
              buf2.799 = (int) buf2;
              D.32958 = p2.798 - buf2.799;
              D.32959 = (sizetype) D.32958;
              p.801 = p.790 + D.32959;
              p = p.801;
              monoeg_g_free (buf2);
            }
          finally
            {
              p2 = {CLOBBER};
            }
        }
        goto <D.32961>;
        <D.32948>:
        p.790 = p;
        encode_value (0, p.790, &p);
        <D.32961>:
        <D.32945>:
        p.790 = p;
        D.32962 = ei->try_start;
        D.32963 = (int) D.32962;
        code.796 = (int) code;
        D.32964 = D.32963 - code.796;
        encode_value (D.32964, p.790, &p);
        p.790 = p;
        D.32965 = ei->try_end;
        D.32966 = (int) D.32965;
        code.796 = (int) code;
        D.32967 = D.32966 - code.796;
        encode_value (D.32967, p.790, &p);
        p.790 = p;
        D.32968 = ei->handler_start;
        D.32969 = (int) D.32968;
        code.796 = (int) code;
        D.32970 = D.32969 - code.796;
        encode_value (D.32970, p.790, &p);
      }
      k = k + 1;
      <D.25161>:
      D.32933 = jinfo->num_clauses;
      D.32971 = (int) D.32933;
      if (D.32971 > k) goto <D.25160>; else goto <D.25162>;
      <D.25162>:
      <D.32928>:
      D.32840 = BIT_FIELD_REF <*jinfo, 8, 176>;
      D.32869 = D.32840 & 4;
      if (D.32869 != 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.25166>;
        <D.25165>:
        {
          struct MonoTryBlockHoleJitInfo * hole;

          hole = &table->holes[i];
          p.790 = p;
          D.32974 = hole->clause;
          D.32975 = (int) D.32974;
          encode_value (D.32975, p.790, &p);
          p.790 = p;
          D.32976 = hole->length;
          D.32977 = (int) D.32976;
          encode_value (D.32977, p.790, &p);
          p.790 = p;
          D.32978 = hole->offset;
          D.32979 = (int) D.32978;
          encode_value (D.32979, p.790, &p);
        }
        i = i + 1;
        <D.25166>:
        D.32980 = table->num_holes;
        D.32981 = (int) D.32980;
        if (D.32981 > i) goto <D.25165>; else goto <D.25167>;
        <D.25167>:
      }
      <D.32973>:
      D.32840 = BIT_FIELD_REF <*jinfo, 8, 176>;
      D.32881 = D.32840 & 8;
      if (D.32881 != 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.790 = p;
        D.32984 = eh_info->stack_size;
        D.32985 = (int) D.32984;
        encode_value (D.32985, p.790, &p);
      }
      <D.32983>:
      D.32840 = BIT_FIELD_REF <*jinfo, 8, 176>;
      D.32841 = D.32840 & 2;
      if (D.32841 != 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.790 = p;
            D.32988 = gi->nlocs;
            encode_value (D.32988, p.790, &p);
            D.32988 = gi->nlocs;
            if (D.32988 != 0) goto <D.32989>; else goto <D.32990>;
            <D.32989>:
            i = 0;
            goto <D.25177>;
            <D.25176>:
            {
              struct MonoDwarfLocListEntry * entry;

              D.32991 = gi->locations;
              i.802 = (unsigned int) i;
              D.32993 = i.802 * 20;
              entry = D.32991 + D.32993;
              p.790 = p;
              D.32994 = entry->is_reg;
              D.32995 = D.32994 != 0;
              D.32996 = (int) D.32995;
              encode_value (D.32996, p.790, &p);
              p.790 = p;
              D.32997 = entry->reg;
              encode_value (D.32997, p.790, &p);
              D.32994 = entry->is_reg;
              if (D.32994 == 0) goto <D.32998>; else goto <D.32999>;
              <D.32998>:
              p.790 = p;
              D.33000 = entry->offset;
              encode_value (D.33000, p.790, &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.790 = p;
              D.33003 = entry->from;
              encode_value (D.33003, p.790, &p);
              <D.33009>:
              p.790 = p;
              D.33010 = entry->to;
              encode_value (D.33010, p.790, &p);
            }
            i = i + 1;
            <D.25177>:
            D.32988 = gi->nlocs;
            if (D.32988 > i) goto <D.25176>; else goto <D.25178>;
            <D.25178>:
            goto <D.33011>;
            <D.32990>:
            D.32862 = BIT_FIELD_REF <*cfg, 8, 3400>;
            D.32863 = D.32862 & 1;
            if (D.32863 == 0) goto <D.33012>; else goto <D.33013>;
            <D.33012>:
            p.790 = p;
            D.33014 = BIT_FIELD_REF <*gi, 8, 136>;
            D.33015 = D.33014 & 1;
            D.33016 = D.33015 != 0;
            D.33017 = (int) D.33016;
            encode_value (D.33017, p.790, &p);
            p.790 = p;
            D.33018 = gi->this_reg;
            D.33019 = (int) D.33018;
            encode_value (D.33019, p.790, &p);
            p.790 = p;
            D.33020 = gi->this_offset;
            encode_value (D.33020, p.790, &p);
            <D.33013>:
            <D.33011>:
            buf2 = monoeg_malloc (4096);
            p2 = buf2;
            p2.803 = p2;
            D.33022 = jinfo->d.method;
            encode_method_ref (acfg, D.33022, p2.803, &p2);
            p2.803 = p2;
            p2.804 = (int) p2.803;
            buf2.805 = (int) buf2;
            len = p2.804 - buf2.805;
            D.33025 = len > 4095;
            D.33026 = (long int) D.33025;
            D.33027 = __builtin_expect (D.33026, 0);
            if (D.33027 != 0) goto <D.33028>; else goto <D.33029>;
            <D.33028>:
            monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "aot-compiler.c", 5397, "len < 4096");
            <D.33029>:
            p.790 = p;
            encode_value (len, p.790, &p);
            len.806 = (unsigned int) len;
            p.790 = p;
            memcpy (p.790, buf2, len.806);
            p.790 = p;
            p2.803 = p2;
            p2.804 = (int) p2.803;
            buf2.805 = (int) buf2;
            D.33031 = p2.804 - buf2.805;
            D.33032 = (sizetype) D.33031;
            p.807 = p.790 + D.33032;
            p = p.807;
            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, 168>;
              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.790 = p;
              encode_value (1, p.790, &p);
              D.33048 = context->class_inst;
              if (D.33048 != 0B) goto <D.33049>; else goto <D.33050>;
              <D.33049>:
              inst = context->class_inst;
              p.790 = p;
              D.33051 = inst->type_argc;
              D.33052 = (int) D.33051;
              encode_value (D.33052, p.790, &p);
              i = 0;
              goto <D.25183>;
              <D.25182>:
              p.790 = p;
              D.33038 = gsctx->var_is_vt;
              i.802 = (unsigned int) i;
              D.33053 = i.802 * 4;
              D.33054 = D.33038 + D.33053;
              D.33055 = *D.33054;
              encode_value (D.33055, p.790, &p);
              i = i + 1;
              <D.25183>:
              D.33051 = inst->type_argc;
              D.33056 = (int) D.33051;
              if (D.33056 > i) goto <D.25182>; else goto <D.25184>;
              <D.25184>:
              goto <D.33057>;
              <D.33050>:
              p.790 = p;
              encode_value (0, p.790, &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.790 = p;
              D.33051 = inst->type_argc;
              D.33052 = (int) D.33051;
              encode_value (D.33052, p.790, &p);
              i = 0;
              goto <D.25186>;
              <D.25185>:
              p.790 = p;
              D.33040 = gsctx->mvar_is_vt;
              i.802 = (unsigned int) i;
              D.33053 = i.802 * 4;
              D.33061 = D.33040 + D.33053;
              D.33062 = *D.33061;
              encode_value (D.33062, p.790, &p);
              i = i + 1;
              <D.25186>:
              D.33051 = inst->type_argc;
              D.33056 = (int) D.33051;
              if (D.33056 > i) goto <D.25185>; else goto <D.25187>;
              <D.25187>:
              goto <D.33063>;
              <D.33060>:
              p.790 = p;
              encode_value (0, p.790, &p);
              <D.33063>:
            }
            goto <D.33036>;
            <D.33034>:
            p.790 = p;
            encode_value (0, p.790, &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.790 = p;
        D.32830 = seq_points->len;
        encode_value (D.32830, p.790, &p);
        last_native_offset = 0;
        last_il_offset = last_native_offset;
        i = 0;
        goto <D.25198>;
        <D.25197>:
        {
          struct SeqPoint * sp;

          sp = &seq_points->seq_points[i];
          il_offset = sp->il_offset;
          native_offset = sp->native_offset;
          p.790 = p;
          D.33066 = il_offset - last_il_offset;
          encode_value (D.33066, p.790, &p);
          p.790 = p;
          D.33067 = native_offset - last_native_offset;
          encode_value (D.33067, p.790, &p);
          last_il_offset = il_offset;
          last_native_offset = native_offset;
          p.790 = p;
          D.33068 = sp->flags;
          encode_value (D.33068, p.790, &p);
          p.790 = p;
          D.33069 = sp->next_len;
          encode_value (D.33069, p.790, &p);
          j = 0;
          goto <D.25195>;
          <D.25194>:
          p.790 = p;
          D.33070 = sp->next;
          j.808 = (unsigned int) j;
          D.33072 = j.808 * 4;
          D.33073 = D.33070 + D.33072;
          D.33074 = *D.33073;
          encode_value (D.33074, p.790, &p);
          j = j + 1;
          <D.25195>:
          D.33069 = sp->next_len;
          if (D.33069 > j) goto <D.25194>; else goto <D.25196>;
          <D.25196>:
        }
        i = i + 1;
        <D.25198>:
        D.32830 = seq_points->len;
        if (D.32830 > i) goto <D.25197>; else goto <D.25199>;
        <D.25199>:
      }
      <D.33065>:
      buf_size.809 = (unsigned int) buf_size;
      debug_info_size.780 = debug_info_size;
      D.33076 = buf_size.809 <= debug_info_size.780;
      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.790 = p;
      debug_info_size.780 = debug_info_size;
      debug_info_size.810 = (int) debug_info_size.780;
      encode_value (debug_info_size.810, p.790, &p);
      debug_info_size.780 = debug_info_size;
      if (debug_info_size.780 != 0) goto <D.33082>; else goto <D.33083>;
      <D.33082>:
      debug_info_size.780 = debug_info_size;
      debug_info.811 = debug_info;
      p.790 = p;
      memcpy (p.790, debug_info.811, debug_info_size.780);
      p.790 = p;
      debug_info_size.780 = debug_info_size;
      p.812 = p.790 + debug_info_size.780;
      p = p.812;
      debug_info.811 = debug_info;
      monoeg_g_free (debug_info.811);
      <D.33083>:
      D.32875 = cfg->gc_map;
      if (D.32875 != 0B) goto <D.33086>; else goto <D.33087>;
      <D.33086>:
      p.790 = p;
      D.32834 = cfg->gc_map_size;
      D.33088 = (int) D.32834;
      encode_value (D.33088, p.790, &p);
      goto <D.25201>;
      <D.25200>:
      p.790 = p;
      p.813 = p.790 + 1;
      p = p.813;
      <D.25201>:
      p.790 = p;
      p.814 = (unsigned int) p.790;
      D.33091 = p.814 & 3;
      if (D.33091 != 0) goto <D.25200>; else goto <D.25202>;
      <D.25202>:
      D.32834 = cfg->gc_map_size;
      D.32875 = cfg->gc_map;
      p.790 = p;
      memcpy (p.790, D.32875, D.32834);
      p.790 = p;
      D.32834 = cfg->gc_map_size;
      p.815 = p.790 + D.32834;
      p = p.815;
      <D.33087>:
      D.33093 = acfg->stats.ex_info_size;
      p.790 = p;
      p.816 = (int) p.790;
      buf.817 = (int) buf;
      D.33096 = p.816 - buf.817;
      D.33097 = D.33093 + D.33096;
      acfg->stats.ex_info_size = D.33097;
      p.790 = p;
      p.816 = (int) p.790;
      buf.817 = (int) buf;
      D.33096 = p.816 - buf.817;
      D.33098 = D.33096 >= buf_size;
      D.33099 = (long int) D.33098;
      D.33100 = __builtin_expect (D.33099, 0);
      if (D.33100 != 0) goto <D.33101>; else goto <D.33102>;
      <D.33101>:
      monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "aot-compiler.c", 5478, "p - buf < buf_size");
      <D.33102>:
      D.32875 = cfg->gc_map;
      if (D.32875 != 0B) goto <D.33104>; else goto <D.33105>;
      <D.33104>:
      iftmp.818 = 4;
      goto <D.33106>;
      <D.33105>:
      iftmp.818 = 1;
      <D.33106>:
      p.790 = p;
      p.816 = (int) p.790;
      buf.817 = (int) buf;
      D.33096 = p.816 - buf.817;
      D.33107 = (unsigned int) D.33096;
      D.33108 = add_to_blob_aligned (acfg, buf, D.33107, iftmp.818);
      cfg->ex_info_offset = D.33108;
      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.33109;
  struct MonoDynamicStream * D.33112;
  unsigned int D.33113;
  unsigned int D.33116;
  guint32 D.33117;
  char buf[4];
  guint32 count;

  try
    {
      buf = {};
      D.33109 = acfg->blob.alloc_size;
      if (D.33109 == 0) goto <D.33110>; else goto <D.33111>;
      <D.33110>:
      D.33112 = &acfg->blob;
      stream_init (D.33112);
      <D.33111>:
      D.33113 = acfg->blob.index;
      count = D.33113 % align;
      if (count != 0) goto <D.33114>; else goto <D.33115>;
      <D.33114>:
      D.33116 = 4 - count;
      D.33112 = &acfg->blob;
      add_stream_data (D.33112, &buf, D.33116);
      <D.33115>:
      D.33112 = &acfg->blob;
      D.33117 = add_stream_data (D.33112, data, data_len);
      return D.33117;
    }
  finally
    {
      buf = {CLOBBER};
    }
}


emit_unwind_info (struct MonoAotCompile * acfg)
{
  struct GPtrArray * D.33120;
  void * * D.33121;
  unsigned int i.819;
  unsigned int D.33123;
  void * * D.33124;
  void * D.33125;
  guint8 * p.820;
  unsigned int unwind_info_len.821;
  int unwind_info_len.822;
  int p.823;
  int buf.824;
  int D.33131;
  int unwind_info_len.825;
  int D.33133;
  unsigned int D.33134;
  unsigned int D.33135;
  unsigned int D.33136;
  unsigned int D.33137;
  int D.33138;
  unsigned int i.826;
  unsigned int D.33140;
  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.25842>;
      <D.25841>:
      {
        guint32 index;
        guint8 * unwind_info;
        guint32 unwind_info_len;
        guint8 buf[16];
        guint8 * p;

        try
          {
            D.33120 = acfg->unwind_ops;
            D.33121 = D.33120->pdata;
            i.819 = (unsigned int) i;
            D.33123 = i.819 * 4;
            D.33124 = D.33121 + D.33123;
            D.33125 = *D.33124;
            index = (guint32) D.33125;
            unwind_info = mono_get_cached_unwind_info (index, &unwind_info_len);
            p = &buf;
            p.820 = p;
            unwind_info_len.821 = unwind_info_len;
            unwind_info_len.822 = (int) unwind_info_len.821;
            encode_value (unwind_info_len.822, p.820, &p);
            p.820 = p;
            p.823 = (int) p.820;
            buf.824 = (int) &buf;
            D.33131 = p.823 - buf.824;
            emit_bytes (acfg, &buf, D.33131);
            unwind_info_len.821 = unwind_info_len;
            unwind_info_len.825 = (int) unwind_info_len.821;
            emit_bytes (acfg, unwind_info, unwind_info_len.825);
            D.33133 = acfg->stats.unwind_info_size;
            D.33134 = (unsigned int) D.33133;
            p.820 = p;
            p.823 = (int) p.820;
            buf.824 = (int) &buf;
            D.33131 = p.823 - buf.824;
            D.33135 = (unsigned int) D.33131;
            unwind_info_len.821 = unwind_info_len;
            D.33136 = D.33135 + unwind_info_len.821;
            D.33137 = D.33134 + D.33136;
            D.33138 = (int) D.33137;
            acfg->stats.unwind_info_size = D.33138;
          }
        finally
          {
            unwind_info_len = {CLOBBER};
            buf = {CLOBBER};
            p = {CLOBBER};
          }
      }
      i = i + 1;
      <D.25842>:
      i.826 = (unsigned int) i;
      D.33120 = acfg->unwind_ops;
      D.33140 = D.33120->len;
      if (i.826 < D.33140) goto <D.25841>; else goto <D.25843>;
      <D.25843>:
    }
  finally
    {
      symbol = {CLOBBER};
    }
}


emit_class_info (struct MonoAotCompile * acfg)
{
  struct MonoImage * D.33141;
  <unnamed-unsigned:24> D.33142;
  unsigned int D.33143;
  unsigned int D.33144;
  unsigned int i.827;
  unsigned int D.33146;
  gint32 * D.33147;
  int D.33148;
  int D.33149;
  unsigned int D.33150;
  unsigned int D.33151;
  int D.33152;
  int D.33153;
  unsigned int D.33154;
  int D.33155;
  unsigned int D.33156;
  unsigned int D.33157;
  int D.33158;
  int i;
  char symbol[256];
  gint32 * offsets;

  try
    {
      D.33141 = acfg->image;
      D.33142 = D.33141->tables[2].rows;
      D.33143 = (unsigned int) D.33142;
      D.33144 = D.33143 * 4;
      offsets = monoeg_malloc0 (D.33144);
      i = 0;
      goto <D.25851>;
      <D.25850>:
      i.827 = (unsigned int) i;
      D.33146 = i.827 * 4;
      D.33147 = offsets + D.33146;
      D.33148 = i + 1;
      D.33149 = D.33148 | 33554432;
      D.33150 = (unsigned int) D.33149;
      D.33151 = emit_klass_info (acfg, D.33150);
      D.33152 = (int) D.33151;
      *D.33147 = D.33152;
      i = i + 1;
      <D.25851>:
      D.33141 = acfg->image;
      D.33142 = D.33141->tables[2].rows;
      D.33153 = (int) D.33142;
      if (D.33153 > i) goto <D.25850>; else goto <D.25852>;
      <D.25852>:
      sprintf (&symbol, "class_info_offsets");
      emit_section_change (acfg, ".rodata", 1);
      emit_alignment (acfg, 8);
      emit_label (acfg, &symbol);
      D.33141 = acfg->image;
      D.33142 = D.33141->tables[2].rows;
      D.33153 = (int) D.33142;
      D.33154 = emit_offset_table (acfg, D.33153, 10, offsets);
      D.33155 = acfg->stats.offsets_size;
      D.33156 = (unsigned int) D.33155;
      D.33157 = D.33156 + D.33154;
      D.33158 = (int) D.33157;
      acfg->stats.offsets_size = D.33158;
      monoeg_g_free (offsets);
    }
  finally
    {
      symbol = {CLOBBER};
    }
}


emit_klass_info (struct MonoAotCompile * acfg, guint32 token)
{
  struct MonoImage * D.33159;
  unsigned int buf_size.828;
  guint8 * p.829;
  int p.830;
  int buf.831;
  int D.33166;
  unsigned int D.33167;
  unsigned int D.33168;
  guint32 D.33169;
  int D.33170;
  int D.33171;
  _Bool D.33172;
  long int D.33173;
  long int D.33174;
  unsigned char D.33177;
  signed char D.33178;
  _Bool D.33179;
  long int D.33180;
  long int D.33181;
  int D.33184;
  _Bool D.33185;
  struct MonoMethod * * D.33186;
  unsigned int i.832;
  unsigned int D.33188;
  struct MonoMethod * * D.33189;
  struct MonoMethodSignature * D.33192;
  unsigned char D.33193;
  unsigned char D.33194;
  struct GHashTable * D.33197;
  void * D.33198;
  struct MonoGenericContainer * D.33203;
  gboolean iftmp.833;
  int D.33209;
  int D.33210;
  <unnamed-unsigned:1> D.33211;
  int D.33212;
  int D.33213;
  int D.33214;
  <unnamed-unsigned:1> D.33215;
  int D.33216;
  int D.33217;
  int D.33218;
  <unnamed-unsigned:1> D.33219;
  int D.33220;
  int D.33221;
  int iftmp.834;
  struct MonoClassExt * D.33225;
  struct GList * D.33227;
  int D.33229;
  int D.33230;
  int D.33231;
  <unnamed-unsigned:1> D.33232;
  int D.33233;
  int D.33234;
  int D.33235;
  <unnamed-unsigned:1> D.33236;
  int D.33237;
  int D.33238;
  int D.33239;
  <unnamed-unsigned:1> D.33240;
  int D.33241;
  int D.33242;
  unsigned char D.33243;
  struct MonoMethod * D.33246;
  unsigned char D.33247;
  unsigned char D.33248;
  struct MonoMethod * D.33251;
  int D.33252;
  int D.33253;
  <unnamed-unsigned:4> D.33254;
  int D.33255;
  unsigned char D.33256;
  int D.33257;
  int D.33261;
  int D.33262;
  _Bool D.33263;
  long int D.33264;
  long int D.33265;
  unsigned int D.33268;
  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.33159 = acfg->image;
      klass = mono_class_get (D.33159, token);
      iter = 0B;
      if (klass == 0B) goto <D.33160>; else goto <D.33161>;
      <D.33160>:
      mono_loader_clear_error ();
      buf_size = 16;
      buf_size.828 = (unsigned int) buf_size;
      buf = monoeg_malloc (buf_size.828);
      p = buf;
      p.829 = p;
      encode_value (-1, p.829, &p);
      p.829 = p;
      p.830 = (int) p.829;
      buf.831 = (int) buf;
      D.33166 = p.830 - buf.831;
      D.33167 = (unsigned int) D.33166;
      D.33168 = add_to_blob (acfg, buf, D.33167);
      res = (int) D.33168;
      monoeg_g_free (buf);
      D.33169 = (guint32) res;
      return D.33169;
      <D.33161>:
      D.33170 = klass->vtable_size;
      D.33171 = D.33170 + 640;
      buf_size = D.33171 * 16;
      buf_size.828 = (unsigned int) buf_size;
      buf = monoeg_malloc (buf_size.828);
      p = buf;
      D.33172 = klass == 0B;
      D.33173 = (long int) D.33172;
      D.33174 = __builtin_expect (D.33173, 0);
      if (D.33174 != 0) goto <D.33175>; else goto <D.33176>;
      <D.33175>:
      monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "aot-compiler.c", 5514, "klass");
      <D.33176>:
      mono_class_init (klass);
      mono_class_get_nested_types (klass, &iter);
      D.33177 = BIT_FIELD_REF <*klass, 8, 184>;
      D.33178 = (signed char) D.33177;
      D.33179 = D.33178 >= 0;
      D.33180 = (long int) D.33179;
      D.33181 = __builtin_expect (D.33180, 0);
      if (D.33181 != 0) goto <D.33182>; else goto <D.33183>;
      <D.33182>:
      monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "aot-compiler.c", 5519, "klass->nested_classes_inited");
      <D.33183>:
      mono_class_setup_vtable (klass);
      D.33184 = mono_class_has_special_static_fields (klass);
      D.33185 = D.33184 == 0;
      no_special_static = (gboolean) D.33185;
      cant_encode = 0;
      i = 0;
      goto <D.25218>;
      <D.25217>:
      {
        struct MonoMethod * cm;

        D.33186 = klass->vtable;
        i.832 = (unsigned int) i;
        D.33188 = i.832 * 4;
        D.33189 = D.33186 + D.33188;
        cm = *D.33189;
        if (cm != 0B) goto <D.33190>; else goto <D.33191>;
        <D.33190>:
        D.33192 = mono_method_signature (cm);
        D.33193 = BIT_FIELD_REF <*D.33192, 8, 88>;
        D.33194 = D.33193 & 2;
        if (D.33194 != 0) goto <D.33195>; else goto <D.33196>;
        <D.33195>:
        D.33197 = acfg->token_info_hash;
        D.33198 = monoeg_g_hash_table_lookup (D.33197, cm);
        if (D.33198 == 0B) goto <D.33199>; else goto <D.33200>;
        <D.33199>:
        cant_encode = 1;
        <D.33200>:
        <D.33196>:
        <D.33191>:
      }
      i = i + 1;
      <D.25218>:
      D.33170 = klass->vtable_size;
      if (D.33170 > i) goto <D.25217>; else goto <D.25219>;
      <D.25219>:
      mono_class_has_finalizer (klass);
      D.33203 = klass->generic_container;
      if (D.33203 != 0B) goto <D.33201>; else goto <D.33204>;
      <D.33204>:
      if (cant_encode != 0) goto <D.33201>; else goto <D.33202>;
      <D.33201>:
      p.829 = p;
      encode_value (-1, p.829, &p);
      goto <D.25223>;
      <D.33202>:
      p.829 = p;
      D.33170 = klass->vtable_size;
      encode_value (D.33170, p.829, &p);
      p.829 = p;
      D.33203 = klass->generic_container;
      if (D.33203 != 0B) goto <D.33206>; else goto <D.33207>;
      <D.33206>:
      iftmp.833 = 256;
      goto <D.33208>;
      <D.33207>:
      iftmp.833 = 0;
      <D.33208>:
      D.33209 = no_special_static << 7;
      D.33210 = iftmp.833 | D.33209;
      D.33211 = klass->has_static_refs;
      D.33212 = (int) D.33211;
      D.33213 = D.33212 << 6;
      D.33214 = D.33210 | D.33213;
      D.33215 = klass->has_references;
      D.33216 = (int) D.33215;
      D.33217 = D.33216 << 5;
      D.33218 = D.33214 | D.33217;
      D.33219 = klass->blittable;
      D.33220 = (int) D.33219;
      D.33221 = D.33220 << 4;
      D.33225 = klass->ext;
      if (D.33225 != 0B) goto <D.33226>; else goto <D.33223>;
      <D.33226>:
      D.33225 = klass->ext;
      D.33227 = D.33225->nested_classes;
      if (D.33227 != 0B) goto <D.33228>; else goto <D.33223>;
      <D.33228>:
      iftmp.834 = 1;
      goto <D.33224>;
      <D.33223>:
      iftmp.834 = 0;
      <D.33224>:
      D.33229 = iftmp.834 << 3;
      D.33230 = D.33221 | D.33229;
      D.33231 = D.33218 | D.33230;
      D.33232 = klass->has_cctor;
      D.33233 = (int) D.33232;
      D.33234 = D.33233 << 2;
      D.33235 = D.33231 | D.33234;
      D.33236 = klass->has_finalize;
      D.33237 = (int) D.33236;
      D.33238 = D.33237 << 1;
      D.33239 = D.33235 | D.33238;
      D.33240 = klass->ghcimpl;
      D.33241 = (int) D.33240;
      D.33242 = D.33239 | D.33241;
      encode_value (D.33242, p.829, &p);
      D.33177 = BIT_FIELD_REF <*klass, 8, 184>;
      D.33243 = D.33177 & 4;
      if (D.33243 != 0) goto <D.33244>; else goto <D.33245>;
      <D.33244>:
      p.829 = p;
      D.33246 = mono_class_get_cctor (klass);
      encode_method_ref (acfg, D.33246, p.829, &p);
      <D.33245>:
      D.33247 = BIT_FIELD_REF <*klass, 8, 176>;
      D.33248 = D.33247 & 32;
      if (D.33248 != 0) goto <D.33249>; else goto <D.33250>;
      <D.33249>:
      p.829 = p;
      D.33251 = mono_class_get_finalizer (klass);
      encode_method_ref (acfg, D.33251, p.829, &p);
      <D.33250>:
      p.829 = p;
      D.33252 = klass->instance_size;
      encode_value (D.33252, p.829, &p);
      p.829 = p;
      D.33253 = mono_class_data_size (klass);
      encode_value (D.33253, p.829, &p);
      p.829 = p;
      D.33254 = klass->packing_size;
      D.33255 = (int) D.33254;
      encode_value (D.33255, p.829, &p);
      p.829 = p;
      D.33256 = klass->min_align;
      D.33257 = (int) D.33256;
      encode_value (D.33257, p.829, &p);
      i = 0;
      goto <D.25222>;
      <D.25221>:
      {
        struct MonoMethod * cm;

        D.33186 = klass->vtable;
        i.832 = (unsigned int) i;
        D.33188 = i.832 * 4;
        D.33189 = D.33186 + D.33188;
        cm = *D.33189;
        if (cm != 0B) goto <D.33258>; else goto <D.33259>;
        <D.33258>:
        p.829 = p;
        encode_method_ref (acfg, cm, p.829, &p);
        goto <D.33260>;
        <D.33259>:
        p.829 = p;
        encode_value (0, p.829, &p);
        <D.33260>:
      }
      i = i + 1;
      <D.25222>:
      D.33170 = klass->vtable_size;
      if (D.33170 > i) goto <D.25221>; else goto <D.25223>;
      <D.25223>:
      D.33261 = acfg->stats.class_info_size;
      p.829 = p;
      p.830 = (int) p.829;
      buf.831 = (int) buf;
      D.33166 = p.830 - buf.831;
      D.33262 = D.33261 + D.33166;
      acfg->stats.class_info_size = D.33262;
      p.829 = p;
      p.830 = (int) p.829;
      buf.831 = (int) buf;
      D.33166 = p.830 - buf.831;
      D.33263 = D.33166 >= buf_size;
      D.33264 = (long int) D.33263;
      D.33265 = __builtin_expect (D.33264, 0);
      if (D.33265 != 0) goto <D.33266>; else goto <D.33267>;
      <D.33266>:
      monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "aot-compiler.c", 5569, "p - buf < buf_size");
      <D.33267>:
      p.829 = p;
      p.830 = (int) p.829;
      buf.831 = (int) buf;
      D.33166 = p.830 - buf.831;
      D.33167 = (unsigned int) D.33166;
      D.33268 = add_to_blob (acfg, buf, D.33167);
      res = (int) D.33268;
      monoeg_g_free (buf);
      D.33169 = (guint32) res;
      return D.33169;
    }
  finally
    {
      p = {CLOBBER};
      iter = {CLOBBER};
    }
}


emit_plt (struct MonoAotCompile * acfg)
{
  char * D.33271;
  const void * i.835;
  struct GHashTable * D.33275;
  int D.33276;
  int D.33281;
  int D.33284;
  struct MonoMethod * D.33287;
  struct GHashTable * D.33288;
  int D.33293;
  unsigned char D.33295;
  unsigned char D.33296;
  struct FILE * D.33298;
  char * D.33299;
  char * D.33300;
  int D.33303;
  int D.33312;
  char * D.33315;
  unsigned int i.836;
  unsigned int D.33319;
  int D.33326;
  int D.33331;
  int D.33334;
  char * D.33337;
  char * D.33342;
  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.33271 = acfg->plt_symbol;
      emit_label (acfg, D.33271);
      i = 0;
      goto <D.25252>;
      <D.25251>:
      {
        char * debug_sym;
        struct MonoPltEntry * plt_entry;
        struct MonoJumpInfo * ji;

        debug_sym = 0B;
        plt_entry = 0B;
        if (i == 0) goto <D.33272>; else goto <D.33273>;
        <D.33272>:
        // predicted unlikely by continue predictor.
        goto <D.25249>;
        <D.33273>:
        i.835 = (const void *) i;
        D.33275 = acfg->plt_offset_to_entry;
        plt_entry = monoeg_g_hash_table_lookup (D.33275, i.835);
        ji = plt_entry->ji;
        D.33276 = acfg->llvm;
        if (D.33276 != 0) goto <D.33277>; else goto <D.33278>;
        <D.33277>:
        if (ji != 0B) goto <D.33279>; else goto <D.33280>;
        <D.33279>:
        D.33281 = is_direct_callable (acfg, 0B, ji);
        if (D.33281 != 0) goto <D.33282>; else goto <D.33283>;
        <D.33282>:
        D.33284 = acfg->use_bin_writer;
        if (D.33284 == 0) goto <D.33285>; else goto <D.33286>;
        <D.33285>:
        {
          struct MonoCompile * callee_cfg;

          D.33287 = ji->data.method;
          D.33288 = acfg->method_to_cfg;
          callee_cfg = monoeg_g_hash_table_lookup (D.33288, D.33287);
          if (callee_cfg != 0B) goto <D.33289>; else goto <D.33290>;
          <D.33289>:
          D.33293 = acfg->thumb_mixed;
          if (D.33293 != 0) goto <D.33294>; else goto <D.33291>;
          <D.33294>:
          D.33295 = BIT_FIELD_REF <*callee_cfg, 8, 3400>;
          D.33296 = D.33295 & 1;
          if (D.33296 == 0) goto <D.33297>; else goto <D.33291>;
          <D.33297>:
          emit_set_thumb_mode (acfg);
          D.33298 = acfg->fp;
          fprintf (D.33298, "\n.thumb_func\n");
          D.33299 = plt_entry->llvm_symbol;
          emit_label (acfg, D.33299);
          D.33298 = acfg->fp;
          fprintf (D.33298, "bx pc\n");
          D.33298 = acfg->fp;
          fprintf (D.33298, "nop\n");
          emit_set_arm_mode (acfg);
          D.33300 = callee_cfg->asm_symbol;
          D.33298 = acfg->fp;
          fprintf (D.33298, "b %s\n", D.33300);
          goto <D.33292>;
          <D.33291>:
          D.33300 = callee_cfg->asm_symbol;
          D.33299 = plt_entry->llvm_symbol;
          D.33298 = acfg->fp;
          fprintf (D.33298, "\n.set %s, %s\n", D.33299, D.33300);
          <D.33292>:
          // predicted unlikely by continue predictor.
          goto <D.25249>;
          <D.33290>:
        }
        <D.33286>:
        <D.33283>:
        <D.33280>:
        <D.33278>:
        debug_sym = plt_entry->debug_sym;
        D.33293 = acfg->thumb_mixed;
        if (D.33293 != 0) goto <D.33301>; else goto <D.33302>;
        <D.33301>:
        D.33303 = plt_entry->jit_used;
        if (D.33303 == 0) goto <D.33304>; else goto <D.33305>;
        <D.33304>:
        // predicted unlikely by continue predictor.
        goto <D.25249>;
        <D.33305>:
        <D.33302>:
        D.33276 = acfg->llvm;
        if (D.33276 != 0) goto <D.33306>; else goto <D.33307>;
        <D.33306>:
        D.33293 = acfg->thumb_mixed;
        if (D.33293 == 0) goto <D.33308>; else goto <D.33309>;
        <D.33308>:
        D.33299 = plt_entry->llvm_symbol;
        emit_label (acfg, D.33299);
        <D.33309>:
        <D.33307>:
        if (debug_sym != 0B) goto <D.33310>; else goto <D.33311>;
        <D.33310>:
        D.33312 = acfg->need_no_dead_strip;
        if (D.33312 != 0) goto <D.33313>; else goto <D.33314>;
        <D.33313>:
        emit_unset_mode (acfg);
        D.33298 = acfg->fp;
        fprintf (D.33298, "\t.no_dead_strip %s\n", debug_sym);
        <D.33314>:
        emit_local_symbol (acfg, debug_sym, 0B, 1);
        emit_label (acfg, debug_sym);
        <D.33311>:
        D.33315 = plt_entry->symbol;
        emit_label (acfg, D.33315);
        arch_emit_plt_entry (acfg, i);
        if (debug_sym != 0B) goto <D.33316>; else goto <D.33317>;
        <D.33316>:
        emit_symbol_size (acfg, debug_sym, ".");
        <D.33317>:
      }
      <D.25249>:
      i = i + 1;
      <D.25252>:
      i.836 = (unsigned int) i;
      D.33319 = acfg->plt_offset;
      if (i.836 < D.33319) goto <D.25251>; else goto <D.25253>;
      <D.25253>:
      D.33293 = acfg->thumb_mixed;
      if (D.33293 != 0) goto <D.33320>; else goto <D.33321>;
      <D.33320>:
      emit_zero_bytes (acfg, 16);
      i = 0;
      goto <D.25259>;
      <D.25258>:
      {
        char * debug_sym;
        struct MonoPltEntry * plt_entry;
        struct MonoJumpInfo * ji;

        debug_sym = 0B;
        plt_entry = 0B;
        if (i == 0) goto <D.33322>; else goto <D.33323>;
        <D.33322>:
        // predicted unlikely by continue predictor.
        goto <D.25257>;
        <D.33323>:
        i.835 = (const void *) i;
        D.33275 = acfg->plt_offset_to_entry;
        plt_entry = monoeg_g_hash_table_lookup (D.33275, i.835);
        ji = plt_entry->ji;
        if (ji != 0B) goto <D.33324>; else goto <D.33325>;
        <D.33324>:
        D.33326 = is_direct_callable (acfg, 0B, ji);
        if (D.33326 != 0) goto <D.33327>; else goto <D.33328>;
        <D.33327>:
        D.33284 = acfg->use_bin_writer;
        if (D.33284 == 0) goto <D.33329>; else goto <D.33330>;
        <D.33329>:
        // predicted unlikely by continue predictor.
        goto <D.25257>;
        <D.33330>:
        <D.33328>:
        <D.33325>:
        D.33331 = plt_entry->llvm_used;
        if (D.33331 == 0) goto <D.33332>; else goto <D.33333>;
        <D.33332>:
        // predicted unlikely by continue predictor.
        goto <D.25257>;
        <D.33333>:
        D.33334 = acfg->aot_opts.write_symbols;
        if (D.33334 != 0) goto <D.33335>; else goto <D.33336>;
        <D.33335>:
        D.33337 = plt_entry->debug_sym;
        if (D.33337 != 0B) goto <D.33338>; else goto <D.33339>;
        <D.33338>:
        D.33337 = plt_entry->debug_sym;
        debug_sym = monoeg_g_strdup_printf ("%s_thumb", D.33337);
        <D.33339>:
        <D.33336>:
        if (debug_sym != 0B) goto <D.33340>; else goto <D.33341>;
        <D.33340>:
        emit_local_symbol (acfg, debug_sym, 0B, 1);
        emit_label (acfg, debug_sym);
        <D.33341>:
        D.33298 = acfg->fp;
        fprintf (D.33298, "\n.thumb_func\n");
        D.33342 = plt_entry->llvm_symbol;
        emit_label (acfg, D.33342);
        arch_emit_llvm_plt_entry (acfg, i);
        if (debug_sym != 0B) goto <D.33343>; else goto <D.33344>;
        <D.33343>:
        emit_symbol_size (acfg, debug_sym, ".");
        monoeg_g_free (debug_sym);
        <D.33344>:
      }
      <D.25257>:
      i = i + 1;
      <D.25259>:
      i.836 = (unsigned int) i;
      D.33319 = acfg->plt_offset;
      if (i.836 < D.33319) goto <D.25258>; else goto <D.25260>;
      <D.25260>:
      <D.33321>:
      D.33271 = acfg->plt_symbol;
      emit_symbol_size (acfg, D.33271, ".");
      sprintf (&symbol, "plt_end");
      emit_label (acfg, &symbol);
    }
  finally
    {
      symbol = {CLOBBER};
    }
}


arch_emit_plt_entry (struct MonoAotCompile * acfg, int index)
{
  unsigned int D.33345;
  unsigned int index.837;
  unsigned int D.33347;
  int offset.838;
  guint32 * D.33349;
  unsigned int index.839;
  unsigned int D.33351;
  guint32 * D.33352;
  unsigned int D.33353;
  int D.33354;
  guint32 offset;

  D.33345 = acfg->plt_got_offset_base;
  index.837 = (unsigned int) index;
  D.33347 = D.33345 + index.837;
  offset = D.33347 * 4;
  emit_byte (acfg, 255);
  emit_byte (acfg, 163);
  offset.838 = (int) offset;
  emit_int32 (acfg, offset.838);
  D.33349 = acfg->plt_got_info_offsets;
  index.839 = (unsigned int) index;
  D.33351 = index.839 * 4;
  D.33352 = D.33349 + D.33351;
  D.33353 = *D.33352;
  D.33354 = (int) D.33353;
  emit_int32 (acfg, D.33354);
}


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.33355;
  unsigned int D.33356;
  int D.33357;
  void * * D.33358;
  unsigned int i.840;
  unsigned int D.33360;
  void * * D.33361;
  struct MonoAssembly * D.33362;
  struct MonoImage * D.33363;
  _Bool D.33364;
  long int D.33365;
  long int D.33366;
  const char * D.33369;
  char * D.33370;
  const char * iftmp.841;
  const char * D.33372;
  mono_byte[17] * D.33376;
  unsigned int D.33377;
  int D.33378;
  short unsigned int D.33379;
  int D.33380;
  short unsigned int D.33381;
  int D.33382;
  short unsigned int D.33383;
  int D.33384;
  short unsigned int D.33385;
  int D.33386;
  unsigned int i.842;
  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.33355 = acfg->image_table;
      D.33356 = D.33355->len;
      D.33357 = (int) D.33356;
      emit_int32 (acfg, D.33357);
      i = 0;
      goto <D.25893>;
      <D.25892>:
      {
        struct MonoImage * image;
        struct MonoAssemblyName * aname;

        D.33355 = acfg->image_table;
        D.33358 = D.33355->pdata;
        i.840 = (unsigned int) i;
        D.33360 = i.840 * 4;
        D.33361 = D.33358 + D.33360;
        image = *D.33361;
        D.33362 = image->assembly;
        aname = &D.33362->aname;
        D.33362 = image->assembly;
        D.33363 = D.33362->image;
        D.33364 = D.33363 != image;
        D.33365 = (long int) D.33364;
        D.33366 = __builtin_expect (D.33365, 0);
        if (D.33366 != 0) goto <D.33367>; else goto <D.33368>;
        <D.33367>:
        monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "aot-compiler.c", 7785, "image->assembly->image == image");
        <D.33368>:
        D.33369 = image->assembly_name;
        emit_string (acfg, D.33369);
        D.33370 = image->guid;
        emit_string (acfg, D.33370);
        D.33372 = aname->culture;
        if (D.33372 != 0B) goto <D.33373>; else goto <D.33374>;
        <D.33373>:
        iftmp.841 = aname->culture;
        goto <D.33375>;
        <D.33374>:
        iftmp.841 = "";
        <D.33375>:
        emit_string (acfg, iftmp.841);
        D.33376 = &aname->public_key_token;
        emit_string (acfg, D.33376);
        emit_alignment (acfg, 8);
        D.33377 = aname->flags;
        D.33378 = (int) D.33377;
        emit_int32 (acfg, D.33378);
        D.33379 = aname->major;
        D.33380 = (int) D.33379;
        emit_int32 (acfg, D.33380);
        D.33381 = aname->minor;
        D.33382 = (int) D.33381;
        emit_int32 (acfg, D.33382);
        D.33383 = aname->build;
        D.33384 = (int) D.33383;
        emit_int32 (acfg, D.33384);
        D.33385 = aname->revision;
        D.33386 = (int) D.33385;
        emit_int32 (acfg, D.33386);
      }
      i = i + 1;
      <D.25893>:
      i.842 = (unsigned int) i;
      D.33355 = acfg->image_table;
      D.33356 = D.33355->len;
      if (i.842 < D.33356) goto <D.25892>; else goto <D.25894>;
      <D.25894>:
    }
  finally
    {
      symbol = {CLOBBER};
    }
}


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

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


emit_got (struct MonoAotCompile * acfg)
{
  int D.33389;
  char * D.33392;
  unsigned int D.33393;
  unsigned int D.33396;
  int D.33397;
  char symbol[256];

  try
    {
      D.33389 = acfg->llvm;
      if (D.33389 == 0) goto <D.33390>; else goto <D.33391>;
      <D.33390>:
      D.33392 = acfg->got_symbol;
      sprintf (&symbol, "%s", D.33392);
      emit_section_change (acfg, ".bss", 0);
      emit_alignment (acfg, 8);
      emit_local_symbol (acfg, &symbol, "got_end", 0);
      emit_label (acfg, &symbol);
      D.33393 = acfg->got_offset;
      if (D.33393 != 0) goto <D.33394>; else goto <D.33395>;
      <D.33394>:
      D.33393 = acfg->got_offset;
      D.33396 = D.33393 * 4;
      D.33397 = (int) D.33396;
      emit_zero_bytes (acfg, D.33397);
      <D.33395>:
      sprintf (&symbol, "got_end");
      emit_label (acfg, &symbol);
      <D.33391>:
    }
  finally
    {
      symbol = {CLOBBER};
    }
}


emit_file_info (struct MonoAotCompile * acfg)
{
  struct MonoImage * D.33398;
  char * D.33399;
  int D.33400;
  struct MonoAssembly * D.33404;
  const char * D.33405;
  unsigned int D.33406;
  unsigned int D.33407;
  unsigned int D.33408;
  const char * D.33409;
  int D.33410;
  char * D.33413;
  char * D.33414;
  int D.33415;
  int D.33419;
  unsigned int D.33423;
  int D.33427;
  unsigned int D.33434;
  int D.33435;
  unsigned int D.33436;
  unsigned int D.33437;
  int D.33438;
  unsigned int D.33439;
  int D.33440;
  unsigned int D.33441;
  int D.33442;
  <unnamed type> D.33443;
  int D.33444;
  unsigned int D.33445;
  int D.33446;
  unsigned int D.33447;
  int D.33448;
  unsigned int D.33449;
  int D.33450;
  unsigned int D.33451;
  int D.33452;
  unsigned int D.33453;
  int D.33454;
  int D.33455;
  unsigned int D.33456;
  int D.33457;
  unsigned int D.33458;
  int D.33459;
  const short unsigned int * * D.33462;
  const short unsigned int * D.33463;
  char D.33464;
  unsigned int D.33465;
  unsigned int D.33466;
  const short unsigned int * D.33467;
  short unsigned int D.33468;
  int D.33469;
  int D.33470;
  gchar * D.33475;
  char symbol[256];
  int i;
  int gc_name_offset;
  const char * gc_name;
  char * build_info;

  try
    {
      D.33398 = acfg->image;
      D.33399 = D.33398->guid;
      emit_string_symbol (acfg, "assembly_guid", D.33399);
      D.33400 = acfg->aot_opts.bind_to_runtime_version;
      if (D.33400 != 0) goto <D.33401>; else goto <D.33402>;
      <D.33401>:
      build_info = mono_get_runtime_build_info ();
      emit_string_symbol (acfg, "runtime_version", build_info);
      monoeg_g_free (build_info);
      goto <D.33403>;
      <D.33402>:
      emit_string_symbol (acfg, "runtime_version", "");
      <D.33403>:
      D.33398 = acfg->image;
      D.33404 = D.33398->assembly;
      D.33405 = D.33404->aname.name;
      emit_string_symbol (acfg, "assembly_name", D.33405);
      gc_name = mono_gc_get_gc_name ();
      D.33406 = strlen (gc_name);
      D.33407 = D.33406 + 1;
      D.33408 = add_to_blob (acfg, gc_name, D.33407);
      gc_name_offset = (int) D.33408;
      D.33409 = acfg->user_symbol_prefix;
      sprintf (&symbol, "%smono_aot_file_info", D.33409);
      emit_section_change (acfg, ".data", 0);
      emit_alignment (acfg, 8);
      emit_label (acfg, &symbol);
      D.33410 = acfg->aot_opts.static_link;
      if (D.33410 == 0) goto <D.33411>; else goto <D.33412>;
      <D.33411>:
      emit_global (acfg, &symbol, 0);
      <D.33412>:
      emit_int32 (acfg, 97);
      emit_int32 (acfg, 0);
      D.33413 = acfg->got_symbol;
      emit_pointer (acfg, D.33413);
      D.33414 = acfg->methods_symbol;
      emit_pointer (acfg, D.33414);
      D.33415 = acfg->llvm;
      if (D.33415 != 0) goto <D.33416>; else goto <D.33417>;
      <D.33416>:
      emit_pointer (acfg, "mono_eh_frame");
      goto <D.33418>;
      <D.33417>:
      emit_pointer (acfg, 0B);
      <D.33418>:
      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.33419 = acfg->direct_method_addresses;
      if (D.33419 != 0) goto <D.33420>; else goto <D.33421>;
      <D.33420>:
      emit_pointer (acfg, "method_addresses");
      goto <D.33422>;
      <D.33421>:
      emit_pointer (acfg, 0B);
      <D.33422>:
      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.33423 = acfg->num_trampoline_got_entries;
      if (D.33423 != 0) goto <D.33424>; else goto <D.33425>;
      <D.33424>:
      emit_pointer (acfg, "specific_trampolines");
      emit_pointer (acfg, "static_rgctx_trampolines");
      emit_pointer (acfg, "imt_thunks");
      emit_pointer (acfg, "gsharedvt_arg_trampolines");
      goto <D.33426>;
      <D.33425>:
      emit_pointer (acfg, 0B);
      emit_pointer (acfg, 0B);
      emit_pointer (acfg, 0B);
      emit_pointer (acfg, 0B);
      <D.33426>:
      D.33427 = acfg->thumb_mixed;
      if (D.33427 != 0) goto <D.33428>; else goto <D.33429>;
      <D.33428>:
      emit_pointer (acfg, "thumb_end");
      goto <D.33430>;
      <D.33429>:
      emit_pointer (acfg, 0B);
      <D.33430>:
      D.33410 = acfg->aot_opts.static_link;
      if (D.33410 != 0) goto <D.33431>; else goto <D.33432>;
      <D.33431>:
      emit_pointer (acfg, "globals");
      goto <D.33433>;
      <D.33432>:
      emit_pointer (acfg, 0B);
      <D.33433>:
      emit_pointer (acfg, "assembly_name");
      emit_pointer (acfg, "unbox_trampolines");
      emit_pointer (acfg, "unbox_trampolines_end");
      D.33434 = acfg->plt_got_offset_base;
      D.33435 = (int) D.33434;
      emit_int32 (acfg, D.33435);
      D.33436 = acfg->got_offset;
      D.33437 = D.33436 * 4;
      D.33438 = (int) D.33437;
      emit_int32 (acfg, D.33438);
      D.33439 = acfg->plt_offset;
      D.33440 = (int) D.33439;
      emit_int32 (acfg, D.33440);
      D.33441 = acfg->nmethods;
      D.33442 = (int) D.33441;
      emit_int32 (acfg, D.33442);
      D.33443 = acfg->flags;
      D.33444 = (int) D.33443;
      emit_int32 (acfg, D.33444);
      D.33445 = acfg->opts;
      D.33446 = (int) D.33445;
      emit_int32 (acfg, D.33446);
      D.33447 = acfg->simd_opts;
      D.33448 = (int) D.33447;
      emit_int32 (acfg, D.33448);
      emit_int32 (acfg, gc_name_offset);
      i = 0;
      goto <D.25972>;
      <D.25971>:
      D.33449 = acfg->num_trampolines[i];
      D.33450 = (int) D.33449;
      emit_int32 (acfg, D.33450);
      i = i + 1;
      <D.25972>:
      if (i <= 3) goto <D.25971>; else goto <D.25973>;
      <D.25973>:
      i = 0;
      goto <D.25975>;
      <D.25974>:
      D.33451 = acfg->trampoline_got_offset_base[i];
      D.33452 = (int) D.33451;
      emit_int32 (acfg, D.33452);
      i = i + 1;
      <D.25975>:
      if (i <= 3) goto <D.25974>; else goto <D.25976>;
      <D.25976>:
      i = 0;
      goto <D.25978>;
      <D.25977>:
      D.33453 = acfg->trampoline_size[i];
      D.33454 = (int) D.33453;
      emit_int32 (acfg, D.33454);
      i = i + 1;
      <D.25978>:
      if (i <= 3) goto <D.25977>; else goto <D.25979>;
      <D.25979>:
      D.33455 = acfg->aot_opts.nrgctx_fetch_trampolines;
      emit_int32 (acfg, D.33455);
      emit_int32 (acfg, 8);
      emit_int32 (acfg, 8);
      emit_int32 (acfg, 14);
      D.33456 = acfg->tramp_page_size;
      D.33457 = (int) D.33456;
      emit_int32 (acfg, D.33457);
      i = 0;
      goto <D.25981>;
      <D.25980>:
      D.33458 = acfg->tramp_page_code_offsets[i];
      D.33459 = (int) D.33458;
      emit_int32 (acfg, D.33459);
      i = i + 1;
      <D.25981>:
      if (i <= 3) goto <D.25980>; else goto <D.25982>;
      <D.25982>:
      D.33410 = acfg->aot_opts.static_link;
      if (D.33410 != 0) goto <D.33460>; else goto <D.33461>;
      <D.33460>:
      {
        char * p;

        D.33398 = acfg->image;
        D.33404 = D.33398->assembly;
        D.33405 = D.33404->aname.name;
        D.33409 = acfg->user_symbol_prefix;
        sprintf (&symbol, "%smono_aot_module_%s_info", D.33409, D.33405);
        p = &symbol;
        p = &symbol;
        goto <D.25985>;
        <D.25984>:
        D.33462 = __ctype_b_loc ();
        D.33463 = *D.33462;
        D.33464 = *p;
        D.33465 = (unsigned int) D.33464;
        D.33466 = D.33465 * 2;
        D.33467 = D.33463 + D.33466;
        D.33468 = *D.33467;
        D.33469 = (int) D.33468;
        D.33470 = D.33469 & 8;
        if (D.33470 == 0) goto <D.33471>; else goto <D.33472>;
        <D.33471>:
        D.33464 = *p;
        if (D.33464 != 95) goto <D.33473>; else goto <D.33474>;
        <D.33473>:
        *p = 95;
        <D.33474>:
        <D.33472>:
        p = p + 1;
        <D.25985>:
        D.33464 = *p;
        if (D.33464 != 0) goto <D.25984>; else goto <D.25986>;
        <D.25986>:
        D.33475 = monoeg_strdup (&symbol);
        acfg->static_linking_symbol = D.33475;
        emit_global_inner (acfg, &symbol, 0);
        emit_alignment (acfg, 4);
        emit_label (acfg, &symbol);
        D.33409 = acfg->user_symbol_prefix;
        emit_pointer_2 (acfg, D.33409, "mono_aot_file_info");
      }
      <D.33461>:
    }
  finally
    {
      symbol = {CLOBBER};
    }
}


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

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


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

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


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

  D.33478 = *prefix;
  if (D.33478 != 0) goto <D.33479>; else goto <D.33480>;
  <D.33479>:
  {
    char * s;

    s = monoeg_g_strdup_printf ("%s%s", prefix, target);
    D.33481 = acfg->w;
    img_writer_emit_pointer (D.33481, s);
    monoeg_g_free (s);
  }
  goto <D.33482>;
  <D.33480>:
  D.33481 = acfg->w;
  img_writer_emit_pointer (D.33481, target);
  <D.33482>:
}


emit_blob (struct MonoAotCompile * acfg)
{
  unsigned int D.33483;
  int D.33484;
  char * D.33485;
  char symbol[128];

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


emit_objc_selectors (struct MonoAotCompile * acfg)
{
  struct GPtrArray * D.33488;
  unsigned int D.33490;
  struct MonoImageWriter * D.33491;
  struct FILE * D.33492;
  _Bool D.33493;
  long int D.33494;
  long int D.33495;
  unsigned int i.843;
  void * * D.33499;
  unsigned int i.844;
  unsigned int D.33501;
  void * * D.33502;
  void * D.33503;
  int i;

  D.33488 = acfg->objc_selectors;
  if (D.33488 == 0B) goto <D.33486>; else goto <D.33489>;
  <D.33489>:
  D.33488 = acfg->objc_selectors;
  D.33490 = D.33488->len;
  if (D.33490 == 0) goto <D.33486>; else goto <D.33487>;
  <D.33486>:
  return;
  <D.33487>:
  D.33491 = acfg->w;
  img_writer_emit_unset_mode (D.33491);
  D.33492 = acfg->fp;
  D.33493 = D.33492 == 0B;
  D.33494 = (long int) D.33493;
  D.33495 = __builtin_expect (D.33494, 0);
  if (D.33495 != 0) goto <D.33496>; else goto <D.33497>;
  <D.33496>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "aot-compiler.c", 8235, "acfg->fp");
  <D.33497>:
  D.33492 = acfg->fp;
  fprintf (D.33492, ".section\t__DATA,__objc_selrefs,literal_pointers,no_dead_strip\n");
  D.33492 = acfg->fp;
  fprintf (D.33492, ".align\t2\n");
  i = 0;
  goto <D.25996>;
  <D.25995>:
  D.33492 = acfg->fp;
  fprintf (D.33492, "L_OBJC_SELECTOR_REFERENCES_%d:\n", i);
  D.33492 = acfg->fp;
  fprintf (D.33492, ".long\tL_OBJC_METH_VAR_NAME_%d\n", i);
  i = i + 1;
  <D.25996>:
  i.843 = (unsigned int) i;
  D.33488 = acfg->objc_selectors;
  D.33490 = D.33488->len;
  if (i.843 < D.33490) goto <D.25995>; else goto <D.25997>;
  <D.25997>:
  D.33492 = acfg->fp;
  fprintf (D.33492, ".section\t__TEXT,__cstring,cstring_literals\n");
  i = 0;
  goto <D.25999>;
  <D.25998>:
  D.33492 = acfg->fp;
  fprintf (D.33492, "L_OBJC_METH_VAR_NAME_%d:\n", i);
  D.33488 = acfg->objc_selectors;
  D.33499 = D.33488->pdata;
  i.844 = (unsigned int) i;
  D.33501 = i.844 * 4;
  D.33502 = D.33499 + D.33501;
  D.33503 = *D.33502;
  D.33492 = acfg->fp;
  fprintf (D.33492, ".asciz \"%s\"\n", D.33503);
  i = i + 1;
  <D.25999>:
  i.843 = (unsigned int) i;
  D.33488 = acfg->objc_selectors;
  D.33490 = D.33488->len;
  if (i.843 < D.33490) goto <D.25998>; else goto <D.26000>;
  <D.26000>:
  D.33492 = acfg->fp;
  fprintf (D.33492, ".section\t__DATA,__objc_imageinfo,regular,no_dead_strip\n");
  D.33492 = acfg->fp;
  fprintf (D.33492, ".align\t2\n");
  D.33492 = acfg->fp;
  fprintf (D.33492, "L_OBJC_IMAGE_INFO:\n");
  D.33492 = acfg->fp;
  fprintf (D.33492, ".long\t0\n");
  D.33492 = acfg->fp;
  fprintf (D.33492, ".long\t16\n");
}


emit_globals (struct MonoAotCompile * acfg)
{
  int D.33505;
  struct GPtrArray * D.33508;
  unsigned int D.33509;
  double D.33510;
  double D.33511;
  int D.33512;
  unsigned int D.33513;
  unsigned int D.33514;
  unsigned int table_size.845;
  void * * D.33516;
  unsigned int i.846;
  unsigned int D.33518;
  void * * D.33519;
  unsigned int D.33520;
  unsigned int i.847;
  void * * D.33522;
  unsigned int D.33523;
  void * * D.33524;
  struct GlobalsTableEntry * D.33528;
  unsigned int D.33529;
  unsigned int i.848;
  _Bool D.33531;
  long int D.33532;
  long int D.33533;
  void * * D.33536;
  unsigned int D.33540;
  unsigned int D.33541;
  int D.33542;
  struct GlobalsTableEntry * D.33543;
  unsigned int D.33546;
  int D.33547;
  const char * D.33549;
  int i;
  int table_size;
  guint32 hash;
  struct GPtrArray * table;
  char symbol[256];
  struct GlobalsTableEntry * entry;
  struct GlobalsTableEntry * new_entry;

  try
    {
      D.33505 = acfg->aot_opts.static_link;
      if (D.33505 == 0) goto <D.33506>; else goto <D.33507>;
      <D.33506>:
      return;
      <D.33507>:
      D.33508 = acfg->globals;
      D.33509 = D.33508->len;
      D.33510 = (double) D.33509;
      D.33511 = D.33510 * 1.5e+0;
      D.33512 = (int) D.33511;
      D.33513 = (unsigned int) D.33512;
      D.33514 = monoeg_g_spaced_primes_closest (D.33513);
      table_size = (int) D.33514;
      table_size.845 = (unsigned int) table_size;
      table = monoeg_g_ptr_array_sized_new (table_size.845);
      i = 0;
      goto <D.25934>;
      <D.25933>:
      monoeg_g_ptr_array_add (table, 0B);
      i = i + 1;
      <D.25934>:
      if (i < table_size) goto <D.25933>; else goto <D.25935>;
      <D.25935>:
      i = 0;
      goto <D.25941>;
      <D.25940>:
      {
        char * name;

        D.33508 = acfg->globals;
        D.33516 = D.33508->pdata;
        i.846 = (unsigned int) i;
        D.33518 = i.846 * 4;
        D.33519 = D.33516 + D.33518;
        name = *D.33519;
        D.33520 = mono_metadata_str_hash (name);
        table_size.845 = (unsigned int) table_size;
        hash = D.33520 % table_size.845;
        new_entry = monoeg_malloc0 (12);
        i.847 = (unsigned int) i;
        new_entry->value = i.847;
        D.33522 = table->pdata;
        D.33523 = hash * 4;
        D.33524 = D.33522 + D.33523;
        entry = *D.33524;
        if (entry == 0B) goto <D.33525>; else goto <D.33526>;
        <D.33525>:
        new_entry->index = hash;
        D.33522 = table->pdata;
        D.33523 = hash * 4;
        D.33524 = D.33522 + D.33523;
        *D.33524 = new_entry;
        goto <D.33527>;
        <D.33526>:
        goto <D.25938>;
        <D.25937>:
        entry = entry->next;
        <D.25938>:
        D.33528 = entry->next;
        if (D.33528 != 0B) goto <D.25937>; else goto <D.25939>;
        <D.25939>:
        entry->next = new_entry;
        D.33529 = table->len;
        new_entry->index = D.33529;
        monoeg_g_ptr_array_add (table, new_entry);
        <D.33527>:
      }
      i = i + 1;
      <D.25941>:
      i.848 = (unsigned int) i;
      D.33508 = acfg->globals;
      D.33509 = D.33508->len;
      if (i.848 < D.33509) goto <D.25940>; else goto <D.25942>;
      <D.25942>:
      sprintf (&symbol, ".Lglobals_hash");
      emit_section_change (acfg, ".rodata", 0);
      emit_alignment (acfg, 8);
      emit_label (acfg, &symbol);
      D.33531 = table_size > 64999;
      D.33532 = (long int) D.33531;
      D.33533 = __builtin_expect (D.33532, 0);
      if (D.33533 != 0) goto <D.33534>; else goto <D.33535>;
      <D.33534>:
      monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "aot-compiler.c", 7948, "table_size < 65000");
      <D.33535>:
      emit_int16 (acfg, table_size);
      i = 0;
      goto <D.25945>;
      <D.25944>:
      {
        struct GlobalsTableEntry * entry;

        D.33522 = table->pdata;
        i.846 = (unsigned int) i;
        D.33518 = i.846 * 4;
        D.33536 = D.33522 + D.33518;
        entry = *D.33536;
        if (entry == 0B) goto <D.33537>; else goto <D.33538>;
        <D.33537>:
        emit_int16 (acfg, 0);
        emit_int16 (acfg, 0);
        goto <D.33539>;
        <D.33538>:
        D.33540 = entry->value;
        D.33541 = D.33540 + 1;
        D.33542 = (int) D.33541;
        emit_int16 (acfg, D.33542);
        D.33543 = entry->next;
        if (D.33543 != 0B) goto <D.33544>; else goto <D.33545>;
        <D.33544>:
        D.33543 = entry->next;
        D.33546 = D.33543->index;
        D.33547 = (int) D.33546;
        emit_int16 (acfg, D.33547);
        goto <D.33548>;
        <D.33545>:
        emit_int16 (acfg, 0);
        <D.33548>:
        <D.33539>:
      }
      i = i + 1;
      <D.25945>:
      i.848 = (unsigned int) i;
      D.33529 = table->len;
      if (i.848 < D.33529) goto <D.25944>; else goto <D.25946>;
      <D.25946>:
      i = 0;
      goto <D.25949>;
      <D.25948>:
      {
        char * name;

        D.33508 = acfg->globals;
        D.33516 = D.33508->pdata;
        i.846 = (unsigned int) i;
        D.33518 = i.846 * 4;
        D.33519 = D.33516 + D.33518;
        name = *D.33519;
        sprintf (&symbol, "name_%d", i);
        emit_section_change (acfg, ".rodata", 1);
        emit_label (acfg, &symbol);
        emit_string (acfg, name);
      }
      i = i + 1;
      <D.25949>:
      i.848 = (unsigned int) i;
      D.33508 = acfg->globals;
      D.33509 = D.33508->len;
      if (i.848 < D.33509) goto <D.25948>; else goto <D.25950>;
      <D.25950>:
      sprintf (&symbol, "globals");
      emit_section_change (acfg, ".data", 0);
      emit_alignment (acfg, 8);
      emit_label (acfg, &symbol);
      D.33549 = acfg->temp_prefix;
      sprintf (&symbol, "%sglobals_hash", D.33549);
      emit_pointer (acfg, &symbol);
      i = 0;
      goto <D.25953>;
      <D.25952>:
      {
        char * name;

        D.33508 = acfg->globals;
        D.33516 = D.33508->pdata;
        i.846 = (unsigned int) i;
        D.33518 = i.846 * 4;
        D.33519 = D.33516 + D.33518;
        name = *D.33519;
        sprintf (&symbol, "name_%d", i);
        emit_pointer (acfg, &symbol);
        sprintf (&symbol, "%s", name);
        emit_pointer (acfg, &symbol);
      }
      i = i + 1;
      <D.25953>:
      i.848 = (unsigned int) i;
      D.33508 = acfg->globals;
      D.33509 = D.33508->len;
      if (i.848 < D.33509) goto <D.25952>; else goto <D.25954>;
      <D.25954>:
      emit_int32 (acfg, 0);
      emit_int32 (acfg, 0);
    }
  finally
    {
      symbol = {CLOBBER};
    }
}


emit_autoreg (struct MonoAotCompile * acfg)
{
  int D.33555;
  int D.33557;
  int D.33559;
  char * D.33560;
  char * symbol;

  D.33555 = acfg->use_bin_writer;
  if (D.33555 != 0) goto <D.33553>; else goto <D.33556>;
  <D.33556>:
  D.33557 = acfg->aot_opts.static_link;
  if (D.33557 == 0) goto <D.33553>; else goto <D.33558>;
  <D.33558>:
  D.33559 = acfg->aot_opts.autoreg;
  if (D.33559 == 0) goto <D.33553>; else goto <D.33554>;
  <D.33553>:
  return;
  <D.33554>:
  D.33560 = acfg->static_linking_symbol;
  symbol = monoeg_g_strdup_printf ("_%s_autoreg", D.33560);
  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.33562;
  unsigned int i.849;
  unsigned int D.33564;
  struct MonoCompile * * D.33565;
  unsigned char D.33568;
  unsigned char D.33569;
  const char * D.33572;
  struct MonoDomain * D.33573;
  struct MonoJitInfo * D.33574;
  struct MonoMethod * D.33575;
  struct MonoDebugMethodJitInfo * D.33576;
  struct GSList * D.33577;
  struct MonoInst * * D.33578;
  struct MonoInst * * D.33579;
  int D.33580;
  unsigned int D.33581;
  void * D.33582;
  char * D.33583;
  struct MonoMethod * D.33584;
  struct MonoDwarfWriter * D.33585;
  unsigned int i.850;
  unsigned int D.33587;
  int i;
  char symbol2[128];

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

        D.33562 = acfg->cfgs;
        i.849 = (unsigned int) i;
        D.33564 = i.849 * 4;
        D.33565 = D.33562 + D.33564;
        cfg = *D.33565;
        if (cfg == 0B) goto <D.33566>; else goto <D.33567>;
        <D.33566>:
        // predicted unlikely by continue predictor.
        goto <D.26007>;
        <D.33567>:
        D.33568 = BIT_FIELD_REF <*cfg, 8, 3400>;
        D.33569 = D.33568 & 1;
        if (D.33569 != 0) goto <D.33570>; else goto <D.33571>;
        <D.33570>:
        // predicted unlikely by continue predictor.
        goto <D.26007>;
        <D.33571>:
        D.33572 = acfg->temp_prefix;
        sprintf (&symbol2, "%sme_%x", D.33572, i);
        D.33573 = mono_domain_get ();
        D.33574 = cfg->jit_info;
        D.33575 = D.33574->d.method;
        D.33576 = mono_debug_find_method (D.33575, D.33573);
        D.33577 = cfg->unwind_ops;
        D.33578 = cfg->locals;
        D.33579 = cfg->args;
        D.33574 = cfg->jit_info;
        D.33580 = D.33574->code_size;
        D.33581 = (unsigned int) D.33580;
        D.33574 = cfg->jit_info;
        D.33582 = D.33574->code_start;
        D.33583 = cfg->asm_symbol;
        D.33584 = cfg->method;
        D.33585 = acfg->dwarf;
        mono_dwarf_writer_emit_method (D.33585, cfg, D.33584, D.33583, &symbol2, D.33582, D.33581, D.33579, D.33578, D.33577, D.33576);
      }
      <D.26007>:
      i = i + 1;
      <D.26009>:
      i.850 = (unsigned int) i;
      D.33587 = acfg->nmethods;
      if (i.850 < D.33587) goto <D.26008>; else goto <D.26010>;
      <D.26010>:
    }
  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.33588;

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


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

  D.33591 = __builtin_object_size (__dest, 1);
  D.33590 = __builtin___strcpy_chk (__dest, __src, D.33591);
  return D.33590;
}


compile_asm (struct MonoAotCompile * acfg)
{
  const char * iftmp.851;
  char * D.33594;
  int D.33598;
  char * D.33601;
  int D.33602;
  char * D.33605;
  int D.33606;
  char * D.33609;
  struct MonoImage * D.33613;
  char * D.33614;
  const char * iftmp.852;
  struct GString * D.33617;
  int D.33621;
  int D.33629;
  int D.33632;
  char * command;
  char * objfile;
  char * outfile_name;
  char * tmp_outfile_name;
  const char * tool_prefix;

  D.33594 = acfg->aot_opts.tool_prefix;
  if (D.33594 != 0B) goto <D.33595>; else goto <D.33596>;
  <D.33595>:
  iftmp.851 = acfg->aot_opts.tool_prefix;
  goto <D.33597>;
  <D.33596>:
  iftmp.851 = "";
  <D.33597>:
  tool_prefix = iftmp.851;
  D.33598 = acfg->aot_opts.asm_only;
  if (D.33598 != 0) goto <D.33599>; else goto <D.33600>;
  <D.33599>:
  D.33601 = acfg->tmpfname;
  printf ("Output file: \'%s\'.\n", D.33601);
  D.33602 = acfg->aot_opts.static_link;
  if (D.33602 != 0) goto <D.33603>; else goto <D.33604>;
  <D.33603>:
  D.33605 = acfg->static_linking_symbol;
  printf ("Linking symbol: \'%s\'.\n", D.33605);
  <D.33604>:
  D.33606 = 0;
  return D.33606;
  <D.33600>:
  D.33602 = acfg->aot_opts.static_link;
  if (D.33602 != 0) goto <D.33607>; else goto <D.33608>;
  <D.33607>:
  D.33609 = acfg->aot_opts.outfile;
  if (D.33609 != 0B) goto <D.33610>; else goto <D.33611>;
  <D.33610>:
  D.33609 = acfg->aot_opts.outfile;
  objfile = monoeg_g_strdup_printf ("%s", D.33609);
  goto <D.33612>;
  <D.33611>:
  D.33613 = acfg->image;
  D.33614 = D.33613->name;
  objfile = monoeg_g_strdup_printf ("%s.o", D.33614);
  <D.33612>:
  goto <D.33615>;
  <D.33608>:
  D.33601 = acfg->tmpfname;
  objfile = monoeg_g_strdup_printf ("%s.o", D.33601);
  <D.33615>:
  D.33601 = acfg->tmpfname;
  D.33617 = acfg->as_args;
  if (D.33617 != 0B) goto <D.33618>; else goto <D.33619>;
  <D.33618>:
  D.33617 = acfg->as_args;
  iftmp.852 = D.33617->str;
  goto <D.33620>;
  <D.33619>:
  iftmp.852 = "";
  <D.33620>:
  command = monoeg_g_strdup_printf ("%s%s %s %s -o %s %s", tool_prefix, "as", "", iftmp.852, objfile, D.33601);
  printf ("Executing the native assembler: %s\n", command);
  D.33621 = system (command);
  if (D.33621 != 0) goto <D.33622>; else goto <D.33623>;
  <D.33622>:
  monoeg_g_free (command);
  monoeg_g_free (objfile);
  D.33606 = 1;
  return D.33606;
  <D.33623>:
  monoeg_g_free (command);
  D.33602 = acfg->aot_opts.static_link;
  if (D.33602 != 0) goto <D.33624>; else goto <D.33625>;
  <D.33624>:
  printf ("Output file: \'%s\'.\n", objfile);
  D.33605 = acfg->static_linking_symbol;
  printf ("Linking symbol: \'%s\'.\n", D.33605);
  monoeg_g_free (objfile);
  D.33606 = 0;
  return D.33606;
  <D.33625>:
  D.33609 = acfg->aot_opts.outfile;
  if (D.33609 != 0B) goto <D.33626>; else goto <D.33627>;
  <D.33626>:
  D.33609 = acfg->aot_opts.outfile;
  outfile_name = monoeg_g_strdup_printf ("%s", D.33609);
  goto <D.33628>;
  <D.33627>:
  D.33613 = acfg->image;
  D.33614 = D.33613->name;
  outfile_name = monoeg_g_strdup_printf ("%s%s", D.33614, ".so");
  <D.33628>:
  tmp_outfile_name = monoeg_g_strdup_printf ("%s.tmp", outfile_name);
  D.33601 = acfg->tmpfname;
  command = monoeg_g_strdup_printf ("%sld %s -shared -o %s %s.o", tool_prefix, "", tmp_outfile_name, D.33601);
  printf ("Executing the native linker: %s\n", command);
  D.33629 = system (command);
  if (D.33629 != 0) goto <D.33630>; else goto <D.33631>;
  <D.33630>:
  monoeg_g_free (tmp_outfile_name);
  monoeg_g_free (outfile_name);
  monoeg_g_free (command);
  monoeg_g_free (objfile);
  D.33606 = 1;
  return D.33606;
  <D.33631>:
  monoeg_g_free (command);
  rename (tmp_outfile_name, outfile_name);
  D.33632 = acfg->aot_opts.save_temps;
  if (D.33632 == 0) goto <D.33633>; else goto <D.33634>;
  <D.33633>:
  unlink (objfile);
  <D.33634>:
  monoeg_g_free (tmp_outfile_name);
  monoeg_g_free (outfile_name);
  monoeg_g_free (objfile);
  D.33632 = acfg->aot_opts.save_temps;
  if (D.33632 != 0) goto <D.33635>; else goto <D.33636>;
  <D.33635>:
  printf ("Retained input file.\n");
  goto <D.33637>;
  <D.33636>:
  D.33601 = acfg->tmpfname;
  unlink (D.33601);
  <D.33637>:
  D.33606 = 0;
  return D.33606;
}


get_patch_name (int info)
{
  const char * D.33639;
  short int D.33640;
  sizetype D.33641;

  D.33640 = opidx[info];
  D.33641 = (sizetype) D.33640;
  D.33639 = &opstr + D.33641;
  return D.33639;
}


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

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


acfg_free (struct MonoAotCompile * acfg)
{
  struct MonoImageWriter * D.33645;
  struct MonoCompile * * D.33646;
  unsigned int i.853;
  unsigned int D.33648;
  struct MonoCompile * * D.33649;
  struct MonoCompile * D.33650;
  unsigned int i.854;
  unsigned int D.33654;
  char * D.33655;
  char * D.33656;
  char * D.33657;
  struct GPtrArray * D.33658;
  struct GPtrArray * D.33659;
  struct GPtrArray * D.33660;
  struct GPtrArray * D.33661;
  struct GPtrArray * D.33662;
  struct GHashTable * D.33663;
  struct GHashTable * D.33664;
  struct GHashTable * D.33665;
  struct GHashTable * * D.33666;
  struct GHashTable * * D.33667;
  struct GHashTable * D.33668;
  struct GHashTable * D.33671;
  struct GHashTable * D.33672;
  struct GHashTable * D.33673;
  struct GHashTable * D.33674;
  struct GHashTable * D.33675;
  struct GHashTable * D.33676;
  struct GHashTable * D.33677;
  struct GHashTable * D.33678;
  struct GHashTable * D.33679;
  struct GHashTable * D.33680;
  struct GHashTable * D.33681;
  struct GHashTable * * D.33682;
  struct GHashTable * * D.33683;
  struct GHashTable * D.33684;
  struct MonoMemPool * D.33685;
  int i;

  D.33645 = acfg->w;
  img_writer_destroy (D.33645);
  i = 0;
  goto <D.26080>;
  <D.26079>:
  D.33646 = acfg->cfgs;
  i.853 = (unsigned int) i;
  D.33648 = i.853 * 4;
  D.33649 = D.33646 + D.33648;
  D.33650 = *D.33649;
  if (D.33650 != 0B) goto <D.33651>; else goto <D.33652>;
  <D.33651>:
  D.33646 = acfg->cfgs;
  i.853 = (unsigned int) i;
  D.33648 = i.853 * 4;
  D.33649 = D.33646 + D.33648;
  D.33650 = *D.33649;
  monoeg_g_free (D.33650);
  <D.33652>:
  i = i + 1;
  <D.26080>:
  i.854 = (unsigned int) i;
  D.33654 = acfg->nmethods;
  if (i.854 < D.33654) goto <D.26079>; else goto <D.26081>;
  <D.26081>:
  D.33646 = acfg->cfgs;
  monoeg_g_free (D.33646);
  D.33655 = acfg->static_linking_symbol;
  monoeg_g_free (D.33655);
  D.33656 = acfg->got_symbol;
  monoeg_g_free (D.33656);
  D.33657 = acfg->plt_symbol;
  monoeg_g_free (D.33657);
  D.33658 = acfg->methods;
  monoeg_g_ptr_array_free (D.33658, 1);
  D.33659 = acfg->got_patches;
  monoeg_g_ptr_array_free (D.33659, 1);
  D.33660 = acfg->image_table;
  monoeg_g_ptr_array_free (D.33660, 1);
  D.33661 = acfg->globals;
  monoeg_g_ptr_array_free (D.33661, 1);
  D.33662 = acfg->unwind_ops;
  monoeg_g_ptr_array_free (D.33662, 1);
  D.33663 = acfg->method_indexes;
  monoeg_g_hash_table_destroy (D.33663);
  D.33664 = acfg->method_depth;
  monoeg_g_hash_table_destroy (D.33664);
  D.33665 = acfg->plt_offset_to_entry;
  monoeg_g_hash_table_destroy (D.33665);
  i = 0;
  goto <D.26083>;
  <D.26082>:
  D.33666 = acfg->patch_to_plt_entry;
  i.853 = (unsigned int) i;
  D.33648 = i.853 * 4;
  D.33667 = D.33666 + D.33648;
  D.33668 = *D.33667;
  if (D.33668 != 0B) goto <D.33669>; else goto <D.33670>;
  <D.33669>:
  D.33666 = acfg->patch_to_plt_entry;
  i.853 = (unsigned int) i;
  D.33648 = i.853 * 4;
  D.33667 = D.33666 + D.33648;
  D.33668 = *D.33667;
  monoeg_g_hash_table_destroy (D.33668);
  <D.33670>:
  i = i + 1;
  <D.26083>:
  if (i <= 51) goto <D.26082>; else goto <D.26084>;
  <D.26084>:
  D.33666 = acfg->patch_to_plt_entry;
  monoeg_g_free (D.33666);
  D.33671 = acfg->patch_to_got_offset;
  monoeg_g_hash_table_destroy (D.33671);
  D.33672 = acfg->method_to_cfg;
  monoeg_g_hash_table_destroy (D.33672);
  D.33673 = acfg->token_info_hash;
  monoeg_g_hash_table_destroy (D.33673);
  D.33674 = acfg->method_to_pinvoke_import;
  monoeg_g_hash_table_destroy (D.33674);
  D.33675 = acfg->image_hash;
  monoeg_g_hash_table_destroy (D.33675);
  D.33676 = acfg->unwind_info_offsets;
  monoeg_g_hash_table_destroy (D.33676);
  D.33677 = acfg->method_label_hash;
  monoeg_g_hash_table_destroy (D.33677);
  D.33678 = acfg->export_names;
  monoeg_g_hash_table_destroy (D.33678);
  D.33679 = acfg->plt_entry_debug_sym_cache;
  monoeg_g_hash_table_destroy (D.33679);
  D.33680 = acfg->klass_blob_hash;
  monoeg_g_hash_table_destroy (D.33680);
  D.33681 = acfg->method_blob_hash;
  monoeg_g_hash_table_destroy (D.33681);
  i = 0;
  goto <D.26086>;
  <D.26085>:
  D.33682 = acfg->patch_to_got_offset_by_type;
  i.853 = (unsigned int) i;
  D.33648 = i.853 * 4;
  D.33683 = D.33682 + D.33648;
  D.33684 = *D.33683;
  monoeg_g_hash_table_destroy (D.33684);
  i = i + 1;
  <D.26086>:
  if (i <= 51) goto <D.26085>; else goto <D.26087>;
  <D.26087>:
  D.33682 = acfg->patch_to_got_offset_by_type;
  monoeg_g_free (D.33682);
  D.33685 = acfg->mempool;
  mono_mempool_destroy (D.33685);
  monoeg_g_free (acfg);
}