mono_domain_get_tls_key ()
{
  pthread_key_t D.18217;

  D.18217 = appdomain_thread_id;
  return D.18217;
}


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

  offset = -1;
  offset = -1;
  D.18219 = offset;
  return D.18219;
}


mono_jit_info_table_find_internal (struct MonoDomain * domain, char * addr, gboolean try_aot)
{
  long unsigned int D.18221;
  long unsigned int D.18222;
  struct MonoJitInfoTable * volatile * D.18223;
  struct MonoJitInfo * D.18230;
  struct MonoDomain * mono_root_domain.0;
  struct MonoJitInfoTable * D.18236;
  struct MonoJitInfoTable * volatile * D.18239;
  struct MonoJitInfo * (*<T19b5>) (struct MonoDomain *, struct MonoImage *, void *) jit_info_find_in_aot_func.1;
  struct MonoImage * D.18243;
  struct MonoJitInfoTable * table;
  struct MonoJitInfo * ji;
  struct MonoJitInfo * module_ji;
  struct MonoThreadHazardPointers * hp;

  hp = mono_hazard_pointer_get ();
  D.18221 = mono_stats.jit_info_table_lookup_count;
  D.18222 = D.18221 + 1;
  mono_stats.jit_info_table_lookup_count = D.18222;
  D.18223 = &domain->jit_info_table;
  table = get_hazardous_pointer (D.18223, hp, 0);
  ji = jit_info_table_find (table, hp, addr);
  if (hp != 0B) goto <D.18224>; else goto <D.18225>;
  <D.18224>:
  if (0 != 0) goto <D.18226>; else goto <D.18227>;
  <D.18226>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "domain.c", 401, "(0) >= 0 && (0) < HAZARD_POINTER_COUNT");
  <D.18227>:
  hp->hazard_pointers[0] = 0B;
  <D.18225>:
  if (ji != 0B) goto <D.18228>; else goto <D.18229>;
  <D.18228>:
  D.18230 = ji;
  return D.18230;
  <D.18229>:
  if (try_aot != 0) goto <D.18231>; else goto <D.18232>;
  <D.18231>:
  mono_root_domain.0 = mono_root_domain;
  if (mono_root_domain.0 != 0B) goto <D.18234>; else goto <D.18235>;
  <D.18234>:
  mono_root_domain.0 = mono_root_domain;
  D.18236 = mono_root_domain.0->aot_modules;
  if (D.18236 != 0B) goto <D.18237>; else goto <D.18238>;
  <D.18237>:
  mono_root_domain.0 = mono_root_domain;
  D.18239 = &mono_root_domain.0->aot_modules;
  table = get_hazardous_pointer (D.18239, hp, 0);
  module_ji = jit_info_table_find (table, hp, addr);
  if (module_ji != 0B) goto <D.18240>; else goto <D.18241>;
  <D.18240>:
  jit_info_find_in_aot_func.1 = jit_info_find_in_aot_func;
  D.18243 = module_ji->d.image;
  ji = jit_info_find_in_aot_func.1 (domain, D.18243, addr);
  <D.18241>:
  if (hp != 0B) goto <D.18244>; else goto <D.18245>;
  <D.18244>:
  if (0 != 0) goto <D.18246>; else goto <D.18247>;
  <D.18246>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "domain.c", 412, "(0) >= 0 && (0) < HAZARD_POINTER_COUNT");
  <D.18247>:
  hp->hazard_pointers[0] = 0B;
  <D.18245>:
  <D.18238>:
  <D.18235>:
  <D.18232>:
  D.18230 = ji;
  return D.18230;
}


jit_info_table_find (struct MonoJitInfoTable * table, struct MonoThreadHazardPointers * hp, gint8 * addr)
{
  int D.18249;
  _Bool D.18250;
  long int D.18251;
  long int D.18252;
  struct MonoJitInfoTableChunk * D.18255;
  struct MonoJitInfo * volatile * D.18256;
  struct MonoMethod * D.18257;
  void * D.18262;
  int D.18265;
  sizetype D.18266;
  gint8 * D.18267;
  struct MonoJitInfo * D.18272;
  int D.18274;
  struct MonoJitInfo * ji;
  int chunk_pos;
  int pos;
  void not_found = <<< error >>>;

  chunk_pos = jit_info_table_index (table, addr);
  D.18249 = table->num_chunks;
  D.18250 = D.18249 <= chunk_pos;
  D.18251 = (long int) D.18250;
  D.18252 = __builtin_expect (D.18251, 0);
  if (D.18252 != 0) goto <D.18253>; else goto <D.18254>;
  <D.18253>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "domain.c", 327, "chunk_pos < table->num_chunks");
  <D.18254>:
  D.18255 = table->chunks[chunk_pos];
  pos = jit_info_table_chunk_index (D.18255, hp, addr);
  <D.17470>:
  {
    struct MonoJitInfoTableChunk * chunk;

    chunk = table->chunks[chunk_pos];
    goto <D.17466>;
    <D.17468>:
    D.18256 = &chunk->data[pos];
    ji = get_hazardous_pointer (D.18256, hp, 1);
    pos = pos + 1;
    D.18257 = ji->d.method;
    if (D.18257 == 0B) goto <D.18258>; else goto <D.18259>;
    <D.18258>:
    if (0 != 0) goto <D.18260>; else goto <D.18261>;
    <D.18260>:
    monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "domain.c", 345, "(1) >= 0 && (1) < HAZARD_POINTER_COUNT");
    <D.18261>:
    hp->hazard_pointers[1] = 0B;
    // predicted unlikely by continue predictor.
    goto <D.17466>;
    <D.18259>:
    D.18262 = ji->code_start;
    if (D.18262 <= addr) goto <D.18263>; else goto <D.18264>;
    <D.18263>:
    D.18262 = ji->code_start;
    D.18265 = ji->code_size;
    D.18266 = (sizetype) D.18265;
    D.18267 = D.18262 + D.18266;
    if (D.18267 > addr) goto <D.18268>; else goto <D.18269>;
    <D.18268>:
    if (0 != 0) goto <D.18270>; else goto <D.18271>;
    <D.18270>:
    monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "domain.c", 350, "(1) >= 0 && (1) < HAZARD_POINTER_COUNT");
    <D.18271>:
    hp->hazard_pointers[1] = 0B;
    D.18272 = ji;
    return D.18272;
    <D.18269>:
    <D.18264>:
    D.18262 = ji->code_start;
    if (D.18262 > addr) goto not_found; else goto <D.18273>;
    <D.18273>:
    <D.17466>:
    D.18274 = chunk->num_elements;
    if (D.18274 > pos) goto <D.17468>; else goto <D.17469>;
    <D.17469>:
    chunk_pos = chunk_pos + 1;
    pos = 0;
  }
  D.18249 = table->num_chunks;
  if (D.18249 > chunk_pos) goto <D.17470>; else goto <D.17471>;
  <D.17471>:
  not_found:
  if (hp != 0B) goto <D.18275>; else goto <D.18276>;
  <D.18275>:
  if (0 != 0) goto <D.18277>; else goto <D.18278>;
  <D.18277>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "domain.c", 367, "(1) >= 0 && (1) < HAZARD_POINTER_COUNT");
  <D.18278>:
  hp->hazard_pointers[1] = 0B;
  <D.18276>:
  D.18272 = 0B;
  return D.18272;
}


jit_info_table_index (struct MonoJitInfoTable * table, gint8 * addr)
{
  _Bool D.18280;
  long int D.18281;
  long int D.18282;
  int D.18285;
  volatile gint8 * D.18286;
  _Bool D.18290;
  long int D.18291;
  long int D.18292;
  int D.18295;
  int D.18298;
  int left;
  int right;

  left = 0;
  right = table->num_chunks;
  D.18280 = left >= right;
  D.18281 = (long int) D.18280;
  D.18282 = __builtin_expect (D.18281, 0);
  if (D.18282 != 0) goto <D.18283>; else goto <D.18284>;
  <D.18283>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "domain.c", 282, "left < right");
  <D.18284>:
  <D.17442>:
  {
    int pos;
    struct MonoJitInfoTableChunk * chunk;

    D.18285 = left + right;
    pos = D.18285 / 2;
    chunk = table->chunks[pos];
    D.18286 = chunk->last_code_end;
    if (D.18286 > addr) goto <D.18287>; else goto <D.18288>;
    <D.18287>:
    right = pos;
    goto <D.18289>;
    <D.18288>:
    left = pos + 1;
    <D.18289>:
  }
  if (left < right) goto <D.17442>; else goto <D.17443>;
  <D.17443>:
  D.18290 = left != right;
  D.18291 = (long int) D.18290;
  D.18292 = __builtin_expect (D.18291, 0);
  if (D.18292 != 0) goto <D.18293>; else goto <D.18294>;
  <D.18293>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "domain.c", 293, "left == right");
  <D.18294>:
  D.18295 = table->num_chunks;
  if (D.18295 <= left) goto <D.18296>; else goto <D.18297>;
  <D.18296>:
  D.18295 = table->num_chunks;
  D.18298 = D.18295 + -1;
  return D.18298;
  <D.18297>:
  D.18298 = left;
  return D.18298;
}


jit_info_table_chunk_index (struct MonoJitInfoTableChunk * chunk, struct MonoThreadHazardPointers * hp, gint8 * addr)
{
  int D.18300;
  struct MonoJitInfo * volatile * D.18301;
  void * D.18302;
  int D.18303;
  sizetype D.18304;
  _Bool D.18308;
  long int D.18309;
  long int D.18310;
  int D.18313;
  int left;
  int right;

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

    D.18300 = left + right;
    pos = D.18300 / 2;
    D.18301 = &chunk->data[pos];
    ji = get_hazardous_pointer (D.18301, hp, 1);
    D.18302 = ji->code_start;
    D.18303 = ji->code_size;
    D.18304 = (sizetype) D.18303;
    code_end = D.18302 + D.18304;
    if (addr < code_end) goto <D.18305>; else goto <D.18306>;
    <D.18305>:
    right = pos;
    goto <D.18307>;
    <D.18306>:
    left = pos + 1;
    <D.18307>:
  }
  <D.17455>:
  if (left < right) goto <D.17454>; else goto <D.17456>;
  <D.17456>:
  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", 315, "left == right");
  <D.18312>:
  D.18313 = left;
  return D.18313;
}


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

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


mono_jit_info_table_add (struct MonoDomain * domain, struct MonoJitInfo * ji)
{
  struct MonoMethod * D.18317;
  _Bool D.18318;
  long int D.18319;
  long int D.18320;
  union mono_mutex_t * D.18323;
  _Bool D.18326;
  long int D.18327;
  long int D.18328;
  long unsigned int D.18331;
  long unsigned int D.18332;
  struct MonoJitInfoTable * volatile * D.18333;
  _Bool D.18336;
  long int D.18337;
  long int D.18338;

  D.18317 = ji->d.method;
  D.18318 = D.18317 == 0B;
  D.18319 = (long int) D.18318;
  D.18320 = __builtin_expect (D.18319, 0);
  if (D.18320 != 0) goto <D.18321>; else goto <D.18322>;
  <D.18321>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "domain.c", 749, "ji->d.method != NULL");
  <D.18322>:
  {
    int ret;

    D.18323 = &domain->lock.mutex;
    ret = pthread_mutex_lock (D.18323);
    if (ret != 0) goto <D.18324>; else goto <D.18325>;
    <D.18324>:
    monoeg_g_log (0B, 16, "Bad call to mono_mutex_lock result %d", ret);
    <D.18325>:
    D.18326 = ret != 0;
    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", 751, "ret == 0");
    <D.18330>:
  }
  D.18331 = mono_stats.jit_info_table_insert_count;
  D.18332 = D.18331 + 1;
  mono_stats.jit_info_table_insert_count = D.18332;
  D.18333 = &domain->jit_info_table;
  jit_info_table_add (domain, D.18333, ji);
  {
    int ret;

    D.18323 = &domain->lock.mutex;
    ret = pthread_mutex_unlock (D.18323);
    if (ret != 0) goto <D.18334>; else goto <D.18335>;
    <D.18334>:
    monoeg_g_log (0B, 16, "Bad call to mono_mutex_unlock result %d", ret);
    <D.18335>:
    D.18336 = ret != 0;
    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", 757, "ret == 0");
    <D.18340>:
  }
}


jit_info_table_add (struct MonoDomain * domain, struct MonoJitInfoTable * volatile * table_ptr, struct MonoJitInfo * ji)
{
  void * D.18341;
  int D.18342;
  sizetype D.18343;
  gint8 * D.18344;
  int D.18345;
  _Bool D.18346;
  long int D.18347;
  long int D.18348;
  int D.18351;
  int D.18354;
  int D.18355;
  int D.18358;
  struct MonoJitInfo * D.18359;
  int D.18361;
  struct MonoJitInfo * D.18362;
  int D.18363;
  int D.18364;
  struct MonoJitInfo * D.18365;
  void * D.18366;
  int D.18367;
  int D.18368;
  struct MonoJitInfo * D.18369;
  int D.18370;
  sizetype D.18371;
  volatile gint8 * D.18372;
  struct MonoJitInfoTable * table;
  struct MonoJitInfoTableChunk * chunk;
  int chunk_pos;
  int pos;
  int num_elements;
  int i;
  void restart = <<< error >>>;

  table = *table_ptr;
  restart:
  D.18341 = ji->code_start;
  D.18342 = ji->code_size;
  D.18343 = (sizetype) D.18342;
  D.18344 = D.18341 + D.18343;
  chunk_pos = jit_info_table_index (table, D.18344);
  D.18345 = table->num_chunks;
  D.18346 = D.18345 <= chunk_pos;
  D.18347 = (long int) D.18346;
  D.18348 = __builtin_expect (D.18347, 0);
  if (D.18348 != 0) goto <D.18349>; else goto <D.18350>;
  <D.18349>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "domain.c", 693, "chunk_pos < table->num_chunks");
  <D.18350>:
  chunk = table->chunks[chunk_pos];
  D.18351 = chunk->num_elements;
  if (D.18351 > 63) goto <D.18352>; else goto <D.18353>;
  <D.18352>:
  {
    struct MonoJitInfoTable * new_table;

    new_table = jit_info_table_chunk_overflow (table, chunk);
    *table_ptr = new_table;
    mono_memory_barrier ();
    D.18354 = domain->num_jit_info_tables;
    D.18355 = D.18354 + 1;
    domain->num_jit_info_tables = D.18355;
    mono_thread_hazardous_free_or_queue (table, jit_info_table_free, 1, 0);
    table = new_table;
    goto restart;
  }
  <D.18353>:
  num_elements = chunk->num_elements;
  D.18341 = ji->code_start;
  D.18342 = ji->code_size;
  D.18343 = (sizetype) D.18342;
  D.18344 = D.18341 + D.18343;
  pos = jit_info_table_chunk_index (chunk, 0B, D.18344);
  if (num_elements > 0) goto <D.18356>; else goto <D.18357>;
  <D.18356>:
  D.18358 = num_elements + -1;
  D.18359 = chunk->data[D.18358];
  chunk->data[num_elements] = D.18359;
  goto <D.18360>;
  <D.18357>:
  chunk->data[0] = ji;
  <D.18360>:
  mono_memory_write_barrier ();
  num_elements = num_elements + 1;
  chunk->num_elements = num_elements;
  i = num_elements + -2;
  goto <D.17589>;
  <D.17588>:
  mono_memory_write_barrier ();
  D.18361 = i + 1;
  D.18362 = chunk->data[i];
  chunk->data[D.18361] = D.18362;
  i = i + -1;
  <D.17589>:
  if (i >= pos) goto <D.17588>; else goto <D.17590>;
  <D.17590>:
  mono_memory_write_barrier ();
  chunk->data[pos] = ji;
  D.18363 = chunk->num_elements;
  D.18364 = D.18363 + -1;
  D.18365 = chunk->data[D.18364];
  D.18366 = D.18365->code_start;
  D.18367 = chunk->num_elements;
  D.18368 = D.18367 + -1;
  D.18369 = chunk->data[D.18368];
  D.18370 = D.18369->code_size;
  D.18371 = (sizetype) D.18370;
  D.18372 = D.18366 + D.18371;
  chunk->last_code_end = D.18372;
}


jit_info_table_free (struct MonoJitInfoTable * table)
{
  union mono_mutex_t * D.18373;
  _Bool D.18376;
  long int D.18377;
  long int D.18378;
  struct MonoDomain * D.18381;
  int D.18382;
  int D.18383;
  void * D.18386;
  struct GSList * D.18387;
  int D.18388;
  int D.18389;
  struct MonoMethod * D.18392;
  _Bool D.18397;
  long int D.18398;
  long int D.18399;
  int i;
  int num_chunks;
  struct MonoDomain * domain;

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

    D.18373 = &domain->lock.mutex;
    ret = pthread_mutex_lock (D.18373);
    if (ret != 0) goto <D.18374>; else goto <D.18375>;
    <D.18374>:
    monoeg_g_log (0B, 16, "Bad call to mono_mutex_lock result %d", ret);
    <D.18375>:
    D.18376 = ret != 0;
    D.18377 = (long int) D.18376;
    D.18378 = __builtin_expect (D.18377, 0);
    if (D.18378 != 0) goto <D.18379>; else goto <D.18380>;
    <D.18379>:
    monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "domain.c", 216, "ret == 0");
    <D.18380>:
  }
  D.18381 = table->domain;
  D.18382 = D.18381->num_jit_info_tables;
  D.18383 = D.18382 + -1;
  D.18381->num_jit_info_tables = D.18383;
  D.18381 = table->domain;
  D.18382 = D.18381->num_jit_info_tables;
  if (D.18382 <= 1) goto <D.18384>; else goto <D.18385>;
  <D.18384>:
  {
    struct GSList * list;

    D.18381 = table->domain;
    list = D.18381->jit_info_free_queue;
    goto <D.17420>;
    <D.17419>:
    D.18386 = list->data;
    monoeg_g_free (D.18386);
    list = list->next;
    <D.17420>:
    if (list != 0B) goto <D.17419>; else goto <D.17421>;
    <D.17421>:
    D.18381 = table->domain;
    D.18387 = D.18381->jit_info_free_queue;
    monoeg_g_slist_free (D.18387);
    D.18381 = table->domain;
    D.18381->jit_info_free_queue = 0B;
  }
  <D.18385>:
  i = 0;
  goto <D.17431>;
  <D.17430>:
  {
    struct MonoJitInfoTableChunk * chunk;
    int num_elements;
    int j;

    chunk = table->chunks[i];
    D.18388 = chunk->refcount;
    D.18389 = D.18388 + -1;
    chunk->refcount = D.18389;
    D.18388 = chunk->refcount;
    if (D.18388 > 0) goto <D.18390>; else goto <D.18391>;
    <D.18390>:
    // predicted unlikely by continue predictor.
    goto <D.17425>;
    <D.18391>:
    num_elements = chunk->num_elements;
    j = 0;
    goto <D.17428>;
    <D.17427>:
    {
      struct MonoJitInfo * ji;

      ji = chunk->data[j];
      D.18392 = ji->d.method;
      if (D.18392 == 0B) goto <D.18393>; else goto <D.18394>;
      <D.18393>:
      monoeg_g_free (ji);
      <D.18394>:
    }
    j = j + 1;
    <D.17428>:
    if (j < num_elements) goto <D.17427>; else goto <D.17429>;
    <D.17429>:
    monoeg_g_free (chunk);
  }
  <D.17425>:
  i = i + 1;
  <D.17431>:
  if (i < num_chunks) goto <D.17430>; else goto <D.17432>;
  <D.17432>:
  {
    int ret;

    D.18373 = &domain->lock.mutex;
    ret = pthread_mutex_unlock (D.18373);
    if (ret != 0) goto <D.18395>; else goto <D.18396>;
    <D.18395>:
    monoeg_g_log (0B, 16, "Bad call to mono_mutex_unlock result %d", ret);
    <D.18396>:
    D.18397 = ret != 0;
    D.18398 = (long int) D.18397;
    D.18399 = __builtin_expect (D.18398, 0);
    if (D.18399 != 0) goto <D.18400>; else goto <D.18401>;
    <D.18400>:
    monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "domain.c", 252, "ret == 0");
    <D.18401>:
  }
  monoeg_g_free (table);
}


