mono_domain_get_tls_key ()
{
  pthread_key_t D.18235;

  D.18235 = appdomain_thread_id;
  return D.18235;
}


mono_domain_get_tls_offset ()
{
  gint32 D.18237;
  int offset;

  offset = -1;
  __asm__("movl $tls_appdomain@ntpoff, %0" : "=r" offset);
  D.18237 = offset;
  return D.18237;
}


mono_jit_info_table_find_internal (struct MonoDomain * domain, char * addr, gboolean try_aot)
{
  long unsigned int D.18239;
  long unsigned int D.18240;
  struct MonoJitInfoTable * volatile * D.18241;
  struct MonoJitInfo * D.18248;
  struct MonoDomain * mono_root_domain.0;
  struct MonoJitInfoTable * D.18254;
  struct MonoJitInfoTable * volatile * D.18257;
  struct MonoJitInfo * (*<T199c>) (struct MonoDomain *, struct MonoImage *, void *) jit_info_find_in_aot_func.1;
  struct MonoImage * D.18261;
  struct MonoJitInfoTable * table;
  struct MonoJitInfo * ji;
  struct MonoJitInfo * module_ji;
  struct MonoThreadHazardPointers * hp;

  hp = mono_hazard_pointer_get ();
  D.18239 = mono_stats.jit_info_table_lookup_count;
  D.18240 = D.18239 + 1;
  mono_stats.jit_info_table_lookup_count = D.18240;
  D.18241 = &domain->jit_info_table;
  table = get_hazardous_pointer (D.18241, hp, 0);
  ji = jit_info_table_find (table, hp, addr);
  if (hp != 0B) goto <D.18242>; else goto <D.18243>;
  <D.18242>:
  if (0 != 0) goto <D.18244>; else goto <D.18245>;
  <D.18244>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "domain.c", 401, "(0) >= 0 && (0) < HAZARD_POINTER_COUNT");
  <D.18245>:
  hp->hazard_pointers[0] = 0B;
  <D.18243>:
  if (ji != 0B) goto <D.18246>; else goto <D.18247>;
  <D.18246>:
  D.18248 = ji;
  return D.18248;
  <D.18247>:
  if (try_aot != 0) goto <D.18249>; else goto <D.18250>;
  <D.18249>:
  mono_root_domain.0 = mono_root_domain;
  if (mono_root_domain.0 != 0B) goto <D.18252>; else goto <D.18253>;
  <D.18252>:
  mono_root_domain.0 = mono_root_domain;
  D.18254 = mono_root_domain.0->aot_modules;
  if (D.18254 != 0B) goto <D.18255>; else goto <D.18256>;
  <D.18255>:
  mono_root_domain.0 = mono_root_domain;
  D.18257 = &mono_root_domain.0->aot_modules;
  table = get_hazardous_pointer (D.18257, hp, 0);
  module_ji = jit_info_table_find (table, hp, addr);
  if (module_ji != 0B) goto <D.18258>; else goto <D.18259>;
  <D.18258>:
  jit_info_find_in_aot_func.1 = jit_info_find_in_aot_func;
  D.18261 = module_ji->d.image;
  ji = jit_info_find_in_aot_func.1 (domain, D.18261, addr);
  <D.18259>:
  if (hp != 0B) goto <D.18262>; else goto <D.18263>;
  <D.18262>:
  if (0 != 0) goto <D.18264>; else goto <D.18265>;
  <D.18264>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "domain.c", 412, "(0) >= 0 && (0) < HAZARD_POINTER_COUNT");
  <D.18265>:
  hp->hazard_pointers[0] = 0B;
  <D.18263>:
  <D.18256>:
  <D.18253>:
  <D.18250>:
  D.18248 = ji;
  return D.18248;
}


jit_info_table_find (struct MonoJitInfoTable * table, struct MonoThreadHazardPointers * hp, gint8 * addr)
{
  int D.18267;
  _Bool D.18268;
  long int D.18269;
  long int D.18270;
  struct MonoJitInfoTableChunk * D.18273;
  struct MonoJitInfo * volatile * D.18274;
  struct MonoMethod * D.18275;
  void * D.18280;
  int D.18283;
  sizetype D.18284;
  gint8 * D.18285;
  struct MonoJitInfo * D.18290;
  int D.18292;
  struct MonoJitInfo * ji;
  int chunk_pos;
  int pos;
  void not_found = <<< error >>>;

  chunk_pos = jit_info_table_index (table, addr);
  D.18267 = table->num_chunks;
  D.18268 = D.18267 <= chunk_pos;
  D.18269 = (long int) D.18268;
  D.18270 = __builtin_expect (D.18269, 0);
  if (D.18270 != 0) goto <D.18271>; else goto <D.18272>;
  <D.18271>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "domain.c", 327, "chunk_pos < table->num_chunks");
  <D.18272>:
  D.18273 = table->chunks[chunk_pos];
  pos = jit_info_table_chunk_index (D.18273, hp, addr);
  <D.17488>:
  {
    struct MonoJitInfoTableChunk * chunk;

    chunk = table->chunks[chunk_pos];
    goto <D.17484>;
    <D.17486>:
    D.18274 = &chunk->data[pos];
    ji = get_hazardous_pointer (D.18274, hp, 1);
    pos = pos + 1;
    D.18275 = ji->d.method;
    if (D.18275 == 0B) goto <D.18276>; else goto <D.18277>;
    <D.18276>:
    if (0 != 0) goto <D.18278>; else goto <D.18279>;
    <D.18278>:
    monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "domain.c", 345, "(1) >= 0 && (1) < HAZARD_POINTER_COUNT");
    <D.18279>:
    hp->hazard_pointers[1] = 0B;
    // predicted unlikely by continue predictor.
    goto <D.17484>;
    <D.18277>:
    D.18280 = ji->code_start;
    if (D.18280 <= addr) goto <D.18281>; else goto <D.18282>;
    <D.18281>:
    D.18280 = ji->code_start;
    D.18283 = ji->code_size;
    D.18284 = (sizetype) D.18283;
    D.18285 = D.18280 + D.18284;
    if (D.18285 > addr) goto <D.18286>; else goto <D.18287>;
    <D.18286>:
    if (0 != 0) goto <D.18288>; else goto <D.18289>;
    <D.18288>:
    monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "domain.c", 350, "(1) >= 0 && (1) < HAZARD_POINTER_COUNT");
    <D.18289>:
    hp->hazard_pointers[1] = 0B;
    D.18290 = ji;
    return D.18290;
    <D.18287>:
    <D.18282>:
    D.18280 = ji->code_start;
    if (D.18280 > addr) goto not_found; else goto <D.18291>;
    <D.18291>:
    <D.17484>:
    D.18292 = chunk->num_elements;
    if (D.18292 > pos) goto <D.17486>; else goto <D.17487>;
    <D.17487>:
    chunk_pos = chunk_pos + 1;
    pos = 0;
  }
  D.18267 = table->num_chunks;
  if (D.18267 > chunk_pos) goto <D.17488>; else goto <D.17489>;
  <D.17489>:
  not_found:
  if (hp != 0B) goto <D.18293>; else goto <D.18294>;
  <D.18293>:
  if (0 != 0) goto <D.18295>; else goto <D.18296>;
  <D.18295>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "domain.c", 367, "(1) >= 0 && (1) < HAZARD_POINTER_COUNT");
  <D.18296>:
  hp->hazard_pointers[1] = 0B;
  <D.18294>:
  D.18290 = 0B;
  return D.18290;
}


jit_info_table_index (struct MonoJitInfoTable * table, gint8 * addr)
{
  _Bool D.18298;
  long int D.18299;
  long int D.18300;
  int D.18303;
  volatile gint8 * D.18304;
  _Bool D.18308;
  long int D.18309;
  long int D.18310;
  int D.18313;
  int D.18316;
  int left;
  int right;

  left = 0;
  right = table->num_chunks;
  D.18298 = left >= right;
  D.18299 = (long int) D.18298;
  D.18300 = __builtin_expect (D.18299, 0);
  if (D.18300 != 0) goto <D.18301>; else goto <D.18302>;
  <D.18301>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "domain.c", 282, "left < right");
  <D.18302>:
  <D.17460>:
  {
    int pos;
    struct MonoJitInfoTableChunk * chunk;

    D.18303 = left + right;
    pos = D.18303 / 2;
    chunk = table->chunks[pos];
    D.18304 = chunk->last_code_end;
    if (D.18304 > addr) goto <D.18305>; else goto <D.18306>;
    <D.18305>:
    right = pos;
    goto <D.18307>;
    <D.18306>:
    left = pos + 1;
    <D.18307>:
  }
  if (left < right) goto <D.17460>; else goto <D.17461>;
  <D.17461>:
  D.18308 = left != right;
  D.18309 = (long int) D.18308;
  D.18310 = __builtin_expect (D.18309, 0);
  if (D.18310 != 0) goto <D.18311>; else goto <D.18312>;
  <D.18311>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "domain.c", 293, "left == right");
  <D.18312>:
  D.18313 = table->num_chunks;
  if (D.18313 <= left) goto <D.18314>; else goto <D.18315>;
  <D.18314>:
  D.18313 = table->num_chunks;
  D.18316 = D.18313 + -1;
  return D.18316;
  <D.18315>:
  D.18316 = left;
  return D.18316;
}


jit_info_table_chunk_index (struct MonoJitInfoTableChunk * chunk, struct MonoThreadHazardPointers * hp, gint8 * addr)
{
  int D.18318;
  struct MonoJitInfo * volatile * D.18319;
  void * D.18320;
  int D.18321;
  sizetype D.18322;
  _Bool D.18326;
  long int D.18327;
  long int D.18328;
  int D.18331;
  int left;
  int right;

  left = 0;
  right = chunk->num_elements;
  goto <D.17473>;
  <D.17472>:
  {
    int pos;
    struct MonoJitInfo * ji;
    gint8 * code_end;

    D.18318 = left + right;
    pos = D.18318 / 2;
    D.18319 = &chunk->data[pos];
    ji = get_hazardous_pointer (D.18319, hp, 1);
    D.18320 = ji->code_start;
    D.18321 = ji->code_size;
    D.18322 = (sizetype) D.18321;
    code_end = D.18320 + D.18322;
    if (addr < code_end) goto <D.18323>; else goto <D.18324>;
    <D.18323>:
    right = pos;
    goto <D.18325>;
    <D.18324>:
    left = pos + 1;
    <D.18325>:
  }
  <D.17473>:
  if (left < right) goto <D.17472>; else goto <D.17474>;
  <D.17474>:
  D.18326 = left != right;
  D.18327 = (long int) D.18326;
  D.18328 = __builtin_expect (D.18327, 0);
  if (D.18328 != 0) goto <D.18329>; else goto <D.18330>;
  <D.18329>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "domain.c", 315, "left == right");
  <D.18330>:
  D.18331 = left;
  return D.18331;
}


mono_jit_info_table_find (struct MonoDomain * domain, char * addr)
{
  struct MonoJitInfo * D.18333;

  D.18333 = mono_jit_info_table_find_internal (domain, addr, 1);
  return D.18333;
}


mono_jit_info_table_add (struct MonoDomain * domain, struct MonoJitInfo * ji)
{
  struct MonoMethod * D.18335;
  _Bool D.18336;
  long int D.18337;
  long int D.18338;
  union mono_mutex_t * D.18341;
  _Bool D.18344;
  long int D.18345;
  long int D.18346;
  long unsigned int D.18349;
  long unsigned int D.18350;
  struct MonoJitInfoTable * volatile * D.18351;
  _Bool D.18354;
  long int D.18355;
  long int D.18356;

  D.18335 = ji->d.method;
  D.18336 = D.18335 == 0B;
  D.18337 = (long int) D.18336;
  D.18338 = __builtin_expect (D.18337, 0);
  if (D.18338 != 0) goto <D.18339>; else goto <D.18340>;
  <D.18339>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "domain.c", 749, "ji->d.method != NULL");
  <D.18340>:
  {
    int ret;

    D.18341 = &domain->lock.mutex;
    ret = pthread_mutex_lock (D.18341);
    if (ret != 0) goto <D.18342>; else goto <D.18343>;
    <D.18342>:
    monoeg_g_log (0B, 16, "Bad call to mono_mutex_lock result %d", ret);
    <D.18343>:
    D.18344 = ret != 0;
    D.18345 = (long int) D.18344;
    D.18346 = __builtin_expect (D.18345, 0);
    if (D.18346 != 0) goto <D.18347>; else goto <D.18348>;
    <D.18347>:
    monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "domain.c", 751, "ret == 0");
    <D.18348>:
  }
  D.18349 = mono_stats.jit_info_table_insert_count;
  D.18350 = D.18349 + 1;
  mono_stats.jit_info_table_insert_count = D.18350;
  D.18351 = &domain->jit_info_table;
  jit_info_table_add (domain, D.18351, ji);
  {
    int ret;

    D.18341 = &domain->lock.mutex;
    ret = pthread_mutex_unlock (D.18341);
    if (ret != 0) goto <D.18352>; else goto <D.18353>;
    <D.18352>:
    monoeg_g_log (0B, 16, "Bad call to mono_mutex_unlock result %d", ret);
    <D.18353>:
    D.18354 = ret != 0;
    D.18355 = (long int) D.18354;
    D.18356 = __builtin_expect (D.18355, 0);
    if (D.18356 != 0) goto <D.18357>; else goto <D.18358>;
    <D.18357>:
    monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "domain.c", 757, "ret == 0");
    <D.18358>:
  }
}


jit_info_table_add (struct MonoDomain * domain, struct MonoJitInfoTable * volatile * table_ptr, struct MonoJitInfo * ji)
{
  void * D.18359;
  int D.18360;
  sizetype D.18361;
  gint8 * D.18362;
  int D.18363;
  _Bool D.18364;
  long int D.18365;
  long int D.18366;
  int D.18369;
  int D.18372;
  int D.18373;
  int D.18376;
  struct MonoJitInfo * D.18377;
  int D.18379;
  struct MonoJitInfo * D.18380;
  int D.18381;
  int D.18382;
  struct MonoJitInfo * D.18383;
  void * D.18384;
  int D.18385;
  int D.18386;
  struct MonoJitInfo * D.18387;
  int D.18388;
  sizetype D.18389;
  volatile gint8 * D.18390;
  struct MonoJitInfoTable * table;
  struct MonoJitInfoTableChunk * chunk;
  int chunk_pos;
  int pos;
  int num_elements;
  int i;
  void restart = <<< error >>>;

  table = *table_ptr;
  restart:
  D.18359 = ji->code_start;
  D.18360 = ji->code_size;
  D.18361 = (sizetype) D.18360;
  D.18362 = D.18359 + D.18361;
  chunk_pos = jit_info_table_index (table, D.18362);
  D.18363 = table->num_chunks;
  D.18364 = D.18363 <= chunk_pos;
  D.18365 = (long int) D.18364;
  D.18366 = __builtin_expect (D.18365, 0);
  if (D.18366 != 0) goto <D.18367>; else goto <D.18368>;
  <D.18367>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "domain.c", 693, "chunk_pos < table->num_chunks");
  <D.18368>:
  chunk = table->chunks[chunk_pos];
  D.18369 = chunk->num_elements;
  if (D.18369 > 63) goto <D.18370>; else goto <D.18371>;
  <D.18370>:
  {
    struct MonoJitInfoTable * new_table;

    new_table = jit_info_table_chunk_overflow (table, chunk);
    *table_ptr = new_table;
    mono_memory_barrier ();
    D.18372 = domain->num_jit_info_tables;
    D.18373 = D.18372 + 1;
    domain->num_jit_info_tables = D.18373;
    mono_thread_hazardous_free_or_queue (table, jit_info_table_free, 1, 0);
    table = new_table;
    goto restart;
  }
  <D.18371>:
  num_elements = chunk->num_elements;
  D.18359 = ji->code_start;
  D.18360 = ji->code_size;
  D.18361 = (sizetype) D.18360;
  D.18362 = D.18359 + D.18361;
  pos = jit_info_table_chunk_index (chunk, 0B, D.18362);
  if (num_elements > 0) goto <D.18374>; else goto <D.18375>;
  <D.18374>:
  D.18376 = num_elements + -1;
  D.18377 = chunk->data[D.18376];
  chunk->data[num_elements] = D.18377;
  goto <D.18378>;
  <D.18375>:
  chunk->data[0] = ji;
  <D.18378>:
  mono_memory_write_barrier ();
  num_elements = num_elements + 1;
  chunk->num_elements = num_elements;
  i = num_elements + -2;
  goto <D.17607>;
  <D.17606>:
  mono_memory_write_barrier ();
  D.18379 = i + 1;
  D.18380 = chunk->data[i];
  chunk->data[D.18379] = D.18380;
  i = i + -1;
  <D.17607>:
  if (i >= pos) goto <D.17606>; else goto <D.17608>;
  <D.17608>:
  mono_memory_write_barrier ();
  chunk->data[pos] = ji;
  D.18381 = chunk->num_elements;
  D.18382 = D.18381 + -1;
  D.18383 = chunk->data[D.18382];
  D.18384 = D.18383->code_start;
  D.18385 = chunk->num_elements;
  D.18386 = D.18385 + -1;
  D.18387 = chunk->data[D.18386];
  D.18388 = D.18387->code_size;
  D.18389 = (sizetype) D.18388;
  D.18390 = D.18384 + D.18389;
  chunk->last_code_end = D.18390;
}


jit_info_table_free (struct MonoJitInfoTable * table)
{
  union mono_mutex_t * D.18391;
  _Bool D.18394;
  long int D.18395;
  long int D.18396;
  struct MonoDomain * D.18399;
  int D.18400;
  int D.18401;
  void * D.18404;
  struct GSList * D.18405;
  int D.18406;
  int D.18407;
  struct MonoMethod * D.18410;
  _Bool D.18415;
  long int D.18416;
  long int D.18417;
  int i;
  int num_chunks;
  struct MonoDomain * domain;

  num_chunks = table->num_chunks;
  domain = table->domain;
  {
    int ret;

    D.18391 = &domain->lock.mutex;
    ret = pthread_mutex_lock (D.18391);
    if (ret != 0) goto <D.18392>; else goto <D.18393>;
    <D.18392>:
    monoeg_g_log (0B, 16, "Bad call to mono_mutex_lock result %d", ret);
    <D.18393>:
    D.18394 = ret != 0;
    D.18395 = (long int) D.18394;
    D.18396 = __builtin_expect (D.18395, 0);
    if (D.18396 != 0) goto <D.18397>; else goto <D.18398>;
    <D.18397>:
    monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "domain.c", 216, "ret == 0");
    <D.18398>:
  }
  D.18399 = table->domain;
  D.18400 = D.18399->num_jit_info_tables;
  D.18401 = D.18400 + -1;
  D.18399->num_jit_info_tables = D.18401;
  D.18399 = table->domain;
  D.18400 = D.18399->num_jit_info_tables;
  if (D.18400 <= 1) goto <D.18402>; else goto <D.18403>;
  <D.18402>:
  {
    struct GSList * list;

    D.18399 = table->domain;
    list = D.18399->jit_info_free_queue;
    goto <D.17438>;
    <D.17437>:
    D.18404 = list->data;
    monoeg_g_free (D.18404);
    list = list->next;
    <D.17438>:
    if (list != 0B) goto <D.17437>; else goto <D.17439>;
    <D.17439>:
    D.18399 = table->domain;
    D.18405 = D.18399->jit_info_free_queue;
    monoeg_g_slist_free (D.18405);
    D.18399 = table->domain;
    D.18399->jit_info_free_queue = 0B;
  }
  <D.18403>:
  i = 0;
  goto <D.17449>;
  <D.17448>:
  {
    struct MonoJitInfoTableChunk * chunk;
    int num_elements;
    int j;

    chunk = table->chunks[i];
    D.18406 = chunk->refcount;
    D.18407 = D.18406 + -1;
    chunk->refcount = D.18407;
    D.18406 = chunk->refcount;
    if (D.18406 > 0) goto <D.18408>; else goto <D.18409>;
    <D.18408>:
    // predicted unlikely by continue predictor.
    goto <D.17443>;
    <D.18409>:
    num_elements = chunk->num_elements;
    j = 0;
    goto <D.17446>;
    <D.17445>:
    {
      struct MonoJitInfo * ji;

      ji = chunk->data[j];
      D.18410 = ji->d.method;
      if (D.18410 == 0B) goto <D.18411>; else goto <D.18412>;
      <D.18411>:
      monoeg_g_free (ji);
      <D.18412>:
    }
    j = j + 1;
    <D.17446>:
    if (j < num_elements) goto <D.17445>; else goto <D.17447>;
    <D.17447>:
    monoeg_g_free (chunk);
  }
  <D.17443>:
  i = i + 1;
  <D.17449>:
  if (i < num_chunks) goto <D.17448>; else goto <D.17450>;
  <D.17450>:
  {
    int ret;

    D.18391 = &domain->lock.mutex;
    ret = pthread_mutex_unlock (D.18391);
    if (ret != 0) goto <D.18413>; else goto <D.18414>;
    <D.18413>:
    monoeg_g_log (0B, 16, "Bad call to mono_mutex_unlock result %d", ret);
    <D.18414>:
    D.18415 = ret != 0;
    D.18416 = (long int) D.18415;
    D.18417 = __builtin_expect (D.18416, 0);
    if (D.18417 != 0) goto <D.18418>; else goto <D.18419>;
    <D.18418>:
    monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "domain.c", 252, "ret == 0");
    <D.18419>:
  }
  monoeg_g_free (table);
}


jit_info_table_chunk_overflow (struct MonoJitInfoTable * table, struct MonoJitInfoTableChunk * chunk)
{
  int D.18422;
  int D.18423;
  int D.18425;
  int D.18426;
  struct MonoJitInfoTable * D.18427;
  struct MonoJitInfo * D.18428;
  struct MonoMethod * D.18429;
  int D.18432;
  int num_elements;
  int i;

  num_elements = jit_info_table_num_elements (table);
  D.18422 = table->num_chunks;
  D.18423 = D.18422 * 32;
  if (D.18423 > num_elements) goto <D.18420>; else goto <D.18424>;
  <D.18424>:
  D.18422 = table->num_chunks;
  D.18425 = D.18422 * 320;
  D.18426 = D.18425 / 6;
  if (D.18426 < num_elements) goto <D.18420>; else goto <D.18421>;
  <D.18420>:
  D.18427 = jit_info_table_realloc (table);
  return D.18427;
  <D.18421>:
  num_elements = 0;
  i = 0;
  goto <D.17591>;
  <D.17590>:
  D.18428 = chunk->data[i];
  D.18429 = D.18428->d.method;
  if (D.18429 != 0B) goto <D.18430>; else goto <D.18431>;
  <D.18430>:
  num_elements = num_elements + 1;
  <D.18431>:
  i = i + 1;
  <D.17591>:
  D.18432 = chunk->num_elements;
  if (D.18432 > i) goto <D.17590>; else goto <D.17592>;
  <D.17592>:
  if (num_elements == 64) goto <D.18433>; else goto <D.18434>;
  <D.18433>:
  D.18427 = jit_info_table_copy_and_split_chunk (table, chunk);
  return D.18427;
  <D.18434>:
  D.18427 = jit_info_table_copy_and_purify_chunk (table, chunk);
  return D.18427;
}


jit_info_table_num_elements (struct MonoJitInfoTable * table)
{
  struct MonoJitInfo * D.18436;
  struct MonoMethod * D.18437;
  int D.18440;
  int D.18441;
  int i;
  int num_elements;

  num_elements = 0;
  i = 0;
  goto <D.17419>;
  <D.17418>:
  {
    struct MonoJitInfoTableChunk * chunk;
    int chunk_num_elements;
    int j;

    chunk = table->chunks[i];
    chunk_num_elements = chunk->num_elements;
    j = 0;
    goto <D.17416>;
    <D.17415>:
    D.18436 = chunk->data[j];
    D.18437 = D.18436->d.method;
    if (D.18437 != 0B) goto <D.18438>; else goto <D.18439>;
    <D.18438>:
    num_elements = num_elements + 1;
    <D.18439>:
    j = j + 1;
    <D.17416>:
    if (j < chunk_num_elements) goto <D.17415>; else goto <D.17417>;
    <D.17417>:
  }
  i = i + 1;
  <D.17419>:
  D.18440 = table->num_chunks;
  if (D.18440 > i) goto <D.17418>; else goto <D.17420>;
  <D.17420>:
  D.18441 = num_elements;
  return D.18441;
}


