mono_domain_get_tls_key ()
{
  pthread_key_t D.19131;

  D.19131 = appdomain_thread_id;
  return D.19131;
}


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

  offset = -1;
  __asm__("lis	%0,tls_appdomain@tprel@ha
addi	%0,%0, tls_appdomain@tprel@l
" : "=r" offset);
  D.19133 = offset;
  return D.19133;
}


mono_jit_info_table_find_internal (struct MonoDomain * domain, char * addr, gboolean try_aot)
{
  long unsigned int D.19135;
  long unsigned int D.19136;
  struct MonoJitInfoTable * volatile * D.19137;
  struct MonoJitInfo * D.19144;
  struct MonoDomain * mono_root_domain.0;
  struct MonoJitInfoTable * D.19150;
  struct MonoJitInfoTable * volatile * D.19153;
  struct MonoJitInfo * (*<T1a6b>) (struct MonoDomain *, struct MonoImage *, void *) jit_info_find_in_aot_func.1;
  struct MonoImage * D.19157;
  struct MonoJitInfoTable * table;
  struct MonoJitInfo * ji;
  struct MonoJitInfo * module_ji;
  struct MonoThreadHazardPointers * hp;

  hp = mono_hazard_pointer_get ();
  D.19135 = mono_stats.jit_info_table_lookup_count;
  D.19136 = D.19135 + 1;
  mono_stats.jit_info_table_lookup_count = D.19136;
  D.19137 = &domain->jit_info_table;
  table = get_hazardous_pointer (D.19137, hp, 0);
  ji = jit_info_table_find (table, hp, addr);
  if (hp != 0B) goto <D.19138>; else goto <D.19139>;
  <D.19138>:
  if (0 != 0) goto <D.19140>; else goto <D.19141>;
  <D.19140>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "domain.c", 401, "(0) >= 0 && (0) < HAZARD_POINTER_COUNT");
  <D.19141>:
  hp->hazard_pointers[0] = 0B;
  <D.19139>:
  if (ji != 0B) goto <D.19142>; else goto <D.19143>;
  <D.19142>:
  D.19144 = ji;
  return D.19144;
  <D.19143>:
  if (try_aot != 0) goto <D.19145>; else goto <D.19146>;
  <D.19145>:
  mono_root_domain.0 = mono_root_domain;
  if (mono_root_domain.0 != 0B) goto <D.19148>; else goto <D.19149>;
  <D.19148>:
  mono_root_domain.0 = mono_root_domain;
  D.19150 = mono_root_domain.0->aot_modules;
  if (D.19150 != 0B) goto <D.19151>; else goto <D.19152>;
  <D.19151>:
  mono_root_domain.0 = mono_root_domain;
  D.19153 = &mono_root_domain.0->aot_modules;
  table = get_hazardous_pointer (D.19153, hp, 0);
  module_ji = jit_info_table_find (table, hp, addr);
  if (module_ji != 0B) goto <D.19154>; else goto <D.19155>;
  <D.19154>:
  jit_info_find_in_aot_func.1 = jit_info_find_in_aot_func;
  D.19157 = module_ji->d.image;
  ji = jit_info_find_in_aot_func.1 (domain, D.19157, addr);
  <D.19155>:
  if (hp != 0B) goto <D.19158>; else goto <D.19159>;
  <D.19158>:
  if (0 != 0) goto <D.19160>; else goto <D.19161>;
  <D.19160>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "domain.c", 412, "(0) >= 0 && (0) < HAZARD_POINTER_COUNT");
  <D.19161>:
  hp->hazard_pointers[0] = 0B;
  <D.19159>:
  <D.19152>:
  <D.19149>:
  <D.19146>:
  D.19144 = ji;
  return D.19144;
}


jit_info_table_find (struct MonoJitInfoTable * table, struct MonoThreadHazardPointers * hp, gint8 * addr)
{
  int D.19163;
  _Bool D.19164;
  long int D.19165;
  long int D.19166;
  struct MonoJitInfoTableChunk * D.19169;
  struct MonoJitInfo * volatile * D.19170;
  struct MonoMethod * D.19171;
  void * D.19176;
  int D.19179;
  sizetype D.19180;
  gint8 * D.19181;
  struct MonoJitInfo * D.19186;
  int D.19188;
  struct MonoJitInfo * ji;
  int chunk_pos;
  int pos;
  void not_found = <<< error >>>;

  chunk_pos = jit_info_table_index (table, addr);
  D.19163 = table->num_chunks;
  D.19164 = D.19163 <= chunk_pos;
  D.19165 = (long int) D.19164;
  D.19166 = __builtin_expect (D.19165, 0);
  if (D.19166 != 0) goto <D.19167>; else goto <D.19168>;
  <D.19167>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "domain.c", 327, "chunk_pos < table->num_chunks");
  <D.19168>:
  D.19169 = table->chunks[chunk_pos];
  pos = jit_info_table_chunk_index (D.19169, hp, addr);
  <D.18384>:
  {
    struct MonoJitInfoTableChunk * chunk;

    chunk = table->chunks[chunk_pos];
    goto <D.18380>;
    <D.18382>:
    D.19170 = &chunk->data[pos];
    ji = get_hazardous_pointer (D.19170, hp, 1);
    pos = pos + 1;
    D.19171 = ji->d.method;
    if (D.19171 == 0B) goto <D.19172>; else goto <D.19173>;
    <D.19172>:
    if (0 != 0) goto <D.19174>; else goto <D.19175>;
    <D.19174>:
    monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "domain.c", 345, "(1) >= 0 && (1) < HAZARD_POINTER_COUNT");
    <D.19175>:
    hp->hazard_pointers[1] = 0B;
    // predicted unlikely by continue predictor.
    goto <D.18380>;
    <D.19173>:
    D.19176 = ji->code_start;
    if (D.19176 <= addr) goto <D.19177>; else goto <D.19178>;
    <D.19177>:
    D.19176 = ji->code_start;
    D.19179 = ji->code_size;
    D.19180 = (sizetype) D.19179;
    D.19181 = D.19176 + D.19180;
    if (D.19181 > addr) goto <D.19182>; else goto <D.19183>;
    <D.19182>:
    if (0 != 0) goto <D.19184>; else goto <D.19185>;
    <D.19184>:
    monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "domain.c", 350, "(1) >= 0 && (1) < HAZARD_POINTER_COUNT");
    <D.19185>:
    hp->hazard_pointers[1] = 0B;
    D.19186 = ji;
    return D.19186;
    <D.19183>:
    <D.19178>:
    D.19176 = ji->code_start;
    if (D.19176 > addr) goto not_found; else goto <D.19187>;
    <D.19187>:
    <D.18380>:
    D.19188 = chunk->num_elements;
    if (D.19188 > pos) goto <D.18382>; else goto <D.18383>;
    <D.18383>:
    chunk_pos = chunk_pos + 1;
    pos = 0;
  }
  D.19163 = table->num_chunks;
  if (D.19163 > chunk_pos) goto <D.18384>; else goto <D.18385>;
  <D.18385>:
  not_found:
  if (hp != 0B) goto <D.19189>; else goto <D.19190>;
  <D.19189>:
  if (0 != 0) goto <D.19191>; else goto <D.19192>;
  <D.19191>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "domain.c", 367, "(1) >= 0 && (1) < HAZARD_POINTER_COUNT");
  <D.19192>:
  hp->hazard_pointers[1] = 0B;
  <D.19190>:
  D.19186 = 0B;
  return D.19186;
}


jit_info_table_index (struct MonoJitInfoTable * table, gint8 * addr)
{
  _Bool D.19194;
  long int D.19195;
  long int D.19196;
  int D.19199;
  volatile gint8 * D.19200;
  _Bool D.19204;
  long int D.19205;
  long int D.19206;
  int D.19209;
  int D.19212;
  int left;
  int right;

  left = 0;
  right = table->num_chunks;
  D.19194 = left >= right;
  D.19195 = (long int) D.19194;
  D.19196 = __builtin_expect (D.19195, 0);
  if (D.19196 != 0) goto <D.19197>; else goto <D.19198>;
  <D.19197>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "domain.c", 282, "left < right");
  <D.19198>:
  <D.18356>:
  {
    int pos;
    struct MonoJitInfoTableChunk * chunk;

    D.19199 = left + right;
    pos = D.19199 / 2;
    chunk = table->chunks[pos];
    D.19200 = chunk->last_code_end;
    if (D.19200 > addr) goto <D.19201>; else goto <D.19202>;
    <D.19201>:
    right = pos;
    goto <D.19203>;
    <D.19202>:
    left = pos + 1;
    <D.19203>:
  }
  if (left < right) goto <D.18356>; else goto <D.18357>;
  <D.18357>:
  D.19204 = left != right;
  D.19205 = (long int) D.19204;
  D.19206 = __builtin_expect (D.19205, 0);
  if (D.19206 != 0) goto <D.19207>; else goto <D.19208>;
  <D.19207>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "domain.c", 293, "left == right");
  <D.19208>:
  D.19209 = table->num_chunks;
  if (D.19209 <= left) goto <D.19210>; else goto <D.19211>;
  <D.19210>:
  D.19209 = table->num_chunks;
  D.19212 = D.19209 + -1;
  return D.19212;
  <D.19211>:
  D.19212 = left;
  return D.19212;
}


jit_info_table_chunk_index (struct MonoJitInfoTableChunk * chunk, struct MonoThreadHazardPointers * hp, gint8 * addr)
{
  int D.19214;
  struct MonoJitInfo * volatile * D.19215;
  void * D.19216;
  int D.19217;
  sizetype D.19218;
  _Bool D.19222;
  long int D.19223;
  long int D.19224;
  int D.19227;
  int left;
  int right;

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

    D.19214 = left + right;
    pos = D.19214 / 2;
    D.19215 = &chunk->data[pos];
    ji = get_hazardous_pointer (D.19215, hp, 1);
    D.19216 = ji->code_start;
    D.19217 = ji->code_size;
    D.19218 = (sizetype) D.19217;
    code_end = D.19216 + D.19218;
    if (addr < code_end) goto <D.19219>; else goto <D.19220>;
    <D.19219>:
    right = pos;
    goto <D.19221>;
    <D.19220>:
    left = pos + 1;
    <D.19221>:
  }
  <D.18369>:
  if (left < right) goto <D.18368>; else goto <D.18370>;
  <D.18370>:
  D.19222 = left != right;
  D.19223 = (long int) D.19222;
  D.19224 = __builtin_expect (D.19223, 0);
  if (D.19224 != 0) goto <D.19225>; else goto <D.19226>;
  <D.19225>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "domain.c", 315, "left == right");
  <D.19226>:
  D.19227 = left;
  return D.19227;
}


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

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


mono_jit_info_table_add (struct MonoDomain * domain, struct MonoJitInfo * ji)
{
  struct MonoMethod * D.19231;
  _Bool D.19232;
  long int D.19233;
  long int D.19234;
  union mono_mutex_t * D.19237;
  _Bool D.19240;
  long int D.19241;
  long int D.19242;
  long unsigned int D.19245;
  long unsigned int D.19246;
  struct MonoJitInfoTable * volatile * D.19247;
  _Bool D.19250;
  long int D.19251;
  long int D.19252;

  D.19231 = ji->d.method;
  D.19232 = D.19231 == 0B;
  D.19233 = (long int) D.19232;
  D.19234 = __builtin_expect (D.19233, 0);
  if (D.19234 != 0) goto <D.19235>; else goto <D.19236>;
  <D.19235>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "domain.c", 749, "ji->d.method != NULL");
  <D.19236>:
  {
    int ret;

    D.19237 = &domain->lock.mutex;
    ret = pthread_mutex_lock (D.19237);
    if (ret != 0) goto <D.19238>; else goto <D.19239>;
    <D.19238>:
    monoeg_g_log (0B, 16, "Bad call to mono_mutex_lock result %d", ret);
    <D.19239>:
    D.19240 = ret != 0;
    D.19241 = (long int) D.19240;
    D.19242 = __builtin_expect (D.19241, 0);
    if (D.19242 != 0) goto <D.19243>; else goto <D.19244>;
    <D.19243>:
    monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "domain.c", 751, "ret == 0");
    <D.19244>:
  }
  D.19245 = mono_stats.jit_info_table_insert_count;
  D.19246 = D.19245 + 1;
  mono_stats.jit_info_table_insert_count = D.19246;
  D.19247 = &domain->jit_info_table;
  jit_info_table_add (domain, D.19247, ji);
  {
    int ret;

    D.19237 = &domain->lock.mutex;
    ret = pthread_mutex_unlock (D.19237);
    if (ret != 0) goto <D.19248>; else goto <D.19249>;
    <D.19248>:
    monoeg_g_log (0B, 16, "Bad call to mono_mutex_unlock result %d", ret);
    <D.19249>:
    D.19250 = ret != 0;
    D.19251 = (long int) D.19250;
    D.19252 = __builtin_expect (D.19251, 0);
    if (D.19252 != 0) goto <D.19253>; else goto <D.19254>;
    <D.19253>:
    monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "domain.c", 757, "ret == 0");
    <D.19254>:
  }
}


jit_info_table_add (struct MonoDomain * domain, struct MonoJitInfoTable * volatile * table_ptr, struct MonoJitInfo * ji)
{
  void * D.19255;
  int D.19256;
  sizetype D.19257;
  gint8 * D.19258;
  int D.19259;
  _Bool D.19260;
  long int D.19261;
  long int D.19262;
  int D.19265;
  int D.19268;
  int D.19269;
  int D.19272;
  struct MonoJitInfo * D.19273;
  int D.19275;
  struct MonoJitInfo * D.19276;
  int D.19277;
  int D.19278;
  struct MonoJitInfo * D.19279;
  void * D.19280;
  int D.19281;
  int D.19282;
  struct MonoJitInfo * D.19283;
  int D.19284;
  sizetype D.19285;
  volatile gint8 * D.19286;
  struct MonoJitInfoTable * table;
  struct MonoJitInfoTableChunk * chunk;
  int chunk_pos;
  int pos;
  int num_elements;
  int i;
  void restart = <<< error >>>;

  table = *table_ptr;
  restart:
  D.19255 = ji->code_start;
  D.19256 = ji->code_size;
  D.19257 = (sizetype) D.19256;
  D.19258 = D.19255 + D.19257;
  chunk_pos = jit_info_table_index (table, D.19258);
  D.19259 = table->num_chunks;
  D.19260 = D.19259 <= chunk_pos;
  D.19261 = (long int) D.19260;
  D.19262 = __builtin_expect (D.19261, 0);
  if (D.19262 != 0) goto <D.19263>; else goto <D.19264>;
  <D.19263>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "domain.c", 693, "chunk_pos < table->num_chunks");
  <D.19264>:
  chunk = table->chunks[chunk_pos];
  D.19265 = chunk->num_elements;
  if (D.19265 > 63) goto <D.19266>; else goto <D.19267>;
  <D.19266>:
  {
    struct MonoJitInfoTable * new_table;

    new_table = jit_info_table_chunk_overflow (table, chunk);
    *table_ptr = new_table;
    mono_memory_barrier ();
    D.19268 = domain->num_jit_info_tables;
    D.19269 = D.19268 + 1;
    domain->num_jit_info_tables = D.19269;
    mono_thread_hazardous_free_or_queue (table, jit_info_table_free, 1, 0);
    table = new_table;
    goto restart;
  }
  <D.19267>:
  num_elements = chunk->num_elements;
  D.19255 = ji->code_start;
  D.19256 = ji->code_size;
  D.19257 = (sizetype) D.19256;
  D.19258 = D.19255 + D.19257;
  pos = jit_info_table_chunk_index (chunk, 0B, D.19258);
  if (num_elements > 0) goto <D.19270>; else goto <D.19271>;
  <D.19270>:
  D.19272 = num_elements + -1;
  D.19273 = chunk->data[D.19272];
  chunk->data[num_elements] = D.19273;
  goto <D.19274>;
  <D.19271>:
  chunk->data[0] = ji;
  <D.19274>:
  mono_memory_write_barrier ();
  num_elements = num_elements + 1;
  chunk->num_elements = num_elements;
  i = num_elements + -2;
  goto <D.18503>;
  <D.18502>:
  mono_memory_write_barrier ();
  D.19275 = i + 1;
  D.19276 = chunk->data[i];
  chunk->data[D.19275] = D.19276;
  i = i + -1;
  <D.18503>:
  if (i >= pos) goto <D.18502>; else goto <D.18504>;
  <D.18504>:
  mono_memory_write_barrier ();
  chunk->data[pos] = ji;
  D.19277 = chunk->num_elements;
  D.19278 = D.19277 + -1;
  D.19279 = chunk->data[D.19278];
  D.19280 = D.19279->code_start;
  D.19281 = chunk->num_elements;
  D.19282 = D.19281 + -1;
  D.19283 = chunk->data[D.19282];
  D.19284 = D.19283->code_size;
  D.19285 = (sizetype) D.19284;
  D.19286 = D.19280 + D.19285;
  chunk->last_code_end = D.19286;
}


jit_info_table_free (struct MonoJitInfoTable * table)
{
  union mono_mutex_t * D.19287;
  _Bool D.19290;
  long int D.19291;
  long int D.19292;
  struct MonoDomain * D.19295;
  int D.19296;
  int D.19297;
  void * D.19300;
  struct GSList * D.19301;
  int D.19302;
  int D.19303;
  struct MonoMethod * D.19306;
  _Bool D.19311;
  long int D.19312;
  long int D.19313;
  int i;
  int num_chunks;
  struct MonoDomain * domain;

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

    D.19287 = &domain->lock.mutex;
    ret = pthread_mutex_lock (D.19287);
    if (ret != 0) goto <D.19288>; else goto <D.19289>;
    <D.19288>:
    monoeg_g_log (0B, 16, "Bad call to mono_mutex_lock result %d", ret);
    <D.19289>:
    D.19290 = ret != 0;
    D.19291 = (long int) D.19290;
    D.19292 = __builtin_expect (D.19291, 0);
    if (D.19292 != 0) goto <D.19293>; else goto <D.19294>;
    <D.19293>:
    monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "domain.c", 216, "ret == 0");
    <D.19294>:
  }
  D.19295 = table->domain;
  D.19296 = D.19295->num_jit_info_tables;
  D.19297 = D.19296 + -1;
  D.19295->num_jit_info_tables = D.19297;
  D.19295 = table->domain;
  D.19296 = D.19295->num_jit_info_tables;
  if (D.19296 <= 1) goto <D.19298>; else goto <D.19299>;
  <D.19298>:
  {
    struct GSList * list;

    D.19295 = table->domain;
    list = D.19295->jit_info_free_queue;
    goto <D.18334>;
    <D.18333>:
    D.19300 = list->data;
    monoeg_g_free (D.19300);
    list = list->next;
    <D.18334>:
    if (list != 0B) goto <D.18333>; else goto <D.18335>;
    <D.18335>:
    D.19295 = table->domain;
    D.19301 = D.19295->jit_info_free_queue;
    monoeg_g_slist_free (D.19301);
    D.19295 = table->domain;
    D.19295->jit_info_free_queue = 0B;
  }
  <D.19299>:
  i = 0;
  goto <D.18345>;
  <D.18344>:
  {
    struct MonoJitInfoTableChunk * chunk;
    int num_elements;
    int j;

    chunk = table->chunks[i];
    D.19302 = chunk->refcount;
    D.19303 = D.19302 + -1;
    chunk->refcount = D.19303;
    D.19302 = chunk->refcount;
    if (D.19302 > 0) goto <D.19304>; else goto <D.19305>;
    <D.19304>:
    // predicted unlikely by continue predictor.
    goto <D.18339>;
    <D.19305>:
    num_elements = chunk->num_elements;
    j = 0;
    goto <D.18342>;
    <D.18341>:
    {
      struct MonoJitInfo * ji;

      ji = chunk->data[j];
      D.19306 = ji->d.method;
      if (D.19306 == 0B) goto <D.19307>; else goto <D.19308>;
      <D.19307>:
      monoeg_g_free (ji);
      <D.19308>:
    }
    j = j + 1;
    <D.18342>:
    if (j < num_elements) goto <D.18341>; else goto <D.18343>;
    <D.18343>:
    monoeg_g_free (chunk);
  }
  <D.18339>:
  i = i + 1;
  <D.18345>:
  if (i < num_chunks) goto <D.18344>; else goto <D.18346>;
  <D.18346>:
  {
    int ret;

    D.19287 = &domain->lock.mutex;
    ret = pthread_mutex_unlock (D.19287);
    if (ret != 0) goto <D.19309>; else goto <D.19310>;
    <D.19309>:
    monoeg_g_log (0B, 16, "Bad call to mono_mutex_unlock result %d", ret);
    <D.19310>:
    D.19311 = ret != 0;
    D.19312 = (long int) D.19311;
    D.19313 = __builtin_expect (D.19312, 0);
    if (D.19313 != 0) goto <D.19314>; else goto <D.19315>;
    <D.19314>:
    monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "domain.c", 252, "ret == 0");
    <D.19315>:
  }
  monoeg_g_free (table);
}


jit_info_table_chunk_overflow (struct MonoJitInfoTable * table, struct MonoJitInfoTableChunk * chunk)
{
  int D.19318;
  int D.19319;
  int D.19321;
  int D.19322;
  struct MonoJitInfoTable * D.19323;
  struct MonoJitInfo * D.19324;
  struct MonoMethod * D.19325;
  int D.19328;
  int num_elements;
  int i;

  num_elements = jit_info_table_num_elements (table);
  D.19318 = table->num_chunks;
  D.19319 = D.19318 * 32;
  if (D.19319 > num_elements) goto <D.19316>; else goto <D.19320>;
  <D.19320>:
  D.19318 = table->num_chunks;
  D.19321 = D.19318 * 320;
  D.19322 = D.19321 / 6;
  if (D.19322 < num_elements) goto <D.19316>; else goto <D.19317>;
  <D.19316>:
  D.19323 = jit_info_table_realloc (table);
  return D.19323;
  <D.19317>:
  num_elements = 0;
  i = 0;
  goto <D.18487>;
  <D.18486>:
  D.19324 = chunk->data[i];
  D.19325 = D.19324->d.method;
  if (D.19325 != 0B) goto <D.19326>; else goto <D.19327>;
  <D.19326>:
  num_elements = num_elements + 1;
  <D.19327>:
  i = i + 1;
  <D.18487>:
  D.19328 = chunk->num_elements;
  if (D.19328 > i) goto <D.18486>; else goto <D.18488>;
  <D.18488>:
  if (num_elements == 64) goto <D.19329>; else goto <D.19330>;
  <D.19329>:
  D.19323 = jit_info_table_copy_and_split_chunk (table, chunk);
  return D.19323;
  <D.19330>:
  D.19323 = jit_info_table_copy_and_purify_chunk (table, chunk);
  return D.19323;
}


jit_info_table_num_elements (struct MonoJitInfoTable * table)
{
  struct MonoJitInfo * D.19332;
  struct MonoMethod * D.19333;
  int D.19336;
  int D.19337;
  int i;
  int num_elements;

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

    chunk = table->chunks[i];
    chunk_num_elements = chunk->num_elements;
    j = 0;
    goto <D.18312>;
    <D.18311>:
    D.19332 = chunk->data[j];
    D.19333 = D.19332->d.method;
    if (D.19333 != 0B) goto <D.19334>; else goto <D.19335>;
    <D.19334>:
    num_elements = num_elements + 1;
    <D.19335>:
    j = j + 1;
    <D.18312>:
    if (j < chunk_num_elements) goto <D.18311>; else goto <D.18313>;
    <D.18313>:
  }
  i = i + 1;
  <D.18315>:
  D.19336 = table->num_chunks;
  if (D.19336 > i) goto <D.18314>; else goto <D.18316>;
  <D.18316>:
  D.19337 = num_elements;
  return D.19337;
}