jit_info_table_chunk_overflow (struct MonoJitInfoTable * table, struct MonoJitInfoTableChunk * chunk)
{
  int D.18404;
  int D.18405;
  int D.18407;
  int D.18408;
  struct MonoJitInfoTable * D.18409;
  struct MonoJitInfo * D.18410;
  struct MonoMethod * D.18411;
  int D.18414;
  int num_elements;
  int i;

  num_elements = jit_info_table_num_elements (table);
  D.18404 = table->num_chunks;
  D.18405 = D.18404 * 32;
  if (D.18405 > num_elements) goto <D.18402>; else goto <D.18406>;
  <D.18406>:
  D.18404 = table->num_chunks;
  D.18407 = D.18404 * 320;
  D.18408 = D.18407 / 6;
  if (D.18408 < num_elements) goto <D.18402>; else goto <D.18403>;
  <D.18402>:
  D.18409 = jit_info_table_realloc (table);
  return D.18409;
  <D.18403>:
  num_elements = 0;
  i = 0;
  goto <D.17573>;
  <D.17572>:
  D.18410 = chunk->data[i];
  D.18411 = D.18410->d.method;
  if (D.18411 != 0B) goto <D.18412>; else goto <D.18413>;
  <D.18412>:
  num_elements = num_elements + 1;
  <D.18413>:
  i = i + 1;
  <D.17573>:
  D.18414 = chunk->num_elements;
  if (D.18414 > i) goto <D.17572>; else goto <D.17574>;
  <D.17574>:
  if (num_elements == 64) goto <D.18415>; else goto <D.18416>;
  <D.18415>:
  D.18409 = jit_info_table_copy_and_split_chunk (table, chunk);
  return D.18409;
  <D.18416>:
  D.18409 = jit_info_table_copy_and_purify_chunk (table, chunk);
  return D.18409;
}


jit_info_table_num_elements (struct MonoJitInfoTable * table)
{
  struct MonoJitInfo * D.18418;
  struct MonoMethod * D.18419;
  int D.18422;
  int D.18423;
  int i;
  int num_elements;

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

    chunk = table->chunks[i];
    chunk_num_elements = chunk->num_elements;
    j = 0;
    goto <D.17398>;
    <D.17397>:
    D.18418 = chunk->data[j];
    D.18419 = D.18418->d.method;
    if (D.18419 != 0B) goto <D.18420>; else goto <D.18421>;
    <D.18420>:
    num_elements = num_elements + 1;
    <D.18421>:
    j = j + 1;
    <D.17398>:
    if (j < chunk_num_elements) goto <D.17397>; else goto <D.17399>;
    <D.17399>:
  }
  i = i + 1;
  <D.17401>:
  D.18422 = table->num_chunks;
  if (D.18422 > i) goto <D.17400>; else goto <D.17402>;
  <D.17402>:
  D.18423 = num_elements;
  return D.18423;
}


jit_info_table_realloc (struct MonoJitInfoTable * old)
{
  long int D.18425;
  int D.18426;
  _Bool D.18429;
  long int D.18430;
  long int D.18431;
  struct MonoJitInfoTable * D.18434;
  struct MonoDomain * D.18435;
  _Bool D.18436;
  long int D.18437;
  long int D.18438;
  unsigned int num_chunks.2;
  unsigned int D.18442;
  unsigned int D.18443;
  struct MonoJitInfoTableChunk * D.18444;
  struct MonoJitInfo * D.18445;
  struct MonoMethod * D.18446;
  _Bool D.18449;
  long int D.18450;
  long int D.18451;
  struct MonoJitInfoTableChunk * D.18454;
  struct MonoJitInfo * D.18455;
  int D.18458;
  int D.18461;
  _Bool D.18462;
  long int D.18463;
  long int D.18464;
  int D.18467;
  _Bool D.18468;
  long int D.18469;
  long int D.18470;
  int D.18473;
  int D.18474;
  struct MonoJitInfoTableChunk * D.18475;
  void * D.18476;
  int D.18477;
  sizetype D.18478;
  volatile gint8 * D.18479;
  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.18425 = num_elements * 4;
  required_size = D.18425 / 3;
  D.18426 = required_size + 63;
  num_chunks = D.18426 / 64;
  if (num_chunks == 0) goto <D.18427>; else goto <D.18428>;
  <D.18427>:
  D.18429 = num_elements != 0;
  D.18430 = (long int) D.18429;
  D.18431 = __builtin_expect (D.18430, 0);
  if (D.18431 != 0) goto <D.18432>; else goto <D.18433>;
  <D.18432>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "domain.c", 480, "num_elements == 0");
  <D.18433>:
  D.18435 = old->domain;
  D.18434 = jit_info_table_new (D.18435);
  return D.18434;
  <D.18428>:
  D.18436 = num_chunks <= 0;
  D.18437 = (long int) D.18436;
  D.18438 = __builtin_expect (D.18437, 0);
  if (D.18438 != 0) goto <D.18439>; else goto <D.18440>;
  <D.18439>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "domain.c", 483, "num_chunks > 0");
  <D.18440>:
  num_chunks.2 = (unsigned int) num_chunks;
  D.18442 = num_chunks.2 + 2;
  D.18443 = D.18442 * 4;
  new = monoeg_malloc (D.18443);
  D.18435 = old->domain;
  new->domain = D.18435;
  new->num_chunks = num_chunks;
  i = 0;
  goto <D.17514>;
  <D.17513>:
  D.18444 = jit_info_table_new_chunk ();
  new->chunks[i] = D.18444;
  i = i + 1;
  <D.17514>:
  if (i < num_chunks) goto <D.17513>; else goto <D.17515>;
  <D.17515>:
  new_chunk = 0;
  new_element = 0;
  i = 0;
  goto <D.17523>;
  <D.17522>:
  {
    struct MonoJitInfoTableChunk * chunk;
    int chunk_num_elements;
    int j;

    chunk = old->chunks[i];
    chunk_num_elements = chunk->num_elements;
    j = 0;
    goto <D.17520>;
    <D.17519>:
    D.18445 = chunk->data[j];
    D.18446 = D.18445->d.method;
    if (D.18446 != 0B) goto <D.18447>; else goto <D.18448>;
    <D.18447>:
    D.18449 = new_chunk >= num_chunks;
    D.18450 = (long int) D.18449;
    D.18451 = __builtin_expect (D.18450, 0);
    if (D.18451 != 0) goto <D.18452>; else goto <D.18453>;
    <D.18452>:
    monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "domain.c", 501, "new_chunk < num_chunks");
    <D.18453>:
    D.18454 = new->chunks[new_chunk];
    D.18455 = chunk->data[j];
    D.18454->data[new_element] = D.18455;
    new_element = new_element + 1;
    if (new_element > 47) goto <D.18456>; else goto <D.18457>;
    <D.18456>:
    D.18454 = new->chunks[new_chunk];
    D.18454->num_elements = new_element;
    new_chunk = new_chunk + 1;
    new_element = 0;
    <D.18457>:
    <D.18448>:
    j = j + 1;
    <D.17520>:
    if (j < chunk_num_elements) goto <D.17519>; else goto <D.17521>;
    <D.17521>:
  }
  i = i + 1;
  <D.17523>:
  D.18458 = old->num_chunks;
  if (D.18458 > i) goto <D.17522>; else goto <D.17524>;
  <D.17524>:
  if (new_chunk < num_chunks) goto <D.18459>; else goto <D.18460>;
  <D.18459>:
  D.18461 = num_chunks + -1;
  D.18462 = D.18461 != new_chunk;
  D.18463 = (long int) D.18462;
  D.18464 = __builtin_expect (D.18463, 0);
  if (D.18464 != 0) goto <D.18465>; else goto <D.18466>;
  <D.18465>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "domain.c", 513, "new_chunk == num_chunks - 1");
  <D.18466>:
  D.18454 = new->chunks[new_chunk];
  D.18454->num_elements = new_element;
  D.18454 = new->chunks[new_chunk];
  D.18467 = D.18454->num_elements;
  D.18468 = D.18467 <= 0;
  D.18469 = (long int) D.18468;
  D.18470 = __builtin_expect (D.18469, 0);
  if (D.18470 != 0) goto <D.18471>; else goto <D.18472>;
  <D.18471>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "domain.c", 515, "new->chunks [new_chunk]->num_elements > 0");
  <D.18472>:
  <D.18460>:
  i = 0;
  goto <D.17528>;
  <D.17527>:
  {
    struct MonoJitInfoTableChunk * chunk;
    struct MonoJitInfo * ji;

    chunk = new->chunks[i];
    D.18473 = chunk->num_elements;
    D.18474 = D.18473 + -1;
    ji = chunk->data[D.18474];
    D.18475 = new->chunks[i];
    D.18476 = ji->code_start;
    D.18477 = ji->code_size;
    D.18478 = (sizetype) D.18477;
    D.18479 = D.18476 + D.18478;
    D.18475->last_code_end = D.18479;
  }
  i = i + 1;
  <D.17528>:
  if (i < num_chunks) goto <D.17527>; else goto <D.17529>;
  <D.17529>:
  D.18434 = new;
  return D.18434;
}


jit_info_table_new (struct MonoDomain * domain)
{
  struct MonoJitInfoTableChunk * D.18481;
  struct MonoJitInfoTable * D.18482;
  struct MonoJitInfoTable * table;

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


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

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


jit_info_table_copy_and_split_chunk (struct MonoJitInfoTable * table, struct MonoJitInfoTableChunk * chunk)
{
  int D.18486;
  unsigned int D.18487;
  unsigned int D.18488;
  unsigned int D.18489;
  struct MonoDomain * D.18490;
  int D.18491;
  struct MonoJitInfoTableChunk * D.18492;
  struct MonoJitInfoTableChunk * * D.18495;
  int D.18496;
  struct MonoJitInfoTableChunk * * D.18497;
  struct MonoJitInfoTableChunk * D.18499;
  int D.18500;
  int D.18501;
  int D.18502;
  _Bool D.18503;
  long int D.18504;
  long int D.18505;
  struct MonoJitInfoTable * D.18508;
  struct MonoJitInfoTable * new_table;
  int i;
  int j;

  D.18486 = table->num_chunks;
  D.18487 = (unsigned int) D.18486;
  D.18488 = D.18487 + 3;
  D.18489 = D.18488 * 4;
  new_table = monoeg_malloc (D.18489);
  D.18490 = table->domain;
  new_table->domain = D.18490;
  D.18486 = table->num_chunks;
  D.18491 = D.18486 + 1;
  new_table->num_chunks = D.18491;
  j = 0;
  i = 0;
  goto <D.17545>;
  <D.17544>:
  D.18492 = table->chunks[i];
  if (D.18492 == chunk) goto <D.18493>; else goto <D.18494>;
  <D.18493>:
  D.18495 = &new_table->chunks[j];
  D.18496 = j + 1;
  D.18497 = &new_table->chunks[D.18496];
  jit_info_table_split_chunk (chunk, D.18495, D.18497);
  j = j + 2;
  goto <D.18498>;
  <D.18494>:
  D.18492 = table->chunks[i];
  new_table->chunks[j] = D.18492;
  D.18499 = new_table->chunks[j];
  D.18500 = D.18499->refcount;
  D.18501 = D.18500 + 1;
  D.18499->refcount = D.18501;
  j = j + 1;
  <D.18498>:
  i = i + 1;
  <D.17545>:
  D.18486 = table->num_chunks;
  if (D.18486 > i) goto <D.17544>; else goto <D.17546>;
  <D.17546>:
  D.18502 = new_table->num_chunks;
  D.18503 = D.18502 != j;
  D.18504 = (long int) D.18503;
  D.18505 = __builtin_expect (D.18504, 0);
  if (D.18505 != 0) goto <D.18506>; else goto <D.18507>;
  <D.18506>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "domain.c", 573, "j == new_table->num_chunks");
  <D.18507>:
  D.18508 = new_table;
  return D.18508;
}


jit_info_table_split_chunk (struct MonoJitInfoTableChunk * chunk, struct MonoJitInfoTableChunk * * new1p, struct MonoJitInfoTableChunk * * new2p)
{
  int D.18510;
  _Bool D.18511;
  long int D.18512;
  long int D.18513;
  int D.18516;
  int D.18517;
  struct MonoJitInfo * volatile[64] * D.18518;
  struct MonoJitInfo * volatile[64] * D.18519;
  int D.18520;
  unsigned int D.18521;
  unsigned int D.18522;
  struct MonoJitInfo * volatile[64] * D.18523;
  int D.18524;
  sizetype D.18525;
  struct MonoJitInfo * volatile * D.18526;
  int D.18527;
  unsigned int D.18528;
  unsigned int D.18529;
  int D.18530;
  int D.18531;
  struct MonoJitInfo * D.18532;
  void * D.18533;
  int D.18534;
  int D.18535;
  struct MonoJitInfo * D.18536;
  int D.18537;
  sizetype D.18538;
  volatile gint8 * D.18539;
  int D.18540;
  int D.18541;
  struct MonoJitInfo * D.18542;
  void * D.18543;
  int D.18544;
  int D.18545;
  struct MonoJitInfo * D.18546;
  int D.18547;
  sizetype D.18548;
  volatile gint8 * D.18549;
  struct MonoJitInfoTableChunk * new1;
  struct MonoJitInfoTableChunk * new2;

  new1 = jit_info_table_new_chunk ();
  new2 = jit_info_table_new_chunk ();
  D.18510 = chunk->num_elements;
  D.18511 = D.18510 != 64;
  D.18512 = (long int) D.18511;
  D.18513 = __builtin_expect (D.18512, 0);
  if (D.18513 != 0) goto <D.18514>; else goto <D.18515>;
  <D.18514>:
  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.18515>:
  new1->num_elements = 32;
  D.18516 = new1->num_elements;
  D.18517 = 64 - D.18516;
  new2->num_elements = D.18517;
  D.18518 = &new1->data;
  D.18519 = &chunk->data;
  D.18520 = new1->num_elements;
  D.18521 = (unsigned int) D.18520;
  D.18522 = D.18521 * 4;
  memcpy (D.18518, D.18519, D.18522);
  D.18523 = &new2->data;
  D.18524 = new1->num_elements;
  D.18525 = (sizetype) D.18524;
  D.18526 = &chunk->data[D.18525];
  D.18527 = new2->num_elements;
  D.18528 = (unsigned int) D.18527;
  D.18529 = D.18528 * 4;
  memcpy (D.18523, D.18526, D.18529);
  D.18530 = new1->num_elements;
  D.18531 = D.18530 + -1;
  D.18532 = new1->data[D.18531];
  D.18533 = D.18532->code_start;
  D.18534 = new1->num_elements;
  D.18535 = D.18534 + -1;
  D.18536 = new1->data[D.18535];
  D.18537 = D.18536->code_size;
  D.18538 = (sizetype) D.18537;
  D.18539 = D.18533 + D.18538;
  new1->last_code_end = D.18539;
  D.18540 = new2->num_elements;
  D.18541 = D.18540 + -1;
  D.18542 = new2->data[D.18541];
  D.18543 = D.18542->code_start;
  D.18544 = new2->num_elements;
  D.18545 = D.18544 + -1;
  D.18546 = new2->data[D.18545];
  D.18547 = D.18546->code_size;
  D.18548 = (sizetype) D.18547;
  D.18549 = D.18543 + D.18548;
  new2->last_code_end = D.18549;
  *new1p = new1;
  *new2p = new2;
}


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

  D.18551 = __builtin_object_size (__dest, 0);
  D.18550 = __builtin___memcpy_chk (__dest, __src, __len, D.18551);
  return D.18550;
}


jit_info_table_copy_and_purify_chunk (struct MonoJitInfoTable * table, struct MonoJitInfoTableChunk * chunk)
{
  int D.18553;
  unsigned int D.18554;
  unsigned int D.18555;
  unsigned int D.18556;
  struct MonoDomain * D.18557;
  struct MonoJitInfoTableChunk * D.18558;
  int j.3;
  struct MonoJitInfoTableChunk * D.18562;
  struct MonoJitInfoTableChunk * D.18564;
  int D.18565;
  int D.18566;
  int D.18567;
  _Bool D.18568;
  long int D.18569;
  long int D.18570;
  struct MonoJitInfoTable * D.18573;
  struct MonoJitInfoTable * new_table;
  int i;
  int j;

  D.18553 = table->num_chunks;
  D.18554 = (unsigned int) D.18553;
  D.18555 = D.18554 + 2;
  D.18556 = D.18555 * 4;
  new_table = monoeg_malloc (D.18556);
  D.18557 = table->domain;
  new_table->domain = D.18557;
  D.18553 = table->num_chunks;
  new_table->num_chunks = D.18553;
  j = 0;
  i = 0;
  goto <D.17564>;
  <D.17563>:
  D.18558 = table->chunks[i];
  if (D.18558 == chunk) goto <D.18559>; else goto <D.18560>;
  <D.18559>:
  j.3 = j;
  j = j.3 + 1;
  D.18558 = table->chunks[i];
  D.18562 = jit_info_table_purify_chunk (D.18558);
  new_table->chunks[j.3] = D.18562;
  goto <D.18563>;
  <D.18560>:
  D.18558 = table->chunks[i];
  new_table->chunks[j] = D.18558;
  D.18564 = new_table->chunks[j];
  D.18565 = D.18564->refcount;
  D.18566 = D.18565 + 1;
  D.18564->refcount = D.18566;
  j = j + 1;
  <D.18563>:
  i = i + 1;
  <D.17564>:
  D.18553 = table->num_chunks;
  if (D.18553 > i) goto <D.17563>; else goto <D.17565>;
  <D.17565>:
  D.18567 = new_table->num_chunks;
  D.18568 = D.18567 != j;
  D.18569 = (long int) D.18568;
  D.18570 = __builtin_expect (D.18569, 0);
  if (D.18570 != 0) goto <D.18571>; else goto <D.18572>;
  <D.18571>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "domain.c", 620, "j == new_table->num_chunks");
  <D.18572>:
  D.18573 = new_table;
  return D.18573;
}


jit_info_table_purify_chunk (struct MonoJitInfoTableChunk * old)
{
  struct MonoJitInfo * D.18575;
  struct MonoMethod * D.18576;
  int j.4;
  struct MonoJitInfo * D.18580;
  int D.18581;
  int D.18582;
  int D.18585;
  struct MonoJitInfo * D.18586;
  void * D.18587;
  struct MonoJitInfo * D.18588;
  int D.18589;
  sizetype D.18590;
  volatile gint8 * D.18591;
  volatile gint8 * D.18593;
  struct MonoJitInfoTableChunk * D.18594;
  struct MonoJitInfoTableChunk * new;
  int i;
  int j;

  new = jit_info_table_new_chunk ();
  j = 0;
  i = 0;
  goto <D.17554>;
  <D.17553>:
  D.18575 = old->data[i];
  D.18576 = D.18575->d.method;
  if (D.18576 != 0B) goto <D.18577>; else goto <D.18578>;
  <D.18577>:
  j.4 = j;
  j = j.4 + 1;
  D.18580 = old->data[i];
  new->data[j.4] = D.18580;
  <D.18578>:
  i = i + 1;
  <D.17554>:
  D.18581 = old->num_elements;
  if (D.18581 > i) goto <D.17553>; else goto <D.17555>;
  <D.17555>:
  new->num_elements = j;
  D.18582 = new->num_elements;
  if (D.18582 > 0) goto <D.18583>; else goto <D.18584>;
  <D.18583>:
  D.18585 = j + -1;
  D.18586 = new->data[D.18585];
  D.18587 = D.18586->code_start;
  D.18585 = j + -1;
  D.18588 = new->data[D.18585];
  D.18589 = D.18588->code_size;
  D.18590 = (sizetype) D.18589;
  D.18591 = D.18587 + D.18590;
  new->last_code_end = D.18591;
  goto <D.18592>;
  <D.18584>:
  D.18593 = old->last_code_end;
  new->last_code_end = D.18593;
  <D.18592>:
  D.18594 = new;
  return D.18594;
}


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.18596;
  _Bool D.18599;
  long int D.18600;
  long int D.18601;
  long unsigned int D.18604;
  long unsigned int D.18605;
  _Bool D.18608;
  long int D.18609;
  long int D.18610;
  struct MonoJitInfoTable * table;

  {
    int ret;

    D.18596 = &domain->lock.mutex;
    ret = pthread_mutex_lock (D.18596);
    if (ret != 0) goto <D.18597>; else goto <D.18598>;
    <D.18597>:
    monoeg_g_log (0B, 16, "Bad call to mono_mutex_lock result %d", ret);
    <D.18598>:
    D.18599 = ret != 0;
    D.18600 = (long int) D.18599;
    D.18601 = __builtin_expect (D.18600, 0);
    if (D.18601 != 0) goto <D.18602>; else goto <D.18603>;
    <D.18602>:
    monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "domain.c", 831, "ret == 0");
    <D.18603>:
  }
  table = domain->jit_info_table;
  D.18604 = mono_stats.jit_info_table_remove_count;
  D.18605 = D.18604 + 1;
  mono_stats.jit_info_table_remove_count = D.18605;
  jit_info_table_remove (table, ji);
  mono_jit_info_free_or_queue (domain, ji);
  {
    int ret;

    D.18596 = &domain->lock.mutex;
    ret = pthread_mutex_unlock (D.18596);
    if (ret != 0) goto <D.18606>; else goto <D.18607>;
    <D.18606>:
    monoeg_g_log (0B, 16, "Bad call to mono_mutex_unlock result %d", ret);
    <D.18607>:
    D.18608 = ret != 0;
    D.18609 = (long int) D.18608;
    D.18610 = __builtin_expect (D.18609, 0);
    if (D.18610 != 0) goto <D.18611>; else goto <D.18612>;
    <D.18611>:
    monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "domain.c", 840, "ret == 0");
    <D.18612>:
  }
}