jit_info_table_realloc (struct MonoJitInfoTable * old)
{
  long int D.18443;
  int D.18444;
  _Bool D.18447;
  long int D.18448;
  long int D.18449;
  struct MonoJitInfoTable * D.18452;
  struct MonoDomain * D.18453;
  _Bool D.18454;
  long int D.18455;
  long int D.18456;
  unsigned int num_chunks.2;
  unsigned int D.18460;
  unsigned int D.18461;
  struct MonoJitInfoTableChunk * D.18462;
  struct MonoJitInfo * D.18463;
  struct MonoMethod * D.18464;
  _Bool D.18467;
  long int D.18468;
  long int D.18469;
  struct MonoJitInfoTableChunk * D.18472;
  struct MonoJitInfo * D.18473;
  int D.18476;
  int D.18479;
  _Bool D.18480;
  long int D.18481;
  long int D.18482;
  int D.18485;
  _Bool D.18486;
  long int D.18487;
  long int D.18488;
  int D.18491;
  int D.18492;
  struct MonoJitInfoTableChunk * D.18493;
  void * D.18494;
  int D.18495;
  sizetype D.18496;
  volatile gint8 * D.18497;
  int i;
  int num_elements;
  int required_size;
  int num_chunks;
  int new_chunk;
  int new_element;
  struct MonoJitInfoTable * new;

  num_elements = jit_info_table_num_elements (old);
  D.18443 = num_elements * 4;
  required_size = D.18443 / 3;
  D.18444 = required_size + 63;
  num_chunks = D.18444 / 64;
  if (num_chunks == 0) goto <D.18445>; else goto <D.18446>;
  <D.18445>:
  D.18447 = num_elements != 0;
  D.18448 = (long int) D.18447;
  D.18449 = __builtin_expect (D.18448, 0);
  if (D.18449 != 0) goto <D.18450>; else goto <D.18451>;
  <D.18450>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "domain.c", 480, "num_elements == 0");
  <D.18451>:
  D.18453 = old->domain;
  D.18452 = jit_info_table_new (D.18453);
  return D.18452;
  <D.18446>:
  D.18454 = num_chunks <= 0;
  D.18455 = (long int) D.18454;
  D.18456 = __builtin_expect (D.18455, 0);
  if (D.18456 != 0) goto <D.18457>; else goto <D.18458>;
  <D.18457>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "domain.c", 483, "num_chunks > 0");
  <D.18458>:
  num_chunks.2 = (unsigned int) num_chunks;
  D.18460 = num_chunks.2 + 2;
  D.18461 = D.18460 * 4;
  new = monoeg_malloc (D.18461);
  D.18453 = old->domain;
  new->domain = D.18453;
  new->num_chunks = num_chunks;
  i = 0;
  goto <D.17532>;
  <D.17531>:
  D.18462 = jit_info_table_new_chunk ();
  new->chunks[i] = D.18462;
  i = i + 1;
  <D.17532>:
  if (i < num_chunks) goto <D.17531>; else goto <D.17533>;
  <D.17533>:
  new_chunk = 0;
  new_element = 0;
  i = 0;
  goto <D.17541>;
  <D.17540>:
  {
    struct MonoJitInfoTableChunk * chunk;
    int chunk_num_elements;
    int j;

    chunk = old->chunks[i];
    chunk_num_elements = chunk->num_elements;
    j = 0;
    goto <D.17538>;
    <D.17537>:
    D.18463 = chunk->data[j];
    D.18464 = D.18463->d.method;
    if (D.18464 != 0B) goto <D.18465>; else goto <D.18466>;
    <D.18465>:
    D.18467 = new_chunk >= num_chunks;
    D.18468 = (long int) D.18467;
    D.18469 = __builtin_expect (D.18468, 0);
    if (D.18469 != 0) goto <D.18470>; else goto <D.18471>;
    <D.18470>:
    monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "domain.c", 501, "new_chunk < num_chunks");
    <D.18471>:
    D.18472 = new->chunks[new_chunk];
    D.18473 = chunk->data[j];
    D.18472->data[new_element] = D.18473;
    new_element = new_element + 1;
    if (new_element > 47) goto <D.18474>; else goto <D.18475>;
    <D.18474>:
    D.18472 = new->chunks[new_chunk];
    D.18472->num_elements = new_element;
    new_chunk = new_chunk + 1;
    new_element = 0;
    <D.18475>:
    <D.18466>:
    j = j + 1;
    <D.17538>:
    if (j < chunk_num_elements) goto <D.17537>; else goto <D.17539>;
    <D.17539>:
  }
  i = i + 1;
  <D.17541>:
  D.18476 = old->num_chunks;
  if (D.18476 > i) goto <D.17540>; else goto <D.17542>;
  <D.17542>:
  if (new_chunk < num_chunks) goto <D.18477>; else goto <D.18478>;
  <D.18477>:
  D.18479 = num_chunks + -1;
  D.18480 = D.18479 != new_chunk;
  D.18481 = (long int) D.18480;
  D.18482 = __builtin_expect (D.18481, 0);
  if (D.18482 != 0) goto <D.18483>; else goto <D.18484>;
  <D.18483>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "domain.c", 513, "new_chunk == num_chunks - 1");
  <D.18484>:
  D.18472 = new->chunks[new_chunk];
  D.18472->num_elements = new_element;
  D.18472 = new->chunks[new_chunk];
  D.18485 = D.18472->num_elements;
  D.18486 = D.18485 <= 0;
  D.18487 = (long int) D.18486;
  D.18488 = __builtin_expect (D.18487, 0);
  if (D.18488 != 0) goto <D.18489>; else goto <D.18490>;
  <D.18489>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "domain.c", 515, "new->chunks [new_chunk]->num_elements > 0");
  <D.18490>:
  <D.18478>:
  i = 0;
  goto <D.17546>;
  <D.17545>:
  {
    struct MonoJitInfoTableChunk * chunk;
    struct MonoJitInfo * ji;

    chunk = new->chunks[i];
    D.18491 = chunk->num_elements;
    D.18492 = D.18491 + -1;
    ji = chunk->data[D.18492];
    D.18493 = new->chunks[i];
    D.18494 = ji->code_start;
    D.18495 = ji->code_size;
    D.18496 = (sizetype) D.18495;
    D.18497 = D.18494 + D.18496;
    D.18493->last_code_end = D.18497;
  }
  i = i + 1;
  <D.17546>:
  if (i < num_chunks) goto <D.17545>; else goto <D.17547>;
  <D.17547>:
  D.18452 = new;
  return D.18452;
}


jit_info_table_new (struct MonoDomain * domain)
{
  struct MonoJitInfoTableChunk * D.18499;
  struct MonoJitInfoTable * D.18500;
  struct MonoJitInfoTable * table;

  table = monoeg_malloc0 (12);
  table->domain = domain;
  table->num_chunks = 1;
  D.18499 = jit_info_table_new_chunk ();
  table->chunks[0] = D.18499;
  D.18500 = table;
  return D.18500;
}


jit_info_table_new_chunk ()
{
  struct MonoJitInfoTableChunk * D.18502;
  struct MonoJitInfoTableChunk * chunk;

  chunk = monoeg_malloc0 (268);
  chunk->refcount = 1;
  D.18502 = chunk;
  return D.18502;
}


jit_info_table_copy_and_split_chunk (struct MonoJitInfoTable * table, struct MonoJitInfoTableChunk * chunk)
{
  int D.18504;
  unsigned int D.18505;
  unsigned int D.18506;
  unsigned int D.18507;
  struct MonoDomain * D.18508;
  int D.18509;
  struct MonoJitInfoTableChunk * D.18510;
  int D.18513;
  struct MonoJitInfoTableChunk * * D.18514;
  struct MonoJitInfoTableChunk * * D.18515;
  struct MonoJitInfoTableChunk * D.18517;
  int D.18518;
  int D.18519;
  int D.18520;
  _Bool D.18521;
  long int D.18522;
  long int D.18523;
  struct MonoJitInfoTable * D.18526;
  struct MonoJitInfoTable * new_table;
  int i;
  int j;

  D.18504 = table->num_chunks;
  D.18505 = (unsigned int) D.18504;
  D.18506 = D.18505 + 3;
  D.18507 = D.18506 * 4;
  new_table = monoeg_malloc (D.18507);
  D.18508 = table->domain;
  new_table->domain = D.18508;
  D.18504 = table->num_chunks;
  D.18509 = D.18504 + 1;
  new_table->num_chunks = D.18509;
  j = 0;
  i = 0;
  goto <D.17563>;
  <D.17562>:
  D.18510 = table->chunks[i];
  if (D.18510 == chunk) goto <D.18511>; else goto <D.18512>;
  <D.18511>:
  D.18513 = j + 1;
  D.18514 = &new_table->chunks[D.18513];
  D.18515 = &new_table->chunks[j];
  jit_info_table_split_chunk (chunk, D.18515, D.18514);
  j = j + 2;
  goto <D.18516>;
  <D.18512>:
  D.18510 = table->chunks[i];
  new_table->chunks[j] = D.18510;
  D.18517 = new_table->chunks[j];
  D.18518 = D.18517->refcount;
  D.18519 = D.18518 + 1;
  D.18517->refcount = D.18519;
  j = j + 1;
  <D.18516>:
  i = i + 1;
  <D.17563>:
  D.18504 = table->num_chunks;
  if (D.18504 > i) goto <D.17562>; else goto <D.17564>;
  <D.17564>:
  D.18520 = new_table->num_chunks;
  D.18521 = D.18520 != j;
  D.18522 = (long int) D.18521;
  D.18523 = __builtin_expect (D.18522, 0);
  if (D.18523 != 0) goto <D.18524>; else goto <D.18525>;
  <D.18524>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "domain.c", 573, "j == new_table->num_chunks");
  <D.18525>:
  D.18526 = new_table;
  return D.18526;
}


jit_info_table_split_chunk (struct MonoJitInfoTableChunk * chunk, struct MonoJitInfoTableChunk * * new1p, struct MonoJitInfoTableChunk * * new2p)
{
  int D.18528;
  _Bool D.18529;
  long int D.18530;
  long int D.18531;
  int D.18534;
  int D.18535;
  int D.18536;
  unsigned int D.18537;
  unsigned int D.18538;
  struct MonoJitInfo * volatile[64] * D.18539;
  struct MonoJitInfo * volatile[64] * D.18540;
  int D.18541;
  unsigned int D.18542;
  unsigned int D.18543;
  int D.18544;
  sizetype D.18545;
  struct MonoJitInfo * volatile * D.18546;
  struct MonoJitInfo * volatile[64] * D.18547;
  int D.18548;
  int D.18549;
  struct MonoJitInfo * D.18550;
  void * D.18551;
  int D.18552;
  int D.18553;
  struct MonoJitInfo * D.18554;
  int D.18555;
  sizetype D.18556;
  volatile gint8 * D.18557;
  int D.18558;
  int D.18559;
  struct MonoJitInfo * D.18560;
  void * D.18561;
  int D.18562;
  int D.18563;
  struct MonoJitInfo * D.18564;
  int D.18565;
  sizetype D.18566;
  volatile gint8 * D.18567;
  struct MonoJitInfoTableChunk * new1;
  struct MonoJitInfoTableChunk * new2;

  new1 = jit_info_table_new_chunk ();
  new2 = jit_info_table_new_chunk ();
  D.18528 = chunk->num_elements;
  D.18529 = D.18528 != 64;
  D.18530 = (long int) D.18529;
  D.18531 = __builtin_expect (D.18530, 0);
  if (D.18531 != 0) goto <D.18532>; else goto <D.18533>;
  <D.18532>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "domain.c", 534, "chunk->num_elements == MONO_JIT_INFO_TABLE_CHUNK_SIZE");
  <D.18533>:
  new1->num_elements = 32;
  D.18534 = new1->num_elements;
  D.18535 = 64 - D.18534;
  new2->num_elements = D.18535;
  D.18536 = new1->num_elements;
  D.18537 = (unsigned int) D.18536;
  D.18538 = D.18537 * 4;
  D.18539 = &chunk->data;
  D.18540 = &new1->data;
  memcpy (D.18540, D.18539, D.18538);
  D.18541 = new2->num_elements;
  D.18542 = (unsigned int) D.18541;
  D.18543 = D.18542 * 4;
  D.18544 = new1->num_elements;
  D.18545 = (sizetype) D.18544;
  D.18546 = &chunk->data[D.18545];
  D.18547 = &new2->data;
  memcpy (D.18547, D.18546, D.18543);
  D.18548 = new1->num_elements;
  D.18549 = D.18548 + -1;
  D.18550 = new1->data[D.18549];
  D.18551 = D.18550->code_start;
  D.18552 = new1->num_elements;
  D.18553 = D.18552 + -1;
  D.18554 = new1->data[D.18553];
  D.18555 = D.18554->code_size;
  D.18556 = (sizetype) D.18555;
  D.18557 = D.18551 + D.18556;
  new1->last_code_end = D.18557;
  D.18558 = new2->num_elements;
  D.18559 = D.18558 + -1;
  D.18560 = new2->data[D.18559];
  D.18561 = D.18560->code_start;
  D.18562 = new2->num_elements;
  D.18563 = D.18562 + -1;
  D.18564 = new2->data[D.18563];
  D.18565 = D.18564->code_size;
  D.18566 = (sizetype) D.18565;
  D.18567 = D.18561 + D.18566;
  new2->last_code_end = D.18567;
  *new1p = new1;
  *new2p = new2;
}


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

  D.18569 = __builtin_object_size (__dest, 0);
  D.18568 = __builtin___memcpy_chk (__dest, __src, __len, D.18569);
  return D.18568;
}


jit_info_table_copy_and_purify_chunk (struct MonoJitInfoTable * table, struct MonoJitInfoTableChunk * chunk)
{
  int D.18571;
  unsigned int D.18572;
  unsigned int D.18573;
  unsigned int D.18574;
  struct MonoDomain * D.18575;
  struct MonoJitInfoTableChunk * D.18576;
  int j.3;
  struct MonoJitInfoTableChunk * D.18580;
  struct MonoJitInfoTableChunk * D.18582;
  int D.18583;
  int D.18584;
  int D.18585;
  _Bool D.18586;
  long int D.18587;
  long int D.18588;
  struct MonoJitInfoTable * D.18591;
  struct MonoJitInfoTable * new_table;
  int i;
  int j;

  D.18571 = table->num_chunks;
  D.18572 = (unsigned int) D.18571;
  D.18573 = D.18572 + 2;
  D.18574 = D.18573 * 4;
  new_table = monoeg_malloc (D.18574);
  D.18575 = table->domain;
  new_table->domain = D.18575;
  D.18571 = table->num_chunks;
  new_table->num_chunks = D.18571;
  j = 0;
  i = 0;
  goto <D.17582>;
  <D.17581>:
  D.18576 = table->chunks[i];
  if (D.18576 == chunk) goto <D.18577>; else goto <D.18578>;
  <D.18577>:
  j.3 = j;
  j = j.3 + 1;
  D.18576 = table->chunks[i];
  D.18580 = jit_info_table_purify_chunk (D.18576);
  new_table->chunks[j.3] = D.18580;
  goto <D.18581>;
  <D.18578>:
  D.18576 = table->chunks[i];
  new_table->chunks[j] = D.18576;
  D.18582 = new_table->chunks[j];
  D.18583 = D.18582->refcount;
  D.18584 = D.18583 + 1;
  D.18582->refcount = D.18584;
  j = j + 1;
  <D.18581>:
  i = i + 1;
  <D.17582>:
  D.18571 = table->num_chunks;
  if (D.18571 > i) goto <D.17581>; else goto <D.17583>;
  <D.17583>:
  D.18585 = new_table->num_chunks;
  D.18586 = D.18585 != j;
  D.18587 = (long int) D.18586;
  D.18588 = __builtin_expect (D.18587, 0);
  if (D.18588 != 0) goto <D.18589>; else goto <D.18590>;
  <D.18589>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "domain.c", 620, "j == new_table->num_chunks");
  <D.18590>:
  D.18591 = new_table;
  return D.18591;
}


jit_info_table_purify_chunk (struct MonoJitInfoTableChunk * old)
{
  struct MonoJitInfo * D.18593;
  struct MonoMethod * D.18594;
  int j.4;
  struct MonoJitInfo * D.18598;
  int D.18599;
  int D.18600;
  int D.18603;
  struct MonoJitInfo * D.18604;
  void * D.18605;
  struct MonoJitInfo * D.18606;
  int D.18607;
  sizetype D.18608;
  volatile gint8 * D.18609;
  volatile gint8 * D.18611;
  struct MonoJitInfoTableChunk * D.18612;
  struct MonoJitInfoTableChunk * new;
  int i;
  int j;

  new = jit_info_table_new_chunk ();
  j = 0;
  i = 0;
  goto <D.17572>;
  <D.17571>:
  D.18593 = old->data[i];
  D.18594 = D.18593->d.method;
  if (D.18594 != 0B) goto <D.18595>; else goto <D.18596>;
  <D.18595>:
  j.4 = j;
  j = j.4 + 1;
  D.18598 = old->data[i];
  new->data[j.4] = D.18598;
  <D.18596>:
  i = i + 1;
  <D.17572>:
  D.18599 = old->num_elements;
  if (D.18599 > i) goto <D.17571>; else goto <D.17573>;
  <D.17573>:
  new->num_elements = j;
  D.18600 = new->num_elements;
  if (D.18600 > 0) goto <D.18601>; else goto <D.18602>;
  <D.18601>:
  D.18603 = j + -1;
  D.18604 = new->data[D.18603];
  D.18605 = D.18604->code_start;
  D.18603 = j + -1;
  D.18606 = new->data[D.18603];
  D.18607 = D.18606->code_size;
  D.18608 = (sizetype) D.18607;
  D.18609 = D.18605 + D.18608;
  new->last_code_end = D.18609;
  goto <D.18610>;
  <D.18602>:
  D.18611 = old->last_code_end;
  new->last_code_end = D.18611;
  <D.18610>:
  D.18612 = new;
  return D.18612;
}


mono_memory_barrier ()
{
  __sync_synchronize ();
}


mono_memory_write_barrier ()
{
  mono_memory_barrier ();
}


mono_jit_info_table_remove (struct MonoDomain * domain, struct MonoJitInfo * ji)
{
  union mono_mutex_t * D.18614;
  _Bool D.18617;
  long int D.18618;
  long int D.18619;
  long unsigned int D.18622;
  long unsigned int D.18623;
  _Bool D.18626;
  long int D.18627;
  long int D.18628;
  struct MonoJitInfoTable * table;

  {
    int ret;

    D.18614 = &domain->lock.mutex;
    ret = pthread_mutex_lock (D.18614);
    if (ret != 0) goto <D.18615>; else goto <D.18616>;
    <D.18615>:
    monoeg_g_log (0B, 16, "Bad call to mono_mutex_lock result %d", ret);
    <D.18616>:
    D.18617 = ret != 0;
    D.18618 = (long int) D.18617;
    D.18619 = __builtin_expect (D.18618, 0);
    if (D.18619 != 0) goto <D.18620>; else goto <D.18621>;
    <D.18620>:
    monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "domain.c", 831, "ret == 0");
    <D.18621>:
  }
  table = domain->jit_info_table;
  D.18622 = mono_stats.jit_info_table_remove_count;
  D.18623 = D.18622 + 1;
  mono_stats.jit_info_table_remove_count = D.18623;
  jit_info_table_remove (table, ji);
  mono_jit_info_free_or_queue (domain, ji);
  {
    int ret;

    D.18614 = &domain->lock.mutex;
    ret = pthread_mutex_unlock (D.18614);
    if (ret != 0) goto <D.18624>; else goto <D.18625>;
    <D.18624>:
    monoeg_g_log (0B, 16, "Bad call to mono_mutex_unlock result %d", ret);
    <D.18625>:
    D.18626 = ret != 0;
    D.18627 = (long int) D.18626;
    D.18628 = __builtin_expect (D.18627, 0);
    if (D.18628 != 0) goto <D.18629>; else goto <D.18630>;
    <D.18629>:
    monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "domain.c", 840, "ret == 0");
    <D.18630>:
  }
}


jit_info_table_remove (struct MonoJitInfoTable * table, struct MonoJitInfo * ji)
{
  int D.18631;
  _Bool D.18632;
  long int D.18633;
  long int D.18634;
  struct MonoJitInfoTableChunk * D.18637;
  struct MonoJitInfo * D.18638;
  struct MonoJitInfo * D.18640;
  struct MonoMethod * D.18641;
  _Bool D.18642;
  long int D.18643;
  long int D.18644;
  struct MonoJitInfo * D.18647;
  void * D.18648;
  struct MonoJitInfo * D.18649;
  int D.18650;
  sizetype D.18651;
  guint8 * D.18652;
  void * D.18653;
  int D.18654;
  sizetype D.18655;
  guint8 * D.18656;
  _Bool D.18657;
  long int D.18658;
  long int D.18659;
  int D.18662;
  struct MonoJitInfo * D.18663;
  _Bool D.18664;
  long int D.18665;
  long int D.18666;
  struct MonoJitInfo * D.18669;
  struct MonoJitInfoTableChunk * chunk;
  void * start;
  int chunk_pos;
  int pos;
  void found = <<< error >>>;

  start = ji->code_start;
  chunk_pos = jit_info_table_index (table, start);
  D.18631 = table->num_chunks;
  D.18632 = D.18631 <= chunk_pos;
  D.18633 = (long int) D.18632;
  D.18634 = __builtin_expect (D.18633, 0);
  if (D.18634 != 0) goto <D.18635>; else goto <D.18636>;
  <D.18635>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "domain.c", 795, "chunk_pos < table->num_chunks");
  <D.18636>:
  D.18637 = table->chunks[chunk_pos];
  pos = jit_info_table_chunk_index (D.18637, 0B, start);
  <D.17635>:
  chunk = table->chunks[chunk_pos];
  goto <D.17633>;
  <D.17632>:
  D.18638 = chunk->data[pos];
  if (D.18638 == ji) goto found; else goto <D.18639>;
  <D.18639>:
  D.18640 = chunk->data[pos];
  D.18641 = D.18640->d.method;
  D.18642 = D.18641 != 0B;
  D.18643 = (long int) D.18642;
  D.18644 = __builtin_expect (D.18643, 0);
  if (D.18644 != 0) goto <D.18645>; else goto <D.18646>;
  <D.18645>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "domain.c", 806, "IS_JIT_INFO_TOMBSTONE (chunk->data [pos])");
  <D.18646>:
  D.18647 = chunk->data[pos];
  D.18648 = D.18647->code_start;
  D.18649 = chunk->data[pos];
  D.18650 = D.18649->code_size;
  D.18651 = (sizetype) D.18650;
  D.18652 = D.18648 + D.18651;
  D.18653 = ji->code_start;
  D.18654 = ji->code_size;
  D.18655 = (sizetype) D.18654;
  D.18656 = D.18653 + D.18655;
  D.18657 = D.18652 > D.18656;
  D.18658 = (long int) D.18657;
  D.18659 = __builtin_expect (D.18658, 0);
  if (D.18659 != 0) goto <D.18660>; else goto <D.18661>;
  <D.18660>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "domain.c", 808, "(guint8*)chunk->data [pos]->code_start + chunk->data [pos]->code_size <= (guint8*)ji->code_start + ji->code_size");
  <D.18661>:
  pos = pos + 1;
  <D.17633>:
  D.18662 = chunk->num_elements;
  if (D.18662 > pos) goto <D.17632>; else goto <D.17634>;
  <D.17634>:
  chunk_pos = chunk_pos + 1;
  pos = 0;
  D.18631 = table->num_chunks;
  if (D.18631 > chunk_pos) goto <D.17635>; else goto <D.17636>;
  <D.17636>:
  found:
  D.18663 = chunk->data[pos];
  D.18664 = D.18663 != ji;
  D.18665 = (long int) D.18664;
  D.18666 = __builtin_expect (D.18665, 0);
  if (D.18666 != 0) goto <D.18667>; else goto <D.18668>;
  <D.18667>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "domain.c", 818, "chunk->data [pos] == ji");
  <D.18668>:
  D.18669 = mono_jit_info_make_tombstone (ji);
  chunk->data[pos] = D.18669;
}


mono_jit_info_make_tombstone (struct MonoJitInfo * ji)
{
  void * D.18670;
  int D.18671;
  struct MonoJitInfo * D.18672;
  struct MonoJitInfo * tombstone;

  tombstone = monoeg_malloc0 (28);
  D.18670 = ji->code_start;
  tombstone->code_start = D.18670;
  D.18671 = ji->code_size;
  tombstone->code_size = D.18671;
  tombstone->d.method = 0B;
  D.18672 = tombstone;
  return D.18672;
}


mono_jit_info_free_or_queue (struct MonoDomain * domain, struct MonoJitInfo * ji)
{
  int D.18674;
  struct GSList * D.18678;
  struct GSList * D.18679;

  D.18674 = domain->num_jit_info_tables;
  if (D.18674 <= 1) goto <D.18675>; else goto <D.18676>;
  <D.18675>:
  mono_thread_hazardous_free_or_queue (ji, monoeg_g_free, 1, 0);
  goto <D.18677>;
  <D.18676>:
  D.18678 = domain->jit_info_free_queue;
  D.18679 = monoeg_g_slist_prepend (D.18678, ji);
  domain->jit_info_free_queue = D.18679;
  <D.18677>:
}


mono_jit_info_add_aot_module (struct MonoImage * image, void * start, void * end)
{
  _Bool D.18682;
  long int D.18683;
  long int D.18684;
  struct MonoDomain * mono_root_domain.5;
  _Bool D.18688;
  long int D.18689;
  long int D.18690;
  struct MonoJitInfoTable * D.18693;
  int D.18696;
  int D.18697;
  struct MonoJitInfoTable * D.18698;
  int end.6;
  int start.7;
  int D.18701;
  struct MonoJitInfoTable * volatile * D.18702;
  _Bool D.18705;
  long int D.18706;
  long int D.18707;
  struct MonoJitInfo * ji;

  {
    int ret;

    ret = pthread_mutex_lock (&appdomains_mutex.mutex);
    if (ret != 0) goto <D.18680>; else goto <D.18681>;
    <D.18680>:
    monoeg_g_log (0B, 16, "Bad call to mono_mutex_lock result %d", ret);
    <D.18681>:
    D.18682 = ret != 0;
    D.18683 = (long int) D.18682;
    D.18684 = __builtin_expect (D.18683, 0);
    if (D.18684 != 0) goto <D.18685>; else goto <D.18686>;
    <D.18685>:
    monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "domain.c", 848, "ret == 0");
    <D.18686>:
  }
  mono_root_domain.5 = mono_root_domain;
  D.18688 = mono_root_domain.5 == 0B;
  D.18689 = (long int) D.18688;
  D.18690 = __builtin_expect (D.18689, 0);
  if (D.18690 != 0) goto <D.18691>; else goto <D.18692>;
  <D.18691>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "domain.c", 854, "mono_root_domain");
  <D.18692>:
  mono_root_domain.5 = mono_root_domain;
  D.18693 = mono_root_domain.5->aot_modules;
  if (D.18693 == 0B) goto <D.18694>; else goto <D.18695>;
  <D.18694>:
  mono_root_domain.5 = mono_root_domain;
  D.18696 = mono_root_domain.5->num_jit_info_tables;
  D.18697 = D.18696 + 1;
  mono_root_domain.5->num_jit_info_tables = D.18697;
  mono_root_domain.5 = mono_root_domain;
  mono_root_domain.5 = mono_root_domain;
  D.18698 = jit_info_table_new (mono_root_domain.5);
  mono_root_domain.5->aot_modules = D.18698;
  <D.18695>:
  ji = monoeg_malloc0 (28);
  ji->d.image = image;
  ji->code_start = start;
  end.6 = (int) end;
  start.7 = (int) start;
  D.18701 = end.6 - start.7;
  ji->code_size = D.18701;
  mono_root_domain.5 = mono_root_domain;
  D.18702 = &mono_root_domain.5->aot_modules;
  mono_root_domain.5 = mono_root_domain;
  jit_info_table_add (mono_root_domain.5, D.18702, ji);
  {
    int ret;

    ret = pthread_mutex_unlock (&appdomains_mutex.mutex);
    if (ret != 0) goto <D.18703>; else goto <D.18704>;
    <D.18703>:
    monoeg_g_log (0B, 16, "Bad call to mono_mutex_unlock result %d", ret);
    <D.18704>:
    D.18705 = ret != 0;
    D.18706 = (long int) D.18705;
    D.18707 = __builtin_expect (D.18706, 0);
    if (D.18707 != 0) goto <D.18708>; else goto <D.18709>;
    <D.18708>:
    monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "domain.c", 866, "ret == 0");
    <D.18709>:
  }
}


mono_install_jit_info_find_in_aot (struct MonoJitInfo * (*MonoJitInfoFindInAot) (struct MonoDomain *, struct MonoImage *, void *) func)
{
  jit_info_find_in_aot_func = func;
}


mono_jit_info_get_code_start (struct MonoJitInfo * ji)
{
  void * D.18710;

  D.18710 = ji->code_start;
  return D.18710;
}


mono_jit_info_get_code_size (struct MonoJitInfo * ji)
{
  int D.18712;

  D.18712 = ji->code_size;
  return D.18712;
}