jit_info_table_realloc (struct MonoJitInfoTable * old)
{
  long int D.19339;
  long int D.19340;
  long int D.19341;
  int D.19342;
  _Bool D.19345;
  long int D.19346;
  long int D.19347;
  struct MonoJitInfoTable * D.19350;
  struct MonoDomain * D.19351;
  _Bool D.19352;
  long int D.19353;
  long int D.19354;
  long unsigned int D.19357;
  long unsigned int D.19358;
  long unsigned int D.19359;
  struct MonoJitInfoTableChunk * D.19360;
  struct MonoJitInfo * D.19361;
  struct MonoMethod * D.19362;
  _Bool D.19365;
  long int D.19366;
  long int D.19367;
  struct MonoJitInfoTableChunk * D.19370;
  struct MonoJitInfo * D.19371;
  int D.19374;
  int D.19377;
  _Bool D.19378;
  long int D.19379;
  long int D.19380;
  int D.19383;
  _Bool D.19384;
  long int D.19385;
  long int D.19386;
  int D.19389;
  int D.19390;
  struct MonoJitInfoTableChunk * D.19391;
  void * D.19392;
  int D.19393;
  sizetype D.19394;
  volatile gint8 * D.19395;
  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.19339 = (long int) num_elements;
  D.19340 = D.19339 * 4;
  D.19341 = D.19340 / 3;
  required_size = (int) D.19341;
  D.19342 = required_size + 63;
  num_chunks = D.19342 / 64;
  if (num_chunks == 0) goto <D.19343>; else goto <D.19344>;
  <D.19343>:
  D.19345 = num_elements != 0;
  D.19346 = (long int) D.19345;
  D.19347 = __builtin_expect (D.19346, 0);
  if (D.19347 != 0) goto <D.19348>; else goto <D.19349>;
  <D.19348>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "domain.c", 480, "num_elements == 0");
  <D.19349>:
  D.19351 = old->domain;
  D.19350 = jit_info_table_new (D.19351);
  return D.19350;
  <D.19344>:
  D.19352 = num_chunks <= 0;
  D.19353 = (long int) D.19352;
  D.19354 = __builtin_expect (D.19353, 0);
  if (D.19354 != 0) goto <D.19355>; else goto <D.19356>;
  <D.19355>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "domain.c", 483, "num_chunks > 0");
  <D.19356>:
  D.19357 = (long unsigned int) num_chunks;
  D.19358 = D.19357 + 2;
  D.19359 = D.19358 * 8;
  new = monoeg_malloc (D.19359);
  D.19351 = old->domain;
  new->domain = D.19351;
  new->num_chunks = num_chunks;
  i = 0;
  goto <D.18428>;
  <D.18427>:
  D.19360 = jit_info_table_new_chunk ();
  new->chunks[i] = D.19360;
  i = i + 1;
  <D.18428>:
  if (i < num_chunks) goto <D.18427>; else goto <D.18429>;
  <D.18429>:
  new_chunk = 0;
  new_element = 0;
  i = 0;
  goto <D.18437>;
  <D.18436>:
  {
    struct MonoJitInfoTableChunk * chunk;
    int chunk_num_elements;
    int j;

    chunk = old->chunks[i];
    chunk_num_elements = chunk->num_elements;
    j = 0;
    goto <D.18434>;
    <D.18433>:
    D.19361 = chunk->data[j];
    D.19362 = D.19361->d.method;
    if (D.19362 != 0B) goto <D.19363>; else goto <D.19364>;
    <D.19363>:
    D.19365 = new_chunk >= num_chunks;
    D.19366 = (long int) D.19365;
    D.19367 = __builtin_expect (D.19366, 0);
    if (D.19367 != 0) goto <D.19368>; else goto <D.19369>;
    <D.19368>:
    monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "domain.c", 501, "new_chunk < num_chunks");
    <D.19369>:
    D.19370 = new->chunks[new_chunk];
    D.19371 = chunk->data[j];
    D.19370->data[new_element] = D.19371;
    new_element = new_element + 1;
    if (new_element > 47) goto <D.19372>; else goto <D.19373>;
    <D.19372>:
    D.19370 = new->chunks[new_chunk];
    D.19370->num_elements = new_element;
    new_chunk = new_chunk + 1;
    new_element = 0;
    <D.19373>:
    <D.19364>:
    j = j + 1;
    <D.18434>:
    if (j < chunk_num_elements) goto <D.18433>; else goto <D.18435>;
    <D.18435>:
  }
  i = i + 1;
  <D.18437>:
  D.19374 = old->num_chunks;
  if (D.19374 > i) goto <D.18436>; else goto <D.18438>;
  <D.18438>:
  if (new_chunk < num_chunks) goto <D.19375>; else goto <D.19376>;
  <D.19375>:
  D.19377 = num_chunks + -1;
  D.19378 = D.19377 != new_chunk;
  D.19379 = (long int) D.19378;
  D.19380 = __builtin_expect (D.19379, 0);
  if (D.19380 != 0) goto <D.19381>; else goto <D.19382>;
  <D.19381>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "domain.c", 513, "new_chunk == num_chunks - 1");
  <D.19382>:
  D.19370 = new->chunks[new_chunk];
  D.19370->num_elements = new_element;
  D.19370 = new->chunks[new_chunk];
  D.19383 = D.19370->num_elements;
  D.19384 = D.19383 <= 0;
  D.19385 = (long int) D.19384;
  D.19386 = __builtin_expect (D.19385, 0);
  if (D.19386 != 0) goto <D.19387>; else goto <D.19388>;
  <D.19387>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "domain.c", 515, "new->chunks [new_chunk]->num_elements > 0");
  <D.19388>:
  <D.19376>:
  i = 0;
  goto <D.18442>;
  <D.18441>:
  {
    struct MonoJitInfoTableChunk * chunk;
    struct MonoJitInfo * ji;

    chunk = new->chunks[i];
    D.19389 = chunk->num_elements;
    D.19390 = D.19389 + -1;
    ji = chunk->data[D.19390];
    D.19391 = new->chunks[i];
    D.19392 = ji->code_start;
    D.19393 = ji->code_size;
    D.19394 = (sizetype) D.19393;
    D.19395 = D.19392 + D.19394;
    D.19391->last_code_end = D.19395;
  }
  i = i + 1;
  <D.18442>:
  if (i < num_chunks) goto <D.18441>; else goto <D.18443>;
  <D.18443>:
  D.19350 = new;
  return D.19350;
}


jit_info_table_new (struct MonoDomain * domain)
{
  struct MonoJitInfoTableChunk * D.19397;
  struct MonoJitInfoTable * D.19398;
  struct MonoJitInfoTable * table;

  table = monoeg_malloc0 (24);
  table->domain = domain;
  table->num_chunks = 1;
  D.19397 = jit_info_table_new_chunk ();
  table->chunks[0] = D.19397;
  D.19398 = table;
  return D.19398;
}


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

  chunk = monoeg_malloc0 (528);
  chunk->refcount = 1;
  D.19400 = chunk;
  return D.19400;
}


jit_info_table_copy_and_split_chunk (struct MonoJitInfoTable * table, struct MonoJitInfoTableChunk * chunk)
{
  int D.19402;
  int D.19403;
  long unsigned int D.19404;
  long unsigned int D.19405;
  long unsigned int D.19406;
  struct MonoDomain * D.19407;
  struct MonoJitInfoTableChunk * D.19408;
  struct MonoJitInfoTableChunk * * D.19411;
  int D.19412;
  struct MonoJitInfoTableChunk * * D.19413;
  struct MonoJitInfoTableChunk * D.19415;
  int D.19416;
  int D.19417;
  int D.19418;
  _Bool D.19419;
  long int D.19420;
  long int D.19421;
  struct MonoJitInfoTable * D.19424;
  struct MonoJitInfoTable * new_table;
  int i;
  int j;

  D.19402 = table->num_chunks;
  D.19403 = D.19402 + 1;
  D.19404 = (long unsigned int) D.19403;
  D.19405 = D.19404 + 2;
  D.19406 = D.19405 * 8;
  new_table = monoeg_malloc (D.19406);
  D.19407 = table->domain;
  new_table->domain = D.19407;
  D.19402 = table->num_chunks;
  D.19403 = D.19402 + 1;
  new_table->num_chunks = D.19403;
  j = 0;
  i = 0;
  goto <D.18459>;
  <D.18458>:
  D.19408 = table->chunks[i];
  if (D.19408 == chunk) goto <D.19409>; else goto <D.19410>;
  <D.19409>:
  D.19411 = &new_table->chunks[j];
  D.19412 = j + 1;
  D.19413 = &new_table->chunks[D.19412];
  jit_info_table_split_chunk (chunk, D.19411, D.19413);
  j = j + 2;
  goto <D.19414>;
  <D.19410>:
  D.19408 = table->chunks[i];
  new_table->chunks[j] = D.19408;
  D.19415 = new_table->chunks[j];
  D.19416 = D.19415->refcount;
  D.19417 = D.19416 + 1;
  D.19415->refcount = D.19417;
  j = j + 1;
  <D.19414>:
  i = i + 1;
  <D.18459>:
  D.19402 = table->num_chunks;
  if (D.19402 > i) goto <D.18458>; else goto <D.18460>;
  <D.18460>:
  D.19418 = new_table->num_chunks;
  D.19419 = D.19418 != j;
  D.19420 = (long int) D.19419;
  D.19421 = __builtin_expect (D.19420, 0);
  if (D.19421 != 0) goto <D.19422>; else goto <D.19423>;
  <D.19422>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "domain.c", 573, "j == new_table->num_chunks");
  <D.19423>:
  D.19424 = new_table;
  return D.19424;
}


jit_info_table_split_chunk (struct MonoJitInfoTableChunk * chunk, struct MonoJitInfoTableChunk * * new1p, struct MonoJitInfoTableChunk * * new2p)
{
  int D.19426;
  _Bool D.19427;
  long int D.19428;
  long int D.19429;
  int D.19432;
  int D.19433;
  struct MonoJitInfo * volatile[64] * D.19434;
  struct MonoJitInfo * volatile[64] * D.19435;
  int D.19436;
  long unsigned int D.19437;
  long unsigned int D.19438;
  struct MonoJitInfo * volatile[64] * D.19439;
  int D.19440;
  sizetype D.19441;
  struct MonoJitInfo * volatile * D.19442;
  int D.19443;
  long unsigned int D.19444;
  long unsigned int D.19445;
  int D.19446;
  int D.19447;
  struct MonoJitInfo * D.19448;
  void * D.19449;
  int D.19450;
  int D.19451;
  struct MonoJitInfo * D.19452;
  int D.19453;
  sizetype D.19454;
  volatile gint8 * D.19455;
  int D.19456;
  int D.19457;
  struct MonoJitInfo * D.19458;
  void * D.19459;
  int D.19460;
  int D.19461;
  struct MonoJitInfo * D.19462;
  int D.19463;
  sizetype D.19464;
  volatile gint8 * D.19465;
  struct MonoJitInfoTableChunk * new1;
  struct MonoJitInfoTableChunk * new2;

  new1 = jit_info_table_new_chunk ();
  new2 = jit_info_table_new_chunk ();
  D.19426 = chunk->num_elements;
  D.19427 = D.19426 != 64;
  D.19428 = (long int) D.19427;
  D.19429 = __builtin_expect (D.19428, 0);
  if (D.19429 != 0) goto <D.19430>; else goto <D.19431>;
  <D.19430>:
  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.19431>:
  new1->num_elements = 32;
  D.19432 = new1->num_elements;
  D.19433 = 64 - D.19432;
  new2->num_elements = D.19433;
  D.19434 = &new1->data;
  D.19435 = &chunk->data;
  D.19436 = new1->num_elements;
  D.19437 = (long unsigned int) D.19436;
  D.19438 = D.19437 * 8;
  memcpy (D.19434, D.19435, D.19438);
  D.19439 = &new2->data;
  D.19440 = new1->num_elements;
  D.19441 = (sizetype) D.19440;
  D.19442 = &chunk->data[D.19441];
  D.19443 = new2->num_elements;
  D.19444 = (long unsigned int) D.19443;
  D.19445 = D.19444 * 8;
  memcpy (D.19439, D.19442, D.19445);
  D.19446 = new1->num_elements;
  D.19447 = D.19446 + -1;
  D.19448 = new1->data[D.19447];
  D.19449 = D.19448->code_start;
  D.19450 = new1->num_elements;
  D.19451 = D.19450 + -1;
  D.19452 = new1->data[D.19451];
  D.19453 = D.19452->code_size;
  D.19454 = (sizetype) D.19453;
  D.19455 = D.19449 + D.19454;
  new1->last_code_end = D.19455;
  D.19456 = new2->num_elements;
  D.19457 = D.19456 + -1;
  D.19458 = new2->data[D.19457];
  D.19459 = D.19458->code_start;
  D.19460 = new2->num_elements;
  D.19461 = D.19460 + -1;
  D.19462 = new2->data[D.19461];
  D.19463 = D.19462->code_size;
  D.19464 = (sizetype) D.19463;
  D.19465 = D.19459 + D.19464;
  new2->last_code_end = D.19465;
  *new1p = new1;
  *new2p = new2;
}


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

  D.19467 = __builtin_object_size (__dest, 0);
  D.19466 = __builtin___memcpy_chk (__dest, __src, __len, D.19467);
  return D.19466;
}


jit_info_table_copy_and_purify_chunk (struct MonoJitInfoTable * table, struct MonoJitInfoTableChunk * chunk)
{
  int D.19469;
  long unsigned int D.19470;
  long unsigned int D.19471;
  long unsigned int D.19472;
  struct MonoDomain * D.19473;
  struct MonoJitInfoTableChunk * D.19474;
  int j.2;
  struct MonoJitInfoTableChunk * D.19478;
  struct MonoJitInfoTableChunk * D.19480;
  int D.19481;
  int D.19482;
  int D.19483;
  _Bool D.19484;
  long int D.19485;
  long int D.19486;
  struct MonoJitInfoTable * D.19489;
  struct MonoJitInfoTable * new_table;
  int i;
  int j;

  D.19469 = table->num_chunks;
  D.19470 = (long unsigned int) D.19469;
  D.19471 = D.19470 + 2;
  D.19472 = D.19471 * 8;
  new_table = monoeg_malloc (D.19472);
  D.19473 = table->domain;
  new_table->domain = D.19473;
  D.19469 = table->num_chunks;
  new_table->num_chunks = D.19469;
  j = 0;
  i = 0;
  goto <D.18478>;
  <D.18477>:
  D.19474 = table->chunks[i];
  if (D.19474 == chunk) goto <D.19475>; else goto <D.19476>;
  <D.19475>:
  j.2 = j;
  j = j.2 + 1;
  D.19474 = table->chunks[i];
  D.19478 = jit_info_table_purify_chunk (D.19474);
  new_table->chunks[j.2] = D.19478;
  goto <D.19479>;
  <D.19476>:
  D.19474 = table->chunks[i];
  new_table->chunks[j] = D.19474;
  D.19480 = new_table->chunks[j];
  D.19481 = D.19480->refcount;
  D.19482 = D.19481 + 1;
  D.19480->refcount = D.19482;
  j = j + 1;
  <D.19479>:
  i = i + 1;
  <D.18478>:
  D.19469 = table->num_chunks;
  if (D.19469 > i) goto <D.18477>; else goto <D.18479>;
  <D.18479>:
  D.19483 = new_table->num_chunks;
  D.19484 = D.19483 != j;
  D.19485 = (long int) D.19484;
  D.19486 = __builtin_expect (D.19485, 0);
  if (D.19486 != 0) goto <D.19487>; else goto <D.19488>;
  <D.19487>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "domain.c", 620, "j == new_table->num_chunks");
  <D.19488>:
  D.19489 = new_table;
  return D.19489;
}


jit_info_table_purify_chunk (struct MonoJitInfoTableChunk * old)
{
  struct MonoJitInfo * D.19491;
  struct MonoMethod * D.19492;
  int j.3;
  struct MonoJitInfo * D.19496;
  int D.19497;
  int D.19498;
  int D.19501;
  struct MonoJitInfo * D.19502;
  void * D.19503;
  struct MonoJitInfo * D.19504;
  int D.19505;
  sizetype D.19506;
  volatile gint8 * D.19507;
  volatile gint8 * D.19509;
  struct MonoJitInfoTableChunk * D.19510;
  struct MonoJitInfoTableChunk * new;
  int i;
  int j;

  new = jit_info_table_new_chunk ();
  j = 0;
  i = 0;
  goto <D.18468>;
  <D.18467>:
  D.19491 = old->data[i];
  D.19492 = D.19491->d.method;
  if (D.19492 != 0B) goto <D.19493>; else goto <D.19494>;
  <D.19493>:
  j.3 = j;
  j = j.3 + 1;
  D.19496 = old->data[i];
  new->data[j.3] = D.19496;
  <D.19494>:
  i = i + 1;
  <D.18468>:
  D.19497 = old->num_elements;
  if (D.19497 > i) goto <D.18467>; else goto <D.18469>;
  <D.18469>:
  new->num_elements = j;
  D.19498 = new->num_elements;
  if (D.19498 > 0) goto <D.19499>; else goto <D.19500>;
  <D.19499>:
  D.19501 = j + -1;
  D.19502 = new->data[D.19501];
  D.19503 = D.19502->code_start;
  D.19501 = j + -1;
  D.19504 = new->data[D.19501];
  D.19505 = D.19504->code_size;
  D.19506 = (sizetype) D.19505;
  D.19507 = D.19503 + D.19506;
  new->last_code_end = D.19507;
  goto <D.19508>;
  <D.19500>:
  D.19509 = old->last_code_end;
  new->last_code_end = D.19509;
  <D.19508>:
  D.19510 = new;
  return D.19510;
}


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.19512;
  _Bool D.19515;
  long int D.19516;
  long int D.19517;
  long unsigned int D.19520;
  long unsigned int D.19521;
  _Bool D.19524;
  long int D.19525;
  long int D.19526;
  struct MonoJitInfoTable * table;

  {
    int ret;

    D.19512 = &domain->lock.mutex;
    ret = pthread_mutex_lock (D.19512);
    if (ret != 0) goto <D.19513>; else goto <D.19514>;
    <D.19513>:
    monoeg_g_log (0B, 16, "Bad call to mono_mutex_lock result %d", ret);
    <D.19514>:
    D.19515 = ret != 0;
    D.19516 = (long int) D.19515;
    D.19517 = __builtin_expect (D.19516, 0);
    if (D.19517 != 0) goto <D.19518>; else goto <D.19519>;
    <D.19518>:
    monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "domain.c", 831, "ret == 0");
    <D.19519>:
  }
  table = domain->jit_info_table;
  D.19520 = mono_stats.jit_info_table_remove_count;
  D.19521 = D.19520 + 1;
  mono_stats.jit_info_table_remove_count = D.19521;
  jit_info_table_remove (table, ji);
  mono_jit_info_free_or_queue (domain, ji);
  {
    int ret;

    D.19512 = &domain->lock.mutex;
    ret = pthread_mutex_unlock (D.19512);
    if (ret != 0) goto <D.19522>; else goto <D.19523>;
    <D.19522>:
    monoeg_g_log (0B, 16, "Bad call to mono_mutex_unlock result %d", ret);
    <D.19523>:
    D.19524 = ret != 0;
    D.19525 = (long int) D.19524;
    D.19526 = __builtin_expect (D.19525, 0);
    if (D.19526 != 0) goto <D.19527>; else goto <D.19528>;
    <D.19527>:
    monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "domain.c", 840, "ret == 0");
    <D.19528>:
  }
}


jit_info_table_remove (struct MonoJitInfoTable * table, struct MonoJitInfo * ji)
{
  int D.19529;
  _Bool D.19530;
  long int D.19531;
  long int D.19532;
  struct MonoJitInfoTableChunk * D.19535;
  struct MonoJitInfo * D.19536;
  struct MonoJitInfo * D.19538;
  struct MonoMethod * D.19539;
  _Bool D.19540;
  long int D.19541;
  long int D.19542;
  struct MonoJitInfo * D.19545;
  void * D.19546;
  struct MonoJitInfo * D.19547;
  int D.19548;
  sizetype D.19549;
  guint8 * D.19550;
  void * D.19551;
  int D.19552;
  sizetype D.19553;
  guint8 * D.19554;
  _Bool D.19555;
  long int D.19556;
  long int D.19557;
  int D.19560;
  struct MonoJitInfo * D.19561;
  _Bool D.19562;
  long int D.19563;
  long int D.19564;
  struct MonoJitInfo * D.19567;
  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.19529 = table->num_chunks;
  D.19530 = D.19529 <= chunk_pos;
  D.19531 = (long int) D.19530;
  D.19532 = __builtin_expect (D.19531, 0);
  if (D.19532 != 0) goto <D.19533>; else goto <D.19534>;
  <D.19533>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "domain.c", 795, "chunk_pos < table->num_chunks");
  <D.19534>:
  D.19535 = table->chunks[chunk_pos];
  pos = jit_info_table_chunk_index (D.19535, 0B, start);
  <D.18531>:
  chunk = table->chunks[chunk_pos];
  goto <D.18529>;
  <D.18528>:
  D.19536 = chunk->data[pos];
  if (D.19536 == ji) goto found; else goto <D.19537>;
  <D.19537>:
  D.19538 = chunk->data[pos];
  D.19539 = D.19538->d.method;
  D.19540 = D.19539 != 0B;
  D.19541 = (long int) D.19540;
  D.19542 = __builtin_expect (D.19541, 0);
  if (D.19542 != 0) goto <D.19543>; else goto <D.19544>;
  <D.19543>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "domain.c", 806, "IS_JIT_INFO_TOMBSTONE (chunk->data [pos])");
  <D.19544>:
  D.19545 = chunk->data[pos];
  D.19546 = D.19545->code_start;
  D.19547 = chunk->data[pos];
  D.19548 = D.19547->code_size;
  D.19549 = (sizetype) D.19548;
  D.19550 = D.19546 + D.19549;
  D.19551 = ji->code_start;
  D.19552 = ji->code_size;
  D.19553 = (sizetype) D.19552;
  D.19554 = D.19551 + D.19553;
  D.19555 = D.19550 > D.19554;
  D.19556 = (long int) D.19555;
  D.19557 = __builtin_expect (D.19556, 0);
  if (D.19557 != 0) goto <D.19558>; else goto <D.19559>;
  <D.19558>:
  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.19559>:
  pos = pos + 1;
  <D.18529>:
  D.19560 = chunk->num_elements;
  if (D.19560 > pos) goto <D.18528>; else goto <D.18530>;
  <D.18530>:
  chunk_pos = chunk_pos + 1;
  pos = 0;
  D.19529 = table->num_chunks;
  if (D.19529 > chunk_pos) goto <D.18531>; else goto <D.18532>;
  <D.18532>:
  found:
  D.19561 = chunk->data[pos];
  D.19562 = D.19561 != ji;
  D.19563 = (long int) D.19562;
  D.19564 = __builtin_expect (D.19563, 0);
  if (D.19564 != 0) goto <D.19565>; else goto <D.19566>;
  <D.19565>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "domain.c", 818, "chunk->data [pos] == ji");
  <D.19566>:
  D.19567 = mono_jit_info_make_tombstone (ji);
  chunk->data[pos] = D.19567;
}


mono_jit_info_make_tombstone (struct MonoJitInfo * ji)
{
  void * D.19568;
  int D.19569;
  struct MonoJitInfo * D.19570;
  struct MonoJitInfo * tombstone;

  tombstone = monoeg_malloc0 (48);
  D.19568 = ji->code_start;
  tombstone->code_start = D.19568;
  D.19569 = ji->code_size;
  tombstone->code_size = D.19569;
  tombstone->d.method = 0B;
  D.19570 = tombstone;
  return D.19570;
}


mono_jit_info_free_or_queue (struct MonoDomain * domain, struct MonoJitInfo * ji)
{
  int D.19572;
  struct GSList * D.19576;
  struct GSList * D.19577;

  D.19572 = domain->num_jit_info_tables;
  if (D.19572 <= 1) goto <D.19573>; else goto <D.19574>;
  <D.19573>:
  mono_thread_hazardous_free_or_queue (ji, monoeg_g_free, 1, 0);
  goto <D.19575>;
  <D.19574>:
  D.19576 = domain->jit_info_free_queue;
  D.19577 = monoeg_g_slist_prepend (D.19576, ji);
  domain->jit_info_free_queue = D.19577;
  <D.19575>:
}


mono_jit_info_add_aot_module (struct MonoImage * image, void * start, void * end)
{
  _Bool D.19580;
  long int D.19581;
  long int D.19582;
  struct MonoDomain * mono_root_domain.4;
  _Bool D.19586;
  long int D.19587;
  long int D.19588;
  struct MonoJitInfoTable * D.19591;
  int D.19594;
  int D.19595;
  struct MonoJitInfoTable * D.19596;
  long int end.5;
  long int start.6;
  long int D.19599;
  int D.19600;
  struct MonoJitInfoTable * volatile * D.19601;
  _Bool D.19604;
  long int D.19605;
  long int D.19606;
  struct MonoJitInfo * ji;

  {
    int ret;

    ret = pthread_mutex_lock (&appdomains_mutex.mutex);
    if (ret != 0) goto <D.19578>; else goto <D.19579>;
    <D.19578>:
    monoeg_g_log (0B, 16, "Bad call to mono_mutex_lock result %d", ret);
    <D.19579>:
    D.19580 = ret != 0;
    D.19581 = (long int) D.19580;
    D.19582 = __builtin_expect (D.19581, 0);
    if (D.19582 != 0) goto <D.19583>; else goto <D.19584>;
    <D.19583>:
    monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "domain.c", 848, "ret == 0");
    <D.19584>:
  }
  mono_root_domain.4 = mono_root_domain;
  D.19586 = mono_root_domain.4 == 0B;
  D.19587 = (long int) D.19586;
  D.19588 = __builtin_expect (D.19587, 0);
  if (D.19588 != 0) goto <D.19589>; else goto <D.19590>;
  <D.19589>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "domain.c", 854, "mono_root_domain");
  <D.19590>:
  mono_root_domain.4 = mono_root_domain;
  D.19591 = mono_root_domain.4->aot_modules;
  if (D.19591 == 0B) goto <D.19592>; else goto <D.19593>;
  <D.19592>:
  mono_root_domain.4 = mono_root_domain;
  D.19594 = mono_root_domain.4->num_jit_info_tables;
  D.19595 = D.19594 + 1;
  mono_root_domain.4->num_jit_info_tables = D.19595;
  mono_root_domain.4 = mono_root_domain;
  mono_root_domain.4 = mono_root_domain;
  D.19596 = jit_info_table_new (mono_root_domain.4);
  mono_root_domain.4->aot_modules = D.19596;
  <D.19593>:
  ji = monoeg_malloc0 (48);
  ji->d.image = image;
  ji->code_start = start;
  end.5 = (long int) end;
  start.6 = (long int) start;
  D.19599 = end.5 - start.6;
  D.19600 = (int) D.19599;
  ji->code_size = D.19600;
  mono_root_domain.4 = mono_root_domain;
  mono_root_domain.4 = mono_root_domain;
  D.19601 = &mono_root_domain.4->aot_modules;
  jit_info_table_add (mono_root_domain.4, D.19601, ji);
  {
    int ret;

    ret = pthread_mutex_unlock (&appdomains_mutex.mutex);
    if (ret != 0) goto <D.19602>; else goto <D.19603>;
    <D.19602>:
    monoeg_g_log (0B, 16, "Bad call to mono_mutex_unlock result %d", ret);
    <D.19603>:
    D.19604 = ret != 0;
    D.19605 = (long int) D.19604;
    D.19606 = __builtin_expect (D.19605, 0);
    if (D.19606 != 0) goto <D.19607>; else goto <D.19608>;
    <D.19607>:
    monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "domain.c", 866, "ret == 0");
    <D.19608>:
  }
}


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

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


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

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