jit_info_table_remove (struct MonoJitInfoTable * table, struct MonoJitInfo * ji)
{
  int D.18613;
  _Bool D.18614;
  long int D.18615;
  long int D.18616;
  struct MonoJitInfoTableChunk * D.18619;
  struct MonoJitInfo * D.18620;
  struct MonoJitInfo * D.18622;
  struct MonoMethod * D.18623;
  _Bool D.18624;
  long int D.18625;
  long int D.18626;
  struct MonoJitInfo * D.18629;
  void * D.18630;
  struct MonoJitInfo * D.18631;
  int D.18632;
  sizetype D.18633;
  guint8 * D.18634;
  void * D.18635;
  int D.18636;
  sizetype D.18637;
  guint8 * D.18638;
  _Bool D.18639;
  long int D.18640;
  long int D.18641;
  int D.18644;
  struct MonoJitInfo * D.18645;
  _Bool D.18646;
  long int D.18647;
  long int D.18648;
  struct MonoJitInfo * D.18651;
  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.18613 = table->num_chunks;
  D.18614 = D.18613 <= chunk_pos;
  D.18615 = (long int) D.18614;
  D.18616 = __builtin_expect (D.18615, 0);
  if (D.18616 != 0) goto <D.18617>; else goto <D.18618>;
  <D.18617>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "domain.c", 795, "chunk_pos < table->num_chunks");
  <D.18618>:
  D.18619 = table->chunks[chunk_pos];
  pos = jit_info_table_chunk_index (D.18619, 0B, start);
  <D.17617>:
  chunk = table->chunks[chunk_pos];
  goto <D.17615>;
  <D.17614>:
  D.18620 = chunk->data[pos];
  if (D.18620 == ji) goto found; else goto <D.18621>;
  <D.18621>:
  D.18622 = chunk->data[pos];
  D.18623 = D.18622->d.method;
  D.18624 = D.18623 != 0B;
  D.18625 = (long int) D.18624;
  D.18626 = __builtin_expect (D.18625, 0);
  if (D.18626 != 0) goto <D.18627>; else goto <D.18628>;
  <D.18627>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "domain.c", 806, "IS_JIT_INFO_TOMBSTONE (chunk->data [pos])");
  <D.18628>:
  D.18629 = chunk->data[pos];
  D.18630 = D.18629->code_start;
  D.18631 = chunk->data[pos];
  D.18632 = D.18631->code_size;
  D.18633 = (sizetype) D.18632;
  D.18634 = D.18630 + D.18633;
  D.18635 = ji->code_start;
  D.18636 = ji->code_size;
  D.18637 = (sizetype) D.18636;
  D.18638 = D.18635 + D.18637;
  D.18639 = D.18634 > D.18638;
  D.18640 = (long int) D.18639;
  D.18641 = __builtin_expect (D.18640, 0);
  if (D.18641 != 0) goto <D.18642>; else goto <D.18643>;
  <D.18642>:
  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.18643>:
  pos = pos + 1;
  <D.17615>:
  D.18644 = chunk->num_elements;
  if (D.18644 > pos) goto <D.17614>; else goto <D.17616>;
  <D.17616>:
  chunk_pos = chunk_pos + 1;
  pos = 0;
  D.18613 = table->num_chunks;
  if (D.18613 > chunk_pos) goto <D.17617>; else goto <D.17618>;
  <D.17618>:
  found:
  D.18645 = chunk->data[pos];
  D.18646 = D.18645 != ji;
  D.18647 = (long int) D.18646;
  D.18648 = __builtin_expect (D.18647, 0);
  if (D.18648 != 0) goto <D.18649>; else goto <D.18650>;
  <D.18649>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "domain.c", 818, "chunk->data [pos] == ji");
  <D.18650>:
  D.18651 = mono_jit_info_make_tombstone (ji);
  chunk->data[pos] = D.18651;
}


mono_jit_info_make_tombstone (struct MonoJitInfo * ji)
{
  void * D.18652;
  int D.18653;
  struct MonoJitInfo * D.18654;
  struct MonoJitInfo * tombstone;

  tombstone = monoeg_malloc0 (28);
  D.18652 = ji->code_start;
  tombstone->code_start = D.18652;
  D.18653 = ji->code_size;
  tombstone->code_size = D.18653;
  tombstone->d.method = 0B;
  D.18654 = tombstone;
  return D.18654;
}


mono_jit_info_free_or_queue (struct MonoDomain * domain, struct MonoJitInfo * ji)
{
  int D.18656;
  struct GSList * D.18660;
  struct GSList * D.18661;

  D.18656 = domain->num_jit_info_tables;
  if (D.18656 <= 1) goto <D.18657>; else goto <D.18658>;
  <D.18657>:
  mono_thread_hazardous_free_or_queue (ji, monoeg_g_free, 1, 0);
  goto <D.18659>;
  <D.18658>:
  D.18660 = domain->jit_info_free_queue;
  D.18661 = monoeg_g_slist_prepend (D.18660, ji);
  domain->jit_info_free_queue = D.18661;
  <D.18659>:
}


mono_jit_info_add_aot_module (struct MonoImage * image, void * start, void * end)
{
  _Bool D.18664;
  long int D.18665;
  long int D.18666;
  struct MonoDomain * mono_root_domain.5;
  _Bool D.18670;
  long int D.18671;
  long int D.18672;
  struct MonoJitInfoTable * D.18675;
  int D.18678;
  int D.18679;
  struct MonoJitInfoTable * D.18680;
  int end.6;
  int start.7;
  int D.18683;
  struct MonoJitInfoTable * volatile * D.18684;
  _Bool D.18687;
  long int D.18688;
  long int D.18689;
  struct MonoJitInfo * ji;

  {
    int ret;

    ret = pthread_mutex_lock (&appdomains_mutex.mutex);
    if (ret != 0) goto <D.18662>; else goto <D.18663>;
    <D.18662>:
    monoeg_g_log (0B, 16, "Bad call to mono_mutex_lock result %d", ret);
    <D.18663>:
    D.18664 = ret != 0;
    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", 848, "ret == 0");
    <D.18668>:
  }
  mono_root_domain.5 = mono_root_domain;
  D.18670 = mono_root_domain.5 == 0B;
  D.18671 = (long int) D.18670;
  D.18672 = __builtin_expect (D.18671, 0);
  if (D.18672 != 0) goto <D.18673>; else goto <D.18674>;
  <D.18673>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "domain.c", 854, "mono_root_domain");
  <D.18674>:
  mono_root_domain.5 = mono_root_domain;
  D.18675 = mono_root_domain.5->aot_modules;
  if (D.18675 == 0B) goto <D.18676>; else goto <D.18677>;
  <D.18676>:
  mono_root_domain.5 = mono_root_domain;
  D.18678 = mono_root_domain.5->num_jit_info_tables;
  D.18679 = D.18678 + 1;
  mono_root_domain.5->num_jit_info_tables = D.18679;
  mono_root_domain.5 = mono_root_domain;
  mono_root_domain.5 = mono_root_domain;
  D.18680 = jit_info_table_new (mono_root_domain.5);
  mono_root_domain.5->aot_modules = D.18680;
  <D.18677>:
  ji = monoeg_malloc0 (28);
  ji->d.image = image;
  ji->code_start = start;
  end.6 = (int) end;
  start.7 = (int) start;
  D.18683 = end.6 - start.7;
  ji->code_size = D.18683;
  mono_root_domain.5 = mono_root_domain;
  mono_root_domain.5 = mono_root_domain;
  D.18684 = &mono_root_domain.5->aot_modules;
  jit_info_table_add (mono_root_domain.5, D.18684, ji);
  {
    int ret;

    ret = pthread_mutex_unlock (&appdomains_mutex.mutex);
    if (ret != 0) goto <D.18685>; else goto <D.18686>;
    <D.18685>:
    monoeg_g_log (0B, 16, "Bad call to mono_mutex_unlock result %d", ret);
    <D.18686>:
    D.18687 = ret != 0;
    D.18688 = (long int) D.18687;
    D.18689 = __builtin_expect (D.18688, 0);
    if (D.18689 != 0) goto <D.18690>; else goto <D.18691>;
    <D.18690>:
    monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "domain.c", 866, "ret == 0");
    <D.18691>:
  }
}


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.18692;

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


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

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


mono_jit_info_get_method (struct MonoJitInfo * ji)
{
  unsigned int D.18696;
  unsigned int D.18697;
  _Bool D.18698;
  long int D.18699;
  long int D.18700;
  struct MonoMethod * D.18703;

  D.18696 = BIT_FIELD_REF <*ji, 32, 160>;
  D.18697 = D.18696 & 16777216;
  D.18698 = D.18697 != 0;
  D.18699 = (long int) D.18698;
  D.18700 = __builtin_expect (D.18699, 0);
  if (D.18700 != 0) goto <D.18701>; else goto <D.18702>;
  <D.18701>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "domain.c", 890, "!ji->async");
  <D.18702>:
  D.18703 = ji->d.method;
  return D.18703;
}


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.18705;
  struct MonoJitInfo * info;

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


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

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


mono_jit_info_get_generic_jit_info (struct MonoJitInfo * ji)
{
  unsigned int D.18709;
  unsigned int D.18710;
  struct MonoGenericJitInfo * D.18713;
  <unnamed-unsigned:15> D.18714;
  int D.18715;

  D.18709 = BIT_FIELD_REF <*ji, 32, 160>;
  D.18710 = D.18709 & 131072;
  if (D.18710 != 0) goto <D.18711>; else goto <D.18712>;
  <D.18711>:
  D.18714 = ji->num_clauses;
  D.18715 = (int) D.18714;
  D.18713 = &ji->clauses[D.18715];
  return D.18713;
  <D.18712>:
  D.18713 = 0B;
  return D.18713;
}


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

  gi = mono_jit_info_get_generic_jit_info (ji);
  if (gi != 0B) goto <D.18717>; else goto <D.18718>;
  <D.18717>:
  D.18719 = gi->generic_sharing_context;
  return D.18719;
  <D.18718>:
  D.18719 = 0B;
  return D.18719;
}


mono_jit_info_set_generic_sharing_context (struct MonoJitInfo * ji, struct MonoGenericSharingContext * gsctx)
{
  _Bool D.18721;
  long int D.18722;
  long int D.18723;
  struct MonoGenericJitInfo * gi;

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


mono_jit_info_get_try_block_hole_table_info (struct MonoJitInfo * ji)
{
  unsigned int D.18726;
  unsigned int D.18727;
  <unnamed-unsigned:15> D.18730;
  int D.18731;
  unsigned int D.18732;
  struct MonoTryBlockHoleTableJitInfo * D.18735;

  D.18726 = BIT_FIELD_REF <*ji, 32, 160>;
  D.18727 = D.18726 & 262144;
  if (D.18727 != 0) goto <D.18728>; else goto <D.18729>;
  <D.18728>:
  {
    char * ptr;

    D.18730 = ji->num_clauses;
    D.18731 = (int) D.18730;
    ptr = &ji->clauses[D.18731];
    D.18726 = BIT_FIELD_REF <*ji, 32, 160>;
    D.18732 = D.18726 & 131072;
    if (D.18732 != 0) goto <D.18733>; else goto <D.18734>;
    <D.18733>:
    ptr = ptr + 20;
    <D.18734>:
    D.18735 = ptr;
    return D.18735;
  }
  <D.18729>:
  D.18735 = 0B;
  return D.18735;
}


mono_jit_info_get_arch_eh_info (struct MonoJitInfo * ji)
{
  unsigned int D.18737;
  unsigned int D.18738;
  <unnamed-unsigned:15> D.18741;
  int D.18742;
  unsigned int D.18743;
  unsigned int D.18746;
  struct MonoArchEHJitInfo * D.18749;

  D.18737 = BIT_FIELD_REF <*ji, 32, 160>;
  D.18738 = D.18737 & 524288;
  if (D.18738 != 0) goto <D.18739>; else goto <D.18740>;
  <D.18739>:
  {
    char * ptr;

    D.18741 = ji->num_clauses;
    D.18742 = (int) D.18741;
    ptr = &ji->clauses[D.18742];
    D.18737 = BIT_FIELD_REF <*ji, 32, 160>;
    D.18743 = D.18737 & 131072;
    if (D.18743 != 0) goto <D.18744>; else goto <D.18745>;
    <D.18744>:
    ptr = ptr + 20;
    <D.18745>:
    D.18737 = BIT_FIELD_REF <*ji, 32, 160>;
    D.18746 = D.18737 & 262144;
    if (D.18746 != 0) goto <D.18747>; else goto <D.18748>;
    <D.18747>:
    ptr = ptr + 4;
    <D.18748>:
    D.18749 = ptr;
    return D.18749;
  }
  <D.18740>:
  D.18749 = 0B;
  return D.18749;
}


mono_jit_info_get_cas_info (struct MonoJitInfo * ji)
{
  unsigned int D.18751;
  unsigned int D.18752;
  <unnamed-unsigned:15> D.18755;
  int D.18756;
  unsigned int D.18757;
  unsigned int D.18760;
  unsigned int D.18763;
  struct MonoMethodCasInfo * D.18766;

  D.18751 = BIT_FIELD_REF <*ji, 32, 160>;
  D.18752 = D.18751 & 65536;
  if (D.18752 != 0) goto <D.18753>; else goto <D.18754>;
  <D.18753>:
  {
    char * ptr;

    D.18755 = ji->num_clauses;
    D.18756 = (int) D.18755;
    ptr = &ji->clauses[D.18756];
    D.18751 = BIT_FIELD_REF <*ji, 32, 160>;
    D.18757 = D.18751 & 131072;
    if (D.18757 != 0) goto <D.18758>; else goto <D.18759>;
    <D.18758>:
    ptr = ptr + 20;
    <D.18759>:
    D.18751 = BIT_FIELD_REF <*ji, 32, 160>;
    D.18760 = D.18751 & 262144;
    if (D.18760 != 0) goto <D.18761>; else goto <D.18762>;
    <D.18761>:
    ptr = ptr + 4;
    <D.18762>:
    D.18751 = BIT_FIELD_REF <*ji, 32, 160>;
    D.18763 = D.18751 & 524288;
    if (D.18763 != 0) goto <D.18764>; else goto <D.18765>;
    <D.18764>:
    ptr = ptr + 4;
    <D.18765>:
    D.18766 = ptr;
    return D.18766;
  }
  <D.18754>:
  D.18766 = 0B;
  return D.18766;
}


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.18770;
  mono_unichar2 * D.18773;
  mono_unichar2 * D.18774;
  int D.18775;
  unsigned int D.18776;
  int D.18777;
  _Bool D.18778;
  int l1;
  int l2;

  l1 = mono_string_length (s1);
  l2 = mono_string_length (s2);
  if (s1 == s2) goto <D.18768>; else goto <D.18769>;
  <D.18768>:
  D.18770 = 1;
  return D.18770;
  <D.18769>:
  if (l1 != l2) goto <D.18771>; else goto <D.18772>;
  <D.18771>:
  D.18770 = 0;
  return D.18770;
  <D.18772>:
  D.18773 = mono_string_chars (s1);
  D.18774 = mono_string_chars (s2);
  D.18775 = l1 * 2;
  D.18776 = (unsigned int) D.18775;
  D.18777 = memcmp (D.18773, D.18774, D.18776);
  D.18778 = D.18777 == 0;
  D.18770 = (mono_bool) D.18778;
  return D.18770;
}


mono_string_hash (struct MonoString * s)
{
  unsigned int D.18780;
  unsigned int D.18781;
  short unsigned int D.18782;
  unsigned int D.18783;
  unsigned int D.18784;
  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.17731>;
  <D.17730>:
  D.18780 = h << 5;
  D.18781 = D.18780 - h;
  D.18782 = *p;
  D.18783 = (unsigned int) D.18782;
  h = D.18781 + D.18783;
  p = p + 2;
  i = i + 1;
  <D.17731>:
  if (i < len) goto <D.17730>; else goto <D.17732>;
  <D.17732>:
  D.18784 = h;
  return D.18784;
}