mono_jit_info_get_method (struct MonoJitInfo * ji)
{
  unsigned char D.18714;
  unsigned char D.18715;
  _Bool D.18716;
  long int D.18717;
  long int D.18718;
  struct MonoMethod * D.18721;

  D.18714 = BIT_FIELD_REF <*ji, 8, 184>;
  D.18715 = D.18714 & 1;
  D.18716 = D.18715 != 0;
  D.18717 = (long int) D.18716;
  D.18718 = __builtin_expect (D.18717, 0);
  if (D.18718 != 0) goto <D.18719>; else goto <D.18720>;
  <D.18719>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "domain.c", 890, "!ji->async");
  <D.18720>:
  D.18721 = ji->d.method;
  return D.18721;
}


mono_jit_code_hash_init (struct MonoInternalHashTable * jit_code_hash)
{
  mono_internal_hash_table_init (jit_code_hash, mono_aligned_addr_hash, jit_info_key_extract, jit_info_next_value);
}


jit_info_next_value (void * value)
{
  void * * D.18723;
  struct MonoJitInfo * info;

  info = value;
  D.18723 = &info->next_jit_code_hash;
  return D.18723;
}


jit_info_key_extract (void * value)
{
  void * D.18725;
  struct MonoJitInfo * info;

  info = value;
  D.18725 = info->d.method;
  return D.18725;
}


mono_jit_info_get_generic_jit_info (struct MonoJitInfo * ji)
{
  unsigned char D.18727;
  unsigned char D.18728;
  struct MonoGenericJitInfo * D.18731;
  <unnamed-unsigned:15> D.18732;
  int D.18733;

  D.18727 = BIT_FIELD_REF <*ji, 8, 176>;
  D.18728 = D.18727 & 2;
  if (D.18728 != 0) goto <D.18729>; else goto <D.18730>;
  <D.18729>:
  D.18732 = ji->num_clauses;
  D.18733 = (int) D.18732;
  D.18731 = &ji->clauses[D.18733];
  return D.18731;
  <D.18730>:
  D.18731 = 0B;
  return D.18731;
}


mono_jit_info_get_generic_sharing_context (struct MonoJitInfo * ji)
{
  struct MonoGenericSharingContext * D.18737;
  struct MonoGenericJitInfo * gi;

  gi = mono_jit_info_get_generic_jit_info (ji);
  if (gi != 0B) goto <D.18735>; else goto <D.18736>;
  <D.18735>:
  D.18737 = gi->generic_sharing_context;
  return D.18737;
  <D.18736>:
  D.18737 = 0B;
  return D.18737;
}


mono_jit_info_set_generic_sharing_context (struct MonoJitInfo * ji, struct MonoGenericSharingContext * gsctx)
{
  _Bool D.18739;
  long int D.18740;
  long int D.18741;
  struct MonoGenericJitInfo * gi;

  gi = mono_jit_info_get_generic_jit_info (ji);
  D.18739 = gi == 0B;
  D.18740 = (long int) D.18739;
  D.18741 = __builtin_expect (D.18740, 0);
  if (D.18741 != 0) goto <D.18742>; else goto <D.18743>;
  <D.18742>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "domain.c", 959, "gi");
  <D.18743>:
  gi->generic_sharing_context = gsctx;
}


mono_jit_info_get_try_block_hole_table_info (struct MonoJitInfo * ji)
{
  unsigned char D.18744;
  unsigned char D.18745;
  <unnamed-unsigned:15> D.18748;
  int D.18749;
  unsigned char D.18750;
  struct MonoTryBlockHoleTableJitInfo * D.18753;

  D.18744 = BIT_FIELD_REF <*ji, 8, 176>;
  D.18745 = D.18744 & 4;
  if (D.18745 != 0) goto <D.18746>; else goto <D.18747>;
  <D.18746>:
  {
    char * ptr;

    D.18748 = ji->num_clauses;
    D.18749 = (int) D.18748;
    ptr = &ji->clauses[D.18749];
    D.18744 = BIT_FIELD_REF <*ji, 8, 176>;
    D.18750 = D.18744 & 2;
    if (D.18750 != 0) goto <D.18751>; else goto <D.18752>;
    <D.18751>:
    ptr = ptr + 20;
    <D.18752>:
    D.18753 = ptr;
    return D.18753;
  }
  <D.18747>:
  D.18753 = 0B;
  return D.18753;
}


mono_jit_info_get_arch_eh_info (struct MonoJitInfo * ji)
{
  unsigned char D.18755;
  unsigned char D.18756;
  <unnamed-unsigned:15> D.18759;
  int D.18760;
  unsigned char D.18761;
  unsigned char D.18764;
  struct MonoArchEHJitInfo * D.18767;

  D.18755 = BIT_FIELD_REF <*ji, 8, 176>;
  D.18756 = D.18755 & 8;
  if (D.18756 != 0) goto <D.18757>; else goto <D.18758>;
  <D.18757>:
  {
    char * ptr;

    D.18759 = ji->num_clauses;
    D.18760 = (int) D.18759;
    ptr = &ji->clauses[D.18760];
    D.18755 = BIT_FIELD_REF <*ji, 8, 176>;
    D.18761 = D.18755 & 2;
    if (D.18761 != 0) goto <D.18762>; else goto <D.18763>;
    <D.18762>:
    ptr = ptr + 20;
    <D.18763>:
    D.18755 = BIT_FIELD_REF <*ji, 8, 176>;
    D.18764 = D.18755 & 4;
    if (D.18764 != 0) goto <D.18765>; else goto <D.18766>;
    <D.18765>:
    ptr = ptr + 4;
    <D.18766>:
    D.18767 = ptr;
    return D.18767;
  }
  <D.18758>:
  D.18767 = 0B;
  return D.18767;
}


mono_jit_info_get_cas_info (struct MonoJitInfo * ji)
{
  unsigned char D.18769;
  unsigned char D.18770;
  <unnamed-unsigned:15> D.18773;
  int D.18774;
  unsigned char D.18775;
  unsigned char D.18778;
  unsigned char D.18781;
  struct MonoMethodCasInfo * D.18784;

  D.18769 = BIT_FIELD_REF <*ji, 8, 176>;
  D.18770 = D.18769 & 1;
  if (D.18770 != 0) goto <D.18771>; else goto <D.18772>;
  <D.18771>:
  {
    char * ptr;

    D.18773 = ji->num_clauses;
    D.18774 = (int) D.18773;
    ptr = &ji->clauses[D.18774];
    D.18769 = BIT_FIELD_REF <*ji, 8, 176>;
    D.18775 = D.18769 & 2;
    if (D.18775 != 0) goto <D.18776>; else goto <D.18777>;
    <D.18776>:
    ptr = ptr + 20;
    <D.18777>:
    D.18769 = BIT_FIELD_REF <*ji, 8, 176>;
    D.18778 = D.18769 & 4;
    if (D.18778 != 0) goto <D.18779>; else goto <D.18780>;
    <D.18779>:
    ptr = ptr + 4;
    <D.18780>:
    D.18769 = BIT_FIELD_REF <*ji, 8, 176>;
    D.18781 = D.18769 & 8;
    if (D.18781 != 0) goto <D.18782>; else goto <D.18783>;
    <D.18782>:
    ptr = ptr + 4;
    <D.18783>:
    D.18784 = ptr;
    return D.18784;
  }
  <D.18772>:
  D.18784 = 0B;
  return D.18784;
}


mono_install_create_domain_hook (void (*MonoCreateDomainFunc) (struct MonoDomain *) func)
{
  create_domain_hook = func;
}


mono_install_free_domain_hook (void (*MonoFreeDomainFunc) (struct MonoDomain *) func)
{
  free_domain_hook = func;
}


mono_string_equal (struct MonoString * s1, struct MonoString * s2)
{
  mono_bool D.18788;
  int D.18791;
  unsigned int D.18792;
  mono_unichar2 * D.18793;
  mono_unichar2 * D.18794;
  int D.18795;
  _Bool D.18796;
  int l1;
  int l2;

  l1 = mono_string_length (s1);
  l2 = mono_string_length (s2);
  if (s1 == s2) goto <D.18786>; else goto <D.18787>;
  <D.18786>:
  D.18788 = 1;
  return D.18788;
  <D.18787>:
  if (l1 != l2) goto <D.18789>; else goto <D.18790>;
  <D.18789>:
  D.18788 = 0;
  return D.18788;
  <D.18790>:
  D.18791 = l1 * 2;
  D.18792 = (unsigned int) D.18791;
  D.18793 = mono_string_chars (s2);
  D.18794 = mono_string_chars (s1);
  D.18795 = memcmp (D.18794, D.18793, D.18792);
  D.18796 = D.18795 == 0;
  D.18788 = (mono_bool) D.18796;
  return D.18788;
}


mono_string_hash (struct MonoString * s)
{
  unsigned int D.18798;
  unsigned int D.18799;
  short unsigned int D.18800;
  unsigned int D.18801;
  unsigned int D.18802;
  const guint16 * p;
  int i;
  int len;
  guint h;

  p = mono_string_chars (s);
  len = mono_string_length (s);
  h = 0;
  i = 0;
  goto <D.17749>;
  <D.17748>:
  D.18798 = h << 5;
  D.18799 = D.18798 - h;
  D.18800 = *p;
  D.18801 = (unsigned int) D.18800;
  h = D.18799 + D.18801;
  p = p + 2;
  i = i + 1;
  <D.17749>:
  if (i < len) goto <D.17748>; else goto <D.17750>;
  <D.17750>:
  D.18802 = h;
  return D.18802;
}


mono_domain_create ()
{
  _Bool D.18806;
  long int D.18807;
  long int D.18808;
  unsigned int domain_shadow_serial.8;
  unsigned int domain_shadow_serial.9;
  unsigned int domain_shadow_serial.10;
  void * domain_gc_desc.11;
  unsigned int D.18817;
  unsigned int D.18818;
  int bit.12;
  int D.18820;
  unsigned int D.18821;
  unsigned int D.18822;
  unsigned int D.18823;
  int D.18824;
  void * domain_gc_desc.13;
  _Bool D.18828;
  long int D.18829;
  long int D.18830;
  struct MonoGHashTable * * D.18833;
  int shadow_serial.14;
  struct MonoMemPool * D.18835;
  struct MonoCodeManager * D.18836;
  struct LockFreeMempool * D.18837;
  struct MonoGHashTable * D.18838;
  struct GPtrArray * D.18839;
  struct GHashTable * D.18840;
  struct MonoInternalHashTable * D.18841;
  struct MonoGHashTable * D.18842;
  struct MonoJitInfoTable * D.18843;
  struct GHashTable * D.18844;
  struct GHashTable * D.18845;
  struct CRITICAL_SECTION * D.18846;
  struct CRITICAL_SECTION * D.18847;
  struct CRITICAL_SECTION * D.18848;
  struct CRITICAL_SECTION * D.18849;
  _Bool D.18852;
  long int D.18853;
  long int D.18854;
  _Bool D.18859;
  long int D.18860;
  long int D.18861;
  struct MonoPerfCounters * mono_perfcounters.15;
  unsigned int D.18865;
  unsigned int D.18866;
  unsigned int D.18867;
  unsigned int D.18868;
  void (*<T1923>) (struct MonoDomain *) create_domain_hook.16;
  struct MonoDomain * D.18872;
  struct MonoDomain * domain;
  guint32 shadow_serial;

  {
    int ret;

    ret = pthread_mutex_lock (&appdomains_mutex.mutex);
    if (ret != 0) goto <D.18804>; else goto <D.18805>;
    <D.18804>:
    monoeg_g_log (0B, 16, "Bad call to mono_mutex_lock result %d", ret);
    <D.18805>:
    D.18806 = ret != 0;
    D.18807 = (long int) D.18806;
    D.18808 = __builtin_expect (D.18807, 0);
    if (D.18808 != 0) goto <D.18809>; else goto <D.18810>;
    <D.18809>:
    monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "domain.c", 1234, "ret == 0");
    <D.18810>:
  }
  domain_shadow_serial.8 = domain_shadow_serial;
  domain_shadow_serial.9 = domain_shadow_serial.8;
  domain_shadow_serial.10 = domain_shadow_serial.9 + 1;
  domain_shadow_serial = domain_shadow_serial.10;
  shadow_serial = domain_shadow_serial.9;
  domain_gc_desc.11 = domain_gc_desc;
  if (domain_gc_desc.11 == 0B) goto <D.18815>; else goto <D.18816>;
  <D.18815>:
  {
    unsigned int i;
    unsigned int bit;

    bit = 0;
    i = 36;
    goto <D.17790>;
    <D.17789>:
    bit = i / 4;
    D.18817 = bit / 32;
    D.18818 = domain_gc_bitmap[D.18817];
    bit.12 = (int) bit;
    D.18820 = bit.12 & 31;
    D.18821 = 1 << D.18820;
    D.18822 = D.18818 | D.18821;
    domain_gc_bitmap[D.18817] = D.18822;
    i = i + 4;
    <D.17790>:
    if (i <= 71) goto <D.17789>; else goto <D.17791>;
    <D.17791>:
    D.18823 = bit + 1;
    D.18824 = (int) D.18823;
    domain_gc_desc.13 = mono_gc_make_descr_from_bitmap (&domain_gc_bitmap, D.18824);
    domain_gc_desc = domain_gc_desc.13;
  }
  <D.18816>:
  {
    int ret;

    ret = pthread_mutex_unlock (&appdomains_mutex.mutex);
    if (ret != 0) goto <D.18826>; else goto <D.18827>;
    <D.18826>:
    monoeg_g_log (0B, 16, "Bad call to mono_mutex_unlock result %d", ret);
    <D.18827>:
    D.18828 = ret != 0;
    D.18829 = (long int) D.18828;
    D.18830 = __builtin_expect (D.18829, 0);
    if (D.18830 != 0) goto <D.18831>; else goto <D.18832>;
    <D.18831>:
    monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "domain.c", 1245, "ret == 0");
    <D.18832>:
  }
  domain_gc_desc.11 = domain_gc_desc;
  domain = mono_gc_alloc_fixed (380, domain_gc_desc.11);
  D.18833 = &domain->env;
  mono_gc_register_root (D.18833, 24, 0B);
  shadow_serial.14 = (int) shadow_serial;
  domain->shadow_serial = shadow_serial.14;
  domain->domain = 0B;
  domain->setup = 0B;
  domain->friendly_name = 0B;
  domain->search_path = 0B;
  mono_profiler_appdomain_event (domain, 0);
  D.18835 = mono_mempool_new ();
  domain->mp = D.18835;
  D.18836 = mono_code_manager_new ();
  domain->code_mp = D.18836;
  D.18837 = lock_free_mempool_new ();
  domain->lock_free_mp = D.18837;
  D.18838 = mono_g_hash_table_new_type (mono_string_hash, mono_string_equal, 3);
  domain->env = D.18838;
  domain->domain_assemblies = 0B;
  domain->assembly_bindings = 0B;
  domain->assembly_bindings_parsed = 0;
  D.18839 = monoeg_g_ptr_array_new ();
  domain->class_vtable_array = D.18839;
  D.18840 = monoeg_g_hash_table_new (mono_ptrarray_hash, mono_ptrarray_equal);
  domain->proxy_vtable_hash = D.18840;
  domain->static_data_array = 0B;
  D.18841 = &domain->jit_code_hash;
  mono_jit_code_hash_init (D.18841);
  D.18842 = mono_g_hash_table_new_type (mono_string_hash, mono_string_equal, 3);
  domain->ldstr_table = D.18842;
  domain->num_jit_info_tables = 1;
  D.18843 = jit_info_table_new (domain);
  domain->jit_info_table = D.18843;
  domain->jit_info_free_queue = 0B;
  D.18844 = monoeg_g_hash_table_new (mono_aligned_addr_hash, 0B);
  domain->finalizable_objects_hash = D.18844;
  D.18845 = monoeg_g_hash_table_new (mono_aligned_addr_hash, 0B);
  domain->ftnptrs_hash = D.18845;
  D.18846 = &domain->lock;
  InitializeCriticalSection (D.18846);
  D.18847 = &domain->assemblies_lock;
  InitializeCriticalSection (D.18847);
  D.18848 = &domain->jit_code_hash_lock;
  InitializeCriticalSection (D.18848);
  D.18849 = &domain->finalizable_objects_hash_lock;
  InitializeCriticalSection (D.18849);
  domain->method_rgctx_hash = 0B;
  {
    int ret;

    ret = pthread_mutex_lock (&appdomains_mutex.mutex);
    if (ret != 0) goto <D.18850>; else goto <D.18851>;
    <D.18850>:
    monoeg_g_log (0B, 16, "Bad call to mono_mutex_lock result %d", ret);
    <D.18851>:
    D.18852 = ret != 0;
    D.18853 = (long int) D.18852;
    D.18854 = __builtin_expect (D.18853, 0);
    if (D.18854 != 0) goto <D.18855>; else goto <D.18856>;
    <D.18855>:
    monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "domain.c", 1292, "ret == 0");
    <D.18856>:
  }
  domain_id_alloc (domain);
  {
    int ret;

    ret = pthread_mutex_unlock (&appdomains_mutex.mutex);
    if (ret != 0) goto <D.18857>; else goto <D.18858>;
    <D.18857>:
    monoeg_g_log (0B, 16, "Bad call to mono_mutex_unlock result %d", ret);
    <D.18858>:
    D.18859 = ret != 0;
    D.18860 = (long int) D.18859;
    D.18861 = __builtin_expect (D.18860, 0);
    if (D.18861 != 0) goto <D.18862>; else goto <D.18863>;
    <D.18862>:
    monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "domain.c", 1294, "ret == 0");
    <D.18863>:
  }
  mono_perfcounters.15 = mono_perfcounters;
  D.18865 = mono_perfcounters.15->loader_appdomains;
  D.18866 = D.18865 + 1;
  mono_perfcounters.15->loader_appdomains = D.18866;
  mono_perfcounters.15 = mono_perfcounters;
  D.18867 = mono_perfcounters.15->loader_total_appdomains;
  D.18868 = D.18867 + 1;
  mono_perfcounters.15->loader_total_appdomains = D.18868;
  mono_debug_domain_create (domain);
  create_domain_hook.16 = create_domain_hook;
  if (create_domain_hook.16 != 0B) goto <D.18870>; else goto <D.18871>;
  <D.18870>:
  create_domain_hook.16 = create_domain_hook;
  create_domain_hook.16 (domain);
  <D.18871>:
  mono_profiler_appdomain_loaded (domain, 0);
  D.18872 = domain;
  return D.18872;
}


mono_ptrarray_equal (void * * s1, void * * s2)
{
  void * D.18874;
  void * D.18875;
  int D.18876;
  gboolean D.18879;
  unsigned int len.17;
  unsigned int D.18881;
  const void * D.18882;
  const void * D.18883;
  int D.18884;
  _Bool D.18885;
  int len;

  D.18874 = *s1;
  len = (int) D.18874;
  D.18875 = *s2;
  D.18876 = (int) D.18875;
  if (D.18876 != len) goto <D.18877>; else goto <D.18878>;
  <D.18877>:
  D.18879 = 0;
  return D.18879;
  <D.18878>:
  len.17 = (unsigned int) len;
  D.18881 = len.17 * 4;
  D.18882 = s2 + 4;
  D.18883 = s1 + 4;
  D.18884 = memcmp (D.18883, D.18882, D.18881);
  D.18885 = D.18884 == 0;
  D.18879 = (gboolean) D.18885;
  return D.18879;
}


mono_ptrarray_hash (void * * s)
{
  void * D.18887;
  unsigned int i.18;
  unsigned int D.18889;
  void * * D.18890;
  void * D.18891;
  unsigned int D.18892;
  guint D.18893;
  int i;
  int len;
  guint hash;

  D.18887 = *s;
  len = (int) D.18887;
  hash = 0;
  i = 1;
  goto <D.17763>;
  <D.17762>:
  i.18 = (unsigned int) i;
  D.18889 = i.18 * 4;
  D.18890 = s + D.18889;
  D.18891 = *D.18890;
  D.18892 = (unsigned int) D.18891;
  hash = D.18892 + hash;
  i = i + 1;
  <D.17763>:
  if (i < len) goto <D.17762>; else goto <D.17764>;
  <D.17764>:
  D.18893 = hash;
  return D.18893;
}


lock_free_mempool_new ()
{
  struct LockFreeMempool * D.18895;

  D.18895 = monoeg_malloc0 (8);
  return D.18895;
}


domain_id_alloc (struct MonoDomain * domain)
{
  struct MonoDomain * * appdomains_list.19;
  short unsigned int appdomain_list_size.20;
  unsigned int D.18901;
  unsigned int D.18902;
  void * appdomains_list.21;
  short unsigned int appdomain_next.22;
  unsigned int i.23;
  unsigned int D.18906;
  struct MonoDomain * * D.18907;
  struct MonoDomain * D.18908;
  int D.18911;
  int D.18916;
  unsigned int new_size.24;
  unsigned int D.18922;
  short unsigned int appdomain_list_size.25;
  unsigned int id.26;
  unsigned int D.18925;
  struct MonoDomain * * D.18926;
  short unsigned int appdomain_next.27;
  short unsigned int appdomain_next.28;
  int D.18931;
  int id;
  int i;

  id = -1;
  appdomains_list.19 = appdomains_list;
  if (appdomains_list.19 == 0B) goto <D.18898>; else goto <D.18899>;
  <D.18898>:
  appdomain_list_size = 2;
  appdomain_list_size.20 = appdomain_list_size;
  D.18901 = (unsigned int) appdomain_list_size.20;
  D.18902 = D.18901 * 4;
  appdomains_list.21 = mono_gc_alloc_fixed (D.18902, 0B);
  appdomains_list = appdomains_list.21;
  <D.18899>:
  appdomain_next.22 = appdomain_next;
  i = (int) appdomain_next.22;
  goto <D.17772>;
  <D.17771>:
  appdomains_list.19 = appdomains_list;
  i.23 = (unsigned int) i;
  D.18906 = i.23 * 4;
  D.18907 = appdomains_list.19 + D.18906;
  D.18908 = *D.18907;
  if (D.18908 == 0B) goto <D.18909>; else goto <D.18910>;
  <D.18909>:
  id = i;
  goto <D.17770>;
  <D.18910>:
  i = i + 1;
  <D.17772>:
  appdomain_list_size.20 = appdomain_list_size;
  D.18911 = (int) appdomain_list_size.20;
  if (D.18911 > i) goto <D.17771>; else goto <D.17770>;
  <D.17770>:
  if (id == -1) goto <D.18912>; else goto <D.18913>;
  <D.18912>:
  i = 0;
  goto <D.17775>;
  <D.17774>:
  appdomains_list.19 = appdomains_list;
  i.23 = (unsigned int) i;
  D.18906 = i.23 * 4;
  D.18907 = appdomains_list.19 + D.18906;
  D.18908 = *D.18907;
  if (D.18908 == 0B) goto <D.18914>; else goto <D.18915>;
  <D.18914>:
  id = i;
  goto <D.17773>;
  <D.18915>:
  i = i + 1;
  <D.17775>:
  appdomain_next.22 = appdomain_next;
  D.18916 = (int) appdomain_next.22;
  if (D.18916 > i) goto <D.17774>; else goto <D.17773>;
  <D.17773>:
  <D.18913>:
  if (id == -1) goto <D.18917>; else goto <D.18918>;
  <D.18917>:
  {
    struct MonoDomain * * new_list;
    int new_size;

    appdomain_list_size.20 = appdomain_list_size;
    D.18911 = (int) appdomain_list_size.20;
    new_size = D.18911 * 2;
    if (new_size > 65535) goto <D.18919>; else goto <D.18920>;
    <D.18919>:
    monoeg_assertion_message ("* Assertion: should not be reached at %s:%d\n", "domain.c", 1208);
    <D.18920>:
    appdomain_list_size.20 = appdomain_list_size;
    id = (int) appdomain_list_size.20;
    new_size.24 = (unsigned int) new_size;
    D.18922 = new_size.24 * 4;
    new_list = mono_gc_alloc_fixed (D.18922, 0B);
    appdomain_list_size.20 = appdomain_list_size;
    D.18901 = (unsigned int) appdomain_list_size.20;
    D.18902 = D.18901 * 4;
    appdomains_list.19 = appdomains_list;
    memcpy (new_list, appdomains_list.19, D.18902);
    appdomains_list.19 = appdomains_list;
    mono_gc_free_fixed (appdomains_list.19);
    appdomains_list = new_list;
    appdomain_list_size.25 = (short unsigned int) new_size;
    appdomain_list_size = appdomain_list_size.25;
  }
  <D.18918>:
  domain->domain_id = id;
  appdomains_list.19 = appdomains_list;
  id.26 = (unsigned int) id;
  D.18925 = id.26 * 4;
  D.18926 = appdomains_list.19 + D.18925;
  *D.18926 = domain;
  appdomain_next.22 = appdomain_next;
  appdomain_next.27 = appdomain_next.22;
  appdomain_next.28 = appdomain_next.27 + 1;
  appdomain_next = appdomain_next.28;
  appdomain_next.22 = appdomain_next;
  appdomain_list_size.20 = appdomain_list_size;
  if (appdomain_next.22 > appdomain_list_size.20) goto <D.18929>; else goto <D.18930>;
  <D.18929>:
  appdomain_next = 0;
  <D.18930>:
  D.18931 = id;
  return D.18931;
}


mono_init (const char * domain_name)
{
  struct MonoDomain * D.18933;

  D.18933 = mono_init_internal (domain_name, 0B, "v2.0.50727");
  return D.18933;
}