mono_jit_info_get_method (struct MonoJitInfo * ji)
{
  long unsigned int D.19613;
  long unsigned int D.19614;
  _Bool D.19615;
  long int D.19616;
  long int D.19617;
  struct MonoMethod * D.19620;

  D.19613 = BIT_FIELD_REF <*ji, 64, 256>;
  D.19614 = D.19613 & 16777216;
  D.19615 = D.19614 != 0;
  D.19616 = (long int) D.19615;
  D.19617 = __builtin_expect (D.19616, 0);
  if (D.19617 != 0) goto <D.19618>; else goto <D.19619>;
  <D.19618>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "domain.c", 890, "!ji->async");
  <D.19619>:
  D.19620 = ji->d.method;
  return D.19620;
}


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

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


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

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


mono_jit_info_get_generic_jit_info (struct MonoJitInfo * ji)
{
  long unsigned int D.19626;
  long unsigned int D.19627;
  struct MonoGenericJitInfo * D.19630;
  <unnamed-unsigned:15> D.19631;
  int D.19632;

  D.19626 = BIT_FIELD_REF <*ji, 64, 256>;
  D.19627 = D.19626 & 131072;
  if (D.19627 != 0) goto <D.19628>; else goto <D.19629>;
  <D.19628>:
  D.19631 = ji->num_clauses;
  D.19632 = (int) D.19631;
  D.19630 = &ji->clauses[D.19632];
  return D.19630;
  <D.19629>:
  D.19630 = 0B;
  return D.19630;
}


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

  gi = mono_jit_info_get_generic_jit_info (ji);
  if (gi != 0B) goto <D.19634>; else goto <D.19635>;
  <D.19634>:
  D.19636 = gi->generic_sharing_context;
  return D.19636;
  <D.19635>:
  D.19636 = 0B;
  return D.19636;
}


mono_jit_info_set_generic_sharing_context (struct MonoJitInfo * ji, struct MonoGenericSharingContext * gsctx)
{
  _Bool D.19638;
  long int D.19639;
  long int D.19640;
  struct MonoGenericJitInfo * gi;

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


mono_jit_info_get_try_block_hole_table_info (struct MonoJitInfo * ji)
{
  long unsigned int D.19643;
  long unsigned int D.19644;
  <unnamed-unsigned:15> D.19647;
  int D.19648;
  long unsigned int D.19649;
  struct MonoTryBlockHoleTableJitInfo * D.19652;

  D.19643 = BIT_FIELD_REF <*ji, 64, 256>;
  D.19644 = D.19643 & 262144;
  if (D.19644 != 0) goto <D.19645>; else goto <D.19646>;
  <D.19645>:
  {
    char * ptr;

    D.19647 = ji->num_clauses;
    D.19648 = (int) D.19647;
    ptr = &ji->clauses[D.19648];
    D.19643 = BIT_FIELD_REF <*ji, 64, 256>;
    D.19649 = D.19643 & 131072;
    if (D.19649 != 0) goto <D.19650>; else goto <D.19651>;
    <D.19650>:
    ptr = ptr + 32;
    <D.19651>:
    D.19652 = ptr;
    return D.19652;
  }
  <D.19646>:
  D.19652 = 0B;
  return D.19652;
}


mono_jit_info_get_arch_eh_info (struct MonoJitInfo * ji)
{
  long unsigned int D.19654;
  long unsigned int D.19655;
  <unnamed-unsigned:15> D.19658;
  int D.19659;
  long unsigned int D.19660;
  long unsigned int D.19663;
  struct MonoArchEHJitInfo * D.19666;

  D.19654 = BIT_FIELD_REF <*ji, 64, 256>;
  D.19655 = D.19654 & 524288;
  if (D.19655 != 0) goto <D.19656>; else goto <D.19657>;
  <D.19656>:
  {
    char * ptr;

    D.19658 = ji->num_clauses;
    D.19659 = (int) D.19658;
    ptr = &ji->clauses[D.19659];
    D.19654 = BIT_FIELD_REF <*ji, 64, 256>;
    D.19660 = D.19654 & 131072;
    if (D.19660 != 0) goto <D.19661>; else goto <D.19662>;
    <D.19661>:
    ptr = ptr + 32;
    <D.19662>:
    D.19654 = BIT_FIELD_REF <*ji, 64, 256>;
    D.19663 = D.19654 & 262144;
    if (D.19663 != 0) goto <D.19664>; else goto <D.19665>;
    <D.19664>:
    ptr = ptr + 4;
    <D.19665>:
    D.19666 = ptr;
    return D.19666;
  }
  <D.19657>:
  D.19666 = 0B;
  return D.19666;
}


mono_jit_info_get_cas_info (struct MonoJitInfo * ji)
{
  long unsigned int D.19668;
  long unsigned int D.19669;
  <unnamed-unsigned:15> D.19672;
  int D.19673;
  long unsigned int D.19674;
  long unsigned int D.19677;
  long unsigned int D.19680;
  struct MonoMethodCasInfo * D.19683;

  D.19668 = BIT_FIELD_REF <*ji, 64, 256>;
  D.19669 = D.19668 & 65536;
  if (D.19669 != 0) goto <D.19670>; else goto <D.19671>;
  <D.19670>:
  {
    char * ptr;

    D.19672 = ji->num_clauses;
    D.19673 = (int) D.19672;
    ptr = &ji->clauses[D.19673];
    D.19668 = BIT_FIELD_REF <*ji, 64, 256>;
    D.19674 = D.19668 & 131072;
    if (D.19674 != 0) goto <D.19675>; else goto <D.19676>;
    <D.19675>:
    ptr = ptr + 32;
    <D.19676>:
    D.19668 = BIT_FIELD_REF <*ji, 64, 256>;
    D.19677 = D.19668 & 262144;
    if (D.19677 != 0) goto <D.19678>; else goto <D.19679>;
    <D.19678>:
    ptr = ptr + 4;
    <D.19679>:
    D.19668 = BIT_FIELD_REF <*ji, 64, 256>;
    D.19680 = D.19668 & 524288;
    if (D.19680 != 0) goto <D.19681>; else goto <D.19682>;
    <D.19681>:
    ptr = ptr + 4;
    <D.19682>:
    D.19683 = ptr;
    return D.19683;
  }
  <D.19671>:
  D.19683 = 0B;
  return D.19683;
}


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.19687;
  mono_unichar2 * D.19690;
  mono_unichar2 * D.19691;
  int D.19692;
  long unsigned int D.19693;
  int D.19694;
  _Bool D.19695;
  int l1;
  int l2;

  l1 = mono_string_length (s1);
  l2 = mono_string_length (s2);
  if (s1 == s2) goto <D.19685>; else goto <D.19686>;
  <D.19685>:
  D.19687 = 1;
  return D.19687;
  <D.19686>:
  if (l1 != l2) goto <D.19688>; else goto <D.19689>;
  <D.19688>:
  D.19687 = 0;
  return D.19687;
  <D.19689>:
  D.19690 = mono_string_chars (s1);
  D.19691 = mono_string_chars (s2);
  D.19692 = l1 * 2;
  D.19693 = (long unsigned int) D.19692;
  D.19694 = memcmp (D.19690, D.19691, D.19693);
  D.19695 = D.19694 == 0;
  D.19687 = (mono_bool) D.19695;
  return D.19687;
}


mono_string_hash (struct MonoString * s)
{
  unsigned int D.19697;
  unsigned int D.19698;
  short unsigned int D.19699;
  unsigned int D.19700;
  unsigned int D.19701;
  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.18645>;
  <D.18644>:
  D.19697 = h << 5;
  D.19698 = D.19697 - h;
  D.19699 = *p;
  D.19700 = (unsigned int) D.19699;
  h = D.19698 + D.19700;
  p = p + 2;
  i = i + 1;
  <D.18645>:
  if (i < len) goto <D.18644>; else goto <D.18646>;
  <D.18646>:
  D.19701 = h;
  return D.19701;
}


mono_domain_create ()
{
  _Bool D.19705;
  long int D.19706;
  long int D.19707;
  unsigned int domain_shadow_serial.7;
  unsigned int domain_shadow_serial.8;
  unsigned int domain_shadow_serial.9;
  void * domain_gc_desc.10;
  unsigned int D.19716;
  long unsigned int D.19717;
  int bit.11;
  int D.19719;
  long unsigned int D.19720;
  long unsigned int D.19721;
  unsigned int D.19722;
  int D.19723;
  void * domain_gc_desc.12;
  _Bool D.19727;
  long int D.19728;
  long int D.19729;
  struct MonoGHashTable * * D.19732;
  int shadow_serial.13;
  struct MonoMemPool * D.19734;
  struct MonoCodeManager * D.19735;
  struct LockFreeMempool * D.19736;
  struct MonoGHashTable * D.19737;
  struct GPtrArray * D.19738;
  struct GHashTable * D.19739;
  struct MonoInternalHashTable * D.19740;
  struct MonoGHashTable * D.19741;
  struct MonoJitInfoTable * D.19742;
  struct GHashTable * D.19743;
  struct GHashTable * D.19744;
  struct CRITICAL_SECTION * D.19745;
  struct CRITICAL_SECTION * D.19746;
  struct CRITICAL_SECTION * D.19747;
  struct CRITICAL_SECTION * D.19748;
  _Bool D.19751;
  long int D.19752;
  long int D.19753;
  _Bool D.19758;
  long int D.19759;
  long int D.19760;
  struct MonoPerfCounters * mono_perfcounters.14;
  unsigned int D.19764;
  unsigned int D.19765;
  unsigned int D.19766;
  unsigned int D.19767;
  void (*<T19f2>) (struct MonoDomain *) create_domain_hook.15;
  struct MonoDomain * D.19771;
  struct MonoDomain * domain;
  guint32 shadow_serial;

  {
    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", 1234, "ret == 0");
    <D.19709>:
  }
  domain_shadow_serial.7 = domain_shadow_serial;
  domain_shadow_serial.8 = domain_shadow_serial.7;
  domain_shadow_serial.9 = domain_shadow_serial.8 + 1;
  domain_shadow_serial = domain_shadow_serial.9;
  shadow_serial = domain_shadow_serial.8;
  domain_gc_desc.10 = domain_gc_desc;
  if (domain_gc_desc.10 == 0B) goto <D.19714>; else goto <D.19715>;
  <D.19714>:
  {
    unsigned int i;
    unsigned int bit;

    bit = 0;
    i = 64;
    goto <D.18686>;
    <D.18685>:
    bit = i / 8;
    D.19716 = bit / 32;
    D.19717 = domain_gc_bitmap[D.19716];
    bit.11 = (int) bit;
    D.19719 = bit.11 & 31;
    D.19720 = 1 << D.19719;
    D.19721 = D.19717 | D.19720;
    domain_gc_bitmap[D.19716] = D.19721;
    i = i + 8;
    <D.18686>:
    if (i <= 135) goto <D.18685>; else goto <D.18687>;
    <D.18687>:
    D.19722 = bit + 1;
    D.19723 = (int) D.19722;
    domain_gc_desc.12 = mono_gc_make_descr_from_bitmap (&domain_gc_bitmap, D.19723);
    domain_gc_desc = domain_gc_desc.12;
  }
  <D.19715>:
  {
    int ret;

    ret = pthread_mutex_unlock (&appdomains_mutex.mutex);
    if (ret != 0) goto <D.19725>; else goto <D.19726>;
    <D.19725>:
    monoeg_g_log (0B, 16, "Bad call to mono_mutex_unlock result %d", ret);
    <D.19726>:
    D.19727 = ret != 0;
    D.19728 = (long int) D.19727;
    D.19729 = __builtin_expect (D.19728, 0);
    if (D.19729 != 0) goto <D.19730>; else goto <D.19731>;
    <D.19730>:
    monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "domain.c", 1245, "ret == 0");
    <D.19731>:
  }
  domain_gc_desc.10 = domain_gc_desc;
  domain = mono_gc_alloc_fixed (704, domain_gc_desc.10);
  D.19732 = &domain->env;
  mono_gc_register_root (D.19732, 48, 0B);
  shadow_serial.13 = (int) shadow_serial;
  domain->shadow_serial = shadow_serial.13;
  domain->domain = 0B;
  domain->setup = 0B;
  domain->friendly_name = 0B;
  domain->search_path = 0B;
  mono_profiler_appdomain_event (domain, 0);
  D.19734 = mono_mempool_new ();
  domain->mp = D.19734;
  D.19735 = mono_code_manager_new ();
  domain->code_mp = D.19735;
  D.19736 = lock_free_mempool_new ();
  domain->lock_free_mp = D.19736;
  D.19737 = mono_g_hash_table_new_type (mono_string_hash, mono_string_equal, 3);
  domain->env = D.19737;
  domain->domain_assemblies = 0B;
  domain->assembly_bindings = 0B;
  domain->assembly_bindings_parsed = 0;
  D.19738 = monoeg_g_ptr_array_new ();
  domain->class_vtable_array = D.19738;
  D.19739 = monoeg_g_hash_table_new (mono_ptrarray_hash, mono_ptrarray_equal);
  domain->proxy_vtable_hash = D.19739;
  domain->static_data_array = 0B;
  D.19740 = &domain->jit_code_hash;
  mono_jit_code_hash_init (D.19740);
  D.19741 = mono_g_hash_table_new_type (mono_string_hash, mono_string_equal, 3);
  domain->ldstr_table = D.19741;
  domain->num_jit_info_tables = 1;
  D.19742 = jit_info_table_new (domain);
  domain->jit_info_table = D.19742;
  domain->jit_info_free_queue = 0B;
  D.19743 = monoeg_g_hash_table_new (mono_aligned_addr_hash, 0B);
  domain->finalizable_objects_hash = D.19743;
  D.19744 = monoeg_g_hash_table_new (mono_aligned_addr_hash, 0B);
  domain->ftnptrs_hash = D.19744;
  D.19745 = &domain->lock;
  InitializeCriticalSection (D.19745);
  D.19746 = &domain->assemblies_lock;
  InitializeCriticalSection (D.19746);
  D.19747 = &domain->jit_code_hash_lock;
  InitializeCriticalSection (D.19747);
  D.19748 = &domain->finalizable_objects_hash_lock;
  InitializeCriticalSection (D.19748);
  domain->method_rgctx_hash = 0B;
  {
    int ret;

    ret = pthread_mutex_lock (&appdomains_mutex.mutex);
    if (ret != 0) goto <D.19749>; else goto <D.19750>;
    <D.19749>:
    monoeg_g_log (0B, 16, "Bad call to mono_mutex_lock result %d", ret);
    <D.19750>:
    D.19751 = ret != 0;
    D.19752 = (long int) D.19751;
    D.19753 = __builtin_expect (D.19752, 0);
    if (D.19753 != 0) goto <D.19754>; else goto <D.19755>;
    <D.19754>:
    monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "domain.c", 1292, "ret == 0");
    <D.19755>:
  }
  domain_id_alloc (domain);
  {
    int ret;

    ret = pthread_mutex_unlock (&appdomains_mutex.mutex);
    if (ret != 0) goto <D.19756>; else goto <D.19757>;
    <D.19756>:
    monoeg_g_log (0B, 16, "Bad call to mono_mutex_unlock result %d", ret);
    <D.19757>:
    D.19758 = ret != 0;
    D.19759 = (long int) D.19758;
    D.19760 = __builtin_expect (D.19759, 0);
    if (D.19760 != 0) goto <D.19761>; else goto <D.19762>;
    <D.19761>:
    monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "domain.c", 1294, "ret == 0");
    <D.19762>:
  }
  mono_perfcounters.14 = mono_perfcounters;
  D.19764 = mono_perfcounters.14->loader_appdomains;
  D.19765 = D.19764 + 1;
  mono_perfcounters.14->loader_appdomains = D.19765;
  mono_perfcounters.14 = mono_perfcounters;
  D.19766 = mono_perfcounters.14->loader_total_appdomains;
  D.19767 = D.19766 + 1;
  mono_perfcounters.14->loader_total_appdomains = D.19767;
  mono_debug_domain_create (domain);
  create_domain_hook.15 = create_domain_hook;
  if (create_domain_hook.15 != 0B) goto <D.19769>; else goto <D.19770>;
  <D.19769>:
  create_domain_hook.15 = create_domain_hook;
  create_domain_hook.15 (domain);
  <D.19770>:
  mono_profiler_appdomain_loaded (domain, 0);
  D.19771 = domain;
  return D.19771;
}


mono_ptrarray_equal (void * * s1, void * * s2)
{
  void * D.19773;
  long int D.19774;
  void * D.19775;
  long int D.19776;
  int D.19777;
  gboolean D.19780;
  const void * D.19781;
  const void * D.19782;
  long unsigned int D.19783;
  long unsigned int D.19784;
  int D.19785;
  _Bool D.19786;
  int len;

  D.19773 = *s1;
  D.19774 = (long int) D.19773;
  len = (int) D.19774;
  D.19775 = *s2;
  D.19776 = (long int) D.19775;
  D.19777 = (int) D.19776;
  if (D.19777 != len) goto <D.19778>; else goto <D.19779>;
  <D.19778>:
  D.19780 = 0;
  return D.19780;
  <D.19779>:
  D.19781 = s1 + 8;
  D.19782 = s2 + 8;
  D.19783 = (long unsigned int) len;
  D.19784 = D.19783 * 8;
  D.19785 = memcmp (D.19781, D.19782, D.19784);
  D.19786 = D.19785 == 0;
  D.19780 = (gboolean) D.19786;
  return D.19780;
}


mono_ptrarray_hash (void * * s)
{
  void * D.19788;
  long int D.19789;
  long unsigned int D.19790;
  long unsigned int D.19791;
  void * * D.19792;
  void * D.19793;
  long int D.19794;
  unsigned int D.19795;
  guint D.19796;
  int i;
  int len;
  guint hash;

  D.19788 = *s;
  D.19789 = (long int) D.19788;
  len = (int) D.19789;
  hash = 0;
  i = 1;
  goto <D.18659>;
  <D.18658>:
  D.19790 = (long unsigned int) i;
  D.19791 = D.19790 * 8;
  D.19792 = s + D.19791;
  D.19793 = *D.19792;
  D.19794 = (long int) D.19793;
  D.19795 = (unsigned int) D.19794;
  hash = D.19795 + hash;
  i = i + 1;
  <D.18659>:
  if (i < len) goto <D.18658>; else goto <D.18660>;
  <D.18660>:
  D.19796 = hash;
  return D.19796;
}


lock_free_mempool_new ()
{
  struct LockFreeMempool * D.19798;

  D.19798 = monoeg_malloc0 (16);
  return D.19798;
}


domain_id_alloc (struct MonoDomain * domain)
{
  struct MonoDomain * * appdomains_list.16;
  short unsigned int appdomain_list_size.17;
  long unsigned int D.19804;
  long unsigned int D.19805;
  void * appdomains_list.18;
  short unsigned int appdomain_next.19;
  long unsigned int D.19808;
  long unsigned int D.19809;
  struct MonoDomain * * D.19810;
  struct MonoDomain * D.19811;
  int D.19814;
  int D.19819;
  long unsigned int D.19824;
  long unsigned int D.19825;
  short unsigned int appdomain_list_size.20;
  long unsigned int D.19827;
  long unsigned int D.19828;
  struct MonoDomain * * D.19829;
  short unsigned int appdomain_next.21;
  short unsigned int appdomain_next.22;
  int D.19834;
  int id;
  int i;

  id = -1;
  appdomains_list.16 = appdomains_list;
  if (appdomains_list.16 == 0B) goto <D.19801>; else goto <D.19802>;
  <D.19801>:
  appdomain_list_size = 2;
  appdomain_list_size.17 = appdomain_list_size;
  D.19804 = (long unsigned int) appdomain_list_size.17;
  D.19805 = D.19804 * 8;
  appdomains_list.18 = mono_gc_alloc_fixed (D.19805, 0B);
  appdomains_list = appdomains_list.18;
  <D.19802>:
  appdomain_next.19 = appdomain_next;
  i = (int) appdomain_next.19;
  goto <D.18668>;
  <D.18667>:
  appdomains_list.16 = appdomains_list;
  D.19808 = (long unsigned int) i;
  D.19809 = D.19808 * 8;
  D.19810 = appdomains_list.16 + D.19809;
  D.19811 = *D.19810;
  if (D.19811 == 0B) goto <D.19812>; else goto <D.19813>;
  <D.19812>:
  id = i;
  goto <D.18666>;
  <D.19813>:
  i = i + 1;
  <D.18668>:
  appdomain_list_size.17 = appdomain_list_size;
  D.19814 = (int) appdomain_list_size.17;
  if (D.19814 > i) goto <D.18667>; else goto <D.18666>;
  <D.18666>:
  if (id == -1) goto <D.19815>; else goto <D.19816>;
  <D.19815>:
  i = 0;
  goto <D.18671>;
  <D.18670>:
  appdomains_list.16 = appdomains_list;
  D.19808 = (long unsigned int) i;
  D.19809 = D.19808 * 8;
  D.19810 = appdomains_list.16 + D.19809;
  D.19811 = *D.19810;
  if (D.19811 == 0B) goto <D.19817>; else goto <D.19818>;
  <D.19817>:
  id = i;
  goto <D.18669>;
  <D.19818>:
  i = i + 1;
  <D.18671>:
  appdomain_next.19 = appdomain_next;
  D.19819 = (int) appdomain_next.19;
  if (D.19819 > i) goto <D.18670>; else goto <D.18669>;
  <D.18669>:
  <D.19816>:
  if (id == -1) goto <D.19820>; else goto <D.19821>;
  <D.19820>:
  {
    struct MonoDomain * * new_list;
    int new_size;

    appdomain_list_size.17 = appdomain_list_size;
    D.19814 = (int) appdomain_list_size.17;
    new_size = D.19814 * 2;
    if (new_size > 65535) goto <D.19822>; else goto <D.19823>;
    <D.19822>:
    monoeg_assertion_message ("* Assertion: should not be reached at %s:%d\n", "domain.c", 1208);
    <D.19823>:
    appdomain_list_size.17 = appdomain_list_size;
    id = (int) appdomain_list_size.17;
    D.19824 = (long unsigned int) new_size;
    D.19825 = D.19824 * 8;
    new_list = mono_gc_alloc_fixed (D.19825, 0B);
    appdomains_list.16 = appdomains_list;
    appdomain_list_size.17 = appdomain_list_size;
    D.19804 = (long unsigned int) appdomain_list_size.17;
    D.19805 = D.19804 * 8;
    memcpy (new_list, appdomains_list.16, D.19805);
    appdomains_list.16 = appdomains_list;
    mono_gc_free_fixed (appdomains_list.16);
    appdomains_list = new_list;
    appdomain_list_size.20 = (short unsigned int) new_size;
    appdomain_list_size = appdomain_list_size.20;
  }
  <D.19821>:
  domain->domain_id = id;
  appdomains_list.16 = appdomains_list;
  D.19827 = (long unsigned int) id;
  D.19828 = D.19827 * 8;
  D.19829 = appdomains_list.16 + D.19828;
  *D.19829 = domain;
  appdomain_next.19 = appdomain_next;
  appdomain_next.21 = appdomain_next.19;
  appdomain_next.22 = appdomain_next.21 + 1;
  appdomain_next = appdomain_next.22;
  appdomain_next.19 = appdomain_next;
  appdomain_list_size.17 = appdomain_list_size;
  if (appdomain_next.19 > appdomain_list_size.17) goto <D.19832>; else goto <D.19833>;
  <D.19832>:
  appdomain_next = 0;
  <D.19833>:
  D.19834 = id;
  return D.19834;
}


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

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