mono_domain_create ()
{
  _Bool D.18788;
  long int D.18789;
  long int D.18790;
  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.18799;
  unsigned int D.18800;
  int bit.12;
  int D.18802;
  unsigned int D.18803;
  unsigned int D.18804;
  unsigned int D.18805;
  int D.18806;
  void * domain_gc_desc.13;
  _Bool D.18810;
  long int D.18811;
  long int D.18812;
  struct MonoGHashTable * * D.18815;
  int shadow_serial.14;
  struct MonoMemPool * D.18817;
  struct MonoCodeManager * D.18818;
  struct LockFreeMempool * D.18819;
  struct MonoGHashTable * D.18820;
  struct GPtrArray * D.18821;
  struct GHashTable * D.18822;
  struct MonoInternalHashTable * D.18823;
  struct MonoGHashTable * D.18824;
  struct MonoJitInfoTable * D.18825;
  struct GHashTable * D.18826;
  struct GHashTable * D.18827;
  struct CRITICAL_SECTION * D.18828;
  struct CRITICAL_SECTION * D.18829;
  struct CRITICAL_SECTION * D.18830;
  struct CRITICAL_SECTION * D.18831;
  _Bool D.18834;
  long int D.18835;
  long int D.18836;
  _Bool D.18841;
  long int D.18842;
  long int D.18843;
  struct MonoPerfCounters * mono_perfcounters.15;
  unsigned int D.18847;
  unsigned int D.18848;
  unsigned int D.18849;
  unsigned int D.18850;
  void (*<T193c>) (struct MonoDomain *) create_domain_hook.16;
  struct MonoDomain * D.18854;
  struct MonoDomain * domain;
  guint32 shadow_serial;

  {
    int ret;

    ret = pthread_mutex_lock (&appdomains_mutex.mutex);
    if (ret != 0) goto <D.18786>; else goto <D.18787>;
    <D.18786>:
    monoeg_g_log (0B, 16, "Bad call to mono_mutex_lock result %d", ret);
    <D.18787>:
    D.18788 = ret != 0;
    D.18789 = (long int) D.18788;
    D.18790 = __builtin_expect (D.18789, 0);
    if (D.18790 != 0) goto <D.18791>; else goto <D.18792>;
    <D.18791>:
    monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "domain.c", 1234, "ret == 0");
    <D.18792>:
  }
  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.18797>; else goto <D.18798>;
  <D.18797>:
  {
    unsigned int i;
    unsigned int bit;

    bit = 0;
    i = 36;
    goto <D.17772>;
    <D.17771>:
    bit = i / 4;
    D.18799 = bit / 32;
    D.18800 = domain_gc_bitmap[D.18799];
    bit.12 = (int) bit;
    D.18802 = bit.12 & 31;
    D.18803 = 1 << D.18802;
    D.18804 = D.18800 | D.18803;
    domain_gc_bitmap[D.18799] = D.18804;
    i = i + 4;
    <D.17772>:
    if (i <= 71) goto <D.17771>; else goto <D.17773>;
    <D.17773>:
    D.18805 = bit + 1;
    D.18806 = (int) D.18805;
    domain_gc_desc.13 = mono_gc_make_descr_from_bitmap (&domain_gc_bitmap, D.18806);
    domain_gc_desc = domain_gc_desc.13;
  }
  <D.18798>:
  {
    int ret;

    ret = pthread_mutex_unlock (&appdomains_mutex.mutex);
    if (ret != 0) goto <D.18808>; else goto <D.18809>;
    <D.18808>:
    monoeg_g_log (0B, 16, "Bad call to mono_mutex_unlock result %d", ret);
    <D.18809>:
    D.18810 = ret != 0;
    D.18811 = (long int) D.18810;
    D.18812 = __builtin_expect (D.18811, 0);
    if (D.18812 != 0) goto <D.18813>; else goto <D.18814>;
    <D.18813>:
    monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "domain.c", 1245, "ret == 0");
    <D.18814>:
  }
  domain_gc_desc.11 = domain_gc_desc;
  domain = mono_gc_alloc_fixed (380, domain_gc_desc.11);
  D.18815 = &domain->env;
  mono_gc_register_root (D.18815, 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.18817 = mono_mempool_new ();
  domain->mp = D.18817;
  D.18818 = mono_code_manager_new ();
  domain->code_mp = D.18818;
  D.18819 = lock_free_mempool_new ();
  domain->lock_free_mp = D.18819;
  D.18820 = mono_g_hash_table_new_type (mono_string_hash, mono_string_equal, 3);
  domain->env = D.18820;
  domain->domain_assemblies = 0B;
  domain->assembly_bindings = 0B;
  domain->assembly_bindings_parsed = 0;
  D.18821 = monoeg_g_ptr_array_new ();
  domain->class_vtable_array = D.18821;
  D.18822 = monoeg_g_hash_table_new (mono_ptrarray_hash, mono_ptrarray_equal);
  domain->proxy_vtable_hash = D.18822;
  domain->static_data_array = 0B;
  D.18823 = &domain->jit_code_hash;
  mono_jit_code_hash_init (D.18823);
  D.18824 = mono_g_hash_table_new_type (mono_string_hash, mono_string_equal, 3);
  domain->ldstr_table = D.18824;
  domain->num_jit_info_tables = 1;
  D.18825 = jit_info_table_new (domain);
  domain->jit_info_table = D.18825;
  domain->jit_info_free_queue = 0B;
  D.18826 = monoeg_g_hash_table_new (mono_aligned_addr_hash, 0B);
  domain->finalizable_objects_hash = D.18826;
  D.18827 = monoeg_g_hash_table_new (mono_aligned_addr_hash, 0B);
  domain->ftnptrs_hash = D.18827;
  D.18828 = &domain->lock;
  InitializeCriticalSection (D.18828);
  D.18829 = &domain->assemblies_lock;
  InitializeCriticalSection (D.18829);
  D.18830 = &domain->jit_code_hash_lock;
  InitializeCriticalSection (D.18830);
  D.18831 = &domain->finalizable_objects_hash_lock;
  InitializeCriticalSection (D.18831);
  domain->method_rgctx_hash = 0B;
  {
    int ret;

    ret = pthread_mutex_lock (&appdomains_mutex.mutex);
    if (ret != 0) goto <D.18832>; else goto <D.18833>;
    <D.18832>:
    monoeg_g_log (0B, 16, "Bad call to mono_mutex_lock result %d", ret);
    <D.18833>:
    D.18834 = ret != 0;
    D.18835 = (long int) D.18834;
    D.18836 = __builtin_expect (D.18835, 0);
    if (D.18836 != 0) goto <D.18837>; else goto <D.18838>;
    <D.18837>:
    monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "domain.c", 1292, "ret == 0");
    <D.18838>:
  }
  domain_id_alloc (domain);
  {
    int ret;

    ret = pthread_mutex_unlock (&appdomains_mutex.mutex);
    if (ret != 0) goto <D.18839>; else goto <D.18840>;
    <D.18839>:
    monoeg_g_log (0B, 16, "Bad call to mono_mutex_unlock result %d", ret);
    <D.18840>:
    D.18841 = ret != 0;
    D.18842 = (long int) D.18841;
    D.18843 = __builtin_expect (D.18842, 0);
    if (D.18843 != 0) goto <D.18844>; else goto <D.18845>;
    <D.18844>:
    monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "domain.c", 1294, "ret == 0");
    <D.18845>:
  }
  mono_perfcounters.15 = mono_perfcounters;
  D.18847 = mono_perfcounters.15->loader_appdomains;
  D.18848 = D.18847 + 1;
  mono_perfcounters.15->loader_appdomains = D.18848;
  mono_perfcounters.15 = mono_perfcounters;
  D.18849 = mono_perfcounters.15->loader_total_appdomains;
  D.18850 = D.18849 + 1;
  mono_perfcounters.15->loader_total_appdomains = D.18850;
  mono_debug_domain_create (domain);
  create_domain_hook.16 = create_domain_hook;
  if (create_domain_hook.16 != 0B) goto <D.18852>; else goto <D.18853>;
  <D.18852>:
  create_domain_hook.16 = create_domain_hook;
  create_domain_hook.16 (domain);
  <D.18853>:
  mono_profiler_appdomain_loaded (domain, 0);
  D.18854 = domain;
  return D.18854;
}


mono_ptrarray_equal (void * * s1, void * * s2)
{
  void * D.18856;
  void * D.18857;
  int D.18858;
  gboolean D.18861;
  const void * D.18862;
  const void * D.18863;
  unsigned int len.17;
  unsigned int D.18865;
  int D.18866;
  _Bool D.18867;
  int len;

  D.18856 = *s1;
  len = (int) D.18856;
  D.18857 = *s2;
  D.18858 = (int) D.18857;
  if (D.18858 != len) goto <D.18859>; else goto <D.18860>;
  <D.18859>:
  D.18861 = 0;
  return D.18861;
  <D.18860>:
  D.18862 = s1 + 4;
  D.18863 = s2 + 4;
  len.17 = (unsigned int) len;
  D.18865 = len.17 * 4;
  D.18866 = memcmp (D.18862, D.18863, D.18865);
  D.18867 = D.18866 == 0;
  D.18861 = (gboolean) D.18867;
  return D.18861;
}


mono_ptrarray_hash (void * * s)
{
  void * D.18869;
  unsigned int i.18;
  unsigned int D.18871;
  void * * D.18872;
  void * D.18873;
  unsigned int D.18874;
  guint D.18875;
  int i;
  int len;
  guint hash;

  D.18869 = *s;
  len = (int) D.18869;
  hash = 0;
  i = 1;
  goto <D.17745>;
  <D.17744>:
  i.18 = (unsigned int) i;
  D.18871 = i.18 * 4;
  D.18872 = s + D.18871;
  D.18873 = *D.18872;
  D.18874 = (unsigned int) D.18873;
  hash = D.18874 + hash;
  i = i + 1;
  <D.17745>:
  if (i < len) goto <D.17744>; else goto <D.17746>;
  <D.17746>:
  D.18875 = hash;
  return D.18875;
}