mono_init_internal (const char * filename, const char * exe_filename, const char * runtime_version)
{
  struct MonoDomain * domain.29;
  int D.18938;
  struct MonoDomain * domain.30;
  unsigned int appdomain_thread_id.31;
  const struct MonoRuntimeInfo * D.18948;
  const struct MonoRuntimeInfo * D.18949;
  const char[12] * D.18952;
  const struct MonoRuntimeInfo * current_runtime.32;
  const struct MonoRuntimeInfo * current_runtime.33;
  <unnamed type> status.34;
  const char[4] * D.18961;
  const char * D.18962;
  const char * D.18963;
  const char * D.18964;
  struct MonoImage * D.18966;
  struct MonoImage * D.18967;
  struct MonoClass * D.18968;
  struct MonoClass * D.18969;
  _Bool D.18970;
  long int D.18971;
  long int D.18972;
  struct MonoClass * D.18975;
  struct MonoClass * D.18976;
  _Bool D.18977;
  long int D.18978;
  long int D.18979;
  struct MonoClass * D.18982;
  struct MonoClass * D.18983;
  _Bool D.18984;
  long int D.18985;
  long int D.18986;
  struct MonoClass * D.18989;
  struct MonoClass * D.18990;
  _Bool D.18991;
  long int D.18992;
  long int D.18993;
  struct MonoClass * D.18996;
  struct MonoClass * D.18997;
  _Bool D.18998;
  long int D.18999;
  long int D.19000;
  struct MonoClass * D.19003;
  struct MonoClass * D.19004;
  _Bool D.19005;
  long int D.19006;
  long int D.19007;
  struct MonoClass * D.19010;
  struct MonoClass * D.19011;
  _Bool D.19012;
  long int D.19013;
  long int D.19014;
  struct MonoClass * D.19017;
  struct MonoClass * D.19018;
  _Bool D.19019;
  long int D.19020;
  long int D.19021;
  struct MonoClass * D.19024;
  struct MonoClass * D.19025;
  _Bool D.19026;
  long int D.19027;
  long int D.19028;
  struct MonoClass * D.19031;
  struct MonoClass * D.19032;
  _Bool D.19033;
  long int D.19034;
  long int D.19035;
  struct MonoClass * D.19038;
  struct MonoClass * D.19039;
  _Bool D.19040;
  long int D.19041;
  long int D.19042;
  struct MonoClass * D.19045;
  struct MonoClass * D.19046;
  _Bool D.19047;
  long int D.19048;
  long int D.19049;
  struct MonoClass * D.19052;
  struct MonoClass * D.19053;
  _Bool D.19054;
  long int D.19055;
  long int D.19056;
  struct MonoClass * D.19059;
  struct MonoClass * D.19060;
  _Bool D.19061;
  long int D.19062;
  long int D.19063;
  struct MonoClass * D.19066;
  struct MonoClass * D.19067;
  _Bool D.19068;
  long int D.19069;
  long int D.19070;
  struct MonoClass * D.19073;
  struct MonoClass * D.19074;
  _Bool D.19075;
  long int D.19076;
  long int D.19077;
  struct MonoClass * D.19080;
  struct MonoClass * D.19081;
  _Bool D.19082;
  long int D.19083;
  long int D.19084;
  struct MonoClass * D.19087;
  struct MonoClass * D.19088;
  _Bool D.19089;
  long int D.19090;
  long int D.19091;
  struct MonoClass * D.19094;
  struct MonoClass * D.19095;
  _Bool D.19096;
  long int D.19097;
  long int D.19098;
  struct MonoClass * D.19101;
  struct MonoClass * D.19102;
  _Bool D.19103;
  long int D.19104;
  long int D.19105;
  struct MonoClass * D.19108;
  struct MonoClass * D.19109;
  _Bool D.19110;
  long int D.19111;
  long int D.19112;
  struct MonoClass * D.19115;
  struct MonoClass * D.19116;
  _Bool D.19117;
  long int D.19118;
  long int D.19119;
  struct MonoClass * D.19122;
  struct MonoClass * D.19123;
  _Bool D.19124;
  long int D.19125;
  long int D.19126;
  struct MonoClass * D.19129;
  struct MonoClass * D.19130;
  _Bool D.19131;
  long int D.19132;
  long int D.19133;
  struct MonoClass * D.19136;
  struct MonoClass * D.19137;
  _Bool D.19138;
  long int D.19139;
  long int D.19140;
  struct MonoClass * D.19143;
  struct MonoClass * D.19144;
  _Bool D.19145;
  long int D.19146;
  long int D.19147;
  struct MonoClass * D.19150;
  struct MonoClass * D.19151;
  _Bool D.19152;
  long int D.19153;
  long int D.19154;
  struct MonoClass * D.19157;
  struct MonoClass * D.19158;
  _Bool D.19159;
  long int D.19160;
  long int D.19161;
  struct MonoClass * D.19164;
  struct MonoClass * D.19165;
  _Bool D.19166;
  long int D.19167;
  long int D.19168;
  struct MonoClass * D.19171;
  struct MonoClass * D.19172;
  _Bool D.19173;
  long int D.19174;
  long int D.19175;
  struct MonoClass * D.19178;
  struct MonoClass * D.19179;
  _Bool D.19180;
  long int D.19181;
  long int D.19182;
  struct MonoClass * D.19185;
  struct MonoClass * D.19186;
  struct _IO_FILE * stderr.35;
  const char * iftmp.36;
  struct MonoClass * D.19194;
  struct MonoClass * D.19195;
  _Bool D.19196;
  long int D.19197;
  long int D.19198;
  struct MonoClass * D.19201;
  struct MonoClass * D.19202;
  _Bool D.19203;
  long int D.19204;
  long int D.19205;
  struct MonoClass * D.19208;
  struct MonoClass * D.19209;
  _Bool D.19210;
  long int D.19211;
  long int D.19212;
  struct MonoClass * D.19215;
  struct MonoClass * D.19216;
  _Bool D.19217;
  long int D.19218;
  long int D.19219;
  struct MonoClass * D.19222;
  struct MonoClass * D.19223;
  _Bool D.19224;
  long int D.19225;
  long int D.19226;
  struct MonoClass * D.19229;
  struct MonoClass * D.19230;
  _Bool D.19231;
  long int D.19232;
  long int D.19233;
  struct MonoClass * D.19236;
  struct MonoClass * D.19237;
  _Bool D.19238;
  long int D.19239;
  long int D.19240;
  struct MonoClass * D.19243;
  struct MonoClass * D.19244;
  _Bool D.19245;
  long int D.19246;
  long int D.19247;
  struct MonoClass * D.19250;
  struct MonoClass * D.19251;
  _Bool D.19252;
  long int D.19253;
  long int D.19254;
  struct MonoClass * D.19257;
  struct MonoClass * D.19258;
  _Bool D.19259;
  long int D.19260;
  long int D.19261;
  struct MonoClass * D.19264;
  struct MonoClass * D.19265;
  _Bool D.19266;
  long int D.19267;
  long int D.19268;
  struct MonoClass * D.19271;
  struct MonoClass * D.19272;
  _Bool D.19273;
  long int D.19274;
  long int D.19275;
  struct MonoClass * D.19278;
  struct MonoClass * D.19279;
  _Bool D.19280;
  long int D.19281;
  long int D.19282;
  struct MonoClass * D.19285;
  struct MonoClass * D.19286;
  _Bool D.19287;
  long int D.19288;
  long int D.19289;
  struct MonoClass * D.19292;
  struct MonoClass * D.19293;
  _Bool D.19294;
  long int D.19295;
  long int D.19296;
  struct MonoClass * D.19299;
  struct MonoClass * D.19300;
  _Bool D.19301;
  long int D.19302;
  long int D.19303;
  struct MonoClass * D.19306;
  struct MonoClass * D.19307;
  struct MonoClass * D.19308;
  struct MonoClass * D.19309;
  struct MonoClass * D.19310;
  struct MonoClass * D.19311;
  struct MonoClass * D.19312;
  struct MonoClass * D.19313;
  struct MonoClass * D.19314;
  struct MonoClass * D.19315;
  struct MonoClass * D.19316;
  gchar * D.19317;
  struct MonoDomain * D.19318;
  static struct MonoDomain * domain = 0B;
  struct MonoAssembly * ass;
  MonoImageOpenStatus status;
  const struct MonoRuntimeInfo * runtimes[7];
  int n;

  try
    {
      ass = 0B;
      status = 0;
      domain.29 = domain;
      if (domain.29 != 0B) goto <D.18936>; else goto <D.18937>;
      <D.18936>:
      monoeg_assertion_message ("* Assertion: should not be reached at %s:%d\n", "domain.c", 1334);
      <D.18937>:
      wapi_init ();
      mono_perfcounters_init ();
      mono_counters_register ("Max native code in a domain", 256, &max_domain_code_size);
      mono_counters_register ("Max code space allocated in a domain", 256, &max_domain_code_alloc);
      mono_counters_register ("Total code space allocated", 256, &total_domain_code_alloc);
      mono_gc_base_init ();
      mono_native_tls_alloc (&appdomain_thread_id, 0B);
      InitializeCriticalSection (&appdomains_mutex);
      mono_metadata_init ();
      mono_images_init ();
      mono_assemblies_init ();
      mono_classes_init ();
      mono_loader_init ();
      mono_reflection_init ();
      mono_runtime_init_tls ();
      D.18938 = mono_gc_is_moving ();
      if (D.18938 == 0) goto <D.18939>; else goto <D.18940>;
      <D.18939>:
      mono_gc_register_root (&appdomains_list, 4, 0B);
      <D.18940>:
      domain.30 = mono_domain_create ();
      domain = domain.30;
      domain.29 = domain;
      mono_root_domain = domain.29;
      domain.29 = domain;
      tls_appdomain = domain.29;
      domain.29 = domain;
      appdomain_thread_id.31 = appdomain_thread_id;
      mono_native_tls_set_value (appdomain_thread_id.31, domain.29);
      domain.29 = domain;
      mono_gc_set_current_thread_appdomain (domain.29);
      if (exe_filename != 0B) goto <D.18943>; else goto <D.18944>;
      <D.18943>:
      get_runtimes_from_exe (exe_filename, &exe_image, &runtimes);
      goto <D.18945>;
      <D.18944>:
      if (runtime_version != 0B) goto <D.18946>; else goto <D.18947>;
      <D.18946>:
      D.18948 = get_runtime_by_version (runtime_version);
      runtimes[0] = D.18948;
      runtimes[1] = 0B;
      <D.18947>:
      <D.18945>:
      D.18949 = runtimes[0];
      if (D.18949 == 0B) goto <D.18950>; else goto <D.18951>;
      <D.18950>:
      {
        const struct MonoRuntimeInfo * default_runtime;

        default_runtime = get_runtime_by_version ("v2.0.50727");
        runtimes[0] = default_runtime;
        runtimes[1] = 0B;
        monoeg_g_print ("WARNING: The runtime version supported by this application is unavailable.\n");
        D.18952 = &default_runtime->runtime_version;
        monoeg_g_print ("Using default runtime: %s\n", D.18952);
      }
      <D.18951>:
      n = 0;
      goto <D.17808>;
      <D.17807>:
      current_runtime.32 = runtimes[n];
      current_runtime = current_runtime.32;
      current_runtime.33 = current_runtime;
      ass = mono_assembly_load_corlib (current_runtime.33, &status);
      status.34 = status;
      if (status.34 > 1) goto <D.17806>; else goto <D.18956>;
      <D.18956>:
      n = n + 1;
      <D.17808>:
      current_runtime.32 = runtimes[n];
      if (current_runtime.32 != 0B) goto <D.18957>; else goto <D.17806>;
      <D.18957>:
      if (ass == 0B) goto <D.17807>; else goto <D.17806>;
      <D.17806>:
      status.34 = status;
      if (status.34 != 0) goto <D.18958>; else goto <D.18960>;
      <D.18960>:
      if (ass == 0B) goto <D.18958>; else goto <D.18959>;
      <D.18958>:
      status.34 = status;
      switch (status.34) <default: <D.18965>, case 0: <D.17814>, case 1: <D.17809>, case 2: <D.17813>, case 3: <D.17812>>
      <D.17809>:
      {
        char * corlib_file;

        current_runtime.33 = current_runtime;
        D.18961 = &current_runtime.33->framework_version;
        D.18962 = mono_assembly_getrootdir ();
        corlib_file = monoeg_g_build_path ("/", D.18962, "mono", D.18961, "mscorlib.dll", 0B);
        monoeg_g_print ("The assembly mscorlib.dll was not found or could not be loaded.\n");
        monoeg_g_print ("It should have been installed in the `%s\' directory.\n", corlib_file);
        monoeg_g_free (corlib_file);
        goto <D.17811>;
      }
      <D.17812>:
      D.18963 = mono_assembly_getrootdir ();
      monoeg_g_print ("The file %s/mscorlib.dll is an invalid CIL image\n", D.18963);
      goto <D.17811>;
      <D.17813>:
      D.18964 = mono_assembly_getrootdir ();
      monoeg_g_print ("Missing assembly reference in %s/mscorlib.dll\n", D.18964);
      goto <D.17811>;
      <D.17814>:
      goto <D.17811>;
      <D.18965>:
      <D.17811>:
      exit (1);
      <D.18959>:
      D.18966 = mono_assembly_get_image (ass);
      mono_defaults.corlib = D.18966;
      D.18967 = mono_defaults.corlib;
      D.18968 = mono_class_from_name (D.18967, "System", "Object");
      mono_defaults.object_class = D.18968;
      D.18969 = mono_defaults.object_class;
      D.18970 = D.18969 == 0B;
      D.18971 = (long int) D.18970;
      D.18972 = __builtin_expect (D.18971, 0);
      if (D.18972 != 0) goto <D.18973>; else goto <D.18974>;
      <D.18973>:
      monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "domain.c", 1442, "mono_defaults.object_class != 0");
      <D.18974>:
      D.18967 = mono_defaults.corlib;
      D.18975 = mono_class_from_name (D.18967, "System", "Void");
      mono_defaults.void_class = D.18975;
      D.18976 = mono_defaults.void_class;
      D.18977 = D.18976 == 0B;
      D.18978 = (long int) D.18977;
      D.18979 = __builtin_expect (D.18978, 0);
      if (D.18979 != 0) goto <D.18980>; else goto <D.18981>;
      <D.18980>:
      monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "domain.c", 1446, "mono_defaults.void_class != 0");
      <D.18981>:
      D.18967 = mono_defaults.corlib;
      D.18982 = mono_class_from_name (D.18967, "System", "Boolean");
      mono_defaults.boolean_class = D.18982;
      D.18983 = mono_defaults.boolean_class;
      D.18984 = D.18983 == 0B;
      D.18985 = (long int) D.18984;
      D.18986 = __builtin_expect (D.18985, 0);
      if (D.18986 != 0) goto <D.18987>; else goto <D.18988>;
      <D.18987>:
      monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "domain.c", 1450, "mono_defaults.boolean_class != 0");
      <D.18988>:
      D.18967 = mono_defaults.corlib;
      D.18989 = mono_class_from_name (D.18967, "System", "Byte");
      mono_defaults.byte_class = D.18989;
      D.18990 = mono_defaults.byte_class;
      D.18991 = D.18990 == 0B;
      D.18992 = (long int) D.18991;
      D.18993 = __builtin_expect (D.18992, 0);
      if (D.18993 != 0) goto <D.18994>; else goto <D.18995>;
      <D.18994>:
      monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "domain.c", 1454, "mono_defaults.byte_class != 0");
      <D.18995>:
      D.18967 = mono_defaults.corlib;
      D.18996 = mono_class_from_name (D.18967, "System", "SByte");
      mono_defaults.sbyte_class = D.18996;
      D.18997 = mono_defaults.sbyte_class;
      D.18998 = D.18997 == 0B;
      D.18999 = (long int) D.18998;
      D.19000 = __builtin_expect (D.18999, 0);
      if (D.19000 != 0) goto <D.19001>; else goto <D.19002>;
      <D.19001>:
      monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "domain.c", 1458, "mono_defaults.sbyte_class != 0");
      <D.19002>:
      D.18967 = mono_defaults.corlib;
      D.19003 = mono_class_from_name (D.18967, "System", "Int16");
      mono_defaults.int16_class = D.19003;
      D.19004 = mono_defaults.int16_class;
      D.19005 = D.19004 == 0B;
      D.19006 = (long int) D.19005;
      D.19007 = __builtin_expect (D.19006, 0);
      if (D.19007 != 0) goto <D.19008>; else goto <D.19009>;
      <D.19008>:
      monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "domain.c", 1462, "mono_defaults.int16_class != 0");
      <D.19009>:
      D.18967 = mono_defaults.corlib;
      D.19010 = mono_class_from_name (D.18967, "System", "UInt16");
      mono_defaults.uint16_class = D.19010;
      D.19011 = mono_defaults.uint16_class;
      D.19012 = D.19011 == 0B;
      D.19013 = (long int) D.19012;
      D.19014 = __builtin_expect (D.19013, 0);
      if (D.19014 != 0) goto <D.19015>; else goto <D.19016>;
      <D.19015>:
      monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "domain.c", 1466, "mono_defaults.uint16_class != 0");
      <D.19016>:
      D.18967 = mono_defaults.corlib;
      D.19017 = mono_class_from_name (D.18967, "System", "Int32");
      mono_defaults.int32_class = D.19017;
      D.19018 = mono_defaults.int32_class;
      D.19019 = D.19018 == 0B;
      D.19020 = (long int) D.19019;
      D.19021 = __builtin_expect (D.19020, 0);
      if (D.19021 != 0) goto <D.19022>; else goto <D.19023>;
      <D.19022>:
      monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "domain.c", 1470, "mono_defaults.int32_class != 0");
      <D.19023>:
      D.18967 = mono_defaults.corlib;
      D.19024 = mono_class_from_name (D.18967, "System", "UInt32");
      mono_defaults.uint32_class = D.19024;
      D.19025 = mono_defaults.uint32_class;
      D.19026 = D.19025 == 0B;
      D.19027 = (long int) D.19026;
      D.19028 = __builtin_expect (D.19027, 0);
      if (D.19028 != 0) goto <D.19029>; else goto <D.19030>;
      <D.19029>:
      monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "domain.c", 1474, "mono_defaults.uint32_class != 0");
      <D.19030>:
      D.18967 = mono_defaults.corlib;
      D.19031 = mono_class_from_name (D.18967, "System", "UIntPtr");
      mono_defaults.uint_class = D.19031;
      D.19032 = mono_defaults.uint_class;
      D.19033 = D.19032 == 0B;
      D.19034 = (long int) D.19033;
      D.19035 = __builtin_expect (D.19034, 0);
      if (D.19035 != 0) goto <D.19036>; else goto <D.19037>;
      <D.19036>:
      monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "domain.c", 1478, "mono_defaults.uint_class != 0");
      <D.19037>:
      D.18967 = mono_defaults.corlib;
      D.19038 = mono_class_from_name (D.18967, "System", "IntPtr");
      mono_defaults.int_class = D.19038;
      D.19039 = mono_defaults.int_class;
      D.19040 = D.19039 == 0B;
      D.19041 = (long int) D.19040;
      D.19042 = __builtin_expect (D.19041, 0);
      if (D.19042 != 0) goto <D.19043>; else goto <D.19044>;
      <D.19043>:
      monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "domain.c", 1482, "mono_defaults.int_class != 0");
      <D.19044>:
      D.18967 = mono_defaults.corlib;
      D.19045 = mono_class_from_name (D.18967, "System", "Int64");
      mono_defaults.int64_class = D.19045;
      D.19046 = mono_defaults.int64_class;
      D.19047 = D.19046 == 0B;
      D.19048 = (long int) D.19047;
      D.19049 = __builtin_expect (D.19048, 0);
      if (D.19049 != 0) goto <D.19050>; else goto <D.19051>;
      <D.19050>:
      monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "domain.c", 1486, "mono_defaults.int64_class != 0");
      <D.19051>:
      D.18967 = mono_defaults.corlib;
      D.19052 = mono_class_from_name (D.18967, "System", "UInt64");
      mono_defaults.uint64_class = D.19052;
      D.19053 = mono_defaults.uint64_class;
      D.19054 = D.19053 == 0B;
      D.19055 = (long int) D.19054;
      D.19056 = __builtin_expect (D.19055, 0);
      if (D.19056 != 0) goto <D.19057>; else goto <D.19058>;
      <D.19057>:
      monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "domain.c", 1490, "mono_defaults.uint64_class != 0");
      <D.19058>:
      D.18967 = mono_defaults.corlib;
      D.19059 = mono_class_from_name (D.18967, "System", "Single");
      mono_defaults.single_class = D.19059;
      D.19060 = mono_defaults.single_class;
      D.19061 = D.19060 == 0B;
      D.19062 = (long int) D.19061;
      D.19063 = __builtin_expect (D.19062, 0);
      if (D.19063 != 0) goto <D.19064>; else goto <D.19065>;
      <D.19064>:
      monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "domain.c", 1494, "mono_defaults.single_class != 0");
      <D.19065>:
      D.18967 = mono_defaults.corlib;
      D.19066 = mono_class_from_name (D.18967, "System", "Double");
      mono_defaults.double_class = D.19066;
      D.19067 = mono_defaults.double_class;
      D.19068 = D.19067 == 0B;
      D.19069 = (long int) D.19068;
      D.19070 = __builtin_expect (D.19069, 0);
      if (D.19070 != 0) goto <D.19071>; else goto <D.19072>;
      <D.19071>:
      monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "domain.c", 1498, "mono_defaults.double_class != 0");
      <D.19072>:
      D.18967 = mono_defaults.corlib;
      D.19073 = mono_class_from_name (D.18967, "System", "Char");
      mono_defaults.char_class = D.19073;
      D.19074 = mono_defaults.char_class;
      D.19075 = D.19074 == 0B;
      D.19076 = (long int) D.19075;
      D.19077 = __builtin_expect (D.19076, 0);
      if (D.19077 != 0) goto <D.19078>; else goto <D.19079>;
      <D.19078>:
      monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "domain.c", 1502, "mono_defaults.char_class != 0");
      <D.19079>:
      D.18967 = mono_defaults.corlib;
      D.19080 = mono_class_from_name (D.18967, "System", "String");
      mono_defaults.string_class = D.19080;
      D.19081 = mono_defaults.string_class;
      D.19082 = D.19081 == 0B;
      D.19083 = (long int) D.19082;
      D.19084 = __builtin_expect (D.19083, 0);
      if (D.19084 != 0) goto <D.19085>; else goto <D.19086>;
      <D.19085>:
      monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "domain.c", 1506, "mono_defaults.string_class != 0");
      <D.19086>:
      D.18967 = mono_defaults.corlib;
      D.19087 = mono_class_from_name (D.18967, "System", "Enum");
      mono_defaults.enum_class = D.19087;
      D.19088 = mono_defaults.enum_class;
      D.19089 = D.19088 == 0B;
      D.19090 = (long int) D.19089;
      D.19091 = __builtin_expect (D.19090, 0);
      if (D.19091 != 0) goto <D.19092>; else goto <D.19093>;
      <D.19092>:
      monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "domain.c", 1510, "mono_defaults.enum_class != 0");
      <D.19093>:
      D.18967 = mono_defaults.corlib;
      D.19094 = mono_class_from_name (D.18967, "System", "Array");
      mono_defaults.array_class = D.19094;
      D.19095 = mono_defaults.array_class;
      D.19096 = D.19095 == 0B;
      D.19097 = (long int) D.19096;
      D.19098 = __builtin_expect (D.19097, 0);
      if (D.19098 != 0) goto <D.19099>; else goto <D.19100>;
      <D.19099>:
      monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "domain.c", 1514, "mono_defaults.array_class != 0");
      <D.19100>:
      D.18967 = mono_defaults.corlib;
      D.19101 = mono_class_from_name (D.18967, "System", "Delegate");
      mono_defaults.delegate_class = D.19101;
      D.19102 = mono_defaults.delegate_class;
      D.19103 = D.19102 == 0B;
      D.19104 = (long int) D.19103;
      D.19105 = __builtin_expect (D.19104, 0);
      if (D.19105 != 0) goto <D.19106>; else goto <D.19107>;
      <D.19106>:
      monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "domain.c", 1518, "mono_defaults.delegate_class != 0");
      <D.19107>:
      D.18967 = mono_defaults.corlib;
      D.19108 = mono_class_from_name (D.18967, "System", "MulticastDelegate");
      mono_defaults.multicastdelegate_class = D.19108;
      D.19109 = mono_defaults.multicastdelegate_class;
      D.19110 = D.19109 == 0B;
      D.19111 = (long int) D.19110;
      D.19112 = __builtin_expect (D.19111, 0);
      if (D.19112 != 0) goto <D.19113>; else goto <D.19114>;
      <D.19113>:
      monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "domain.c", 1522, "mono_defaults.multicastdelegate_class != 0");
      <D.19114>:
      D.18967 = mono_defaults.corlib;
      D.19115 = mono_class_from_name (D.18967, "System.Runtime.Remoting.Messaging", "AsyncResult");
      mono_defaults.asyncresult_class = D.19115;
      D.19116 = mono_defaults.asyncresult_class;
      D.19117 = D.19116 == 0B;
      D.19118 = (long int) D.19117;
      D.19119 = __builtin_expect (D.19118, 0);
      if (D.19119 != 0) goto <D.19120>; else goto <D.19121>;
      <D.19120>:
      monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "domain.c", 1527, "mono_defaults.asyncresult_class != 0");
      <D.19121>:
      D.18967 = mono_defaults.corlib;
      D.19122 = mono_class_from_name (D.18967, "System.Threading", "ManualResetEvent");
      mono_defaults.manualresetevent_class = D.19122;
      D.19123 = mono_defaults.manualresetevent_class;
      D.19124 = D.19123 == 0B;
      D.19125 = (long int) D.19124;
      D.19126 = __builtin_expect (D.19125, 0);
      if (D.19126 != 0) goto <D.19127>; else goto <D.19128>;
      <D.19127>:
      monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "domain.c", 1531, "mono_defaults.manualresetevent_class != 0");
      <D.19128>:
      D.18967 = mono_defaults.corlib;
      D.19129 = mono_class_from_name (D.18967, "System", "RuntimeTypeHandle");
      mono_defaults.typehandle_class = D.19129;
      D.19130 = mono_defaults.typehandle_class;
      D.19131 = D.19130 == 0B;
      D.19132 = (long int) D.19131;
      D.19133 = __builtin_expect (D.19132, 0);
      if (D.19133 != 0) goto <D.19134>; else goto <D.19135>;
      <D.19134>:
      monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "domain.c", 1535, "mono_defaults.typehandle_class != 0");
      <D.19135>:
      D.18967 = mono_defaults.corlib;
      D.19136 = mono_class_from_name (D.18967, "System", "RuntimeMethodHandle");
      mono_defaults.methodhandle_class = D.19136;
      D.19137 = mono_defaults.methodhandle_class;
      D.19138 = D.19137 == 0B;
      D.19139 = (long int) D.19138;
      D.19140 = __builtin_expect (D.19139, 0);
      if (D.19140 != 0) goto <D.19141>; else goto <D.19142>;
      <D.19141>:
      monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "domain.c", 1539, "mono_defaults.methodhandle_class != 0");
      <D.19142>:
      D.18967 = mono_defaults.corlib;
      D.19143 = mono_class_from_name (D.18967, "System", "RuntimeFieldHandle");
      mono_defaults.fieldhandle_class = D.19143;
      D.19144 = mono_defaults.fieldhandle_class;
      D.19145 = D.19144 == 0B;
      D.19146 = (long int) D.19145;
      D.19147 = __builtin_expect (D.19146, 0);
      if (D.19147 != 0) goto <D.19148>; else goto <D.19149>;
      <D.19148>:
      monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "domain.c", 1543, "mono_defaults.fieldhandle_class != 0");
      <D.19149>:
      D.18967 = mono_defaults.corlib;
      D.19150 = mono_class_from_name (D.18967, "System", "Type");
      mono_defaults.systemtype_class = D.19150;
      D.19151 = mono_defaults.systemtype_class;
      D.19152 = D.19151 == 0B;
      D.19153 = (long int) D.19152;
      D.19154 = __builtin_expect (D.19153, 0);
      if (D.19154 != 0) goto <D.19155>; else goto <D.19156>;
      <D.19155>:
      monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "domain.c", 1547, "mono_defaults.systemtype_class != 0");
      <D.19156>:
      D.18967 = mono_defaults.corlib;
      D.19157 = mono_class_from_name (D.18967, "System", "MonoType");
      mono_defaults.monotype_class = D.19157;
      D.19158 = mono_defaults.monotype_class;
      D.19159 = D.19158 == 0B;
      D.19160 = (long int) D.19159;
      D.19161 = __builtin_expect (D.19160, 0);
      if (D.19161 != 0) goto <D.19162>; else goto <D.19163>;
      <D.19162>:
      monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "domain.c", 1551, "mono_defaults.monotype_class != 0");
      <D.19163>:
      D.18967 = mono_defaults.corlib;
      D.19164 = mono_class_from_name (D.18967, "System", "Exception");
      mono_defaults.exception_class = D.19164;
      D.19165 = mono_defaults.exception_class;
      D.19166 = D.19165 == 0B;
      D.19167 = (long int) D.19166;
      D.19168 = __builtin_expect (D.19167, 0);
      if (D.19168 != 0) goto <D.19169>; else goto <D.19170>;
      <D.19169>:
      monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "domain.c", 1555, "mono_defaults.exception_class != 0");
      <D.19170>:
      D.18967 = mono_defaults.corlib;
      D.19171 = mono_class_from_name (D.18967, "System.Threading", "ThreadAbortException");
      mono_defaults.threadabortexception_class = D.19171;
      D.19172 = mono_defaults.threadabortexception_class;
      D.19173 = D.19172 == 0B;
      D.19174 = (long int) D.19173;
      D.19175 = __builtin_expect (D.19174, 0);
      if (D.19175 != 0) goto <D.19176>; else goto <D.19177>;
      <D.19176>:
      monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "domain.c", 1559, "mono_defaults.threadabortexception_class != 0");
      <D.19177>:
      D.18967 = mono_defaults.corlib;
      D.19178 = mono_class_from_name (D.18967, "System.Threading", "Thread");
      mono_defaults.thread_class = D.19178;
      D.19179 = mono_defaults.thread_class;
      D.19180 = D.19179 == 0B;
      D.19181 = (long int) D.19180;
      D.19182 = __builtin_expect (D.19181, 0);
      if (D.19182 != 0) goto <D.19183>; else goto <D.19184>;
      <D.19183>:
      monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "domain.c", 1563, "mono_defaults.thread_class != 0");
      <D.19184>:
      D.18967 = mono_defaults.corlib;
      D.19185 = mono_class_from_name (D.18967, "System.Threading", "InternalThread");
      mono_defaults.internal_thread_class = D.19185;
      D.19186 = mono_defaults.internal_thread_class;
      if (D.19186 == 0B) goto <D.19187>; else goto <D.19188>;
      <D.19187>:
      stderr.35 = stderr;
      fprintf (stderr.35, "Corlib too old for this runtime.\n");
      D.18967 = mono_defaults.corlib;
      if (D.18967 != 0B) goto <D.19191>; else goto <D.19192>;
      <D.19191>:
      D.18967 = mono_defaults.corlib;
      iftmp.36 = mono_image_get_filename (D.18967);
      goto <D.19193>;
      <D.19192>:
      iftmp.36 = "unknown";
      <D.19193>:
      stderr.35 = stderr;
      fprintf (stderr.35, "Loaded from: %s\n", iftmp.36);
      exit (1);
      <D.19188>:
      D.18967 = mono_defaults.corlib;
      D.19194 = mono_class_from_name (D.18967, "System", "AppDomain");
      mono_defaults.appdomain_class = D.19194;
      D.19195 = mono_defaults.appdomain_class;
      D.19196 = D.19195 == 0B;
      D.19197 = (long int) D.19196;
      D.19198 = __builtin_expect (D.19197, 0);
      if (D.19198 != 0) goto <D.19199>; else goto <D.19200>;
      <D.19199>:
      monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "domain.c", 1577, "mono_defaults.appdomain_class != 0");
      <D.19200>:
      D.18967 = mono_defaults.corlib;
      D.19201 = mono_class_from_name (D.18967, "System.Runtime.Remoting.Proxies", "TransparentProxy");
      mono_defaults.transparent_proxy_class = D.19201;
      D.19202 = mono_defaults.transparent_proxy_class;
      D.19203 = D.19202 == 0B;
      D.19204 = (long int) D.19203;
      D.19205 = __builtin_expect (D.19204, 0);
      if (D.19205 != 0) goto <D.19206>; else goto <D.19207>;
      <D.19206>:
      monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "domain.c", 1582, "mono_defaults.transparent_proxy_class != 0");
      <D.19207>:
      D.18967 = mono_defaults.corlib;
      D.19208 = mono_class_from_name (D.18967, "System.Runtime.Remoting.Proxies", "RealProxy");
      mono_defaults.real_proxy_class = D.19208;
      D.19209 = mono_defaults.real_proxy_class;
      D.19210 = D.19209 == 0B;
      D.19211 = (long int) D.19210;
      D.19212 = __builtin_expect (D.19211, 0);
      if (D.19212 != 0) goto <D.19213>; else goto <D.19214>;
      <D.19213>:
      monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "domain.c", 1586, "mono_defaults.real_proxy_class != 0");
      <D.19214>:
      D.18967 = mono_defaults.corlib;
      D.19215 = mono_class_from_name (D.18967, "System", "MarshalByRefObject");
      mono_defaults.marshalbyrefobject_class = D.19215;
      D.19216 = mono_defaults.marshalbyrefobject_class;
      D.19217 = D.19216 == 0B;
      D.19218 = (long int) D.19217;
      D.19219 = __builtin_expect (D.19218, 0);
      if (D.19219 != 0) goto <D.19220>; else goto <D.19221>;
      <D.19220>:
      monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "domain.c", 1590, "mono_defaults.marshalbyrefobject_class != 0");
      <D.19221>:
      D.18967 = mono_defaults.corlib;
      D.19222 = mono_class_from_name (D.18967, "System.Runtime.Remoting", "IRemotingTypeInfo");
      mono_defaults.iremotingtypeinfo_class = D.19222;
      D.19223 = mono_defaults.iremotingtypeinfo_class;
      D.19224 = D.19223 == 0B;
      D.19225 = (long int) D.19224;
      D.19226 = __builtin_expect (D.19225, 0);
      if (D.19226 != 0) goto <D.19227>; else goto <D.19228>;
      <D.19227>:
      monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "domain.c", 1594, "mono_defaults.iremotingtypeinfo_class != 0");
      <D.19228>:
      D.18967 = mono_defaults.corlib;
      D.19229 = mono_class_from_name (D.18967, "System.Runtime.Remoting.Messaging", "MonoMethodMessage");
      mono_defaults.mono_method_message_class = D.19229;
      D.19230 = mono_defaults.mono_method_message_class;
      D.19231 = D.19230 == 0B;
      D.19232 = (long int) D.19231;
      D.19233 = __builtin_expect (D.19232, 0);
      if (D.19233 != 0) goto <D.19234>; else goto <D.19235>;
      <D.19234>:
      monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "domain.c", 1599, "mono_defaults.mono_method_message_class != 0");
      <D.19235>:
      D.18967 = mono_defaults.corlib;
      D.19236 = mono_class_from_name (D.18967, "System.Reflection", "FieldInfo");
      mono_defaults.field_info_class = D.19236;
      D.19237 = mono_defaults.field_info_class;
      D.19238 = D.19237 == 0B;
      D.19239 = (long int) D.19238;
      D.19240 = __builtin_expect (D.19239, 0);
      if (D.19240 != 0) goto <D.19241>; else goto <D.19242>;
      <D.19241>:
      monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "domain.c", 1603, "mono_defaults.field_info_class != 0");
      <D.19242>:
      D.18967 = mono_defaults.corlib;
      D.19243 = mono_class_from_name (D.18967, "System.Reflection", "MethodInfo");
      mono_defaults.method_info_class = D.19243;
      D.19244 = mono_defaults.method_info_class;
      D.19245 = D.19244 == 0B;
      D.19246 = (long int) D.19245;
      D.19247 = __builtin_expect (D.19246, 0);
      if (D.19247 != 0) goto <D.19248>; else goto <D.19249>;
      <D.19248>:
      monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "domain.c", 1607, "mono_defaults.method_info_class != 0");
      <D.19249>:
      D.18967 = mono_defaults.corlib;
      D.19250 = mono_class_from_name (D.18967, "System.Text", "StringBuilder");
      mono_defaults.stringbuilder_class = D.19250;
      D.19251 = mono_defaults.stringbuilder_class;
      D.19252 = D.19251 == 0B;
      D.19253 = (long int) D.19252;
      D.19254 = __builtin_expect (D.19253, 0);
      if (D.19254 != 0) goto <D.19255>; else goto <D.19256>;
      <D.19255>:
      monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "domain.c", 1611, "mono_defaults.stringbuilder_class != 0");
      <D.19256>:
      D.18967 = mono_defaults.corlib;
      D.19257 = mono_class_from_name (D.18967, "System", "Math");
      mono_defaults.math_class = D.19257;
      D.19258 = mono_defaults.math_class;
      D.19259 = D.19258 == 0B;
      D.19260 = (long int) D.19259;
      D.19261 = __builtin_expect (D.19260, 0);
      if (D.19261 != 0) goto <D.19262>; else goto <D.19263>;
      <D.19262>:
      monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "domain.c", 1615, "mono_defaults.math_class != 0");
      <D.19263>:
      D.18967 = mono_defaults.corlib;
      D.19264 = mono_class_from_name (D.18967, "System.Diagnostics", "StackFrame");
      mono_defaults.stack_frame_class = D.19264;
      D.19265 = mono_defaults.stack_frame_class;
      D.19266 = D.19265 == 0B;
      D.19267 = (long int) D.19266;
      D.19268 = __builtin_expect (D.19267, 0);
      if (D.19268 != 0) goto <D.19269>; else goto <D.19270>;
      <D.19269>:
      monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "domain.c", 1619, "mono_defaults.stack_frame_class != 0");
      <D.19270>:
      D.18967 = mono_defaults.corlib;
      D.19271 = mono_class_from_name (D.18967, "System.Diagnostics", "StackTrace");
      mono_defaults.stack_trace_class = D.19271;
      D.19272 = mono_defaults.stack_trace_class;
      D.19273 = D.19272 == 0B;
      D.19274 = (long int) D.19273;
      D.19275 = __builtin_expect (D.19274, 0);
      if (D.19275 != 0) goto <D.19276>; else goto <D.19277>;
      <D.19276>:
      monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "domain.c", 1623, "mono_defaults.stack_trace_class != 0");
      <D.19277>:
      D.18967 = mono_defaults.corlib;
      D.19278 = mono_class_from_name (D.18967, "System.Runtime.InteropServices", "Marshal");
      mono_defaults.marshal_class = D.19278;
      D.19279 = mono_defaults.marshal_class;
      D.19280 = D.19279 == 0B;
      D.19281 = (long int) D.19280;
      D.19282 = __builtin_expect (D.19281, 0);
      if (D.19282 != 0) goto <D.19283>; else goto <D.19284>;
      <D.19283>:
      monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "domain.c", 1627, "mono_defaults.marshal_class != 0");
      <D.19284>:
      D.18967 = mono_defaults.corlib;
      D.19285 = mono_class_from_name (D.18967, "System", "TypedReference");
      mono_defaults.typed_reference_class = D.19285;
      D.19286 = mono_defaults.typed_reference_class;
      D.19287 = D.19286 == 0B;
      D.19288 = (long int) D.19287;
      D.19289 = __builtin_expect (D.19288, 0);
      if (D.19289 != 0) goto <D.19290>; else goto <D.19291>;
      <D.19290>:
      monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "domain.c", 1631, "mono_defaults.typed_reference_class != 0");
      <D.19291>:
      D.18967 = mono_defaults.corlib;
      D.19292 = mono_class_from_name (D.18967, "System", "RuntimeArgumentHandle");
      mono_defaults.argumenthandle_class = D.19292;
      D.19293 = mono_defaults.argumenthandle_class;
      D.19294 = D.19293 == 0B;
      D.19295 = (long int) D.19294;
      D.19296 = __builtin_expect (D.19295, 0);
      if (D.19296 != 0) goto <D.19297>; else goto <D.19298>;
      <D.19297>:
      monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "domain.c", 1635, "mono_defaults.argumenthandle_class != 0");
      <D.19298>:
      D.18967 = mono_defaults.corlib;
      D.19299 = mono_class_from_name (D.18967, "System.Threading", "Monitor");
      mono_defaults.monitor_class = D.19299;
      D.19300 = mono_defaults.monitor_class;
      D.19301 = D.19300 == 0B;
      D.19302 = (long int) D.19301;
      D.19303 = __builtin_expect (D.19302, 0);
      if (D.19303 != 0) goto <D.19304>; else goto <D.19305>;
      <D.19304>:
      monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "domain.c", 1639, "mono_defaults.monitor_class != 0");
      <D.19305>:
      D.18967 = mono_defaults.corlib;
      D.19306 = mono_class_from_name (D.18967, "System.Security", "RuntimeSecurityFrame");
      mono_defaults.runtimesecurityframe_class = D.19306;
      D.18967 = mono_defaults.corlib;
      D.19307 = mono_class_from_name (D.18967, "System.Threading", "ExecutionContext");
      mono_defaults.executioncontext_class = D.19307;
      D.18967 = mono_defaults.corlib;
      D.19308 = mono_class_from_name (D.18967, "System.Runtime.CompilerServices", "InternalsVisibleToAttribute");
      mono_defaults.internals_visible_class = D.19308;
      D.18967 = mono_defaults.corlib;
      D.19309 = mono_class_from_name (D.18967, "System.Runtime.ConstrainedExecution", "CriticalFinalizerObject");
      mono_defaults.critical_finalizer_object = D.19309;
      mono_assembly_load_friends (ass);
      D.18967 = mono_defaults.corlib;
      D.19310 = mono_class_from_name (D.18967, "System.Runtime.InteropServices", "SafeHandle");
      mono_defaults.safehandle_class = D.19310;
      D.18967 = mono_defaults.corlib;
      D.19311 = mono_class_from_name (D.18967, "System.Runtime.InteropServices", "HandleRef");
      mono_defaults.handleref_class = D.19311;
      D.18967 = mono_defaults.corlib;
      D.19312 = mono_class_from_name (D.18967, "System", "Attribute");
      mono_defaults.attribute_class = D.19312;
      D.18967 = mono_defaults.corlib;
      D.19313 = mono_class_from_name (D.18967, "System.Reflection", "CustomAttributeData");
      mono_defaults.customattribute_data_class = D.19313;
      D.19095 = mono_defaults.array_class;
      mono_class_init (D.19095);
      D.18967 = mono_defaults.corlib;
      D.19314 = mono_class_from_name (D.18967, "System", "Nullable`1");
      mono_defaults.generic_nullable_class = D.19314;
      D.18967 = mono_defaults.corlib;
      D.19315 = mono_class_from_name (D.18967, "System.Collections.Generic", "IList`1");
      mono_defaults.generic_ilist_class = D.19315;
      D.18967 = mono_defaults.corlib;
      D.19316 = mono_class_from_name (D.18967, "System.Collections.Generic", "IReadOnlyList`1");
      mono_defaults.generic_ireadonlylist_class = D.19316;
      domain.29 = domain;
      D.19317 = monoeg_g_path_get_basename (filename);
      domain.29->friendly_name = D.19317;
      domain.29 = domain;
      _mono_debug_init_corlib (domain.29);
      D.19318 = domain;
      return D.19318;
    }
  finally
    {
      status = {CLOBBER};
      runtimes = {CLOBBER};
    }
}