mono_init_internal (const char * filename, const char * exe_filename, const char * runtime_version)
{
  struct MonoDomain * domain.23;
  int D.19841;
  struct MonoDomain * domain.24;
  unsigned int appdomain_thread_id.25;
  const struct MonoRuntimeInfo * D.19851;
  const struct MonoRuntimeInfo * D.19852;
  const char[12] * D.19855;
  const struct MonoRuntimeInfo * current_runtime.26;
  const struct MonoRuntimeInfo * current_runtime.27;
  <unnamed type> status.28;
  const char * D.19864;
  const char[4] * D.19865;
  const char * D.19866;
  const char * D.19867;
  struct MonoImage * D.19869;
  struct MonoImage * D.19870;
  struct MonoClass * D.19871;
  struct MonoClass * D.19872;
  _Bool D.19873;
  long int D.19874;
  long int D.19875;
  struct MonoClass * D.19878;
  struct MonoClass * D.19879;
  _Bool D.19880;
  long int D.19881;
  long int D.19882;
  struct MonoClass * D.19885;
  struct MonoClass * D.19886;
  _Bool D.19887;
  long int D.19888;
  long int D.19889;
  struct MonoClass * D.19892;
  struct MonoClass * D.19893;
  _Bool D.19894;
  long int D.19895;
  long int D.19896;
  struct MonoClass * D.19899;
  struct MonoClass * D.19900;
  _Bool D.19901;
  long int D.19902;
  long int D.19903;
  struct MonoClass * D.19906;
  struct MonoClass * D.19907;
  _Bool D.19908;
  long int D.19909;
  long int D.19910;
  struct MonoClass * D.19913;
  struct MonoClass * D.19914;
  _Bool D.19915;
  long int D.19916;
  long int D.19917;
  struct MonoClass * D.19920;
  struct MonoClass * D.19921;
  _Bool D.19922;
  long int D.19923;
  long int D.19924;
  struct MonoClass * D.19927;
  struct MonoClass * D.19928;
  _Bool D.19929;
  long int D.19930;
  long int D.19931;
  struct MonoClass * D.19934;
  struct MonoClass * D.19935;
  _Bool D.19936;
  long int D.19937;
  long int D.19938;
  struct MonoClass * D.19941;
  struct MonoClass * D.19942;
  _Bool D.19943;
  long int D.19944;
  long int D.19945;
  struct MonoClass * D.19948;
  struct MonoClass * D.19949;
  _Bool D.19950;
  long int D.19951;
  long int D.19952;
  struct MonoClass * D.19955;
  struct MonoClass * D.19956;
  _Bool D.19957;
  long int D.19958;
  long int D.19959;
  struct MonoClass * D.19962;
  struct MonoClass * D.19963;
  _Bool D.19964;
  long int D.19965;
  long int D.19966;
  struct MonoClass * D.19969;
  struct MonoClass * D.19970;
  _Bool D.19971;
  long int D.19972;
  long int D.19973;
  struct MonoClass * D.19976;
  struct MonoClass * D.19977;
  _Bool D.19978;
  long int D.19979;
  long int D.19980;
  struct MonoClass * D.19983;
  struct MonoClass * D.19984;
  _Bool D.19985;
  long int D.19986;
  long int D.19987;
  struct MonoClass * D.19990;
  struct MonoClass * D.19991;
  _Bool D.19992;
  long int D.19993;
  long int D.19994;
  struct MonoClass * D.19997;
  struct MonoClass * D.19998;
  _Bool D.19999;
  long int D.20000;
  long int D.20001;
  struct MonoClass * D.20004;
  struct MonoClass * D.20005;
  _Bool D.20006;
  long int D.20007;
  long int D.20008;
  struct MonoClass * D.20011;
  struct MonoClass * D.20012;
  _Bool D.20013;
  long int D.20014;
  long int D.20015;
  struct MonoClass * D.20018;
  struct MonoClass * D.20019;
  _Bool D.20020;
  long int D.20021;
  long int D.20022;
  struct MonoClass * D.20025;
  struct MonoClass * D.20026;
  _Bool D.20027;
  long int D.20028;
  long int D.20029;
  struct MonoClass * D.20032;
  struct MonoClass * D.20033;
  _Bool D.20034;
  long int D.20035;
  long int D.20036;
  struct MonoClass * D.20039;
  struct MonoClass * D.20040;
  _Bool D.20041;
  long int D.20042;
  long int D.20043;
  struct MonoClass * D.20046;
  struct MonoClass * D.20047;
  _Bool D.20048;
  long int D.20049;
  long int D.20050;
  struct MonoClass * D.20053;
  struct MonoClass * D.20054;
  _Bool D.20055;
  long int D.20056;
  long int D.20057;
  struct MonoClass * D.20060;
  struct MonoClass * D.20061;
  _Bool D.20062;
  long int D.20063;
  long int D.20064;
  struct MonoClass * D.20067;
  struct MonoClass * D.20068;
  _Bool D.20069;
  long int D.20070;
  long int D.20071;
  struct MonoClass * D.20074;
  struct MonoClass * D.20075;
  _Bool D.20076;
  long int D.20077;
  long int D.20078;
  struct MonoClass * D.20081;
  struct MonoClass * D.20082;
  _Bool D.20083;
  long int D.20084;
  long int D.20085;
  struct MonoClass * D.20088;
  struct MonoClass * D.20089;
  struct _IO_FILE * stderr.29;
  const char * iftmp.30;
  struct MonoClass * D.20097;
  struct MonoClass * D.20098;
  _Bool D.20099;
  long int D.20100;
  long int D.20101;
  struct MonoClass * D.20104;
  struct MonoClass * D.20105;
  _Bool D.20106;
  long int D.20107;
  long int D.20108;
  struct MonoClass * D.20111;
  struct MonoClass * D.20112;
  _Bool D.20113;
  long int D.20114;
  long int D.20115;
  struct MonoClass * D.20118;
  struct MonoClass * D.20119;
  _Bool D.20120;
  long int D.20121;
  long int D.20122;
  struct MonoClass * D.20125;
  struct MonoClass * D.20126;
  _Bool D.20127;
  long int D.20128;
  long int D.20129;
  struct MonoClass * D.20132;
  struct MonoClass * D.20133;
  _Bool D.20134;
  long int D.20135;
  long int D.20136;
  struct MonoClass * D.20139;
  struct MonoClass * D.20140;
  _Bool D.20141;
  long int D.20142;
  long int D.20143;
  struct MonoClass * D.20146;
  struct MonoClass * D.20147;
  _Bool D.20148;
  long int D.20149;
  long int D.20150;
  struct MonoClass * D.20153;
  struct MonoClass * D.20154;
  _Bool D.20155;
  long int D.20156;
  long int D.20157;
  struct MonoClass * D.20160;
  struct MonoClass * D.20161;
  _Bool D.20162;
  long int D.20163;
  long int D.20164;
  struct MonoClass * D.20167;
  struct MonoClass * D.20168;
  _Bool D.20169;
  long int D.20170;
  long int D.20171;
  struct MonoClass * D.20174;
  struct MonoClass * D.20175;
  _Bool D.20176;
  long int D.20177;
  long int D.20178;
  struct MonoClass * D.20181;
  struct MonoClass * D.20182;
  _Bool D.20183;
  long int D.20184;
  long int D.20185;
  struct MonoClass * D.20188;
  struct MonoClass * D.20189;
  _Bool D.20190;
  long int D.20191;
  long int D.20192;
  struct MonoClass * D.20195;
  struct MonoClass * D.20196;
  _Bool D.20197;
  long int D.20198;
  long int D.20199;
  struct MonoClass * D.20202;
  struct MonoClass * D.20203;
  _Bool D.20204;
  long int D.20205;
  long int D.20206;
  struct MonoClass * D.20209;
  struct MonoClass * D.20210;
  struct MonoClass * D.20211;
  struct MonoClass * D.20212;
  struct MonoClass * D.20213;
  struct MonoClass * D.20214;
  struct MonoClass * D.20215;
  struct MonoClass * D.20216;
  struct MonoClass * D.20217;
  struct MonoClass * D.20218;
  struct MonoClass * D.20219;
  gchar * D.20220;
  struct MonoDomain * D.20221;
  static struct MonoDomain * domain = 0B;
  struct MonoAssembly * ass;
  MonoImageOpenStatus status;
  const struct MonoRuntimeInfo * runtimes[7];
  int n;

  try
    {
      ass = 0B;
      status = 0;
      domain.23 = domain;
      if (domain.23 != 0B) goto <D.19839>; else goto <D.19840>;
      <D.19839>:
      monoeg_assertion_message ("* Assertion: should not be reached at %s:%d\n", "domain.c", 1334);
      <D.19840>:
      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.19841 = mono_gc_is_moving ();
      if (D.19841 == 0) goto <D.19842>; else goto <D.19843>;
      <D.19842>:
      mono_gc_register_root (&appdomains_list, 8, 0B);
      <D.19843>:
      domain.24 = mono_domain_create ();
      domain = domain.24;
      domain.23 = domain;
      mono_root_domain = domain.23;
      domain.23 = domain;
      tls_appdomain = domain.23;
      appdomain_thread_id.25 = appdomain_thread_id;
      domain.23 = domain;
      mono_native_tls_set_value (appdomain_thread_id.25, domain.23);
      domain.23 = domain;
      mono_gc_set_current_thread_appdomain (domain.23);
      if (exe_filename != 0B) goto <D.19846>; else goto <D.19847>;
      <D.19846>:
      get_runtimes_from_exe (exe_filename, &exe_image, &runtimes);
      goto <D.19848>;
      <D.19847>:
      if (runtime_version != 0B) goto <D.19849>; else goto <D.19850>;
      <D.19849>:
      D.19851 = get_runtime_by_version (runtime_version);
      runtimes[0] = D.19851;
      runtimes[1] = 0B;
      <D.19850>:
      <D.19848>:
      D.19852 = runtimes[0];
      if (D.19852 == 0B) goto <D.19853>; else goto <D.19854>;
      <D.19853>:
      {
        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.19855 = &default_runtime->runtime_version;
        monoeg_g_print ("Using default runtime: %s\n", D.19855);
      }
      <D.19854>:
      n = 0;
      goto <D.18704>;
      <D.18703>:
      current_runtime.26 = runtimes[n];
      current_runtime = current_runtime.26;
      current_runtime.27 = current_runtime;
      ass = mono_assembly_load_corlib (current_runtime.27, &status);
      status.28 = status;
      if (status.28 > 1) goto <D.18702>; else goto <D.19859>;
      <D.19859>:
      n = n + 1;
      <D.18704>:
      current_runtime.26 = runtimes[n];
      if (current_runtime.26 != 0B) goto <D.19860>; else goto <D.18702>;
      <D.19860>:
      if (ass == 0B) goto <D.18703>; else goto <D.18702>;
      <D.18702>:
      status.28 = status;
      if (status.28 != 0) goto <D.19861>; else goto <D.19863>;
      <D.19863>:
      if (ass == 0B) goto <D.19861>; else goto <D.19862>;
      <D.19861>:
      status.28 = status;
      switch (status.28) <default: <D.19868>, case 0: <D.18710>, case 1: <D.18705>, case 2: <D.18709>, case 3: <D.18708>>
      <D.18705>:
      {
        char * corlib_file;

        D.19864 = mono_assembly_getrootdir ();
        current_runtime.27 = current_runtime;
        D.19865 = &current_runtime.27->framework_version;
        corlib_file = monoeg_g_build_path ("/", D.19864, "mono", D.19865, "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.18707>;
      }
      <D.18708>:
      D.19866 = mono_assembly_getrootdir ();
      monoeg_g_print ("The file %s/mscorlib.dll is an invalid CIL image\n", D.19866);
      goto <D.18707>;
      <D.18709>:
      D.19867 = mono_assembly_getrootdir ();
      monoeg_g_print ("Missing assembly reference in %s/mscorlib.dll\n", D.19867);
      goto <D.18707>;
      <D.18710>:
      goto <D.18707>;
      <D.19868>:
      <D.18707>:
      exit (1);
      <D.19862>:
      D.19869 = mono_assembly_get_image (ass);
      mono_defaults.corlib = D.19869;
      D.19870 = mono_defaults.corlib;
      D.19871 = mono_class_from_name (D.19870, "System", "Object");
      mono_defaults.object_class = D.19871;
      D.19872 = mono_defaults.object_class;
      D.19873 = D.19872 == 0B;
      D.19874 = (long int) D.19873;
      D.19875 = __builtin_expect (D.19874, 0);
      if (D.19875 != 0) goto <D.19876>; else goto <D.19877>;
      <D.19876>:
      monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "domain.c", 1442, "mono_defaults.object_class != 0");
      <D.19877>:
      D.19870 = mono_defaults.corlib;
      D.19878 = mono_class_from_name (D.19870, "System", "Void");
      mono_defaults.void_class = D.19878;
      D.19879 = mono_defaults.void_class;
      D.19880 = D.19879 == 0B;
      D.19881 = (long int) D.19880;
      D.19882 = __builtin_expect (D.19881, 0);
      if (D.19882 != 0) goto <D.19883>; else goto <D.19884>;
      <D.19883>:
      monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "domain.c", 1446, "mono_defaults.void_class != 0");
      <D.19884>:
      D.19870 = mono_defaults.corlib;
      D.19885 = mono_class_from_name (D.19870, "System", "Boolean");
      mono_defaults.boolean_class = D.19885;
      D.19886 = mono_defaults.boolean_class;
      D.19887 = D.19886 == 0B;
      D.19888 = (long int) D.19887;
      D.19889 = __builtin_expect (D.19888, 0);
      if (D.19889 != 0) goto <D.19890>; else goto <D.19891>;
      <D.19890>:
      monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "domain.c", 1450, "mono_defaults.boolean_class != 0");
      <D.19891>:
      D.19870 = mono_defaults.corlib;
      D.19892 = mono_class_from_name (D.19870, "System", "Byte");
      mono_defaults.byte_class = D.19892;
      D.19893 = mono_defaults.byte_class;
      D.19894 = D.19893 == 0B;
      D.19895 = (long int) D.19894;
      D.19896 = __builtin_expect (D.19895, 0);
      if (D.19896 != 0) goto <D.19897>; else goto <D.19898>;
      <D.19897>:
      monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "domain.c", 1454, "mono_defaults.byte_class != 0");
      <D.19898>:
      D.19870 = mono_defaults.corlib;
      D.19899 = mono_class_from_name (D.19870, "System", "SByte");
      mono_defaults.sbyte_class = D.19899;
      D.19900 = mono_defaults.sbyte_class;
      D.19901 = D.19900 == 0B;
      D.19902 = (long int) D.19901;
      D.19903 = __builtin_expect (D.19902, 0);
      if (D.19903 != 0) goto <D.19904>; else goto <D.19905>;
      <D.19904>:
      monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "domain.c", 1458, "mono_defaults.sbyte_class != 0");
      <D.19905>:
      D.19870 = mono_defaults.corlib;
      D.19906 = mono_class_from_name (D.19870, "System", "Int16");
      mono_defaults.int16_class = D.19906;
      D.19907 = mono_defaults.int16_class;
      D.19908 = D.19907 == 0B;
      D.19909 = (long int) D.19908;
      D.19910 = __builtin_expect (D.19909, 0);
      if (D.19910 != 0) goto <D.19911>; else goto <D.19912>;
      <D.19911>:
      monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "domain.c", 1462, "mono_defaults.int16_class != 0");
      <D.19912>:
      D.19870 = mono_defaults.corlib;
      D.19913 = mono_class_from_name (D.19870, "System", "UInt16");
      mono_defaults.uint16_class = D.19913;
      D.19914 = mono_defaults.uint16_class;
      D.19915 = D.19914 == 0B;
      D.19916 = (long int) D.19915;
      D.19917 = __builtin_expect (D.19916, 0);
      if (D.19917 != 0) goto <D.19918>; else goto <D.19919>;
      <D.19918>:
      monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "domain.c", 1466, "mono_defaults.uint16_class != 0");
      <D.19919>:
      D.19870 = mono_defaults.corlib;
      D.19920 = mono_class_from_name (D.19870, "System", "Int32");
      mono_defaults.int32_class = D.19920;
      D.19921 = mono_defaults.int32_class;
      D.19922 = D.19921 == 0B;
      D.19923 = (long int) D.19922;
      D.19924 = __builtin_expect (D.19923, 0);
      if (D.19924 != 0) goto <D.19925>; else goto <D.19926>;
      <D.19925>:
      monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "domain.c", 1470, "mono_defaults.int32_class != 0");
      <D.19926>:
      D.19870 = mono_defaults.corlib;
      D.19927 = mono_class_from_name (D.19870, "System", "UInt32");
      mono_defaults.uint32_class = D.19927;
      D.19928 = mono_defaults.uint32_class;
      D.19929 = D.19928 == 0B;
      D.19930 = (long int) D.19929;
      D.19931 = __builtin_expect (D.19930, 0);
      if (D.19931 != 0) goto <D.19932>; else goto <D.19933>;
      <D.19932>:
      monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "domain.c", 1474, "mono_defaults.uint32_class != 0");
      <D.19933>:
      D.19870 = mono_defaults.corlib;
      D.19934 = mono_class_from_name (D.19870, "System", "UIntPtr");
      mono_defaults.uint_class = D.19934;
      D.19935 = mono_defaults.uint_class;
      D.19936 = D.19935 == 0B;
      D.19937 = (long int) D.19936;
      D.19938 = __builtin_expect (D.19937, 0);
      if (D.19938 != 0) goto <D.19939>; else goto <D.19940>;
      <D.19939>:
      monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "domain.c", 1478, "mono_defaults.uint_class != 0");
      <D.19940>:
      D.19870 = mono_defaults.corlib;
      D.19941 = mono_class_from_name (D.19870, "System", "IntPtr");
      mono_defaults.int_class = D.19941;
      D.19942 = mono_defaults.int_class;
      D.19943 = D.19942 == 0B;
      D.19944 = (long int) D.19943;
      D.19945 = __builtin_expect (D.19944, 0);
      if (D.19945 != 0) goto <D.19946>; else goto <D.19947>;
      <D.19946>:
      monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "domain.c", 1482, "mono_defaults.int_class != 0");
      <D.19947>:
      D.19870 = mono_defaults.corlib;
      D.19948 = mono_class_from_name (D.19870, "System", "Int64");
      mono_defaults.int64_class = D.19948;
      D.19949 = mono_defaults.int64_class;
      D.19950 = D.19949 == 0B;
      D.19951 = (long int) D.19950;
      D.19952 = __builtin_expect (D.19951, 0);
      if (D.19952 != 0) goto <D.19953>; else goto <D.19954>;
      <D.19953>:
      monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "domain.c", 1486, "mono_defaults.int64_class != 0");
      <D.19954>:
      D.19870 = mono_defaults.corlib;
      D.19955 = mono_class_from_name (D.19870, "System", "UInt64");
      mono_defaults.uint64_class = D.19955;
      D.19956 = mono_defaults.uint64_class;
      D.19957 = D.19956 == 0B;
      D.19958 = (long int) D.19957;
      D.19959 = __builtin_expect (D.19958, 0);
      if (D.19959 != 0) goto <D.19960>; else goto <D.19961>;
      <D.19960>:
      monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "domain.c", 1490, "mono_defaults.uint64_class != 0");
      <D.19961>:
      D.19870 = mono_defaults.corlib;
      D.19962 = mono_class_from_name (D.19870, "System", "Single");
      mono_defaults.single_class = D.19962;
      D.19963 = mono_defaults.single_class;
      D.19964 = D.19963 == 0B;
      D.19965 = (long int) D.19964;
      D.19966 = __builtin_expect (D.19965, 0);
      if (D.19966 != 0) goto <D.19967>; else goto <D.19968>;
      <D.19967>:
      monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "domain.c", 1494, "mono_defaults.single_class != 0");
      <D.19968>:
      D.19870 = mono_defaults.corlib;
      D.19969 = mono_class_from_name (D.19870, "System", "Double");
      mono_defaults.double_class = D.19969;
      D.19970 = mono_defaults.double_class;
      D.19971 = D.19970 == 0B;
      D.19972 = (long int) D.19971;
      D.19973 = __builtin_expect (D.19972, 0);
      if (D.19973 != 0) goto <D.19974>; else goto <D.19975>;
      <D.19974>:
      monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "domain.c", 1498, "mono_defaults.double_class != 0");
      <D.19975>:
      D.19870 = mono_defaults.corlib;
      D.19976 = mono_class_from_name (D.19870, "System", "Char");
      mono_defaults.char_class = D.19976;
      D.19977 = mono_defaults.char_class;
      D.19978 = D.19977 == 0B;
      D.19979 = (long int) D.19978;
      D.19980 = __builtin_expect (D.19979, 0);
      if (D.19980 != 0) goto <D.19981>; else goto <D.19982>;
      <D.19981>:
      monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "domain.c", 1502, "mono_defaults.char_class != 0");
      <D.19982>:
      D.19870 = mono_defaults.corlib;
      D.19983 = mono_class_from_name (D.19870, "System", "String");
      mono_defaults.string_class = D.19983;
      D.19984 = mono_defaults.string_class;
      D.19985 = D.19984 == 0B;
      D.19986 = (long int) D.19985;
      D.19987 = __builtin_expect (D.19986, 0);
      if (D.19987 != 0) goto <D.19988>; else goto <D.19989>;
      <D.19988>:
      monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "domain.c", 1506, "mono_defaults.string_class != 0");
      <D.19989>:
      D.19870 = mono_defaults.corlib;
      D.19990 = mono_class_from_name (D.19870, "System", "Enum");
      mono_defaults.enum_class = D.19990;
      D.19991 = mono_defaults.enum_class;
      D.19992 = D.19991 == 0B;
      D.19993 = (long int) D.19992;
      D.19994 = __builtin_expect (D.19993, 0);
      if (D.19994 != 0) goto <D.19995>; else goto <D.19996>;
      <D.19995>:
      monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "domain.c", 1510, "mono_defaults.enum_class != 0");
      <D.19996>:
      D.19870 = mono_defaults.corlib;
      D.19997 = mono_class_from_name (D.19870, "System", "Array");
      mono_defaults.array_class = D.19997;
      D.19998 = mono_defaults.array_class;
      D.19999 = D.19998 == 0B;
      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", 1514, "mono_defaults.array_class != 0");
      <D.20003>:
      D.19870 = mono_defaults.corlib;
      D.20004 = mono_class_from_name (D.19870, "System", "Delegate");
      mono_defaults.delegate_class = D.20004;
      D.20005 = mono_defaults.delegate_class;
      D.20006 = D.20005 == 0B;
      D.20007 = (long int) D.20006;
      D.20008 = __builtin_expect (D.20007, 0);
      if (D.20008 != 0) goto <D.20009>; else goto <D.20010>;
      <D.20009>:
      monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "domain.c", 1518, "mono_defaults.delegate_class != 0");
      <D.20010>:
      D.19870 = mono_defaults.corlib;
      D.20011 = mono_class_from_name (D.19870, "System", "MulticastDelegate");
      mono_defaults.multicastdelegate_class = D.20011;
      D.20012 = mono_defaults.multicastdelegate_class;
      D.20013 = D.20012 == 0B;
      D.20014 = (long int) D.20013;
      D.20015 = __builtin_expect (D.20014, 0);
      if (D.20015 != 0) goto <D.20016>; else goto <D.20017>;
      <D.20016>:
      monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "domain.c", 1522, "mono_defaults.multicastdelegate_class != 0");
      <D.20017>:
      D.19870 = mono_defaults.corlib;
      D.20018 = mono_class_from_name (D.19870, "System.Runtime.Remoting.Messaging", "AsyncResult");
      mono_defaults.asyncresult_class = D.20018;
      D.20019 = mono_defaults.asyncresult_class;
      D.20020 = D.20019 == 0B;
      D.20021 = (long int) D.20020;
      D.20022 = __builtin_expect (D.20021, 0);
      if (D.20022 != 0) goto <D.20023>; else goto <D.20024>;
      <D.20023>:
      monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "domain.c", 1527, "mono_defaults.asyncresult_class != 0");
      <D.20024>:
      D.19870 = mono_defaults.corlib;
      D.20025 = mono_class_from_name (D.19870, "System.Threading", "ManualResetEvent");
      mono_defaults.manualresetevent_class = D.20025;
      D.20026 = mono_defaults.manualresetevent_class;
      D.20027 = D.20026 == 0B;
      D.20028 = (long int) D.20027;
      D.20029 = __builtin_expect (D.20028, 0);
      if (D.20029 != 0) goto <D.20030>; else goto <D.20031>;
      <D.20030>:
      monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "domain.c", 1531, "mono_defaults.manualresetevent_class != 0");
      <D.20031>:
      D.19870 = mono_defaults.corlib;
      D.20032 = mono_class_from_name (D.19870, "System", "RuntimeTypeHandle");
      mono_defaults.typehandle_class = D.20032;
      D.20033 = mono_defaults.typehandle_class;
      D.20034 = D.20033 == 0B;
      D.20035 = (long int) D.20034;
      D.20036 = __builtin_expect (D.20035, 0);
      if (D.20036 != 0) goto <D.20037>; else goto <D.20038>;
      <D.20037>:
      monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "domain.c", 1535, "mono_defaults.typehandle_class != 0");
      <D.20038>:
      D.19870 = mono_defaults.corlib;
      D.20039 = mono_class_from_name (D.19870, "System", "RuntimeMethodHandle");
      mono_defaults.methodhandle_class = D.20039;
      D.20040 = mono_defaults.methodhandle_class;
      D.20041 = D.20040 == 0B;
      D.20042 = (long int) D.20041;
      D.20043 = __builtin_expect (D.20042, 0);
      if (D.20043 != 0) goto <D.20044>; else goto <D.20045>;
      <D.20044>:
      monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "domain.c", 1539, "mono_defaults.methodhandle_class != 0");
      <D.20045>:
      D.19870 = mono_defaults.corlib;
      D.20046 = mono_class_from_name (D.19870, "System", "RuntimeFieldHandle");
      mono_defaults.fieldhandle_class = D.20046;
      D.20047 = mono_defaults.fieldhandle_class;
      D.20048 = D.20047 == 0B;
      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", 1543, "mono_defaults.fieldhandle_class != 0");
      <D.20052>:
      D.19870 = mono_defaults.corlib;
      D.20053 = mono_class_from_name (D.19870, "System", "Type");
      mono_defaults.systemtype_class = D.20053;
      D.20054 = mono_defaults.systemtype_class;
      D.20055 = D.20054 == 0B;
      D.20056 = (long int) D.20055;
      D.20057 = __builtin_expect (D.20056, 0);
      if (D.20057 != 0) goto <D.20058>; else goto <D.20059>;
      <D.20058>:
      monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "domain.c", 1547, "mono_defaults.systemtype_class != 0");
      <D.20059>:
      D.19870 = mono_defaults.corlib;
      D.20060 = mono_class_from_name (D.19870, "System", "MonoType");
      mono_defaults.monotype_class = D.20060;
      D.20061 = mono_defaults.monotype_class;
      D.20062 = D.20061 == 0B;
      D.20063 = (long int) D.20062;
      D.20064 = __builtin_expect (D.20063, 0);
      if (D.20064 != 0) goto <D.20065>; else goto <D.20066>;
      <D.20065>:
      monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "domain.c", 1551, "mono_defaults.monotype_class != 0");
      <D.20066>:
      D.19870 = mono_defaults.corlib;
      D.20067 = mono_class_from_name (D.19870, "System", "Exception");
      mono_defaults.exception_class = D.20067;
      D.20068 = mono_defaults.exception_class;
      D.20069 = D.20068 == 0B;
      D.20070 = (long int) D.20069;
      D.20071 = __builtin_expect (D.20070, 0);
      if (D.20071 != 0) goto <D.20072>; else goto <D.20073>;
      <D.20072>:
      monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "domain.c", 1555, "mono_defaults.exception_class != 0");
      <D.20073>:
      D.19870 = mono_defaults.corlib;
      D.20074 = mono_class_from_name (D.19870, "System.Threading", "ThreadAbortException");
      mono_defaults.threadabortexception_class = D.20074;
      D.20075 = mono_defaults.threadabortexception_class;
      D.20076 = D.20075 == 0B;
      D.20077 = (long int) D.20076;
      D.20078 = __builtin_expect (D.20077, 0);
      if (D.20078 != 0) goto <D.20079>; else goto <D.20080>;
      <D.20079>:
      monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "domain.c", 1559, "mono_defaults.threadabortexception_class != 0");
      <D.20080>:
      D.19870 = mono_defaults.corlib;
      D.20081 = mono_class_from_name (D.19870, "System.Threading", "Thread");
      mono_defaults.thread_class = D.20081;
      D.20082 = mono_defaults.thread_class;
      D.20083 = D.20082 == 0B;
      D.20084 = (long int) D.20083;
      D.20085 = __builtin_expect (D.20084, 0);
      if (D.20085 != 0) goto <D.20086>; else goto <D.20087>;
      <D.20086>:
      monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "domain.c", 1563, "mono_defaults.thread_class != 0");
      <D.20087>:
      D.19870 = mono_defaults.corlib;
      D.20088 = mono_class_from_name (D.19870, "System.Threading", "InternalThread");
      mono_defaults.internal_thread_class = D.20088;
      D.20089 = mono_defaults.internal_thread_class;
      if (D.20089 == 0B) goto <D.20090>; else goto <D.20091>;
      <D.20090>:
      stderr.29 = stderr;
      fprintf (stderr.29, "Corlib too old for this runtime.\n");
      stderr.29 = stderr;
      D.19870 = mono_defaults.corlib;
      if (D.19870 != 0B) goto <D.20094>; else goto <D.20095>;
      <D.20094>:
      D.19870 = mono_defaults.corlib;
      iftmp.30 = mono_image_get_filename (D.19870);
      goto <D.20096>;
      <D.20095>:
      iftmp.30 = "unknown";
      <D.20096>:
      fprintf (stderr.29, "Loaded from: %s\n", iftmp.30);
      exit (1);
      <D.20091>:
      D.19870 = mono_defaults.corlib;
      D.20097 = mono_class_from_name (D.19870, "System", "AppDomain");
      mono_defaults.appdomain_class = D.20097;
      D.20098 = mono_defaults.appdomain_class;
      D.20099 = D.20098 == 0B;
      D.20100 = (long int) D.20099;
      D.20101 = __builtin_expect (D.20100, 0);
      if (D.20101 != 0) goto <D.20102>; else goto <D.20103>;
      <D.20102>:
      monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "domain.c", 1577, "mono_defaults.appdomain_class != 0");
      <D.20103>:
      D.19870 = mono_defaults.corlib;
      D.20104 = mono_class_from_name (D.19870, "System.Runtime.Remoting.Proxies", "TransparentProxy");
      mono_defaults.transparent_proxy_class = D.20104;
      D.20105 = mono_defaults.transparent_proxy_class;
      D.20106 = D.20105 == 0B;
      D.20107 = (long int) D.20106;
      D.20108 = __builtin_expect (D.20107, 0);
      if (D.20108 != 0) goto <D.20109>; else goto <D.20110>;
      <D.20109>:
      monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "domain.c", 1582, "mono_defaults.transparent_proxy_class != 0");
      <D.20110>:
      D.19870 = mono_defaults.corlib;
      D.20111 = mono_class_from_name (D.19870, "System.Runtime.Remoting.Proxies", "RealProxy");
      mono_defaults.real_proxy_class = D.20111;
      D.20112 = mono_defaults.real_proxy_class;
      D.20113 = D.20112 == 0B;
      D.20114 = (long int) D.20113;
      D.20115 = __builtin_expect (D.20114, 0);
      if (D.20115 != 0) goto <D.20116>; else goto <D.20117>;
      <D.20116>:
      monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "domain.c", 1586, "mono_defaults.real_proxy_class != 0");
      <D.20117>:
      D.19870 = mono_defaults.corlib;
      D.20118 = mono_class_from_name (D.19870, "System", "MarshalByRefObject");
      mono_defaults.marshalbyrefobject_class = D.20118;
      D.20119 = mono_defaults.marshalbyrefobject_class;
      D.20120 = D.20119 == 0B;
      D.20121 = (long int) D.20120;
      D.20122 = __builtin_expect (D.20121, 0);
      if (D.20122 != 0) goto <D.20123>; else goto <D.20124>;
      <D.20123>:
      monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "domain.c", 1590, "mono_defaults.marshalbyrefobject_class != 0");
      <D.20124>:
      D.19870 = mono_defaults.corlib;
      D.20125 = mono_class_from_name (D.19870, "System.Runtime.Remoting", "IRemotingTypeInfo");
      mono_defaults.iremotingtypeinfo_class = D.20125;
      D.20126 = mono_defaults.iremotingtypeinfo_class;
      D.20127 = D.20126 == 0B;
      D.20128 = (long int) D.20127;
      D.20129 = __builtin_expect (D.20128, 0);
      if (D.20129 != 0) goto <D.20130>; else goto <D.20131>;
      <D.20130>:
      monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "domain.c", 1594, "mono_defaults.iremotingtypeinfo_class != 0");
      <D.20131>:
      D.19870 = mono_defaults.corlib;
      D.20132 = mono_class_from_name (D.19870, "System.Runtime.Remoting.Messaging", "MonoMethodMessage");
      mono_defaults.mono_method_message_class = D.20132;
      D.20133 = mono_defaults.mono_method_message_class;
      D.20134 = D.20133 == 0B;
      D.20135 = (long int) D.20134;
      D.20136 = __builtin_expect (D.20135, 0);
      if (D.20136 != 0) goto <D.20137>; else goto <D.20138>;
      <D.20137>:
      monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "domain.c", 1599, "mono_defaults.mono_method_message_class != 0");
      <D.20138>:
      D.19870 = mono_defaults.corlib;
      D.20139 = mono_class_from_name (D.19870, "System.Reflection", "FieldInfo");
      mono_defaults.field_info_class = D.20139;
      D.20140 = mono_defaults.field_info_class;
      D.20141 = D.20140 == 0B;
      D.20142 = (long int) D.20141;
      D.20143 = __builtin_expect (D.20142, 0);
      if (D.20143 != 0) goto <D.20144>; else goto <D.20145>;
      <D.20144>:
      monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "domain.c", 1603, "mono_defaults.field_info_class != 0");
      <D.20145>:
      D.19870 = mono_defaults.corlib;
      D.20146 = mono_class_from_name (D.19870, "System.Reflection", "MethodInfo");
      mono_defaults.method_info_class = D.20146;
      D.20147 = mono_defaults.method_info_class;
      D.20148 = D.20147 == 0B;
      D.20149 = (long int) D.20148;
      D.20150 = __builtin_expect (D.20149, 0);
      if (D.20150 != 0) goto <D.20151>; else goto <D.20152>;
      <D.20151>:
      monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "domain.c", 1607, "mono_defaults.method_info_class != 0");
      <D.20152>:
      D.19870 = mono_defaults.corlib;
      D.20153 = mono_class_from_name (D.19870, "System.Text", "StringBuilder");
      mono_defaults.stringbuilder_class = D.20153;
      D.20154 = mono_defaults.stringbuilder_class;
      D.20155 = D.20154 == 0B;
      D.20156 = (long int) D.20155;
      D.20157 = __builtin_expect (D.20156, 0);
      if (D.20157 != 0) goto <D.20158>; else goto <D.20159>;
      <D.20158>:
      monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "domain.c", 1611, "mono_defaults.stringbuilder_class != 0");
      <D.20159>:
      D.19870 = mono_defaults.corlib;
      D.20160 = mono_class_from_name (D.19870, "System", "Math");
      mono_defaults.math_class = D.20160;
      D.20161 = mono_defaults.math_class;
      D.20162 = D.20161 == 0B;
      D.20163 = (long int) D.20162;
      D.20164 = __builtin_expect (D.20163, 0);
      if (D.20164 != 0) goto <D.20165>; else goto <D.20166>;
      <D.20165>:
      monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "domain.c", 1615, "mono_defaults.math_class != 0");
      <D.20166>:
      D.19870 = mono_defaults.corlib;
      D.20167 = mono_class_from_name (D.19870, "System.Diagnostics", "StackFrame");
      mono_defaults.stack_frame_class = D.20167;
      D.20168 = mono_defaults.stack_frame_class;
      D.20169 = D.20168 == 0B;
      D.20170 = (long int) D.20169;
      D.20171 = __builtin_expect (D.20170, 0);
      if (D.20171 != 0) goto <D.20172>; else goto <D.20173>;
      <D.20172>:
      monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "domain.c", 1619, "mono_defaults.stack_frame_class != 0");
      <D.20173>:
      D.19870 = mono_defaults.corlib;
      D.20174 = mono_class_from_name (D.19870, "System.Diagnostics", "StackTrace");
      mono_defaults.stack_trace_class = D.20174;
      D.20175 = mono_defaults.stack_trace_class;
      D.20176 = D.20175 == 0B;
      D.20177 = (long int) D.20176;
      D.20178 = __builtin_expect (D.20177, 0);
      if (D.20178 != 0) goto <D.20179>; else goto <D.20180>;
      <D.20179>:
      monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "domain.c", 1623, "mono_defaults.stack_trace_class != 0");
      <D.20180>:
      D.19870 = mono_defaults.corlib;
      D.20181 = mono_class_from_name (D.19870, "System.Runtime.InteropServices", "Marshal");
      mono_defaults.marshal_class = D.20181;
      D.20182 = mono_defaults.marshal_class;
      D.20183 = D.20182 == 0B;
      D.20184 = (long int) D.20183;
      D.20185 = __builtin_expect (D.20184, 0);
      if (D.20185 != 0) goto <D.20186>; else goto <D.20187>;
      <D.20186>:
      monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "domain.c", 1627, "mono_defaults.marshal_class != 0");
      <D.20187>:
      D.19870 = mono_defaults.corlib;
      D.20188 = mono_class_from_name (D.19870, "System", "TypedReference");
      mono_defaults.typed_reference_class = D.20188;
      D.20189 = mono_defaults.typed_reference_class;
      D.20190 = D.20189 == 0B;
      D.20191 = (long int) D.20190;
      D.20192 = __builtin_expect (D.20191, 0);
      if (D.20192 != 0) goto <D.20193>; else goto <D.20194>;
      <D.20193>:
      monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "domain.c", 1631, "mono_defaults.typed_reference_class != 0");
      <D.20194>:
      D.19870 = mono_defaults.corlib;
      D.20195 = mono_class_from_name (D.19870, "System", "RuntimeArgumentHandle");
      mono_defaults.argumenthandle_class = D.20195;
      D.20196 = mono_defaults.argumenthandle_class;
      D.20197 = D.20196 == 0B;
      D.20198 = (long int) D.20197;
      D.20199 = __builtin_expect (D.20198, 0);
      if (D.20199 != 0) goto <D.20200>; else goto <D.20201>;
      <D.20200>:
      monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "domain.c", 1635, "mono_defaults.argumenthandle_class != 0");
      <D.20201>:
      D.19870 = mono_defaults.corlib;
      D.20202 = mono_class_from_name (D.19870, "System.Threading", "Monitor");
      mono_defaults.monitor_class = D.20202;
      D.20203 = mono_defaults.monitor_class;
      D.20204 = D.20203 == 0B;
      D.20205 = (long int) D.20204;
      D.20206 = __builtin_expect (D.20205, 0);
      if (D.20206 != 0) goto <D.20207>; else goto <D.20208>;
      <D.20207>:
      monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "domain.c", 1639, "mono_defaults.monitor_class != 0");
      <D.20208>:
      D.19870 = mono_defaults.corlib;
      D.20209 = mono_class_from_name (D.19870, "System.Security", "RuntimeSecurityFrame");
      mono_defaults.runtimesecurityframe_class = D.20209;
      D.19870 = mono_defaults.corlib;
      D.20210 = mono_class_from_name (D.19870, "System.Threading", "ExecutionContext");
      mono_defaults.executioncontext_class = D.20210;
      D.19870 = mono_defaults.corlib;
      D.20211 = mono_class_from_name (D.19870, "System.Runtime.CompilerServices", "InternalsVisibleToAttribute");
      mono_defaults.internals_visible_class = D.20211;
      D.19870 = mono_defaults.corlib;
      D.20212 = mono_class_from_name (D.19870, "System.Runtime.ConstrainedExecution", "CriticalFinalizerObject");
      mono_defaults.critical_finalizer_object = D.20212;
      mono_assembly_load_friends (ass);
      D.19870 = mono_defaults.corlib;
      D.20213 = mono_class_from_name (D.19870, "System.Runtime.InteropServices", "SafeHandle");
      mono_defaults.safehandle_class = D.20213;
      D.19870 = mono_defaults.corlib;
      D.20214 = mono_class_from_name (D.19870, "System.Runtime.InteropServices", "HandleRef");
      mono_defaults.handleref_class = D.20214;
      D.19870 = mono_defaults.corlib;
      D.20215 = mono_class_from_name (D.19870, "System", "Attribute");
      mono_defaults.attribute_class = D.20215;
      D.19870 = mono_defaults.corlib;
      D.20216 = mono_class_from_name (D.19870, "System.Reflection", "CustomAttributeData");
      mono_defaults.customattribute_data_class = D.20216;
      D.19998 = mono_defaults.array_class;
      mono_class_init (D.19998);
      D.19870 = mono_defaults.corlib;
      D.20217 = mono_class_from_name (D.19870, "System", "Nullable`1");
      mono_defaults.generic_nullable_class = D.20217;
      D.19870 = mono_defaults.corlib;
      D.20218 = mono_class_from_name (D.19870, "System.Collections.Generic", "IList`1");
      mono_defaults.generic_ilist_class = D.20218;
      D.19870 = mono_defaults.corlib;
      D.20219 = mono_class_from_name (D.19870, "System.Collections.Generic", "IReadOnlyList`1");
      mono_defaults.generic_ireadonlylist_class = D.20219;
      domain.23 = domain;
      D.20220 = monoeg_g_path_get_basename (filename);
      domain.23->friendly_name = D.20220;
      domain.23 = domain;
      _mono_debug_init_corlib (domain.23);
      D.20221 = domain;
      return D.20221;
    }
  finally
    {
      status = {CLOBBER};
      runtimes = {CLOBBER};
    }
}