lock_free_mempool_new ()
{
  struct LockFreeMempool * D.18877;

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


domain_id_alloc (struct MonoDomain * domain)
{
  struct MonoDomain * * appdomains_list.19;
  short unsigned int appdomain_list_size.20;
  unsigned int D.18883;
  unsigned int D.18884;
  void * appdomains_list.21;
  short unsigned int appdomain_next.22;
  unsigned int i.23;
  unsigned int D.18888;
  struct MonoDomain * * D.18889;
  struct MonoDomain * D.18890;
  int D.18893;
  int D.18898;
  unsigned int new_size.24;
  unsigned int D.18904;
  short unsigned int appdomain_list_size.25;
  unsigned int id.26;
  unsigned int D.18907;
  struct MonoDomain * * D.18908;
  short unsigned int appdomain_next.27;
  short unsigned int appdomain_next.28;
  int D.18913;
  int id;
  int i;

  id = -1;
  appdomains_list.19 = appdomains_list;
  if (appdomains_list.19 == 0B) goto <D.18880>; else goto <D.18881>;
  <D.18880>:
  appdomain_list_size = 2;
  appdomain_list_size.20 = appdomain_list_size;
  D.18883 = (unsigned int) appdomain_list_size.20;
  D.18884 = D.18883 * 4;
  appdomains_list.21 = mono_gc_alloc_fixed (D.18884, 0B);
  appdomains_list = appdomains_list.21;
  <D.18881>:
  appdomain_next.22 = appdomain_next;
  i = (int) appdomain_next.22;
  goto <D.17754>;
  <D.17753>:
  appdomains_list.19 = appdomains_list;
  i.23 = (unsigned int) i;
  D.18888 = i.23 * 4;
  D.18889 = appdomains_list.19 + D.18888;
  D.18890 = *D.18889;
  if (D.18890 == 0B) goto <D.18891>; else goto <D.18892>;
  <D.18891>:
  id = i;
  goto <D.17752>;
  <D.18892>:
  i = i + 1;
  <D.17754>:
  appdomain_list_size.20 = appdomain_list_size;
  D.18893 = (int) appdomain_list_size.20;
  if (D.18893 > i) goto <D.17753>; else goto <D.17752>;
  <D.17752>:
  if (id == -1) goto <D.18894>; else goto <D.18895>;
  <D.18894>:
  i = 0;
  goto <D.17757>;
  <D.17756>:
  appdomains_list.19 = appdomains_list;
  i.23 = (unsigned int) i;
  D.18888 = i.23 * 4;
  D.18889 = appdomains_list.19 + D.18888;
  D.18890 = *D.18889;
  if (D.18890 == 0B) goto <D.18896>; else goto <D.18897>;
  <D.18896>:
  id = i;
  goto <D.17755>;
  <D.18897>:
  i = i + 1;
  <D.17757>:
  appdomain_next.22 = appdomain_next;
  D.18898 = (int) appdomain_next.22;
  if (D.18898 > i) goto <D.17756>; else goto <D.17755>;
  <D.17755>:
  <D.18895>:
  if (id == -1) goto <D.18899>; else goto <D.18900>;
  <D.18899>:
  {
    struct MonoDomain * * new_list;
    int new_size;

    appdomain_list_size.20 = appdomain_list_size;
    D.18893 = (int) appdomain_list_size.20;
    new_size = D.18893 * 2;
    if (new_size > 65535) goto <D.18901>; else goto <D.18902>;
    <D.18901>:
    monoeg_assertion_message ("* Assertion: should not be reached at %s:%d\n", "domain.c", 1208);
    <D.18902>:
    appdomain_list_size.20 = appdomain_list_size;
    id = (int) appdomain_list_size.20;
    new_size.24 = (unsigned int) new_size;
    D.18904 = new_size.24 * 4;
    new_list = mono_gc_alloc_fixed (D.18904, 0B);
    appdomains_list.19 = appdomains_list;
    appdomain_list_size.20 = appdomain_list_size;
    D.18883 = (unsigned int) appdomain_list_size.20;
    D.18884 = D.18883 * 4;
    memcpy (new_list, appdomains_list.19, D.18884);
    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.18900>:
  domain->domain_id = id;
  appdomains_list.19 = appdomains_list;
  id.26 = (unsigned int) id;
  D.18907 = id.26 * 4;
  D.18908 = appdomains_list.19 + D.18907;
  *D.18908 = 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.18911>; else goto <D.18912>;
  <D.18911>:
  appdomain_next = 0;
  <D.18912>:
  D.18913 = id;
  return D.18913;
}


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

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


mono_init_internal (const char * filename, const char * exe_filename, const char * runtime_version)
{
  struct MonoDomain * domain.29;
  int D.18920;
  struct MonoDomain * domain.30;
  unsigned int appdomain_thread_id.31;
  const struct MonoRuntimeInfo * D.18930;
  const struct MonoRuntimeInfo * D.18931;
  const char[12] * D.18934;
  const struct MonoRuntimeInfo * current_runtime.32;
  const struct MonoRuntimeInfo * current_runtime.33;
  <unnamed type> status.34;
  const char * D.18943;
  const char[4] * D.18944;
  const char * D.18945;
  const char * D.18946;
  struct MonoImage * D.18948;
  struct MonoImage * D.18949;
  struct MonoClass * D.18950;
  struct MonoClass * D.18951;
  _Bool D.18952;
  long int D.18953;
  long int D.18954;
  struct MonoClass * D.18957;
  struct MonoClass * D.18958;
  _Bool D.18959;
  long int D.18960;
  long int D.18961;
  struct MonoClass * D.18964;
  struct MonoClass * D.18965;
  _Bool D.18966;
  long int D.18967;
  long int D.18968;
  struct MonoClass * D.18971;
  struct MonoClass * D.18972;
  _Bool D.18973;
  long int D.18974;
  long int D.18975;
  struct MonoClass * D.18978;
  struct MonoClass * D.18979;
  _Bool D.18980;
  long int D.18981;
  long int D.18982;
  struct MonoClass * D.18985;
  struct MonoClass * D.18986;
  _Bool D.18987;
  long int D.18988;
  long int D.18989;
  struct MonoClass * D.18992;
  struct MonoClass * D.18993;
  _Bool D.18994;
  long int D.18995;
  long int D.18996;
  struct MonoClass * D.18999;
  struct MonoClass * D.19000;
  _Bool D.19001;
  long int D.19002;
  long int D.19003;
  struct MonoClass * D.19006;
  struct MonoClass * D.19007;
  _Bool D.19008;
  long int D.19009;
  long int D.19010;
  struct MonoClass * D.19013;
  struct MonoClass * D.19014;
  _Bool D.19015;
  long int D.19016;
  long int D.19017;
  struct MonoClass * D.19020;
  struct MonoClass * D.19021;
  _Bool D.19022;
  long int D.19023;
  long int D.19024;
  struct MonoClass * D.19027;
  struct MonoClass * D.19028;
  _Bool D.19029;
  long int D.19030;
  long int D.19031;
  struct MonoClass * D.19034;
  struct MonoClass * D.19035;
  _Bool D.19036;
  long int D.19037;
  long int D.19038;
  struct MonoClass * D.19041;
  struct MonoClass * D.19042;
  _Bool D.19043;
  long int D.19044;
  long int D.19045;
  struct MonoClass * D.19048;
  struct MonoClass * D.19049;
  _Bool D.19050;
  long int D.19051;
  long int D.19052;
  struct MonoClass * D.19055;
  struct MonoClass * D.19056;
  _Bool D.19057;
  long int D.19058;
  long int D.19059;
  struct MonoClass * D.19062;
  struct MonoClass * D.19063;
  _Bool D.19064;
  long int D.19065;
  long int D.19066;
  struct MonoClass * D.19069;
  struct MonoClass * D.19070;
  _Bool D.19071;
  long int D.19072;
  long int D.19073;
  struct MonoClass * D.19076;
  struct MonoClass * D.19077;
  _Bool D.19078;
  long int D.19079;
  long int D.19080;
  struct MonoClass * D.19083;
  struct MonoClass * D.19084;
  _Bool D.19085;
  long int D.19086;
  long int D.19087;
  struct MonoClass * D.19090;
  struct MonoClass * D.19091;
  _Bool D.19092;
  long int D.19093;
  long int D.19094;
  struct MonoClass * D.19097;
  struct MonoClass * D.19098;
  _Bool D.19099;
  long int D.19100;
  long int D.19101;
  struct MonoClass * D.19104;
  struct MonoClass * D.19105;
  _Bool D.19106;
  long int D.19107;
  long int D.19108;
  struct MonoClass * D.19111;
  struct MonoClass * D.19112;
  _Bool D.19113;
  long int D.19114;
  long int D.19115;
  struct MonoClass * D.19118;
  struct MonoClass * D.19119;
  _Bool D.19120;
  long int D.19121;
  long int D.19122;
  struct MonoClass * D.19125;
  struct MonoClass * D.19126;
  _Bool D.19127;
  long int D.19128;
  long int D.19129;
  struct MonoClass * D.19132;
  struct MonoClass * D.19133;
  _Bool D.19134;
  long int D.19135;
  long int D.19136;
  struct MonoClass * D.19139;
  struct MonoClass * D.19140;
  _Bool D.19141;
  long int D.19142;
  long int D.19143;
  struct MonoClass * D.19146;
  struct MonoClass * D.19147;
  _Bool D.19148;
  long int D.19149;
  long int D.19150;
  struct MonoClass * D.19153;
  struct MonoClass * D.19154;
  _Bool D.19155;
  long int D.19156;
  long int D.19157;
  struct MonoClass * D.19160;
  struct MonoClass * D.19161;
  _Bool D.19162;
  long int D.19163;
  long int D.19164;
  struct MonoClass * D.19167;
  struct MonoClass * D.19168;
  struct _IO_FILE * stderr.35;
  const char * iftmp.36;
  struct MonoClass * D.19176;
  struct MonoClass * D.19177;
  _Bool D.19178;
  long int D.19179;
  long int D.19180;
  struct MonoClass * D.19183;
  struct MonoClass * D.19184;
  _Bool D.19185;
  long int D.19186;
  long int D.19187;
  struct MonoClass * D.19190;
  struct MonoClass * D.19191;
  _Bool D.19192;
  long int D.19193;
  long int D.19194;
  struct MonoClass * D.19197;
  struct MonoClass * D.19198;
  _Bool D.19199;
  long int D.19200;
  long int D.19201;
  struct MonoClass * D.19204;
  struct MonoClass * D.19205;
  _Bool D.19206;
  long int D.19207;
  long int D.19208;
  struct MonoClass * D.19211;
  struct MonoClass * D.19212;
  _Bool D.19213;
  long int D.19214;
  long int D.19215;
  struct MonoClass * D.19218;
  struct MonoClass * D.19219;
  _Bool D.19220;
  long int D.19221;
  long int D.19222;
  struct MonoClass * D.19225;
  struct MonoClass * D.19226;
  _Bool D.19227;
  long int D.19228;
  long int D.19229;
  struct MonoClass * D.19232;
  struct MonoClass * D.19233;
  _Bool D.19234;
  long int D.19235;
  long int D.19236;
  struct MonoClass * D.19239;
  struct MonoClass * D.19240;
  _Bool D.19241;
  long int D.19242;
  long int D.19243;
  struct MonoClass * D.19246;
  struct MonoClass * D.19247;
  _Bool D.19248;
  long int D.19249;
  long int D.19250;
  struct MonoClass * D.19253;
  struct MonoClass * D.19254;
  _Bool D.19255;
  long int D.19256;
  long int D.19257;
  struct MonoClass * D.19260;
  struct MonoClass * D.19261;
  _Bool D.19262;
  long int D.19263;
  long int D.19264;
  struct MonoClass * D.19267;
  struct MonoClass * D.19268;
  _Bool D.19269;
  long int D.19270;
  long int D.19271;
  struct MonoClass * D.19274;
  struct MonoClass * D.19275;
  _Bool D.19276;
  long int D.19277;
  long int D.19278;
  struct MonoClass * D.19281;
  struct MonoClass * D.19282;
  _Bool D.19283;
  long int D.19284;
  long int D.19285;
  struct MonoClass * D.19288;
  struct MonoClass * D.19289;
  struct MonoClass * D.19290;
  struct MonoClass * D.19291;
  struct MonoClass * D.19292;
  struct MonoClass * D.19293;
  struct MonoClass * D.19294;
  struct MonoClass * D.19295;
  struct MonoClass * D.19296;
  struct MonoClass * D.19297;
  struct MonoClass * D.19298;
  gchar * D.19299;
  struct MonoDomain * D.19300;
  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.18918>; else goto <D.18919>;
      <D.18918>:
      monoeg_assertion_message ("* Assertion: should not be reached at %s:%d\n", "domain.c", 1334);
      <D.18919>:
      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.18920 = mono_gc_is_moving ();
      if (D.18920 == 0) goto <D.18921>; else goto <D.18922>;
      <D.18921>:
      mono_gc_register_root (&appdomains_list, 4, 0B);
      <D.18922>:
      domain.30 = mono_domain_create ();
      domain = domain.30;
      domain.29 = domain;
      mono_root_domain = domain.29;
      domain.29 = domain;
      tls_appdomain = domain.29;
      appdomain_thread_id.31 = appdomain_thread_id;
      domain.29 = domain;
      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.18925>; else goto <D.18926>;
      <D.18925>:
      get_runtimes_from_exe (exe_filename, &exe_image, &runtimes);
      goto <D.18927>;
      <D.18926>:
      if (runtime_version != 0B) goto <D.18928>; else goto <D.18929>;
      <D.18928>:
      D.18930 = get_runtime_by_version (runtime_version);
      runtimes[0] = D.18930;
      runtimes[1] = 0B;
      <D.18929>:
      <D.18927>:
      D.18931 = runtimes[0];
      if (D.18931 == 0B) goto <D.18932>; else goto <D.18933>;
      <D.18932>:
      {
        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.18934 = &default_runtime->runtime_version;
        monoeg_g_print ("Using default runtime: %s\n", D.18934);
      }
      <D.18933>:
      n = 0;
      goto <D.17790>;
      <D.17789>:
      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.17788>; else goto <D.18938>;
      <D.18938>:
      n = n + 1;
      <D.17790>:
      current_runtime.32 = runtimes[n];
      if (current_runtime.32 != 0B) goto <D.18939>; else goto <D.17788>;
      <D.18939>:
      if (ass == 0B) goto <D.17789>; else goto <D.17788>;
      <D.17788>:
      status.34 = status;
      if (status.34 != 0) goto <D.18940>; else goto <D.18942>;
      <D.18942>:
      if (ass == 0B) goto <D.18940>; else goto <D.18941>;
      <D.18940>:
      status.34 = status;
      switch (status.34) <default: <D.18947>, case 0: <D.17796>, case 1: <D.17791>, case 2: <D.17795>, case 3: <D.17794>>
      <D.17791>:
      {
        char * corlib_file;

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


mono_native_tls_alloc (pthread_key_t * key, void * destructor)
{
  int D.19303;
  void (*<Tc3>) (void *) destructor.37;
  int D.19305;
  _Bool D.19306;

  destructor.37 = (void (*<Tc3>) (void *)) destructor;
  D.19305 = pthread_key_create (key, destructor.37);
  D.19306 = D.19305 == 0;
  D.19303 = (int) D.19306;
  return D.19303;
}


mono_native_tls_set_value (pthread_key_t key, void * value)
{
  int D.19308;
  int D.19309;
  _Bool D.19310;

  D.19309 = pthread_setspecific (key, value);
  D.19310 = D.19309 == 0;
  D.19308 = (int) D.19310;
  return D.19308;
}


get_runtimes_from_exe (const char * exe_file, struct MonoImage * * exe_image, const struct MonoRuntimeInfo * * runtimes)
{
  struct GSList * D.19314;
  int n.38;
  unsigned int n.39;
  unsigned int D.19321;
  const struct MonoRuntimeInfo * * D.19322;
  struct GSList * iftmp.40;
  unsigned int n.41;
  unsigned int D.19328;
  const struct MonoRuntimeInfo * * D.19329;
  char * D.19330;
  const struct MonoRuntimeInfo * D.19333;
  const struct MonoRuntimeInfo * * D.19334;
  const struct MonoRuntimeInfo * D.19339;
  char * D.19340;
  const struct MonoRuntimeInfo * D.19341;
  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.19312>; else goto <D.19313>;
  <D.19312>:
  D.19314 = app_config->supported_runtimes;
  if (D.19314 != 0B) goto <D.19315>; else goto <D.19316>;
  <D.19315>:
  {
    int n;
    struct GSList * list;

    n = 0;
    list = app_config->supported_runtimes;
    goto <D.18202>;
    <D.18201>:
    version = list->data;
    runtime = get_runtime_by_version (version);
    if (runtime != 0B) goto <D.19317>; else goto <D.19318>;
    <D.19317>:
    n.38 = n;
    n = n.38 + 1;
    n.39 = (unsigned int) n.38;
    D.19321 = n.39 * 4;
    D.19322 = runtimes + D.19321;
    *D.19322 = runtime;
    <D.19318>:
    if (list != 0B) goto <D.19324>; else goto <D.19325>;
    <D.19324>:
    iftmp.40 = list->next;
    goto <D.19326>;
    <D.19325>:
    iftmp.40 = 0B;
    <D.19326>:
    list = iftmp.40;
    <D.18202>:
    if (list != 0B) goto <D.18201>; else goto <D.18203>;
    <D.18203>:
    n.41 = (unsigned int) n;
    D.19328 = n.41 * 4;
    D.19329 = runtimes + D.19328;
    *D.19329 = 0B;
    app_config_free (app_config);
    return;
  }
  <D.19316>:
  D.19330 = app_config->required_runtime;
  if (D.19330 != 0B) goto <D.19331>; else goto <D.19332>;
  <D.19331>:
  D.19330 = app_config->required_runtime;
  D.19333 = get_runtime_by_version (D.19330);
  *runtimes = D.19333;
  D.19334 = runtimes + 4;
  *D.19334 = 0B;
  app_config_free (app_config);
  return;
  <D.19332>:
  app_config_free (app_config);
  <D.19313>:
  image = mono_assembly_open_from_bundle (exe_file, 0B, 0);
  if (image == 0B) goto <D.19335>; else goto <D.19336>;
  <D.19335>:
  image = mono_image_open (exe_file, 0B);
  <D.19336>:
  if (image == 0B) goto <D.19337>; else goto <D.19338>;
  <D.19337>:
  D.19339 = get_runtime_by_version ("v2.0.50727");
  *runtimes = D.19339;
  D.19334 = runtimes + 4;
  *D.19334 = 0B;
  return;
  <D.19338>:
  *exe_image = image;
  D.19340 = image->version;
  D.19341 = get_runtime_by_version (D.19340);
  *runtimes = D.19341;
  D.19334 = runtimes + 4;
  *D.19334 = 0B;
}


app_config_parse (const char * exe_filename)
{
  gchar * text.42;
  char * text.43;
  unsigned int len.44;
  int D.19349;
  struct AppConfigInfo * D.19352;
  unsigned int len.45;
  int len.46;
  int D.19355;
  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.19343>; else goto <D.19344>;
      <D.19343>:
      text.42 = monoeg_strdup (bundled_config);
      text = text.42;
      text.43 = text;
      len.44 = strlen (text.43);
      len = len.44;
      goto <D.19348>;
      <D.19344>:
      config_filename = monoeg_g_strconcat (exe_filename, ".config", 0B);
      D.19349 = monoeg_g_file_get_contents (config_filename, &text, &len, 0B);
      if (D.19349 == 0) goto <D.19350>; else goto <D.19351>;
      <D.19350>:
      monoeg_g_free (config_filename);
      D.19352 = 0B;
      return D.19352;
      <D.19351>:
      monoeg_g_free (config_filename);
      <D.19348>:
      app_config = monoeg_malloc0 (16);
      context = monoeg_g_markup_parse_context_new (&mono_parser, 0, app_config, 0B);
      text.43 = text;
      len.45 = len;
      len.46 = (int) len.45;
      D.19355 = monoeg_g_markup_parse_context_parse (context, text.43, len.46, 0B);
      if (D.19355 != 0) goto <D.19356>; else goto <D.19357>;
      <D.19356>:
      monoeg_g_markup_parse_context_end_parse (context, 0B);
      <D.19357>:
      monoeg_g_markup_parse_context_free (context);
      text.43 = text;
      monoeg_g_free (text.43);
      D.19352 = app_config;
      return D.19352;
    }
  finally
    {
      text = {CLOBBER};
      len = {CLOBBER};
    }
}


end_element (struct GMarkupParseContext * context, const gchar * element_name, void * user_data, struct GError * * error)
{
  int D.18132;
  int iftmp.47;
  int D.18131;
  const char[14] * D.19363;
  unsigned char D.19364;
  int D.19365;
  unsigned char D.19366;
  int D.19367;
  const unsigned char * D.19372;
  unsigned char D.19373;
  int D.19374;
  const unsigned char * D.19375;
  unsigned char D.19376;
  int D.19377;
  const unsigned char * D.19382;
  unsigned char D.19383;
  int D.19384;
  const unsigned char * D.19385;
  unsigned char D.19386;
  int D.19387;
  const unsigned char * D.19392;
  unsigned char D.19393;
  int D.19394;
  const unsigned char * D.19395;
  unsigned char D.19396;
  int D.19397;
  int D.19401;
  int D.19402;
  int D.18141;
  int iftmp.48;
  int D.18140;
  const char[8] * D.19407;
  unsigned char D.19408;
  int D.19409;
  unsigned char D.19410;
  int D.19411;
  const unsigned char * D.19416;
  unsigned char D.19417;
  int D.19418;
  const unsigned char * D.19419;
  unsigned char D.19420;
  int D.19421;
  const unsigned char * D.19426;
  unsigned char D.19427;
  int D.19428;
  const unsigned char * D.19429;
  unsigned char D.19430;
  int D.19431;
  const unsigned char * D.19436;
  unsigned char D.19437;
  int D.19438;
  const unsigned char * D.19439;
  unsigned char D.19440;
  int D.19441;
  int D.19445;
  int D.19446;
  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.19361>; else goto <D.19362>;
    <D.19361>:
    {
      const unsigned char * __s2;
      int __result;

      __s2 = element_name;
      D.19363 = "configuration";
      D.19364 = MEM[(const unsigned char *)D.19363];
      D.19365 = (int) D.19364;
      D.19366 = *__s2;
      D.19367 = (int) D.19366;
      __result = D.19365 - D.19367;
      {
        if (__s2_len != 0) goto <D.19368>; else goto <D.19369>;
        <D.19368>:
        if (__result == 0) goto <D.19370>; else goto <D.19371>;
        <D.19370>:
        D.19372 = &MEM[(void *)"configuration" + 1B];
        D.19373 = *D.19372;
        D.19374 = (int) D.19373;
        D.19375 = __s2 + 1;
        D.19376 = *D.19375;
        D.19377 = (int) D.19376;
        __result = D.19374 - D.19377;
        if (__s2_len > 1) goto <D.19378>; else goto <D.19379>;
        <D.19378>:
        if (__result == 0) goto <D.19380>; else goto <D.19381>;
        <D.19380>:
        D.19382 = &MEM[(void *)"configuration" + 2B];
        D.19383 = *D.19382;
        D.19384 = (int) D.19383;
        D.19385 = __s2 + 2;
        D.19386 = *D.19385;
        D.19387 = (int) D.19386;
        __result = D.19384 - D.19387;
        if (__s2_len > 2) goto <D.19388>; else goto <D.19389>;
        <D.19388>:
        if (__result == 0) goto <D.19390>; else goto <D.19391>;
        <D.19390>:
        D.19392 = &MEM[(void *)"configuration" + 3B];
        D.19393 = *D.19392;
        D.19394 = (int) D.19393;
        D.19395 = __s2 + 3;
        D.19396 = *D.19395;
        D.19397 = (int) D.19396;
        __result = D.19394 - D.19397;
        <D.19391>:
        <D.19389>:
        <D.19381>:
        <D.19379>:
        <D.19371>:
        <D.19369>:
      }
      D.18131 = __result;
    }
    iftmp.47 = -D.18131;
    goto <D.19398>;
    <D.19362>:
    iftmp.47 = __builtin_strcmp (element_name, "configuration");
    <D.19398>:
    D.18132 = iftmp.47;
  }
  if (D.18132 == 0) goto <D.19399>; else goto <D.19400>;
  <D.19399>:
  D.19401 = app_config->configuration_count;
  D.19402 = D.19401 + -1;
  app_config->configuration_count = D.19402;
  goto <D.19403>;
  <D.19400>:
  {
    size_t __s1_len;
    size_t __s2_len;

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

      __s2 = element_name;
      D.19407 = "startup";
      D.19408 = MEM[(const unsigned char *)D.19407];
      D.19409 = (int) D.19408;
      D.19410 = *__s2;
      D.19411 = (int) D.19410;
      __result = D.19409 - D.19411;
      {
        if (__s2_len != 0) goto <D.19412>; else goto <D.19413>;
        <D.19412>:
        if (__result == 0) goto <D.19414>; else goto <D.19415>;
        <D.19414>:
        D.19416 = &MEM[(void *)"startup" + 1B];
        D.19417 = *D.19416;
        D.19418 = (int) D.19417;
        D.19419 = __s2 + 1;
        D.19420 = *D.19419;
        D.19421 = (int) D.19420;
        __result = D.19418 - D.19421;
        if (__s2_len > 1) goto <D.19422>; else goto <D.19423>;
        <D.19422>:
        if (__result == 0) goto <D.19424>; else goto <D.19425>;
        <D.19424>:
        D.19426 = &MEM[(void *)"startup" + 2B];
        D.19427 = *D.19426;
        D.19428 = (int) D.19427;
        D.19429 = __s2 + 2;
        D.19430 = *D.19429;
        D.19431 = (int) D.19430;
        __result = D.19428 - D.19431;
        if (__s2_len > 2) goto <D.19432>; else goto <D.19433>;
        <D.19432>:
        if (__result == 0) goto <D.19434>; else goto <D.19435>;
        <D.19434>:
        D.19436 = &MEM[(void *)"startup" + 3B];
        D.19437 = *D.19436;
        D.19438 = (int) D.19437;
        D.19439 = __s2 + 3;
        D.19440 = *D.19439;
        D.19441 = (int) D.19440;
        __result = D.19438 - D.19441;
        <D.19435>:
        <D.19433>:
        <D.19425>:
        <D.19423>:
        <D.19415>:
        <D.19413>:
      }
      D.18140 = __result;
    }
    iftmp.48 = -D.18140;
    goto <D.19442>;
    <D.19406>:
    iftmp.48 = __builtin_strcmp (element_name, "startup");
    <D.19442>:
    D.18141 = iftmp.48;
  }
  if (D.18141 == 0) goto <D.19443>; else goto <D.19444>;
  <D.19443>:
  D.19445 = app_config->startup_count;
  D.19446 = D.19445 + -1;
  app_config->startup_count = D.19446;
  <D.19444>:
  <D.19403>:
}


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.18088;
  int iftmp.49;
  int D.18087;
  const char[14] * D.19450;
  unsigned char D.19451;
  int D.19452;
  unsigned char D.19453;
  int D.19454;
  const unsigned char * D.19459;
  unsigned char D.19460;
  int D.19461;
  const unsigned char * D.19462;
  unsigned char D.19463;
  int D.19464;
  const unsigned char * D.19469;
  unsigned char D.19470;
  int D.19471;
  const unsigned char * D.19472;
  unsigned char D.19473;
  int D.19474;
  const unsigned char * D.19479;
  unsigned char D.19480;
  int D.19481;
  const unsigned char * D.19482;
  unsigned char D.19483;
  int D.19484;
  int D.19488;
  int D.19489;
  int D.18097;
  int iftmp.50;
  int D.18096;
  const char[8] * D.19493;
  unsigned char D.19494;
  int D.19495;
  unsigned char D.19496;
  int D.19497;
  const unsigned char * D.19502;
  unsigned char D.19503;
  int D.19504;
  const unsigned char * D.19505;
  unsigned char D.19506;
  int D.19507;
  const unsigned char * D.19512;
  unsigned char D.19513;
  int D.19514;
  const unsigned char * D.19515;
  unsigned char D.19516;
  int D.19517;
  const unsigned char * D.19522;
  unsigned char D.19523;
  int D.19524;
  const unsigned char * D.19525;
  unsigned char D.19526;
  int D.19527;
  int D.19531;
  int D.19532;
  int D.18106;
  int iftmp.51;
  int D.18105;
  const char[16] * D.19539;
  unsigned char D.19540;
  int D.19541;
  unsigned char D.19542;
  int D.19543;
  const unsigned char * D.19548;
  unsigned char D.19549;
  int D.19550;
  const unsigned char * D.19551;
  unsigned char D.19552;
  int D.19553;
  const unsigned char * D.19558;
  unsigned char D.19559;
  int D.19560;
  const unsigned char * D.19561;
  unsigned char D.19562;
  int D.19563;
  const unsigned char * D.19568;
  unsigned char D.19569;
  int D.19570;
  const unsigned char * D.19571;
  unsigned char D.19572;
  int D.19573;
  char * D.19577;
  int D.18115;
  int iftmp.52;
  int D.18114;
  const char[17] * D.19582;
  unsigned char D.19583;
  int D.19584;
  unsigned char D.19585;
  int D.19586;
  const unsigned char * D.19591;
  unsigned char D.19592;
  int D.19593;
  const unsigned char * D.19594;
  unsigned char D.19595;
  int D.19596;
  const unsigned char * D.19601;
  unsigned char D.19602;
  int D.19603;
  const unsigned char * D.19604;
  unsigned char D.19605;
  int D.19606;
  const unsigned char * D.19611;
  unsigned char D.19612;
  int D.19613;
  const unsigned char * D.19614;
  unsigned char D.19615;
  int D.19616;
  struct GSList * D.19620;
  struct GSList * D.19621;
  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.19448>; else goto <D.19449>;
    <D.19448>:
    {
      const unsigned char * __s2;
      int __result;

      __s2 = element_name;
      D.19450 = "configuration";
      D.19451 = MEM[(const unsigned char *)D.19450];
      D.19452 = (int) D.19451;
      D.19453 = *__s2;
      D.19454 = (int) D.19453;
      __result = D.19452 - D.19454;
      {
        if (__s2_len != 0) goto <D.19455>; else goto <D.19456>;
        <D.19455>:
        if (__result == 0) goto <D.19457>; else goto <D.19458>;
        <D.19457>:
        D.19459 = &MEM[(void *)"configuration" + 1B];
        D.19460 = *D.19459;
        D.19461 = (int) D.19460;
        D.19462 = __s2 + 1;
        D.19463 = *D.19462;
        D.19464 = (int) D.19463;
        __result = D.19461 - D.19464;
        if (__s2_len > 1) goto <D.19465>; else goto <D.19466>;
        <D.19465>:
        if (__result == 0) goto <D.19467>; else goto <D.19468>;
        <D.19467>:
        D.19469 = &MEM[(void *)"configuration" + 2B];
        D.19470 = *D.19469;
        D.19471 = (int) D.19470;
        D.19472 = __s2 + 2;
        D.19473 = *D.19472;
        D.19474 = (int) D.19473;
        __result = D.19471 - D.19474;
        if (__s2_len > 2) goto <D.19475>; else goto <D.19476>;
        <D.19475>:
        if (__result == 0) goto <D.19477>; else goto <D.19478>;
        <D.19477>:
        D.19479 = &MEM[(void *)"configuration" + 3B];
        D.19480 = *D.19479;
        D.19481 = (int) D.19480;
        D.19482 = __s2 + 3;
        D.19483 = *D.19482;
        D.19484 = (int) D.19483;
        __result = D.19481 - D.19484;
        <D.19478>:
        <D.19476>:
        <D.19468>:
        <D.19466>:
        <D.19458>:
        <D.19456>:
      }
      D.18087 = __result;
    }
    iftmp.49 = -D.18087;
    goto <D.19485>;
    <D.19449>:
    iftmp.49 = __builtin_strcmp (element_name, "configuration");
    <D.19485>:
    D.18088 = iftmp.49;
  }
  if (D.18088 == 0) goto <D.19486>; else goto <D.19487>;
  <D.19486>:
  D.19488 = app_config->configuration_count;
  D.19489 = D.19488 + 1;
  app_config->configuration_count = D.19489;
  return;
  <D.19487>:
  {
    size_t __s1_len;
    size_t __s2_len;

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

      __s2 = element_name;
      D.19493 = "startup";
      D.19494 = MEM[(const unsigned char *)D.19493];
      D.19495 = (int) D.19494;
      D.19496 = *__s2;
      D.19497 = (int) D.19496;
      __result = D.19495 - D.19497;
      {
        if (__s2_len != 0) goto <D.19498>; else goto <D.19499>;
        <D.19498>:
        if (__result == 0) goto <D.19500>; else goto <D.19501>;
        <D.19500>:
        D.19502 = &MEM[(void *)"startup" + 1B];
        D.19503 = *D.19502;
        D.19504 = (int) D.19503;
        D.19505 = __s2 + 1;
        D.19506 = *D.19505;
        D.19507 = (int) D.19506;
        __result = D.19504 - D.19507;
        if (__s2_len > 1) goto <D.19508>; else goto <D.19509>;
        <D.19508>:
        if (__result == 0) goto <D.19510>; else goto <D.19511>;
        <D.19510>:
        D.19512 = &MEM[(void *)"startup" + 2B];
        D.19513 = *D.19512;
        D.19514 = (int) D.19513;
        D.19515 = __s2 + 2;
        D.19516 = *D.19515;
        D.19517 = (int) D.19516;
        __result = D.19514 - D.19517;
        if (__s2_len > 2) goto <D.19518>; else goto <D.19519>;
        <D.19518>:
        if (__result == 0) goto <D.19520>; else goto <D.19521>;
        <D.19520>:
        D.19522 = &MEM[(void *)"startup" + 3B];
        D.19523 = *D.19522;
        D.19524 = (int) D.19523;
        D.19525 = __s2 + 3;
        D.19526 = *D.19525;
        D.19527 = (int) D.19526;
        __result = D.19524 - D.19527;
        <D.19521>:
        <D.19519>:
        <D.19511>:
        <D.19509>:
        <D.19501>:
        <D.19499>:
      }
      D.18096 = __result;
    }
    iftmp.50 = -D.18096;
    goto <D.19528>;
    <D.19492>:
    iftmp.50 = __builtin_strcmp (element_name, "startup");
    <D.19528>:
    D.18097 = iftmp.50;
  }
  if (D.18097 == 0) goto <D.19529>; else goto <D.19530>;
  <D.19529>:
  D.19531 = app_config->startup_count;
  D.19532 = D.19531 + 1;
  app_config->startup_count = D.19532;
  return;
  <D.19530>:
  D.19488 = app_config->configuration_count;
  if (D.19488 != 1) goto <D.19533>; else goto <D.19535>;
  <D.19535>:
  D.19531 = app_config->startup_count;
  if (D.19531 != 1) goto <D.19533>; else goto <D.19534>;
  <D.19533>:
  return;
  <D.19534>:
  {
    size_t __s1_len;
    size_t __s2_len;

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

      __s2 = element_name;
      D.19539 = "requiredRuntime";
      D.19540 = MEM[(const unsigned char *)D.19539];
      D.19541 = (int) D.19540;
      D.19542 = *__s2;
      D.19543 = (int) D.19542;
      __result = D.19541 - D.19543;
      {
        if (__s2_len != 0) goto <D.19544>; else goto <D.19545>;
        <D.19544>:
        if (__result == 0) goto <D.19546>; else goto <D.19547>;
        <D.19546>:
        D.19548 = &MEM[(void *)"requiredRuntime" + 1B];
        D.19549 = *D.19548;
        D.19550 = (int) D.19549;
        D.19551 = __s2 + 1;
        D.19552 = *D.19551;
        D.19553 = (int) D.19552;
        __result = D.19550 - D.19553;
        if (__s2_len > 1) goto <D.19554>; else goto <D.19555>;
        <D.19554>:
        if (__result == 0) goto <D.19556>; else goto <D.19557>;
        <D.19556>:
        D.19558 = &MEM[(void *)"requiredRuntime" + 2B];
        D.19559 = *D.19558;
        D.19560 = (int) D.19559;
        D.19561 = __s2 + 2;
        D.19562 = *D.19561;
        D.19563 = (int) D.19562;
        __result = D.19560 - D.19563;
        if (__s2_len > 2) goto <D.19564>; else goto <D.19565>;
        <D.19564>:
        if (__result == 0) goto <D.19566>; else goto <D.19567>;
        <D.19566>:
        D.19568 = &MEM[(void *)"requiredRuntime" + 3B];
        D.19569 = *D.19568;
        D.19570 = (int) D.19569;
        D.19571 = __s2 + 3;
        D.19572 = *D.19571;
        D.19573 = (int) D.19572;
        __result = D.19570 - D.19573;
        <D.19567>:
        <D.19565>:
        <D.19557>:
        <D.19555>:
        <D.19547>:
        <D.19545>:
      }
      D.18105 = __result;
    }
    iftmp.51 = -D.18105;
    goto <D.19574>;
    <D.19538>:
    iftmp.51 = __builtin_strcmp (element_name, "requiredRuntime");
    <D.19574>:
    D.18106 = iftmp.51;
  }
  if (D.18106 == 0) goto <D.19575>; else goto <D.19576>;
  <D.19575>:
  D.19577 = get_attribute_value (attribute_names, attribute_values, "version");
  app_config->required_runtime = D.19577;
  goto <D.19578>;
  <D.19576>:
  {
    size_t __s1_len;
    size_t __s2_len;

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

      __s2 = element_name;
      D.19582 = "supportedRuntime";
      D.19583 = MEM[(const unsigned char *)D.19582];
      D.19584 = (int) D.19583;
      D.19585 = *__s2;
      D.19586 = (int) D.19585;
      __result = D.19584 - D.19586;
      {
        if (__s2_len != 0) goto <D.19587>; else goto <D.19588>;
        <D.19587>:
        if (__result == 0) goto <D.19589>; else goto <D.19590>;
        <D.19589>:
        D.19591 = &MEM[(void *)"supportedRuntime" + 1B];
        D.19592 = *D.19591;
        D.19593 = (int) D.19592;
        D.19594 = __s2 + 1;
        D.19595 = *D.19594;
        D.19596 = (int) D.19595;
        __result = D.19593 - D.19596;
        if (__s2_len > 1) goto <D.19597>; else goto <D.19598>;
        <D.19597>:
        if (__result == 0) goto <D.19599>; else goto <D.19600>;
        <D.19599>:
        D.19601 = &MEM[(void *)"supportedRuntime" + 2B];
        D.19602 = *D.19601;
        D.19603 = (int) D.19602;
        D.19604 = __s2 + 2;
        D.19605 = *D.19604;
        D.19606 = (int) D.19605;
        __result = D.19603 - D.19606;
        if (__s2_len > 2) goto <D.19607>; else goto <D.19608>;
        <D.19607>:
        if (__result == 0) goto <D.19609>; else goto <D.19610>;
        <D.19609>:
        D.19611 = &MEM[(void *)"supportedRuntime" + 3B];
        D.19612 = *D.19611;
        D.19613 = (int) D.19612;
        D.19614 = __s2 + 3;
        D.19615 = *D.19614;
        D.19616 = (int) D.19615;
        __result = D.19613 - D.19616;
        <D.19610>:
        <D.19608>:
        <D.19600>:
        <D.19598>:
        <D.19590>:
        <D.19588>:
      }
      D.18114 = __result;
    }
    iftmp.52 = -D.18114;
    goto <D.19617>;
    <D.19581>:
    iftmp.52 = __builtin_strcmp (element_name, "supportedRuntime");
    <D.19617>:
    D.18115 = iftmp.52;
  }
  if (D.18115 == 0) goto <D.19618>; else goto <D.19619>;
  <D.19618>:
  {
    char * version;

    version = get_attribute_value (attribute_names, attribute_values, "version");
    D.19620 = app_config->supported_runtimes;
    D.19621 = monoeg_g_slist_append (D.19620, version);
    app_config->supported_runtimes = D.19621;
  }
  <D.19619>:
  <D.19578>:
}