mono_native_tls_alloc (pthread_key_t * key, void * destructor)
{
  int D.19321;
  void (*<Tbf>) (void *) destructor.37;
  int D.19323;
  _Bool D.19324;

  destructor.37 = (void (*<Tbf>) (void *)) destructor;
  D.19323 = pthread_key_create (key, destructor.37);
  D.19324 = D.19323 == 0;
  D.19321 = (int) D.19324;
  return D.19321;
}


mono_native_tls_set_value (pthread_key_t key, void * value)
{
  int D.19326;
  int D.19327;
  _Bool D.19328;

  D.19327 = pthread_setspecific (key, value);
  D.19328 = D.19327 == 0;
  D.19326 = (int) D.19328;
  return D.19326;
}


get_runtimes_from_exe (const char * exe_file, struct MonoImage * * exe_image, const struct MonoRuntimeInfo * * runtimes)
{
  struct GSList * D.19332;
  int n.38;
  unsigned int n.39;
  unsigned int D.19339;
  const struct MonoRuntimeInfo * * D.19340;
  struct GSList * iftmp.40;
  unsigned int n.41;
  unsigned int D.19346;
  const struct MonoRuntimeInfo * * D.19347;
  char * D.19348;
  const struct MonoRuntimeInfo * D.19351;
  const struct MonoRuntimeInfo * * D.19352;
  const struct MonoRuntimeInfo * D.19357;
  char * D.19358;
  const struct MonoRuntimeInfo * D.19359;
  struct AppConfigInfo * app_config;
  char * version;
  const struct MonoRuntimeInfo * runtime;
  struct MonoImage * image;

  runtime = 0B;
  image = 0B;
  app_config = app_config_parse (exe_file);
  if (app_config != 0B) goto <D.19330>; else goto <D.19331>;
  <D.19330>:
  D.19332 = app_config->supported_runtimes;
  if (D.19332 != 0B) goto <D.19333>; else goto <D.19334>;
  <D.19333>:
  {
    int n;
    struct GSList * list;

    n = 0;
    list = app_config->supported_runtimes;
    goto <D.18220>;
    <D.18219>:
    version = list->data;
    runtime = get_runtime_by_version (version);
    if (runtime != 0B) goto <D.19335>; else goto <D.19336>;
    <D.19335>:
    n.38 = n;
    n = n.38 + 1;
    n.39 = (unsigned int) n.38;
    D.19339 = n.39 * 4;
    D.19340 = runtimes + D.19339;
    *D.19340 = runtime;
    <D.19336>:
    if (list != 0B) goto <D.19342>; else goto <D.19343>;
    <D.19342>:
    iftmp.40 = list->next;
    goto <D.19344>;
    <D.19343>:
    iftmp.40 = 0B;
    <D.19344>:
    list = iftmp.40;
    <D.18220>:
    if (list != 0B) goto <D.18219>; else goto <D.18221>;
    <D.18221>:
    n.41 = (unsigned int) n;
    D.19346 = n.41 * 4;
    D.19347 = runtimes + D.19346;
    *D.19347 = 0B;
    app_config_free (app_config);
    return;
  }
  <D.19334>:
  D.19348 = app_config->required_runtime;
  if (D.19348 != 0B) goto <D.19349>; else goto <D.19350>;
  <D.19349>:
  D.19348 = app_config->required_runtime;
  D.19351 = get_runtime_by_version (D.19348);
  *runtimes = D.19351;
  D.19352 = runtimes + 4;
  *D.19352 = 0B;
  app_config_free (app_config);
  return;
  <D.19350>:
  app_config_free (app_config);
  <D.19331>:
  image = mono_assembly_open_from_bundle (exe_file, 0B, 0);
  if (image == 0B) goto <D.19353>; else goto <D.19354>;
  <D.19353>:
  image = mono_image_open (exe_file, 0B);
  <D.19354>:
  if (image == 0B) goto <D.19355>; else goto <D.19356>;
  <D.19355>:
  D.19357 = get_runtime_by_version ("v2.0.50727");
  *runtimes = D.19357;
  D.19352 = runtimes + 4;
  *D.19352 = 0B;
  return;
  <D.19356>:
  *exe_image = image;
  D.19358 = image->version;
  D.19359 = get_runtime_by_version (D.19358);
  *runtimes = D.19359;
  D.19352 = runtimes + 4;
  *D.19352 = 0B;
}


app_config_parse (const char * exe_filename)
{
  gchar * text.42;
  char * text.43;
  unsigned int len.44;
  int D.19367;
  struct AppConfigInfo * D.19370;
  unsigned int len.45;
  int len.46;
  int D.19373;
  struct AppConfigInfo * app_config;
  struct GMarkupParseContext * context;
  char * text;
  gsize len;
  const char * bundled_config;
  char * config_filename;

  try
    {
      bundled_config = mono_config_string_for_assembly_file (exe_filename);
      if (bundled_config != 0B) goto <D.19361>; else goto <D.19362>;
      <D.19361>:
      text.42 = monoeg_strdup (bundled_config);
      text = text.42;
      text.43 = text;
      len.44 = strlen (text.43);
      len = len.44;
      goto <D.19366>;
      <D.19362>:
      config_filename = monoeg_g_strconcat (exe_filename, ".config", 0B);
      D.19367 = monoeg_g_file_get_contents (config_filename, &text, &len, 0B);
      if (D.19367 == 0) goto <D.19368>; else goto <D.19369>;
      <D.19368>:
      monoeg_g_free (config_filename);
      D.19370 = 0B;
      return D.19370;
      <D.19369>:
      monoeg_g_free (config_filename);
      <D.19366>:
      app_config = monoeg_malloc0 (16);
      context = monoeg_g_markup_parse_context_new (&mono_parser, 0, app_config, 0B);
      len.45 = len;
      len.46 = (int) len.45;
      text.43 = text;
      D.19373 = monoeg_g_markup_parse_context_parse (context, text.43, len.46, 0B);
      if (D.19373 != 0) goto <D.19374>; else goto <D.19375>;
      <D.19374>:
      monoeg_g_markup_parse_context_end_parse (context, 0B);
      <D.19375>:
      monoeg_g_markup_parse_context_free (context);
      text.43 = text;
      monoeg_g_free (text.43);
      D.19370 = app_config;
      return D.19370;
    }
  finally
    {
      text = {CLOBBER};
      len = {CLOBBER};
    }
}


end_element (struct GMarkupParseContext * context, const gchar * element_name, void * user_data, struct GError * * error)
{
  int D.18150;
  int iftmp.47;
  int D.18149;
  const char[14] * D.19381;
  unsigned char D.19382;
  int D.19383;
  unsigned char D.19384;
  int D.19385;
  _Bool D.19386;
  _Bool D.19387;
  _Bool D.19388;
  const unsigned char * D.19391;
  unsigned char D.19392;
  int D.19393;
  const unsigned char * D.19394;
  unsigned char D.19395;
  int D.19396;
  _Bool D.19397;
  _Bool D.19398;
  const unsigned char * D.19401;
  unsigned char D.19402;
  int D.19403;
  const unsigned char * D.19404;
  unsigned char D.19405;
  int D.19406;
  _Bool D.19407;
  _Bool D.19408;
  const unsigned char * D.19411;
  unsigned char D.19412;
  int D.19413;
  const unsigned char * D.19414;
  unsigned char D.19415;
  int D.19416;
  int D.19420;
  int D.19421;
  int D.18159;
  int iftmp.48;
  int D.18158;
  const char[8] * D.19426;
  unsigned char D.19427;
  int D.19428;
  unsigned char D.19429;
  int D.19430;
  _Bool D.19431;
  _Bool D.19432;
  _Bool D.19433;
  const unsigned char * D.19436;
  unsigned char D.19437;
  int D.19438;
  const unsigned char * D.19439;
  unsigned char D.19440;
  int D.19441;
  _Bool D.19442;
  _Bool D.19443;
  const unsigned char * D.19446;
  unsigned char D.19447;
  int D.19448;
  const unsigned char * D.19449;
  unsigned char D.19450;
  int D.19451;
  _Bool D.19452;
  _Bool D.19453;
  const unsigned char * D.19456;
  unsigned char D.19457;
  int D.19458;
  const unsigned char * D.19459;
  unsigned char D.19460;
  int D.19461;
  int D.19465;
  int D.19466;
  struct AppConfigInfo * app_config;

  app_config = user_data;
  {
    size_t __s1_len;
    size_t __s2_len;

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

      __s2 = element_name;
      D.19381 = "configuration";
      D.19382 = MEM[(const unsigned char *)D.19381];
      D.19383 = (int) D.19382;
      D.19384 = *__s2;
      D.19385 = (int) D.19384;
      __result = D.19383 - D.19385;
      {
        D.19386 = __s2_len != 0;
        D.19387 = __result == 0;
        D.19388 = D.19386 & D.19387;
        if (D.19388 != 0) goto <D.19389>; else goto <D.19390>;
        <D.19389>:
        D.19391 = &MEM[(void *)"configuration" + 1B];
        D.19392 = *D.19391;
        D.19393 = (int) D.19392;
        D.19394 = __s2 + 1;
        D.19395 = *D.19394;
        D.19396 = (int) D.19395;
        __result = D.19393 - D.19396;
        D.19397 = __s2_len > 1;
        D.19387 = __result == 0;
        D.19398 = D.19397 & D.19387;
        if (D.19398 != 0) goto <D.19399>; else goto <D.19400>;
        <D.19399>:
        D.19401 = &MEM[(void *)"configuration" + 2B];
        D.19402 = *D.19401;
        D.19403 = (int) D.19402;
        D.19404 = __s2 + 2;
        D.19405 = *D.19404;
        D.19406 = (int) D.19405;
        __result = D.19403 - D.19406;
        D.19407 = __s2_len > 2;
        D.19387 = __result == 0;
        D.19408 = D.19407 & D.19387;
        if (D.19408 != 0) goto <D.19409>; else goto <D.19410>;
        <D.19409>:
        D.19411 = &MEM[(void *)"configuration" + 3B];
        D.19412 = *D.19411;
        D.19413 = (int) D.19412;
        D.19414 = __s2 + 3;
        D.19415 = *D.19414;
        D.19416 = (int) D.19415;
        __result = D.19413 - D.19416;
        <D.19410>:
        <D.19400>:
        <D.19390>:
      }
      D.18149 = __result;
    }
    iftmp.47 = -D.18149;
    goto <D.19417>;
    <D.19380>:
    iftmp.47 = __builtin_strcmp (element_name, "configuration");
    <D.19417>:
    D.18150 = iftmp.47;
  }
  if (D.18150 == 0) goto <D.19418>; else goto <D.19419>;
  <D.19418>:
  D.19420 = app_config->configuration_count;
  D.19421 = D.19420 + -1;
  app_config->configuration_count = D.19421;
  goto <D.19422>;
  <D.19419>:
  {
    size_t __s1_len;
    size_t __s2_len;

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

      __s2 = element_name;
      D.19426 = "startup";
      D.19427 = MEM[(const unsigned char *)D.19426];
      D.19428 = (int) D.19427;
      D.19429 = *__s2;
      D.19430 = (int) D.19429;
      __result = D.19428 - D.19430;
      {
        D.19431 = __s2_len != 0;
        D.19432 = __result == 0;
        D.19433 = D.19431 & D.19432;
        if (D.19433 != 0) goto <D.19434>; else goto <D.19435>;
        <D.19434>:
        D.19436 = &MEM[(void *)"startup" + 1B];
        D.19437 = *D.19436;
        D.19438 = (int) D.19437;
        D.19439 = __s2 + 1;
        D.19440 = *D.19439;
        D.19441 = (int) D.19440;
        __result = D.19438 - D.19441;
        D.19442 = __s2_len > 1;
        D.19432 = __result == 0;
        D.19443 = D.19442 & D.19432;
        if (D.19443 != 0) goto <D.19444>; else goto <D.19445>;
        <D.19444>:
        D.19446 = &MEM[(void *)"startup" + 2B];
        D.19447 = *D.19446;
        D.19448 = (int) D.19447;
        D.19449 = __s2 + 2;
        D.19450 = *D.19449;
        D.19451 = (int) D.19450;
        __result = D.19448 - D.19451;
        D.19452 = __s2_len > 2;
        D.19432 = __result == 0;
        D.19453 = D.19452 & D.19432;
        if (D.19453 != 0) goto <D.19454>; else goto <D.19455>;
        <D.19454>:
        D.19456 = &MEM[(void *)"startup" + 3B];
        D.19457 = *D.19456;
        D.19458 = (int) D.19457;
        D.19459 = __s2 + 3;
        D.19460 = *D.19459;
        D.19461 = (int) D.19460;
        __result = D.19458 - D.19461;
        <D.19455>:
        <D.19445>:
        <D.19435>:
      }
      D.18158 = __result;
    }
    iftmp.48 = -D.18158;
    goto <D.19462>;
    <D.19425>:
    iftmp.48 = __builtin_strcmp (element_name, "startup");
    <D.19462>:
    D.18159 = iftmp.48;
  }
  if (D.18159 == 0) goto <D.19463>; else goto <D.19464>;
  <D.19463>:
  D.19465 = app_config->startup_count;
  D.19466 = D.19465 + -1;
  app_config->startup_count = D.19466;
  <D.19464>:
  <D.19422>:
}