mono_native_tls_alloc (pthread_key_t * key, void * destructor)
{
  int D.20224;
  void (*<Tbf>) (void *) destructor.31;
  int D.20226;
  _Bool D.20227;

  destructor.31 = (void (*<Tbf>) (void *)) destructor;
  D.20226 = pthread_key_create (key, destructor.31);
  D.20227 = D.20226 == 0;
  D.20224 = (int) D.20227;
  return D.20224;
}


mono_native_tls_set_value (pthread_key_t key, void * value)
{
  int D.20229;
  int D.20230;
  _Bool D.20231;

  D.20230 = pthread_setspecific (key, value);
  D.20231 = D.20230 == 0;
  D.20229 = (int) D.20231;
  return D.20229;
}


get_runtimes_from_exe (const char * exe_file, struct MonoImage * * exe_image, const struct MonoRuntimeInfo * * runtimes)
{
  struct GSList * D.20235;
  int n.32;
  long unsigned int D.20241;
  long unsigned int D.20242;
  const struct MonoRuntimeInfo * * D.20243;
  struct GSList * iftmp.33;
  long unsigned int D.20248;
  long unsigned int D.20249;
  const struct MonoRuntimeInfo * * D.20250;
  char * D.20251;
  const struct MonoRuntimeInfo * D.20254;
  const struct MonoRuntimeInfo * * D.20255;
  const struct MonoRuntimeInfo * D.20260;
  char * D.20261;
  const struct MonoRuntimeInfo * D.20262;
  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.20233>; else goto <D.20234>;
  <D.20233>:
  D.20235 = app_config->supported_runtimes;
  if (D.20235 != 0B) goto <D.20236>; else goto <D.20237>;
  <D.20236>:
  {
    int n;
    struct GSList * list;

    n = 0;
    list = app_config->supported_runtimes;
    goto <D.19116>;
    <D.19115>:
    version = list->data;
    runtime = get_runtime_by_version (version);
    if (runtime != 0B) goto <D.20238>; else goto <D.20239>;
    <D.20238>:
    n.32 = n;
    n = n.32 + 1;
    D.20241 = (long unsigned int) n.32;
    D.20242 = D.20241 * 8;
    D.20243 = runtimes + D.20242;
    *D.20243 = runtime;
    <D.20239>:
    if (list != 0B) goto <D.20245>; else goto <D.20246>;
    <D.20245>:
    iftmp.33 = list->next;
    goto <D.20247>;
    <D.20246>:
    iftmp.33 = 0B;
    <D.20247>:
    list = iftmp.33;
    <D.19116>:
    if (list != 0B) goto <D.19115>; else goto <D.19117>;
    <D.19117>:
    D.20248 = (long unsigned int) n;
    D.20249 = D.20248 * 8;
    D.20250 = runtimes + D.20249;
    *D.20250 = 0B;
    app_config_free (app_config);
    return;
  }
  <D.20237>:
  D.20251 = app_config->required_runtime;
  if (D.20251 != 0B) goto <D.20252>; else goto <D.20253>;
  <D.20252>:
  D.20251 = app_config->required_runtime;
  D.20254 = get_runtime_by_version (D.20251);
  *runtimes = D.20254;
  D.20255 = runtimes + 8;
  *D.20255 = 0B;
  app_config_free (app_config);
  return;
  <D.20253>:
  app_config_free (app_config);
  <D.20234>:
  image = mono_assembly_open_from_bundle (exe_file, 0B, 0);
  if (image == 0B) goto <D.20256>; else goto <D.20257>;
  <D.20256>:
  image = mono_image_open (exe_file, 0B);
  <D.20257>:
  if (image == 0B) goto <D.20258>; else goto <D.20259>;
  <D.20258>:
  D.20260 = get_runtime_by_version ("v2.0.50727");
  *runtimes = D.20260;
  D.20255 = runtimes + 8;
  *D.20255 = 0B;
  return;
  <D.20259>:
  *exe_image = image;
  D.20261 = image->version;
  D.20262 = get_runtime_by_version (D.20261);
  *runtimes = D.20262;
  D.20255 = runtimes + 8;
  *D.20255 = 0B;
}


app_config_parse (const char * exe_filename)
{
  gchar * text.34;
  char * text.35;
  long unsigned int len.36;
  int D.20270;
  struct AppConfigInfo * D.20273;
  long unsigned int len.37;
  long int len.38;
  int D.20276;
  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.20264>; else goto <D.20265>;
      <D.20264>:
      text.34 = monoeg_strdup (bundled_config);
      text = text.34;
      text.35 = text;
      len.36 = strlen (text.35);
      len = len.36;
      goto <D.20269>;
      <D.20265>:
      config_filename = monoeg_g_strconcat (exe_filename, ".config", 0B);
      D.20270 = monoeg_g_file_get_contents (config_filename, &text, &len, 0B);
      if (D.20270 == 0) goto <D.20271>; else goto <D.20272>;
      <D.20271>:
      monoeg_g_free (config_filename);
      D.20273 = 0B;
      return D.20273;
      <D.20272>:
      monoeg_g_free (config_filename);
      <D.20269>:
      app_config = monoeg_malloc0 (24);
      context = monoeg_g_markup_parse_context_new (&mono_parser, 0, app_config, 0B);
      text.35 = text;
      len.37 = len;
      len.38 = (long int) len.37;
      D.20276 = monoeg_g_markup_parse_context_parse (context, text.35, len.38, 0B);
      if (D.20276 != 0) goto <D.20277>; else goto <D.20278>;
      <D.20277>:
      monoeg_g_markup_parse_context_end_parse (context, 0B);
      <D.20278>:
      monoeg_g_markup_parse_context_free (context);
      text.35 = text;
      monoeg_g_free (text.35);
      D.20273 = app_config;
      return D.20273;
    }
  finally
    {
      text = {CLOBBER};
      len = {CLOBBER};
    }
}