get_attribute_value (const gchar * * attribute_names, const gchar * * attribute_values, const char * att_name)
{
  int D.18067;
  unsigned int n.53;
  unsigned int D.19624;
  const gchar * * D.19625;
  const gchar * D.19626;
  char * D.19629;
  const gchar * * D.19630;
  const gchar * D.19631;
  int n;

  n = 0;
  goto <D.18069>;
  <D.18068>:
  {
    size_t __s1_len;
    size_t __s2_len;

    n.53 = (unsigned int) n;
    D.19624 = n.53 * 4;
    D.19625 = attribute_names + D.19624;
    D.19626 = *D.19625;
    D.18067 = __builtin_strcmp (D.19626, att_name);
  }
  if (D.18067 == 0) goto <D.19627>; else goto <D.19628>;
  <D.19627>:
  n.53 = (unsigned int) n;
  D.19624 = n.53 * 4;
  D.19630 = attribute_values + D.19624;
  D.19631 = *D.19630;
  D.19629 = monoeg_strdup (D.19631);
  return D.19629;
  <D.19628>:
  n = n + 1;
  <D.18069>:
  n.53 = (unsigned int) n;
  D.19624 = n.53 * 4;
  D.19625 = attribute_names + D.19624;
  D.19626 = *D.19625;
  if (D.19626 != 0B) goto <D.18068>; else goto <D.18070>;
  <D.18070>:
  D.19629 = 0B;
  return D.19629;
}


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

  if (str != 0B) goto <D.19633>; else goto <D.19634>;
  <D.19633>:
  D.19635 = __strdup (str);
  return D.19635;
  <D.19634>:
  D.19635 = 0B;
  return D.19635;
}


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

  list = app_config->supported_runtimes;
  goto <D.18158>;
  <D.18157>:
  rt = list->data;
  monoeg_g_free (rt);
  if (list != 0B) goto <D.19638>; else goto <D.19639>;
  <D.19638>:
  iftmp.54 = list->next;
  goto <D.19640>;
  <D.19639>:
  iftmp.54 = 0B;
  <D.19640>:
  list = iftmp.54;
  <D.18158>:
  if (list != 0B) goto <D.18157>; else goto <D.18159>;
  <D.18159>:
  D.19641 = app_config->supported_runtimes;
  monoeg_g_slist_free (D.19641);
  D.19642 = app_config->required_runtime;
  monoeg_g_free (D.19642);
  monoeg_g_free (app_config);
}


get_runtime_by_version (const char * version)
{
  const struct MonoRuntimeInfo * D.19645;
  int D.18174;
  const char[12] * D.19646;
  unsigned int D.19649;
  const char * D.19652;
  char D.19653;
  int D.19656;
  int n;
  int max;
  int vlen;

  max = 6;
  if (version == 0B) goto <D.19643>; else goto <D.19644>;
  <D.19643>:
  D.19645 = 0B;
  return D.19645;
  <D.19644>:
  n = 0;
  goto <D.18176>;
  <D.18175>:
  {
    size_t __s1_len;
    size_t __s2_len;

    D.19646 = &supported_runtimes[n].runtime_version;
    D.18174 = __builtin_strcmp (version, D.19646);
  }
  if (D.18174 == 0) goto <D.19647>; else goto <D.19648>;
  <D.19647>:
  D.19645 = &supported_runtimes[n];
  return D.19645;
  <D.19648>:
  n = n + 1;
  <D.18176>:
  if (n < max) goto <D.18175>; else goto <D.18177>;
  <D.18177>:
  D.19649 = strlen (version);
  vlen = (int) D.19649;
  if (vlen > 3) goto <D.19650>; else goto <D.19651>;
  <D.19650>:
  D.19652 = version + 1;
  D.19653 = *D.19652;
  if (D.19653 > 51) goto <D.19654>; else goto <D.19655>;
  <D.19654>:
  n = 0;
  goto <D.18188>;
  <D.18187>:
  D.19646 = &supported_runtimes[n].runtime_version;
  D.19656 = strncmp (version, D.19646, 4);
  if (D.19656 == 0) goto <D.19657>; else goto <D.19658>;
  <D.19657>:
  D.19645 = &supported_runtimes[n];
  return D.19645;
  <D.19658>:
  n = n + 1;
  <D.18188>:
  if (n < max) goto <D.18187>; else goto <D.18189>;
  <D.18189>:
  <D.19655>:
  <D.19651>:
  D.19645 = 0B;
  return D.19645;
}


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

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


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

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


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

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


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.19668>; else goto <D.19669>;
  <D.19668>:
  exe_image.56 = exe_image;
  mono_image_close (exe_image.56);
  <D.19669>:
}


mono_get_root_domain ()
{
  struct MonoDomain * D.19670;

  D.19670 = mono_root_domain;
  return D.19670;
}


mono_domain_get ()
{
  struct MonoDomain * D.19672;

  D.19672 = tls_appdomain;
  return D.19672;
}


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.19675;
  unsigned int appdomain_thread_id.58;
  struct MonoInternalThread * D.19679;
  struct MonoInternalThread * D.19680;
  struct MonoAppContext * * D.19681;
  struct MonoAppContext * D.19682;
  struct MonoException * D.19685;
  struct MonoVTable * D.19688;
  struct MonoDomain * D.19689;
  _Bool D.19690;
  long int D.19691;
  long int D.19692;
  struct MonoException * * D.19695;
  struct MonoException * D.19696;
  _Bool D.19697;
  long int D.19698;
  long int D.19699;
  struct MonoInternalThread * thread;

  D.19675 = mono_domain_get ();
  if (D.19675 == domain) goto <D.19676>; else goto <D.19677>;
  <D.19676>:
  return;
  <D.19677>:
  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.19679 = mono_thread_internal_current ();
  D.19680 = mono_thread_internal_current ();
  D.19681 = &D.19680->current_appcontext;
  D.19682 = domain->default_context;
  mono_gc_wbarrier_set_field (D.19679, D.19681, D.19682);
  if (migrate_exception != 0) goto <D.19683>; else goto <D.19684>;
  <D.19683>:
  thread = mono_thread_internal_current ();
  D.19685 = thread->abort_exc;
  if (D.19685 == 0B) goto <D.19686>; else goto <D.19687>;
  <D.19686>:
  return;
  <D.19687>:
  D.19685 = thread->abort_exc;
  D.19688 = D.19685->object.vtable;
  D.19689 = D.19688->domain;
  D.19690 = D.19689 == domain;
  D.19691 = (long int) D.19690;
  D.19692 = __builtin_expect (D.19691, 0);
  if (D.19692 != 0) goto <D.19693>; else goto <D.19694>;
  <D.19693>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "domain.c", 1830, "thread->abort_exc->object.vtable->domain != domain");
  <D.19694>:
  D.19695 = &thread->abort_exc;
  D.19696 = mono_get_exception_thread_abort ();
  mono_gc_wbarrier_set_field (thread, D.19695, D.19696);
  D.19685 = thread->abort_exc;
  D.19688 = D.19685->object.vtable;
  D.19689 = D.19688->domain;
  D.19697 = D.19689 != domain;
  D.19698 = (long int) D.19697;
  D.19699 = __builtin_expect (D.19698, 0);
  if (D.19699 != 0) goto <D.19700>; else goto <D.19701>;
  <D.19700>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "domain.c", 1832, "thread->abort_exc->object.vtable->domain == domain");
  <D.19701>:
  <D.19684>:
}


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.19705;
  long int D.19706;
  long int D.19707;
  short unsigned int appdomain_list_size.59;
  unsigned int D.19711;
  unsigned int D.19712;
  struct MonoDomain * * appdomains_list.60;
  _Bool D.19716;
  long int D.19717;
  long int D.19718;
  unsigned int i.61;
  unsigned int D.19722;
  struct MonoDomain * * D.19723;
  struct MonoDomain * D.19724;
  int i;
  int size;
  struct MonoDomain * * copy;

  {
    int ret;

    ret = pthread_mutex_lock (&appdomains_mutex.mutex);
    if (ret != 0) goto <D.19703>; else goto <D.19704>;
    <D.19703>:
    monoeg_g_log (0B, 16, "Bad call to mono_mutex_lock result %d", ret);
    <D.19704>:
    D.19705 = ret != 0;
    D.19706 = (long int) D.19705;
    D.19707 = __builtin_expect (D.19706, 0);
    if (D.19707 != 0) goto <D.19708>; else goto <D.19709>;
    <D.19708>:
    monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "domain.c", 1859, "ret == 0");
    <D.19709>:
  }
  appdomain_list_size.59 = appdomain_list_size;
  size = (int) appdomain_list_size.59;
  appdomain_list_size.59 = appdomain_list_size;
  D.19711 = (unsigned int) appdomain_list_size.59;
  D.19712 = D.19711 * 4;
  copy = mono_gc_alloc_fixed (D.19712, 0B);
  appdomains_list.60 = appdomains_list;
  appdomain_list_size.59 = appdomain_list_size;
  D.19711 = (unsigned int) appdomain_list_size.59;
  D.19712 = D.19711 * 4;
  memcpy (copy, appdomains_list.60, D.19712);
  {
    int ret;

    ret = pthread_mutex_unlock (&appdomains_mutex.mutex);
    if (ret != 0) goto <D.19714>; else goto <D.19715>;
    <D.19714>:
    monoeg_g_log (0B, 16, "Bad call to mono_mutex_unlock result %d", ret);
    <D.19715>:
    D.19716 = ret != 0;
    D.19717 = (long int) D.19716;
    D.19718 = __builtin_expect (D.19717, 0);
    if (D.19718 != 0) goto <D.19719>; else goto <D.19720>;
    <D.19719>:
    monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "domain.c", 1863, "ret == 0");
    <D.19720>:
  }
  i = 0;
  goto <D.17840>;
  <D.17839>:
  i.61 = (unsigned int) i;
  D.19722 = i.61 * 4;
  D.19723 = copy + D.19722;
  D.19724 = *D.19723;
  if (D.19724 != 0B) goto <D.19725>; else goto <D.19726>;
  <D.19725>:
  i.61 = (unsigned int) i;
  D.19722 = i.61 * 4;
  D.19723 = copy + D.19722;
  D.19724 = *D.19723;
  func (D.19724, user_data);
  <D.19726>:
  i = i + 1;
  <D.17840>:
  if (i < size) goto <D.17839>; else goto <D.17841>;
  <D.17841>:
  mono_gc_free_fixed (copy);
}


mono_domain_assembly_open (struct MonoDomain * domain, const char * name)
{
  union mono_mutex_t * D.19727;
  _Bool D.19730;
  long int D.19731;
  long int D.19732;
  int D.17858;
  const char * D.19735;
  _Bool D.19740;
  long int D.19741;
  long int D.19742;
  struct MonoAssembly * D.19745;
  _Bool D.19748;
  long int D.19749;
  long int D.19750;
  struct MonoDomain * D.19753;
  struct MonoDomain * current;
  struct MonoAssembly * ass;
  struct GSList * tmp;

  {
    int ret;

    D.19727 = &domain->assemblies_lock.mutex;
    ret = pthread_mutex_lock (D.19727);
    if (ret != 0) goto <D.19728>; else goto <D.19729>;
    <D.19728>:
    monoeg_g_log (0B, 16, "Bad call to mono_mutex_lock result %d", ret);
    <D.19729>:
    D.19730 = ret != 0;
    D.19731 = (long int) D.19730;
    D.19732 = __builtin_expect (D.19731, 0);
    if (D.19732 != 0) goto <D.19733>; else goto <D.19734>;
    <D.19733>:
    monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "domain.c", 1887, "ret == 0");
    <D.19734>:
  }
  tmp = domain->domain_assemblies;
  goto <D.17861>;
  <D.17860>:
  ass = tmp->data;
  {
    size_t __s1_len;
    size_t __s2_len;

    D.19735 = ass->aname.name;
    D.17858 = __builtin_strcmp (name, D.19735);
  }
  if (D.17858 == 0) goto <D.19736>; else goto <D.19737>;
  <D.19736>:
  {
    int ret;

    D.19727 = &domain->assemblies_lock.mutex;
    ret = pthread_mutex_unlock (D.19727);
    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", 1891, "ret == 0");
    <D.19744>:
  }
  D.19745 = ass;
  return D.19745;
  <D.19737>:
  tmp = tmp->next;
  <D.17861>:
  if (tmp != 0B) goto <D.17860>; else goto <D.17862>;
  <D.17862>:
  {
    int ret;

    D.19727 = &domain->assemblies_lock.mutex;
    ret = pthread_mutex_unlock (D.19727);
    if (ret != 0) goto <D.19746>; else goto <D.19747>;
    <D.19746>:
    monoeg_g_log (0B, 16, "Bad call to mono_mutex_unlock result %d", ret);
    <D.19747>:
    D.19748 = ret != 0;
    D.19749 = (long int) D.19748;
    D.19750 = __builtin_expect (D.19749, 0);
    if (D.19750 != 0) goto <D.19751>; else goto <D.19752>;
    <D.19751>:
    monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "domain.c", 1895, "ret == 0");
    <D.19752>:
  }
  D.19753 = mono_domain_get ();
  if (D.19753 != domain) goto <D.19754>; else goto <D.19755>;
  <D.19754>:
  current = mono_domain_get ();
  mono_domain_set (domain, 0);
  ass = mono_assembly_open (name, 0B);
  mono_domain_set (current, 0);
  goto <D.19756>;
  <D.19755>:
  ass = mono_assembly_open (name, 0B);
  <D.19756>:
  D.19745 = ass;
  return D.19745;
}