start_element (struct GMarkupParseContext * context, const gchar * element_name, const gchar * * attribute_names, const gchar * * attribute_values, void * user_data, struct GError * * error)
{
  int D.18106;
  int iftmp.49;
  int D.18105;
  const char[14] * D.19470;
  unsigned char D.19471;
  int D.19472;
  unsigned char D.19473;
  int D.19474;
  _Bool D.19475;
  _Bool D.19476;
  _Bool D.19477;
  const unsigned char * D.19480;
  unsigned char D.19481;
  int D.19482;
  const unsigned char * D.19483;
  unsigned char D.19484;
  int D.19485;
  _Bool D.19486;
  _Bool D.19487;
  const unsigned char * D.19490;
  unsigned char D.19491;
  int D.19492;
  const unsigned char * D.19493;
  unsigned char D.19494;
  int D.19495;
  _Bool D.19496;
  _Bool D.19497;
  const unsigned char * D.19500;
  unsigned char D.19501;
  int D.19502;
  const unsigned char * D.19503;
  unsigned char D.19504;
  int D.19505;
  int D.19509;
  int D.19510;
  int D.18115;
  int iftmp.50;
  int D.18114;
  const char[8] * D.19514;
  unsigned char D.19515;
  int D.19516;
  unsigned char D.19517;
  int D.19518;
  _Bool D.19519;
  _Bool D.19520;
  _Bool D.19521;
  const unsigned char * D.19524;
  unsigned char D.19525;
  int D.19526;
  const unsigned char * D.19527;
  unsigned char D.19528;
  int D.19529;
  _Bool D.19530;
  _Bool D.19531;
  const unsigned char * D.19534;
  unsigned char D.19535;
  int D.19536;
  const unsigned char * D.19537;
  unsigned char D.19538;
  int D.19539;
  _Bool D.19540;
  _Bool D.19541;
  const unsigned char * D.19544;
  unsigned char D.19545;
  int D.19546;
  const unsigned char * D.19547;
  unsigned char D.19548;
  int D.19549;
  int D.19553;
  int D.19554;
  int D.18124;
  int iftmp.51;
  int D.18123;
  const char[16] * D.19561;
  unsigned char D.19562;
  int D.19563;
  unsigned char D.19564;
  int D.19565;
  _Bool D.19566;
  _Bool D.19567;
  _Bool D.19568;
  const unsigned char * D.19571;
  unsigned char D.19572;
  int D.19573;
  const unsigned char * D.19574;
  unsigned char D.19575;
  int D.19576;
  _Bool D.19577;
  _Bool D.19578;
  const unsigned char * D.19581;
  unsigned char D.19582;
  int D.19583;
  const unsigned char * D.19584;
  unsigned char D.19585;
  int D.19586;
  _Bool D.19587;
  _Bool D.19588;
  const unsigned char * D.19591;
  unsigned char D.19592;
  int D.19593;
  const unsigned char * D.19594;
  unsigned char D.19595;
  int D.19596;
  char * D.19600;
  int D.18133;
  int iftmp.52;
  int D.18132;
  const char[17] * D.19605;
  unsigned char D.19606;
  int D.19607;
  unsigned char D.19608;
  int D.19609;
  _Bool D.19610;
  _Bool D.19611;
  _Bool D.19612;
  const unsigned char * D.19615;
  unsigned char D.19616;
  int D.19617;
  const unsigned char * D.19618;
  unsigned char D.19619;
  int D.19620;
  _Bool D.19621;
  _Bool D.19622;
  const unsigned char * D.19625;
  unsigned char D.19626;
  int D.19627;
  const unsigned char * D.19628;
  unsigned char D.19629;
  int D.19630;
  _Bool D.19631;
  _Bool D.19632;
  const unsigned char * D.19635;
  unsigned char D.19636;
  int D.19637;
  const unsigned char * D.19638;
  unsigned char D.19639;
  int D.19640;
  struct GSList * D.19644;
  struct GSList * D.19645;
  struct AppConfigInfo * app_config;

  app_config = user_data;
  {
    size_t __s1_len;
    size_t __s2_len;

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

      __s2 = element_name;
      D.19470 = "configuration";
      D.19471 = MEM[(const unsigned char *)D.19470];
      D.19472 = (int) D.19471;
      D.19473 = *__s2;
      D.19474 = (int) D.19473;
      __result = D.19472 - D.19474;
      {
        D.19475 = __s2_len != 0;
        D.19476 = __result == 0;
        D.19477 = D.19475 & D.19476;
        if (D.19477 != 0) goto <D.19478>; else goto <D.19479>;
        <D.19478>:
        D.19480 = &MEM[(void *)"configuration" + 1B];
        D.19481 = *D.19480;
        D.19482 = (int) D.19481;
        D.19483 = __s2 + 1;
        D.19484 = *D.19483;
        D.19485 = (int) D.19484;
        __result = D.19482 - D.19485;
        D.19486 = __s2_len > 1;
        D.19476 = __result == 0;
        D.19487 = D.19486 & D.19476;
        if (D.19487 != 0) goto <D.19488>; else goto <D.19489>;
        <D.19488>:
        D.19490 = &MEM[(void *)"configuration" + 2B];
        D.19491 = *D.19490;
        D.19492 = (int) D.19491;
        D.19493 = __s2 + 2;
        D.19494 = *D.19493;
        D.19495 = (int) D.19494;
        __result = D.19492 - D.19495;
        D.19496 = __s2_len > 2;
        D.19476 = __result == 0;
        D.19497 = D.19496 & D.19476;
        if (D.19497 != 0) goto <D.19498>; else goto <D.19499>;
        <D.19498>:
        D.19500 = &MEM[(void *)"configuration" + 3B];
        D.19501 = *D.19500;
        D.19502 = (int) D.19501;
        D.19503 = __s2 + 3;
        D.19504 = *D.19503;
        D.19505 = (int) D.19504;
        __result = D.19502 - D.19505;
        <D.19499>:
        <D.19489>:
        <D.19479>:
      }
      D.18105 = __result;
    }
    iftmp.49 = -D.18105;
    goto <D.19506>;
    <D.19469>:
    iftmp.49 = __builtin_strcmp (element_name, "configuration");
    <D.19506>:
    D.18106 = iftmp.49;
  }
  if (D.18106 == 0) goto <D.19507>; else goto <D.19508>;
  <D.19507>:
  D.19509 = app_config->configuration_count;
  D.19510 = D.19509 + 1;
  app_config->configuration_count = D.19510;
  return;
  <D.19508>:
  {
    size_t __s1_len;
    size_t __s2_len;

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

      __s2 = element_name;
      D.19514 = "startup";
      D.19515 = MEM[(const unsigned char *)D.19514];
      D.19516 = (int) D.19515;
      D.19517 = *__s2;
      D.19518 = (int) D.19517;
      __result = D.19516 - D.19518;
      {
        D.19519 = __s2_len != 0;
        D.19520 = __result == 0;
        D.19521 = D.19519 & D.19520;
        if (D.19521 != 0) goto <D.19522>; else goto <D.19523>;
        <D.19522>:
        D.19524 = &MEM[(void *)"startup" + 1B];
        D.19525 = *D.19524;
        D.19526 = (int) D.19525;
        D.19527 = __s2 + 1;
        D.19528 = *D.19527;
        D.19529 = (int) D.19528;
        __result = D.19526 - D.19529;
        D.19530 = __s2_len > 1;
        D.19520 = __result == 0;
        D.19531 = D.19530 & D.19520;
        if (D.19531 != 0) goto <D.19532>; else goto <D.19533>;
        <D.19532>:
        D.19534 = &MEM[(void *)"startup" + 2B];
        D.19535 = *D.19534;
        D.19536 = (int) D.19535;
        D.19537 = __s2 + 2;
        D.19538 = *D.19537;
        D.19539 = (int) D.19538;
        __result = D.19536 - D.19539;
        D.19540 = __s2_len > 2;
        D.19520 = __result == 0;
        D.19541 = D.19540 & D.19520;
        if (D.19541 != 0) goto <D.19542>; else goto <D.19543>;
        <D.19542>:
        D.19544 = &MEM[(void *)"startup" + 3B];
        D.19545 = *D.19544;
        D.19546 = (int) D.19545;
        D.19547 = __s2 + 3;
        D.19548 = *D.19547;
        D.19549 = (int) D.19548;
        __result = D.19546 - D.19549;
        <D.19543>:
        <D.19533>:
        <D.19523>:
      }
      D.18114 = __result;
    }
    iftmp.50 = -D.18114;
    goto <D.19550>;
    <D.19513>:
    iftmp.50 = __builtin_strcmp (element_name, "startup");
    <D.19550>:
    D.18115 = iftmp.50;
  }
  if (D.18115 == 0) goto <D.19551>; else goto <D.19552>;
  <D.19551>:
  D.19553 = app_config->startup_count;
  D.19554 = D.19553 + 1;
  app_config->startup_count = D.19554;
  return;
  <D.19552>:
  D.19509 = app_config->configuration_count;
  if (D.19509 != 1) goto <D.19555>; else goto <D.19557>;
  <D.19557>:
  D.19553 = app_config->startup_count;
  if (D.19553 != 1) goto <D.19555>; else goto <D.19556>;
  <D.19555>:
  return;
  <D.19556>:
  {
    size_t __s1_len;
    size_t __s2_len;

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

      __s2 = element_name;
      D.19561 = "requiredRuntime";
      D.19562 = MEM[(const unsigned char *)D.19561];
      D.19563 = (int) D.19562;
      D.19564 = *__s2;
      D.19565 = (int) D.19564;
      __result = D.19563 - D.19565;
      {
        D.19566 = __s2_len != 0;
        D.19567 = __result == 0;
        D.19568 = D.19566 & D.19567;
        if (D.19568 != 0) goto <D.19569>; else goto <D.19570>;
        <D.19569>:
        D.19571 = &MEM[(void *)"requiredRuntime" + 1B];
        D.19572 = *D.19571;
        D.19573 = (int) D.19572;
        D.19574 = __s2 + 1;
        D.19575 = *D.19574;
        D.19576 = (int) D.19575;
        __result = D.19573 - D.19576;
        D.19577 = __s2_len > 1;
        D.19567 = __result == 0;
        D.19578 = D.19577 & D.19567;
        if (D.19578 != 0) goto <D.19579>; else goto <D.19580>;
        <D.19579>:
        D.19581 = &MEM[(void *)"requiredRuntime" + 2B];
        D.19582 = *D.19581;
        D.19583 = (int) D.19582;
        D.19584 = __s2 + 2;
        D.19585 = *D.19584;
        D.19586 = (int) D.19585;
        __result = D.19583 - D.19586;
        D.19587 = __s2_len > 2;
        D.19567 = __result == 0;
        D.19588 = D.19587 & D.19567;
        if (D.19588 != 0) goto <D.19589>; else goto <D.19590>;
        <D.19589>:
        D.19591 = &MEM[(void *)"requiredRuntime" + 3B];
        D.19592 = *D.19591;
        D.19593 = (int) D.19592;
        D.19594 = __s2 + 3;
        D.19595 = *D.19594;
        D.19596 = (int) D.19595;
        __result = D.19593 - D.19596;
        <D.19590>:
        <D.19580>:
        <D.19570>:
      }
      D.18123 = __result;
    }
    iftmp.51 = -D.18123;
    goto <D.19597>;
    <D.19560>:
    iftmp.51 = __builtin_strcmp (element_name, "requiredRuntime");
    <D.19597>:
    D.18124 = iftmp.51;
  }
  if (D.18124 == 0) goto <D.19598>; else goto <D.19599>;
  <D.19598>:
  D.19600 = get_attribute_value (attribute_names, attribute_values, "version");
  app_config->required_runtime = D.19600;
  goto <D.19601>;
  <D.19599>:
  {
    size_t __s1_len;
    size_t __s2_len;

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

      __s2 = element_name;
      D.19605 = "supportedRuntime";
      D.19606 = MEM[(const unsigned char *)D.19605];
      D.19607 = (int) D.19606;
      D.19608 = *__s2;
      D.19609 = (int) D.19608;
      __result = D.19607 - D.19609;
      {
        D.19610 = __s2_len != 0;
        D.19611 = __result == 0;
        D.19612 = D.19610 & D.19611;
        if (D.19612 != 0) goto <D.19613>; else goto <D.19614>;
        <D.19613>:
        D.19615 = &MEM[(void *)"supportedRuntime" + 1B];
        D.19616 = *D.19615;
        D.19617 = (int) D.19616;
        D.19618 = __s2 + 1;
        D.19619 = *D.19618;
        D.19620 = (int) D.19619;
        __result = D.19617 - D.19620;
        D.19621 = __s2_len > 1;
        D.19611 = __result == 0;
        D.19622 = D.19621 & D.19611;
        if (D.19622 != 0) goto <D.19623>; else goto <D.19624>;
        <D.19623>:
        D.19625 = &MEM[(void *)"supportedRuntime" + 2B];
        D.19626 = *D.19625;
        D.19627 = (int) D.19626;
        D.19628 = __s2 + 2;
        D.19629 = *D.19628;
        D.19630 = (int) D.19629;
        __result = D.19627 - D.19630;
        D.19631 = __s2_len > 2;
        D.19611 = __result == 0;
        D.19632 = D.19631 & D.19611;
        if (D.19632 != 0) goto <D.19633>; else goto <D.19634>;
        <D.19633>:
        D.19635 = &MEM[(void *)"supportedRuntime" + 3B];
        D.19636 = *D.19635;
        D.19637 = (int) D.19636;
        D.19638 = __s2 + 3;
        D.19639 = *D.19638;
        D.19640 = (int) D.19639;
        __result = D.19637 - D.19640;
        <D.19634>:
        <D.19624>:
        <D.19614>:
      }
      D.18132 = __result;
    }
    iftmp.52 = -D.18132;
    goto <D.19641>;
    <D.19604>:
    iftmp.52 = __builtin_strcmp (element_name, "supportedRuntime");
    <D.19641>:
    D.18133 = iftmp.52;
  }
  if (D.18133 == 0) goto <D.19642>; else goto <D.19643>;
  <D.19642>:
  {
    char * version;

    version = get_attribute_value (attribute_names, attribute_values, "version");
    D.19644 = app_config->supported_runtimes;
    D.19645 = monoeg_g_slist_append (D.19644, version);
    app_config->supported_runtimes = D.19645;
  }
  <D.19643>:
  <D.19601>:
}


get_attribute_value (const gchar * * attribute_names, const gchar * * attribute_values, const char * att_name)
{
  int D.18085;
  unsigned int n.53;
  unsigned int D.19648;
  const gchar * * D.19649;
  const gchar * D.19650;
  char * D.19653;
  const gchar * * D.19654;
  const gchar * D.19655;
  int n;

  n = 0;
  goto <D.18087>;
  <D.18086>:
  {
    size_t __s1_len;
    size_t __s2_len;

    n.53 = (unsigned int) n;
    D.19648 = n.53 * 4;
    D.19649 = attribute_names + D.19648;
    D.19650 = *D.19649;
    D.18085 = __builtin_strcmp (D.19650, att_name);
  }
  if (D.18085 == 0) goto <D.19651>; else goto <D.19652>;
  <D.19651>:
  n.53 = (unsigned int) n;
  D.19648 = n.53 * 4;
  D.19654 = attribute_values + D.19648;
  D.19655 = *D.19654;
  D.19653 = monoeg_strdup (D.19655);
  return D.19653;
  <D.19652>:
  n = n + 1;
  <D.18087>:
  n.53 = (unsigned int) n;
  D.19648 = n.53 * 4;
  D.19649 = attribute_names + D.19648;
  D.19650 = *D.19649;
  if (D.19650 != 0B) goto <D.18086>; else goto <D.18088>;
  <D.18088>:
  D.19653 = 0B;
  return D.19653;
}


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

  if (str != 0B) goto <D.19657>; else goto <D.19658>;
  <D.19657>:
  D.19659 = __strdup (str);
  return D.19659;
  <D.19658>:
  D.19659 = 0B;
  return D.19659;
}


app_config_free (struct AppConfigInfo * app_config)
{
  struct GSList * iftmp.54;
  struct GSList * D.19665;
  char * D.19666;
  char * rt;
  struct GSList * list;

  list = app_config->supported_runtimes;
  goto <D.18176>;
  <D.18175>:
  rt = list->data;
  monoeg_g_free (rt);
  if (list != 0B) goto <D.19662>; else goto <D.19663>;
  <D.19662>:
  iftmp.54 = list->next;
  goto <D.19664>;
  <D.19663>:
  iftmp.54 = 0B;
  <D.19664>:
  list = iftmp.54;
  <D.18176>:
  if (list != 0B) goto <D.18175>; else goto <D.18177>;
  <D.18177>:
  D.19665 = app_config->supported_runtimes;
  monoeg_g_slist_free (D.19665);
  D.19666 = app_config->required_runtime;
  monoeg_g_free (D.19666);
  monoeg_g_free (app_config);
}


get_runtime_by_version (const char * version)
{
  const struct MonoRuntimeInfo * D.19669;
  int D.18192;
  const char[12] * D.19670;
  unsigned int D.19673;
  const char * D.19676;
  char D.19677;
  int D.19680;
  int n;
  int max;
  int vlen;

  max = 6;
  if (version == 0B) goto <D.19667>; else goto <D.19668>;
  <D.19667>:
  D.19669 = 0B;
  return D.19669;
  <D.19668>:
  n = 0;
  goto <D.18194>;
  <D.18193>:
  {
    size_t __s1_len;
    size_t __s2_len;

    D.19670 = &supported_runtimes[n].runtime_version;
    D.18192 = __builtin_strcmp (version, D.19670);
  }
  if (D.18192 == 0) goto <D.19671>; else goto <D.19672>;
  <D.19671>:
  D.19669 = &supported_runtimes[n];
  return D.19669;
  <D.19672>:
  n = n + 1;
  <D.18194>:
  if (n < max) goto <D.18193>; else goto <D.18195>;
  <D.18195>:
  D.19673 = strlen (version);
  vlen = (int) D.19673;
  if (vlen > 3) goto <D.19674>; else goto <D.19675>;
  <D.19674>:
  D.19676 = version + 1;
  D.19677 = *D.19676;
  if (D.19677 > 51) goto <D.19678>; else goto <D.19679>;
  <D.19678>:
  n = 0;
  goto <D.18206>;
  <D.18205>:
  D.19670 = &supported_runtimes[n].runtime_version;
  D.19680 = strncmp (version, D.19670, 4);
  if (D.19680 == 0) goto <D.19681>; else goto <D.19682>;
  <D.19681>:
  D.19669 = &supported_runtimes[n];
  return D.19669;
  <D.19682>:
  n = n + 1;
  <D.18206>:
  if (n < max) goto <D.18205>; else goto <D.18207>;
  <D.18207>:
  <D.19679>:
  <D.19675>:
  D.19669 = 0B;
  return D.19669;
}


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

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


mono_init_from_assembly (const char * domain_name, const char * filename)
{
  struct MonoDomain * D.19686;

  D.19686 = mono_init_internal (domain_name, filename, 0B);
  return D.19686;
}


mono_init_version (const char * domain_name, const char * version)
{
  struct MonoDomain * D.19688;

  D.19688 = mono_init_internal (domain_name, 0B, version);
  return D.19688;
}


mono_cleanup ()
{
  unsigned int appdomain_thread_id.55;

  mono_close_exe_image ();
  mono_defaults.corlib = 0B;
  mono_config_cleanup ();
  mono_loader_cleanup ();
  mono_classes_cleanup ();
  mono_assemblies_cleanup ();
  mono_images_cleanup ();
  mono_debug_cleanup ();
  mono_metadata_cleanup ();
  appdomain_thread_id.55 = appdomain_thread_id;
  mono_native_tls_free (appdomain_thread_id.55);
  DeleteCriticalSection (&appdomains_mutex);
  wapi_cleanup ();
}


mono_native_tls_free (pthread_key_t key)
{
  pthread_key_delete (key);
}


mono_close_exe_image ()
{
  struct MonoImage * exe_image.56;

  exe_image.56 = exe_image;
  if (exe_image.56 != 0B) goto <D.19692>; else goto <D.19693>;
  <D.19692>:
  exe_image.56 = exe_image;
  mono_image_close (exe_image.56);
  <D.19693>:
}


mono_get_root_domain ()
{
  struct MonoDomain * D.19694;

  D.19694 = mono_root_domain;
  return D.19694;
}


mono_domain_get ()
{
  struct MonoDomain * D.19696;

  D.19696 = tls_appdomain;
  return D.19696;
}


mono_domain_unset ()
{
  unsigned int appdomain_thread_id.57;

  tls_appdomain = 0B;
  appdomain_thread_id.57 = appdomain_thread_id;
  mono_native_tls_set_value (appdomain_thread_id.57, 0B);
  mono_gc_set_current_thread_appdomain (0B);
}


mono_domain_set_internal_with_options (struct MonoDomain * domain, gboolean migrate_exception)
{
  struct MonoDomain * D.19699;
  unsigned int appdomain_thread_id.58;
  struct MonoAppContext * D.19703;
  struct MonoInternalThread * D.19704;
  struct MonoAppContext * * D.19705;
  struct MonoInternalThread * D.19706;
  struct MonoException * D.19709;
  struct MonoVTable * D.19712;
  struct MonoDomain * D.19713;
  _Bool D.19714;
  long int D.19715;
  long int D.19716;
  struct MonoException * D.19719;
  struct MonoException * * D.19720;
  _Bool D.19721;
  long int D.19722;
  long int D.19723;
  struct MonoInternalThread * thread;

  D.19699 = mono_domain_get ();
  if (D.19699 == domain) goto <D.19700>; else goto <D.19701>;
  <D.19700>:
  return;
  <D.19701>:
  tls_appdomain = domain;
  appdomain_thread_id.58 = appdomain_thread_id;
  mono_native_tls_set_value (appdomain_thread_id.58, domain);
  mono_gc_set_current_thread_appdomain (domain);
  D.19703 = domain->default_context;
  D.19704 = mono_thread_internal_current ();
  D.19705 = &D.19704->current_appcontext;
  D.19706 = mono_thread_internal_current ();
  mono_gc_wbarrier_set_field (D.19706, D.19705, D.19703);
  if (migrate_exception != 0) goto <D.19707>; else goto <D.19708>;
  <D.19707>:
  thread = mono_thread_internal_current ();
  D.19709 = thread->abort_exc;
  if (D.19709 == 0B) goto <D.19710>; else goto <D.19711>;
  <D.19710>:
  return;
  <D.19711>:
  D.19709 = thread->abort_exc;
  D.19712 = D.19709->object.vtable;
  D.19713 = D.19712->domain;
  D.19714 = D.19713 == domain;
  D.19715 = (long int) D.19714;
  D.19716 = __builtin_expect (D.19715, 0);
  if (D.19716 != 0) goto <D.19717>; else goto <D.19718>;
  <D.19717>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "domain.c", 1830, "thread->abort_exc->object.vtable->domain != domain");
  <D.19718>:
  D.19719 = mono_get_exception_thread_abort ();
  D.19720 = &thread->abort_exc;
  mono_gc_wbarrier_set_field (thread, D.19720, D.19719);
  D.19709 = thread->abort_exc;
  D.19712 = D.19709->object.vtable;
  D.19713 = D.19712->domain;
  D.19721 = D.19713 != domain;
  D.19722 = (long int) D.19721;
  D.19723 = __builtin_expect (D.19722, 0);
  if (D.19723 != 0) goto <D.19724>; else goto <D.19725>;
  <D.19724>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "domain.c", 1832, "thread->abort_exc->object.vtable->domain == domain");
  <D.19725>:
  <D.19708>:
}


mono_domain_set_internal (struct MonoDomain * domain)
{
  mono_domain_set_internal_with_options (domain, 1);
}


mono_domain_foreach (void (*MonoDomainFunc) (struct MonoDomain *, void *) func, void * user_data)
{
  _Bool D.19729;
  long int D.19730;
  long int D.19731;
  short unsigned int appdomain_list_size.59;
  unsigned int D.19735;
  unsigned int D.19736;
  struct MonoDomain * * appdomains_list.60;
  _Bool D.19740;
  long int D.19741;
  long int D.19742;
  unsigned int i.61;
  unsigned int D.19746;
  struct MonoDomain * * D.19747;
  struct MonoDomain * D.19748;
  int i;
  int size;
  struct MonoDomain * * copy;

  {
    int ret;

    ret = pthread_mutex_lock (&appdomains_mutex.mutex);
    if (ret != 0) goto <D.19727>; else goto <D.19728>;
    <D.19727>:
    monoeg_g_log (0B, 16, "Bad call to mono_mutex_lock result %d", ret);
    <D.19728>:
    D.19729 = ret != 0;
    D.19730 = (long int) D.19729;
    D.19731 = __builtin_expect (D.19730, 0);
    if (D.19731 != 0) goto <D.19732>; else goto <D.19733>;
    <D.19732>:
    monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "domain.c", 1859, "ret == 0");
    <D.19733>:
  }
  appdomain_list_size.59 = appdomain_list_size;
  size = (int) appdomain_list_size.59;
  appdomain_list_size.59 = appdomain_list_size;
  D.19735 = (unsigned int) appdomain_list_size.59;
  D.19736 = D.19735 * 4;
  copy = mono_gc_alloc_fixed (D.19736, 0B);
  appdomain_list_size.59 = appdomain_list_size;
  D.19735 = (unsigned int) appdomain_list_size.59;
  D.19736 = D.19735 * 4;
  appdomains_list.60 = appdomains_list;
  memcpy (copy, appdomains_list.60, D.19736);
  {
    int ret;

    ret = pthread_mutex_unlock (&appdomains_mutex.mutex);
    if (ret != 0) goto <D.19738>; else goto <D.19739>;
    <D.19738>:
    monoeg_g_log (0B, 16, "Bad call to mono_mutex_unlock result %d", ret);
    <D.19739>:
    D.19740 = ret != 0;
    D.19741 = (long int) D.19740;
    D.19742 = __builtin_expect (D.19741, 0);
    if (D.19742 != 0) goto <D.19743>; else goto <D.19744>;
    <D.19743>:
    monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "domain.c", 1863, "ret == 0");
    <D.19744>:
  }
  i = 0;
  goto <D.17858>;
  <D.17857>:
  i.61 = (unsigned int) i;
  D.19746 = i.61 * 4;
  D.19747 = copy + D.19746;
  D.19748 = *D.19747;
  if (D.19748 != 0B) goto <D.19749>; else goto <D.19750>;
  <D.19749>:
  i.61 = (unsigned int) i;
  D.19746 = i.61 * 4;
  D.19747 = copy + D.19746;
  D.19748 = *D.19747;
  func (D.19748, user_data);
  <D.19750>:
  i = i + 1;
  <D.17858>:
  if (i < size) goto <D.17857>; else goto <D.17859>;
  <D.17859>:
  mono_gc_free_fixed (copy);
}