end_element (struct GMarkupParseContext * context, const gchar * element_name, void * user_data, struct GError * * error)
{
  int D.19046;
  int iftmp.39;
  int D.19045;
  const char[14] * D.20284;
  unsigned char D.20285;
  int D.20286;
  unsigned char D.20287;
  int D.20288;
  const unsigned char * D.20293;
  unsigned char D.20294;
  int D.20295;
  const unsigned char * D.20296;
  unsigned char D.20297;
  int D.20298;
  const unsigned char * D.20303;
  unsigned char D.20304;
  int D.20305;
  const unsigned char * D.20306;
  unsigned char D.20307;
  int D.20308;
  const unsigned char * D.20313;
  unsigned char D.20314;
  int D.20315;
  const unsigned char * D.20316;
  unsigned char D.20317;
  int D.20318;
  int D.20322;
  int D.20323;
  int D.19055;
  int iftmp.40;
  int D.19054;
  const char[8] * D.20328;
  unsigned char D.20329;
  int D.20330;
  unsigned char D.20331;
  int D.20332;
  const unsigned char * D.20337;
  unsigned char D.20338;
  int D.20339;
  const unsigned char * D.20340;
  unsigned char D.20341;
  int D.20342;
  const unsigned char * D.20347;
  unsigned char D.20348;
  int D.20349;
  const unsigned char * D.20350;
  unsigned char D.20351;
  int D.20352;
  const unsigned char * D.20357;
  unsigned char D.20358;
  int D.20359;
  const unsigned char * D.20360;
  unsigned char D.20361;
  int D.20362;
  int D.20366;
  int D.20367;
  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.20282>; else goto <D.20283>;
    <D.20282>:
    {
      const unsigned char * __s2;
      int __result;

      __s2 = element_name;
      D.20284 = "configuration";
      D.20285 = MEM[(const unsigned char *)D.20284];
      D.20286 = (int) D.20285;
      D.20287 = *__s2;
      D.20288 = (int) D.20287;
      __result = D.20286 - D.20288;
      {
        if (__s2_len != 0) goto <D.20289>; else goto <D.20290>;
        <D.20289>:
        if (__result == 0) goto <D.20291>; else goto <D.20292>;
        <D.20291>:
        D.20293 = &MEM[(void *)"configuration" + 1B];
        D.20294 = *D.20293;
        D.20295 = (int) D.20294;
        D.20296 = __s2 + 1;
        D.20297 = *D.20296;
        D.20298 = (int) D.20297;
        __result = D.20295 - D.20298;
        if (__s2_len > 1) goto <D.20299>; else goto <D.20300>;
        <D.20299>:
        if (__result == 0) goto <D.20301>; else goto <D.20302>;
        <D.20301>:
        D.20303 = &MEM[(void *)"configuration" + 2B];
        D.20304 = *D.20303;
        D.20305 = (int) D.20304;
        D.20306 = __s2 + 2;
        D.20307 = *D.20306;
        D.20308 = (int) D.20307;
        __result = D.20305 - D.20308;
        if (__s2_len > 2) goto <D.20309>; else goto <D.20310>;
        <D.20309>:
        if (__result == 0) goto <D.20311>; else goto <D.20312>;
        <D.20311>:
        D.20313 = &MEM[(void *)"configuration" + 3B];
        D.20314 = *D.20313;
        D.20315 = (int) D.20314;
        D.20316 = __s2 + 3;
        D.20317 = *D.20316;
        D.20318 = (int) D.20317;
        __result = D.20315 - D.20318;
        <D.20312>:
        <D.20310>:
        <D.20302>:
        <D.20300>:
        <D.20292>:
        <D.20290>:
      }
      D.19045 = __result;
    }
    iftmp.39 = -D.19045;
    goto <D.20319>;
    <D.20283>:
    iftmp.39 = __builtin_strcmp (element_name, "configuration");
    <D.20319>:
    D.19046 = iftmp.39;
  }
  if (D.19046 == 0) goto <D.20320>; else goto <D.20321>;
  <D.20320>:
  D.20322 = app_config->configuration_count;
  D.20323 = D.20322 + -1;
  app_config->configuration_count = D.20323;
  goto <D.20324>;
  <D.20321>:
  {
    size_t __s1_len;
    size_t __s2_len;

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

      __s2 = element_name;
      D.20328 = "startup";
      D.20329 = MEM[(const unsigned char *)D.20328];
      D.20330 = (int) D.20329;
      D.20331 = *__s2;
      D.20332 = (int) D.20331;
      __result = D.20330 - D.20332;
      {
        if (__s2_len != 0) goto <D.20333>; else goto <D.20334>;
        <D.20333>:
        if (__result == 0) goto <D.20335>; else goto <D.20336>;
        <D.20335>:
        D.20337 = &MEM[(void *)"startup" + 1B];
        D.20338 = *D.20337;
        D.20339 = (int) D.20338;
        D.20340 = __s2 + 1;
        D.20341 = *D.20340;
        D.20342 = (int) D.20341;
        __result = D.20339 - D.20342;
        if (__s2_len > 1) goto <D.20343>; else goto <D.20344>;
        <D.20343>:
        if (__result == 0) goto <D.20345>; else goto <D.20346>;
        <D.20345>:
        D.20347 = &MEM[(void *)"startup" + 2B];
        D.20348 = *D.20347;
        D.20349 = (int) D.20348;
        D.20350 = __s2 + 2;
        D.20351 = *D.20350;
        D.20352 = (int) D.20351;
        __result = D.20349 - D.20352;
        if (__s2_len > 2) goto <D.20353>; else goto <D.20354>;
        <D.20353>:
        if (__result == 0) goto <D.20355>; else goto <D.20356>;
        <D.20355>:
        D.20357 = &MEM[(void *)"startup" + 3B];
        D.20358 = *D.20357;
        D.20359 = (int) D.20358;
        D.20360 = __s2 + 3;
        D.20361 = *D.20360;
        D.20362 = (int) D.20361;
        __result = D.20359 - D.20362;
        <D.20356>:
        <D.20354>:
        <D.20346>:
        <D.20344>:
        <D.20336>:
        <D.20334>:
      }
      D.19054 = __result;
    }
    iftmp.40 = -D.19054;
    goto <D.20363>;
    <D.20327>:
    iftmp.40 = __builtin_strcmp (element_name, "startup");
    <D.20363>:
    D.19055 = iftmp.40;
  }
  if (D.19055 == 0) goto <D.20364>; else goto <D.20365>;
  <D.20364>:
  D.20366 = app_config->startup_count;
  D.20367 = D.20366 + -1;
  app_config->startup_count = D.20367;
  <D.20365>:
  <D.20324>:
}


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.19002;
  int iftmp.41;
  int D.19001;
  const char[14] * D.20371;
  unsigned char D.20372;
  int D.20373;
  unsigned char D.20374;
  int D.20375;
  const unsigned char * D.20380;
  unsigned char D.20381;
  int D.20382;
  const unsigned char * D.20383;
  unsigned char D.20384;
  int D.20385;
  const unsigned char * D.20390;
  unsigned char D.20391;
  int D.20392;
  const unsigned char * D.20393;
  unsigned char D.20394;
  int D.20395;
  const unsigned char * D.20400;
  unsigned char D.20401;
  int D.20402;
  const unsigned char * D.20403;
  unsigned char D.20404;
  int D.20405;
  int D.20409;
  int D.20410;
  int D.19011;
  int iftmp.42;
  int D.19010;
  const char[8] * D.20414;
  unsigned char D.20415;
  int D.20416;
  unsigned char D.20417;
  int D.20418;
  const unsigned char * D.20423;
  unsigned char D.20424;
  int D.20425;
  const unsigned char * D.20426;
  unsigned char D.20427;
  int D.20428;
  const unsigned char * D.20433;
  unsigned char D.20434;
  int D.20435;
  const unsigned char * D.20436;
  unsigned char D.20437;
  int D.20438;
  const unsigned char * D.20443;
  unsigned char D.20444;
  int D.20445;
  const unsigned char * D.20446;
  unsigned char D.20447;
  int D.20448;
  int D.20452;
  int D.20453;
  signed long D.20454;
  long unsigned int D.20455;
  long unsigned int D.20456;
  int D.19020;
  int iftmp.43;
  int D.19019;
  const char[16] * D.20462;
  unsigned char D.20463;
  int D.20464;
  unsigned char D.20465;
  int D.20466;
  const unsigned char * D.20471;
  unsigned char D.20472;
  int D.20473;
  const unsigned char * D.20474;
  unsigned char D.20475;
  int D.20476;
  const unsigned char * D.20481;
  unsigned char D.20482;
  int D.20483;
  const unsigned char * D.20484;
  unsigned char D.20485;
  int D.20486;
  const unsigned char * D.20491;
  unsigned char D.20492;
  int D.20493;
  const unsigned char * D.20494;
  unsigned char D.20495;
  int D.20496;
  char * D.20500;
  int D.19029;
  int iftmp.44;
  int D.19028;
  const char[17] * D.20505;
  unsigned char D.20506;
  int D.20507;
  unsigned char D.20508;
  int D.20509;
  const unsigned char * D.20514;
  unsigned char D.20515;
  int D.20516;
  const unsigned char * D.20517;
  unsigned char D.20518;
  int D.20519;
  const unsigned char * D.20524;
  unsigned char D.20525;
  int D.20526;
  const unsigned char * D.20527;
  unsigned char D.20528;
  int D.20529;
  const unsigned char * D.20534;
  unsigned char D.20535;
  int D.20536;
  const unsigned char * D.20537;
  unsigned char D.20538;
  int D.20539;
  struct GSList * D.20543;
  struct GSList * D.20544;
  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.20369>; else goto <D.20370>;
    <D.20369>:
    {
      const unsigned char * __s2;
      int __result;

      __s2 = element_name;
      D.20371 = "configuration";
      D.20372 = MEM[(const unsigned char *)D.20371];
      D.20373 = (int) D.20372;
      D.20374 = *__s2;
      D.20375 = (int) D.20374;
      __result = D.20373 - D.20375;
      {
        if (__s2_len != 0) goto <D.20376>; else goto <D.20377>;
        <D.20376>:
        if (__result == 0) goto <D.20378>; else goto <D.20379>;
        <D.20378>:
        D.20380 = &MEM[(void *)"configuration" + 1B];
        D.20381 = *D.20380;
        D.20382 = (int) D.20381;
        D.20383 = __s2 + 1;
        D.20384 = *D.20383;
        D.20385 = (int) D.20384;
        __result = D.20382 - D.20385;
        if (__s2_len > 1) goto <D.20386>; else goto <D.20387>;
        <D.20386>:
        if (__result == 0) goto <D.20388>; else goto <D.20389>;
        <D.20388>:
        D.20390 = &MEM[(void *)"configuration" + 2B];
        D.20391 = *D.20390;
        D.20392 = (int) D.20391;
        D.20393 = __s2 + 2;
        D.20394 = *D.20393;
        D.20395 = (int) D.20394;
        __result = D.20392 - D.20395;
        if (__s2_len > 2) goto <D.20396>; else goto <D.20397>;
        <D.20396>:
        if (__result == 0) goto <D.20398>; else goto <D.20399>;
        <D.20398>:
        D.20400 = &MEM[(void *)"configuration" + 3B];
        D.20401 = *D.20400;
        D.20402 = (int) D.20401;
        D.20403 = __s2 + 3;
        D.20404 = *D.20403;
        D.20405 = (int) D.20404;
        __result = D.20402 - D.20405;
        <D.20399>:
        <D.20397>:
        <D.20389>:
        <D.20387>:
        <D.20379>:
        <D.20377>:
      }
      D.19001 = __result;
    }
    iftmp.41 = -D.19001;
    goto <D.20406>;
    <D.20370>:
    iftmp.41 = __builtin_strcmp (element_name, "configuration");
    <D.20406>:
    D.19002 = iftmp.41;
  }
  if (D.19002 == 0) goto <D.20407>; else goto <D.20408>;
  <D.20407>:
  D.20409 = app_config->configuration_count;
  D.20410 = D.20409 + 1;
  app_config->configuration_count = D.20410;
  return;
  <D.20408>:
  {
    size_t __s1_len;
    size_t __s2_len;

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

      __s2 = element_name;
      D.20414 = "startup";
      D.20415 = MEM[(const unsigned char *)D.20414];
      D.20416 = (int) D.20415;
      D.20417 = *__s2;
      D.20418 = (int) D.20417;
      __result = D.20416 - D.20418;
      {
        if (__s2_len != 0) goto <D.20419>; else goto <D.20420>;
        <D.20419>:
        if (__result == 0) goto <D.20421>; else goto <D.20422>;
        <D.20421>:
        D.20423 = &MEM[(void *)"startup" + 1B];
        D.20424 = *D.20423;
        D.20425 = (int) D.20424;
        D.20426 = __s2 + 1;
        D.20427 = *D.20426;
        D.20428 = (int) D.20427;
        __result = D.20425 - D.20428;
        if (__s2_len > 1) goto <D.20429>; else goto <D.20430>;
        <D.20429>:
        if (__result == 0) goto <D.20431>; else goto <D.20432>;
        <D.20431>:
        D.20433 = &MEM[(void *)"startup" + 2B];
        D.20434 = *D.20433;
        D.20435 = (int) D.20434;
        D.20436 = __s2 + 2;
        D.20437 = *D.20436;
        D.20438 = (int) D.20437;
        __result = D.20435 - D.20438;
        if (__s2_len > 2) goto <D.20439>; else goto <D.20440>;
        <D.20439>:
        if (__result == 0) goto <D.20441>; else goto <D.20442>;
        <D.20441>:
        D.20443 = &MEM[(void *)"startup" + 3B];
        D.20444 = *D.20443;
        D.20445 = (int) D.20444;
        D.20446 = __s2 + 3;
        D.20447 = *D.20446;
        D.20448 = (int) D.20447;
        __result = D.20445 - D.20448;
        <D.20442>:
        <D.20440>:
        <D.20432>:
        <D.20430>:
        <D.20422>:
        <D.20420>:
      }
      D.19010 = __result;
    }
    iftmp.42 = -D.19010;
    goto <D.20449>;
    <D.20413>:
    iftmp.42 = __builtin_strcmp (element_name, "startup");
    <D.20449>:
    D.19011 = iftmp.42;
  }
  if (D.19011 == 0) goto <D.20450>; else goto <D.20451>;
  <D.20450>:
  D.20452 = app_config->startup_count;
  D.20453 = D.20452 + 1;
  app_config->startup_count = D.20453;
  return;
  <D.20451>:
  D.20454 = BIT_FIELD_REF <*app_config, 64, 128>;
  D.20455 = (long unsigned int) D.20454;
  D.20456 = D.20455;
  if (D.20456 != 4294967297) goto <D.20457>; else goto <D.20458>;
  <D.20457>:
  return;
  <D.20458>:
  {
    size_t __s1_len;
    size_t __s2_len;

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

      __s2 = element_name;
      D.20462 = "requiredRuntime";
      D.20463 = MEM[(const unsigned char *)D.20462];
      D.20464 = (int) D.20463;
      D.20465 = *__s2;
      D.20466 = (int) D.20465;
      __result = D.20464 - D.20466;
      {
        if (__s2_len != 0) goto <D.20467>; else goto <D.20468>;
        <D.20467>:
        if (__result == 0) goto <D.20469>; else goto <D.20470>;
        <D.20469>:
        D.20471 = &MEM[(void *)"requiredRuntime" + 1B];
        D.20472 = *D.20471;
        D.20473 = (int) D.20472;
        D.20474 = __s2 + 1;
        D.20475 = *D.20474;
        D.20476 = (int) D.20475;
        __result = D.20473 - D.20476;
        if (__s2_len > 1) goto <D.20477>; else goto <D.20478>;
        <D.20477>:
        if (__result == 0) goto <D.20479>; else goto <D.20480>;
        <D.20479>:
        D.20481 = &MEM[(void *)"requiredRuntime" + 2B];
        D.20482 = *D.20481;
        D.20483 = (int) D.20482;
        D.20484 = __s2 + 2;
        D.20485 = *D.20484;
        D.20486 = (int) D.20485;
        __result = D.20483 - D.20486;
        if (__s2_len > 2) goto <D.20487>; else goto <D.20488>;
        <D.20487>:
        if (__result == 0) goto <D.20489>; else goto <D.20490>;
        <D.20489>:
        D.20491 = &MEM[(void *)"requiredRuntime" + 3B];
        D.20492 = *D.20491;
        D.20493 = (int) D.20492;
        D.20494 = __s2 + 3;
        D.20495 = *D.20494;
        D.20496 = (int) D.20495;
        __result = D.20493 - D.20496;
        <D.20490>:
        <D.20488>:
        <D.20480>:
        <D.20478>:
        <D.20470>:
        <D.20468>:
      }
      D.19019 = __result;
    }
    iftmp.43 = -D.19019;
    goto <D.20497>;
    <D.20461>:
    iftmp.43 = __builtin_strcmp (element_name, "requiredRuntime");
    <D.20497>:
    D.19020 = iftmp.43;
  }
  if (D.19020 == 0) goto <D.20498>; else goto <D.20499>;
  <D.20498>:
  D.20500 = get_attribute_value (attribute_names, attribute_values, "version");
  app_config->required_runtime = D.20500;
  goto <D.20501>;
  <D.20499>:
  {
    size_t __s1_len;
    size_t __s2_len;

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

      __s2 = element_name;
      D.20505 = "supportedRuntime";
      D.20506 = MEM[(const unsigned char *)D.20505];
      D.20507 = (int) D.20506;
      D.20508 = *__s2;
      D.20509 = (int) D.20508;
      __result = D.20507 - D.20509;
      {
        if (__s2_len != 0) goto <D.20510>; else goto <D.20511>;
        <D.20510>:
        if (__result == 0) goto <D.20512>; else goto <D.20513>;
        <D.20512>:
        D.20514 = &MEM[(void *)"supportedRuntime" + 1B];
        D.20515 = *D.20514;
        D.20516 = (int) D.20515;
        D.20517 = __s2 + 1;
        D.20518 = *D.20517;
        D.20519 = (int) D.20518;
        __result = D.20516 - D.20519;
        if (__s2_len > 1) goto <D.20520>; else goto <D.20521>;
        <D.20520>:
        if (__result == 0) goto <D.20522>; else goto <D.20523>;
        <D.20522>:
        D.20524 = &MEM[(void *)"supportedRuntime" + 2B];
        D.20525 = *D.20524;
        D.20526 = (int) D.20525;
        D.20527 = __s2 + 2;
        D.20528 = *D.20527;
        D.20529 = (int) D.20528;
        __result = D.20526 - D.20529;
        if (__s2_len > 2) goto <D.20530>; else goto <D.20531>;
        <D.20530>:
        if (__result == 0) goto <D.20532>; else goto <D.20533>;
        <D.20532>:
        D.20534 = &MEM[(void *)"supportedRuntime" + 3B];
        D.20535 = *D.20534;
        D.20536 = (int) D.20535;
        D.20537 = __s2 + 3;
        D.20538 = *D.20537;
        D.20539 = (int) D.20538;
        __result = D.20536 - D.20539;
        <D.20533>:
        <D.20531>:
        <D.20523>:
        <D.20521>:
        <D.20513>:
        <D.20511>:
      }
      D.19028 = __result;
    }
    iftmp.44 = -D.19028;
    goto <D.20540>;
    <D.20504>:
    iftmp.44 = __builtin_strcmp (element_name, "supportedRuntime");
    <D.20540>:
    D.19029 = iftmp.44;
  }
  if (D.19029 == 0) goto <D.20541>; else goto <D.20542>;
  <D.20541>:
  {
    char * version;

    version = get_attribute_value (attribute_names, attribute_values, "version");
    D.20543 = app_config->supported_runtimes;
    D.20544 = monoeg_g_slist_append (D.20543, version);
    app_config->supported_runtimes = D.20544;
  }
  <D.20542>:
  <D.20501>:
}


get_attribute_value (const gchar * * attribute_names, const gchar * * attribute_values, const char * att_name)
{
  int D.18981;
  long unsigned int D.20546;
  long unsigned int D.20547;
  const gchar * * D.20548;
  const gchar * D.20549;
  char * D.20552;
  const gchar * * D.20553;
  const gchar * D.20554;
  int n;

  n = 0;
  goto <D.18983>;
  <D.18982>:
  {
    size_t __s1_len;
    size_t __s2_len;

    D.20546 = (long unsigned int) n;
    D.20547 = D.20546 * 8;
    D.20548 = attribute_names + D.20547;
    D.20549 = *D.20548;
    D.18981 = __builtin_strcmp (D.20549, att_name);
  }
  if (D.18981 == 0) goto <D.20550>; else goto <D.20551>;
  <D.20550>:
  D.20546 = (long unsigned int) n;
  D.20547 = D.20546 * 8;
  D.20553 = attribute_values + D.20547;
  D.20554 = *D.20553;
  D.20552 = monoeg_strdup (D.20554);
  return D.20552;
  <D.20551>:
  n = n + 1;
  <D.18983>:
  D.20546 = (long unsigned int) n;
  D.20547 = D.20546 * 8;
  D.20548 = attribute_names + D.20547;
  D.20549 = *D.20548;
  if (D.20549 != 0B) goto <D.18982>; else goto <D.18984>;
  <D.18984>:
  D.20552 = 0B;
  return D.20552;
}


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

  if (str != 0B) goto <D.20556>; else goto <D.20557>;
  <D.20556>:
  D.20558 = __strdup (str);
  return D.20558;
  <D.20557>:
  D.20558 = 0B;
  return D.20558;
}


app_config_free (struct AppConfigInfo * app_config)
{
  struct GSList * iftmp.45;
  struct GSList * D.20564;
  char * D.20565;
  char * rt;
  struct GSList * list;

  list = app_config->supported_runtimes;
  goto <D.19072>;
  <D.19071>:
  rt = list->data;
  monoeg_g_free (rt);
  if (list != 0B) goto <D.20561>; else goto <D.20562>;
  <D.20561>:
  iftmp.45 = list->next;
  goto <D.20563>;
  <D.20562>:
  iftmp.45 = 0B;
  <D.20563>:
  list = iftmp.45;
  <D.19072>:
  if (list != 0B) goto <D.19071>; else goto <D.19073>;
  <D.19073>:
  D.20564 = app_config->supported_runtimes;
  monoeg_g_slist_free (D.20564);
  D.20565 = app_config->required_runtime;
  monoeg_g_free (D.20565);
  monoeg_g_free (app_config);
}


get_runtime_by_version (const char * version)
{
  const struct MonoRuntimeInfo * D.20568;
  int D.19088;
  const char[12] * D.20569;
  long unsigned int D.20572;
  const char * D.20575;
  char D.20576;
  int D.20577;
  int D.20580;
  int n;
  int max;
  int vlen;

  max = 6;
  if (version == 0B) goto <D.20566>; else goto <D.20567>;
  <D.20566>:
  D.20568 = 0B;
  return D.20568;
  <D.20567>:
  n = 0;
  goto <D.19090>;
  <D.19089>:
  {
    size_t __s1_len;
    size_t __s2_len;

    D.20569 = &supported_runtimes[n].runtime_version;
    D.19088 = __builtin_strcmp (version, D.20569);
  }
  if (D.19088 == 0) goto <D.20570>; else goto <D.20571>;
  <D.20570>:
  D.20568 = &supported_runtimes[n];
  return D.20568;
  <D.20571>:
  n = n + 1;
  <D.19090>:
  if (n < max) goto <D.19089>; else goto <D.19091>;
  <D.19091>:
  D.20572 = strlen (version);
  vlen = (int) D.20572;
  if (vlen > 3) goto <D.20573>; else goto <D.20574>;
  <D.20573>:
  D.20575 = version + 1;
  D.20576 = *D.20575;
  D.20577 = (int) D.20576;
  if (D.20577 > 51) goto <D.20578>; else goto <D.20579>;
  <D.20578>:
  n = 0;
  goto <D.19102>;
  <D.19101>:
  D.20569 = &supported_runtimes[n].runtime_version;
  D.20580 = strncmp (version, D.20569, 4);
  if (D.20580 == 0) goto <D.20581>; else goto <D.20582>;
  <D.20581>:
  D.20568 = &supported_runtimes[n];
  return D.20568;
  <D.20582>:
  n = n + 1;
  <D.19102>:
  if (n < max) goto <D.19101>; else goto <D.19103>;
  <D.19103>:
  <D.20579>:
  <D.20574>:
  D.20568 = 0B;
  return D.20568;
}


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

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


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

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


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

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


mono_cleanup ()
{
  unsigned int appdomain_thread_id.46;

  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.46 = appdomain_thread_id;
  mono_native_tls_free (appdomain_thread_id.46);
  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.47;

  exe_image.47 = exe_image;
  if (exe_image.47 != 0B) goto <D.20592>; else goto <D.20593>;
  <D.20592>:
  exe_image.47 = exe_image;
  mono_image_close (exe_image.47);
  <D.20593>:
}


mono_get_root_domain ()
{
  struct MonoDomain * D.20594;

  D.20594 = mono_root_domain;
  return D.20594;
}


mono_domain_get ()
{
  struct MonoDomain * D.20596;

  D.20596 = tls_appdomain;
  return D.20596;
}


mono_domain_unset ()
{
  unsigned int appdomain_thread_id.48;

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


mono_domain_set_internal_with_options (struct MonoDomain * domain, gboolean migrate_exception)
{
  struct MonoDomain * D.20599;
  unsigned int appdomain_thread_id.49;
  struct MonoInternalThread * D.20603;
  struct MonoInternalThread * D.20604;
  struct MonoAppContext * * D.20605;
  struct MonoAppContext * D.20606;
  struct MonoException * D.20609;
  struct MonoVTable * D.20612;
  struct MonoDomain * D.20613;
  _Bool D.20614;
  long int D.20615;
  long int D.20616;
  struct MonoException * * D.20619;
  struct MonoException * D.20620;
  _Bool D.20621;
  long int D.20622;
  long int D.20623;
  struct MonoInternalThread * thread;

  D.20599 = mono_domain_get ();
  if (D.20599 == domain) goto <D.20600>; else goto <D.20601>;
  <D.20600>:
  return;
  <D.20601>:
  tls_appdomain = domain;
  appdomain_thread_id.49 = appdomain_thread_id;
  mono_native_tls_set_value (appdomain_thread_id.49, domain);
  mono_gc_set_current_thread_appdomain (domain);
  D.20603 = mono_thread_internal_current ();
  D.20604 = mono_thread_internal_current ();
  D.20605 = &D.20604->current_appcontext;
  D.20606 = domain->default_context;
  mono_gc_wbarrier_set_field (D.20603, D.20605, D.20606);
  if (migrate_exception != 0) goto <D.20607>; else goto <D.20608>;
  <D.20607>:
  thread = mono_thread_internal_current ();
  D.20609 = thread->abort_exc;
  if (D.20609 == 0B) goto <D.20610>; else goto <D.20611>;
  <D.20610>:
  return;
  <D.20611>:
  D.20609 = thread->abort_exc;
  D.20612 = D.20609->object.vtable;
  D.20613 = D.20612->domain;
  D.20614 = D.20613 == domain;
  D.20615 = (long int) D.20614;
  D.20616 = __builtin_expect (D.20615, 0);
  if (D.20616 != 0) goto <D.20617>; else goto <D.20618>;
  <D.20617>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "domain.c", 1830, "thread->abort_exc->object.vtable->domain != domain");
  <D.20618>:
  D.20619 = &thread->abort_exc;
  D.20620 = mono_get_exception_thread_abort ();
  mono_gc_wbarrier_set_field (thread, D.20619, D.20620);
  D.20609 = thread->abort_exc;
  D.20612 = D.20609->object.vtable;
  D.20613 = D.20612->domain;
  D.20621 = D.20613 != domain;
  D.20622 = (long int) D.20621;
  D.20623 = __builtin_expect (D.20622, 0);
  if (D.20623 != 0) goto <D.20624>; else goto <D.20625>;
  <D.20624>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "domain.c", 1832, "thread->abort_exc->object.vtable->domain == domain");
  <D.20625>:
  <D.20608>:
}


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.20629;
  long int D.20630;
  long int D.20631;
  short unsigned int appdomain_list_size.50;
  long unsigned int D.20635;
  long unsigned int D.20636;
  struct MonoDomain * * appdomains_list.51;
  _Bool D.20640;
  long int D.20641;
  long int D.20642;
  long unsigned int D.20645;
  long unsigned int D.20646;
  struct MonoDomain * * D.20647;
  struct MonoDomain * D.20648;
  int i;
  int size;
  struct MonoDomain * * copy;

  {
    int ret;

    ret = pthread_mutex_lock (&appdomains_mutex.mutex);
    if (ret != 0) goto <D.20627>; else goto <D.20628>;
    <D.20627>:
    monoeg_g_log (0B, 16, "Bad call to mono_mutex_lock result %d", ret);
    <D.20628>:
    D.20629 = ret != 0;
    D.20630 = (long int) D.20629;
    D.20631 = __builtin_expect (D.20630, 0);
    if (D.20631 != 0) goto <D.20632>; else goto <D.20633>;
    <D.20632>:
    monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "domain.c", 1859, "ret == 0");
    <D.20633>:
  }
  appdomain_list_size.50 = appdomain_list_size;
  size = (int) appdomain_list_size.50;
  appdomain_list_size.50 = appdomain_list_size;
  D.20635 = (long unsigned int) appdomain_list_size.50;
  D.20636 = D.20635 * 8;
  copy = mono_gc_alloc_fixed (D.20636, 0B);
  appdomains_list.51 = appdomains_list;
  appdomain_list_size.50 = appdomain_list_size;
  D.20635 = (long unsigned int) appdomain_list_size.50;
  D.20636 = D.20635 * 8;
  memcpy (copy, appdomains_list.51, D.20636);
  {
    int ret;

    ret = pthread_mutex_unlock (&appdomains_mutex.mutex);
    if (ret != 0) goto <D.20638>; else goto <D.20639>;
    <D.20638>:
    monoeg_g_log (0B, 16, "Bad call to mono_mutex_unlock result %d", ret);
    <D.20639>:
    D.20640 = ret != 0;
    D.20641 = (long int) D.20640;
    D.20642 = __builtin_expect (D.20641, 0);
    if (D.20642 != 0) goto <D.20643>; else goto <D.20644>;
    <D.20643>:
    monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "domain.c", 1863, "ret == 0");
    <D.20644>:
  }
  i = 0;
  goto <D.18754>;
  <D.18753>:
  D.20645 = (long unsigned int) i;
  D.20646 = D.20645 * 8;
  D.20647 = copy + D.20646;
  D.20648 = *D.20647;
  if (D.20648 != 0B) goto <D.20649>; else goto <D.20650>;
  <D.20649>:
  D.20645 = (long unsigned int) i;
  D.20646 = D.20645 * 8;
  D.20647 = copy + D.20646;
  D.20648 = *D.20647;
  func (D.20648, user_data);
  <D.20650>:
  i = i + 1;
  <D.18754>:
  if (i < size) goto <D.18753>; else goto <D.18755>;
  <D.18755>:
  mono_gc_free_fixed (copy);
}