mono_domain_free (struct MonoDomain * domain, gboolean force)
{
  struct MonoDomain * mono_root_domain.62;
  int mono_dont_free_domains.63;
  _Bool D.19768;
  long int D.19769;
  long int D.19770;
  struct MonoDomain * * appdomains_list.64;
  int D.19774;
  unsigned int D.19775;
  unsigned int D.19776;
  struct MonoDomain * * D.19777;
  _Bool D.19780;
  long int D.19781;
  long int D.19782;
  struct GHashTable * D.19785;
  struct MonoGHashTable * D.19788;
  struct MonoGHashTable * D.19789;
  struct MonoTlsDataRecord * D.19790;
  struct MonoGHashTable * D.19793;
  struct MonoGHashTable * D.19796;
  struct GPtrArray * D.19799;
  void * * D.19802;
  unsigned int i.65;
  unsigned int D.19804;
  void * * D.19805;
  void * D.19806;
  unsigned int i.66;
  unsigned int D.19808;
  struct MonoGHashTable * * D.19809;
  struct MonoImage * D.19812;
  unsigned int D.19814;
  unsigned int D.19815;
  char * D.19816;
  const char * D.19817;
  int D.19818;
  int D.19819;
  struct MonoImage * D.19826;
  unsigned int D.19828;
  unsigned int D.19829;
  const char * D.19830;
  int D.19831;
  int D.19832;
  struct GSList * D.19837;
  void (*<T193c>) (struct MonoDomain *) free_domain_hook.67;
  gchar * * D.19841;
  struct GHashTable * D.19844;
  void * * D.19845;
  struct MonoInternalHashTable * D.19848;
  struct MonoJitInfoTable * D.19849;
  struct MonoJitInfoTable * D.19852;
  int D.19853;
  _Bool D.19854;
  long int D.19855;
  long int D.19856;
  struct MonoJitInfoTable * D.19859;
  struct GSList * D.19860;
  _Bool D.19861;
  long int D.19862;
  long int D.19863;
  struct MonoCodeManager * D.19866;
  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.19874;
  struct LockFreeMempool * D.19875;
  struct GHashTable * D.19876;
  struct GHashTable * D.19877;
  struct GHashTable * D.19880;
  struct GHashTable * D.19883;
  struct GHashTable * D.19886;
  struct CRITICAL_SECTION * D.19889;
  struct CRITICAL_SECTION * D.19890;
  struct CRITICAL_SECTION * D.19891;
  struct CRITICAL_SECTION * D.19892;
  struct MonoPerfCounters * mono_perfcounters.75;
  unsigned int D.19894;
  unsigned int D.19895;
  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.19759>; else goto <D.19760>;
      <D.19759>:
      if (force == 0) goto <D.19761>; else goto <D.19762>;
      <D.19761>:
      monoeg_g_log (0B, 16, "cant unload root domain");
      return;
      <D.19762>:
      <D.19760>:
      mono_dont_free_domains.63 = mono_dont_free_domains;
      if (mono_dont_free_domains.63 != 0) goto <D.19764>; else goto <D.19765>;
      <D.19764>:
      return;
      <D.19765>:
      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.19766>; else goto <D.19767>;
        <D.19766>:
        monoeg_g_log (0B, 16, "Bad call to mono_mutex_lock result %d", ret);
        <D.19767>:
        D.19768 = ret != 0;
        D.19769 = (long int) D.19768;
        D.19770 = __builtin_expect (D.19769, 0);
        if (D.19770 != 0) goto <D.19771>; else goto <D.19772>;
        <D.19771>:
        monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "domain.c", 1938, "ret == 0");
        <D.19772>:
      }
      appdomains_list.64 = appdomains_list;
      D.19774 = domain->domain_id;
      D.19775 = (unsigned int) D.19774;
      D.19776 = D.19775 * 4;
      D.19777 = appdomains_list.64 + D.19776;
      *D.19777 = 0B;
      {
        int ret;

        ret = pthread_mutex_unlock (&appdomains_mutex.mutex);
        if (ret != 0) goto <D.19778>; else goto <D.19779>;
        <D.19778>:
        monoeg_g_log (0B, 16, "Bad call to mono_mutex_unlock result %d", ret);
        <D.19779>:
        D.19780 = ret != 0;
        D.19781 = (long int) D.19780;
        D.19782 = __builtin_expect (D.19781, 0);
        if (D.19782 != 0) goto <D.19783>; else goto <D.19784>;
        <D.19783>:
        monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "domain.c", 1940, "ret == 0");
        <D.19784>:
      }
      D.19785 = domain->special_static_fields;
      if (D.19785 != 0B) goto <D.19786>; else goto <D.19787>;
      <D.19786>:
      D.19785 = domain->special_static_fields;
      mono_alloc_special_static_data_free (D.19785);
      D.19785 = domain->special_static_fields;
      monoeg_g_hash_table_destroy (D.19785);
      domain->special_static_fields = 0B;
      <D.19787>:
      D.19788 = domain->ldstr_table;
      mono_g_hash_table_destroy (D.19788);
      domain->ldstr_table = 0B;
      D.19789 = domain->env;
      mono_g_hash_table_destroy (D.19789);
      domain->env = 0B;
      D.19790 = domain->tlsrec_list;
      if (D.19790 != 0B) goto <D.19791>; else goto <D.19792>;
      <D.19791>:
      mono_thread_destroy_domain_tls (domain);
      domain->tlsrec_list = 0B;
      <D.19792>:
      mono_reflection_cleanup_domain (domain);
      D.19793 = domain->type_hash;
      if (D.19793 != 0B) goto <D.19794>; else goto <D.19795>;
      <D.19794>:
      D.19793 = domain->type_hash;
      mono_g_hash_table_destroy (D.19793);
      domain->type_hash = 0B;
      <D.19795>:
      D.19796 = domain->type_init_exception_hash;
      if (D.19796 != 0B) goto <D.19797>; else goto <D.19798>;
      <D.19797>:
      D.19796 = domain->type_init_exception_hash;
      mono_g_hash_table_destroy (D.19796);
      domain->type_init_exception_hash = 0B;
      <D.19798>:
      D.19799 = domain->class_vtable_array;
      if (D.19799 != 0B) goto <D.19800>; else goto <D.19801>;
      <D.19800>:
      {
        int i;

        i = 0;
        goto <D.17880>;
        <D.17879>:
        D.19799 = domain->class_vtable_array;
        D.19802 = D.19799->pdata;
        i.65 = (unsigned int) i;
        D.19804 = i.65 * 4;
        D.19805 = D.19802 + D.19804;
        D.19806 = *D.19805;
        unregister_vtable_reflection_type (D.19806);
        i = i + 1;
        <D.17880>:
        i.66 = (unsigned int) i;
        D.19799 = domain->class_vtable_array;
        D.19808 = D.19799->len;
        if (i.66 < D.19808) goto <D.17879>; else goto <D.17881>;
        <D.17881>:
      }
      <D.19801>:
      tmp = domain->domain_assemblies;
      goto <D.17884>;
      <D.17883>:
      {
        struct MonoAssembly * ass;

        ass = tmp->data;
        mono_assembly_release_gc_roots (ass);
      }
      tmp = tmp->next;
      <D.17884>:
      if (tmp != 0B) goto <D.17883>; else goto <D.17885>;
      <D.17885>:
      p = &domain->setup;
      goto <D.17887>;
      <D.17886>:
      *p = 0B;
      p = p + 4;
      <D.17887>:
      D.19809 = &domain->env;
      if (D.19809 > p) goto <D.17886>; else goto <D.17888>;
      <D.17888>:
      mono_gc_clear_domain (domain);
      tmp = domain->domain_assemblies;
      goto <D.17892>;
      <D.17891>:
      {
        struct MonoAssembly * ass;

        ass = tmp->data;
        D.19812 = ass->image;
        if (D.19812 == 0B) goto <D.19810>; else goto <D.19813>;
        <D.19813>:
        D.19812 = ass->image;
        D.19814 = BIT_FIELD_REF <*D.19812, 32, 128>;
        D.19815 = D.19814 & 8;
        if (D.19815 == 0) goto <D.19810>; else goto <D.19811>;
        <D.19810>:
        // predicted unlikely by continue predictor.
        goto <D.17890>;
        <D.19811>:
        D.19816 = domain->friendly_name;
        D.19817 = ass->aname.name;
        D.19818 = ass->ref_count;
        mono_trace (64, 1, "Unloading domain %s[%p], assembly %s[%p], ref_count=%d", D.19816, domain, D.19817, ass, D.19818);
        D.19819 = mono_assembly_close_except_image_pools (ass);
        if (D.19819 == 0) goto <D.19820>; else goto <D.19821>;
        <D.19820>:
        tmp->data = 0B;
        <D.19821>:
      }
      <D.17890>:
      tmp = tmp->next;
      <D.17892>:
      if (tmp != 0B) goto <D.17891>; else goto <D.17893>;
      <D.17893>:
      tmp = domain->domain_assemblies;
      goto <D.17897>;
      <D.17896>:
      {
        struct MonoAssembly * ass;

        ass = tmp->data;
        if (ass == 0B) goto <D.19822>; else goto <D.19823>;
        <D.19822>:
        // predicted unlikely by continue predictor.
        goto <D.17895>;
        <D.19823>:
        D.19826 = ass->image;
        if (D.19826 == 0B) goto <D.19824>; else goto <D.19827>;
        <D.19827>:
        D.19826 = ass->image;
        D.19828 = BIT_FIELD_REF <*D.19826, 32, 128>;
        D.19829 = D.19828 & 8;
        if (D.19829 != 0) goto <D.19824>; else goto <D.19825>;
        <D.19824>:
        // predicted unlikely by continue predictor.
        goto <D.17895>;
        <D.19825>:
        D.19816 = domain->friendly_name;
        D.19830 = ass->aname.name;
        D.19831 = ass->ref_count;
        mono_trace (64, 1, "Unloading domain %s[%p], assembly %s[%p], ref_count=%d", D.19816, domain, D.19830, ass, D.19831);
        D.19832 = mono_assembly_close_except_image_pools (ass);
        if (D.19832 == 0) goto <D.19833>; else goto <D.19834>;
        <D.19833>:
        tmp->data = 0B;
        <D.19834>:
      }
      <D.17895>:
      tmp = tmp->next;
      <D.17897>:
      if (tmp != 0B) goto <D.17896>; else goto <D.17898>;
      <D.17898>:
      tmp = domain->domain_assemblies;
      goto <D.17901>;
      <D.17900>:
      {
        struct MonoAssembly * ass;

        ass = tmp->data;
        if (ass != 0B) goto <D.19835>; else goto <D.19836>;
        <D.19835>:
        mono_assembly_close_finish (ass);
        <D.19836>:
      }
      tmp = tmp->next;
      <D.17901>:
      if (tmp != 0B) goto <D.17900>; else goto <D.17902>;
      <D.17902>:
      D.19837 = domain->domain_assemblies;
      monoeg_g_slist_free (D.19837);
      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.19839>; else goto <D.19840>;
      <D.19839>:
      free_domain_hook.67 = free_domain_hook;
      free_domain_hook.67 (domain);
      <D.19840>:
      D.19841 = domain->search_path;
      if (D.19841 != 0B) goto <D.19842>; else goto <D.19843>;
      <D.19842>:
      D.19841 = domain->search_path;
      monoeg_g_strfreev (D.19841);
      domain->search_path = 0B;
      <D.19843>:
      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.19816 = domain->friendly_name;
      monoeg_g_free (D.19816);
      domain->friendly_name = 0B;
      D.19799 = domain->class_vtable_array;
      monoeg_g_ptr_array_free (D.19799, 1);
      domain->class_vtable_array = 0B;
      D.19844 = domain->proxy_vtable_hash;
      monoeg_g_hash_table_destroy (D.19844);
      domain->proxy_vtable_hash = 0B;
      D.19845 = domain->static_data_array;
      if (D.19845 != 0B) goto <D.19846>; else goto <D.19847>;
      <D.19846>:
      D.19845 = domain->static_data_array;
      mono_gc_free_fixed (D.19845);
      domain->static_data_array = 0B;
      <D.19847>:
      D.19848 = &domain->jit_code_hash;
      mono_internal_hash_table_destroy (D.19848);
      mono_thread_hazardous_try_free_all ();
      D.19849 = domain->aot_modules;
      if (D.19849 != 0B) goto <D.19850>; else goto <D.19851>;
      <D.19850>:
      D.19852 = domain->aot_modules;
      jit_info_table_free (D.19852);
      <D.19851>:
      D.19853 = domain->num_jit_info_tables;
      D.19854 = D.19853 != 1;
      D.19855 = (long int) D.19854;
      D.19856 = __builtin_expect (D.19855, 0);
      if (D.19856 != 0) goto <D.19857>; else goto <D.19858>;
      <D.19857>:
      monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "domain.c", 2068, "domain->num_jit_info_tables == 1");
      <D.19858>:
      D.19859 = domain->jit_info_table;
      jit_info_table_free (D.19859);
      domain->jit_info_table = 0B;
      D.19860 = domain->jit_info_free_queue;
      D.19861 = D.19860 != 0B;
      D.19862 = (long int) D.19861;
      D.19863 = __builtin_expect (D.19862, 0);
      if (D.19863 != 0) goto <D.19864>; else goto <D.19865>;
      <D.19864>:
      monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "domain.c", 2071, "!domain->jit_info_free_queue");
      <D.19865>:
      D.19866 = domain->code_mp;
      code_alloc = mono_code_manager_size (D.19866, &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.19874 = domain->mp;
      mono_mempool_invalidate (D.19874);
      D.19866 = domain->code_mp;
      mono_code_manager_invalidate (D.19866);
      D.19875 = domain->lock_free_mp;
      lock_free_mempool_free (D.19875);
      domain->lock_free_mp = 0B;
      D.19876 = domain->finalizable_objects_hash;
      monoeg_g_hash_table_destroy (D.19876);
      domain->finalizable_objects_hash = 0B;
      D.19877 = domain->method_rgctx_hash;
      if (D.19877 != 0B) goto <D.19878>; else goto <D.19879>;
      <D.19878>:
      D.19877 = domain->method_rgctx_hash;
      monoeg_g_hash_table_destroy (D.19877);
      domain->method_rgctx_hash = 0B;
      <D.19879>:
      D.19880 = domain->generic_virtual_cases;
      if (D.19880 != 0B) goto <D.19881>; else goto <D.19882>;
      <D.19881>:
      D.19880 = domain->generic_virtual_cases;
      monoeg_g_hash_table_destroy (D.19880);
      domain->generic_virtual_cases = 0B;
      <D.19882>:
      D.19883 = domain->generic_virtual_thunks;
      if (D.19883 != 0B) goto <D.19884>; else goto <D.19885>;
      <D.19884>:
      D.19883 = domain->generic_virtual_thunks;
      monoeg_g_hash_table_destroy (D.19883);
      domain->generic_virtual_thunks = 0B;
      <D.19885>:
      D.19886 = domain->ftnptrs_hash;
      if (D.19886 != 0B) goto <D.19887>; else goto <D.19888>;
      <D.19887>:
      D.19886 = domain->ftnptrs_hash;
      monoeg_g_hash_table_destroy (D.19886);
      domain->ftnptrs_hash = 0B;
      <D.19888>:
      D.19889 = &domain->finalizable_objects_hash_lock;
      DeleteCriticalSection (D.19889);
      D.19890 = &domain->assemblies_lock;
      DeleteCriticalSection (D.19890);
      D.19891 = &domain->jit_code_hash_lock;
      DeleteCriticalSection (D.19891);
      D.19892 = &domain->lock;
      DeleteCriticalSection (D.19892);
      domain->setup = 0B;
      D.19809 = &domain->env;
      mono_gc_deregister_root (D.19809);
      mono_gc_free_fixed (domain);
      mono_perfcounters.75 = mono_perfcounters;
      D.19894 = mono_perfcounters.75->loader_appdomains;
      D.19895 = D.19894 + 4294967295;
      mono_perfcounters.75->loader_appdomains = D.19895;
      mono_root_domain.62 = mono_root_domain;
      if (domain == mono_root_domain.62) goto <D.19896>; else goto <D.19897>;
      <D.19896>:
      mono_root_domain = 0B;
      <D.19897>:
    }
  finally
    {
      code_size = {CLOBBER};
    }
}


unregister_vtable_reflection_type (struct MonoVTable * vtable)
{
  struct MonoVTable * D.19901;
  struct MonoClass * D.19902;
  struct MonoClass * D.19903;
  int D.19906;
  void * * D.19909;
  struct MonoObject * type;

  type = vtable->type;
  D.19901 = type->vtable;
  D.19902 = D.19901->klass;
  D.19903 = mono_defaults.monotype_class;
  if (D.19902 != D.19903) goto <D.19904>; else goto <D.19905>;
  <D.19904>:
  D.19906 = mono_gc_is_moving ();
  if (D.19906 != 0) goto <D.19907>; else goto <D.19908>;
  <D.19907>:
  D.19909 = &vtable->type;
  mono_gc_deregister_root (D.19909);
  <D.19908>:
  <D.19905>:
}


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

  chunk = mp->chunks;
  goto <D.17690>;
  <D.17689>:
  next = chunk->prev;
  D.19910 = mono_pagesize ();
  D.19911 = (unsigned int) D.19910;
  mono_vfree (chunk, D.19911);
  chunk = next;
  <D.17690>:
  if (chunk != 0B) goto <D.17689>; else goto <D.17691>;
  <D.17691>:
}


mono_domain_get_by_id (gint32 domainid)
{
  _Bool D.19914;
  long int D.19915;
  long int D.19916;
  short unsigned int appdomain_list_size.76;
  int D.19920;
  struct MonoDomain * * appdomains_list.77;
  unsigned int domainid.78;
  unsigned int D.19925;
  struct MonoDomain * * D.19926;
  _Bool D.19930;
  long int D.19931;
  long int D.19932;
  struct MonoDomain * D.19935;
  struct MonoDomain * domain;

  {
    int ret;

    ret = pthread_mutex_lock (&appdomains_mutex.mutex);
    if (ret != 0) goto <D.19912>; else goto <D.19913>;
    <D.19912>:
    monoeg_g_log (0B, 16, "Bad call to mono_mutex_lock result %d", ret);
    <D.19913>:
    D.19914 = ret != 0;
    D.19915 = (long int) D.19914;
    D.19916 = __builtin_expect (D.19915, 0);
    if (D.19916 != 0) goto <D.19917>; else goto <D.19918>;
    <D.19917>:
    monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "domain.c", 2144, "ret == 0");
    <D.19918>:
  }
  appdomain_list_size.76 = appdomain_list_size;
  D.19920 = (int) appdomain_list_size.76;
  if (D.19920 > domainid) goto <D.19921>; else goto <D.19922>;
  <D.19921>:
  appdomains_list.77 = appdomains_list;
  domainid.78 = (unsigned int) domainid;
  D.19925 = domainid.78 * 4;
  D.19926 = appdomains_list.77 + D.19925;
  domain = *D.19926;
  goto <D.19927>;
  <D.19922>:
  domain = 0B;
  <D.19927>:
  {
    int ret;

    ret = pthread_mutex_unlock (&appdomains_mutex.mutex);
    if (ret != 0) goto <D.19928>; else goto <D.19929>;
    <D.19928>:
    monoeg_g_log (0B, 16, "Bad call to mono_mutex_unlock result %d", ret);
    <D.19929>:
    D.19930 = ret != 0;
    D.19931 = (long int) D.19930;
    D.19932 = __builtin_expect (D.19931, 0);
    if (D.19932 != 0) goto <D.19933>; else goto <D.19934>;
    <D.19933>:
    monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "domain.c", 2149, "ret == 0");
    <D.19934>:
  }
  D.19935 = domain;
  return D.19935;
}


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

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