mono_domain_assembly_open (struct MonoDomain * domain, const char * name)
{
  union mono_mutex_t * D.19751;
  _Bool D.19754;
  long int D.19755;
  long int D.19756;
  int D.17876;
  const char * D.19759;
  _Bool D.19764;
  long int D.19765;
  long int D.19766;
  struct MonoAssembly * D.19769;
  _Bool D.19772;
  long int D.19773;
  long int D.19774;
  struct MonoDomain * D.19777;
  struct MonoDomain * current;
  struct MonoAssembly * ass;
  struct GSList * tmp;

  {
    int ret;

    D.19751 = &domain->assemblies_lock.mutex;
    ret = pthread_mutex_lock (D.19751);
    if (ret != 0) goto <D.19752>; else goto <D.19753>;
    <D.19752>:
    monoeg_g_log (0B, 16, "Bad call to mono_mutex_lock result %d", ret);
    <D.19753>:
    D.19754 = ret != 0;
    D.19755 = (long int) D.19754;
    D.19756 = __builtin_expect (D.19755, 0);
    if (D.19756 != 0) goto <D.19757>; else goto <D.19758>;
    <D.19757>:
    monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "domain.c", 1887, "ret == 0");
    <D.19758>:
  }
  tmp = domain->domain_assemblies;
  goto <D.17879>;
  <D.17878>:
  ass = tmp->data;
  {
    size_t __s1_len;
    size_t __s2_len;

    D.19759 = ass->aname.name;
    D.17876 = __builtin_strcmp (name, D.19759);
  }
  if (D.17876 == 0) goto <D.19760>; else goto <D.19761>;
  <D.19760>:
  {
    int ret;

    D.19751 = &domain->assemblies_lock.mutex;
    ret = pthread_mutex_unlock (D.19751);
    if (ret != 0) goto <D.19762>; else goto <D.19763>;
    <D.19762>:
    monoeg_g_log (0B, 16, "Bad call to mono_mutex_unlock result %d", ret);
    <D.19763>:
    D.19764 = ret != 0;
    D.19765 = (long int) D.19764;
    D.19766 = __builtin_expect (D.19765, 0);
    if (D.19766 != 0) goto <D.19767>; else goto <D.19768>;
    <D.19767>:
    monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "domain.c", 1891, "ret == 0");
    <D.19768>:
  }
  D.19769 = ass;
  return D.19769;
  <D.19761>:
  tmp = tmp->next;
  <D.17879>:
  if (tmp != 0B) goto <D.17878>; else goto <D.17880>;
  <D.17880>:
  {
    int ret;

    D.19751 = &domain->assemblies_lock.mutex;
    ret = pthread_mutex_unlock (D.19751);
    if (ret != 0) goto <D.19770>; else goto <D.19771>;
    <D.19770>:
    monoeg_g_log (0B, 16, "Bad call to mono_mutex_unlock result %d", ret);
    <D.19771>:
    D.19772 = ret != 0;
    D.19773 = (long int) D.19772;
    D.19774 = __builtin_expect (D.19773, 0);
    if (D.19774 != 0) goto <D.19775>; else goto <D.19776>;
    <D.19775>:
    monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "domain.c", 1895, "ret == 0");
    <D.19776>:
  }
  D.19777 = mono_domain_get ();
  if (D.19777 != domain) goto <D.19778>; else goto <D.19779>;
  <D.19778>:
  current = mono_domain_get ();
  mono_domain_set (domain, 0);
  ass = mono_assembly_open (name, 0B);
  mono_domain_set (current, 0);
  goto <D.19780>;
  <D.19779>:
  ass = mono_assembly_open (name, 0B);
  <D.19780>:
  D.19769 = ass;
  return D.19769;
}


mono_domain_free (struct MonoDomain * domain, gboolean force)
{
  struct MonoDomain * mono_root_domain.62;
  int mono_dont_free_domains.63;
  _Bool D.19792;
  long int D.19793;
  long int D.19794;
  struct MonoDomain * * appdomains_list.64;
  int D.19798;
  unsigned int D.19799;
  unsigned int D.19800;
  struct MonoDomain * * D.19801;
  _Bool D.19804;
  long int D.19805;
  long int D.19806;
  struct GHashTable * D.19809;
  struct MonoGHashTable * D.19812;
  struct MonoGHashTable * D.19813;
  struct MonoTlsDataRecord * D.19814;
  struct MonoGHashTable * D.19817;
  struct MonoGHashTable * D.19820;
  struct GPtrArray * D.19823;
  void * * D.19826;
  unsigned int i.65;
  unsigned int D.19828;
  void * * D.19829;
  void * D.19830;
  unsigned int i.66;
  unsigned int D.19832;
  struct MonoGHashTable * * D.19833;
  struct MonoImage * D.19836;
  unsigned char D.19838;
  unsigned char D.19839;
  int D.19840;
  const char * D.19841;
  char * D.19842;
  int D.19843;
  struct MonoImage * D.19850;
  unsigned char D.19852;
  unsigned char D.19853;
  int D.19854;
  const char * D.19855;
  int D.19856;
  struct GSList * D.19861;
  void (*<T1923>) (struct MonoDomain *) free_domain_hook.67;
  gchar * * D.19865;
  struct GHashTable * D.19868;
  void * * D.19869;
  struct MonoInternalHashTable * D.19872;
  struct MonoJitInfoTable * D.19873;
  struct MonoJitInfoTable * D.19876;
  int D.19877;
  _Bool D.19878;
  long int D.19879;
  long int D.19880;
  struct MonoJitInfoTable * D.19883;
  struct GSList * D.19884;
  _Bool D.19885;
  long int D.19886;
  long int D.19887;
  struct MonoCodeManager * D.19890;
  int total_domain_code_alloc.68;
  int total_domain_code_alloc.69;
  int max_domain_code_alloc.70;
  int max_domain_code_alloc.71;
  int code_size.72;
  int max_domain_code_size.73;
  int max_domain_code_size.74;
  struct MonoMemPool * D.19898;
  struct LockFreeMempool * D.19899;
  struct GHashTable * D.19900;
  struct GHashTable * D.19901;
  struct GHashTable * D.19904;
  struct GHashTable * D.19907;
  struct GHashTable * D.19910;
  struct CRITICAL_SECTION * D.19913;
  struct CRITICAL_SECTION * D.19914;
  struct CRITICAL_SECTION * D.19915;
  struct CRITICAL_SECTION * D.19916;
  struct MonoPerfCounters * mono_perfcounters.75;
  unsigned int D.19918;
  unsigned int D.19919;
  int code_size;
  int code_alloc;
  struct GSList * tmp;
  void * * p;

  try
    {
      mono_root_domain.62 = mono_root_domain;
      if (domain == mono_root_domain.62) goto <D.19783>; else goto <D.19784>;
      <D.19783>:
      if (force == 0) goto <D.19785>; else goto <D.19786>;
      <D.19785>:
      monoeg_g_log (0B, 16, "cant unload root domain");
      return;
      <D.19786>:
      <D.19784>:
      mono_dont_free_domains.63 = mono_dont_free_domains;
      if (mono_dont_free_domains.63 != 0) goto <D.19788>; else goto <D.19789>;
      <D.19788>:
      return;
      <D.19789>:
      mono_profiler_appdomain_event (domain, 2);
      mono_debug_domain_unload (domain);
      {
        int ret;

        ret = pthread_mutex_lock (&appdomains_mutex.mutex);
        if (ret != 0) goto <D.19790>; else goto <D.19791>;
        <D.19790>:
        monoeg_g_log (0B, 16, "Bad call to mono_mutex_lock result %d", ret);
        <D.19791>:
        D.19792 = ret != 0;
        D.19793 = (long int) D.19792;
        D.19794 = __builtin_expect (D.19793, 0);
        if (D.19794 != 0) goto <D.19795>; else goto <D.19796>;
        <D.19795>:
        monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "domain.c", 1938, "ret == 0");
        <D.19796>:
      }
      appdomains_list.64 = appdomains_list;
      D.19798 = domain->domain_id;
      D.19799 = (unsigned int) D.19798;
      D.19800 = D.19799 * 4;
      D.19801 = appdomains_list.64 + D.19800;
      *D.19801 = 0B;
      {
        int ret;

        ret = pthread_mutex_unlock (&appdomains_mutex.mutex);
        if (ret != 0) goto <D.19802>; else goto <D.19803>;
        <D.19802>:
        monoeg_g_log (0B, 16, "Bad call to mono_mutex_unlock result %d", ret);
        <D.19803>:
        D.19804 = ret != 0;
        D.19805 = (long int) D.19804;
        D.19806 = __builtin_expect (D.19805, 0);
        if (D.19806 != 0) goto <D.19807>; else goto <D.19808>;
        <D.19807>:
        monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "domain.c", 1940, "ret == 0");
        <D.19808>:
      }
      D.19809 = domain->special_static_fields;
      if (D.19809 != 0B) goto <D.19810>; else goto <D.19811>;
      <D.19810>:
      D.19809 = domain->special_static_fields;
      mono_alloc_special_static_data_free (D.19809);
      D.19809 = domain->special_static_fields;
      monoeg_g_hash_table_destroy (D.19809);
      domain->special_static_fields = 0B;
      <D.19811>:
      D.19812 = domain->ldstr_table;
      mono_g_hash_table_destroy (D.19812);
      domain->ldstr_table = 0B;
      D.19813 = domain->env;
      mono_g_hash_table_destroy (D.19813);
      domain->env = 0B;
      D.19814 = domain->tlsrec_list;
      if (D.19814 != 0B) goto <D.19815>; else goto <D.19816>;
      <D.19815>:
      mono_thread_destroy_domain_tls (domain);
      domain->tlsrec_list = 0B;
      <D.19816>:
      mono_reflection_cleanup_domain (domain);
      D.19817 = domain->type_hash;
      if (D.19817 != 0B) goto <D.19818>; else goto <D.19819>;
      <D.19818>:
      D.19817 = domain->type_hash;
      mono_g_hash_table_destroy (D.19817);
      domain->type_hash = 0B;
      <D.19819>:
      D.19820 = domain->type_init_exception_hash;
      if (D.19820 != 0B) goto <D.19821>; else goto <D.19822>;
      <D.19821>:
      D.19820 = domain->type_init_exception_hash;
      mono_g_hash_table_destroy (D.19820);
      domain->type_init_exception_hash = 0B;
      <D.19822>:
      D.19823 = domain->class_vtable_array;
      if (D.19823 != 0B) goto <D.19824>; else goto <D.19825>;
      <D.19824>:
      {
        int i;

        i = 0;
        goto <D.17898>;
        <D.17897>:
        D.19823 = domain->class_vtable_array;
        D.19826 = D.19823->pdata;
        i.65 = (unsigned int) i;
        D.19828 = i.65 * 4;
        D.19829 = D.19826 + D.19828;
        D.19830 = *D.19829;
        unregister_vtable_reflection_type (D.19830);
        i = i + 1;
        <D.17898>:
        i.66 = (unsigned int) i;
        D.19823 = domain->class_vtable_array;
        D.19832 = D.19823->len;
        if (i.66 < D.19832) goto <D.17897>; else goto <D.17899>;
        <D.17899>:
      }
      <D.19825>:
      tmp = domain->domain_assemblies;
      goto <D.17902>;
      <D.17901>:
      {
        struct MonoAssembly * ass;

        ass = tmp->data;
        mono_assembly_release_gc_roots (ass);
      }
      tmp = tmp->next;
      <D.17902>:
      if (tmp != 0B) goto <D.17901>; else goto <D.17903>;
      <D.17903>:
      p = &domain->setup;
      goto <D.17905>;
      <D.17904>:
      *p = 0B;
      p = p + 4;
      <D.17905>:
      D.19833 = &domain->env;
      if (D.19833 > p) goto <D.17904>; else goto <D.17906>;
      <D.17906>:
      mono_gc_clear_domain (domain);
      tmp = domain->domain_assemblies;
      goto <D.17910>;
      <D.17909>:
      {
        struct MonoAssembly * ass;

        ass = tmp->data;
        D.19836 = ass->image;
        if (D.19836 == 0B) goto <D.19834>; else goto <D.19837>;
        <D.19837>:
        D.19836 = ass->image;
        D.19838 = BIT_FIELD_REF <*D.19836, 8, 128>;
        D.19839 = D.19838 & 8;
        if (D.19839 == 0) goto <D.19834>; else goto <D.19835>;
        <D.19834>:
        // predicted unlikely by continue predictor.
        goto <D.17908>;
        <D.19835>:
        D.19840 = ass->ref_count;
        D.19841 = ass->aname.name;
        D.19842 = domain->friendly_name;
        mono_trace (64, 1, "Unloading domain %s[%p], assembly %s[%p], ref_count=%d", D.19842, domain, D.19841, ass, D.19840);
        D.19843 = mono_assembly_close_except_image_pools (ass);
        if (D.19843 == 0) goto <D.19844>; else goto <D.19845>;
        <D.19844>:
        tmp->data = 0B;
        <D.19845>:
      }
      <D.17908>:
      tmp = tmp->next;
      <D.17910>:
      if (tmp != 0B) goto <D.17909>; else goto <D.17911>;
      <D.17911>:
      tmp = domain->domain_assemblies;
      goto <D.17915>;
      <D.17914>:
      {
        struct MonoAssembly * ass;

        ass = tmp->data;
        if (ass == 0B) goto <D.19846>; else goto <D.19847>;
        <D.19846>:
        // predicted unlikely by continue predictor.
        goto <D.17913>;
        <D.19847>:
        D.19850 = ass->image;
        if (D.19850 == 0B) goto <D.19848>; else goto <D.19851>;
        <D.19851>:
        D.19850 = ass->image;
        D.19852 = BIT_FIELD_REF <*D.19850, 8, 128>;
        D.19853 = D.19852 & 8;
        if (D.19853 != 0) goto <D.19848>; else goto <D.19849>;
        <D.19848>:
        // predicted unlikely by continue predictor.
        goto <D.17913>;
        <D.19849>:
        D.19854 = ass->ref_count;
        D.19855 = ass->aname.name;
        D.19842 = domain->friendly_name;
        mono_trace (64, 1, "Unloading domain %s[%p], assembly %s[%p], ref_count=%d", D.19842, domain, D.19855, ass, D.19854);
        D.19856 = mono_assembly_close_except_image_pools (ass);
        if (D.19856 == 0) goto <D.19857>; else goto <D.19858>;
        <D.19857>:
        tmp->data = 0B;
        <D.19858>:
      }
      <D.17913>:
      tmp = tmp->next;
      <D.17915>:
      if (tmp != 0B) goto <D.17914>; else goto <D.17916>;
      <D.17916>:
      tmp = domain->domain_assemblies;
      goto <D.17919>;
      <D.17918>:
      {
        struct MonoAssembly * ass;

        ass = tmp->data;
        if (ass != 0B) goto <D.19859>; else goto <D.19860>;
        <D.19859>:
        mono_assembly_close_finish (ass);
        <D.19860>:
      }
      tmp = tmp->next;
      <D.17919>:
      if (tmp != 0B) goto <D.17918>; else goto <D.17920>;
      <D.17920>:
      D.19861 = domain->domain_assemblies;
      monoeg_g_slist_free (D.19861);
      domain->domain_assemblies = 0B;
      mono_profiler_appdomain_event (domain, 3);
      free_domain_hook.67 = free_domain_hook;
      if (free_domain_hook.67 != 0B) goto <D.19863>; else goto <D.19864>;
      <D.19863>:
      free_domain_hook.67 = free_domain_hook;
      free_domain_hook.67 (domain);
      <D.19864>:
      D.19865 = domain->search_path;
      if (D.19865 != 0B) goto <D.19866>; else goto <D.19867>;
      <D.19866>:
      D.19865 = domain->search_path;
      monoeg_g_strfreev (D.19865);
      domain->search_path = 0B;
      <D.19867>:
      domain->create_proxy_for_type_method = 0B;
      domain->private_invoke_method = 0B;
      domain->default_context = 0B;
      domain->out_of_memory_ex = 0B;
      domain->null_reference_ex = 0B;
      domain->stack_overflow_ex = 0B;
      domain->ephemeron_tombstone = 0B;
      domain->entry_assembly = 0B;
      D.19842 = domain->friendly_name;
      monoeg_g_free (D.19842);
      domain->friendly_name = 0B;
      D.19823 = domain->class_vtable_array;
      monoeg_g_ptr_array_free (D.19823, 1);
      domain->class_vtable_array = 0B;
      D.19868 = domain->proxy_vtable_hash;
      monoeg_g_hash_table_destroy (D.19868);
      domain->proxy_vtable_hash = 0B;
      D.19869 = domain->static_data_array;
      if (D.19869 != 0B) goto <D.19870>; else goto <D.19871>;
      <D.19870>:
      D.19869 = domain->static_data_array;
      mono_gc_free_fixed (D.19869);
      domain->static_data_array = 0B;
      <D.19871>:
      D.19872 = &domain->jit_code_hash;
      mono_internal_hash_table_destroy (D.19872);
      mono_thread_hazardous_try_free_all ();
      D.19873 = domain->aot_modules;
      if (D.19873 != 0B) goto <D.19874>; else goto <D.19875>;
      <D.19874>:
      D.19876 = domain->aot_modules;
      jit_info_table_free (D.19876);
      <D.19875>:
      D.19877 = domain->num_jit_info_tables;
      D.19878 = D.19877 != 1;
      D.19879 = (long int) D.19878;
      D.19880 = __builtin_expect (D.19879, 0);
      if (D.19880 != 0) goto <D.19881>; else goto <D.19882>;
      <D.19881>:
      monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "domain.c", 2068, "domain->num_jit_info_tables == 1");
      <D.19882>:
      D.19883 = domain->jit_info_table;
      jit_info_table_free (D.19883);
      domain->jit_info_table = 0B;
      D.19884 = domain->jit_info_free_queue;
      D.19885 = D.19884 != 0B;
      D.19886 = (long int) D.19885;
      D.19887 = __builtin_expect (D.19886, 0);
      if (D.19887 != 0) goto <D.19888>; else goto <D.19889>;
      <D.19888>:
      monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "domain.c", 2071, "!domain->jit_info_free_queue");
      <D.19889>:
      D.19890 = domain->code_mp;
      code_alloc = mono_code_manager_size (D.19890, &code_size);
      total_domain_code_alloc.68 = total_domain_code_alloc;
      total_domain_code_alloc.69 = total_domain_code_alloc.68 + code_alloc;
      total_domain_code_alloc = total_domain_code_alloc.69;
      max_domain_code_alloc.70 = max_domain_code_alloc;
      max_domain_code_alloc.71 = MAX_EXPR <code_alloc, max_domain_code_alloc.70>;
      max_domain_code_alloc = max_domain_code_alloc.71;
      code_size.72 = code_size;
      max_domain_code_size.73 = max_domain_code_size;
      max_domain_code_size.74 = MAX_EXPR <code_size.72, max_domain_code_size.73>;
      max_domain_code_size = max_domain_code_size.74;
      D.19898 = domain->mp;
      mono_mempool_invalidate (D.19898);
      D.19890 = domain->code_mp;
      mono_code_manager_invalidate (D.19890);
      D.19899 = domain->lock_free_mp;
      lock_free_mempool_free (D.19899);
      domain->lock_free_mp = 0B;
      D.19900 = domain->finalizable_objects_hash;
      monoeg_g_hash_table_destroy (D.19900);
      domain->finalizable_objects_hash = 0B;
      D.19901 = domain->method_rgctx_hash;
      if (D.19901 != 0B) goto <D.19902>; else goto <D.19903>;
      <D.19902>:
      D.19901 = domain->method_rgctx_hash;
      monoeg_g_hash_table_destroy (D.19901);
      domain->method_rgctx_hash = 0B;
      <D.19903>:
      D.19904 = domain->generic_virtual_cases;
      if (D.19904 != 0B) goto <D.19905>; else goto <D.19906>;
      <D.19905>:
      D.19904 = domain->generic_virtual_cases;
      monoeg_g_hash_table_destroy (D.19904);
      domain->generic_virtual_cases = 0B;
      <D.19906>:
      D.19907 = domain->generic_virtual_thunks;
      if (D.19907 != 0B) goto <D.19908>; else goto <D.19909>;
      <D.19908>:
      D.19907 = domain->generic_virtual_thunks;
      monoeg_g_hash_table_destroy (D.19907);
      domain->generic_virtual_thunks = 0B;
      <D.19909>:
      D.19910 = domain->ftnptrs_hash;
      if (D.19910 != 0B) goto <D.19911>; else goto <D.19912>;
      <D.19911>:
      D.19910 = domain->ftnptrs_hash;
      monoeg_g_hash_table_destroy (D.19910);
      domain->ftnptrs_hash = 0B;
      <D.19912>:
      D.19913 = &domain->finalizable_objects_hash_lock;
      DeleteCriticalSection (D.19913);
      D.19914 = &domain->assemblies_lock;
      DeleteCriticalSection (D.19914);
      D.19915 = &domain->jit_code_hash_lock;
      DeleteCriticalSection (D.19915);
      D.19916 = &domain->lock;
      DeleteCriticalSection (D.19916);
      domain->setup = 0B;
      D.19833 = &domain->env;
      mono_gc_deregister_root (D.19833);
      mono_gc_free_fixed (domain);
      mono_perfcounters.75 = mono_perfcounters;
      D.19918 = mono_perfcounters.75->loader_appdomains;
      D.19919 = D.19918 + 4294967295;
      mono_perfcounters.75->loader_appdomains = D.19919;
      mono_root_domain.62 = mono_root_domain;
      if (domain == mono_root_domain.62) goto <D.19920>; else goto <D.19921>;
      <D.19920>:
      mono_root_domain = 0B;
      <D.19921>:
    }
  finally
    {
      code_size = {CLOBBER};
    }
}


unregister_vtable_reflection_type (struct MonoVTable * vtable)
{
  struct MonoVTable * D.19925;
  struct MonoClass * D.19926;
  struct MonoClass * D.19927;
  int D.19930;
  void * * D.19933;
  struct MonoObject * type;

  type = vtable->type;
  D.19925 = type->vtable;
  D.19926 = D.19925->klass;
  D.19927 = mono_defaults.monotype_class;
  if (D.19926 != D.19927) goto <D.19928>; else goto <D.19929>;
  <D.19928>:
  D.19930 = mono_gc_is_moving ();
  if (D.19930 != 0) goto <D.19931>; else goto <D.19932>;
  <D.19931>:
  D.19933 = &vtable->type;
  mono_gc_deregister_root (D.19933);
  <D.19932>:
  <D.19929>:
}


lock_free_mempool_free (struct LockFreeMempool * mp)
{
  int D.19934;
  unsigned int D.19935;
  struct LockFreeMempoolChunk * chunk;
  struct LockFreeMempoolChunk * next;

  chunk = mp->chunks;
  goto <D.17708>;
  <D.17707>:
  next = chunk->prev;
  D.19934 = mono_pagesize ();
  D.19935 = (unsigned int) D.19934;
  mono_vfree (chunk, D.19935);
  chunk = next;
  <D.17708>:
  if (chunk != 0B) goto <D.17707>; else goto <D.17709>;
  <D.17709>:
}


mono_domain_get_by_id (gint32 domainid)
{
  _Bool D.19938;
  long int D.19939;
  long int D.19940;
  short unsigned int appdomain_list_size.76;
  int D.19944;
  struct MonoDomain * * appdomains_list.77;
  unsigned int domainid.78;
  unsigned int D.19949;
  struct MonoDomain * * D.19950;
  _Bool D.19954;
  long int D.19955;
  long int D.19956;
  struct MonoDomain * D.19959;
  struct MonoDomain * domain;

  {
    int ret;

    ret = pthread_mutex_lock (&appdomains_mutex.mutex);
    if (ret != 0) goto <D.19936>; else goto <D.19937>;
    <D.19936>:
    monoeg_g_log (0B, 16, "Bad call to mono_mutex_lock result %d", ret);
    <D.19937>:
    D.19938 = ret != 0;
    D.19939 = (long int) D.19938;
    D.19940 = __builtin_expect (D.19939, 0);
    if (D.19940 != 0) goto <D.19941>; else goto <D.19942>;
    <D.19941>:
    monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "domain.c", 2144, "ret == 0");
    <D.19942>:
  }
  appdomain_list_size.76 = appdomain_list_size;
  D.19944 = (int) appdomain_list_size.76;
  if (D.19944 > domainid) goto <D.19945>; else goto <D.19946>;
  <D.19945>:
  appdomains_list.77 = appdomains_list;
  domainid.78 = (unsigned int) domainid;
  D.19949 = domainid.78 * 4;
  D.19950 = appdomains_list.77 + D.19949;
  domain = *D.19950;
  goto <D.19951>;
  <D.19946>:
  domain = 0B;
  <D.19951>:
  {
    int ret;

    ret = pthread_mutex_unlock (&appdomains_mutex.mutex);
    if (ret != 0) goto <D.19952>; else goto <D.19953>;
    <D.19952>:
    monoeg_g_log (0B, 16, "Bad call to mono_mutex_unlock result %d", ret);
    <D.19953>:
    D.19954 = ret != 0;
    D.19955 = (long int) D.19954;
    D.19956 = __builtin_expect (D.19955, 0);
    if (D.19956 != 0) goto <D.19957>; else goto <D.19958>;
    <D.19957>:
    monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "domain.c", 2149, "ret == 0");
    <D.19958>:
  }
  D.19959 = domain;
  return D.19959;
}