mono_domain_assembly_open (struct MonoDomain * domain, const char * name)
{
  union mono_mutex_t * D.20651;
  _Bool D.20654;
  long int D.20655;
  long int D.20656;
  int D.18772;
  const char * D.20659;
  _Bool D.20664;
  long int D.20665;
  long int D.20666;
  struct MonoAssembly * D.20669;
  _Bool D.20672;
  long int D.20673;
  long int D.20674;
  struct MonoDomain * D.20677;
  struct MonoDomain * current;
  struct MonoAssembly * ass;
  struct GSList * tmp;

  {
    int ret;

    D.20651 = &domain->assemblies_lock.mutex;
    ret = pthread_mutex_lock (D.20651);
    if (ret != 0) goto <D.20652>; else goto <D.20653>;
    <D.20652>:
    monoeg_g_log (0B, 16, "Bad call to mono_mutex_lock result %d", ret);
    <D.20653>:
    D.20654 = ret != 0;
    D.20655 = (long int) D.20654;
    D.20656 = __builtin_expect (D.20655, 0);
    if (D.20656 != 0) goto <D.20657>; else goto <D.20658>;
    <D.20657>:
    monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "domain.c", 1887, "ret == 0");
    <D.20658>:
  }
  tmp = domain->domain_assemblies;
  goto <D.18775>;
  <D.18774>:
  ass = tmp->data;
  {
    size_t __s1_len;
    size_t __s2_len;

    D.20659 = ass->aname.name;
    D.18772 = __builtin_strcmp (name, D.20659);
  }
  if (D.18772 == 0) goto <D.20660>; else goto <D.20661>;
  <D.20660>:
  {
    int ret;

    D.20651 = &domain->assemblies_lock.mutex;
    ret = pthread_mutex_unlock (D.20651);
    if (ret != 0) goto <D.20662>; else goto <D.20663>;
    <D.20662>:
    monoeg_g_log (0B, 16, "Bad call to mono_mutex_unlock result %d", ret);
    <D.20663>:
    D.20664 = ret != 0;
    D.20665 = (long int) D.20664;
    D.20666 = __builtin_expect (D.20665, 0);
    if (D.20666 != 0) goto <D.20667>; else goto <D.20668>;
    <D.20667>:
    monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "domain.c", 1891, "ret == 0");
    <D.20668>:
  }
  D.20669 = ass;
  return D.20669;
  <D.20661>:
  tmp = tmp->next;
  <D.18775>:
  if (tmp != 0B) goto <D.18774>; else goto <D.18776>;
  <D.18776>:
  {
    int ret;

    D.20651 = &domain->assemblies_lock.mutex;
    ret = pthread_mutex_unlock (D.20651);
    if (ret != 0) goto <D.20670>; else goto <D.20671>;
    <D.20670>:
    monoeg_g_log (0B, 16, "Bad call to mono_mutex_unlock result %d", ret);
    <D.20671>:
    D.20672 = ret != 0;
    D.20673 = (long int) D.20672;
    D.20674 = __builtin_expect (D.20673, 0);
    if (D.20674 != 0) goto <D.20675>; else goto <D.20676>;
    <D.20675>:
    monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "domain.c", 1895, "ret == 0");
    <D.20676>:
  }
  D.20677 = mono_domain_get ();
  if (D.20677 != domain) goto <D.20678>; else goto <D.20679>;
  <D.20678>:
  current = mono_domain_get ();
  mono_domain_set (domain, 0);
  ass = mono_assembly_open (name, 0B);
  mono_domain_set (current, 0);
  goto <D.20680>;
  <D.20679>:
  ass = mono_assembly_open (name, 0B);
  <D.20680>:
  D.20669 = ass;
  return D.20669;
}


mono_domain_free (struct MonoDomain * domain, gboolean force)
{
  struct MonoDomain * mono_root_domain.52;
  int mono_dont_free_domains.53;
  _Bool D.20692;
  long int D.20693;
  long int D.20694;
  struct MonoDomain * * appdomains_list.54;
  int D.20698;
  long unsigned int D.20699;
  long unsigned int D.20700;
  struct MonoDomain * * D.20701;
  _Bool D.20704;
  long int D.20705;
  long int D.20706;
  struct GHashTable * D.20709;
  struct MonoGHashTable * D.20712;
  struct MonoGHashTable * D.20713;
  struct MonoTlsDataRecord * D.20714;
  struct MonoGHashTable * D.20717;
  struct MonoGHashTable * D.20720;
  struct GPtrArray * D.20723;
  void * * D.20726;
  long unsigned int D.20727;
  long unsigned int D.20728;
  void * * D.20729;
  void * D.20730;
  unsigned int i.55;
  unsigned int D.20732;
  struct MonoGHashTable * * D.20733;
  struct MonoImage * D.20736;
  long unsigned int D.20738;
  long unsigned int D.20739;
  char * D.20740;
  const char * D.20741;
  int D.20742;
  int D.20743;
  struct MonoImage * D.20750;
  long unsigned int D.20752;
  long unsigned int D.20753;
  const char * D.20754;
  int D.20755;
  int D.20756;
  struct GSList * D.20761;
  void (*<T19f2>) (struct MonoDomain *) free_domain_hook.56;
  gchar * * D.20765;
  struct GHashTable * D.20768;
  void * * D.20769;
  struct MonoInternalHashTable * D.20772;
  struct MonoJitInfoTable * D.20773;
  struct MonoJitInfoTable * D.20776;
  int D.20777;
  _Bool D.20778;
  long int D.20779;
  long int D.20780;
  struct MonoJitInfoTable * D.20783;
  struct GSList * D.20784;
  _Bool D.20785;
  long int D.20786;
  long int D.20787;
  struct MonoCodeManager * D.20790;
  int total_domain_code_alloc.57;
  int total_domain_code_alloc.58;
  int max_domain_code_alloc.59;
  int max_domain_code_alloc.60;
  int code_size.61;
  int max_domain_code_size.62;
  int max_domain_code_size.63;
  struct MonoMemPool * D.20798;
  struct LockFreeMempool * D.20799;
  struct GHashTable * D.20800;
  struct GHashTable * D.20801;
  struct GHashTable * D.20804;
  struct GHashTable * D.20807;
  struct GHashTable * D.20810;
  struct CRITICAL_SECTION * D.20813;
  struct CRITICAL_SECTION * D.20814;
  struct CRITICAL_SECTION * D.20815;
  struct CRITICAL_SECTION * D.20816;
  struct MonoPerfCounters * mono_perfcounters.64;
  unsigned int D.20818;
  unsigned int D.20819;
  int code_size;
  int code_alloc;
  struct GSList * tmp;
  void * * p;

  try
    {
      mono_root_domain.52 = mono_root_domain;
      if (domain == mono_root_domain.52) goto <D.20683>; else goto <D.20684>;
      <D.20683>:
      if (force == 0) goto <D.20685>; else goto <D.20686>;
      <D.20685>:
      monoeg_g_log (0B, 16, "cant unload root domain");
      return;
      <D.20686>:
      <D.20684>:
      mono_dont_free_domains.53 = mono_dont_free_domains;
      if (mono_dont_free_domains.53 != 0) goto <D.20688>; else goto <D.20689>;
      <D.20688>:
      return;
      <D.20689>:
      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.20690>; else goto <D.20691>;
        <D.20690>:
        monoeg_g_log (0B, 16, "Bad call to mono_mutex_lock result %d", ret);
        <D.20691>:
        D.20692 = ret != 0;
        D.20693 = (long int) D.20692;
        D.20694 = __builtin_expect (D.20693, 0);
        if (D.20694 != 0) goto <D.20695>; else goto <D.20696>;
        <D.20695>:
        monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "domain.c", 1938, "ret == 0");
        <D.20696>:
      }
      appdomains_list.54 = appdomains_list;
      D.20698 = domain->domain_id;
      D.20699 = (long unsigned int) D.20698;
      D.20700 = D.20699 * 8;
      D.20701 = appdomains_list.54 + D.20700;
      *D.20701 = 0B;
      {
        int ret;

        ret = pthread_mutex_unlock (&appdomains_mutex.mutex);
        if (ret != 0) goto <D.20702>; else goto <D.20703>;
        <D.20702>:
        monoeg_g_log (0B, 16, "Bad call to mono_mutex_unlock result %d", ret);
        <D.20703>:
        D.20704 = ret != 0;
        D.20705 = (long int) D.20704;
        D.20706 = __builtin_expect (D.20705, 0);
        if (D.20706 != 0) goto <D.20707>; else goto <D.20708>;
        <D.20707>:
        monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "domain.c", 1940, "ret == 0");
        <D.20708>:
      }
      D.20709 = domain->special_static_fields;
      if (D.20709 != 0B) goto <D.20710>; else goto <D.20711>;
      <D.20710>:
      D.20709 = domain->special_static_fields;
      mono_alloc_special_static_data_free (D.20709);
      D.20709 = domain->special_static_fields;
      monoeg_g_hash_table_destroy (D.20709);
      domain->special_static_fields = 0B;
      <D.20711>:
      D.20712 = domain->ldstr_table;
      mono_g_hash_table_destroy (D.20712);
      domain->ldstr_table = 0B;
      D.20713 = domain->env;
      mono_g_hash_table_destroy (D.20713);
      domain->env = 0B;
      D.20714 = domain->tlsrec_list;
      if (D.20714 != 0B) goto <D.20715>; else goto <D.20716>;
      <D.20715>:
      mono_thread_destroy_domain_tls (domain);
      domain->tlsrec_list = 0B;
      <D.20716>:
      mono_reflection_cleanup_domain (domain);
      D.20717 = domain->type_hash;
      if (D.20717 != 0B) goto <D.20718>; else goto <D.20719>;
      <D.20718>:
      D.20717 = domain->type_hash;
      mono_g_hash_table_destroy (D.20717);
      domain->type_hash = 0B;
      <D.20719>:
      D.20720 = domain->type_init_exception_hash;
      if (D.20720 != 0B) goto <D.20721>; else goto <D.20722>;
      <D.20721>:
      D.20720 = domain->type_init_exception_hash;
      mono_g_hash_table_destroy (D.20720);
      domain->type_init_exception_hash = 0B;
      <D.20722>:
      D.20723 = domain->class_vtable_array;
      if (D.20723 != 0B) goto <D.20724>; else goto <D.20725>;
      <D.20724>:
      {
        int i;

        i = 0;
        goto <D.18794>;
        <D.18793>:
        D.20723 = domain->class_vtable_array;
        D.20726 = D.20723->pdata;
        D.20727 = (long unsigned int) i;
        D.20728 = D.20727 * 8;
        D.20729 = D.20726 + D.20728;
        D.20730 = *D.20729;
        unregister_vtable_reflection_type (D.20730);
        i = i + 1;
        <D.18794>:
        i.55 = (unsigned int) i;
        D.20723 = domain->class_vtable_array;
        D.20732 = D.20723->len;
        if (i.55 < D.20732) goto <D.18793>; else goto <D.18795>;
        <D.18795>:
      }
      <D.20725>:
      tmp = domain->domain_assemblies;
      goto <D.18798>;
      <D.18797>:
      {
        struct MonoAssembly * ass;

        ass = tmp->data;
        mono_assembly_release_gc_roots (ass);
      }
      tmp = tmp->next;
      <D.18798>:
      if (tmp != 0B) goto <D.18797>; else goto <D.18799>;
      <D.18799>:
      p = &domain->setup;
      goto <D.18801>;
      <D.18800>:
      *p = 0B;
      p = p + 8;
      <D.18801>:
      D.20733 = &domain->env;
      if (D.20733 > p) goto <D.18800>; else goto <D.18802>;
      <D.18802>:
      mono_gc_clear_domain (domain);
      tmp = domain->domain_assemblies;
      goto <D.18806>;
      <D.18805>:
      {
        struct MonoAssembly * ass;

        ass = tmp->data;
        D.20736 = ass->image;
        if (D.20736 == 0B) goto <D.20734>; else goto <D.20737>;
        <D.20737>:
        D.20736 = ass->image;
        D.20738 = BIT_FIELD_REF <*D.20736, 64, 192>;
        D.20739 = D.20738 & 34359738368;
        if (D.20739 == 0) goto <D.20734>; else goto <D.20735>;
        <D.20734>:
        // predicted unlikely by continue predictor.
        goto <D.18804>;
        <D.20735>:
        D.20740 = domain->friendly_name;
        D.20741 = ass->aname.name;
        D.20742 = ass->ref_count;
        mono_trace (64, 1, "Unloading domain %s[%p], assembly %s[%p], ref_count=%d", D.20740, domain, D.20741, ass, D.20742);
        D.20743 = mono_assembly_close_except_image_pools (ass);
        if (D.20743 == 0) goto <D.20744>; else goto <D.20745>;
        <D.20744>:
        tmp->data = 0B;
        <D.20745>:
      }
      <D.18804>:
      tmp = tmp->next;
      <D.18806>:
      if (tmp != 0B) goto <D.18805>; else goto <D.18807>;
      <D.18807>:
      tmp = domain->domain_assemblies;
      goto <D.18811>;
      <D.18810>:
      {
        struct MonoAssembly * ass;

        ass = tmp->data;
        if (ass == 0B) goto <D.20746>; else goto <D.20747>;
        <D.20746>:
        // predicted unlikely by continue predictor.
        goto <D.18809>;
        <D.20747>:
        D.20750 = ass->image;
        if (D.20750 == 0B) goto <D.20748>; else goto <D.20751>;
        <D.20751>:
        D.20750 = ass->image;
        D.20752 = BIT_FIELD_REF <*D.20750, 64, 192>;
        D.20753 = D.20752 & 34359738368;
        if (D.20753 != 0) goto <D.20748>; else goto <D.20749>;
        <D.20748>:
        // predicted unlikely by continue predictor.
        goto <D.18809>;
        <D.20749>:
        D.20740 = domain->friendly_name;
        D.20754 = ass->aname.name;
        D.20755 = ass->ref_count;
        mono_trace (64, 1, "Unloading domain %s[%p], assembly %s[%p], ref_count=%d", D.20740, domain, D.20754, ass, D.20755);
        D.20756 = mono_assembly_close_except_image_pools (ass);
        if (D.20756 == 0) goto <D.20757>; else goto <D.20758>;
        <D.20757>:
        tmp->data = 0B;
        <D.20758>:
      }
      <D.18809>:
      tmp = tmp->next;
      <D.18811>:
      if (tmp != 0B) goto <D.18810>; else goto <D.18812>;
      <D.18812>:
      tmp = domain->domain_assemblies;
      goto <D.18815>;
      <D.18814>:
      {
        struct MonoAssembly * ass;

        ass = tmp->data;
        if (ass != 0B) goto <D.20759>; else goto <D.20760>;
        <D.20759>:
        mono_assembly_close_finish (ass);
        <D.20760>:
      }
      tmp = tmp->next;
      <D.18815>:
      if (tmp != 0B) goto <D.18814>; else goto <D.18816>;
      <D.18816>:
      D.20761 = domain->domain_assemblies;
      monoeg_g_slist_free (D.20761);
      domain->domain_assemblies = 0B;
      mono_profiler_appdomain_event (domain, 3);
      free_domain_hook.56 = free_domain_hook;
      if (free_domain_hook.56 != 0B) goto <D.20763>; else goto <D.20764>;
      <D.20763>:
      free_domain_hook.56 = free_domain_hook;
      free_domain_hook.56 (domain);
      <D.20764>:
      D.20765 = domain->search_path;
      if (D.20765 != 0B) goto <D.20766>; else goto <D.20767>;
      <D.20766>:
      D.20765 = domain->search_path;
      monoeg_g_strfreev (D.20765);
      domain->search_path = 0B;
      <D.20767>:
      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.20740 = domain->friendly_name;
      monoeg_g_free (D.20740);
      domain->friendly_name = 0B;
      D.20723 = domain->class_vtable_array;
      monoeg_g_ptr_array_free (D.20723, 1);
      domain->class_vtable_array = 0B;
      D.20768 = domain->proxy_vtable_hash;
      monoeg_g_hash_table_destroy (D.20768);
      domain->proxy_vtable_hash = 0B;
      D.20769 = domain->static_data_array;
      if (D.20769 != 0B) goto <D.20770>; else goto <D.20771>;
      <D.20770>:
      D.20769 = domain->static_data_array;
      mono_gc_free_fixed (D.20769);
      domain->static_data_array = 0B;
      <D.20771>:
      D.20772 = &domain->jit_code_hash;
      mono_internal_hash_table_destroy (D.20772);
      mono_thread_hazardous_try_free_all ();
      D.20773 = domain->aot_modules;
      if (D.20773 != 0B) goto <D.20774>; else goto <D.20775>;
      <D.20774>:
      D.20776 = domain->aot_modules;
      jit_info_table_free (D.20776);
      <D.20775>:
      D.20777 = domain->num_jit_info_tables;
      D.20778 = D.20777 != 1;
      D.20779 = (long int) D.20778;
      D.20780 = __builtin_expect (D.20779, 0);
      if (D.20780 != 0) goto <D.20781>; else goto <D.20782>;
      <D.20781>:
      monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "domain.c", 2068, "domain->num_jit_info_tables == 1");
      <D.20782>:
      D.20783 = domain->jit_info_table;
      jit_info_table_free (D.20783);
      domain->jit_info_table = 0B;
      D.20784 = domain->jit_info_free_queue;
      D.20785 = D.20784 != 0B;
      D.20786 = (long int) D.20785;
      D.20787 = __builtin_expect (D.20786, 0);
      if (D.20787 != 0) goto <D.20788>; else goto <D.20789>;
      <D.20788>:
      monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "domain.c", 2071, "!domain->jit_info_free_queue");
      <D.20789>:
      D.20790 = domain->code_mp;
      code_alloc = mono_code_manager_size (D.20790, &code_size);
      total_domain_code_alloc.57 = total_domain_code_alloc;
      total_domain_code_alloc.58 = total_domain_code_alloc.57 + code_alloc;
      total_domain_code_alloc = total_domain_code_alloc.58;
      max_domain_code_alloc.59 = max_domain_code_alloc;
      max_domain_code_alloc.60 = MAX_EXPR <code_alloc, max_domain_code_alloc.59>;
      max_domain_code_alloc = max_domain_code_alloc.60;
      code_size.61 = code_size;
      max_domain_code_size.62 = max_domain_code_size;
      max_domain_code_size.63 = MAX_EXPR <code_size.61, max_domain_code_size.62>;
      max_domain_code_size = max_domain_code_size.63;
      D.20798 = domain->mp;
      mono_mempool_invalidate (D.20798);
      D.20790 = domain->code_mp;
      mono_code_manager_invalidate (D.20790);
      D.20799 = domain->lock_free_mp;
      lock_free_mempool_free (D.20799);
      domain->lock_free_mp = 0B;
      D.20800 = domain->finalizable_objects_hash;
      monoeg_g_hash_table_destroy (D.20800);
      domain->finalizable_objects_hash = 0B;
      D.20801 = domain->method_rgctx_hash;
      if (D.20801 != 0B) goto <D.20802>; else goto <D.20803>;
      <D.20802>:
      D.20801 = domain->method_rgctx_hash;
      monoeg_g_hash_table_destroy (D.20801);
      domain->method_rgctx_hash = 0B;
      <D.20803>:
      D.20804 = domain->generic_virtual_cases;
      if (D.20804 != 0B) goto <D.20805>; else goto <D.20806>;
      <D.20805>:
      D.20804 = domain->generic_virtual_cases;
      monoeg_g_hash_table_destroy (D.20804);
      domain->generic_virtual_cases = 0B;
      <D.20806>:
      D.20807 = domain->generic_virtual_thunks;
      if (D.20807 != 0B) goto <D.20808>; else goto <D.20809>;
      <D.20808>:
      D.20807 = domain->generic_virtual_thunks;
      monoeg_g_hash_table_destroy (D.20807);
      domain->generic_virtual_thunks = 0B;
      <D.20809>:
      D.20810 = domain->ftnptrs_hash;
      if (D.20810 != 0B) goto <D.20811>; else goto <D.20812>;
      <D.20811>:
      D.20810 = domain->ftnptrs_hash;
      monoeg_g_hash_table_destroy (D.20810);
      domain->ftnptrs_hash = 0B;
      <D.20812>:
      D.20813 = &domain->finalizable_objects_hash_lock;
      DeleteCriticalSection (D.20813);
      D.20814 = &domain->assemblies_lock;
      DeleteCriticalSection (D.20814);
      D.20815 = &domain->jit_code_hash_lock;
      DeleteCriticalSection (D.20815);
      D.20816 = &domain->lock;
      DeleteCriticalSection (D.20816);
      domain->setup = 0B;
      D.20733 = &domain->env;
      mono_gc_deregister_root (D.20733);
      mono_gc_free_fixed (domain);
      mono_perfcounters.64 = mono_perfcounters;
      D.20818 = mono_perfcounters.64->loader_appdomains;
      D.20819 = D.20818 + 4294967295;
      mono_perfcounters.64->loader_appdomains = D.20819;
      mono_root_domain.52 = mono_root_domain;
      if (domain == mono_root_domain.52) goto <D.20820>; else goto <D.20821>;
      <D.20820>:
      mono_root_domain = 0B;
      <D.20821>:
    }
  finally
    {
      code_size = {CLOBBER};
    }
}


unregister_vtable_reflection_type (struct MonoVTable * vtable)
{
  struct MonoVTable * D.20825;
  struct MonoClass * D.20826;
  struct MonoClass * D.20827;
  int D.20830;
  void * * D.20833;
  struct MonoObject * type;

  type = vtable->type;
  D.20825 = type->vtable;
  D.20826 = D.20825->klass;
  D.20827 = mono_defaults.monotype_class;
  if (D.20826 != D.20827) goto <D.20828>; else goto <D.20829>;
  <D.20828>:
  D.20830 = mono_gc_is_moving ();
  if (D.20830 != 0) goto <D.20831>; else goto <D.20832>;
  <D.20831>:
  D.20833 = &vtable->type;
  mono_gc_deregister_root (D.20833);
  <D.20832>:
  <D.20829>:
}


lock_free_mempool_free (struct LockFreeMempool * mp)
{
  int D.20834;
  long unsigned int D.20835;
  struct LockFreeMempoolChunk * chunk;
  struct LockFreeMempoolChunk * next;

  chunk = mp->chunks;
  goto <D.18604>;
  <D.18603>:
  next = chunk->prev;
  D.20834 = mono_pagesize ();
  D.20835 = (long unsigned int) D.20834;
  mono_vfree (chunk, D.20835);
  chunk = next;
  <D.18604>:
  if (chunk != 0B) goto <D.18603>; else goto <D.18605>;
  <D.18605>:
}