mono_domain_alloc (struct MonoDomain * domain, guint size)
{
  union mono_mutex_t * D.19939;
  _Bool D.19942;
  long int D.19943;
  long int D.19944;
  struct MonoPerfCounters * mono_perfcounters.79;
  unsigned int D.19948;
  unsigned int D.19949;
  struct MonoMemPool * D.19950;
  _Bool D.19953;
  long int D.19954;
  long int D.19955;
  void * D.19958;
  void * res;

  {
    int ret;

    D.19939 = &domain->lock.mutex;
    ret = pthread_mutex_lock (D.19939);
    if (ret != 0) goto <D.19940>; else goto <D.19941>;
    <D.19940>:
    monoeg_g_log (0B, 16, "Bad call to mono_mutex_lock result %d", ret);
    <D.19941>:
    D.19942 = ret != 0;
    D.19943 = (long int) D.19942;
    D.19944 = __builtin_expect (D.19943, 0);
    if (D.19944 != 0) goto <D.19945>; else goto <D.19946>;
    <D.19945>:
    monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "domain.c", 2170, "ret == 0");
    <D.19946>:
  }
  mono_perfcounters.79 = mono_perfcounters;
  mono_perfcounters.79 = mono_perfcounters;
  D.19948 = mono_perfcounters.79->loader_bytes;
  D.19949 = D.19948 + size;
  mono_perfcounters.79->loader_bytes = D.19949;
  D.19950 = domain->mp;
  res = mono_mempool_alloc (D.19950, size);
  {
    int ret;

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


mono_domain_alloc0 (struct MonoDomain * domain, guint size)
{
  union mono_mutex_t * D.19960;
  _Bool D.19963;
  long int D.19964;
  long int D.19965;
  struct MonoPerfCounters * mono_perfcounters.80;
  unsigned int D.19969;
  unsigned int D.19970;
  struct MonoMemPool * D.19971;
  _Bool D.19974;
  long int D.19975;
  long int D.19976;
  void * D.19979;
  void * res;

  {
    int ret;

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

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


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

  D.19982 = domain->lock_free_mp;
  D.19981 = lock_free_mempool_alloc0 (D.19982, size);
  return D.19981;
}


lock_free_mempool_alloc0 (struct LockFreeMempool * mp, guint size)
{
  unsigned int D.19984;
  int size.81;
  int * D.19988;
  int size.82;
  unsigned int oldpos.83;
  unsigned int D.19991;
  int D.19992;
  unsigned int D.19993;
  int D.19996;
  unsigned int D.19997;
  unsigned int D.19998;
  _Bool D.19999;
  long int D.20000;
  long int D.20001;
  int D.20004;
  guint8 * D.20006;
  sizetype oldpos.84;
  void * D.20008;
  struct LockFreeMempoolChunk * chunk;
  void * res;
  int oldpos;

  D.19984 = size + 7;
  size = D.19984 & 4294967288;
  chunk = mp->current;
  if (chunk == 0B) goto <D.19985>; else goto <D.19986>;
  <D.19985>:
  size.81 = (int) size;
  chunk = lock_free_mempool_chunk_new (mp, size.81);
  mono_memory_barrier ();
  mp->current = chunk;
  <D.19986>:
  D.19988 = &chunk->pos;
  size.82 = (int) size;
  oldpos = InterlockedExchangeAdd (D.19988, size.82);
  oldpos.83 = (unsigned int) oldpos;
  D.19991 = oldpos.83 + size;
  D.19992 = chunk->size;
  D.19993 = (unsigned int) D.19992;
  if (D.19991 > D.19993) goto <D.19994>; else goto <D.19995>;
  <D.19994>:
  size.81 = (int) size;
  chunk = lock_free_mempool_chunk_new (mp, size.81);
  D.19996 = chunk->pos;
  D.19997 = (unsigned int) D.19996;
  D.19998 = D.19997 + size;
  D.19992 = chunk->size;
  D.19993 = (unsigned int) D.19992;
  D.19999 = D.19998 > D.19993;
  D.20000 = (long int) D.19999;
  D.20001 = __builtin_expect (D.20000, 0);
  if (D.20001 != 0) goto <D.20002>; else goto <D.20003>;
  <D.20002>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "domain.c", 1085, "chunk->pos + size <= chunk->size");
  <D.20003>:
  res = chunk->mem;
  D.19996 = chunk->pos;
  D.19997 = (unsigned int) D.19996;
  D.19998 = D.19997 + size;
  D.20004 = (int) D.19998;
  chunk->pos = D.20004;
  mono_memory_barrier ();
  mp->current = chunk;
  goto <D.20005>;
  <D.19995>:
  D.20006 = chunk->mem;
  oldpos.84 = (sizetype) oldpos;
  res = D.20006 + oldpos.84;
  <D.20005>:
  D.20008 = res;
  return D.20008;
}


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

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


lock_free_mempool_chunk_new (struct LockFreeMempool * mp, int len)
{
  int D.20014;
  unsigned int size.86;
  unsigned int D.20016;
  unsigned int len.87;
  unsigned int size.88;
  _Bool D.20019;
  long int D.20020;
  long int D.20021;
  char * D.20024;
  int D.20025;
  int D.20026;
  int D.20027;
  guint8 * D.20028;
  sizetype size.89;
  char * D.20030;
  int D.20031;
  guint8 * D.20032;
  int D.20033;
  int D.20034;
  struct LockFreeMempoolChunk * * D.20035;
  void * D.20036;
  struct LockFreeMempoolChunk * D.20038;
  struct LockFreeMempoolChunk * chunk;
  struct LockFreeMempoolChunk * prev;
  int size;

  size = mono_pagesize ();
  goto <D.17700>;
  <D.17699>:
  D.20014 = mono_pagesize ();
  size = D.20014 + size;
  <D.17700>:
  size.86 = (unsigned int) size;
  D.20016 = size.86 + 4294967280;
  len.87 = (unsigned int) len;
  if (D.20016 < len.87) goto <D.17699>; else goto <D.17701>;
  <D.17701>:
  size.88 = (unsigned int) size;
  chunk = mono_valloc (0B, size.88, 3);
  D.20019 = chunk == 0B;
  D.20020 = (long int) D.20019;
  D.20021 = __builtin_expect (D.20020, 0);
  if (D.20021 != 0) goto <D.20022>; else goto <D.20023>;
  <D.20022>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "domain.c", 1044, "chunk");
  <D.20023>:
  D.20024 = chunk + 16;
  D.20025 = (int) D.20024;
  D.20026 = D.20025 + 15;
  D.20027 = D.20026 & -16;
  D.20028 = (guint8 *) D.20027;
  chunk->mem = D.20028;
  size.89 = (sizetype) size;
  D.20030 = chunk + size.89;
  D.20031 = (int) D.20030;
  D.20032 = chunk->mem;
  D.20033 = (int) D.20032;
  D.20034 = D.20031 - D.20033;
  chunk->size = D.20034;
  chunk->pos = 0;
  <D.17703>:
  prev = mp->chunks;
  D.20035 = &mp->chunks;
  D.20036 = InterlockedCompareExchangePointer (D.20035, chunk, prev);
  if (D.20036 == prev) goto <D.17702>; else goto <D.20037>;
  <D.20037>:
  goto <D.17703>;
  <D.17702>:
  chunk->prev = prev;
  D.20038 = chunk;
  return D.20038;
}


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

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


mono_domain_code_reserve (struct MonoDomain * domain, int size)
{
  union mono_mutex_t * D.20045;
  _Bool D.20048;
  long int D.20049;
  long int D.20050;
  struct MonoCodeManager * D.20053;
  _Bool D.20056;
  long int D.20057;
  long int D.20058;
  void * D.20061;
  void * res;

  {
    int ret;

    D.20045 = &domain->lock.mutex;
    ret = pthread_mutex_lock (D.20045);
    if (ret != 0) goto <D.20046>; else goto <D.20047>;
    <D.20046>:
    monoeg_g_log (0B, 16, "Bad call to mono_mutex_lock result %d", ret);
    <D.20047>:
    D.20048 = ret != 0;
    D.20049 = (long int) D.20048;
    D.20050 = __builtin_expect (D.20049, 0);
    if (D.20050 != 0) goto <D.20051>; else goto <D.20052>;
    <D.20051>:
    monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "domain.c", 2216, "ret == 0");
    <D.20052>:
  }
  D.20053 = domain->code_mp;
  res = mono_code_manager_reserve (D.20053, size);
  {
    int ret;

    D.20045 = &domain->lock.mutex;
    ret = pthread_mutex_unlock (D.20045);
    if (ret != 0) goto <D.20054>; else goto <D.20055>;
    <D.20054>:
    monoeg_g_log (0B, 16, "Bad call to mono_mutex_unlock result %d", ret);
    <D.20055>:
    D.20056 = ret != 0;
    D.20057 = (long int) D.20056;
    D.20058 = __builtin_expect (D.20057, 0);
    if (D.20058 != 0) goto <D.20059>; else goto <D.20060>;
    <D.20059>:
    monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "domain.c", 2218, "ret == 0");
    <D.20060>:
  }
  D.20061 = res;
  return D.20061;
}


mono_domain_code_reserve_align (struct MonoDomain * domain, int size, int alignment)
{
  union mono_mutex_t * D.20063;
  _Bool D.20066;
  long int D.20067;
  long int D.20068;
  struct MonoCodeManager * D.20071;
  _Bool D.20074;
  long int D.20075;
  long int D.20076;
  void * D.20079;
  void * res;

  {
    int ret;

    D.20063 = &domain->lock.mutex;
    ret = pthread_mutex_lock (D.20063);
    if (ret != 0) goto <D.20064>; else goto <D.20065>;
    <D.20064>:
    monoeg_g_log (0B, 16, "Bad call to mono_mutex_lock result %d", ret);
    <D.20065>:
    D.20066 = ret != 0;
    D.20067 = (long int) D.20066;
    D.20068 = __builtin_expect (D.20067, 0);
    if (D.20068 != 0) goto <D.20069>; else goto <D.20070>;
    <D.20069>:
    monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "domain.c", 2233, "ret == 0");
    <D.20070>:
  }
  D.20071 = domain->code_mp;
  res = mono_code_manager_reserve_align (D.20071, size, alignment);
  {
    int ret;

    D.20063 = &domain->lock.mutex;
    ret = pthread_mutex_unlock (D.20063);
    if (ret != 0) goto <D.20072>; else goto <D.20073>;
    <D.20072>:
    monoeg_g_log (0B, 16, "Bad call to mono_mutex_unlock result %d", ret);
    <D.20073>:
    D.20074 = ret != 0;
    D.20075 = (long int) D.20074;
    D.20076 = __builtin_expect (D.20075, 0);
    if (D.20076 != 0) goto <D.20077>; else goto <D.20078>;
    <D.20077>:
    monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "domain.c", 2235, "ret == 0");
    <D.20078>:
  }
  D.20079 = res;
  return D.20079;
}


mono_domain_code_commit (struct MonoDomain * domain, void * data, int size, int newsize)
{
  union mono_mutex_t * D.20081;
  _Bool D.20084;
  long int D.20085;
  long int D.20086;
  struct MonoCodeManager * D.20089;
  _Bool D.20092;
  long int D.20093;
  long int D.20094;

  {
    int ret;

    D.20081 = &domain->lock.mutex;
    ret = pthread_mutex_lock (D.20081);
    if (ret != 0) goto <D.20082>; else goto <D.20083>;
    <D.20082>:
    monoeg_g_log (0B, 16, "Bad call to mono_mutex_lock result %d", ret);
    <D.20083>:
    D.20084 = ret != 0;
    D.20085 = (long int) D.20084;
    D.20086 = __builtin_expect (D.20085, 0);
    if (D.20086 != 0) goto <D.20087>; else goto <D.20088>;
    <D.20087>:
    monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "domain.c", 2248, "ret == 0");
    <D.20088>:
  }
  D.20089 = domain->code_mp;
  mono_code_manager_commit (D.20089, data, size, newsize);
  {
    int ret;

    D.20081 = &domain->lock.mutex;
    ret = pthread_mutex_unlock (D.20081);
    if (ret != 0) goto <D.20090>; else goto <D.20091>;
    <D.20090>:
    monoeg_g_log (0B, 16, "Bad call to mono_mutex_unlock result %d", ret);
    <D.20091>:
    D.20092 = ret != 0;
    D.20093 = (long int) D.20092;
    D.20094 = __builtin_expect (D.20093, 0);
    if (D.20094 != 0) goto <D.20095>; else goto <D.20096>;
    <D.20095>:
    monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "domain.c", 2250, "ret == 0");
    <D.20096>:
  }
}


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

  D.20097 = data;
  return D.20097;
}


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.20099;
  _Bool D.20102;
  long int D.20103;
  long int D.20104;
  struct MonoCodeManager * D.20107;
  _Bool D.20110;
  long int D.20111;
  long int D.20112;

  {
    int ret;

    D.20099 = &domain->lock.mutex;
    ret = pthread_mutex_lock (D.20099);
    if (ret != 0) goto <D.20100>; else goto <D.20101>;
    <D.20100>:
    monoeg_g_log (0B, 16, "Bad call to mono_mutex_lock result %d", ret);
    <D.20101>:
    D.20102 = ret != 0;
    D.20103 = (long int) D.20102;
    D.20104 = __builtin_expect (D.20103, 0);
    if (D.20104 != 0) goto <D.20105>; else goto <D.20106>;
    <D.20105>:
    monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "domain.c", 2317, "ret == 0");
    <D.20106>:
  }
  D.20107 = domain->code_mp;
  mono_code_manager_foreach (D.20107, func, user_data);
  {
    int ret;

    D.20099 = &domain->lock.mutex;
    ret = pthread_mutex_unlock (D.20099);
    if (ret != 0) goto <D.20108>; else goto <D.20109>;
    <D.20108>:
    monoeg_g_log (0B, 16, "Bad call to mono_mutex_unlock result %d", ret);
    <D.20109>:
    D.20110 = ret != 0;
    D.20111 = (long int) D.20110;
    D.20112 = __builtin_expect (D.20111, 0);
    if (D.20112 != 0) goto <D.20113>; else goto <D.20114>;
    <D.20113>:
    monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "domain.c", 2319, "ret == 0");
    <D.20114>:
  }
}


mono_context_set (struct MonoAppContext * new_context)
{
  struct MonoInternalThread * D.20115;
  struct MonoInternalThread * D.20116;
  struct MonoAppContext * * D.20117;

  D.20115 = mono_thread_internal_current ();
  D.20116 = mono_thread_internal_current ();
  D.20117 = &D.20116->current_appcontext;
  mono_gc_wbarrier_set_field (D.20115, D.20117, new_context);
}


mono_context_get ()
{
  struct MonoAppContext * D.20118;
  struct MonoInternalThread * D.20119;

  D.20119 = mono_thread_internal_current ();
  D.20118 = D.20119->current_appcontext;
  return D.20118;
}


mono_domain_add_class_static_data (struct MonoDomain * domain, struct MonoClass * klass, void * data, guint32 * bitmap)
{
  void * * D.20121;
  void * * D.20124;
  void * D.20125;
  void * D.20126;
  unsigned int size.92;
  unsigned int D.20130;
  void * iftmp.93;
  int D.20132;
  unsigned int D.20136;
  void * * D.20137;
  void * size.94;
  unsigned int size.95;
  unsigned int D.20141;
  void * iftmp.96;
  int D.20143;
  void * next.97;
  void * * D.20148;
  void * size.98;
  int next.99;
  unsigned int next.100;
  unsigned int D.20152;
  void * * D.20153;
  int next;

  D.20121 = domain->static_data_array;
  if (D.20121 != 0B) goto <D.20122>; else goto <D.20123>;
  <D.20122>:
  {
    int size;

    D.20121 = domain->static_data_array;
    D.20124 = D.20121 + 4;
    D.20125 = *D.20124;
    size = (int) D.20125;
    D.20121 = domain->static_data_array;
    D.20126 = *D.20121;
    next = (int) D.20126;
    if (next >= size) goto <D.20127>; else goto <D.20128>;
    <D.20127>:
    {
      void * * new_array;

      size.92 = (unsigned int) size;
      D.20130 = size.92 * 8;
      D.20132 = mono_gc_is_moving ();
      if (D.20132 != 0) goto <D.20133>; else goto <D.20134>;
      <D.20133>:
      iftmp.93 = mono_gc_make_root_descr_all_refs (0);
      goto <D.20135>;
      <D.20134>:
      iftmp.93 = 0B;
      <D.20135>:
      new_array = mono_gc_alloc_fixed (D.20130, iftmp.93);
      D.20121 = domain->static_data_array;
      size.92 = (unsigned int) size;
      D.20136 = size.92 * 4;
      mono_gc_memmove_aligned (new_array, D.20121, D.20136);
      size = size * 2;
      D.20137 = new_array + 4;
      size.94 = (void *) size;
      *D.20137 = size.94;
      D.20121 = domain->static_data_array;
      mono_gc_free_fixed (D.20121);
      domain->static_data_array = new_array;
    }
    <D.20128>:
  }
  goto <D.20139>;
  <D.20123>:
  {
    int size;
    void * * new_array;

    size = 32;
    size.95 = (unsigned int) size;
    D.20141 = size.95 * 4;
    D.20143 = mono_gc_is_moving ();
    if (D.20143 != 0) goto <D.20144>; else goto <D.20145>;
    <D.20144>:
    iftmp.96 = mono_gc_make_root_descr_all_refs (0);
    goto <D.20146>;
    <D.20145>:
    iftmp.96 = 0B;
    <D.20146>:
    new_array = mono_gc_alloc_fixed (D.20141, iftmp.96);
    next = 2;
    next.97 = (void *) next;
    *new_array = next.97;
    D.20148 = new_array + 4;
    size.98 = (void *) size;
    *D.20148 = size.98;
    domain->static_data_array = new_array;
  }
  <D.20139>:
  D.20121 = domain->static_data_array;
  next.99 = next;
  next = next.99 + 1;
  next.100 = (unsigned int) next.99;
  D.20152 = next.100 * 4;
  D.20153 = D.20121 + D.20152;
  *D.20153 = data;
  D.20121 = domain->static_data_array;
  next.97 = (void *) next;
  *D.20121 = next.97;
}


mono_get_corlib ()
{
  struct MonoImage * D.20154;

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


mono_get_object_class ()
{
  struct MonoClass * D.20156;

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


mono_get_byte_class ()
{
  struct MonoClass * D.20158;

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


mono_get_void_class ()
{
  struct MonoClass * D.20160;

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


mono_get_boolean_class ()
{
  struct MonoClass * D.20162;

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


mono_get_sbyte_class ()
{
  struct MonoClass * D.20164;

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


mono_get_int16_class ()
{
  struct MonoClass * D.20166;

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


mono_get_uint16_class ()
{
  struct MonoClass * D.20168;

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


mono_get_int32_class ()
{
  struct MonoClass * D.20170;

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


mono_get_uint32_class ()
{
  struct MonoClass * D.20172;

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


mono_get_intptr_class ()
{
  struct MonoClass * D.20174;

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


mono_get_uintptr_class ()
{
  struct MonoClass * D.20176;

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


mono_get_int64_class ()
{
  struct MonoClass * D.20178;

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


mono_get_uint64_class ()
{
  struct MonoClass * D.20180;

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


mono_get_single_class ()
{
  struct MonoClass * D.20182;

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


mono_get_double_class ()
{
  struct MonoClass * D.20184;

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


mono_get_char_class ()
{
  struct MonoClass * D.20186;

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


mono_get_string_class ()
{
  struct MonoClass * D.20188;

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


mono_get_enum_class ()
{
  struct MonoClass * D.20190;

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


mono_get_array_class ()
{
  struct MonoClass * D.20192;

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


mono_get_thread_class ()
{
  struct MonoClass * D.20194;

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


mono_get_exception_class ()
{
  struct MonoClass * D.20196;

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


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

  D.20198 = current_runtime;
  return D.20198;
}


mono_debugger_check_runtime_version (const char * filename)
{
  gchar * D.20202;
  const struct MonoRuntimeInfo * current_runtime.101;
  const char[12] * D.20206;
  const char[12] * D.20207;
  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.20200>; else goto <D.20201>;
      <D.20200>:
      D.20202 = monoeg_g_strdup_printf ("Cannot get runtime version from assembly `%s\'", filename);
      return D.20202;
      <D.20201>:
      current_runtime.101 = current_runtime;
      if (rinfo != current_runtime.101) goto <D.20204>; else goto <D.20205>;
      <D.20204>:
      current_runtime.101 = current_runtime;
      D.20206 = &current_runtime.101->runtime_version;
      D.20207 = &rinfo->runtime_version;
      D.20202 = monoeg_g_strdup_printf ("The Mono Debugger is currently using the `%s\' runtime, but the assembly `%s\' requires version `%s\'", D.20206, filename, D.20207);
      return D.20202;
      <D.20205>:
      D.20202 = 0B;
      return D.20202;
    }
  finally
    {
      runtimes = {CLOBBER};
      image = {CLOBBER};
    }
}


mono_framework_version ()
{
  int D.20210;
  const struct MonoRuntimeInfo * current_runtime.102;
  char D.20212;
  int D.20213;

  current_runtime.102 = current_runtime;
  D.20212 = current_runtime.102->framework_version[0];
  D.20213 = (int) D.20212;
  D.20210 = D.20213 + -48;
  return D.20210;
}