mono_domain_get_id (struct MonoDomain * domain)
{
  int32_t D.19961;

  D.19961 = domain->domain_id;
  return D.19961;
}


mono_domain_alloc (struct MonoDomain * domain, guint size)
{
  union mono_mutex_t * D.19963;
  _Bool D.19966;
  long int D.19967;
  long int D.19968;
  struct MonoPerfCounters * mono_perfcounters.79;
  unsigned int D.19972;
  unsigned int D.19973;
  struct MonoMemPool * D.19974;
  _Bool D.19977;
  long int D.19978;
  long int D.19979;
  void * D.19982;
  void * res;

  {
    int ret;

    D.19963 = &domain->lock.mutex;
    ret = pthread_mutex_lock (D.19963);
    if (ret != 0) goto <D.19964>; else goto <D.19965>;
    <D.19964>:
    monoeg_g_log (0B, 16, "Bad call to mono_mutex_lock result %d", ret);
    <D.19965>:
    D.19966 = ret != 0;
    D.19967 = (long int) D.19966;
    D.19968 = __builtin_expect (D.19967, 0);
    if (D.19968 != 0) goto <D.19969>; else goto <D.19970>;
    <D.19969>:
    monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "domain.c", 2170, "ret == 0");
    <D.19970>:
  }
  mono_perfcounters.79 = mono_perfcounters;
  mono_perfcounters.79 = mono_perfcounters;
  D.19972 = mono_perfcounters.79->loader_bytes;
  D.19973 = D.19972 + size;
  mono_perfcounters.79->loader_bytes = D.19973;
  D.19974 = domain->mp;
  res = mono_mempool_alloc (D.19974, size);
  {
    int ret;

    D.19963 = &domain->lock.mutex;
    ret = pthread_mutex_unlock (D.19963);
    if (ret != 0) goto <D.19975>; else goto <D.19976>;
    <D.19975>:
    monoeg_g_log (0B, 16, "Bad call to mono_mutex_unlock result %d", ret);
    <D.19976>:
    D.19977 = ret != 0;
    D.19978 = (long int) D.19977;
    D.19979 = __builtin_expect (D.19978, 0);
    if (D.19979 != 0) goto <D.19980>; else goto <D.19981>;
    <D.19980>:
    monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "domain.c", 2175, "ret == 0");
    <D.19981>:
  }
  D.19982 = res;
  return D.19982;
}


mono_domain_alloc0 (struct MonoDomain * domain, guint size)
{
  union mono_mutex_t * D.19984;
  _Bool D.19987;
  long int D.19988;
  long int D.19989;
  struct MonoPerfCounters * mono_perfcounters.80;
  unsigned int D.19993;
  unsigned int D.19994;
  struct MonoMemPool * D.19995;
  _Bool D.19998;
  long int D.19999;
  long int D.20000;
  void * D.20003;
  void * res;

  {
    int ret;

    D.19984 = &domain->lock.mutex;
    ret = pthread_mutex_lock (D.19984);
    if (ret != 0) goto <D.19985>; else goto <D.19986>;
    <D.19985>:
    monoeg_g_log (0B, 16, "Bad call to mono_mutex_lock result %d", ret);
    <D.19986>:
    D.19987 = ret != 0;
    D.19988 = (long int) D.19987;
    D.19989 = __builtin_expect (D.19988, 0);
    if (D.19989 != 0) goto <D.19990>; else goto <D.19991>;
    <D.19990>:
    monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "domain.c", 2190, "ret == 0");
    <D.19991>:
  }
  mono_perfcounters.80 = mono_perfcounters;
  mono_perfcounters.80 = mono_perfcounters;
  D.19993 = mono_perfcounters.80->loader_bytes;
  D.19994 = D.19993 + size;
  mono_perfcounters.80->loader_bytes = D.19994;
  D.19995 = domain->mp;
  res = mono_mempool_alloc0 (D.19995, size);
  {
    int ret;

    D.19984 = &domain->lock.mutex;
    ret = pthread_mutex_unlock (D.19984);
    if (ret != 0) goto <D.19996>; else goto <D.19997>;
    <D.19996>:
    monoeg_g_log (0B, 16, "Bad call to mono_mutex_unlock result %d", ret);
    <D.19997>:
    D.19998 = ret != 0;
    D.19999 = (long int) D.19998;
    D.20000 = __builtin_expect (D.19999, 0);
    if (D.20000 != 0) goto <D.20001>; else goto <D.20002>;
    <D.20001>:
    monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "domain.c", 2195, "ret == 0");
    <D.20002>:
  }
  D.20003 = res;
  return D.20003;
}


mono_domain_alloc0_lock_free (struct MonoDomain * domain, guint size)
{
  void * D.20005;
  struct LockFreeMempool * D.20006;

  D.20006 = domain->lock_free_mp;
  D.20005 = lock_free_mempool_alloc0 (D.20006, size);
  return D.20005;
}


lock_free_mempool_alloc0 (struct LockFreeMempool * mp, guint size)
{
  unsigned int D.20008;
  int size.81;
  int size.82;
  int * D.20013;
  unsigned int oldpos.83;
  unsigned int D.20015;
  int D.20016;
  unsigned int D.20017;
  int D.20020;
  unsigned int D.20021;
  unsigned int D.20022;
  _Bool D.20023;
  long int D.20024;
  long int D.20025;
  int D.20028;
  guint8 * D.20030;
  sizetype oldpos.84;
  void * D.20032;
  struct LockFreeMempoolChunk * chunk;
  void * res;
  int oldpos;

  D.20008 = size + 7;
  size = D.20008 & 4294967288;
  chunk = mp->current;
  if (chunk == 0B) goto <D.20009>; else goto <D.20010>;
  <D.20009>:
  size.81 = (int) size;
  chunk = lock_free_mempool_chunk_new (mp, size.81);
  mono_memory_barrier ();
  mp->current = chunk;
  <D.20010>:
  size.82 = (int) size;
  D.20013 = &chunk->pos;
  oldpos = InterlockedExchangeAdd (D.20013, size.82);
  oldpos.83 = (unsigned int) oldpos;
  D.20015 = oldpos.83 + size;
  D.20016 = chunk->size;
  D.20017 = (unsigned int) D.20016;
  if (D.20015 > D.20017) goto <D.20018>; else goto <D.20019>;
  <D.20018>:
  size.81 = (int) size;
  chunk = lock_free_mempool_chunk_new (mp, size.81);
  D.20020 = chunk->pos;
  D.20021 = (unsigned int) D.20020;
  D.20022 = D.20021 + size;
  D.20016 = chunk->size;
  D.20017 = (unsigned int) D.20016;
  D.20023 = D.20022 > D.20017;
  D.20024 = (long int) D.20023;
  D.20025 = __builtin_expect (D.20024, 0);
  if (D.20025 != 0) goto <D.20026>; else goto <D.20027>;
  <D.20026>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "domain.c", 1085, "chunk->pos + size <= chunk->size");
  <D.20027>:
  res = chunk->mem;
  D.20020 = chunk->pos;
  D.20021 = (unsigned int) D.20020;
  D.20022 = D.20021 + size;
  D.20028 = (int) D.20022;
  chunk->pos = D.20028;
  mono_memory_barrier ();
  mp->current = chunk;
  goto <D.20029>;
  <D.20019>:
  D.20030 = chunk->mem;
  oldpos.84 = (sizetype) oldpos;
  res = D.20030 + oldpos.84;
  <D.20029>:
  D.20032 = res;
  return D.20032;
}


InterlockedExchangeAdd (volatile gint32 * val, gint32 add)
{
  gint32 D.20034;
  unsigned int add.85;
  unsigned int D.20036;

  add.85 = (unsigned int) add;
  D.20036 = __sync_fetch_and_add_4 (val, add.85);
  D.20034 = (gint32) D.20036;
  return D.20034;
}


lock_free_mempool_chunk_new (struct LockFreeMempool * mp, int len)
{
  int D.20038;
  unsigned int size.86;
  unsigned int D.20040;
  unsigned int len.87;
  unsigned int size.88;
  _Bool D.20043;
  long int D.20044;
  long int D.20045;
  char * D.20048;
  int D.20049;
  int D.20050;
  int D.20051;
  guint8 * D.20052;
  sizetype size.89;
  char * D.20054;
  int D.20055;
  guint8 * D.20056;
  int D.20057;
  int D.20058;
  struct LockFreeMempoolChunk * * D.20059;
  void * D.20060;
  struct LockFreeMempoolChunk * D.20062;
  struct LockFreeMempoolChunk * chunk;
  struct LockFreeMempoolChunk * prev;
  int size;

  size = mono_pagesize ();
  goto <D.17718>;
  <D.17717>:
  D.20038 = mono_pagesize ();
  size = D.20038 + size;
  <D.17718>:
  size.86 = (unsigned int) size;
  D.20040 = size.86 + 4294967280;
  len.87 = (unsigned int) len;
  if (D.20040 < len.87) goto <D.17717>; else goto <D.17719>;
  <D.17719>:
  size.88 = (unsigned int) size;
  chunk = mono_valloc (0B, size.88, 3);
  D.20043 = chunk == 0B;
  D.20044 = (long int) D.20043;
  D.20045 = __builtin_expect (D.20044, 0);
  if (D.20045 != 0) goto <D.20046>; else goto <D.20047>;
  <D.20046>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "domain.c", 1044, "chunk");
  <D.20047>:
  D.20048 = chunk + 16;
  D.20049 = (int) D.20048;
  D.20050 = D.20049 + 15;
  D.20051 = D.20050 & -16;
  D.20052 = (guint8 *) D.20051;
  chunk->mem = D.20052;
  size.89 = (sizetype) size;
  D.20054 = chunk + size.89;
  D.20055 = (int) D.20054;
  D.20056 = chunk->mem;
  D.20057 = (int) D.20056;
  D.20058 = D.20055 - D.20057;
  chunk->size = D.20058;
  chunk->pos = 0;
  <D.17721>:
  prev = mp->chunks;
  D.20059 = &mp->chunks;
  D.20060 = InterlockedCompareExchangePointer (D.20059, chunk, prev);
  if (D.20060 == prev) goto <D.17720>; else goto <D.20061>;
  <D.20061>:
  goto <D.17721>;
  <D.17720>:
  chunk->prev = prev;
  D.20062 = chunk;
  return D.20062;
}


InterlockedCompareExchangePointer (void * volatile * dest, void * exch, void * comp)
{
  void * D.20064;
  unsigned int exch.90;
  unsigned int comp.91;
  unsigned int D.20067;

  exch.90 = (unsigned int) exch;
  comp.91 = (unsigned int) comp;
  D.20067 = __sync_val_compare_and_swap_4 (dest, comp.91, exch.90);
  D.20064 = (void *) D.20067;
  return D.20064;
}


mono_domain_code_reserve (struct MonoDomain * domain, int size)
{
  union mono_mutex_t * D.20069;
  _Bool D.20072;
  long int D.20073;
  long int D.20074;
  struct MonoCodeManager * D.20077;
  _Bool D.20080;
  long int D.20081;
  long int D.20082;
  void * D.20085;
  void * res;

  {
    int ret;

    D.20069 = &domain->lock.mutex;
    ret = pthread_mutex_lock (D.20069);
    if (ret != 0) goto <D.20070>; else goto <D.20071>;
    <D.20070>:
    monoeg_g_log (0B, 16, "Bad call to mono_mutex_lock result %d", ret);
    <D.20071>:
    D.20072 = ret != 0;
    D.20073 = (long int) D.20072;
    D.20074 = __builtin_expect (D.20073, 0);
    if (D.20074 != 0) goto <D.20075>; else goto <D.20076>;
    <D.20075>:
    monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "domain.c", 2216, "ret == 0");
    <D.20076>:
  }
  D.20077 = domain->code_mp;
  res = mono_code_manager_reserve (D.20077, size);
  {
    int ret;

    D.20069 = &domain->lock.mutex;
    ret = pthread_mutex_unlock (D.20069);
    if (ret != 0) goto <D.20078>; else goto <D.20079>;
    <D.20078>:
    monoeg_g_log (0B, 16, "Bad call to mono_mutex_unlock result %d", ret);
    <D.20079>:
    D.20080 = ret != 0;
    D.20081 = (long int) D.20080;
    D.20082 = __builtin_expect (D.20081, 0);
    if (D.20082 != 0) goto <D.20083>; else goto <D.20084>;
    <D.20083>:
    monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "domain.c", 2218, "ret == 0");
    <D.20084>:
  }
  D.20085 = res;
  return D.20085;
}


mono_domain_code_reserve_align (struct MonoDomain * domain, int size, int alignment)
{
  union mono_mutex_t * D.20087;
  _Bool D.20090;
  long int D.20091;
  long int D.20092;
  struct MonoCodeManager * D.20095;
  _Bool D.20098;
  long int D.20099;
  long int D.20100;
  void * D.20103;
  void * res;

  {
    int ret;

    D.20087 = &domain->lock.mutex;
    ret = pthread_mutex_lock (D.20087);
    if (ret != 0) goto <D.20088>; else goto <D.20089>;
    <D.20088>:
    monoeg_g_log (0B, 16, "Bad call to mono_mutex_lock result %d", ret);
    <D.20089>:
    D.20090 = ret != 0;
    D.20091 = (long int) D.20090;
    D.20092 = __builtin_expect (D.20091, 0);
    if (D.20092 != 0) goto <D.20093>; else goto <D.20094>;
    <D.20093>:
    monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "domain.c", 2233, "ret == 0");
    <D.20094>:
  }
  D.20095 = domain->code_mp;
  res = mono_code_manager_reserve_align (D.20095, size, alignment);
  {
    int ret;

    D.20087 = &domain->lock.mutex;
    ret = pthread_mutex_unlock (D.20087);
    if (ret != 0) goto <D.20096>; else goto <D.20097>;
    <D.20096>:
    monoeg_g_log (0B, 16, "Bad call to mono_mutex_unlock result %d", ret);
    <D.20097>:
    D.20098 = ret != 0;
    D.20099 = (long int) D.20098;
    D.20100 = __builtin_expect (D.20099, 0);
    if (D.20100 != 0) goto <D.20101>; else goto <D.20102>;
    <D.20101>:
    monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "domain.c", 2235, "ret == 0");
    <D.20102>:
  }
  D.20103 = res;
  return D.20103;
}


mono_domain_code_commit (struct MonoDomain * domain, void * data, int size, int newsize)
{
  union mono_mutex_t * D.20105;
  _Bool D.20108;
  long int D.20109;
  long int D.20110;
  struct MonoCodeManager * D.20113;
  _Bool D.20116;
  long int D.20117;
  long int D.20118;

  {
    int ret;

    D.20105 = &domain->lock.mutex;
    ret = pthread_mutex_lock (D.20105);
    if (ret != 0) goto <D.20106>; else goto <D.20107>;
    <D.20106>:
    monoeg_g_log (0B, 16, "Bad call to mono_mutex_lock result %d", ret);
    <D.20107>:
    D.20108 = ret != 0;
    D.20109 = (long int) D.20108;
    D.20110 = __builtin_expect (D.20109, 0);
    if (D.20110 != 0) goto <D.20111>; else goto <D.20112>;
    <D.20111>:
    monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "domain.c", 2248, "ret == 0");
    <D.20112>:
  }
  D.20113 = domain->code_mp;
  mono_code_manager_commit (D.20113, data, size, newsize);
  {
    int ret;

    D.20105 = &domain->lock.mutex;
    ret = pthread_mutex_unlock (D.20105);
    if (ret != 0) goto <D.20114>; else goto <D.20115>;
    <D.20114>:
    monoeg_g_log (0B, 16, "Bad call to mono_mutex_unlock result %d", ret);
    <D.20115>:
    D.20116 = ret != 0;
    D.20117 = (long int) D.20116;
    D.20118 = __builtin_expect (D.20117, 0);
    if (D.20118 != 0) goto <D.20119>; else goto <D.20120>;
    <D.20119>:
    monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "domain.c", 2250, "ret == 0");
    <D.20120>:
  }
}


nacl_domain_get_code_dest (struct MonoDomain * domain, void * data)
{
  void * D.20121;

  D.20121 = data;
  return D.20121;
}


nacl_domain_code_validate (struct MonoDomain * domain, guint8 * * buf_base, int buf_size, guint8 * * code_end)
{

}


mono_domain_code_foreach (struct MonoDomain * domain, int (*MonoCodeManagerFunc) (void *, int, int, void *) func, void * user_data)
{
  union mono_mutex_t * D.20123;
  _Bool D.20126;
  long int D.20127;
  long int D.20128;
  struct MonoCodeManager * D.20131;
  _Bool D.20134;
  long int D.20135;
  long int D.20136;

  {
    int ret;

    D.20123 = &domain->lock.mutex;
    ret = pthread_mutex_lock (D.20123);
    if (ret != 0) goto <D.20124>; else goto <D.20125>;
    <D.20124>:
    monoeg_g_log (0B, 16, "Bad call to mono_mutex_lock result %d", ret);
    <D.20125>:
    D.20126 = ret != 0;
    D.20127 = (long int) D.20126;
    D.20128 = __builtin_expect (D.20127, 0);
    if (D.20128 != 0) goto <D.20129>; else goto <D.20130>;
    <D.20129>:
    monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "domain.c", 2317, "ret == 0");
    <D.20130>:
  }
  D.20131 = domain->code_mp;
  mono_code_manager_foreach (D.20131, func, user_data);
  {
    int ret;

    D.20123 = &domain->lock.mutex;
    ret = pthread_mutex_unlock (D.20123);
    if (ret != 0) goto <D.20132>; else goto <D.20133>;
    <D.20132>:
    monoeg_g_log (0B, 16, "Bad call to mono_mutex_unlock result %d", ret);
    <D.20133>:
    D.20134 = ret != 0;
    D.20135 = (long int) D.20134;
    D.20136 = __builtin_expect (D.20135, 0);
    if (D.20136 != 0) goto <D.20137>; else goto <D.20138>;
    <D.20137>:
    monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "domain.c", 2319, "ret == 0");
    <D.20138>:
  }
}


mono_context_set (struct MonoAppContext * new_context)
{
  struct MonoInternalThread * D.20139;
  struct MonoAppContext * * D.20140;
  struct MonoInternalThread * D.20141;

  D.20139 = mono_thread_internal_current ();
  D.20140 = &D.20139->current_appcontext;
  D.20141 = mono_thread_internal_current ();
  mono_gc_wbarrier_set_field (D.20141, D.20140, new_context);
}


mono_context_get ()
{
  struct MonoAppContext * D.20142;
  struct MonoInternalThread * D.20143;

  D.20143 = mono_thread_internal_current ();
  D.20142 = D.20143->current_appcontext;
  return D.20142;
}


mono_domain_add_class_static_data (struct MonoDomain * domain, struct MonoClass * klass, void * data, guint32 * bitmap)
{
  void * * D.20145;
  void * * D.20148;
  void * D.20149;
  void * D.20150;
  void * iftmp.92;
  int D.20154;
  unsigned int size.93;
  unsigned int D.20159;
  unsigned int D.20160;
  void * * D.20161;
  void * size.94;
  void * iftmp.95;
  int D.20165;
  unsigned int size.96;
  unsigned int D.20170;
  void * next.97;
  void * * D.20172;
  void * size.98;
  int next.99;
  unsigned int next.100;
  unsigned int D.20176;
  void * * D.20177;
  int next;

  D.20145 = domain->static_data_array;
  if (D.20145 != 0B) goto <D.20146>; else goto <D.20147>;
  <D.20146>:
  {
    int size;

    D.20145 = domain->static_data_array;
    D.20148 = D.20145 + 4;
    D.20149 = *D.20148;
    size = (int) D.20149;
    D.20145 = domain->static_data_array;
    D.20150 = *D.20145;
    next = (int) D.20150;
    if (next >= size) goto <D.20151>; else goto <D.20152>;
    <D.20151>:
    {
      void * * new_array;

      D.20154 = mono_gc_is_moving ();
      if (D.20154 != 0) goto <D.20155>; else goto <D.20156>;
      <D.20155>:
      iftmp.92 = mono_gc_make_root_descr_all_refs (0);
      goto <D.20157>;
      <D.20156>:
      iftmp.92 = 0B;
      <D.20157>:
      size.93 = (unsigned int) size;
      D.20159 = size.93 * 8;
      new_array = mono_gc_alloc_fixed (D.20159, iftmp.92);
      size.93 = (unsigned int) size;
      D.20160 = size.93 * 4;
      D.20145 = domain->static_data_array;
      mono_gc_memmove_aligned (new_array, D.20145, D.20160);
      size = size * 2;
      D.20161 = new_array + 4;
      size.94 = (void *) size;
      *D.20161 = size.94;
      D.20145 = domain->static_data_array;
      mono_gc_free_fixed (D.20145);
      domain->static_data_array = new_array;
    }
    <D.20152>:
  }
  goto <D.20163>;
  <D.20147>:
  {
    int size;
    void * * new_array;

    size = 32;
    D.20165 = mono_gc_is_moving ();
    if (D.20165 != 0) goto <D.20166>; else goto <D.20167>;
    <D.20166>:
    iftmp.95 = mono_gc_make_root_descr_all_refs (0);
    goto <D.20168>;
    <D.20167>:
    iftmp.95 = 0B;
    <D.20168>:
    size.96 = (unsigned int) size;
    D.20170 = size.96 * 4;
    new_array = mono_gc_alloc_fixed (D.20170, iftmp.95);
    next = 2;
    next.97 = (void *) next;
    *new_array = next.97;
    D.20172 = new_array + 4;
    size.98 = (void *) size;
    *D.20172 = size.98;
    domain->static_data_array = new_array;
  }
  <D.20163>:
  D.20145 = domain->static_data_array;
  next.99 = next;
  next = next.99 + 1;
  next.100 = (unsigned int) next.99;
  D.20176 = next.100 * 4;
  D.20177 = D.20145 + D.20176;
  *D.20177 = data;
  D.20145 = domain->static_data_array;
  next.97 = (void *) next;
  *D.20145 = next.97;
}


mono_get_corlib ()
{
  struct MonoImage * D.20178;

  D.20178 = mono_defaults.corlib;
  return D.20178;
}


mono_get_object_class ()
{
  struct MonoClass * D.20180;

  D.20180 = mono_defaults.object_class;
  return D.20180;
}


mono_get_byte_class ()
{
  struct MonoClass * D.20182;

  D.20182 = mono_defaults.byte_class;
  return D.20182;
}


mono_get_void_class ()
{
  struct MonoClass * D.20184;

  D.20184 = mono_defaults.void_class;
  return D.20184;
}


mono_get_boolean_class ()
{
  struct MonoClass * D.20186;

  D.20186 = mono_defaults.boolean_class;
  return D.20186;
}


mono_get_sbyte_class ()
{
  struct MonoClass * D.20188;

  D.20188 = mono_defaults.sbyte_class;
  return D.20188;
}


mono_get_int16_class ()
{
  struct MonoClass * D.20190;

  D.20190 = mono_defaults.int16_class;
  return D.20190;
}


mono_get_uint16_class ()
{
  struct MonoClass * D.20192;

  D.20192 = mono_defaults.uint16_class;
  return D.20192;
}


mono_get_int32_class ()
{
  struct MonoClass * D.20194;

  D.20194 = mono_defaults.int32_class;
  return D.20194;
}


mono_get_uint32_class ()
{
  struct MonoClass * D.20196;

  D.20196 = mono_defaults.uint32_class;
  return D.20196;
}


mono_get_intptr_class ()
{
  struct MonoClass * D.20198;

  D.20198 = mono_defaults.int_class;
  return D.20198;
}


mono_get_uintptr_class ()
{
  struct MonoClass * D.20200;

  D.20200 = mono_defaults.uint_class;
  return D.20200;
}


mono_get_int64_class ()
{
  struct MonoClass * D.20202;

  D.20202 = mono_defaults.int64_class;
  return D.20202;
}


mono_get_uint64_class ()
{
  struct MonoClass * D.20204;

  D.20204 = mono_defaults.uint64_class;
  return D.20204;
}


mono_get_single_class ()
{
  struct MonoClass * D.20206;

  D.20206 = mono_defaults.single_class;
  return D.20206;
}


mono_get_double_class ()
{
  struct MonoClass * D.20208;

  D.20208 = mono_defaults.double_class;
  return D.20208;
}


mono_get_char_class ()
{
  struct MonoClass * D.20210;

  D.20210 = mono_defaults.char_class;
  return D.20210;
}


mono_get_string_class ()
{
  struct MonoClass * D.20212;

  D.20212 = mono_defaults.string_class;
  return D.20212;
}


mono_get_enum_class ()
{
  struct MonoClass * D.20214;

  D.20214 = mono_defaults.enum_class;
  return D.20214;
}


mono_get_array_class ()
{
  struct MonoClass * D.20216;

  D.20216 = mono_defaults.array_class;
  return D.20216;
}


mono_get_thread_class ()
{
  struct MonoClass * D.20218;

  D.20218 = mono_defaults.thread_class;
  return D.20218;
}


mono_get_exception_class ()
{
  struct MonoClass * D.20220;

  D.20220 = mono_defaults.exception_class;
  return D.20220;
}


mono_get_runtime_info ()
{
  const struct MonoRuntimeInfo * D.20222;

  D.20222 = current_runtime;
  return D.20222;
}


mono_debugger_check_runtime_version (const char * filename)
{
  gchar * D.20226;
  const struct MonoRuntimeInfo * current_runtime.101;
  const char[12] * D.20230;
  const char[12] * D.20231;
  const struct MonoRuntimeInfo * runtimes[7];
  const struct MonoRuntimeInfo * rinfo;
  struct MonoImage * image;

  try
    {
      get_runtimes_from_exe (filename, &image, &runtimes);
      rinfo = runtimes[0];
      if (rinfo == 0B) goto <D.20224>; else goto <D.20225>;
      <D.20224>:
      D.20226 = monoeg_g_strdup_printf ("Cannot get runtime version from assembly `%s\'", filename);
      return D.20226;
      <D.20225>:
      current_runtime.101 = current_runtime;
      if (rinfo != current_runtime.101) goto <D.20228>; else goto <D.20229>;
      <D.20228>:
      D.20230 = &rinfo->runtime_version;
      current_runtime.101 = current_runtime;
      D.20231 = &current_runtime.101->runtime_version;
      D.20226 = monoeg_g_strdup_printf ("The Mono Debugger is currently using the `%s\' runtime, but the assembly `%s\' requires version `%s\'", D.20231, filename, D.20230);
      return D.20226;
      <D.20229>:
      D.20226 = 0B;
      return D.20226;
    }
  finally
    {
      runtimes = {CLOBBER};
      image = {CLOBBER};
    }
}


mono_framework_version ()
{
  int D.20234;
  const struct MonoRuntimeInfo * current_runtime.102;
  char D.20236;
  int D.20237;

  current_runtime.102 = current_runtime;
  D.20236 = current_runtime.102->framework_version[0];
  D.20237 = (int) D.20236;
  D.20234 = D.20237 + -48;
  return D.20234;
}