mono_domain_get_by_id (gint32 domainid)
{
  _Bool D.20838;
  long int D.20839;
  long int D.20840;
  short unsigned int appdomain_list_size.65;
  int D.20844;
  struct MonoDomain * * appdomains_list.66;
  long unsigned int D.20848;
  long unsigned int D.20849;
  struct MonoDomain * * D.20850;
  _Bool D.20854;
  long int D.20855;
  long int D.20856;
  struct MonoDomain * D.20859;
  struct MonoDomain * domain;

  {
    int ret;

    ret = pthread_mutex_lock (&appdomains_mutex.mutex);
    if (ret != 0) goto <D.20836>; else goto <D.20837>;
    <D.20836>:
    monoeg_g_log (0B, 16, "Bad call to mono_mutex_lock result %d", ret);
    <D.20837>:
    D.20838 = ret != 0;
    D.20839 = (long int) D.20838;
    D.20840 = __builtin_expect (D.20839, 0);
    if (D.20840 != 0) goto <D.20841>; else goto <D.20842>;
    <D.20841>:
    monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "domain.c", 2144, "ret == 0");
    <D.20842>:
  }
  appdomain_list_size.65 = appdomain_list_size;
  D.20844 = (int) appdomain_list_size.65;
  if (D.20844 > domainid) goto <D.20845>; else goto <D.20846>;
  <D.20845>:
  appdomains_list.66 = appdomains_list;
  D.20848 = (long unsigned int) domainid;
  D.20849 = D.20848 * 8;
  D.20850 = appdomains_list.66 + D.20849;
  domain = *D.20850;
  goto <D.20851>;
  <D.20846>:
  domain = 0B;
  <D.20851>:
  {
    int ret;

    ret = pthread_mutex_unlock (&appdomains_mutex.mutex);
    if (ret != 0) goto <D.20852>; else goto <D.20853>;
    <D.20852>:
    monoeg_g_log (0B, 16, "Bad call to mono_mutex_unlock result %d", ret);
    <D.20853>:
    D.20854 = ret != 0;
    D.20855 = (long int) D.20854;
    D.20856 = __builtin_expect (D.20855, 0);
    if (D.20856 != 0) goto <D.20857>; else goto <D.20858>;
    <D.20857>:
    monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "domain.c", 2149, "ret == 0");
    <D.20858>:
  }
  D.20859 = domain;
  return D.20859;
}


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

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


mono_domain_alloc (struct MonoDomain * domain, guint size)
{
  union mono_mutex_t * D.20863;
  _Bool D.20866;
  long int D.20867;
  long int D.20868;
  struct MonoPerfCounters * mono_perfcounters.67;
  unsigned int D.20872;
  unsigned int D.20873;
  struct MonoMemPool * D.20874;
  _Bool D.20877;
  long int D.20878;
  long int D.20879;
  void * D.20882;
  void * res;

  {
    int ret;

    D.20863 = &domain->lock.mutex;
    ret = pthread_mutex_lock (D.20863);
    if (ret != 0) goto <D.20864>; else goto <D.20865>;
    <D.20864>:
    monoeg_g_log (0B, 16, "Bad call to mono_mutex_lock result %d", ret);
    <D.20865>:
    D.20866 = ret != 0;
    D.20867 = (long int) D.20866;
    D.20868 = __builtin_expect (D.20867, 0);
    if (D.20868 != 0) goto <D.20869>; else goto <D.20870>;
    <D.20869>:
    monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "domain.c", 2170, "ret == 0");
    <D.20870>:
  }
  mono_perfcounters.67 = mono_perfcounters;
  mono_perfcounters.67 = mono_perfcounters;
  D.20872 = mono_perfcounters.67->loader_bytes;
  D.20873 = D.20872 + size;
  mono_perfcounters.67->loader_bytes = D.20873;
  D.20874 = domain->mp;
  res = mono_mempool_alloc (D.20874, size);
  {
    int ret;

    D.20863 = &domain->lock.mutex;
    ret = pthread_mutex_unlock (D.20863);
    if (ret != 0) goto <D.20875>; else goto <D.20876>;
    <D.20875>:
    monoeg_g_log (0B, 16, "Bad call to mono_mutex_unlock result %d", ret);
    <D.20876>:
    D.20877 = ret != 0;
    D.20878 = (long int) D.20877;
    D.20879 = __builtin_expect (D.20878, 0);
    if (D.20879 != 0) goto <D.20880>; else goto <D.20881>;
    <D.20880>:
    monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "domain.c", 2175, "ret == 0");
    <D.20881>:
  }
  D.20882 = res;
  return D.20882;
}


mono_domain_alloc0 (struct MonoDomain * domain, guint size)
{
  union mono_mutex_t * D.20884;
  _Bool D.20887;
  long int D.20888;
  long int D.20889;
  struct MonoPerfCounters * mono_perfcounters.68;
  unsigned int D.20893;
  unsigned int D.20894;
  struct MonoMemPool * D.20895;
  _Bool D.20898;
  long int D.20899;
  long int D.20900;
  void * D.20903;
  void * res;

  {
    int ret;

    D.20884 = &domain->lock.mutex;
    ret = pthread_mutex_lock (D.20884);
    if (ret != 0) goto <D.20885>; else goto <D.20886>;
    <D.20885>:
    monoeg_g_log (0B, 16, "Bad call to mono_mutex_lock result %d", ret);
    <D.20886>:
    D.20887 = ret != 0;
    D.20888 = (long int) D.20887;
    D.20889 = __builtin_expect (D.20888, 0);
    if (D.20889 != 0) goto <D.20890>; else goto <D.20891>;
    <D.20890>:
    monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "domain.c", 2190, "ret == 0");
    <D.20891>:
  }
  mono_perfcounters.68 = mono_perfcounters;
  mono_perfcounters.68 = mono_perfcounters;
  D.20893 = mono_perfcounters.68->loader_bytes;
  D.20894 = D.20893 + size;
  mono_perfcounters.68->loader_bytes = D.20894;
  D.20895 = domain->mp;
  res = mono_mempool_alloc0 (D.20895, size);
  {
    int ret;

    D.20884 = &domain->lock.mutex;
    ret = pthread_mutex_unlock (D.20884);
    if (ret != 0) goto <D.20896>; else goto <D.20897>;
    <D.20896>:
    monoeg_g_log (0B, 16, "Bad call to mono_mutex_unlock result %d", ret);
    <D.20897>:
    D.20898 = ret != 0;
    D.20899 = (long int) D.20898;
    D.20900 = __builtin_expect (D.20899, 0);
    if (D.20900 != 0) goto <D.20901>; else goto <D.20902>;
    <D.20901>:
    monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "domain.c", 2195, "ret == 0");
    <D.20902>:
  }
  D.20903 = res;
  return D.20903;
}


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

  D.20906 = domain->lock_free_mp;
  D.20905 = lock_free_mempool_alloc0 (D.20906, size);
  return D.20905;
}


lock_free_mempool_alloc0 (struct LockFreeMempool * mp, guint size)
{
  unsigned int D.20908;
  int size.69;
  int * D.20912;
  int size.70;
  unsigned int oldpos.71;
  unsigned int D.20915;
  int D.20916;
  unsigned int D.20917;
  int D.20920;
  unsigned int D.20921;
  unsigned int D.20922;
  _Bool D.20923;
  long int D.20924;
  long int D.20925;
  int D.20928;
  guint8 * D.20930;
  sizetype D.20931;
  void * D.20932;
  struct LockFreeMempoolChunk * chunk;
  void * res;
  int oldpos;

  D.20908 = size + 7;
  size = D.20908 & 4294967288;
  chunk = mp->current;
  if (chunk == 0B) goto <D.20909>; else goto <D.20910>;
  <D.20909>:
  size.69 = (int) size;
  chunk = lock_free_mempool_chunk_new (mp, size.69);
  mono_memory_barrier ();
  mp->current = chunk;
  <D.20910>:
  D.20912 = &chunk->pos;
  size.70 = (int) size;
  oldpos = InterlockedExchangeAdd (D.20912, size.70);
  oldpos.71 = (unsigned int) oldpos;
  D.20915 = oldpos.71 + size;
  D.20916 = chunk->size;
  D.20917 = (unsigned int) D.20916;
  if (D.20915 > D.20917) goto <D.20918>; else goto <D.20919>;
  <D.20918>:
  size.69 = (int) size;
  chunk = lock_free_mempool_chunk_new (mp, size.69);
  D.20920 = chunk->pos;
  D.20921 = (unsigned int) D.20920;
  D.20922 = D.20921 + size;
  D.20916 = chunk->size;
  D.20917 = (unsigned int) D.20916;
  D.20923 = D.20922 > D.20917;
  D.20924 = (long int) D.20923;
  D.20925 = __builtin_expect (D.20924, 0);
  if (D.20925 != 0) goto <D.20926>; else goto <D.20927>;
  <D.20926>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "domain.c", 1085, "chunk->pos + size <= chunk->size");
  <D.20927>:
  res = chunk->mem;
  D.20920 = chunk->pos;
  D.20921 = (unsigned int) D.20920;
  D.20922 = D.20921 + size;
  D.20928 = (int) D.20922;
  chunk->pos = D.20928;
  mono_memory_barrier ();
  mp->current = chunk;
  goto <D.20929>;
  <D.20919>:
  D.20930 = chunk->mem;
  D.20931 = (sizetype) oldpos;
  res = D.20930 + D.20931;
  <D.20929>:
  D.20932 = res;
  return D.20932;
}


InterlockedExchangeAdd (volatile gint32 * val, gint32 add)
{
  gint32 D.20934;
  unsigned int add.72;
  unsigned int D.20936;

  add.72 = (unsigned int) add;
  D.20936 = __sync_fetch_and_add_4 (val, add.72);
  D.20934 = (gint32) D.20936;
  return D.20934;
}


lock_free_mempool_chunk_new (struct LockFreeMempool * mp, int len)
{
  int D.20938;
  long unsigned int D.20939;
  long unsigned int D.20940;
  long unsigned int D.20941;
  long unsigned int D.20942;
  _Bool D.20943;
  long int D.20944;
  long int D.20945;
  char * D.20948;
  long int D.20949;
  long int D.20950;
  long int D.20951;
  guint8 * D.20952;
  sizetype D.20953;
  char * D.20954;
  long int D.20955;
  guint8 * D.20956;
  long int D.20957;
  long int D.20958;
  int D.20959;
  struct LockFreeMempoolChunk * * D.20960;
  void * D.20961;
  struct LockFreeMempoolChunk * D.20963;
  struct LockFreeMempoolChunk * chunk;
  struct LockFreeMempoolChunk * prev;
  int size;

  size = mono_pagesize ();
  goto <D.18614>;
  <D.18613>:
  D.20938 = mono_pagesize ();
  size = D.20938 + size;
  <D.18614>:
  D.20939 = (long unsigned int) size;
  D.20940 = D.20939 + 18446744073709551592;
  D.20941 = (long unsigned int) len;
  if (D.20940 < D.20941) goto <D.18613>; else goto <D.18615>;
  <D.18615>:
  D.20942 = (long unsigned int) size;
  chunk = mono_valloc (0B, D.20942, 3);
  D.20943 = chunk == 0B;
  D.20944 = (long int) D.20943;
  D.20945 = __builtin_expect (D.20944, 0);
  if (D.20945 != 0) goto <D.20946>; else goto <D.20947>;
  <D.20946>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "domain.c", 1044, "chunk");
  <D.20947>:
  D.20948 = chunk + 24;
  D.20949 = (long int) D.20948;
  D.20950 = D.20949 + 15;
  D.20951 = D.20950 & -16;
  D.20952 = (guint8 *) D.20951;
  chunk->mem = D.20952;
  D.20953 = (sizetype) size;
  D.20954 = chunk + D.20953;
  D.20955 = (long int) D.20954;
  D.20956 = chunk->mem;
  D.20957 = (long int) D.20956;
  D.20958 = D.20955 - D.20957;
  D.20959 = (int) D.20958;
  chunk->size = D.20959;
  chunk->pos = 0;
  <D.18617>:
  prev = mp->chunks;
  D.20960 = &mp->chunks;
  D.20961 = InterlockedCompareExchangePointer (D.20960, chunk, prev);
  if (D.20961 == prev) goto <D.18616>; else goto <D.20962>;
  <D.20962>:
  goto <D.18617>;
  <D.18616>:
  chunk->prev = prev;
  D.20963 = chunk;
  return D.20963;
}


InterlockedCompareExchangePointer (void * volatile * dest, void * exch, void * comp)
{
  void * D.20965;
  long unsigned int comp.73;
  long unsigned int exch.74;
  long unsigned int D.20968;

  comp.73 = (long unsigned int) comp;
  exch.74 = (long unsigned int) exch;
  D.20968 = __sync_val_compare_and_swap_8 (dest, comp.73, exch.74);
  D.20965 = (void *) D.20968;
  return D.20965;
}


mono_domain_code_reserve (struct MonoDomain * domain, int size)
{
  union mono_mutex_t * D.20970;
  _Bool D.20973;
  long int D.20974;
  long int D.20975;
  struct MonoCodeManager * D.20978;
  _Bool D.20981;
  long int D.20982;
  long int D.20983;
  void * D.20986;
  void * res;

  {
    int ret;

    D.20970 = &domain->lock.mutex;
    ret = pthread_mutex_lock (D.20970);
    if (ret != 0) goto <D.20971>; else goto <D.20972>;
    <D.20971>:
    monoeg_g_log (0B, 16, "Bad call to mono_mutex_lock result %d", ret);
    <D.20972>:
    D.20973 = ret != 0;
    D.20974 = (long int) D.20973;
    D.20975 = __builtin_expect (D.20974, 0);
    if (D.20975 != 0) goto <D.20976>; else goto <D.20977>;
    <D.20976>:
    monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "domain.c", 2216, "ret == 0");
    <D.20977>:
  }
  D.20978 = domain->code_mp;
  res = mono_code_manager_reserve (D.20978, size);
  {
    int ret;

    D.20970 = &domain->lock.mutex;
    ret = pthread_mutex_unlock (D.20970);
    if (ret != 0) goto <D.20979>; else goto <D.20980>;
    <D.20979>:
    monoeg_g_log (0B, 16, "Bad call to mono_mutex_unlock result %d", ret);
    <D.20980>:
    D.20981 = ret != 0;
    D.20982 = (long int) D.20981;
    D.20983 = __builtin_expect (D.20982, 0);
    if (D.20983 != 0) goto <D.20984>; else goto <D.20985>;
    <D.20984>:
    monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "domain.c", 2218, "ret == 0");
    <D.20985>:
  }
  D.20986 = res;
  return D.20986;
}


mono_domain_code_reserve_align (struct MonoDomain * domain, int size, int alignment)
{
  union mono_mutex_t * D.20988;
  _Bool D.20991;
  long int D.20992;
  long int D.20993;
  struct MonoCodeManager * D.20996;
  _Bool D.20999;
  long int D.21000;
  long int D.21001;
  void * D.21004;
  void * res;

  {
    int ret;

    D.20988 = &domain->lock.mutex;
    ret = pthread_mutex_lock (D.20988);
    if (ret != 0) goto <D.20989>; else goto <D.20990>;
    <D.20989>:
    monoeg_g_log (0B, 16, "Bad call to mono_mutex_lock result %d", ret);
    <D.20990>:
    D.20991 = ret != 0;
    D.20992 = (long int) D.20991;
    D.20993 = __builtin_expect (D.20992, 0);
    if (D.20993 != 0) goto <D.20994>; else goto <D.20995>;
    <D.20994>:
    monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "domain.c", 2233, "ret == 0");
    <D.20995>:
  }
  D.20996 = domain->code_mp;
  res = mono_code_manager_reserve_align (D.20996, size, alignment);
  {
    int ret;

    D.20988 = &domain->lock.mutex;
    ret = pthread_mutex_unlock (D.20988);
    if (ret != 0) goto <D.20997>; else goto <D.20998>;
    <D.20997>:
    monoeg_g_log (0B, 16, "Bad call to mono_mutex_unlock result %d", ret);
    <D.20998>:
    D.20999 = ret != 0;
    D.21000 = (long int) D.20999;
    D.21001 = __builtin_expect (D.21000, 0);
    if (D.21001 != 0) goto <D.21002>; else goto <D.21003>;
    <D.21002>:
    monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "domain.c", 2235, "ret == 0");
    <D.21003>:
  }
  D.21004 = res;
  return D.21004;
}


mono_domain_code_commit (struct MonoDomain * domain, void * data, int size, int newsize)
{
  union mono_mutex_t * D.21006;
  _Bool D.21009;
  long int D.21010;
  long int D.21011;
  struct MonoCodeManager * D.21014;
  _Bool D.21017;
  long int D.21018;
  long int D.21019;

  {
    int ret;

    D.21006 = &domain->lock.mutex;
    ret = pthread_mutex_lock (D.21006);
    if (ret != 0) goto <D.21007>; else goto <D.21008>;
    <D.21007>:
    monoeg_g_log (0B, 16, "Bad call to mono_mutex_lock result %d", ret);
    <D.21008>:
    D.21009 = ret != 0;
    D.21010 = (long int) D.21009;
    D.21011 = __builtin_expect (D.21010, 0);
    if (D.21011 != 0) goto <D.21012>; else goto <D.21013>;
    <D.21012>:
    monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "domain.c", 2248, "ret == 0");
    <D.21013>:
  }
  D.21014 = domain->code_mp;
  mono_code_manager_commit (D.21014, data, size, newsize);
  {
    int ret;

    D.21006 = &domain->lock.mutex;
    ret = pthread_mutex_unlock (D.21006);
    if (ret != 0) goto <D.21015>; else goto <D.21016>;
    <D.21015>:
    monoeg_g_log (0B, 16, "Bad call to mono_mutex_unlock result %d", ret);
    <D.21016>:
    D.21017 = ret != 0;
    D.21018 = (long int) D.21017;
    D.21019 = __builtin_expect (D.21018, 0);
    if (D.21019 != 0) goto <D.21020>; else goto <D.21021>;
    <D.21020>:
    monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "domain.c", 2250, "ret == 0");
    <D.21021>:
  }
}


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

  D.21022 = data;
  return D.21022;
}


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.21024;
  _Bool D.21027;
  long int D.21028;
  long int D.21029;
  struct MonoCodeManager * D.21032;
  _Bool D.21035;
  long int D.21036;
  long int D.21037;

  {
    int ret;

    D.21024 = &domain->lock.mutex;
    ret = pthread_mutex_lock (D.21024);
    if (ret != 0) goto <D.21025>; else goto <D.21026>;
    <D.21025>:
    monoeg_g_log (0B, 16, "Bad call to mono_mutex_lock result %d", ret);
    <D.21026>:
    D.21027 = ret != 0;
    D.21028 = (long int) D.21027;
    D.21029 = __builtin_expect (D.21028, 0);
    if (D.21029 != 0) goto <D.21030>; else goto <D.21031>;
    <D.21030>:
    monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "domain.c", 2317, "ret == 0");
    <D.21031>:
  }
  D.21032 = domain->code_mp;
  mono_code_manager_foreach (D.21032, func, user_data);
  {
    int ret;

    D.21024 = &domain->lock.mutex;
    ret = pthread_mutex_unlock (D.21024);
    if (ret != 0) goto <D.21033>; else goto <D.21034>;
    <D.21033>:
    monoeg_g_log (0B, 16, "Bad call to mono_mutex_unlock result %d", ret);
    <D.21034>:
    D.21035 = ret != 0;
    D.21036 = (long int) D.21035;
    D.21037 = __builtin_expect (D.21036, 0);
    if (D.21037 != 0) goto <D.21038>; else goto <D.21039>;
    <D.21038>:
    monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "domain.c", 2319, "ret == 0");
    <D.21039>:
  }
}


mono_context_set (struct MonoAppContext * new_context)
{
  struct MonoInternalThread * D.21040;
  struct MonoInternalThread * D.21041;
  struct MonoAppContext * * D.21042;

  D.21040 = mono_thread_internal_current ();
  D.21041 = mono_thread_internal_current ();
  D.21042 = &D.21041->current_appcontext;
  mono_gc_wbarrier_set_field (D.21040, D.21042, new_context);
}


mono_context_get ()
{
  struct MonoAppContext * D.21043;
  struct MonoInternalThread * D.21044;

  D.21044 = mono_thread_internal_current ();
  D.21043 = D.21044->current_appcontext;
  return D.21043;
}


mono_domain_add_class_static_data (struct MonoDomain * domain, struct MonoClass * klass, void * data, guint32 * bitmap)
{
  void * * D.21046;
  void * * D.21049;
  void * D.21050;
  long int D.21051;
  void * D.21052;
  long int D.21053;
  int D.21056;
  long unsigned int D.21057;
  long unsigned int D.21058;
  void * iftmp.75;
  int D.21060;
  long unsigned int D.21064;
  long unsigned int D.21065;
  void * * D.21066;
  long int D.21067;
  void * D.21068;
  long unsigned int D.21070;
  long unsigned int D.21071;
  void * iftmp.76;
  int D.21073;
  long int D.21077;
  void * D.21078;
  void * * D.21079;
  long int D.21080;
  void * D.21081;
  int next.77;
  long unsigned int D.21083;
  long unsigned int D.21084;
  void * * D.21085;
  int next;

  D.21046 = domain->static_data_array;
  if (D.21046 != 0B) goto <D.21047>; else goto <D.21048>;
  <D.21047>:
  {
    int size;

    D.21046 = domain->static_data_array;
    D.21049 = D.21046 + 8;
    D.21050 = *D.21049;
    D.21051 = (long int) D.21050;
    size = (int) D.21051;
    D.21046 = domain->static_data_array;
    D.21052 = *D.21046;
    D.21053 = (long int) D.21052;
    next = (int) D.21053;
    if (next >= size) goto <D.21054>; else goto <D.21055>;
    <D.21054>:
    {
      void * * new_array;

      D.21056 = size * 2;
      D.21057 = (long unsigned int) D.21056;
      D.21058 = D.21057 * 8;
      D.21060 = mono_gc_is_moving ();
      if (D.21060 != 0) goto <D.21061>; else goto <D.21062>;
      <D.21061>:
      iftmp.75 = mono_gc_make_root_descr_all_refs (0);
      goto <D.21063>;
      <D.21062>:
      iftmp.75 = 0B;
      <D.21063>:
      new_array = mono_gc_alloc_fixed (D.21058, iftmp.75);
      D.21046 = domain->static_data_array;
      D.21064 = (long unsigned int) size;
      D.21065 = D.21064 * 8;
      mono_gc_memmove_aligned (new_array, D.21046, D.21065);
      size = size * 2;
      D.21066 = new_array + 8;
      D.21067 = (long int) size;
      D.21068 = (void *) D.21067;
      *D.21066 = D.21068;
      D.21046 = domain->static_data_array;
      mono_gc_free_fixed (D.21046);
      domain->static_data_array = new_array;
    }
    <D.21055>:
  }
  goto <D.21069>;
  <D.21048>:
  {
    int size;
    void * * new_array;

    size = 32;
    D.21070 = (long unsigned int) size;
    D.21071 = D.21070 * 8;
    D.21073 = mono_gc_is_moving ();
    if (D.21073 != 0) goto <D.21074>; else goto <D.21075>;
    <D.21074>:
    iftmp.76 = mono_gc_make_root_descr_all_refs (0);
    goto <D.21076>;
    <D.21075>:
    iftmp.76 = 0B;
    <D.21076>:
    new_array = mono_gc_alloc_fixed (D.21071, iftmp.76);
    next = 2;
    D.21077 = (long int) next;
    D.21078 = (void *) D.21077;
    *new_array = D.21078;
    D.21079 = new_array + 8;
    D.21080 = (long int) size;
    D.21081 = (void *) D.21080;
    *D.21079 = D.21081;
    domain->static_data_array = new_array;
  }
  <D.21069>:
  D.21046 = domain->static_data_array;
  next.77 = next;
  next = next.77 + 1;
  D.21083 = (long unsigned int) next.77;
  D.21084 = D.21083 * 8;
  D.21085 = D.21046 + D.21084;
  *D.21085 = data;
  D.21046 = domain->static_data_array;
  D.21077 = (long int) next;
  D.21078 = (void *) D.21077;
  *D.21046 = D.21078;
}


mono_get_corlib ()
{
  struct MonoImage * D.21086;

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


mono_get_object_class ()
{
  struct MonoClass * D.21088;

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


mono_get_byte_class ()
{
  struct MonoClass * D.21090;

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


mono_get_void_class ()
{
  struct MonoClass * D.21092;

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


mono_get_boolean_class ()
{
  struct MonoClass * D.21094;

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


mono_get_sbyte_class ()
{
  struct MonoClass * D.21096;

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


mono_get_int16_class ()
{
  struct MonoClass * D.21098;

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


mono_get_uint16_class ()
{
  struct MonoClass * D.21100;

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


mono_get_int32_class ()
{
  struct MonoClass * D.21102;

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


mono_get_uint32_class ()
{
  struct MonoClass * D.21104;

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


mono_get_intptr_class ()
{
  struct MonoClass * D.21106;

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


mono_get_uintptr_class ()
{
  struct MonoClass * D.21108;

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


mono_get_int64_class ()
{
  struct MonoClass * D.21110;

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


mono_get_uint64_class ()
{
  struct MonoClass * D.21112;

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


mono_get_single_class ()
{
  struct MonoClass * D.21114;

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


mono_get_double_class ()
{
  struct MonoClass * D.21116;

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


mono_get_char_class ()
{
  struct MonoClass * D.21118;

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


mono_get_string_class ()
{
  struct MonoClass * D.21120;

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


mono_get_enum_class ()
{
  struct MonoClass * D.21122;

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


mono_get_array_class ()
{
  struct MonoClass * D.21124;

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


mono_get_thread_class ()
{
  struct MonoClass * D.21126;

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


mono_get_exception_class ()
{
  struct MonoClass * D.21128;

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


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

  D.21130 = current_runtime;
  return D.21130;
}


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


mono_framework_version ()
{
  int D.21142;
  const struct MonoRuntimeInfo * current_runtime.79;
  char D.21144;
  int D.21145;

  current_runtime.79 = current_runtime;
  D.21144 = current_runtime.79->framework_version[0];
  D.21145 = (int) D.21144;
  D.21142 = D.21145 + -48;
  return D.21142;
}