mono_domain_get_tls_key ()
{
  pthread_key_t D.18598;

  D.18598 = appdomain_thread_id;
  return D.18598;
}


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

  offset = -1;
  {
    guint64 foo;

    __asm__("movq $tls_appdomain@TPOFF, %0" : "=r" foo);
    offset = (int) foo;
  }
  D.18600 = offset;
  return D.18600;
}


mono_jit_info_table_find_internal (struct MonoDomain * domain, char * addr, gboolean try_aot)
{
  long unsigned int D.18602;
  long unsigned int D.18603;
  struct MonoJitInfoTable * volatile * D.18604;
  struct MonoJitInfo * D.18611;
  struct MonoDomain * mono_root_domain.0;
  struct MonoJitInfoTable * D.18617;
  struct MonoJitInfoTable * volatile * D.18620;
  struct MonoJitInfo * (*<T1a3c>) (struct MonoDomain *, struct MonoImage *, void *) jit_info_find_in_aot_func.1;
  struct MonoImage * D.18624;
  struct MonoJitInfoTable * table;
  struct MonoJitInfo * ji;
  struct MonoJitInfo * module_ji;
  struct MonoThreadHazardPointers * hp;

  hp = mono_hazard_pointer_get ();
  D.18602 = mono_stats.jit_info_table_lookup_count;
  D.18603 = D.18602 + 1;
  mono_stats.jit_info_table_lookup_count = D.18603;
  D.18604 = &domain->jit_info_table;
  table = get_hazardous_pointer (D.18604, hp, 0);
  ji = jit_info_table_find (table, hp, addr);
  if (hp != 0B) goto <D.18605>; else goto <D.18606>;
  <D.18605>:
  if (0 != 0) goto <D.18607>; else goto <D.18608>;
  <D.18607>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "domain.c", 401, "(0) >= 0 && (0) < HAZARD_POINTER_COUNT");
  <D.18608>:
  hp->hazard_pointers[0] = 0B;
  <D.18606>:
  if (ji != 0B) goto <D.18609>; else goto <D.18610>;
  <D.18609>:
  D.18611 = ji;
  return D.18611;
  <D.18610>:
  if (try_aot != 0) goto <D.18612>; else goto <D.18613>;
  <D.18612>:
  mono_root_domain.0 = mono_root_domain;
  if (mono_root_domain.0 != 0B) goto <D.18615>; else goto <D.18616>;
  <D.18615>:
  mono_root_domain.0 = mono_root_domain;
  D.18617 = mono_root_domain.0->aot_modules;
  if (D.18617 != 0B) goto <D.18618>; else goto <D.18619>;
  <D.18618>:
  mono_root_domain.0 = mono_root_domain;
  D.18620 = &mono_root_domain.0->aot_modules;
  table = get_hazardous_pointer (D.18620, hp, 0);
  module_ji = jit_info_table_find (table, hp, addr);
  if (module_ji != 0B) goto <D.18621>; else goto <D.18622>;
  <D.18621>:
  jit_info_find_in_aot_func.1 = jit_info_find_in_aot_func;
  D.18624 = module_ji->d.image;
  ji = jit_info_find_in_aot_func.1 (domain, D.18624, addr);
  <D.18622>:
  if (hp != 0B) goto <D.18625>; else goto <D.18626>;
  <D.18625>:
  if (0 != 0) goto <D.18627>; else goto <D.18628>;
  <D.18627>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "domain.c", 412, "(0) >= 0 && (0) < HAZARD_POINTER_COUNT");
  <D.18628>:
  hp->hazard_pointers[0] = 0B;
  <D.18626>:
  <D.18619>:
  <D.18616>:
  <D.18613>:
  D.18611 = ji;
  return D.18611;
}


jit_info_table_find (struct MonoJitInfoTable * table, struct MonoThreadHazardPointers * hp, gint8 * addr)
{
  int D.18630;
  _Bool D.18631;
  long int D.18632;
  long int D.18633;
  struct MonoJitInfoTableChunk * D.18636;
  struct MonoJitInfo * volatile * D.18637;
  struct MonoMethod * D.18638;
  void * D.18643;
  int D.18646;
  sizetype D.18647;
  gint8 * D.18648;
  struct MonoJitInfo * D.18653;
  int D.18655;
  struct MonoJitInfo * ji;
  int chunk_pos;
  int pos;
  void not_found = <<< error >>>;

  chunk_pos = jit_info_table_index (table, addr);
  D.18630 = table->num_chunks;
  D.18631 = D.18630 <= chunk_pos;
  D.18632 = (long int) D.18631;
  D.18633 = __builtin_expect (D.18632, 0);
  if (D.18633 != 0) goto <D.18634>; else goto <D.18635>;
  <D.18634>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "domain.c", 327, "chunk_pos < table->num_chunks");
  <D.18635>:
  D.18636 = table->chunks[chunk_pos];
  pos = jit_info_table_chunk_index (D.18636, hp, addr);
  <D.17851>:
  {
    struct MonoJitInfoTableChunk * chunk;

    chunk = table->chunks[chunk_pos];
    goto <D.17847>;
    <D.17849>:
    D.18637 = &chunk->data[pos];
    ji = get_hazardous_pointer (D.18637, hp, 1);
    pos = pos + 1;
    D.18638 = ji->d.method;
    if (D.18638 == 0B) goto <D.18639>; else goto <D.18640>;
    <D.18639>:
    if (0 != 0) goto <D.18641>; else goto <D.18642>;
    <D.18641>:
    monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "domain.c", 345, "(1) >= 0 && (1) < HAZARD_POINTER_COUNT");
    <D.18642>:
    hp->hazard_pointers[1] = 0B;
    // predicted unlikely by continue predictor.
    goto <D.17847>;
    <D.18640>:
    D.18643 = ji->code_start;
    if (D.18643 <= addr) goto <D.18644>; else goto <D.18645>;
    <D.18644>:
    D.18643 = ji->code_start;
    D.18646 = ji->code_size;
    D.18647 = (sizetype) D.18646;
    D.18648 = D.18643 + D.18647;
    if (D.18648 > addr) goto <D.18649>; else goto <D.18650>;
    <D.18649>:
    if (0 != 0) goto <D.18651>; else goto <D.18652>;
    <D.18651>:
    monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "domain.c", 350, "(1) >= 0 && (1) < HAZARD_POINTER_COUNT");
    <D.18652>:
    hp->hazard_pointers[1] = 0B;
    D.18653 = ji;
    return D.18653;
    <D.18650>:
    <D.18645>:
    D.18643 = ji->code_start;
    if (D.18643 > addr) goto not_found; else goto <D.18654>;
    <D.18654>:
    <D.17847>:
    D.18655 = chunk->num_elements;
    if (D.18655 > pos) goto <D.17849>; else goto <D.17850>;
    <D.17850>:
    chunk_pos = chunk_pos + 1;
    pos = 0;
  }
  D.18630 = table->num_chunks;
  if (D.18630 > chunk_pos) goto <D.17851>; else goto <D.17852>;
  <D.17852>:
  not_found:
  if (hp != 0B) goto <D.18656>; else goto <D.18657>;
  <D.18656>:
  if (0 != 0) goto <D.18658>; else goto <D.18659>;
  <D.18658>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "domain.c", 367, "(1) >= 0 && (1) < HAZARD_POINTER_COUNT");
  <D.18659>:
  hp->hazard_pointers[1] = 0B;
  <D.18657>:
  D.18653 = 0B;
  return D.18653;
}


jit_info_table_index (struct MonoJitInfoTable * table, gint8 * addr)
{
  _Bool D.18661;
  long int D.18662;
  long int D.18663;
  int D.18666;
  volatile gint8 * D.18667;
  _Bool D.18671;
  long int D.18672;
  long int D.18673;
  int D.18676;
  int D.18679;
  int left;
  int right;

  left = 0;
  right = table->num_chunks;
  D.18661 = left >= right;
  D.18662 = (long int) D.18661;
  D.18663 = __builtin_expect (D.18662, 0);
  if (D.18663 != 0) goto <D.18664>; else goto <D.18665>;
  <D.18664>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "domain.c", 282, "left < right");
  <D.18665>:
  <D.17823>:
  {
    int pos;
    struct MonoJitInfoTableChunk * chunk;

    D.18666 = left + right;
    pos = D.18666 / 2;
    chunk = table->chunks[pos];
    D.18667 = chunk->last_code_end;
    if (D.18667 > addr) goto <D.18668>; else goto <D.18669>;
    <D.18668>:
    right = pos;
    goto <D.18670>;
    <D.18669>:
    left = pos + 1;
    <D.18670>:
  }
  if (left < right) goto <D.17823>; else goto <D.17824>;
  <D.17824>:
  D.18671 = left != right;
  D.18672 = (long int) D.18671;
  D.18673 = __builtin_expect (D.18672, 0);
  if (D.18673 != 0) goto <D.18674>; else goto <D.18675>;
  <D.18674>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "domain.c", 293, "left == right");
  <D.18675>:
  D.18676 = table->num_chunks;
  if (D.18676 <= left) goto <D.18677>; else goto <D.18678>;
  <D.18677>:
  D.18676 = table->num_chunks;
  D.18679 = D.18676 + -1;
  return D.18679;
  <D.18678>:
  D.18679 = left;
  return D.18679;
}


jit_info_table_chunk_index (struct MonoJitInfoTableChunk * chunk, struct MonoThreadHazardPointers * hp, gint8 * addr)
{
  int D.18681;
  struct MonoJitInfo * volatile * D.18682;
  void * D.18683;
  int D.18684;
  sizetype D.18685;
  _Bool D.18689;
  long int D.18690;
  long int D.18691;
  int D.18694;
  int left;
  int right;

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

    D.18681 = left + right;
    pos = D.18681 / 2;
    D.18682 = &chunk->data[pos];
    ji = get_hazardous_pointer (D.18682, hp, 1);
    D.18683 = ji->code_start;
    D.18684 = ji->code_size;
    D.18685 = (sizetype) D.18684;
    code_end = D.18683 + D.18685;
    if (addr < code_end) goto <D.18686>; else goto <D.18687>;
    <D.18686>:
    right = pos;
    goto <D.18688>;
    <D.18687>:
    left = pos + 1;
    <D.18688>:
  }
  <D.17836>:
  if (left < right) goto <D.17835>; else goto <D.17837>;
  <D.17837>:
  D.18689 = left != right;
  D.18690 = (long int) D.18689;
  D.18691 = __builtin_expect (D.18690, 0);
  if (D.18691 != 0) goto <D.18692>; else goto <D.18693>;
  <D.18692>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "domain.c", 315, "left == right");
  <D.18693>:
  D.18694 = left;
  return D.18694;
}


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

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


mono_jit_info_table_add (struct MonoDomain * domain, struct MonoJitInfo * ji)
{
  struct MonoMethod * D.18698;
  _Bool D.18699;
  long int D.18700;
  long int D.18701;
  union mono_mutex_t * D.18704;
  _Bool D.18707;
  long int D.18708;
  long int D.18709;
  long unsigned int D.18712;
  long unsigned int D.18713;
  struct MonoJitInfoTable * volatile * D.18714;
  _Bool D.18717;
  long int D.18718;
  long int D.18719;

  D.18698 = ji->d.method;
  D.18699 = D.18698 == 0B;
  D.18700 = (long int) D.18699;
  D.18701 = __builtin_expect (D.18700, 0);
  if (D.18701 != 0) goto <D.18702>; else goto <D.18703>;
  <D.18702>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "domain.c", 749, "ji->d.method != NULL");
  <D.18703>:
  {
    int ret;

    D.18704 = &domain->lock.mutex;
    ret = pthread_mutex_lock (D.18704);
    if (ret != 0) goto <D.18705>; else goto <D.18706>;
    <D.18705>:
    monoeg_g_log (0B, 16, "Bad call to mono_mutex_lock result %d", ret);
    <D.18706>:
    D.18707 = ret != 0;
    D.18708 = (long int) D.18707;
    D.18709 = __builtin_expect (D.18708, 0);
    if (D.18709 != 0) goto <D.18710>; else goto <D.18711>;
    <D.18710>:
    monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "domain.c", 751, "ret == 0");
    <D.18711>:
  }
  D.18712 = mono_stats.jit_info_table_insert_count;
  D.18713 = D.18712 + 1;
  mono_stats.jit_info_table_insert_count = D.18713;
  D.18714 = &domain->jit_info_table;
  jit_info_table_add (domain, D.18714, ji);
  {
    int ret;

    D.18704 = &domain->lock.mutex;
    ret = pthread_mutex_unlock (D.18704);
    if (ret != 0) goto <D.18715>; else goto <D.18716>;
    <D.18715>:
    monoeg_g_log (0B, 16, "Bad call to mono_mutex_unlock result %d", ret);
    <D.18716>:
    D.18717 = ret != 0;
    D.18718 = (long int) D.18717;
    D.18719 = __builtin_expect (D.18718, 0);
    if (D.18719 != 0) goto <D.18720>; else goto <D.18721>;
    <D.18720>:
    monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "domain.c", 757, "ret == 0");
    <D.18721>:
  }
}


jit_info_table_add (struct MonoDomain * domain, struct MonoJitInfoTable * volatile * table_ptr, struct MonoJitInfo * ji)
{
  void * D.18722;
  int D.18723;
  sizetype D.18724;
  gint8 * D.18725;
  int D.18726;
  _Bool D.18727;
  long int D.18728;
  long int D.18729;
  int D.18732;
  int D.18735;
  int D.18736;
  int D.18739;
  struct MonoJitInfo * D.18740;
  int D.18742;
  struct MonoJitInfo * D.18743;
  int D.18744;
  int D.18745;
  struct MonoJitInfo * D.18746;
  void * D.18747;
  int D.18748;
  int D.18749;
  struct MonoJitInfo * D.18750;
  int D.18751;
  sizetype D.18752;
  volatile gint8 * D.18753;
  struct MonoJitInfoTable * table;
  struct MonoJitInfoTableChunk * chunk;
  int chunk_pos;
  int pos;
  int num_elements;
  int i;
  void restart = <<< error >>>;

  table = *table_ptr;
  restart:
  D.18722 = ji->code_start;
  D.18723 = ji->code_size;
  D.18724 = (sizetype) D.18723;
  D.18725 = D.18722 + D.18724;
  chunk_pos = jit_info_table_index (table, D.18725);
  D.18726 = table->num_chunks;
  D.18727 = D.18726 <= chunk_pos;
  D.18728 = (long int) D.18727;
  D.18729 = __builtin_expect (D.18728, 0);
  if (D.18729 != 0) goto <D.18730>; else goto <D.18731>;
  <D.18730>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "domain.c", 693, "chunk_pos < table->num_chunks");
  <D.18731>:
  chunk = table->chunks[chunk_pos];
  D.18732 = chunk->num_elements;
  if (D.18732 > 63) goto <D.18733>; else goto <D.18734>;
  <D.18733>:
  {
    struct MonoJitInfoTable * new_table;

    new_table = jit_info_table_chunk_overflow (table, chunk);
    *table_ptr = new_table;
    mono_memory_barrier ();
    D.18735 = domain->num_jit_info_tables;
    D.18736 = D.18735 + 1;
    domain->num_jit_info_tables = D.18736;
    mono_thread_hazardous_free_or_queue (table, jit_info_table_free, 1, 0);
    table = new_table;
    goto restart;
  }
  <D.18734>:
  num_elements = chunk->num_elements;
  D.18722 = ji->code_start;
  D.18723 = ji->code_size;
  D.18724 = (sizetype) D.18723;
  D.18725 = D.18722 + D.18724;
  pos = jit_info_table_chunk_index (chunk, 0B, D.18725);
  if (num_elements > 0) goto <D.18737>; else goto <D.18738>;
  <D.18737>:
  D.18739 = num_elements + -1;
  D.18740 = chunk->data[D.18739];
  chunk->data[num_elements] = D.18740;
  goto <D.18741>;
  <D.18738>:
  chunk->data[0] = ji;
  <D.18741>:
  mono_memory_write_barrier ();
  num_elements = num_elements + 1;
  chunk->num_elements = num_elements;
  i = num_elements + -2;
  goto <D.17970>;
  <D.17969>:
  mono_memory_write_barrier ();
  D.18742 = i + 1;
  D.18743 = chunk->data[i];
  chunk->data[D.18742] = D.18743;
  i = i + -1;
  <D.17970>:
  if (i >= pos) goto <D.17969>; else goto <D.17971>;
  <D.17971>:
  mono_memory_write_barrier ();
  chunk->data[pos] = ji;
  D.18744 = chunk->num_elements;
  D.18745 = D.18744 + -1;
  D.18746 = chunk->data[D.18745];
  D.18747 = D.18746->code_start;
  D.18748 = chunk->num_elements;
  D.18749 = D.18748 + -1;
  D.18750 = chunk->data[D.18749];
  D.18751 = D.18750->code_size;
  D.18752 = (sizetype) D.18751;
  D.18753 = D.18747 + D.18752;
  chunk->last_code_end = D.18753;
}


jit_info_table_free (struct MonoJitInfoTable * table)
{
  union mono_mutex_t * D.18754;
  _Bool D.18757;
  long int D.18758;
  long int D.18759;
  struct MonoDomain * D.18762;
  int D.18763;
  int D.18764;
  void * D.18767;
  struct GSList * D.18768;
  int D.18769;
  int D.18770;
  struct MonoMethod * D.18773;
  _Bool D.18778;
  long int D.18779;
  long int D.18780;
  int i;
  int num_chunks;
  struct MonoDomain * domain;

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

    D.18754 = &domain->lock.mutex;
    ret = pthread_mutex_lock (D.18754);
    if (ret != 0) goto <D.18755>; else goto <D.18756>;
    <D.18755>:
    monoeg_g_log (0B, 16, "Bad call to mono_mutex_lock result %d", ret);
    <D.18756>:
    D.18757 = ret != 0;
    D.18758 = (long int) D.18757;
    D.18759 = __builtin_expect (D.18758, 0);
    if (D.18759 != 0) goto <D.18760>; else goto <D.18761>;
    <D.18760>:
    monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "domain.c", 216, "ret == 0");
    <D.18761>:
  }
  D.18762 = table->domain;
  D.18763 = D.18762->num_jit_info_tables;
  D.18764 = D.18763 + -1;
  D.18762->num_jit_info_tables = D.18764;
  D.18762 = table->domain;
  D.18763 = D.18762->num_jit_info_tables;
  if (D.18763 <= 1) goto <D.18765>; else goto <D.18766>;
  <D.18765>:
  {
    struct GSList * list;

    D.18762 = table->domain;
    list = D.18762->jit_info_free_queue;
    goto <D.17801>;
    <D.17800>:
    D.18767 = list->data;
    monoeg_g_free (D.18767);
    list = list->next;
    <D.17801>:
    if (list != 0B) goto <D.17800>; else goto <D.17802>;
    <D.17802>:
    D.18762 = table->domain;
    D.18768 = D.18762->jit_info_free_queue;
    monoeg_g_slist_free (D.18768);
    D.18762 = table->domain;
    D.18762->jit_info_free_queue = 0B;
  }
  <D.18766>:
  i = 0;
  goto <D.17812>;
  <D.17811>:
  {
    struct MonoJitInfoTableChunk * chunk;
    int num_elements;
    int j;

    chunk = table->chunks[i];
    D.18769 = chunk->refcount;
    D.18770 = D.18769 + -1;
    chunk->refcount = D.18770;
    D.18769 = chunk->refcount;
    if (D.18769 > 0) goto <D.18771>; else goto <D.18772>;
    <D.18771>:
    // predicted unlikely by continue predictor.
    goto <D.17806>;
    <D.18772>:
    num_elements = chunk->num_elements;
    j = 0;
    goto <D.17809>;
    <D.17808>:
    {
      struct MonoJitInfo * ji;

      ji = chunk->data[j];
      D.18773 = ji->d.method;
      if (D.18773 == 0B) goto <D.18774>; else goto <D.18775>;
      <D.18774>:
      monoeg_g_free (ji);
      <D.18775>:
    }
    j = j + 1;
    <D.17809>:
    if (j < num_elements) goto <D.17808>; else goto <D.17810>;
    <D.17810>:
    monoeg_g_free (chunk);
  }
  <D.17806>:
  i = i + 1;
  <D.17812>:
  if (i < num_chunks) goto <D.17811>; else goto <D.17813>;
  <D.17813>:
  {
    int ret;

    D.18754 = &domain->lock.mutex;
    ret = pthread_mutex_unlock (D.18754);
    if (ret != 0) goto <D.18776>; else goto <D.18777>;
    <D.18776>:
    monoeg_g_log (0B, 16, "Bad call to mono_mutex_unlock result %d", ret);
    <D.18777>:
    D.18778 = ret != 0;
    D.18779 = (long int) D.18778;
    D.18780 = __builtin_expect (D.18779, 0);
    if (D.18780 != 0) goto <D.18781>; else goto <D.18782>;
    <D.18781>:
    monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "domain.c", 252, "ret == 0");
    <D.18782>:
  }
  monoeg_g_free (table);
}


jit_info_table_chunk_overflow (struct MonoJitInfoTable * table, struct MonoJitInfoTableChunk * chunk)
{
  int D.18785;
  int D.18786;
  int D.18788;
  int D.18789;
  struct MonoJitInfoTable * D.18790;
  struct MonoJitInfo * D.18791;
  struct MonoMethod * D.18792;
  int D.18795;
  int num_elements;
  int i;

  num_elements = jit_info_table_num_elements (table);
  D.18785 = table->num_chunks;
  D.18786 = D.18785 * 32;
  if (D.18786 > num_elements) goto <D.18783>; else goto <D.18787>;
  <D.18787>:
  D.18785 = table->num_chunks;
  D.18788 = D.18785 * 320;
  D.18789 = D.18788 / 6;
  if (D.18789 < num_elements) goto <D.18783>; else goto <D.18784>;
  <D.18783>:
  D.18790 = jit_info_table_realloc (table);
  return D.18790;
  <D.18784>:
  num_elements = 0;
  i = 0;
  goto <D.17954>;
  <D.17953>:
  D.18791 = chunk->data[i];
  D.18792 = D.18791->d.method;
  if (D.18792 != 0B) goto <D.18793>; else goto <D.18794>;
  <D.18793>:
  num_elements = num_elements + 1;
  <D.18794>:
  i = i + 1;
  <D.17954>:
  D.18795 = chunk->num_elements;
  if (D.18795 > i) goto <D.17953>; else goto <D.17955>;
  <D.17955>:
  if (num_elements == 64) goto <D.18796>; else goto <D.18797>;
  <D.18796>:
  D.18790 = jit_info_table_copy_and_split_chunk (table, chunk);
  return D.18790;
  <D.18797>:
  D.18790 = jit_info_table_copy_and_purify_chunk (table, chunk);
  return D.18790;
}


jit_info_table_num_elements (struct MonoJitInfoTable * table)
{
  struct MonoJitInfo * D.18799;
  struct MonoMethod * D.18800;
  int D.18803;
  int D.18804;
  int i;
  int num_elements;

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

    chunk = table->chunks[i];
    chunk_num_elements = chunk->num_elements;
    j = 0;
    goto <D.17779>;
    <D.17778>:
    D.18799 = chunk->data[j];
    D.18800 = D.18799->d.method;
    if (D.18800 != 0B) goto <D.18801>; else goto <D.18802>;
    <D.18801>:
    num_elements = num_elements + 1;
    <D.18802>:
    j = j + 1;
    <D.17779>:
    if (j < chunk_num_elements) goto <D.17778>; else goto <D.17780>;
    <D.17780>:
  }
  i = i + 1;
  <D.17782>:
  D.18803 = table->num_chunks;
  if (D.18803 > i) goto <D.17781>; else goto <D.17783>;
  <D.17783>:
  D.18804 = num_elements;
  return D.18804;
}


jit_info_table_realloc (struct MonoJitInfoTable * old)
{
  long int D.18806;
  long int D.18807;
  long int D.18808;
  int D.18809;
  _Bool D.18812;
  long int D.18813;
  long int D.18814;
  struct MonoJitInfoTable * D.18817;
  struct MonoDomain * D.18818;
  _Bool D.18819;
  long int D.18820;
  long int D.18821;
  long unsigned int D.18824;
  long unsigned int D.18825;
  long unsigned int D.18826;
  struct MonoJitInfoTableChunk * D.18827;
  struct MonoJitInfo * D.18828;
  struct MonoMethod * D.18829;
  _Bool D.18832;
  long int D.18833;
  long int D.18834;
  struct MonoJitInfoTableChunk * D.18837;
  struct MonoJitInfo * D.18838;
  int D.18841;
  int D.18844;
  _Bool D.18845;
  long int D.18846;
  long int D.18847;
  int D.18850;
  _Bool D.18851;
  long int D.18852;
  long int D.18853;
  int D.18856;
  int D.18857;
  struct MonoJitInfoTableChunk * D.18858;
  void * D.18859;
  int D.18860;
  sizetype D.18861;
  volatile gint8 * D.18862;
  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.18806 = (long int) num_elements;
  D.18807 = D.18806 * 4;
  D.18808 = D.18807 / 3;
  required_size = (int) D.18808;
  D.18809 = required_size + 63;
  num_chunks = D.18809 / 64;
  if (num_chunks == 0) goto <D.18810>; else goto <D.18811>;
  <D.18810>:
  D.18812 = num_elements != 0;
  D.18813 = (long int) D.18812;
  D.18814 = __builtin_expect (D.18813, 0);
  if (D.18814 != 0) goto <D.18815>; else goto <D.18816>;
  <D.18815>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "domain.c", 480, "num_elements == 0");
  <D.18816>:
  D.18818 = old->domain;
  D.18817 = jit_info_table_new (D.18818);
  return D.18817;
  <D.18811>:
  D.18819 = num_chunks <= 0;
  D.18820 = (long int) D.18819;
  D.18821 = __builtin_expect (D.18820, 0);
  if (D.18821 != 0) goto <D.18822>; else goto <D.18823>;
  <D.18822>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "domain.c", 483, "num_chunks > 0");
  <D.18823>:
  D.18824 = (long unsigned int) num_chunks;
  D.18825 = D.18824 + 2;
  D.18826 = D.18825 * 8;
  new = monoeg_malloc (D.18826);
  D.18818 = old->domain;
  new->domain = D.18818;
  new->num_chunks = num_chunks;
  i = 0;
  goto <D.17895>;
  <D.17894>:
  D.18827 = jit_info_table_new_chunk ();
  new->chunks[i] = D.18827;
  i = i + 1;
  <D.17895>:
  if (i < num_chunks) goto <D.17894>; else goto <D.17896>;
  <D.17896>:
  new_chunk = 0;
  new_element = 0;
  i = 0;
  goto <D.17904>;
  <D.17903>:
  {
    struct MonoJitInfoTableChunk * chunk;
    int chunk_num_elements;
    int j;

    chunk = old->chunks[i];
    chunk_num_elements = chunk->num_elements;
    j = 0;
    goto <D.17901>;
    <D.17900>:
    D.18828 = chunk->data[j];
    D.18829 = D.18828->d.method;
    if (D.18829 != 0B) goto <D.18830>; else goto <D.18831>;
    <D.18830>:
    D.18832 = new_chunk >= num_chunks;
    D.18833 = (long int) D.18832;
    D.18834 = __builtin_expect (D.18833, 0);
    if (D.18834 != 0) goto <D.18835>; else goto <D.18836>;
    <D.18835>:
    monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "domain.c", 501, "new_chunk < num_chunks");
    <D.18836>:
    D.18837 = new->chunks[new_chunk];
    D.18838 = chunk->data[j];
    D.18837->data[new_element] = D.18838;
    new_element = new_element + 1;
    if (new_element > 47) goto <D.18839>; else goto <D.18840>;
    <D.18839>:
    D.18837 = new->chunks[new_chunk];
    D.18837->num_elements = new_element;
    new_chunk = new_chunk + 1;
    new_element = 0;
    <D.18840>:
    <D.18831>:
    j = j + 1;
    <D.17901>:
    if (j < chunk_num_elements) goto <D.17900>; else goto <D.17902>;
    <D.17902>:
  }
  i = i + 1;
  <D.17904>:
  D.18841 = old->num_chunks;
  if (D.18841 > i) goto <D.17903>; else goto <D.17905>;
  <D.17905>:
  if (new_chunk < num_chunks) goto <D.18842>; else goto <D.18843>;
  <D.18842>:
  D.18844 = num_chunks + -1;
  D.18845 = D.18844 != new_chunk;
  D.18846 = (long int) D.18845;
  D.18847 = __builtin_expect (D.18846, 0);
  if (D.18847 != 0) goto <D.18848>; else goto <D.18849>;
  <D.18848>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "domain.c", 513, "new_chunk == num_chunks - 1");
  <D.18849>:
  D.18837 = new->chunks[new_chunk];
  D.18837->num_elements = new_element;
  D.18837 = new->chunks[new_chunk];
  D.18850 = D.18837->num_elements;
  D.18851 = D.18850 <= 0;
  D.18852 = (long int) D.18851;
  D.18853 = __builtin_expect (D.18852, 0);
  if (D.18853 != 0) goto <D.18854>; else goto <D.18855>;
  <D.18854>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "domain.c", 515, "new->chunks [new_chunk]->num_elements > 0");
  <D.18855>:
  <D.18843>:
  i = 0;
  goto <D.17909>;
  <D.17908>:
  {
    struct MonoJitInfoTableChunk * chunk;
    struct MonoJitInfo * ji;

    chunk = new->chunks[i];
    D.18856 = chunk->num_elements;
    D.18857 = D.18856 + -1;
    ji = chunk->data[D.18857];
    D.18858 = new->chunks[i];
    D.18859 = ji->code_start;
    D.18860 = ji->code_size;
    D.18861 = (sizetype) D.18860;
    D.18862 = D.18859 + D.18861;
    D.18858->last_code_end = D.18862;
  }
  i = i + 1;
  <D.17909>:
  if (i < num_chunks) goto <D.17908>; else goto <D.17910>;
  <D.17910>:
  D.18817 = new;
  return D.18817;
}


jit_info_table_new (struct MonoDomain * domain)
{
  struct MonoJitInfoTableChunk * D.18864;
  struct MonoJitInfoTable * D.18865;
  struct MonoJitInfoTable * table;

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


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

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


jit_info_table_copy_and_split_chunk (struct MonoJitInfoTable * table, struct MonoJitInfoTableChunk * chunk)
{
  int D.18869;
  int D.18870;
  long unsigned int D.18871;
  long unsigned int D.18872;
  long unsigned int D.18873;
  struct MonoDomain * D.18874;
  struct MonoJitInfoTableChunk * D.18875;
  int D.18878;
  struct MonoJitInfoTableChunk * * D.18879;
  struct MonoJitInfoTableChunk * * D.18880;
  struct MonoJitInfoTableChunk * D.18882;
  int D.18883;
  int D.18884;
  int D.18885;
  _Bool D.18886;
  long int D.18887;
  long int D.18888;
  struct MonoJitInfoTable * D.18891;
  struct MonoJitInfoTable * new_table;
  int i;
  int j;

  D.18869 = table->num_chunks;
  D.18870 = D.18869 + 1;
  D.18871 = (long unsigned int) D.18870;
  D.18872 = D.18871 + 2;
  D.18873 = D.18872 * 8;
  new_table = monoeg_malloc (D.18873);
  D.18874 = table->domain;
  new_table->domain = D.18874;
  D.18869 = table->num_chunks;
  D.18870 = D.18869 + 1;
  new_table->num_chunks = D.18870;
  j = 0;
  i = 0;
  goto <D.17926>;
  <D.17925>:
  D.18875 = table->chunks[i];
  if (D.18875 == chunk) goto <D.18876>; else goto <D.18877>;
  <D.18876>:
  D.18878 = j + 1;
  D.18879 = &new_table->chunks[D.18878];
  D.18880 = &new_table->chunks[j];
  jit_info_table_split_chunk (chunk, D.18880, D.18879);
  j = j + 2;
  goto <D.18881>;
  <D.18877>:
  D.18875 = table->chunks[i];
  new_table->chunks[j] = D.18875;
  D.18882 = new_table->chunks[j];
  D.18883 = D.18882->refcount;
  D.18884 = D.18883 + 1;
  D.18882->refcount = D.18884;
  j = j + 1;
  <D.18881>:
  i = i + 1;
  <D.17926>:
  D.18869 = table->num_chunks;
  if (D.18869 > i) goto <D.17925>; else goto <D.17927>;
  <D.17927>:
  D.18885 = new_table->num_chunks;
  D.18886 = D.18885 != j;
  D.18887 = (long int) D.18886;
  D.18888 = __builtin_expect (D.18887, 0);
  if (D.18888 != 0) goto <D.18889>; else goto <D.18890>;
  <D.18889>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "domain.c", 573, "j == new_table->num_chunks");
  <D.18890>:
  D.18891 = new_table;
  return D.18891;
}


jit_info_table_split_chunk (struct MonoJitInfoTableChunk * chunk, struct MonoJitInfoTableChunk * * new1p, struct MonoJitInfoTableChunk * * new2p)
{
  int D.18893;
  _Bool D.18894;
  long int D.18895;
  long int D.18896;
  int D.18899;
  int D.18900;
  int D.18901;
  long unsigned int D.18902;
  long unsigned int D.18903;
  struct MonoJitInfo * volatile[64] * D.18904;
  struct MonoJitInfo * volatile[64] * D.18905;
  int D.18906;
  long unsigned int D.18907;
  long unsigned int D.18908;
  int D.18909;
  sizetype D.18910;
  struct MonoJitInfo * volatile * D.18911;
  struct MonoJitInfo * volatile[64] * D.18912;
  int D.18913;
  int D.18914;
  struct MonoJitInfo * D.18915;
  void * D.18916;
  int D.18917;
  int D.18918;
  struct MonoJitInfo * D.18919;
  int D.18920;
  sizetype D.18921;
  volatile gint8 * D.18922;
  int D.18923;
  int D.18924;
  struct MonoJitInfo * D.18925;
  void * D.18926;
  int D.18927;
  int D.18928;
  struct MonoJitInfo * D.18929;
  int D.18930;
  sizetype D.18931;
  volatile gint8 * D.18932;
  struct MonoJitInfoTableChunk * new1;
  struct MonoJitInfoTableChunk * new2;

  new1 = jit_info_table_new_chunk ();
  new2 = jit_info_table_new_chunk ();
  D.18893 = chunk->num_elements;
  D.18894 = D.18893 != 64;
  D.18895 = (long int) D.18894;
  D.18896 = __builtin_expect (D.18895, 0);
  if (D.18896 != 0) goto <D.18897>; else goto <D.18898>;
  <D.18897>:
  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.18898>:
  new1->num_elements = 32;
  D.18899 = new1->num_elements;
  D.18900 = 64 - D.18899;
  new2->num_elements = D.18900;
  D.18901 = new1->num_elements;
  D.18902 = (long unsigned int) D.18901;
  D.18903 = D.18902 * 8;
  D.18904 = &chunk->data;
  D.18905 = &new1->data;
  memcpy (D.18905, D.18904, D.18903);
  D.18906 = new2->num_elements;
  D.18907 = (long unsigned int) D.18906;
  D.18908 = D.18907 * 8;
  D.18909 = new1->num_elements;
  D.18910 = (sizetype) D.18909;
  D.18911 = &chunk->data[D.18910];
  D.18912 = &new2->data;
  memcpy (D.18912, D.18911, D.18908);
  D.18913 = new1->num_elements;
  D.18914 = D.18913 + -1;
  D.18915 = new1->data[D.18914];
  D.18916 = D.18915->code_start;
  D.18917 = new1->num_elements;
  D.18918 = D.18917 + -1;
  D.18919 = new1->data[D.18918];
  D.18920 = D.18919->code_size;
  D.18921 = (sizetype) D.18920;
  D.18922 = D.18916 + D.18921;
  new1->last_code_end = D.18922;
  D.18923 = new2->num_elements;
  D.18924 = D.18923 + -1;
  D.18925 = new2->data[D.18924];
  D.18926 = D.18925->code_start;
  D.18927 = new2->num_elements;
  D.18928 = D.18927 + -1;
  D.18929 = new2->data[D.18928];
  D.18930 = D.18929->code_size;
  D.18931 = (sizetype) D.18930;
  D.18932 = D.18926 + D.18931;
  new2->last_code_end = D.18932;
  *new1p = new1;
  *new2p = new2;
}


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

  D.18934 = __builtin_object_size (__dest, 0);
  D.18933 = __builtin___memcpy_chk (__dest, __src, __len, D.18934);
  return D.18933;
}


jit_info_table_copy_and_purify_chunk (struct MonoJitInfoTable * table, struct MonoJitInfoTableChunk * chunk)
{
  int D.18936;
  long unsigned int D.18937;
  long unsigned int D.18938;
  long unsigned int D.18939;
  struct MonoDomain * D.18940;
  struct MonoJitInfoTableChunk * D.18941;
  int j.2;
  struct MonoJitInfoTableChunk * D.18945;
  struct MonoJitInfoTableChunk * D.18947;
  int D.18948;
  int D.18949;
  int D.18950;
  _Bool D.18951;
  long int D.18952;
  long int D.18953;
  struct MonoJitInfoTable * D.18956;
  struct MonoJitInfoTable * new_table;
  int i;
  int j;

  D.18936 = table->num_chunks;
  D.18937 = (long unsigned int) D.18936;
  D.18938 = D.18937 + 2;
  D.18939 = D.18938 * 8;
  new_table = monoeg_malloc (D.18939);
  D.18940 = table->domain;
  new_table->domain = D.18940;
  D.18936 = table->num_chunks;
  new_table->num_chunks = D.18936;
  j = 0;
  i = 0;
  goto <D.17945>;
  <D.17944>:
  D.18941 = table->chunks[i];
  if (D.18941 == chunk) goto <D.18942>; else goto <D.18943>;
  <D.18942>:
  j.2 = j;
  j = j.2 + 1;
  D.18941 = table->chunks[i];
  D.18945 = jit_info_table_purify_chunk (D.18941);
  new_table->chunks[j.2] = D.18945;
  goto <D.18946>;
  <D.18943>:
  D.18941 = table->chunks[i];
  new_table->chunks[j] = D.18941;
  D.18947 = new_table->chunks[j];
  D.18948 = D.18947->refcount;
  D.18949 = D.18948 + 1;
  D.18947->refcount = D.18949;
  j = j + 1;
  <D.18946>:
  i = i + 1;
  <D.17945>:
  D.18936 = table->num_chunks;
  if (D.18936 > i) goto <D.17944>; else goto <D.17946>;
  <D.17946>:
  D.18950 = new_table->num_chunks;
  D.18951 = D.18950 != j;
  D.18952 = (long int) D.18951;
  D.18953 = __builtin_expect (D.18952, 0);
  if (D.18953 != 0) goto <D.18954>; else goto <D.18955>;
  <D.18954>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "domain.c", 620, "j == new_table->num_chunks");
  <D.18955>:
  D.18956 = new_table;
  return D.18956;
}


jit_info_table_purify_chunk (struct MonoJitInfoTableChunk * old)
{
  struct MonoJitInfo * D.18958;
  struct MonoMethod * D.18959;
  int j.3;
  struct MonoJitInfo * D.18963;
  int D.18964;
  int D.18965;
  int D.18968;
  struct MonoJitInfo * D.18969;
  void * D.18970;
  struct MonoJitInfo * D.18971;
  int D.18972;
  sizetype D.18973;
  volatile gint8 * D.18974;
  volatile gint8 * D.18976;
  struct MonoJitInfoTableChunk * D.18977;
  struct MonoJitInfoTableChunk * new;
  int i;
  int j;

  new = jit_info_table_new_chunk ();
  j = 0;
  i = 0;
  goto <D.17935>;
  <D.17934>:
  D.18958 = old->data[i];
  D.18959 = D.18958->d.method;
  if (D.18959 != 0B) goto <D.18960>; else goto <D.18961>;
  <D.18960>:
  j.3 = j;
  j = j.3 + 1;
  D.18963 = old->data[i];
  new->data[j.3] = D.18963;
  <D.18961>:
  i = i + 1;
  <D.17935>:
  D.18964 = old->num_elements;
  if (D.18964 > i) goto <D.17934>; else goto <D.17936>;
  <D.17936>:
  new->num_elements = j;
  D.18965 = new->num_elements;
  if (D.18965 > 0) goto <D.18966>; else goto <D.18967>;
  <D.18966>:
  D.18968 = j + -1;
  D.18969 = new->data[D.18968];
  D.18970 = D.18969->code_start;
  D.18968 = j + -1;
  D.18971 = new->data[D.18968];
  D.18972 = D.18971->code_size;
  D.18973 = (sizetype) D.18972;
  D.18974 = D.18970 + D.18973;
  new->last_code_end = D.18974;
  goto <D.18975>;
  <D.18967>:
  D.18976 = old->last_code_end;
  new->last_code_end = D.18976;
  <D.18975>:
  D.18977 = new;
  return D.18977;
}


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.18979;
  _Bool D.18982;
  long int D.18983;
  long int D.18984;
  long unsigned int D.18987;
  long unsigned int D.18988;
  _Bool D.18991;
  long int D.18992;
  long int D.18993;
  struct MonoJitInfoTable * table;

  {
    int ret;

    D.18979 = &domain->lock.mutex;
    ret = pthread_mutex_lock (D.18979);
    if (ret != 0) goto <D.18980>; else goto <D.18981>;
    <D.18980>:
    monoeg_g_log (0B, 16, "Bad call to mono_mutex_lock result %d", ret);
    <D.18981>:
    D.18982 = ret != 0;
    D.18983 = (long int) D.18982;
    D.18984 = __builtin_expect (D.18983, 0);
    if (D.18984 != 0) goto <D.18985>; else goto <D.18986>;
    <D.18985>:
    monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "domain.c", 831, "ret == 0");
    <D.18986>:
  }
  table = domain->jit_info_table;
  D.18987 = mono_stats.jit_info_table_remove_count;
  D.18988 = D.18987 + 1;
  mono_stats.jit_info_table_remove_count = D.18988;
  jit_info_table_remove (table, ji);
  mono_jit_info_free_or_queue (domain, ji);
  {
    int ret;

    D.18979 = &domain->lock.mutex;
    ret = pthread_mutex_unlock (D.18979);
    if (ret != 0) goto <D.18989>; else goto <D.18990>;
    <D.18989>:
    monoeg_g_log (0B, 16, "Bad call to mono_mutex_unlock result %d", ret);
    <D.18990>:
    D.18991 = ret != 0;
    D.18992 = (long int) D.18991;
    D.18993 = __builtin_expect (D.18992, 0);
    if (D.18993 != 0) goto <D.18994>; else goto <D.18995>;
    <D.18994>:
    monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "domain.c", 840, "ret == 0");
    <D.18995>:
  }
}


jit_info_table_remove (struct MonoJitInfoTable * table, struct MonoJitInfo * ji)
{
  int D.18996;
  _Bool D.18997;
  long int D.18998;
  long int D.18999;
  struct MonoJitInfoTableChunk * D.19002;
  struct MonoJitInfo * D.19003;
  struct MonoJitInfo * D.19005;
  struct MonoMethod * D.19006;
  _Bool D.19007;
  long int D.19008;
  long int D.19009;
  struct MonoJitInfo * D.19012;
  void * D.19013;
  struct MonoJitInfo * D.19014;
  int D.19015;
  sizetype D.19016;
  guint8 * D.19017;
  void * D.19018;
  int D.19019;
  sizetype D.19020;
  guint8 * D.19021;
  _Bool D.19022;
  long int D.19023;
  long int D.19024;
  int D.19027;
  struct MonoJitInfo * D.19028;
  _Bool D.19029;
  long int D.19030;
  long int D.19031;
  struct MonoJitInfo * D.19034;
  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.18996 = table->num_chunks;
  D.18997 = D.18996 <= chunk_pos;
  D.18998 = (long int) D.18997;
  D.18999 = __builtin_expect (D.18998, 0);
  if (D.18999 != 0) goto <D.19000>; else goto <D.19001>;
  <D.19000>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "domain.c", 795, "chunk_pos < table->num_chunks");
  <D.19001>:
  D.19002 = table->chunks[chunk_pos];
  pos = jit_info_table_chunk_index (D.19002, 0B, start);
  <D.17998>:
  chunk = table->chunks[chunk_pos];
  goto <D.17996>;
  <D.17995>:
  D.19003 = chunk->data[pos];
  if (D.19003 == ji) goto found; else goto <D.19004>;
  <D.19004>:
  D.19005 = chunk->data[pos];
  D.19006 = D.19005->d.method;
  D.19007 = D.19006 != 0B;
  D.19008 = (long int) D.19007;
  D.19009 = __builtin_expect (D.19008, 0);
  if (D.19009 != 0) goto <D.19010>; else goto <D.19011>;
  <D.19010>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "domain.c", 806, "IS_JIT_INFO_TOMBSTONE (chunk->data [pos])");
  <D.19011>:
  D.19012 = chunk->data[pos];
  D.19013 = D.19012->code_start;
  D.19014 = chunk->data[pos];
  D.19015 = D.19014->code_size;
  D.19016 = (sizetype) D.19015;
  D.19017 = D.19013 + D.19016;
  D.19018 = ji->code_start;
  D.19019 = ji->code_size;
  D.19020 = (sizetype) D.19019;
  D.19021 = D.19018 + D.19020;
  D.19022 = D.19017 > D.19021;
  D.19023 = (long int) D.19022;
  D.19024 = __builtin_expect (D.19023, 0);
  if (D.19024 != 0) goto <D.19025>; else goto <D.19026>;
  <D.19025>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "domain.c", 808, "(guint8*)chunk->data [pos]->code_start + chunk->data [pos]->code_size <= (guint8*)ji->code_start + ji->code_size");
  <D.19026>:
  pos = pos + 1;
  <D.17996>:
  D.19027 = chunk->num_elements;
  if (D.19027 > pos) goto <D.17995>; else goto <D.17997>;
  <D.17997>:
  chunk_pos = chunk_pos + 1;
  pos = 0;
  D.18996 = table->num_chunks;
  if (D.18996 > chunk_pos) goto <D.17998>; else goto <D.17999>;
  <D.17999>:
  found:
  D.19028 = chunk->data[pos];
  D.19029 = D.19028 != ji;
  D.19030 = (long int) D.19029;
  D.19031 = __builtin_expect (D.19030, 0);
  if (D.19031 != 0) goto <D.19032>; else goto <D.19033>;
  <D.19032>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "domain.c", 818, "chunk->data [pos] == ji");
  <D.19033>:
  D.19034 = mono_jit_info_make_tombstone (ji);
  chunk->data[pos] = D.19034;
}


mono_jit_info_make_tombstone (struct MonoJitInfo * ji)
{
  void * D.19035;
  int D.19036;
  struct MonoJitInfo * D.19037;
  struct MonoJitInfo * tombstone;

  tombstone = monoeg_malloc0 (48);
  D.19035 = ji->code_start;
  tombstone->code_start = D.19035;
  D.19036 = ji->code_size;
  tombstone->code_size = D.19036;
  tombstone->d.method = 0B;
  D.19037 = tombstone;
  return D.19037;
}


mono_jit_info_free_or_queue (struct MonoDomain * domain, struct MonoJitInfo * ji)
{
  int D.19039;
  struct GSList * D.19043;
  struct GSList * D.19044;

  D.19039 = domain->num_jit_info_tables;
  if (D.19039 <= 1) goto <D.19040>; else goto <D.19041>;
  <D.19040>:
  mono_thread_hazardous_free_or_queue (ji, monoeg_g_free, 1, 0);
  goto <D.19042>;
  <D.19041>:
  D.19043 = domain->jit_info_free_queue;
  D.19044 = monoeg_g_slist_prepend (D.19043, ji);
  domain->jit_info_free_queue = D.19044;
  <D.19042>:
}


mono_jit_info_add_aot_module (struct MonoImage * image, void * start, void * end)
{
  _Bool D.19047;
  long int D.19048;
  long int D.19049;
  struct MonoDomain * mono_root_domain.4;
  _Bool D.19053;
  long int D.19054;
  long int D.19055;
  struct MonoJitInfoTable * D.19058;
  int D.19061;
  int D.19062;
  struct MonoJitInfoTable * D.19063;
  long int end.5;
  long int start.6;
  long int D.19066;
  int D.19067;
  struct MonoJitInfoTable * volatile * D.19068;
  _Bool D.19071;
  long int D.19072;
  long int D.19073;
  struct MonoJitInfo * ji;

  {
    int ret;

    ret = pthread_mutex_lock (&appdomains_mutex.mutex);
    if (ret != 0) goto <D.19045>; else goto <D.19046>;
    <D.19045>:
    monoeg_g_log (0B, 16, "Bad call to mono_mutex_lock result %d", ret);
    <D.19046>:
    D.19047 = ret != 0;
    D.19048 = (long int) D.19047;
    D.19049 = __builtin_expect (D.19048, 0);
    if (D.19049 != 0) goto <D.19050>; else goto <D.19051>;
    <D.19050>:
    monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "domain.c", 848, "ret == 0");
    <D.19051>:
  }
  mono_root_domain.4 = mono_root_domain;
  D.19053 = mono_root_domain.4 == 0B;
  D.19054 = (long int) D.19053;
  D.19055 = __builtin_expect (D.19054, 0);
  if (D.19055 != 0) goto <D.19056>; else goto <D.19057>;
  <D.19056>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "domain.c", 854, "mono_root_domain");
  <D.19057>:
  mono_root_domain.4 = mono_root_domain;
  D.19058 = mono_root_domain.4->aot_modules;
  if (D.19058 == 0B) goto <D.19059>; else goto <D.19060>;
  <D.19059>:
  mono_root_domain.4 = mono_root_domain;
  D.19061 = mono_root_domain.4->num_jit_info_tables;
  D.19062 = D.19061 + 1;
  mono_root_domain.4->num_jit_info_tables = D.19062;
  mono_root_domain.4 = mono_root_domain;
  mono_root_domain.4 = mono_root_domain;
  D.19063 = jit_info_table_new (mono_root_domain.4);
  mono_root_domain.4->aot_modules = D.19063;
  <D.19060>:
  ji = monoeg_malloc0 (48);
  ji->d.image = image;
  ji->code_start = start;
  end.5 = (long int) end;
  start.6 = (long int) start;
  D.19066 = end.5 - start.6;
  D.19067 = (int) D.19066;
  ji->code_size = D.19067;
  mono_root_domain.4 = mono_root_domain;
  D.19068 = &mono_root_domain.4->aot_modules;
  mono_root_domain.4 = mono_root_domain;
  jit_info_table_add (mono_root_domain.4, D.19068, ji);
  {
    int ret;

    ret = pthread_mutex_unlock (&appdomains_mutex.mutex);
    if (ret != 0) goto <D.19069>; else goto <D.19070>;
    <D.19069>:
    monoeg_g_log (0B, 16, "Bad call to mono_mutex_unlock result %d", ret);
    <D.19070>:
    D.19071 = ret != 0;
    D.19072 = (long int) D.19071;
    D.19073 = __builtin_expect (D.19072, 0);
    if (D.19073 != 0) goto <D.19074>; else goto <D.19075>;
    <D.19074>:
    monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "domain.c", 866, "ret == 0");
    <D.19075>:
  }
}


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

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


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

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


mono_jit_info_get_method (struct MonoJitInfo * ji)
{
  unsigned char D.19080;
  unsigned char D.19081;
  _Bool D.19082;
  long int D.19083;
  long int D.19084;
  struct MonoMethod * D.19087;

  D.19080 = BIT_FIELD_REF <*ji, 8, 280>;
  D.19081 = D.19080 & 1;
  D.19082 = D.19081 != 0;
  D.19083 = (long int) D.19082;
  D.19084 = __builtin_expect (D.19083, 0);
  if (D.19084 != 0) goto <D.19085>; else goto <D.19086>;
  <D.19085>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "domain.c", 890, "!ji->async");
  <D.19086>:
  D.19087 = ji->d.method;
  return D.19087;
}


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

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


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

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


mono_jit_info_get_generic_jit_info (struct MonoJitInfo * ji)
{
  unsigned char D.19093;
  unsigned char D.19094;
  struct MonoGenericJitInfo * D.19097;
  <unnamed-unsigned:15> D.19098;
  int D.19099;

  D.19093 = BIT_FIELD_REF <*ji, 8, 272>;
  D.19094 = D.19093 & 2;
  if (D.19094 != 0) goto <D.19095>; else goto <D.19096>;
  <D.19095>:
  D.19098 = ji->num_clauses;
  D.19099 = (int) D.19098;
  D.19097 = &ji->clauses[D.19099];
  return D.19097;
  <D.19096>:
  D.19097 = 0B;
  return D.19097;
}


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

  gi = mono_jit_info_get_generic_jit_info (ji);
  if (gi != 0B) goto <D.19101>; else goto <D.19102>;
  <D.19101>:
  D.19103 = gi->generic_sharing_context;
  return D.19103;
  <D.19102>:
  D.19103 = 0B;
  return D.19103;
}


mono_jit_info_set_generic_sharing_context (struct MonoJitInfo * ji, struct MonoGenericSharingContext * gsctx)
{
  _Bool D.19105;
  long int D.19106;
  long int D.19107;
  struct MonoGenericJitInfo * gi;

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


mono_jit_info_get_try_block_hole_table_info (struct MonoJitInfo * ji)
{
  unsigned char D.19110;
  unsigned char D.19111;
  <unnamed-unsigned:15> D.19114;
  int D.19115;
  unsigned char D.19116;
  struct MonoTryBlockHoleTableJitInfo * D.19119;

  D.19110 = BIT_FIELD_REF <*ji, 8, 272>;
  D.19111 = D.19110 & 4;
  if (D.19111 != 0) goto <D.19112>; else goto <D.19113>;
  <D.19112>:
  {
    char * ptr;

    D.19114 = ji->num_clauses;
    D.19115 = (int) D.19114;
    ptr = &ji->clauses[D.19115];
    D.19110 = BIT_FIELD_REF <*ji, 8, 272>;
    D.19116 = D.19110 & 2;
    if (D.19116 != 0) goto <D.19117>; else goto <D.19118>;
    <D.19117>:
    ptr = ptr + 32;
    <D.19118>:
    D.19119 = ptr;
    return D.19119;
  }
  <D.19113>:
  D.19119 = 0B;
  return D.19119;
}


mono_jit_info_get_arch_eh_info (struct MonoJitInfo * ji)
{
  unsigned char D.19121;
  unsigned char D.19122;
  <unnamed-unsigned:15> D.19125;
  int D.19126;
  unsigned char D.19127;
  unsigned char D.19130;
  struct MonoArchEHJitInfo * D.19133;

  D.19121 = BIT_FIELD_REF <*ji, 8, 272>;
  D.19122 = D.19121 & 8;
  if (D.19122 != 0) goto <D.19123>; else goto <D.19124>;
  <D.19123>:
  {
    char * ptr;

    D.19125 = ji->num_clauses;
    D.19126 = (int) D.19125;
    ptr = &ji->clauses[D.19126];
    D.19121 = BIT_FIELD_REF <*ji, 8, 272>;
    D.19127 = D.19121 & 2;
    if (D.19127 != 0) goto <D.19128>; else goto <D.19129>;
    <D.19128>:
    ptr = ptr + 32;
    <D.19129>:
    D.19121 = BIT_FIELD_REF <*ji, 8, 272>;
    D.19130 = D.19121 & 4;
    if (D.19130 != 0) goto <D.19131>; else goto <D.19132>;
    <D.19131>:
    ptr = ptr + 4;
    <D.19132>:
    D.19133 = ptr;
    return D.19133;
  }
  <D.19124>:
  D.19133 = 0B;
  return D.19133;
}


mono_jit_info_get_cas_info (struct MonoJitInfo * ji)
{
  unsigned char D.19135;
  unsigned char D.19136;
  <unnamed-unsigned:15> D.19139;
  int D.19140;
  unsigned char D.19141;
  unsigned char D.19144;
  unsigned char D.19147;
  struct MonoMethodCasInfo * D.19150;

  D.19135 = BIT_FIELD_REF <*ji, 8, 272>;
  D.19136 = D.19135 & 1;
  if (D.19136 != 0) goto <D.19137>; else goto <D.19138>;
  <D.19137>:
  {
    char * ptr;

    D.19139 = ji->num_clauses;
    D.19140 = (int) D.19139;
    ptr = &ji->clauses[D.19140];
    D.19135 = BIT_FIELD_REF <*ji, 8, 272>;
    D.19141 = D.19135 & 2;
    if (D.19141 != 0) goto <D.19142>; else goto <D.19143>;
    <D.19142>:
    ptr = ptr + 32;
    <D.19143>:
    D.19135 = BIT_FIELD_REF <*ji, 8, 272>;
    D.19144 = D.19135 & 4;
    if (D.19144 != 0) goto <D.19145>; else goto <D.19146>;
    <D.19145>:
    ptr = ptr + 4;
    <D.19146>:
    D.19135 = BIT_FIELD_REF <*ji, 8, 272>;
    D.19147 = D.19135 & 8;
    if (D.19147 != 0) goto <D.19148>; else goto <D.19149>;
    <D.19148>:
    ptr = ptr + 4;
    <D.19149>:
    D.19150 = ptr;
    return D.19150;
  }
  <D.19138>:
  D.19150 = 0B;
  return D.19150;
}


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.19154;
  int D.19157;
  long unsigned int D.19158;
  mono_unichar2 * D.19159;
  mono_unichar2 * D.19160;
  int D.19161;
  _Bool D.19162;
  int l1;
  int l2;

  l1 = mono_string_length (s1);
  l2 = mono_string_length (s2);
  if (s1 == s2) goto <D.19152>; else goto <D.19153>;
  <D.19152>:
  D.19154 = 1;
  return D.19154;
  <D.19153>:
  if (l1 != l2) goto <D.19155>; else goto <D.19156>;
  <D.19155>:
  D.19154 = 0;
  return D.19154;
  <D.19156>:
  D.19157 = l1 * 2;
  D.19158 = (long unsigned int) D.19157;
  D.19159 = mono_string_chars (s2);
  D.19160 = mono_string_chars (s1);
  D.19161 = memcmp (D.19160, D.19159, D.19158);
  D.19162 = D.19161 == 0;
  D.19154 = (mono_bool) D.19162;
  return D.19154;
}


mono_string_hash (struct MonoString * s)
{
  unsigned int D.19164;
  unsigned int D.19165;
  short unsigned int D.19166;
  unsigned int D.19167;
  unsigned int D.19168;
  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.18112>;
  <D.18111>:
  D.19164 = h << 5;
  D.19165 = D.19164 - h;
  D.19166 = *p;
  D.19167 = (unsigned int) D.19166;
  h = D.19165 + D.19167;
  p = p + 2;
  i = i + 1;
  <D.18112>:
  if (i < len) goto <D.18111>; else goto <D.18113>;
  <D.18113>:
  D.19168 = h;
  return D.19168;
}


mono_domain_create ()
{
  _Bool D.19172;
  long int D.19173;
  long int D.19174;
  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.19183;
  long unsigned int D.19184;
  int bit.11;
  int D.19186;
  long unsigned int D.19187;
  long unsigned int D.19188;
  unsigned int D.19189;
  int D.19190;
  void * domain_gc_desc.12;
  _Bool D.19194;
  long int D.19195;
  long int D.19196;
  struct MonoGHashTable * * D.19199;
  int shadow_serial.13;
  struct MonoMemPool * D.19201;
  struct MonoCodeManager * D.19202;
  struct LockFreeMempool * D.19203;
  struct MonoGHashTable * D.19204;
  struct GPtrArray * D.19205;
  struct GHashTable * D.19206;
  struct MonoInternalHashTable * D.19207;
  struct MonoGHashTable * D.19208;
  struct MonoJitInfoTable * D.19209;
  struct GHashTable * D.19210;
  struct GHashTable * D.19211;
  struct CRITICAL_SECTION * D.19212;
  struct CRITICAL_SECTION * D.19213;
  struct CRITICAL_SECTION * D.19214;
  struct CRITICAL_SECTION * D.19215;
  _Bool D.19218;
  long int D.19219;
  long int D.19220;
  _Bool D.19225;
  long int D.19226;
  long int D.19227;
  struct MonoPerfCounters * mono_perfcounters.14;
  unsigned int D.19231;
  unsigned int D.19232;
  unsigned int D.19233;
  unsigned int D.19234;
  void (*<T19c3>) (struct MonoDomain *) create_domain_hook.15;
  struct MonoDomain * D.19238;
  struct MonoDomain * domain;
  guint32 shadow_serial;

  {
    int ret;

    ret = pthread_mutex_lock (&appdomains_mutex.mutex);
    if (ret != 0) goto <D.19170>; else goto <D.19171>;
    <D.19170>:
    monoeg_g_log (0B, 16, "Bad call to mono_mutex_lock result %d", ret);
    <D.19171>:
    D.19172 = ret != 0;
    D.19173 = (long int) D.19172;
    D.19174 = __builtin_expect (D.19173, 0);
    if (D.19174 != 0) goto <D.19175>; else goto <D.19176>;
    <D.19175>:
    monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "domain.c", 1234, "ret == 0");
    <D.19176>:
  }
  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.19181>; else goto <D.19182>;
  <D.19181>:
  {
    unsigned int i;
    unsigned int bit;

    bit = 0;
    i = 64;
    goto <D.18153>;
    <D.18152>:
    bit = i / 8;
    D.19183 = bit / 32;
    D.19184 = domain_gc_bitmap[D.19183];
    bit.11 = (int) bit;
    D.19186 = bit.11 & 31;
    D.19187 = 1 << D.19186;
    D.19188 = D.19184 | D.19187;
    domain_gc_bitmap[D.19183] = D.19188;
    i = i + 8;
    <D.18153>:
    if (i <= 135) goto <D.18152>; else goto <D.18154>;
    <D.18154>:
    D.19189 = bit + 1;
    D.19190 = (int) D.19189;
    domain_gc_desc.12 = mono_gc_make_descr_from_bitmap (&domain_gc_bitmap, D.19190);
    domain_gc_desc = domain_gc_desc.12;
  }
  <D.19182>:
  {
    int ret;

    ret = pthread_mutex_unlock (&appdomains_mutex.mutex);
    if (ret != 0) goto <D.19192>; else goto <D.19193>;
    <D.19192>:
    monoeg_g_log (0B, 16, "Bad call to mono_mutex_unlock result %d", ret);
    <D.19193>:
    D.19194 = ret != 0;
    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", 1245, "ret == 0");
    <D.19198>:
  }
  domain_gc_desc.10 = domain_gc_desc;
  domain = mono_gc_alloc_fixed (704, domain_gc_desc.10);
  D.19199 = &domain->env;
  mono_gc_register_root (D.19199, 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.19201 = mono_mempool_new ();
  domain->mp = D.19201;
  D.19202 = mono_code_manager_new ();
  domain->code_mp = D.19202;
  D.19203 = lock_free_mempool_new ();
  domain->lock_free_mp = D.19203;
  D.19204 = mono_g_hash_table_new_type (mono_string_hash, mono_string_equal, 3);
  domain->env = D.19204;
  domain->domain_assemblies = 0B;
  domain->assembly_bindings = 0B;
  domain->assembly_bindings_parsed = 0;
  D.19205 = monoeg_g_ptr_array_new ();
  domain->class_vtable_array = D.19205;
  D.19206 = monoeg_g_hash_table_new (mono_ptrarray_hash, mono_ptrarray_equal);
  domain->proxy_vtable_hash = D.19206;
  domain->static_data_array = 0B;
  D.19207 = &domain->jit_code_hash;
  mono_jit_code_hash_init (D.19207);
  D.19208 = mono_g_hash_table_new_type (mono_string_hash, mono_string_equal, 3);
  domain->ldstr_table = D.19208;
  domain->num_jit_info_tables = 1;
  D.19209 = jit_info_table_new (domain);
  domain->jit_info_table = D.19209;
  domain->jit_info_free_queue = 0B;
  D.19210 = monoeg_g_hash_table_new (mono_aligned_addr_hash, 0B);
  domain->finalizable_objects_hash = D.19210;
  D.19211 = monoeg_g_hash_table_new (mono_aligned_addr_hash, 0B);
  domain->ftnptrs_hash = D.19211;
  D.19212 = &domain->lock;
  InitializeCriticalSection (D.19212);
  D.19213 = &domain->assemblies_lock;
  InitializeCriticalSection (D.19213);
  D.19214 = &domain->jit_code_hash_lock;
  InitializeCriticalSection (D.19214);
  D.19215 = &domain->finalizable_objects_hash_lock;
  InitializeCriticalSection (D.19215);
  domain->method_rgctx_hash = 0B;
  {
    int ret;

    ret = pthread_mutex_lock (&appdomains_mutex.mutex);
    if (ret != 0) goto <D.19216>; else goto <D.19217>;
    <D.19216>:
    monoeg_g_log (0B, 16, "Bad call to mono_mutex_lock result %d", ret);
    <D.19217>:
    D.19218 = ret != 0;
    D.19219 = (long int) D.19218;
    D.19220 = __builtin_expect (D.19219, 0);
    if (D.19220 != 0) goto <D.19221>; else goto <D.19222>;
    <D.19221>:
    monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "domain.c", 1292, "ret == 0");
    <D.19222>:
  }
  domain_id_alloc (domain);
  {
    int ret;

    ret = pthread_mutex_unlock (&appdomains_mutex.mutex);
    if (ret != 0) goto <D.19223>; else goto <D.19224>;
    <D.19223>:
    monoeg_g_log (0B, 16, "Bad call to mono_mutex_unlock result %d", ret);
    <D.19224>:
    D.19225 = ret != 0;
    D.19226 = (long int) D.19225;
    D.19227 = __builtin_expect (D.19226, 0);
    if (D.19227 != 0) goto <D.19228>; else goto <D.19229>;
    <D.19228>:
    monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "domain.c", 1294, "ret == 0");
    <D.19229>:
  }
  mono_perfcounters.14 = mono_perfcounters;
  D.19231 = mono_perfcounters.14->loader_appdomains;
  D.19232 = D.19231 + 1;
  mono_perfcounters.14->loader_appdomains = D.19232;
  mono_perfcounters.14 = mono_perfcounters;
  D.19233 = mono_perfcounters.14->loader_total_appdomains;
  D.19234 = D.19233 + 1;
  mono_perfcounters.14->loader_total_appdomains = D.19234;
  mono_debug_domain_create (domain);
  create_domain_hook.15 = create_domain_hook;
  if (create_domain_hook.15 != 0B) goto <D.19236>; else goto <D.19237>;
  <D.19236>:
  create_domain_hook.15 = create_domain_hook;
  create_domain_hook.15 (domain);
  <D.19237>:
  mono_profiler_appdomain_loaded (domain, 0);
  D.19238 = domain;
  return D.19238;
}


mono_ptrarray_equal (void * * s1, void * * s2)
{
  void * D.19240;
  long int D.19241;
  void * D.19242;
  long int D.19243;
  int D.19244;
  gboolean D.19247;
  long unsigned int D.19248;
  long unsigned int D.19249;
  const void * D.19250;
  const void * D.19251;
  int D.19252;
  _Bool D.19253;
  int len;

  D.19240 = *s1;
  D.19241 = (long int) D.19240;
  len = (int) D.19241;
  D.19242 = *s2;
  D.19243 = (long int) D.19242;
  D.19244 = (int) D.19243;
  if (D.19244 != len) goto <D.19245>; else goto <D.19246>;
  <D.19245>:
  D.19247 = 0;
  return D.19247;
  <D.19246>:
  D.19248 = (long unsigned int) len;
  D.19249 = D.19248 * 8;
  D.19250 = s2 + 8;
  D.19251 = s1 + 8;
  D.19252 = memcmp (D.19251, D.19250, D.19249);
  D.19253 = D.19252 == 0;
  D.19247 = (gboolean) D.19253;
  return D.19247;
}


mono_ptrarray_hash (void * * s)
{
  void * D.19255;
  long int D.19256;
  long unsigned int D.19257;
  long unsigned int D.19258;
  void * * D.19259;
  void * D.19260;
  long int D.19261;
  unsigned int D.19262;
  guint D.19263;
  int i;
  int len;
  guint hash;

  D.19255 = *s;
  D.19256 = (long int) D.19255;
  len = (int) D.19256;
  hash = 0;
  i = 1;
  goto <D.18126>;
  <D.18125>:
  D.19257 = (long unsigned int) i;
  D.19258 = D.19257 * 8;
  D.19259 = s + D.19258;
  D.19260 = *D.19259;
  D.19261 = (long int) D.19260;
  D.19262 = (unsigned int) D.19261;
  hash = D.19262 + hash;
  i = i + 1;
  <D.18126>:
  if (i < len) goto <D.18125>; else goto <D.18127>;
  <D.18127>:
  D.19263 = hash;
  return D.19263;
}


lock_free_mempool_new ()
{
  struct LockFreeMempool * D.19265;

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


domain_id_alloc (struct MonoDomain * domain)
{
  struct MonoDomain * * appdomains_list.16;
  short unsigned int appdomain_list_size.17;
  long unsigned int D.19271;
  long unsigned int D.19272;
  void * appdomains_list.18;
  short unsigned int appdomain_next.19;
  long unsigned int D.19275;
  long unsigned int D.19276;
  struct MonoDomain * * D.19277;
  struct MonoDomain * D.19278;
  int D.19281;
  int D.19286;
  long unsigned int D.19291;
  long unsigned int D.19292;
  short unsigned int appdomain_list_size.20;
  long unsigned int D.19294;
  long unsigned int D.19295;
  struct MonoDomain * * D.19296;
  short unsigned int appdomain_next.21;
  short unsigned int appdomain_next.22;
  int D.19301;
  int id;
  int i;

  id = -1;
  appdomains_list.16 = appdomains_list;
  if (appdomains_list.16 == 0B) goto <D.19268>; else goto <D.19269>;
  <D.19268>:
  appdomain_list_size = 2;
  appdomain_list_size.17 = appdomain_list_size;
  D.19271 = (long unsigned int) appdomain_list_size.17;
  D.19272 = D.19271 * 8;
  appdomains_list.18 = mono_gc_alloc_fixed (D.19272, 0B);
  appdomains_list = appdomains_list.18;
  <D.19269>:
  appdomain_next.19 = appdomain_next;
  i = (int) appdomain_next.19;
  goto <D.18135>;
  <D.18134>:
  appdomains_list.16 = appdomains_list;
  D.19275 = (long unsigned int) i;
  D.19276 = D.19275 * 8;
  D.19277 = appdomains_list.16 + D.19276;
  D.19278 = *D.19277;
  if (D.19278 == 0B) goto <D.19279>; else goto <D.19280>;
  <D.19279>:
  id = i;
  goto <D.18133>;
  <D.19280>:
  i = i + 1;
  <D.18135>:
  appdomain_list_size.17 = appdomain_list_size;
  D.19281 = (int) appdomain_list_size.17;
  if (D.19281 > i) goto <D.18134>; else goto <D.18133>;
  <D.18133>:
  if (id == -1) goto <D.19282>; else goto <D.19283>;
  <D.19282>:
  i = 0;
  goto <D.18138>;
  <D.18137>:
  appdomains_list.16 = appdomains_list;
  D.19275 = (long unsigned int) i;
  D.19276 = D.19275 * 8;
  D.19277 = appdomains_list.16 + D.19276;
  D.19278 = *D.19277;
  if (D.19278 == 0B) goto <D.19284>; else goto <D.19285>;
  <D.19284>:
  id = i;
  goto <D.18136>;
  <D.19285>:
  i = i + 1;
  <D.18138>:
  appdomain_next.19 = appdomain_next;
  D.19286 = (int) appdomain_next.19;
  if (D.19286 > i) goto <D.18137>; else goto <D.18136>;
  <D.18136>:
  <D.19283>:
  if (id == -1) goto <D.19287>; else goto <D.19288>;
  <D.19287>:
  {
    struct MonoDomain * * new_list;
    int new_size;

    appdomain_list_size.17 = appdomain_list_size;
    D.19281 = (int) appdomain_list_size.17;
    new_size = D.19281 * 2;
    if (new_size > 65535) goto <D.19289>; else goto <D.19290>;
    <D.19289>:
    monoeg_assertion_message ("* Assertion: should not be reached at %s:%d\n", "domain.c", 1208);
    <D.19290>:
    appdomain_list_size.17 = appdomain_list_size;
    id = (int) appdomain_list_size.17;
    D.19291 = (long unsigned int) new_size;
    D.19292 = D.19291 * 8;
    new_list = mono_gc_alloc_fixed (D.19292, 0B);
    appdomain_list_size.17 = appdomain_list_size;
    D.19271 = (long unsigned int) appdomain_list_size.17;
    D.19272 = D.19271 * 8;
    appdomains_list.16 = appdomains_list;
    memcpy (new_list, appdomains_list.16, D.19272);
    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.19288>:
  domain->domain_id = id;
  appdomains_list.16 = appdomains_list;
  D.19294 = (long unsigned int) id;
  D.19295 = D.19294 * 8;
  D.19296 = appdomains_list.16 + D.19295;
  *D.19296 = 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.19299>; else goto <D.19300>;
  <D.19299>:
  appdomain_next = 0;
  <D.19300>:
  D.19301 = id;
  return D.19301;
}


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

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


mono_init_internal (const char * filename, const char * exe_filename, const char * runtime_version)
{
  struct MonoDomain * domain.23;
  int D.19308;
  struct MonoDomain * domain.24;
  unsigned int appdomain_thread_id.25;
  const struct MonoRuntimeInfo * D.19318;
  const struct MonoRuntimeInfo * D.19319;
  const char[12] * D.19322;
  const struct MonoRuntimeInfo * current_runtime.26;
  const struct MonoRuntimeInfo * current_runtime.27;
  <unnamed type> status.28;
  const char[4] * D.19331;
  const char * D.19332;
  const char * D.19333;
  const char * D.19334;
  struct MonoImage * D.19336;
  struct MonoImage * D.19337;
  struct MonoClass * D.19338;
  struct MonoClass * D.19339;
  _Bool D.19340;
  long int D.19341;
  long int D.19342;
  struct MonoClass * D.19345;
  struct MonoClass * D.19346;
  _Bool D.19347;
  long int D.19348;
  long int D.19349;
  struct MonoClass * D.19352;
  struct MonoClass * D.19353;
  _Bool D.19354;
  long int D.19355;
  long int D.19356;
  struct MonoClass * D.19359;
  struct MonoClass * D.19360;
  _Bool D.19361;
  long int D.19362;
  long int D.19363;
  struct MonoClass * D.19366;
  struct MonoClass * D.19367;
  _Bool D.19368;
  long int D.19369;
  long int D.19370;
  struct MonoClass * D.19373;
  struct MonoClass * D.19374;
  _Bool D.19375;
  long int D.19376;
  long int D.19377;
  struct MonoClass * D.19380;
  struct MonoClass * D.19381;
  _Bool D.19382;
  long int D.19383;
  long int D.19384;
  struct MonoClass * D.19387;
  struct MonoClass * D.19388;
  _Bool D.19389;
  long int D.19390;
  long int D.19391;
  struct MonoClass * D.19394;
  struct MonoClass * D.19395;
  _Bool D.19396;
  long int D.19397;
  long int D.19398;
  struct MonoClass * D.19401;
  struct MonoClass * D.19402;
  _Bool D.19403;
  long int D.19404;
  long int D.19405;
  struct MonoClass * D.19408;
  struct MonoClass * D.19409;
  _Bool D.19410;
  long int D.19411;
  long int D.19412;
  struct MonoClass * D.19415;
  struct MonoClass * D.19416;
  _Bool D.19417;
  long int D.19418;
  long int D.19419;
  struct MonoClass * D.19422;
  struct MonoClass * D.19423;
  _Bool D.19424;
  long int D.19425;
  long int D.19426;
  struct MonoClass * D.19429;
  struct MonoClass * D.19430;
  _Bool D.19431;
  long int D.19432;
  long int D.19433;
  struct MonoClass * D.19436;
  struct MonoClass * D.19437;
  _Bool D.19438;
  long int D.19439;
  long int D.19440;
  struct MonoClass * D.19443;
  struct MonoClass * D.19444;
  _Bool D.19445;
  long int D.19446;
  long int D.19447;
  struct MonoClass * D.19450;
  struct MonoClass * D.19451;
  _Bool D.19452;
  long int D.19453;
  long int D.19454;
  struct MonoClass * D.19457;
  struct MonoClass * D.19458;
  _Bool D.19459;
  long int D.19460;
  long int D.19461;
  struct MonoClass * D.19464;
  struct MonoClass * D.19465;
  _Bool D.19466;
  long int D.19467;
  long int D.19468;
  struct MonoClass * D.19471;
  struct MonoClass * D.19472;
  _Bool D.19473;
  long int D.19474;
  long int D.19475;
  struct MonoClass * D.19478;
  struct MonoClass * D.19479;
  _Bool D.19480;
  long int D.19481;
  long int D.19482;
  struct MonoClass * D.19485;
  struct MonoClass * D.19486;
  _Bool D.19487;
  long int D.19488;
  long int D.19489;
  struct MonoClass * D.19492;
  struct MonoClass * D.19493;
  _Bool D.19494;
  long int D.19495;
  long int D.19496;
  struct MonoClass * D.19499;
  struct MonoClass * D.19500;
  _Bool D.19501;
  long int D.19502;
  long int D.19503;
  struct MonoClass * D.19506;
  struct MonoClass * D.19507;
  _Bool D.19508;
  long int D.19509;
  long int D.19510;
  struct MonoClass * D.19513;
  struct MonoClass * D.19514;
  _Bool D.19515;
  long int D.19516;
  long int D.19517;
  struct MonoClass * D.19520;
  struct MonoClass * D.19521;
  _Bool D.19522;
  long int D.19523;
  long int D.19524;
  struct MonoClass * D.19527;
  struct MonoClass * D.19528;
  _Bool D.19529;
  long int D.19530;
  long int D.19531;
  struct MonoClass * D.19534;
  struct MonoClass * D.19535;
  _Bool D.19536;
  long int D.19537;
  long int D.19538;
  struct MonoClass * D.19541;
  struct MonoClass * D.19542;
  _Bool D.19543;
  long int D.19544;
  long int D.19545;
  struct MonoClass * D.19548;
  struct MonoClass * D.19549;
  _Bool D.19550;
  long int D.19551;
  long int D.19552;
  struct MonoClass * D.19555;
  struct MonoClass * D.19556;
  struct _IO_FILE * stderr.29;
  const char * iftmp.30;
  struct MonoClass * D.19564;
  struct MonoClass * D.19565;
  _Bool D.19566;
  long int D.19567;
  long int D.19568;
  struct MonoClass * D.19571;
  struct MonoClass * D.19572;
  _Bool D.19573;
  long int D.19574;
  long int D.19575;
  struct MonoClass * D.19578;
  struct MonoClass * D.19579;
  _Bool D.19580;
  long int D.19581;
  long int D.19582;
  struct MonoClass * D.19585;
  struct MonoClass * D.19586;
  _Bool D.19587;
  long int D.19588;
  long int D.19589;
  struct MonoClass * D.19592;
  struct MonoClass * D.19593;
  _Bool D.19594;
  long int D.19595;
  long int D.19596;
  struct MonoClass * D.19599;
  struct MonoClass * D.19600;
  _Bool D.19601;
  long int D.19602;
  long int D.19603;
  struct MonoClass * D.19606;
  struct MonoClass * D.19607;
  _Bool D.19608;
  long int D.19609;
  long int D.19610;
  struct MonoClass * D.19613;
  struct MonoClass * D.19614;
  _Bool D.19615;
  long int D.19616;
  long int D.19617;
  struct MonoClass * D.19620;
  struct MonoClass * D.19621;
  _Bool D.19622;
  long int D.19623;
  long int D.19624;
  struct MonoClass * D.19627;
  struct MonoClass * D.19628;
  _Bool D.19629;
  long int D.19630;
  long int D.19631;
  struct MonoClass * D.19634;
  struct MonoClass * D.19635;
  _Bool D.19636;
  long int D.19637;
  long int D.19638;
  struct MonoClass * D.19641;
  struct MonoClass * D.19642;
  _Bool D.19643;
  long int D.19644;
  long int D.19645;
  struct MonoClass * D.19648;
  struct MonoClass * D.19649;
  _Bool D.19650;
  long int D.19651;
  long int D.19652;
  struct MonoClass * D.19655;
  struct MonoClass * D.19656;
  _Bool D.19657;
  long int D.19658;
  long int D.19659;
  struct MonoClass * D.19662;
  struct MonoClass * D.19663;
  _Bool D.19664;
  long int D.19665;
  long int D.19666;
  struct MonoClass * D.19669;
  struct MonoClass * D.19670;
  _Bool D.19671;
  long int D.19672;
  long int D.19673;
  struct MonoClass * D.19676;
  struct MonoClass * D.19677;
  struct MonoClass * D.19678;
  struct MonoClass * D.19679;
  struct MonoClass * D.19680;
  struct MonoClass * D.19681;
  struct MonoClass * D.19682;
  struct MonoClass * D.19683;
  struct MonoClass * D.19684;
  struct MonoClass * D.19685;
  struct MonoClass * D.19686;
  gchar * D.19687;
  struct MonoDomain * D.19688;
  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.19306>; else goto <D.19307>;
      <D.19306>:
      monoeg_assertion_message ("* Assertion: should not be reached at %s:%d\n", "domain.c", 1334);
      <D.19307>:
      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.19308 = mono_gc_is_moving ();
      if (D.19308 == 0) goto <D.19309>; else goto <D.19310>;
      <D.19309>:
      mono_gc_register_root (&appdomains_list, 8, 0B);
      <D.19310>:
      domain.24 = mono_domain_create ();
      domain = domain.24;
      domain.23 = domain;
      mono_root_domain = domain.23;
      domain.23 = domain;
      tls_appdomain = domain.23;
      domain.23 = domain;
      appdomain_thread_id.25 = appdomain_thread_id;
      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.19313>; else goto <D.19314>;
      <D.19313>:
      get_runtimes_from_exe (exe_filename, &exe_image, &runtimes);
      goto <D.19315>;
      <D.19314>:
      if (runtime_version != 0B) goto <D.19316>; else goto <D.19317>;
      <D.19316>:
      D.19318 = get_runtime_by_version (runtime_version);
      runtimes[0] = D.19318;
      runtimes[1] = 0B;
      <D.19317>:
      <D.19315>:
      D.19319 = runtimes[0];
      if (D.19319 == 0B) goto <D.19320>; else goto <D.19321>;
      <D.19320>:
      {
        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.19322 = &default_runtime->runtime_version;
        monoeg_g_print ("Using default runtime: %s\n", D.19322);
      }
      <D.19321>:
      n = 0;
      goto <D.18171>;
      <D.18170>:
      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.18169>; else goto <D.19326>;
      <D.19326>:
      n = n + 1;
      <D.18171>:
      current_runtime.26 = runtimes[n];
      if (current_runtime.26 != 0B) goto <D.19327>; else goto <D.18169>;
      <D.19327>:
      if (ass == 0B) goto <D.18170>; else goto <D.18169>;
      <D.18169>:
      status.28 = status;
      if (status.28 != 0) goto <D.19328>; else goto <D.19330>;
      <D.19330>:
      if (ass == 0B) goto <D.19328>; else goto <D.19329>;
      <D.19328>:
      status.28 = status;
      switch (status.28) <default: <D.19335>, case 0: <D.18177>, case 1: <D.18172>, case 2: <D.18176>, case 3: <D.18175>>
      <D.18172>:
      {
        char * corlib_file;

        current_runtime.27 = current_runtime;
        D.19331 = &current_runtime.27->framework_version;
        D.19332 = mono_assembly_getrootdir ();
        corlib_file = monoeg_g_build_path ("/", D.19332, "mono", D.19331, "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.18174>;
      }
      <D.18175>:
      D.19333 = mono_assembly_getrootdir ();
      monoeg_g_print ("The file %s/mscorlib.dll is an invalid CIL image\n", D.19333);
      goto <D.18174>;
      <D.18176>:
      D.19334 = mono_assembly_getrootdir ();
      monoeg_g_print ("Missing assembly reference in %s/mscorlib.dll\n", D.19334);
      goto <D.18174>;
      <D.18177>:
      goto <D.18174>;
      <D.19335>:
      <D.18174>:
      exit (1);
      <D.19329>:
      D.19336 = mono_assembly_get_image (ass);
      mono_defaults.corlib = D.19336;
      D.19337 = mono_defaults.corlib;
      D.19338 = mono_class_from_name (D.19337, "System", "Object");
      mono_defaults.object_class = D.19338;
      D.19339 = mono_defaults.object_class;
      D.19340 = D.19339 == 0B;
      D.19341 = (long int) D.19340;
      D.19342 = __builtin_expect (D.19341, 0);
      if (D.19342 != 0) goto <D.19343>; else goto <D.19344>;
      <D.19343>:
      monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "domain.c", 1442, "mono_defaults.object_class != 0");
      <D.19344>:
      D.19337 = mono_defaults.corlib;
      D.19345 = mono_class_from_name (D.19337, "System", "Void");
      mono_defaults.void_class = D.19345;
      D.19346 = mono_defaults.void_class;
      D.19347 = D.19346 == 0B;
      D.19348 = (long int) D.19347;
      D.19349 = __builtin_expect (D.19348, 0);
      if (D.19349 != 0) goto <D.19350>; else goto <D.19351>;
      <D.19350>:
      monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "domain.c", 1446, "mono_defaults.void_class != 0");
      <D.19351>:
      D.19337 = mono_defaults.corlib;
      D.19352 = mono_class_from_name (D.19337, "System", "Boolean");
      mono_defaults.boolean_class = D.19352;
      D.19353 = mono_defaults.boolean_class;
      D.19354 = D.19353 == 0B;
      D.19355 = (long int) D.19354;
      D.19356 = __builtin_expect (D.19355, 0);
      if (D.19356 != 0) goto <D.19357>; else goto <D.19358>;
      <D.19357>:
      monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "domain.c", 1450, "mono_defaults.boolean_class != 0");
      <D.19358>:
      D.19337 = mono_defaults.corlib;
      D.19359 = mono_class_from_name (D.19337, "System", "Byte");
      mono_defaults.byte_class = D.19359;
      D.19360 = mono_defaults.byte_class;
      D.19361 = D.19360 == 0B;
      D.19362 = (long int) D.19361;
      D.19363 = __builtin_expect (D.19362, 0);
      if (D.19363 != 0) goto <D.19364>; else goto <D.19365>;
      <D.19364>:
      monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "domain.c", 1454, "mono_defaults.byte_class != 0");
      <D.19365>:
      D.19337 = mono_defaults.corlib;
      D.19366 = mono_class_from_name (D.19337, "System", "SByte");
      mono_defaults.sbyte_class = D.19366;
      D.19367 = mono_defaults.sbyte_class;
      D.19368 = D.19367 == 0B;
      D.19369 = (long int) D.19368;
      D.19370 = __builtin_expect (D.19369, 0);
      if (D.19370 != 0) goto <D.19371>; else goto <D.19372>;
      <D.19371>:
      monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "domain.c", 1458, "mono_defaults.sbyte_class != 0");
      <D.19372>:
      D.19337 = mono_defaults.corlib;
      D.19373 = mono_class_from_name (D.19337, "System", "Int16");
      mono_defaults.int16_class = D.19373;
      D.19374 = mono_defaults.int16_class;
      D.19375 = D.19374 == 0B;
      D.19376 = (long int) D.19375;
      D.19377 = __builtin_expect (D.19376, 0);
      if (D.19377 != 0) goto <D.19378>; else goto <D.19379>;
      <D.19378>:
      monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "domain.c", 1462, "mono_defaults.int16_class != 0");
      <D.19379>:
      D.19337 = mono_defaults.corlib;
      D.19380 = mono_class_from_name (D.19337, "System", "UInt16");
      mono_defaults.uint16_class = D.19380;
      D.19381 = mono_defaults.uint16_class;
      D.19382 = D.19381 == 0B;
      D.19383 = (long int) D.19382;
      D.19384 = __builtin_expect (D.19383, 0);
      if (D.19384 != 0) goto <D.19385>; else goto <D.19386>;
      <D.19385>:
      monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "domain.c", 1466, "mono_defaults.uint16_class != 0");
      <D.19386>:
      D.19337 = mono_defaults.corlib;
      D.19387 = mono_class_from_name (D.19337, "System", "Int32");
      mono_defaults.int32_class = D.19387;
      D.19388 = mono_defaults.int32_class;
      D.19389 = D.19388 == 0B;
      D.19390 = (long int) D.19389;
      D.19391 = __builtin_expect (D.19390, 0);
      if (D.19391 != 0) goto <D.19392>; else goto <D.19393>;
      <D.19392>:
      monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "domain.c", 1470, "mono_defaults.int32_class != 0");
      <D.19393>:
      D.19337 = mono_defaults.corlib;
      D.19394 = mono_class_from_name (D.19337, "System", "UInt32");
      mono_defaults.uint32_class = D.19394;
      D.19395 = mono_defaults.uint32_class;
      D.19396 = D.19395 == 0B;
      D.19397 = (long int) D.19396;
      D.19398 = __builtin_expect (D.19397, 0);
      if (D.19398 != 0) goto <D.19399>; else goto <D.19400>;
      <D.19399>:
      monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "domain.c", 1474, "mono_defaults.uint32_class != 0");
      <D.19400>:
      D.19337 = mono_defaults.corlib;
      D.19401 = mono_class_from_name (D.19337, "System", "UIntPtr");
      mono_defaults.uint_class = D.19401;
      D.19402 = mono_defaults.uint_class;
      D.19403 = D.19402 == 0B;
      D.19404 = (long int) D.19403;
      D.19405 = __builtin_expect (D.19404, 0);
      if (D.19405 != 0) goto <D.19406>; else goto <D.19407>;
      <D.19406>:
      monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "domain.c", 1478, "mono_defaults.uint_class != 0");
      <D.19407>:
      D.19337 = mono_defaults.corlib;
      D.19408 = mono_class_from_name (D.19337, "System", "IntPtr");
      mono_defaults.int_class = D.19408;
      D.19409 = mono_defaults.int_class;
      D.19410 = D.19409 == 0B;
      D.19411 = (long int) D.19410;
      D.19412 = __builtin_expect (D.19411, 0);
      if (D.19412 != 0) goto <D.19413>; else goto <D.19414>;
      <D.19413>:
      monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "domain.c", 1482, "mono_defaults.int_class != 0");
      <D.19414>:
      D.19337 = mono_defaults.corlib;
      D.19415 = mono_class_from_name (D.19337, "System", "Int64");
      mono_defaults.int64_class = D.19415;
      D.19416 = mono_defaults.int64_class;
      D.19417 = D.19416 == 0B;
      D.19418 = (long int) D.19417;
      D.19419 = __builtin_expect (D.19418, 0);
      if (D.19419 != 0) goto <D.19420>; else goto <D.19421>;
      <D.19420>:
      monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "domain.c", 1486, "mono_defaults.int64_class != 0");
      <D.19421>:
      D.19337 = mono_defaults.corlib;
      D.19422 = mono_class_from_name (D.19337, "System", "UInt64");
      mono_defaults.uint64_class = D.19422;
      D.19423 = mono_defaults.uint64_class;
      D.19424 = D.19423 == 0B;
      D.19425 = (long int) D.19424;
      D.19426 = __builtin_expect (D.19425, 0);
      if (D.19426 != 0) goto <D.19427>; else goto <D.19428>;
      <D.19427>:
      monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "domain.c", 1490, "mono_defaults.uint64_class != 0");
      <D.19428>:
      D.19337 = mono_defaults.corlib;
      D.19429 = mono_class_from_name (D.19337, "System", "Single");
      mono_defaults.single_class = D.19429;
      D.19430 = mono_defaults.single_class;
      D.19431 = D.19430 == 0B;
      D.19432 = (long int) D.19431;
      D.19433 = __builtin_expect (D.19432, 0);
      if (D.19433 != 0) goto <D.19434>; else goto <D.19435>;
      <D.19434>:
      monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "domain.c", 1494, "mono_defaults.single_class != 0");
      <D.19435>:
      D.19337 = mono_defaults.corlib;
      D.19436 = mono_class_from_name (D.19337, "System", "Double");
      mono_defaults.double_class = D.19436;
      D.19437 = mono_defaults.double_class;
      D.19438 = D.19437 == 0B;
      D.19439 = (long int) D.19438;
      D.19440 = __builtin_expect (D.19439, 0);
      if (D.19440 != 0) goto <D.19441>; else goto <D.19442>;
      <D.19441>:
      monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "domain.c", 1498, "mono_defaults.double_class != 0");
      <D.19442>:
      D.19337 = mono_defaults.corlib;
      D.19443 = mono_class_from_name (D.19337, "System", "Char");
      mono_defaults.char_class = D.19443;
      D.19444 = mono_defaults.char_class;
      D.19445 = D.19444 == 0B;
      D.19446 = (long int) D.19445;
      D.19447 = __builtin_expect (D.19446, 0);
      if (D.19447 != 0) goto <D.19448>; else goto <D.19449>;
      <D.19448>:
      monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "domain.c", 1502, "mono_defaults.char_class != 0");
      <D.19449>:
      D.19337 = mono_defaults.corlib;
      D.19450 = mono_class_from_name (D.19337, "System", "String");
      mono_defaults.string_class = D.19450;
      D.19451 = mono_defaults.string_class;
      D.19452 = D.19451 == 0B;
      D.19453 = (long int) D.19452;
      D.19454 = __builtin_expect (D.19453, 0);
      if (D.19454 != 0) goto <D.19455>; else goto <D.19456>;
      <D.19455>:
      monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "domain.c", 1506, "mono_defaults.string_class != 0");
      <D.19456>:
      D.19337 = mono_defaults.corlib;
      D.19457 = mono_class_from_name (D.19337, "System", "Enum");
      mono_defaults.enum_class = D.19457;
      D.19458 = mono_defaults.enum_class;
      D.19459 = D.19458 == 0B;
      D.19460 = (long int) D.19459;
      D.19461 = __builtin_expect (D.19460, 0);
      if (D.19461 != 0) goto <D.19462>; else goto <D.19463>;
      <D.19462>:
      monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "domain.c", 1510, "mono_defaults.enum_class != 0");
      <D.19463>:
      D.19337 = mono_defaults.corlib;
      D.19464 = mono_class_from_name (D.19337, "System", "Array");
      mono_defaults.array_class = D.19464;
      D.19465 = mono_defaults.array_class;
      D.19466 = D.19465 == 0B;
      D.19467 = (long int) D.19466;
      D.19468 = __builtin_expect (D.19467, 0);
      if (D.19468 != 0) goto <D.19469>; else goto <D.19470>;
      <D.19469>:
      monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "domain.c", 1514, "mono_defaults.array_class != 0");
      <D.19470>:
      D.19337 = mono_defaults.corlib;
      D.19471 = mono_class_from_name (D.19337, "System", "Delegate");
      mono_defaults.delegate_class = D.19471;
      D.19472 = mono_defaults.delegate_class;
      D.19473 = D.19472 == 0B;
      D.19474 = (long int) D.19473;
      D.19475 = __builtin_expect (D.19474, 0);
      if (D.19475 != 0) goto <D.19476>; else goto <D.19477>;
      <D.19476>:
      monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "domain.c", 1518, "mono_defaults.delegate_class != 0");
      <D.19477>:
      D.19337 = mono_defaults.corlib;
      D.19478 = mono_class_from_name (D.19337, "System", "MulticastDelegate");
      mono_defaults.multicastdelegate_class = D.19478;
      D.19479 = mono_defaults.multicastdelegate_class;
      D.19480 = D.19479 == 0B;
      D.19481 = (long int) D.19480;
      D.19482 = __builtin_expect (D.19481, 0);
      if (D.19482 != 0) goto <D.19483>; else goto <D.19484>;
      <D.19483>:
      monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "domain.c", 1522, "mono_defaults.multicastdelegate_class != 0");
      <D.19484>:
      D.19337 = mono_defaults.corlib;
      D.19485 = mono_class_from_name (D.19337, "System.Runtime.Remoting.Messaging", "AsyncResult");
      mono_defaults.asyncresult_class = D.19485;
      D.19486 = mono_defaults.asyncresult_class;
      D.19487 = D.19486 == 0B;
      D.19488 = (long int) D.19487;
      D.19489 = __builtin_expect (D.19488, 0);
      if (D.19489 != 0) goto <D.19490>; else goto <D.19491>;
      <D.19490>:
      monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "domain.c", 1527, "mono_defaults.asyncresult_class != 0");
      <D.19491>:
      D.19337 = mono_defaults.corlib;
      D.19492 = mono_class_from_name (D.19337, "System.Threading", "ManualResetEvent");
      mono_defaults.manualresetevent_class = D.19492;
      D.19493 = mono_defaults.manualresetevent_class;
      D.19494 = D.19493 == 0B;
      D.19495 = (long int) D.19494;
      D.19496 = __builtin_expect (D.19495, 0);
      if (D.19496 != 0) goto <D.19497>; else goto <D.19498>;
      <D.19497>:
      monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "domain.c", 1531, "mono_defaults.manualresetevent_class != 0");
      <D.19498>:
      D.19337 = mono_defaults.corlib;
      D.19499 = mono_class_from_name (D.19337, "System", "RuntimeTypeHandle");
      mono_defaults.typehandle_class = D.19499;
      D.19500 = mono_defaults.typehandle_class;
      D.19501 = D.19500 == 0B;
      D.19502 = (long int) D.19501;
      D.19503 = __builtin_expect (D.19502, 0);
      if (D.19503 != 0) goto <D.19504>; else goto <D.19505>;
      <D.19504>:
      monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "domain.c", 1535, "mono_defaults.typehandle_class != 0");
      <D.19505>:
      D.19337 = mono_defaults.corlib;
      D.19506 = mono_class_from_name (D.19337, "System", "RuntimeMethodHandle");
      mono_defaults.methodhandle_class = D.19506;
      D.19507 = mono_defaults.methodhandle_class;
      D.19508 = D.19507 == 0B;
      D.19509 = (long int) D.19508;
      D.19510 = __builtin_expect (D.19509, 0);
      if (D.19510 != 0) goto <D.19511>; else goto <D.19512>;
      <D.19511>:
      monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "domain.c", 1539, "mono_defaults.methodhandle_class != 0");
      <D.19512>:
      D.19337 = mono_defaults.corlib;
      D.19513 = mono_class_from_name (D.19337, "System", "RuntimeFieldHandle");
      mono_defaults.fieldhandle_class = D.19513;
      D.19514 = mono_defaults.fieldhandle_class;
      D.19515 = D.19514 == 0B;
      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", 1543, "mono_defaults.fieldhandle_class != 0");
      <D.19519>:
      D.19337 = mono_defaults.corlib;
      D.19520 = mono_class_from_name (D.19337, "System", "Type");
      mono_defaults.systemtype_class = D.19520;
      D.19521 = mono_defaults.systemtype_class;
      D.19522 = D.19521 == 0B;
      D.19523 = (long int) D.19522;
      D.19524 = __builtin_expect (D.19523, 0);
      if (D.19524 != 0) goto <D.19525>; else goto <D.19526>;
      <D.19525>:
      monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "domain.c", 1547, "mono_defaults.systemtype_class != 0");
      <D.19526>:
      D.19337 = mono_defaults.corlib;
      D.19527 = mono_class_from_name (D.19337, "System", "MonoType");
      mono_defaults.monotype_class = D.19527;
      D.19528 = mono_defaults.monotype_class;
      D.19529 = D.19528 == 0B;
      D.19530 = (long int) D.19529;
      D.19531 = __builtin_expect (D.19530, 0);
      if (D.19531 != 0) goto <D.19532>; else goto <D.19533>;
      <D.19532>:
      monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "domain.c", 1551, "mono_defaults.monotype_class != 0");
      <D.19533>:
      D.19337 = mono_defaults.corlib;
      D.19534 = mono_class_from_name (D.19337, "System", "Exception");
      mono_defaults.exception_class = D.19534;
      D.19535 = mono_defaults.exception_class;
      D.19536 = D.19535 == 0B;
      D.19537 = (long int) D.19536;
      D.19538 = __builtin_expect (D.19537, 0);
      if (D.19538 != 0) goto <D.19539>; else goto <D.19540>;
      <D.19539>:
      monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "domain.c", 1555, "mono_defaults.exception_class != 0");
      <D.19540>:
      D.19337 = mono_defaults.corlib;
      D.19541 = mono_class_from_name (D.19337, "System.Threading", "ThreadAbortException");
      mono_defaults.threadabortexception_class = D.19541;
      D.19542 = mono_defaults.threadabortexception_class;
      D.19543 = D.19542 == 0B;
      D.19544 = (long int) D.19543;
      D.19545 = __builtin_expect (D.19544, 0);
      if (D.19545 != 0) goto <D.19546>; else goto <D.19547>;
      <D.19546>:
      monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "domain.c", 1559, "mono_defaults.threadabortexception_class != 0");
      <D.19547>:
      D.19337 = mono_defaults.corlib;
      D.19548 = mono_class_from_name (D.19337, "System.Threading", "Thread");
      mono_defaults.thread_class = D.19548;
      D.19549 = mono_defaults.thread_class;
      D.19550 = D.19549 == 0B;
      D.19551 = (long int) D.19550;
      D.19552 = __builtin_expect (D.19551, 0);
      if (D.19552 != 0) goto <D.19553>; else goto <D.19554>;
      <D.19553>:
      monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "domain.c", 1563, "mono_defaults.thread_class != 0");
      <D.19554>:
      D.19337 = mono_defaults.corlib;
      D.19555 = mono_class_from_name (D.19337, "System.Threading", "InternalThread");
      mono_defaults.internal_thread_class = D.19555;
      D.19556 = mono_defaults.internal_thread_class;
      if (D.19556 == 0B) goto <D.19557>; else goto <D.19558>;
      <D.19557>:
      stderr.29 = stderr;
      fprintf (stderr.29, "Corlib too old for this runtime.\n");
      D.19337 = mono_defaults.corlib;
      if (D.19337 != 0B) goto <D.19561>; else goto <D.19562>;
      <D.19561>:
      D.19337 = mono_defaults.corlib;
      iftmp.30 = mono_image_get_filename (D.19337);
      goto <D.19563>;
      <D.19562>:
      iftmp.30 = "unknown";
      <D.19563>:
      stderr.29 = stderr;
      fprintf (stderr.29, "Loaded from: %s\n", iftmp.30);
      exit (1);
      <D.19558>:
      D.19337 = mono_defaults.corlib;
      D.19564 = mono_class_from_name (D.19337, "System", "AppDomain");
      mono_defaults.appdomain_class = D.19564;
      D.19565 = mono_defaults.appdomain_class;
      D.19566 = D.19565 == 0B;
      D.19567 = (long int) D.19566;
      D.19568 = __builtin_expect (D.19567, 0);
      if (D.19568 != 0) goto <D.19569>; else goto <D.19570>;
      <D.19569>:
      monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "domain.c", 1577, "mono_defaults.appdomain_class != 0");
      <D.19570>:
      D.19337 = mono_defaults.corlib;
      D.19571 = mono_class_from_name (D.19337, "System.Runtime.Remoting.Proxies", "TransparentProxy");
      mono_defaults.transparent_proxy_class = D.19571;
      D.19572 = mono_defaults.transparent_proxy_class;
      D.19573 = D.19572 == 0B;
      D.19574 = (long int) D.19573;
      D.19575 = __builtin_expect (D.19574, 0);
      if (D.19575 != 0) goto <D.19576>; else goto <D.19577>;
      <D.19576>:
      monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "domain.c", 1582, "mono_defaults.transparent_proxy_class != 0");
      <D.19577>:
      D.19337 = mono_defaults.corlib;
      D.19578 = mono_class_from_name (D.19337, "System.Runtime.Remoting.Proxies", "RealProxy");
      mono_defaults.real_proxy_class = D.19578;
      D.19579 = mono_defaults.real_proxy_class;
      D.19580 = D.19579 == 0B;
      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", 1586, "mono_defaults.real_proxy_class != 0");
      <D.19584>:
      D.19337 = mono_defaults.corlib;
      D.19585 = mono_class_from_name (D.19337, "System", "MarshalByRefObject");
      mono_defaults.marshalbyrefobject_class = D.19585;
      D.19586 = mono_defaults.marshalbyrefobject_class;
      D.19587 = D.19586 == 0B;
      D.19588 = (long int) D.19587;
      D.19589 = __builtin_expect (D.19588, 0);
      if (D.19589 != 0) goto <D.19590>; else goto <D.19591>;
      <D.19590>:
      monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "domain.c", 1590, "mono_defaults.marshalbyrefobject_class != 0");
      <D.19591>:
      D.19337 = mono_defaults.corlib;
      D.19592 = mono_class_from_name (D.19337, "System.Runtime.Remoting", "IRemotingTypeInfo");
      mono_defaults.iremotingtypeinfo_class = D.19592;
      D.19593 = mono_defaults.iremotingtypeinfo_class;
      D.19594 = D.19593 == 0B;
      D.19595 = (long int) D.19594;
      D.19596 = __builtin_expect (D.19595, 0);
      if (D.19596 != 0) goto <D.19597>; else goto <D.19598>;
      <D.19597>:
      monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "domain.c", 1594, "mono_defaults.iremotingtypeinfo_class != 0");
      <D.19598>:
      D.19337 = mono_defaults.corlib;
      D.19599 = mono_class_from_name (D.19337, "System.Runtime.Remoting.Messaging", "MonoMethodMessage");
      mono_defaults.mono_method_message_class = D.19599;
      D.19600 = mono_defaults.mono_method_message_class;
      D.19601 = D.19600 == 0B;
      D.19602 = (long int) D.19601;
      D.19603 = __builtin_expect (D.19602, 0);
      if (D.19603 != 0) goto <D.19604>; else goto <D.19605>;
      <D.19604>:
      monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "domain.c", 1599, "mono_defaults.mono_method_message_class != 0");
      <D.19605>:
      D.19337 = mono_defaults.corlib;
      D.19606 = mono_class_from_name (D.19337, "System.Reflection", "FieldInfo");
      mono_defaults.field_info_class = D.19606;
      D.19607 = mono_defaults.field_info_class;
      D.19608 = D.19607 == 0B;
      D.19609 = (long int) D.19608;
      D.19610 = __builtin_expect (D.19609, 0);
      if (D.19610 != 0) goto <D.19611>; else goto <D.19612>;
      <D.19611>:
      monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "domain.c", 1603, "mono_defaults.field_info_class != 0");
      <D.19612>:
      D.19337 = mono_defaults.corlib;
      D.19613 = mono_class_from_name (D.19337, "System.Reflection", "MethodInfo");
      mono_defaults.method_info_class = D.19613;
      D.19614 = mono_defaults.method_info_class;
      D.19615 = D.19614 == 0B;
      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", 1607, "mono_defaults.method_info_class != 0");
      <D.19619>:
      D.19337 = mono_defaults.corlib;
      D.19620 = mono_class_from_name (D.19337, "System.Text", "StringBuilder");
      mono_defaults.stringbuilder_class = D.19620;
      D.19621 = mono_defaults.stringbuilder_class;
      D.19622 = D.19621 == 0B;
      D.19623 = (long int) D.19622;
      D.19624 = __builtin_expect (D.19623, 0);
      if (D.19624 != 0) goto <D.19625>; else goto <D.19626>;
      <D.19625>:
      monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "domain.c", 1611, "mono_defaults.stringbuilder_class != 0");
      <D.19626>:
      D.19337 = mono_defaults.corlib;
      D.19627 = mono_class_from_name (D.19337, "System", "Math");
      mono_defaults.math_class = D.19627;
      D.19628 = mono_defaults.math_class;
      D.19629 = D.19628 == 0B;
      D.19630 = (long int) D.19629;
      D.19631 = __builtin_expect (D.19630, 0);
      if (D.19631 != 0) goto <D.19632>; else goto <D.19633>;
      <D.19632>:
      monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "domain.c", 1615, "mono_defaults.math_class != 0");
      <D.19633>:
      D.19337 = mono_defaults.corlib;
      D.19634 = mono_class_from_name (D.19337, "System.Diagnostics", "StackFrame");
      mono_defaults.stack_frame_class = D.19634;
      D.19635 = mono_defaults.stack_frame_class;
      D.19636 = D.19635 == 0B;
      D.19637 = (long int) D.19636;
      D.19638 = __builtin_expect (D.19637, 0);
      if (D.19638 != 0) goto <D.19639>; else goto <D.19640>;
      <D.19639>:
      monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "domain.c", 1619, "mono_defaults.stack_frame_class != 0");
      <D.19640>:
      D.19337 = mono_defaults.corlib;
      D.19641 = mono_class_from_name (D.19337, "System.Diagnostics", "StackTrace");
      mono_defaults.stack_trace_class = D.19641;
      D.19642 = mono_defaults.stack_trace_class;
      D.19643 = D.19642 == 0B;
      D.19644 = (long int) D.19643;
      D.19645 = __builtin_expect (D.19644, 0);
      if (D.19645 != 0) goto <D.19646>; else goto <D.19647>;
      <D.19646>:
      monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "domain.c", 1623, "mono_defaults.stack_trace_class != 0");
      <D.19647>:
      D.19337 = mono_defaults.corlib;
      D.19648 = mono_class_from_name (D.19337, "System.Runtime.InteropServices", "Marshal");
      mono_defaults.marshal_class = D.19648;
      D.19649 = mono_defaults.marshal_class;
      D.19650 = D.19649 == 0B;
      D.19651 = (long int) D.19650;
      D.19652 = __builtin_expect (D.19651, 0);
      if (D.19652 != 0) goto <D.19653>; else goto <D.19654>;
      <D.19653>:
      monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "domain.c", 1627, "mono_defaults.marshal_class != 0");
      <D.19654>:
      D.19337 = mono_defaults.corlib;
      D.19655 = mono_class_from_name (D.19337, "System", "TypedReference");
      mono_defaults.typed_reference_class = D.19655;
      D.19656 = mono_defaults.typed_reference_class;
      D.19657 = D.19656 == 0B;
      D.19658 = (long int) D.19657;
      D.19659 = __builtin_expect (D.19658, 0);
      if (D.19659 != 0) goto <D.19660>; else goto <D.19661>;
      <D.19660>:
      monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "domain.c", 1631, "mono_defaults.typed_reference_class != 0");
      <D.19661>:
      D.19337 = mono_defaults.corlib;
      D.19662 = mono_class_from_name (D.19337, "System", "RuntimeArgumentHandle");
      mono_defaults.argumenthandle_class = D.19662;
      D.19663 = mono_defaults.argumenthandle_class;
      D.19664 = D.19663 == 0B;
      D.19665 = (long int) D.19664;
      D.19666 = __builtin_expect (D.19665, 0);
      if (D.19666 != 0) goto <D.19667>; else goto <D.19668>;
      <D.19667>:
      monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "domain.c", 1635, "mono_defaults.argumenthandle_class != 0");
      <D.19668>:
      D.19337 = mono_defaults.corlib;
      D.19669 = mono_class_from_name (D.19337, "System.Threading", "Monitor");
      mono_defaults.monitor_class = D.19669;
      D.19670 = mono_defaults.monitor_class;
      D.19671 = D.19670 == 0B;
      D.19672 = (long int) D.19671;
      D.19673 = __builtin_expect (D.19672, 0);
      if (D.19673 != 0) goto <D.19674>; else goto <D.19675>;
      <D.19674>:
      monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "domain.c", 1639, "mono_defaults.monitor_class != 0");
      <D.19675>:
      D.19337 = mono_defaults.corlib;
      D.19676 = mono_class_from_name (D.19337, "System.Security", "RuntimeSecurityFrame");
      mono_defaults.runtimesecurityframe_class = D.19676;
      D.19337 = mono_defaults.corlib;
      D.19677 = mono_class_from_name (D.19337, "System.Threading", "ExecutionContext");
      mono_defaults.executioncontext_class = D.19677;
      D.19337 = mono_defaults.corlib;
      D.19678 = mono_class_from_name (D.19337, "System.Runtime.CompilerServices", "InternalsVisibleToAttribute");
      mono_defaults.internals_visible_class = D.19678;
      D.19337 = mono_defaults.corlib;
      D.19679 = mono_class_from_name (D.19337, "System.Runtime.ConstrainedExecution", "CriticalFinalizerObject");
      mono_defaults.critical_finalizer_object = D.19679;
      mono_assembly_load_friends (ass);
      D.19337 = mono_defaults.corlib;
      D.19680 = mono_class_from_name (D.19337, "System.Runtime.InteropServices", "SafeHandle");
      mono_defaults.safehandle_class = D.19680;
      D.19337 = mono_defaults.corlib;
      D.19681 = mono_class_from_name (D.19337, "System.Runtime.InteropServices", "HandleRef");
      mono_defaults.handleref_class = D.19681;
      D.19337 = mono_defaults.corlib;
      D.19682 = mono_class_from_name (D.19337, "System", "Attribute");
      mono_defaults.attribute_class = D.19682;
      D.19337 = mono_defaults.corlib;
      D.19683 = mono_class_from_name (D.19337, "System.Reflection", "CustomAttributeData");
      mono_defaults.customattribute_data_class = D.19683;
      D.19465 = mono_defaults.array_class;
      mono_class_init (D.19465);
      D.19337 = mono_defaults.corlib;
      D.19684 = mono_class_from_name (D.19337, "System", "Nullable`1");
      mono_defaults.generic_nullable_class = D.19684;
      D.19337 = mono_defaults.corlib;
      D.19685 = mono_class_from_name (D.19337, "System.Collections.Generic", "IList`1");
      mono_defaults.generic_ilist_class = D.19685;
      D.19337 = mono_defaults.corlib;
      D.19686 = mono_class_from_name (D.19337, "System.Collections.Generic", "IReadOnlyList`1");
      mono_defaults.generic_ireadonlylist_class = D.19686;
      domain.23 = domain;
      D.19687 = monoeg_g_path_get_basename (filename);
      domain.23->friendly_name = D.19687;
      domain.23 = domain;
      _mono_debug_init_corlib (domain.23);
      D.19688 = domain;
      return D.19688;
    }
  finally
    {
      status = {CLOBBER};
      runtimes = {CLOBBER};
    }
}


mono_native_tls_alloc (pthread_key_t * key, void * destructor)
{
  int D.19691;
  void (*<Tc2>) (void *) destructor.31;
  int D.19693;
  _Bool D.19694;

  destructor.31 = (void (*<Tc2>) (void *)) destructor;
  D.19693 = pthread_key_create (key, destructor.31);
  D.19694 = D.19693 == 0;
  D.19691 = (int) D.19694;
  return D.19691;
}


mono_native_tls_set_value (pthread_key_t key, void * value)
{
  int D.19696;
  int D.19697;
  _Bool D.19698;

  D.19697 = pthread_setspecific (key, value);
  D.19698 = D.19697 == 0;
  D.19696 = (int) D.19698;
  return D.19696;
}


get_runtimes_from_exe (const char * exe_file, struct MonoImage * * exe_image, const struct MonoRuntimeInfo * * runtimes)
{
  struct GSList * D.19702;
  int n.32;
  long unsigned int D.19708;
  long unsigned int D.19709;
  const struct MonoRuntimeInfo * * D.19710;
  struct GSList * iftmp.33;
  long unsigned int D.19715;
  long unsigned int D.19716;
  const struct MonoRuntimeInfo * * D.19717;
  char * D.19718;
  const struct MonoRuntimeInfo * D.19721;
  const struct MonoRuntimeInfo * * D.19722;
  const struct MonoRuntimeInfo * D.19727;
  char * D.19728;
  const struct MonoRuntimeInfo * D.19729;
  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.19700>; else goto <D.19701>;
  <D.19700>:
  D.19702 = app_config->supported_runtimes;
  if (D.19702 != 0B) goto <D.19703>; else goto <D.19704>;
  <D.19703>:
  {
    int n;
    struct GSList * list;

    n = 0;
    list = app_config->supported_runtimes;
    goto <D.18583>;
    <D.18582>:
    version = list->data;
    runtime = get_runtime_by_version (version);
    if (runtime != 0B) goto <D.19705>; else goto <D.19706>;
    <D.19705>:
    n.32 = n;
    n = n.32 + 1;
    D.19708 = (long unsigned int) n.32;
    D.19709 = D.19708 * 8;
    D.19710 = runtimes + D.19709;
    *D.19710 = runtime;
    <D.19706>:
    if (list != 0B) goto <D.19712>; else goto <D.19713>;
    <D.19712>:
    iftmp.33 = list->next;
    goto <D.19714>;
    <D.19713>:
    iftmp.33 = 0B;
    <D.19714>:
    list = iftmp.33;
    <D.18583>:
    if (list != 0B) goto <D.18582>; else goto <D.18584>;
    <D.18584>:
    D.19715 = (long unsigned int) n;
    D.19716 = D.19715 * 8;
    D.19717 = runtimes + D.19716;
    *D.19717 = 0B;
    app_config_free (app_config);
    return;
  }
  <D.19704>:
  D.19718 = app_config->required_runtime;
  if (D.19718 != 0B) goto <D.19719>; else goto <D.19720>;
  <D.19719>:
  D.19718 = app_config->required_runtime;
  D.19721 = get_runtime_by_version (D.19718);
  *runtimes = D.19721;
  D.19722 = runtimes + 8;
  *D.19722 = 0B;
  app_config_free (app_config);
  return;
  <D.19720>:
  app_config_free (app_config);
  <D.19701>:
  image = mono_assembly_open_from_bundle (exe_file, 0B, 0);
  if (image == 0B) goto <D.19723>; else goto <D.19724>;
  <D.19723>:
  image = mono_image_open (exe_file, 0B);
  <D.19724>:
  if (image == 0B) goto <D.19725>; else goto <D.19726>;
  <D.19725>:
  D.19727 = get_runtime_by_version ("v2.0.50727");
  *runtimes = D.19727;
  D.19722 = runtimes + 8;
  *D.19722 = 0B;
  return;
  <D.19726>:
  *exe_image = image;
  D.19728 = image->version;
  D.19729 = get_runtime_by_version (D.19728);
  *runtimes = D.19729;
  D.19722 = runtimes + 8;
  *D.19722 = 0B;
}


app_config_parse (const char * exe_filename)
{
  gchar * text.34;
  char * text.35;
  long unsigned int len.36;
  int D.19737;
  struct AppConfigInfo * D.19740;
  long unsigned int len.37;
  long int len.38;
  int D.19743;
  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.19731>; else goto <D.19732>;
      <D.19731>:
      text.34 = monoeg_strdup (bundled_config);
      text = text.34;
      text.35 = text;
      len.36 = strlen (text.35);
      len = len.36;
      goto <D.19736>;
      <D.19732>:
      config_filename = monoeg_g_strconcat (exe_filename, ".config", 0B);
      D.19737 = monoeg_g_file_get_contents (config_filename, &text, &len, 0B);
      if (D.19737 == 0) goto <D.19738>; else goto <D.19739>;
      <D.19738>:
      monoeg_g_free (config_filename);
      D.19740 = 0B;
      return D.19740;
      <D.19739>:
      monoeg_g_free (config_filename);
      <D.19736>:
      app_config = monoeg_malloc0 (24);
      context = monoeg_g_markup_parse_context_new (&mono_parser, 0, app_config, 0B);
      len.37 = len;
      len.38 = (long int) len.37;
      text.35 = text;
      D.19743 = monoeg_g_markup_parse_context_parse (context, text.35, len.38, 0B);
      if (D.19743 != 0) goto <D.19744>; else goto <D.19745>;
      <D.19744>:
      monoeg_g_markup_parse_context_end_parse (context, 0B);
      <D.19745>:
      monoeg_g_markup_parse_context_free (context);
      text.35 = text;
      monoeg_g_free (text.35);
      D.19740 = app_config;
      return D.19740;
    }
  finally
    {
      text = {CLOBBER};
      len = {CLOBBER};
    }
}


end_element (struct GMarkupParseContext * context, const gchar * element_name, void * user_data, struct GError * * error)
{
  int D.18513;
  int iftmp.39;
  int D.18512;
  const char[14] * D.19751;
  unsigned char D.19752;
  int D.19753;
  unsigned char D.19754;
  int D.19755;
  _Bool D.19756;
  _Bool D.19757;
  _Bool D.19758;
  const unsigned char * D.19761;
  unsigned char D.19762;
  int D.19763;
  const unsigned char * D.19764;
  unsigned char D.19765;
  int D.19766;
  _Bool D.19767;
  _Bool D.19768;
  const unsigned char * D.19771;
  unsigned char D.19772;
  int D.19773;
  const unsigned char * D.19774;
  unsigned char D.19775;
  int D.19776;
  _Bool D.19777;
  _Bool D.19778;
  const unsigned char * D.19781;
  unsigned char D.19782;
  int D.19783;
  const unsigned char * D.19784;
  unsigned char D.19785;
  int D.19786;
  int D.19790;
  int D.19791;
  int D.18522;
  int iftmp.40;
  int D.18521;
  const char[8] * D.19796;
  unsigned char D.19797;
  int D.19798;
  unsigned char D.19799;
  int D.19800;
  _Bool D.19801;
  _Bool D.19802;
  _Bool D.19803;
  const unsigned char * D.19806;
  unsigned char D.19807;
  int D.19808;
  const unsigned char * D.19809;
  unsigned char D.19810;
  int D.19811;
  _Bool D.19812;
  _Bool D.19813;
  const unsigned char * D.19816;
  unsigned char D.19817;
  int D.19818;
  const unsigned char * D.19819;
  unsigned char D.19820;
  int D.19821;
  _Bool D.19822;
  _Bool D.19823;
  const unsigned char * D.19826;
  unsigned char D.19827;
  int D.19828;
  const unsigned char * D.19829;
  unsigned char D.19830;
  int D.19831;
  int D.19835;
  int D.19836;
  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.19749>; else goto <D.19750>;
    <D.19749>:
    {
      const unsigned char * __s2;
      int __result;

      __s2 = element_name;
      D.19751 = "configuration";
      D.19752 = MEM[(const unsigned char *)D.19751];
      D.19753 = (int) D.19752;
      D.19754 = *__s2;
      D.19755 = (int) D.19754;
      __result = D.19753 - D.19755;
      {
        D.19756 = __s2_len != 0;
        D.19757 = __result == 0;
        D.19758 = D.19756 & D.19757;
        if (D.19758 != 0) goto <D.19759>; else goto <D.19760>;
        <D.19759>:
        D.19761 = &MEM[(void *)"configuration" + 1B];
        D.19762 = *D.19761;
        D.19763 = (int) D.19762;
        D.19764 = __s2 + 1;
        D.19765 = *D.19764;
        D.19766 = (int) D.19765;
        __result = D.19763 - D.19766;
        D.19767 = __s2_len > 1;
        D.19757 = __result == 0;
        D.19768 = D.19767 & D.19757;
        if (D.19768 != 0) goto <D.19769>; else goto <D.19770>;
        <D.19769>:
        D.19771 = &MEM[(void *)"configuration" + 2B];
        D.19772 = *D.19771;
        D.19773 = (int) D.19772;
        D.19774 = __s2 + 2;
        D.19775 = *D.19774;
        D.19776 = (int) D.19775;
        __result = D.19773 - D.19776;
        D.19777 = __s2_len > 2;
        D.19757 = __result == 0;
        D.19778 = D.19777 & D.19757;
        if (D.19778 != 0) goto <D.19779>; else goto <D.19780>;
        <D.19779>:
        D.19781 = &MEM[(void *)"configuration" + 3B];
        D.19782 = *D.19781;
        D.19783 = (int) D.19782;
        D.19784 = __s2 + 3;
        D.19785 = *D.19784;
        D.19786 = (int) D.19785;
        __result = D.19783 - D.19786;
        <D.19780>:
        <D.19770>:
        <D.19760>:
      }
      D.18512 = __result;
    }
    iftmp.39 = -D.18512;
    goto <D.19787>;
    <D.19750>:
    iftmp.39 = __builtin_strcmp (element_name, "configuration");
    <D.19787>:
    D.18513 = iftmp.39;
  }
  if (D.18513 == 0) goto <D.19788>; else goto <D.19789>;
  <D.19788>:
  D.19790 = app_config->configuration_count;
  D.19791 = D.19790 + -1;
  app_config->configuration_count = D.19791;
  goto <D.19792>;
  <D.19789>:
  {
    size_t __s1_len;
    size_t __s2_len;

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

      __s2 = element_name;
      D.19796 = "startup";
      D.19797 = MEM[(const unsigned char *)D.19796];
      D.19798 = (int) D.19797;
      D.19799 = *__s2;
      D.19800 = (int) D.19799;
      __result = D.19798 - D.19800;
      {
        D.19801 = __s2_len != 0;
        D.19802 = __result == 0;
        D.19803 = D.19801 & D.19802;
        if (D.19803 != 0) goto <D.19804>; else goto <D.19805>;
        <D.19804>:
        D.19806 = &MEM[(void *)"startup" + 1B];
        D.19807 = *D.19806;
        D.19808 = (int) D.19807;
        D.19809 = __s2 + 1;
        D.19810 = *D.19809;
        D.19811 = (int) D.19810;
        __result = D.19808 - D.19811;
        D.19812 = __s2_len > 1;
        D.19802 = __result == 0;
        D.19813 = D.19812 & D.19802;
        if (D.19813 != 0) goto <D.19814>; else goto <D.19815>;
        <D.19814>:
        D.19816 = &MEM[(void *)"startup" + 2B];
        D.19817 = *D.19816;
        D.19818 = (int) D.19817;
        D.19819 = __s2 + 2;
        D.19820 = *D.19819;
        D.19821 = (int) D.19820;
        __result = D.19818 - D.19821;
        D.19822 = __s2_len > 2;
        D.19802 = __result == 0;
        D.19823 = D.19822 & D.19802;
        if (D.19823 != 0) goto <D.19824>; else goto <D.19825>;
        <D.19824>:
        D.19826 = &MEM[(void *)"startup" + 3B];
        D.19827 = *D.19826;
        D.19828 = (int) D.19827;
        D.19829 = __s2 + 3;
        D.19830 = *D.19829;
        D.19831 = (int) D.19830;
        __result = D.19828 - D.19831;
        <D.19825>:
        <D.19815>:
        <D.19805>:
      }
      D.18521 = __result;
    }
    iftmp.40 = -D.18521;
    goto <D.19832>;
    <D.19795>:
    iftmp.40 = __builtin_strcmp (element_name, "startup");
    <D.19832>:
    D.18522 = iftmp.40;
  }
  if (D.18522 == 0) goto <D.19833>; else goto <D.19834>;
  <D.19833>:
  D.19835 = app_config->startup_count;
  D.19836 = D.19835 + -1;
  app_config->startup_count = D.19836;
  <D.19834>:
  <D.19792>:
}


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.18469;
  int iftmp.41;
  int D.18468;
  const char[14] * D.19840;
  unsigned char D.19841;
  int D.19842;
  unsigned char D.19843;
  int D.19844;
  _Bool D.19845;
  _Bool D.19846;
  _Bool D.19847;
  const unsigned char * D.19850;
  unsigned char D.19851;
  int D.19852;
  const unsigned char * D.19853;
  unsigned char D.19854;
  int D.19855;
  _Bool D.19856;
  _Bool D.19857;
  const unsigned char * D.19860;
  unsigned char D.19861;
  int D.19862;
  const unsigned char * D.19863;
  unsigned char D.19864;
  int D.19865;
  _Bool D.19866;
  _Bool D.19867;
  const unsigned char * D.19870;
  unsigned char D.19871;
  int D.19872;
  const unsigned char * D.19873;
  unsigned char D.19874;
  int D.19875;
  int D.19879;
  int D.19880;
  int D.18478;
  int iftmp.42;
  int D.18477;
  const char[8] * D.19884;
  unsigned char D.19885;
  int D.19886;
  unsigned char D.19887;
  int D.19888;
  _Bool D.19889;
  _Bool D.19890;
  _Bool D.19891;
  const unsigned char * D.19894;
  unsigned char D.19895;
  int D.19896;
  const unsigned char * D.19897;
  unsigned char D.19898;
  int D.19899;
  _Bool D.19900;
  _Bool D.19901;
  const unsigned char * D.19904;
  unsigned char D.19905;
  int D.19906;
  const unsigned char * D.19907;
  unsigned char D.19908;
  int D.19909;
  _Bool D.19910;
  _Bool D.19911;
  const unsigned char * D.19914;
  unsigned char D.19915;
  int D.19916;
  const unsigned char * D.19917;
  unsigned char D.19918;
  int D.19919;
  int D.19923;
  int D.19924;
  signed long D.19925;
  long unsigned int D.19926;
  long unsigned int D.19927;
  int D.18487;
  int iftmp.43;
  int D.18486;
  const char[16] * D.19933;
  unsigned char D.19934;
  int D.19935;
  unsigned char D.19936;
  int D.19937;
  _Bool D.19938;
  _Bool D.19939;
  _Bool D.19940;
  const unsigned char * D.19943;
  unsigned char D.19944;
  int D.19945;
  const unsigned char * D.19946;
  unsigned char D.19947;
  int D.19948;
  _Bool D.19949;
  _Bool D.19950;
  const unsigned char * D.19953;
  unsigned char D.19954;
  int D.19955;
  const unsigned char * D.19956;
  unsigned char D.19957;
  int D.19958;
  _Bool D.19959;
  _Bool D.19960;
  const unsigned char * D.19963;
  unsigned char D.19964;
  int D.19965;
  const unsigned char * D.19966;
  unsigned char D.19967;
  int D.19968;
  char * D.19972;
  int D.18496;
  int iftmp.44;
  int D.18495;
  const char[17] * D.19977;
  unsigned char D.19978;
  int D.19979;
  unsigned char D.19980;
  int D.19981;
  _Bool D.19982;
  _Bool D.19983;
  _Bool D.19984;
  const unsigned char * D.19987;
  unsigned char D.19988;
  int D.19989;
  const unsigned char * D.19990;
  unsigned char D.19991;
  int D.19992;
  _Bool D.19993;
  _Bool D.19994;
  const unsigned char * D.19997;
  unsigned char D.19998;
  int D.19999;
  const unsigned char * D.20000;
  unsigned char D.20001;
  int D.20002;
  _Bool D.20003;
  _Bool D.20004;
  const unsigned char * D.20007;
  unsigned char D.20008;
  int D.20009;
  const unsigned char * D.20010;
  unsigned char D.20011;
  int D.20012;
  struct GSList * D.20016;
  struct GSList * D.20017;
  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.19838>; else goto <D.19839>;
    <D.19838>:
    {
      const unsigned char * __s2;
      int __result;

      __s2 = element_name;
      D.19840 = "configuration";
      D.19841 = MEM[(const unsigned char *)D.19840];
      D.19842 = (int) D.19841;
      D.19843 = *__s2;
      D.19844 = (int) D.19843;
      __result = D.19842 - D.19844;
      {
        D.19845 = __s2_len != 0;
        D.19846 = __result == 0;
        D.19847 = D.19845 & D.19846;
        if (D.19847 != 0) goto <D.19848>; else goto <D.19849>;
        <D.19848>:
        D.19850 = &MEM[(void *)"configuration" + 1B];
        D.19851 = *D.19850;
        D.19852 = (int) D.19851;
        D.19853 = __s2 + 1;
        D.19854 = *D.19853;
        D.19855 = (int) D.19854;
        __result = D.19852 - D.19855;
        D.19856 = __s2_len > 1;
        D.19846 = __result == 0;
        D.19857 = D.19856 & D.19846;
        if (D.19857 != 0) goto <D.19858>; else goto <D.19859>;
        <D.19858>:
        D.19860 = &MEM[(void *)"configuration" + 2B];
        D.19861 = *D.19860;
        D.19862 = (int) D.19861;
        D.19863 = __s2 + 2;
        D.19864 = *D.19863;
        D.19865 = (int) D.19864;
        __result = D.19862 - D.19865;
        D.19866 = __s2_len > 2;
        D.19846 = __result == 0;
        D.19867 = D.19866 & D.19846;
        if (D.19867 != 0) goto <D.19868>; else goto <D.19869>;
        <D.19868>:
        D.19870 = &MEM[(void *)"configuration" + 3B];
        D.19871 = *D.19870;
        D.19872 = (int) D.19871;
        D.19873 = __s2 + 3;
        D.19874 = *D.19873;
        D.19875 = (int) D.19874;
        __result = D.19872 - D.19875;
        <D.19869>:
        <D.19859>:
        <D.19849>:
      }
      D.18468 = __result;
    }
    iftmp.41 = -D.18468;
    goto <D.19876>;
    <D.19839>:
    iftmp.41 = __builtin_strcmp (element_name, "configuration");
    <D.19876>:
    D.18469 = iftmp.41;
  }
  if (D.18469 == 0) goto <D.19877>; else goto <D.19878>;
  <D.19877>:
  D.19879 = app_config->configuration_count;
  D.19880 = D.19879 + 1;
  app_config->configuration_count = D.19880;
  return;
  <D.19878>:
  {
    size_t __s1_len;
    size_t __s2_len;

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

      __s2 = element_name;
      D.19884 = "startup";
      D.19885 = MEM[(const unsigned char *)D.19884];
      D.19886 = (int) D.19885;
      D.19887 = *__s2;
      D.19888 = (int) D.19887;
      __result = D.19886 - D.19888;
      {
        D.19889 = __s2_len != 0;
        D.19890 = __result == 0;
        D.19891 = D.19889 & D.19890;
        if (D.19891 != 0) goto <D.19892>; else goto <D.19893>;
        <D.19892>:
        D.19894 = &MEM[(void *)"startup" + 1B];
        D.19895 = *D.19894;
        D.19896 = (int) D.19895;
        D.19897 = __s2 + 1;
        D.19898 = *D.19897;
        D.19899 = (int) D.19898;
        __result = D.19896 - D.19899;
        D.19900 = __s2_len > 1;
        D.19890 = __result == 0;
        D.19901 = D.19900 & D.19890;
        if (D.19901 != 0) goto <D.19902>; else goto <D.19903>;
        <D.19902>:
        D.19904 = &MEM[(void *)"startup" + 2B];
        D.19905 = *D.19904;
        D.19906 = (int) D.19905;
        D.19907 = __s2 + 2;
        D.19908 = *D.19907;
        D.19909 = (int) D.19908;
        __result = D.19906 - D.19909;
        D.19910 = __s2_len > 2;
        D.19890 = __result == 0;
        D.19911 = D.19910 & D.19890;
        if (D.19911 != 0) goto <D.19912>; else goto <D.19913>;
        <D.19912>:
        D.19914 = &MEM[(void *)"startup" + 3B];
        D.19915 = *D.19914;
        D.19916 = (int) D.19915;
        D.19917 = __s2 + 3;
        D.19918 = *D.19917;
        D.19919 = (int) D.19918;
        __result = D.19916 - D.19919;
        <D.19913>:
        <D.19903>:
        <D.19893>:
      }
      D.18477 = __result;
    }
    iftmp.42 = -D.18477;
    goto <D.19920>;
    <D.19883>:
    iftmp.42 = __builtin_strcmp (element_name, "startup");
    <D.19920>:
    D.18478 = iftmp.42;
  }
  if (D.18478 == 0) goto <D.19921>; else goto <D.19922>;
  <D.19921>:
  D.19923 = app_config->startup_count;
  D.19924 = D.19923 + 1;
  app_config->startup_count = D.19924;
  return;
  <D.19922>:
  D.19925 = BIT_FIELD_REF <*app_config, 64, 128>;
  D.19926 = (long unsigned int) D.19925;
  D.19927 = D.19926;
  if (D.19927 != 4294967297) goto <D.19928>; else goto <D.19929>;
  <D.19928>:
  return;
  <D.19929>:
  {
    size_t __s1_len;
    size_t __s2_len;

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

      __s2 = element_name;
      D.19933 = "requiredRuntime";
      D.19934 = MEM[(const unsigned char *)D.19933];
      D.19935 = (int) D.19934;
      D.19936 = *__s2;
      D.19937 = (int) D.19936;
      __result = D.19935 - D.19937;
      {
        D.19938 = __s2_len != 0;
        D.19939 = __result == 0;
        D.19940 = D.19938 & D.19939;
        if (D.19940 != 0) goto <D.19941>; else goto <D.19942>;
        <D.19941>:
        D.19943 = &MEM[(void *)"requiredRuntime" + 1B];
        D.19944 = *D.19943;
        D.19945 = (int) D.19944;
        D.19946 = __s2 + 1;
        D.19947 = *D.19946;
        D.19948 = (int) D.19947;
        __result = D.19945 - D.19948;
        D.19949 = __s2_len > 1;
        D.19939 = __result == 0;
        D.19950 = D.19949 & D.19939;
        if (D.19950 != 0) goto <D.19951>; else goto <D.19952>;
        <D.19951>:
        D.19953 = &MEM[(void *)"requiredRuntime" + 2B];
        D.19954 = *D.19953;
        D.19955 = (int) D.19954;
        D.19956 = __s2 + 2;
        D.19957 = *D.19956;
        D.19958 = (int) D.19957;
        __result = D.19955 - D.19958;
        D.19959 = __s2_len > 2;
        D.19939 = __result == 0;
        D.19960 = D.19959 & D.19939;
        if (D.19960 != 0) goto <D.19961>; else goto <D.19962>;
        <D.19961>:
        D.19963 = &MEM[(void *)"requiredRuntime" + 3B];
        D.19964 = *D.19963;
        D.19965 = (int) D.19964;
        D.19966 = __s2 + 3;
        D.19967 = *D.19966;
        D.19968 = (int) D.19967;
        __result = D.19965 - D.19968;
        <D.19962>:
        <D.19952>:
        <D.19942>:
      }
      D.18486 = __result;
    }
    iftmp.43 = -D.18486;
    goto <D.19969>;
    <D.19932>:
    iftmp.43 = __builtin_strcmp (element_name, "requiredRuntime");
    <D.19969>:
    D.18487 = iftmp.43;
  }
  if (D.18487 == 0) goto <D.19970>; else goto <D.19971>;
  <D.19970>:
  D.19972 = get_attribute_value (attribute_names, attribute_values, "version");
  app_config->required_runtime = D.19972;
  goto <D.19973>;
  <D.19971>:
  {
    size_t __s1_len;
    size_t __s2_len;

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

      __s2 = element_name;
      D.19977 = "supportedRuntime";
      D.19978 = MEM[(const unsigned char *)D.19977];
      D.19979 = (int) D.19978;
      D.19980 = *__s2;
      D.19981 = (int) D.19980;
      __result = D.19979 - D.19981;
      {
        D.19982 = __s2_len != 0;
        D.19983 = __result == 0;
        D.19984 = D.19982 & D.19983;
        if (D.19984 != 0) goto <D.19985>; else goto <D.19986>;
        <D.19985>:
        D.19987 = &MEM[(void *)"supportedRuntime" + 1B];
        D.19988 = *D.19987;
        D.19989 = (int) D.19988;
        D.19990 = __s2 + 1;
        D.19991 = *D.19990;
        D.19992 = (int) D.19991;
        __result = D.19989 - D.19992;
        D.19993 = __s2_len > 1;
        D.19983 = __result == 0;
        D.19994 = D.19993 & D.19983;
        if (D.19994 != 0) goto <D.19995>; else goto <D.19996>;
        <D.19995>:
        D.19997 = &MEM[(void *)"supportedRuntime" + 2B];
        D.19998 = *D.19997;
        D.19999 = (int) D.19998;
        D.20000 = __s2 + 2;
        D.20001 = *D.20000;
        D.20002 = (int) D.20001;
        __result = D.19999 - D.20002;
        D.20003 = __s2_len > 2;
        D.19983 = __result == 0;
        D.20004 = D.20003 & D.19983;
        if (D.20004 != 0) goto <D.20005>; else goto <D.20006>;
        <D.20005>:
        D.20007 = &MEM[(void *)"supportedRuntime" + 3B];
        D.20008 = *D.20007;
        D.20009 = (int) D.20008;
        D.20010 = __s2 + 3;
        D.20011 = *D.20010;
        D.20012 = (int) D.20011;
        __result = D.20009 - D.20012;
        <D.20006>:
        <D.19996>:
        <D.19986>:
      }
      D.18495 = __result;
    }
    iftmp.44 = -D.18495;
    goto <D.20013>;
    <D.19976>:
    iftmp.44 = __builtin_strcmp (element_name, "supportedRuntime");
    <D.20013>:
    D.18496 = iftmp.44;
  }
  if (D.18496 == 0) goto <D.20014>; else goto <D.20015>;
  <D.20014>:
  {
    char * version;

    version = get_attribute_value (attribute_names, attribute_values, "version");
    D.20016 = app_config->supported_runtimes;
    D.20017 = monoeg_g_slist_append (D.20016, version);
    app_config->supported_runtimes = D.20017;
  }
  <D.20015>:
  <D.19973>:
}


get_attribute_value (const gchar * * attribute_names, const gchar * * attribute_values, const char * att_name)
{
  int D.18448;
  long unsigned int D.20019;
  long unsigned int D.20020;
  const gchar * * D.20021;
  const gchar * D.20022;
  char * D.20025;
  const gchar * * D.20026;
  const gchar * D.20027;
  int n;

  n = 0;
  goto <D.18450>;
  <D.18449>:
  {
    size_t __s1_len;
    size_t __s2_len;

    D.20019 = (long unsigned int) n;
    D.20020 = D.20019 * 8;
    D.20021 = attribute_names + D.20020;
    D.20022 = *D.20021;
    D.18448 = __builtin_strcmp (D.20022, att_name);
  }
  if (D.18448 == 0) goto <D.20023>; else goto <D.20024>;
  <D.20023>:
  D.20019 = (long unsigned int) n;
  D.20020 = D.20019 * 8;
  D.20026 = attribute_values + D.20020;
  D.20027 = *D.20026;
  D.20025 = monoeg_strdup (D.20027);
  return D.20025;
  <D.20024>:
  n = n + 1;
  <D.18450>:
  D.20019 = (long unsigned int) n;
  D.20020 = D.20019 * 8;
  D.20021 = attribute_names + D.20020;
  D.20022 = *D.20021;
  if (D.20022 != 0B) goto <D.18449>; else goto <D.18451>;
  <D.18451>:
  D.20025 = 0B;
  return D.20025;
}


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

  if (str != 0B) goto <D.20029>; else goto <D.20030>;
  <D.20029>:
  D.20031 = __strdup (str);
  return D.20031;
  <D.20030>:
  D.20031 = 0B;
  return D.20031;
}


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

  list = app_config->supported_runtimes;
  goto <D.18539>;
  <D.18538>:
  rt = list->data;
  monoeg_g_free (rt);
  if (list != 0B) goto <D.20034>; else goto <D.20035>;
  <D.20034>:
  iftmp.45 = list->next;
  goto <D.20036>;
  <D.20035>:
  iftmp.45 = 0B;
  <D.20036>:
  list = iftmp.45;
  <D.18539>:
  if (list != 0B) goto <D.18538>; else goto <D.18540>;
  <D.18540>:
  D.20037 = app_config->supported_runtimes;
  monoeg_g_slist_free (D.20037);
  D.20038 = app_config->required_runtime;
  monoeg_g_free (D.20038);
  monoeg_g_free (app_config);
}


get_runtime_by_version (const char * version)
{
  const struct MonoRuntimeInfo * D.20041;
  int D.18555;
  const char[12] * D.20042;
  long unsigned int D.20045;
  const char * D.20048;
  char D.20049;
  int D.20052;
  int n;
  int max;
  int vlen;

  max = 6;
  if (version == 0B) goto <D.20039>; else goto <D.20040>;
  <D.20039>:
  D.20041 = 0B;
  return D.20041;
  <D.20040>:
  n = 0;
  goto <D.18557>;
  <D.18556>:
  {
    size_t __s1_len;
    size_t __s2_len;

    D.20042 = &supported_runtimes[n].runtime_version;
    D.18555 = __builtin_strcmp (version, D.20042);
  }
  if (D.18555 == 0) goto <D.20043>; else goto <D.20044>;
  <D.20043>:
  D.20041 = &supported_runtimes[n];
  return D.20041;
  <D.20044>:
  n = n + 1;
  <D.18557>:
  if (n < max) goto <D.18556>; else goto <D.18558>;
  <D.18558>:
  D.20045 = strlen (version);
  vlen = (int) D.20045;
  if (vlen > 3) goto <D.20046>; else goto <D.20047>;
  <D.20046>:
  D.20048 = version + 1;
  D.20049 = *D.20048;
  if (D.20049 > 51) goto <D.20050>; else goto <D.20051>;
  <D.20050>:
  n = 0;
  goto <D.18569>;
  <D.18568>:
  D.20042 = &supported_runtimes[n].runtime_version;
  D.20052 = strncmp (version, D.20042, 4);
  if (D.20052 == 0) goto <D.20053>; else goto <D.20054>;
  <D.20053>:
  D.20041 = &supported_runtimes[n];
  return D.20041;
  <D.20054>:
  n = n + 1;
  <D.18569>:
  if (n < max) goto <D.18568>; else goto <D.18570>;
  <D.18570>:
  <D.20051>:
  <D.20047>:
  D.20041 = 0B;
  return D.20041;
}


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

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


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

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


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

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


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.20064>; else goto <D.20065>;
  <D.20064>:
  exe_image.47 = exe_image;
  mono_image_close (exe_image.47);
  <D.20065>:
}


mono_get_root_domain ()
{
  struct MonoDomain * D.20066;

  D.20066 = mono_root_domain;
  return D.20066;
}


mono_domain_get ()
{
  struct MonoDomain * D.20068;

  D.20068 = tls_appdomain;
  return D.20068;
}


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.20071;
  unsigned int appdomain_thread_id.49;
  struct MonoAppContext * D.20075;
  struct MonoInternalThread * D.20076;
  struct MonoAppContext * * D.20077;
  struct MonoInternalThread * D.20078;
  struct MonoException * D.20081;
  struct MonoVTable * D.20084;
  struct MonoDomain * D.20085;
  _Bool D.20086;
  long int D.20087;
  long int D.20088;
  struct MonoException * D.20091;
  struct MonoException * * D.20092;
  _Bool D.20093;
  long int D.20094;
  long int D.20095;
  struct MonoInternalThread * thread;

  D.20071 = mono_domain_get ();
  if (D.20071 == domain) goto <D.20072>; else goto <D.20073>;
  <D.20072>:
  return;
  <D.20073>:
  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.20075 = domain->default_context;
  D.20076 = mono_thread_internal_current ();
  D.20077 = &D.20076->current_appcontext;
  D.20078 = mono_thread_internal_current ();
  mono_gc_wbarrier_set_field (D.20078, D.20077, D.20075);
  if (migrate_exception != 0) goto <D.20079>; else goto <D.20080>;
  <D.20079>:
  thread = mono_thread_internal_current ();
  D.20081 = thread->abort_exc;
  if (D.20081 == 0B) goto <D.20082>; else goto <D.20083>;
  <D.20082>:
  return;
  <D.20083>:
  D.20081 = thread->abort_exc;
  D.20084 = D.20081->object.vtable;
  D.20085 = D.20084->domain;
  D.20086 = D.20085 == domain;
  D.20087 = (long int) D.20086;
  D.20088 = __builtin_expect (D.20087, 0);
  if (D.20088 != 0) goto <D.20089>; else goto <D.20090>;
  <D.20089>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "domain.c", 1830, "thread->abort_exc->object.vtable->domain != domain");
  <D.20090>:
  D.20091 = mono_get_exception_thread_abort ();
  D.20092 = &thread->abort_exc;
  mono_gc_wbarrier_set_field (thread, D.20092, D.20091);
  D.20081 = thread->abort_exc;
  D.20084 = D.20081->object.vtable;
  D.20085 = D.20084->domain;
  D.20093 = D.20085 != domain;
  D.20094 = (long int) D.20093;
  D.20095 = __builtin_expect (D.20094, 0);
  if (D.20095 != 0) goto <D.20096>; else goto <D.20097>;
  <D.20096>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "domain.c", 1832, "thread->abort_exc->object.vtable->domain == domain");
  <D.20097>:
  <D.20080>:
}


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.20101;
  long int D.20102;
  long int D.20103;
  short unsigned int appdomain_list_size.50;
  long unsigned int D.20107;
  long unsigned int D.20108;
  struct MonoDomain * * appdomains_list.51;
  _Bool D.20112;
  long int D.20113;
  long int D.20114;
  long unsigned int D.20117;
  long unsigned int D.20118;
  struct MonoDomain * * D.20119;
  struct MonoDomain * D.20120;
  int i;
  int size;
  struct MonoDomain * * copy;

  {
    int ret;

    ret = pthread_mutex_lock (&appdomains_mutex.mutex);
    if (ret != 0) goto <D.20099>; else goto <D.20100>;
    <D.20099>:
    monoeg_g_log (0B, 16, "Bad call to mono_mutex_lock result %d", ret);
    <D.20100>:
    D.20101 = ret != 0;
    D.20102 = (long int) D.20101;
    D.20103 = __builtin_expect (D.20102, 0);
    if (D.20103 != 0) goto <D.20104>; else goto <D.20105>;
    <D.20104>:
    monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "domain.c", 1859, "ret == 0");
    <D.20105>:
  }
  appdomain_list_size.50 = appdomain_list_size;
  size = (int) appdomain_list_size.50;
  appdomain_list_size.50 = appdomain_list_size;
  D.20107 = (long unsigned int) appdomain_list_size.50;
  D.20108 = D.20107 * 8;
  copy = mono_gc_alloc_fixed (D.20108, 0B);
  appdomain_list_size.50 = appdomain_list_size;
  D.20107 = (long unsigned int) appdomain_list_size.50;
  D.20108 = D.20107 * 8;
  appdomains_list.51 = appdomains_list;
  memcpy (copy, appdomains_list.51, D.20108);
  {
    int ret;

    ret = pthread_mutex_unlock (&appdomains_mutex.mutex);
    if (ret != 0) goto <D.20110>; else goto <D.20111>;
    <D.20110>:
    monoeg_g_log (0B, 16, "Bad call to mono_mutex_unlock result %d", ret);
    <D.20111>:
    D.20112 = ret != 0;
    D.20113 = (long int) D.20112;
    D.20114 = __builtin_expect (D.20113, 0);
    if (D.20114 != 0) goto <D.20115>; else goto <D.20116>;
    <D.20115>:
    monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "domain.c", 1863, "ret == 0");
    <D.20116>:
  }
  i = 0;
  goto <D.18221>;
  <D.18220>:
  D.20117 = (long unsigned int) i;
  D.20118 = D.20117 * 8;
  D.20119 = copy + D.20118;
  D.20120 = *D.20119;
  if (D.20120 != 0B) goto <D.20121>; else goto <D.20122>;
  <D.20121>:
  D.20117 = (long unsigned int) i;
  D.20118 = D.20117 * 8;
  D.20119 = copy + D.20118;
  D.20120 = *D.20119;
  func (D.20120, user_data);
  <D.20122>:
  i = i + 1;
  <D.18221>:
  if (i < size) goto <D.18220>; else goto <D.18222>;
  <D.18222>:
  mono_gc_free_fixed (copy);
}


mono_domain_assembly_open (struct MonoDomain * domain, const char * name)
{
  union mono_mutex_t * D.20123;
  _Bool D.20126;
  long int D.20127;
  long int D.20128;
  int D.18239;
  const char * D.20131;
  _Bool D.20136;
  long int D.20137;
  long int D.20138;
  struct MonoAssembly * D.20141;
  _Bool D.20144;
  long int D.20145;
  long int D.20146;
  struct MonoDomain * D.20149;
  struct MonoDomain * current;
  struct MonoAssembly * ass;
  struct GSList * tmp;

  {
    int ret;

    D.20123 = &domain->assemblies_lock.mutex;
    ret = pthread_mutex_lock (D.20123);
    if (ret != 0) goto <D.20124>; else goto <D.20125>;
    <D.20124>:
    monoeg_g_log (0B, 16, "Bad call to mono_mutex_lock result %d", ret);
    <D.20125>:
    D.20126 = ret != 0;
    D.20127 = (long int) D.20126;
    D.20128 = __builtin_expect (D.20127, 0);
    if (D.20128 != 0) goto <D.20129>; else goto <D.20130>;
    <D.20129>:
    monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "domain.c", 1887, "ret == 0");
    <D.20130>:
  }
  tmp = domain->domain_assemblies;
  goto <D.18242>;
  <D.18241>:
  ass = tmp->data;
  {
    size_t __s1_len;
    size_t __s2_len;

    D.20131 = ass->aname.name;
    D.18239 = __builtin_strcmp (name, D.20131);
  }
  if (D.18239 == 0) goto <D.20132>; else goto <D.20133>;
  <D.20132>:
  {
    int ret;

    D.20123 = &domain->assemblies_lock.mutex;
    ret = pthread_mutex_unlock (D.20123);
    if (ret != 0) goto <D.20134>; else goto <D.20135>;
    <D.20134>:
    monoeg_g_log (0B, 16, "Bad call to mono_mutex_unlock result %d", ret);
    <D.20135>:
    D.20136 = ret != 0;
    D.20137 = (long int) D.20136;
    D.20138 = __builtin_expect (D.20137, 0);
    if (D.20138 != 0) goto <D.20139>; else goto <D.20140>;
    <D.20139>:
    monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "domain.c", 1891, "ret == 0");
    <D.20140>:
  }
  D.20141 = ass;
  return D.20141;
  <D.20133>:
  tmp = tmp->next;
  <D.18242>:
  if (tmp != 0B) goto <D.18241>; else goto <D.18243>;
  <D.18243>:
  {
    int ret;

    D.20123 = &domain->assemblies_lock.mutex;
    ret = pthread_mutex_unlock (D.20123);
    if (ret != 0) goto <D.20142>; else goto <D.20143>;
    <D.20142>:
    monoeg_g_log (0B, 16, "Bad call to mono_mutex_unlock result %d", ret);
    <D.20143>:
    D.20144 = ret != 0;
    D.20145 = (long int) D.20144;
    D.20146 = __builtin_expect (D.20145, 0);
    if (D.20146 != 0) goto <D.20147>; else goto <D.20148>;
    <D.20147>:
    monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "domain.c", 1895, "ret == 0");
    <D.20148>:
  }
  D.20149 = mono_domain_get ();
  if (D.20149 != domain) goto <D.20150>; else goto <D.20151>;
  <D.20150>:
  current = mono_domain_get ();
  mono_domain_set (domain, 0);
  ass = mono_assembly_open (name, 0B);
  mono_domain_set (current, 0);
  goto <D.20152>;
  <D.20151>:
  ass = mono_assembly_open (name, 0B);
  <D.20152>:
  D.20141 = ass;
  return D.20141;
}


mono_domain_free (struct MonoDomain * domain, gboolean force)
{
  struct MonoDomain * mono_root_domain.52;
  int mono_dont_free_domains.53;
  _Bool D.20164;
  long int D.20165;
  long int D.20166;
  struct MonoDomain * * appdomains_list.54;
  int D.20170;
  long unsigned int D.20171;
  long unsigned int D.20172;
  struct MonoDomain * * D.20173;
  _Bool D.20176;
  long int D.20177;
  long int D.20178;
  struct GHashTable * D.20181;
  struct MonoGHashTable * D.20184;
  struct MonoGHashTable * D.20185;
  struct MonoTlsDataRecord * D.20186;
  struct MonoGHashTable * D.20189;
  struct MonoGHashTable * D.20192;
  struct GPtrArray * D.20195;
  void * * D.20198;
  long unsigned int D.20199;
  long unsigned int D.20200;
  void * * D.20201;
  void * D.20202;
  unsigned int i.55;
  unsigned int D.20204;
  struct MonoGHashTable * * D.20205;
  struct MonoImage * D.20208;
  unsigned char D.20210;
  unsigned char D.20211;
  int D.20212;
  const char * D.20213;
  char * D.20214;
  int D.20215;
  struct MonoImage * D.20222;
  unsigned char D.20224;
  unsigned char D.20225;
  int D.20226;
  const char * D.20227;
  int D.20228;
  struct GSList * D.20233;
  void (*<T19c3>) (struct MonoDomain *) free_domain_hook.56;
  gchar * * D.20237;
  struct GHashTable * D.20240;
  void * * D.20241;
  struct MonoInternalHashTable * D.20244;
  struct MonoJitInfoTable * D.20245;
  struct MonoJitInfoTable * D.20248;
  int D.20249;
  _Bool D.20250;
  long int D.20251;
  long int D.20252;
  struct MonoJitInfoTable * D.20255;
  struct GSList * D.20256;
  _Bool D.20257;
  long int D.20258;
  long int D.20259;
  struct MonoCodeManager * D.20262;
  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.20270;
  struct LockFreeMempool * D.20271;
  struct GHashTable * D.20272;
  struct GHashTable * D.20273;
  struct GHashTable * D.20276;
  struct GHashTable * D.20279;
  struct GHashTable * D.20282;
  struct CRITICAL_SECTION * D.20285;
  struct CRITICAL_SECTION * D.20286;
  struct CRITICAL_SECTION * D.20287;
  struct CRITICAL_SECTION * D.20288;
  struct MonoPerfCounters * mono_perfcounters.64;
  unsigned int D.20290;
  unsigned int D.20291;
  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.20155>; else goto <D.20156>;
      <D.20155>:
      if (force == 0) goto <D.20157>; else goto <D.20158>;
      <D.20157>:
      monoeg_g_log (0B, 16, "cant unload root domain");
      return;
      <D.20158>:
      <D.20156>:
      mono_dont_free_domains.53 = mono_dont_free_domains;
      if (mono_dont_free_domains.53 != 0) goto <D.20160>; else goto <D.20161>;
      <D.20160>:
      return;
      <D.20161>:
      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.20162>; else goto <D.20163>;
        <D.20162>:
        monoeg_g_log (0B, 16, "Bad call to mono_mutex_lock result %d", ret);
        <D.20163>:
        D.20164 = ret != 0;
        D.20165 = (long int) D.20164;
        D.20166 = __builtin_expect (D.20165, 0);
        if (D.20166 != 0) goto <D.20167>; else goto <D.20168>;
        <D.20167>:
        monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "domain.c", 1938, "ret == 0");
        <D.20168>:
      }
      appdomains_list.54 = appdomains_list;
      D.20170 = domain->domain_id;
      D.20171 = (long unsigned int) D.20170;
      D.20172 = D.20171 * 8;
      D.20173 = appdomains_list.54 + D.20172;
      *D.20173 = 0B;
      {
        int ret;

        ret = pthread_mutex_unlock (&appdomains_mutex.mutex);
        if (ret != 0) goto <D.20174>; else goto <D.20175>;
        <D.20174>:
        monoeg_g_log (0B, 16, "Bad call to mono_mutex_unlock result %d", ret);
        <D.20175>:
        D.20176 = ret != 0;
        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", 1940, "ret == 0");
        <D.20180>:
      }
      D.20181 = domain->special_static_fields;
      if (D.20181 != 0B) goto <D.20182>; else goto <D.20183>;
      <D.20182>:
      D.20181 = domain->special_static_fields;
      mono_alloc_special_static_data_free (D.20181);
      D.20181 = domain->special_static_fields;
      monoeg_g_hash_table_destroy (D.20181);
      domain->special_static_fields = 0B;
      <D.20183>:
      D.20184 = domain->ldstr_table;
      mono_g_hash_table_destroy (D.20184);
      domain->ldstr_table = 0B;
      D.20185 = domain->env;
      mono_g_hash_table_destroy (D.20185);
      domain->env = 0B;
      D.20186 = domain->tlsrec_list;
      if (D.20186 != 0B) goto <D.20187>; else goto <D.20188>;
      <D.20187>:
      mono_thread_destroy_domain_tls (domain);
      domain->tlsrec_list = 0B;
      <D.20188>:
      mono_reflection_cleanup_domain (domain);
      D.20189 = domain->type_hash;
      if (D.20189 != 0B) goto <D.20190>; else goto <D.20191>;
      <D.20190>:
      D.20189 = domain->type_hash;
      mono_g_hash_table_destroy (D.20189);
      domain->type_hash = 0B;
      <D.20191>:
      D.20192 = domain->type_init_exception_hash;
      if (D.20192 != 0B) goto <D.20193>; else goto <D.20194>;
      <D.20193>:
      D.20192 = domain->type_init_exception_hash;
      mono_g_hash_table_destroy (D.20192);
      domain->type_init_exception_hash = 0B;
      <D.20194>:
      D.20195 = domain->class_vtable_array;
      if (D.20195 != 0B) goto <D.20196>; else goto <D.20197>;
      <D.20196>:
      {
        int i;

        i = 0;
        goto <D.18261>;
        <D.18260>:
        D.20195 = domain->class_vtable_array;
        D.20198 = D.20195->pdata;
        D.20199 = (long unsigned int) i;
        D.20200 = D.20199 * 8;
        D.20201 = D.20198 + D.20200;
        D.20202 = *D.20201;
        unregister_vtable_reflection_type (D.20202);
        i = i + 1;
        <D.18261>:
        i.55 = (unsigned int) i;
        D.20195 = domain->class_vtable_array;
        D.20204 = D.20195->len;
        if (i.55 < D.20204) goto <D.18260>; else goto <D.18262>;
        <D.18262>:
      }
      <D.20197>:
      tmp = domain->domain_assemblies;
      goto <D.18265>;
      <D.18264>:
      {
        struct MonoAssembly * ass;

        ass = tmp->data;
        mono_assembly_release_gc_roots (ass);
      }
      tmp = tmp->next;
      <D.18265>:
      if (tmp != 0B) goto <D.18264>; else goto <D.18266>;
      <D.18266>:
      p = &domain->setup;
      goto <D.18268>;
      <D.18267>:
      *p = 0B;
      p = p + 8;
      <D.18268>:
      D.20205 = &domain->env;
      if (D.20205 > p) goto <D.18267>; else goto <D.18269>;
      <D.18269>:
      mono_gc_clear_domain (domain);
      tmp = domain->domain_assemblies;
      goto <D.18273>;
      <D.18272>:
      {
        struct MonoAssembly * ass;

        ass = tmp->data;
        D.20208 = ass->image;
        if (D.20208 == 0B) goto <D.20206>; else goto <D.20209>;
        <D.20209>:
        D.20208 = ass->image;
        D.20210 = BIT_FIELD_REF <*D.20208, 8, 224>;
        D.20211 = D.20210 & 8;
        if (D.20211 == 0) goto <D.20206>; else goto <D.20207>;
        <D.20206>:
        // predicted unlikely by continue predictor.
        goto <D.18271>;
        <D.20207>:
        D.20212 = ass->ref_count;
        D.20213 = ass->aname.name;
        D.20214 = domain->friendly_name;
        mono_trace (64, 1, "Unloading domain %s[%p], assembly %s[%p], ref_count=%d", D.20214, domain, D.20213, ass, D.20212);
        D.20215 = mono_assembly_close_except_image_pools (ass);
        if (D.20215 == 0) goto <D.20216>; else goto <D.20217>;
        <D.20216>:
        tmp->data = 0B;
        <D.20217>:
      }
      <D.18271>:
      tmp = tmp->next;
      <D.18273>:
      if (tmp != 0B) goto <D.18272>; else goto <D.18274>;
      <D.18274>:
      tmp = domain->domain_assemblies;
      goto <D.18278>;
      <D.18277>:
      {
        struct MonoAssembly * ass;

        ass = tmp->data;
        if (ass == 0B) goto <D.20218>; else goto <D.20219>;
        <D.20218>:
        // predicted unlikely by continue predictor.
        goto <D.18276>;
        <D.20219>:
        D.20222 = ass->image;
        if (D.20222 == 0B) goto <D.20220>; else goto <D.20223>;
        <D.20223>:
        D.20222 = ass->image;
        D.20224 = BIT_FIELD_REF <*D.20222, 8, 224>;
        D.20225 = D.20224 & 8;
        if (D.20225 != 0) goto <D.20220>; else goto <D.20221>;
        <D.20220>:
        // predicted unlikely by continue predictor.
        goto <D.18276>;
        <D.20221>:
        D.20226 = ass->ref_count;
        D.20227 = ass->aname.name;
        D.20214 = domain->friendly_name;
        mono_trace (64, 1, "Unloading domain %s[%p], assembly %s[%p], ref_count=%d", D.20214, domain, D.20227, ass, D.20226);
        D.20228 = mono_assembly_close_except_image_pools (ass);
        if (D.20228 == 0) goto <D.20229>; else goto <D.20230>;
        <D.20229>:
        tmp->data = 0B;
        <D.20230>:
      }
      <D.18276>:
      tmp = tmp->next;
      <D.18278>:
      if (tmp != 0B) goto <D.18277>; else goto <D.18279>;
      <D.18279>:
      tmp = domain->domain_assemblies;
      goto <D.18282>;
      <D.18281>:
      {
        struct MonoAssembly * ass;

        ass = tmp->data;
        if (ass != 0B) goto <D.20231>; else goto <D.20232>;
        <D.20231>:
        mono_assembly_close_finish (ass);
        <D.20232>:
      }
      tmp = tmp->next;
      <D.18282>:
      if (tmp != 0B) goto <D.18281>; else goto <D.18283>;
      <D.18283>:
      D.20233 = domain->domain_assemblies;
      monoeg_g_slist_free (D.20233);
      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.20235>; else goto <D.20236>;
      <D.20235>:
      free_domain_hook.56 = free_domain_hook;
      free_domain_hook.56 (domain);
      <D.20236>:
      D.20237 = domain->search_path;
      if (D.20237 != 0B) goto <D.20238>; else goto <D.20239>;
      <D.20238>:
      D.20237 = domain->search_path;
      monoeg_g_strfreev (D.20237);
      domain->search_path = 0B;
      <D.20239>:
      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.20214 = domain->friendly_name;
      monoeg_g_free (D.20214);
      domain->friendly_name = 0B;
      D.20195 = domain->class_vtable_array;
      monoeg_g_ptr_array_free (D.20195, 1);
      domain->class_vtable_array = 0B;
      D.20240 = domain->proxy_vtable_hash;
      monoeg_g_hash_table_destroy (D.20240);
      domain->proxy_vtable_hash = 0B;
      D.20241 = domain->static_data_array;
      if (D.20241 != 0B) goto <D.20242>; else goto <D.20243>;
      <D.20242>:
      D.20241 = domain->static_data_array;
      mono_gc_free_fixed (D.20241);
      domain->static_data_array = 0B;
      <D.20243>:
      D.20244 = &domain->jit_code_hash;
      mono_internal_hash_table_destroy (D.20244);
      mono_thread_hazardous_try_free_all ();
      D.20245 = domain->aot_modules;
      if (D.20245 != 0B) goto <D.20246>; else goto <D.20247>;
      <D.20246>:
      D.20248 = domain->aot_modules;
      jit_info_table_free (D.20248);
      <D.20247>:
      D.20249 = domain->num_jit_info_tables;
      D.20250 = D.20249 != 1;
      D.20251 = (long int) D.20250;
      D.20252 = __builtin_expect (D.20251, 0);
      if (D.20252 != 0) goto <D.20253>; else goto <D.20254>;
      <D.20253>:
      monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "domain.c", 2068, "domain->num_jit_info_tables == 1");
      <D.20254>:
      D.20255 = domain->jit_info_table;
      jit_info_table_free (D.20255);
      domain->jit_info_table = 0B;
      D.20256 = domain->jit_info_free_queue;
      D.20257 = D.20256 != 0B;
      D.20258 = (long int) D.20257;
      D.20259 = __builtin_expect (D.20258, 0);
      if (D.20259 != 0) goto <D.20260>; else goto <D.20261>;
      <D.20260>:
      monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "domain.c", 2071, "!domain->jit_info_free_queue");
      <D.20261>:
      D.20262 = domain->code_mp;
      code_alloc = mono_code_manager_size (D.20262, &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.20270 = domain->mp;
      mono_mempool_invalidate (D.20270);
      D.20262 = domain->code_mp;
      mono_code_manager_invalidate (D.20262);
      D.20271 = domain->lock_free_mp;
      lock_free_mempool_free (D.20271);
      domain->lock_free_mp = 0B;
      D.20272 = domain->finalizable_objects_hash;
      monoeg_g_hash_table_destroy (D.20272);
      domain->finalizable_objects_hash = 0B;
      D.20273 = domain->method_rgctx_hash;
      if (D.20273 != 0B) goto <D.20274>; else goto <D.20275>;
      <D.20274>:
      D.20273 = domain->method_rgctx_hash;
      monoeg_g_hash_table_destroy (D.20273);
      domain->method_rgctx_hash = 0B;
      <D.20275>:
      D.20276 = domain->generic_virtual_cases;
      if (D.20276 != 0B) goto <D.20277>; else goto <D.20278>;
      <D.20277>:
      D.20276 = domain->generic_virtual_cases;
      monoeg_g_hash_table_destroy (D.20276);
      domain->generic_virtual_cases = 0B;
      <D.20278>:
      D.20279 = domain->generic_virtual_thunks;
      if (D.20279 != 0B) goto <D.20280>; else goto <D.20281>;
      <D.20280>:
      D.20279 = domain->generic_virtual_thunks;
      monoeg_g_hash_table_destroy (D.20279);
      domain->generic_virtual_thunks = 0B;
      <D.20281>:
      D.20282 = domain->ftnptrs_hash;
      if (D.20282 != 0B) goto <D.20283>; else goto <D.20284>;
      <D.20283>:
      D.20282 = domain->ftnptrs_hash;
      monoeg_g_hash_table_destroy (D.20282);
      domain->ftnptrs_hash = 0B;
      <D.20284>:
      D.20285 = &domain->finalizable_objects_hash_lock;
      DeleteCriticalSection (D.20285);
      D.20286 = &domain->assemblies_lock;
      DeleteCriticalSection (D.20286);
      D.20287 = &domain->jit_code_hash_lock;
      DeleteCriticalSection (D.20287);
      D.20288 = &domain->lock;
      DeleteCriticalSection (D.20288);
      domain->setup = 0B;
      D.20205 = &domain->env;
      mono_gc_deregister_root (D.20205);
      mono_gc_free_fixed (domain);
      mono_perfcounters.64 = mono_perfcounters;
      D.20290 = mono_perfcounters.64->loader_appdomains;
      D.20291 = D.20290 + 4294967295;
      mono_perfcounters.64->loader_appdomains = D.20291;
      mono_root_domain.52 = mono_root_domain;
      if (domain == mono_root_domain.52) goto <D.20292>; else goto <D.20293>;
      <D.20292>:
      mono_root_domain = 0B;
      <D.20293>:
    }
  finally
    {
      code_size = {CLOBBER};
    }
}


unregister_vtable_reflection_type (struct MonoVTable * vtable)
{
  struct MonoVTable * D.20297;
  struct MonoClass * D.20298;
  struct MonoClass * D.20299;
  int D.20302;
  void * * D.20305;
  struct MonoObject * type;

  type = vtable->type;
  D.20297 = type->vtable;
  D.20298 = D.20297->klass;
  D.20299 = mono_defaults.monotype_class;
  if (D.20298 != D.20299) goto <D.20300>; else goto <D.20301>;
  <D.20300>:
  D.20302 = mono_gc_is_moving ();
  if (D.20302 != 0) goto <D.20303>; else goto <D.20304>;
  <D.20303>:
  D.20305 = &vtable->type;
  mono_gc_deregister_root (D.20305);
  <D.20304>:
  <D.20301>:
}


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

  chunk = mp->chunks;
  goto <D.18071>;
  <D.18070>:
  next = chunk->prev;
  D.20306 = mono_pagesize ();
  D.20307 = (long unsigned int) D.20306;
  mono_vfree (chunk, D.20307);
  chunk = next;
  <D.18071>:
  if (chunk != 0B) goto <D.18070>; else goto <D.18072>;
  <D.18072>:
}


mono_domain_get_by_id (gint32 domainid)
{
  _Bool D.20310;
  long int D.20311;
  long int D.20312;
  short unsigned int appdomain_list_size.65;
  int D.20316;
  struct MonoDomain * * appdomains_list.66;
  long unsigned int D.20320;
  long unsigned int D.20321;
  struct MonoDomain * * D.20322;
  _Bool D.20326;
  long int D.20327;
  long int D.20328;
  struct MonoDomain * D.20331;
  struct MonoDomain * domain;

  {
    int ret;

    ret = pthread_mutex_lock (&appdomains_mutex.mutex);
    if (ret != 0) goto <D.20308>; else goto <D.20309>;
    <D.20308>:
    monoeg_g_log (0B, 16, "Bad call to mono_mutex_lock result %d", ret);
    <D.20309>:
    D.20310 = ret != 0;
    D.20311 = (long int) D.20310;
    D.20312 = __builtin_expect (D.20311, 0);
    if (D.20312 != 0) goto <D.20313>; else goto <D.20314>;
    <D.20313>:
    monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "domain.c", 2144, "ret == 0");
    <D.20314>:
  }
  appdomain_list_size.65 = appdomain_list_size;
  D.20316 = (int) appdomain_list_size.65;
  if (D.20316 > domainid) goto <D.20317>; else goto <D.20318>;
  <D.20317>:
  appdomains_list.66 = appdomains_list;
  D.20320 = (long unsigned int) domainid;
  D.20321 = D.20320 * 8;
  D.20322 = appdomains_list.66 + D.20321;
  domain = *D.20322;
  goto <D.20323>;
  <D.20318>:
  domain = 0B;
  <D.20323>:
  {
    int ret;

    ret = pthread_mutex_unlock (&appdomains_mutex.mutex);
    if (ret != 0) goto <D.20324>; else goto <D.20325>;
    <D.20324>:
    monoeg_g_log (0B, 16, "Bad call to mono_mutex_unlock result %d", ret);
    <D.20325>:
    D.20326 = ret != 0;
    D.20327 = (long int) D.20326;
    D.20328 = __builtin_expect (D.20327, 0);
    if (D.20328 != 0) goto <D.20329>; else goto <D.20330>;
    <D.20329>:
    monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "domain.c", 2149, "ret == 0");
    <D.20330>:
  }
  D.20331 = domain;
  return D.20331;
}


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

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


mono_domain_alloc (struct MonoDomain * domain, guint size)
{
  union mono_mutex_t * D.20335;
  _Bool D.20338;
  long int D.20339;
  long int D.20340;
  struct MonoPerfCounters * mono_perfcounters.67;
  unsigned int D.20344;
  unsigned int D.20345;
  struct MonoMemPool * D.20346;
  _Bool D.20349;
  long int D.20350;
  long int D.20351;
  void * D.20354;
  void * res;

  {
    int ret;

    D.20335 = &domain->lock.mutex;
    ret = pthread_mutex_lock (D.20335);
    if (ret != 0) goto <D.20336>; else goto <D.20337>;
    <D.20336>:
    monoeg_g_log (0B, 16, "Bad call to mono_mutex_lock result %d", ret);
    <D.20337>:
    D.20338 = ret != 0;
    D.20339 = (long int) D.20338;
    D.20340 = __builtin_expect (D.20339, 0);
    if (D.20340 != 0) goto <D.20341>; else goto <D.20342>;
    <D.20341>:
    monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "domain.c", 2170, "ret == 0");
    <D.20342>:
  }
  mono_perfcounters.67 = mono_perfcounters;
  mono_perfcounters.67 = mono_perfcounters;
  D.20344 = mono_perfcounters.67->loader_bytes;
  D.20345 = D.20344 + size;
  mono_perfcounters.67->loader_bytes = D.20345;
  D.20346 = domain->mp;
  res = mono_mempool_alloc (D.20346, size);
  {
    int ret;

    D.20335 = &domain->lock.mutex;
    ret = pthread_mutex_unlock (D.20335);
    if (ret != 0) goto <D.20347>; else goto <D.20348>;
    <D.20347>:
    monoeg_g_log (0B, 16, "Bad call to mono_mutex_unlock result %d", ret);
    <D.20348>:
    D.20349 = ret != 0;
    D.20350 = (long int) D.20349;
    D.20351 = __builtin_expect (D.20350, 0);
    if (D.20351 != 0) goto <D.20352>; else goto <D.20353>;
    <D.20352>:
    monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "domain.c", 2175, "ret == 0");
    <D.20353>:
  }
  D.20354 = res;
  return D.20354;
}


mono_domain_alloc0 (struct MonoDomain * domain, guint size)
{
  union mono_mutex_t * D.20356;
  _Bool D.20359;
  long int D.20360;
  long int D.20361;
  struct MonoPerfCounters * mono_perfcounters.68;
  unsigned int D.20365;
  unsigned int D.20366;
  struct MonoMemPool * D.20367;
  _Bool D.20370;
  long int D.20371;
  long int D.20372;
  void * D.20375;
  void * res;

  {
    int ret;

    D.20356 = &domain->lock.mutex;
    ret = pthread_mutex_lock (D.20356);
    if (ret != 0) goto <D.20357>; else goto <D.20358>;
    <D.20357>:
    monoeg_g_log (0B, 16, "Bad call to mono_mutex_lock result %d", ret);
    <D.20358>:
    D.20359 = ret != 0;
    D.20360 = (long int) D.20359;
    D.20361 = __builtin_expect (D.20360, 0);
    if (D.20361 != 0) goto <D.20362>; else goto <D.20363>;
    <D.20362>:
    monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "domain.c", 2190, "ret == 0");
    <D.20363>:
  }
  mono_perfcounters.68 = mono_perfcounters;
  mono_perfcounters.68 = mono_perfcounters;
  D.20365 = mono_perfcounters.68->loader_bytes;
  D.20366 = D.20365 + size;
  mono_perfcounters.68->loader_bytes = D.20366;
  D.20367 = domain->mp;
  res = mono_mempool_alloc0 (D.20367, size);
  {
    int ret;

    D.20356 = &domain->lock.mutex;
    ret = pthread_mutex_unlock (D.20356);
    if (ret != 0) goto <D.20368>; else goto <D.20369>;
    <D.20368>:
    monoeg_g_log (0B, 16, "Bad call to mono_mutex_unlock result %d", ret);
    <D.20369>:
    D.20370 = ret != 0;
    D.20371 = (long int) D.20370;
    D.20372 = __builtin_expect (D.20371, 0);
    if (D.20372 != 0) goto <D.20373>; else goto <D.20374>;
    <D.20373>:
    monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "domain.c", 2195, "ret == 0");
    <D.20374>:
  }
  D.20375 = res;
  return D.20375;
}


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

  D.20378 = domain->lock_free_mp;
  D.20377 = lock_free_mempool_alloc0 (D.20378, size);
  return D.20377;
}


lock_free_mempool_alloc0 (struct LockFreeMempool * mp, guint size)
{
  unsigned int D.20380;
  int size.69;
  int size.70;
  int * D.20385;
  unsigned int oldpos.71;
  unsigned int D.20387;
  int D.20388;
  unsigned int D.20389;
  int D.20392;
  unsigned int D.20393;
  unsigned int D.20394;
  _Bool D.20395;
  long int D.20396;
  long int D.20397;
  int D.20400;
  guint8 * D.20402;
  sizetype D.20403;
  void * D.20404;
  struct LockFreeMempoolChunk * chunk;
  void * res;
  int oldpos;

  D.20380 = size + 7;
  size = D.20380 & 4294967288;
  chunk = mp->current;
  if (chunk == 0B) goto <D.20381>; else goto <D.20382>;
  <D.20381>:
  size.69 = (int) size;
  chunk = lock_free_mempool_chunk_new (mp, size.69);
  mono_memory_barrier ();
  mp->current = chunk;
  <D.20382>:
  size.70 = (int) size;
  D.20385 = &chunk->pos;
  oldpos = InterlockedExchangeAdd (D.20385, size.70);
  oldpos.71 = (unsigned int) oldpos;
  D.20387 = oldpos.71 + size;
  D.20388 = chunk->size;
  D.20389 = (unsigned int) D.20388;
  if (D.20387 > D.20389) goto <D.20390>; else goto <D.20391>;
  <D.20390>:
  size.69 = (int) size;
  chunk = lock_free_mempool_chunk_new (mp, size.69);
  D.20392 = chunk->pos;
  D.20393 = (unsigned int) D.20392;
  D.20394 = D.20393 + size;
  D.20388 = chunk->size;
  D.20389 = (unsigned int) D.20388;
  D.20395 = D.20394 > D.20389;
  D.20396 = (long int) D.20395;
  D.20397 = __builtin_expect (D.20396, 0);
  if (D.20397 != 0) goto <D.20398>; else goto <D.20399>;
  <D.20398>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "domain.c", 1085, "chunk->pos + size <= chunk->size");
  <D.20399>:
  res = chunk->mem;
  D.20392 = chunk->pos;
  D.20393 = (unsigned int) D.20392;
  D.20394 = D.20393 + size;
  D.20400 = (int) D.20394;
  chunk->pos = D.20400;
  mono_memory_barrier ();
  mp->current = chunk;
  goto <D.20401>;
  <D.20391>:
  D.20402 = chunk->mem;
  D.20403 = (sizetype) oldpos;
  res = D.20402 + D.20403;
  <D.20401>:
  D.20404 = res;
  return D.20404;
}


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

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


lock_free_mempool_chunk_new (struct LockFreeMempool * mp, int len)
{
  int D.20410;
  long unsigned int D.20411;
  long unsigned int D.20412;
  long unsigned int D.20413;
  long unsigned int D.20414;
  _Bool D.20415;
  long int D.20416;
  long int D.20417;
  char * D.20420;
  long int D.20421;
  long int D.20422;
  long int D.20423;
  guint8 * D.20424;
  sizetype D.20425;
  char * D.20426;
  long int D.20427;
  guint8 * D.20428;
  long int D.20429;
  long int D.20430;
  int D.20431;
  struct LockFreeMempoolChunk * * D.20432;
  void * D.20433;
  struct LockFreeMempoolChunk * D.20435;
  struct LockFreeMempoolChunk * chunk;
  struct LockFreeMempoolChunk * prev;
  int size;

  size = mono_pagesize ();
  goto <D.18081>;
  <D.18080>:
  D.20410 = mono_pagesize ();
  size = D.20410 + size;
  <D.18081>:
  D.20411 = (long unsigned int) size;
  D.20412 = D.20411 + 18446744073709551592;
  D.20413 = (long unsigned int) len;
  if (D.20412 < D.20413) goto <D.18080>; else goto <D.18082>;
  <D.18082>:
  D.20414 = (long unsigned int) size;
  chunk = mono_valloc (0B, D.20414, 3);
  D.20415 = chunk == 0B;
  D.20416 = (long int) D.20415;
  D.20417 = __builtin_expect (D.20416, 0);
  if (D.20417 != 0) goto <D.20418>; else goto <D.20419>;
  <D.20418>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "domain.c", 1044, "chunk");
  <D.20419>:
  D.20420 = chunk + 24;
  D.20421 = (long int) D.20420;
  D.20422 = D.20421 + 15;
  D.20423 = D.20422 & -16;
  D.20424 = (guint8 *) D.20423;
  chunk->mem = D.20424;
  D.20425 = (sizetype) size;
  D.20426 = chunk + D.20425;
  D.20427 = (long int) D.20426;
  D.20428 = chunk->mem;
  D.20429 = (long int) D.20428;
  D.20430 = D.20427 - D.20429;
  D.20431 = (int) D.20430;
  chunk->size = D.20431;
  chunk->pos = 0;
  <D.18084>:
  prev = mp->chunks;
  D.20432 = &mp->chunks;
  D.20433 = InterlockedCompareExchangePointer (D.20432, chunk, prev);
  if (D.20433 == prev) goto <D.18083>; else goto <D.20434>;
  <D.20434>:
  goto <D.18084>;
  <D.18083>:
  chunk->prev = prev;
  D.20435 = chunk;
  return D.20435;
}


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

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


mono_domain_code_reserve (struct MonoDomain * domain, int size)
{
  union mono_mutex_t * D.20442;
  _Bool D.20445;
  long int D.20446;
  long int D.20447;
  struct MonoCodeManager * D.20450;
  _Bool D.20453;
  long int D.20454;
  long int D.20455;
  void * D.20458;
  void * res;

  {
    int ret;

    D.20442 = &domain->lock.mutex;
    ret = pthread_mutex_lock (D.20442);
    if (ret != 0) goto <D.20443>; else goto <D.20444>;
    <D.20443>:
    monoeg_g_log (0B, 16, "Bad call to mono_mutex_lock result %d", ret);
    <D.20444>:
    D.20445 = ret != 0;
    D.20446 = (long int) D.20445;
    D.20447 = __builtin_expect (D.20446, 0);
    if (D.20447 != 0) goto <D.20448>; else goto <D.20449>;
    <D.20448>:
    monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "domain.c", 2216, "ret == 0");
    <D.20449>:
  }
  D.20450 = domain->code_mp;
  res = mono_code_manager_reserve (D.20450, size);
  {
    int ret;

    D.20442 = &domain->lock.mutex;
    ret = pthread_mutex_unlock (D.20442);
    if (ret != 0) goto <D.20451>; else goto <D.20452>;
    <D.20451>:
    monoeg_g_log (0B, 16, "Bad call to mono_mutex_unlock result %d", ret);
    <D.20452>:
    D.20453 = ret != 0;
    D.20454 = (long int) D.20453;
    D.20455 = __builtin_expect (D.20454, 0);
    if (D.20455 != 0) goto <D.20456>; else goto <D.20457>;
    <D.20456>:
    monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "domain.c", 2218, "ret == 0");
    <D.20457>:
  }
  D.20458 = res;
  return D.20458;
}


mono_domain_code_reserve_align (struct MonoDomain * domain, int size, int alignment)
{
  union mono_mutex_t * D.20460;
  _Bool D.20463;
  long int D.20464;
  long int D.20465;
  struct MonoCodeManager * D.20468;
  _Bool D.20471;
  long int D.20472;
  long int D.20473;
  void * D.20476;
  void * res;

  {
    int ret;

    D.20460 = &domain->lock.mutex;
    ret = pthread_mutex_lock (D.20460);
    if (ret != 0) goto <D.20461>; else goto <D.20462>;
    <D.20461>:
    monoeg_g_log (0B, 16, "Bad call to mono_mutex_lock result %d", ret);
    <D.20462>:
    D.20463 = ret != 0;
    D.20464 = (long int) D.20463;
    D.20465 = __builtin_expect (D.20464, 0);
    if (D.20465 != 0) goto <D.20466>; else goto <D.20467>;
    <D.20466>:
    monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "domain.c", 2233, "ret == 0");
    <D.20467>:
  }
  D.20468 = domain->code_mp;
  res = mono_code_manager_reserve_align (D.20468, size, alignment);
  {
    int ret;

    D.20460 = &domain->lock.mutex;
    ret = pthread_mutex_unlock (D.20460);
    if (ret != 0) goto <D.20469>; else goto <D.20470>;
    <D.20469>:
    monoeg_g_log (0B, 16, "Bad call to mono_mutex_unlock result %d", ret);
    <D.20470>:
    D.20471 = ret != 0;
    D.20472 = (long int) D.20471;
    D.20473 = __builtin_expect (D.20472, 0);
    if (D.20473 != 0) goto <D.20474>; else goto <D.20475>;
    <D.20474>:
    monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "domain.c", 2235, "ret == 0");
    <D.20475>:
  }
  D.20476 = res;
  return D.20476;
}


mono_domain_code_commit (struct MonoDomain * domain, void * data, int size, int newsize)
{
  union mono_mutex_t * D.20478;
  _Bool D.20481;
  long int D.20482;
  long int D.20483;
  struct MonoCodeManager * D.20486;
  _Bool D.20489;
  long int D.20490;
  long int D.20491;

  {
    int ret;

    D.20478 = &domain->lock.mutex;
    ret = pthread_mutex_lock (D.20478);
    if (ret != 0) goto <D.20479>; else goto <D.20480>;
    <D.20479>:
    monoeg_g_log (0B, 16, "Bad call to mono_mutex_lock result %d", ret);
    <D.20480>:
    D.20481 = ret != 0;
    D.20482 = (long int) D.20481;
    D.20483 = __builtin_expect (D.20482, 0);
    if (D.20483 != 0) goto <D.20484>; else goto <D.20485>;
    <D.20484>:
    monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "domain.c", 2248, "ret == 0");
    <D.20485>:
  }
  D.20486 = domain->code_mp;
  mono_code_manager_commit (D.20486, data, size, newsize);
  {
    int ret;

    D.20478 = &domain->lock.mutex;
    ret = pthread_mutex_unlock (D.20478);
    if (ret != 0) goto <D.20487>; else goto <D.20488>;
    <D.20487>:
    monoeg_g_log (0B, 16, "Bad call to mono_mutex_unlock result %d", ret);
    <D.20488>:
    D.20489 = ret != 0;
    D.20490 = (long int) D.20489;
    D.20491 = __builtin_expect (D.20490, 0);
    if (D.20491 != 0) goto <D.20492>; else goto <D.20493>;
    <D.20492>:
    monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "domain.c", 2250, "ret == 0");
    <D.20493>:
  }
}


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

  D.20494 = data;
  return D.20494;
}


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.20496;
  _Bool D.20499;
  long int D.20500;
  long int D.20501;
  struct MonoCodeManager * D.20504;
  _Bool D.20507;
  long int D.20508;
  long int D.20509;

  {
    int ret;

    D.20496 = &domain->lock.mutex;
    ret = pthread_mutex_lock (D.20496);
    if (ret != 0) goto <D.20497>; else goto <D.20498>;
    <D.20497>:
    monoeg_g_log (0B, 16, "Bad call to mono_mutex_lock result %d", ret);
    <D.20498>:
    D.20499 = ret != 0;
    D.20500 = (long int) D.20499;
    D.20501 = __builtin_expect (D.20500, 0);
    if (D.20501 != 0) goto <D.20502>; else goto <D.20503>;
    <D.20502>:
    monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "domain.c", 2317, "ret == 0");
    <D.20503>:
  }
  D.20504 = domain->code_mp;
  mono_code_manager_foreach (D.20504, func, user_data);
  {
    int ret;

    D.20496 = &domain->lock.mutex;
    ret = pthread_mutex_unlock (D.20496);
    if (ret != 0) goto <D.20505>; else goto <D.20506>;
    <D.20505>:
    monoeg_g_log (0B, 16, "Bad call to mono_mutex_unlock result %d", ret);
    <D.20506>:
    D.20507 = ret != 0;
    D.20508 = (long int) D.20507;
    D.20509 = __builtin_expect (D.20508, 0);
    if (D.20509 != 0) goto <D.20510>; else goto <D.20511>;
    <D.20510>:
    monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "domain.c", 2319, "ret == 0");
    <D.20511>:
  }
}


mono_context_set (struct MonoAppContext * new_context)
{
  struct MonoInternalThread * D.20512;
  struct MonoAppContext * * D.20513;
  struct MonoInternalThread * D.20514;

  D.20512 = mono_thread_internal_current ();
  D.20513 = &D.20512->current_appcontext;
  D.20514 = mono_thread_internal_current ();
  mono_gc_wbarrier_set_field (D.20514, D.20513, new_context);
}


mono_context_get ()
{
  struct MonoAppContext * D.20515;
  struct MonoInternalThread * D.20516;

  D.20516 = mono_thread_internal_current ();
  D.20515 = D.20516->current_appcontext;
  return D.20515;
}


mono_domain_add_class_static_data (struct MonoDomain * domain, struct MonoClass * klass, void * data, guint32 * bitmap)
{
  void * * D.20518;
  void * * D.20521;
  void * D.20522;
  long int D.20523;
  void * D.20524;
  long int D.20525;
  void * iftmp.75;
  int D.20529;
  int D.20533;
  long unsigned int D.20534;
  long unsigned int D.20535;
  long unsigned int D.20536;
  long unsigned int D.20537;
  void * * D.20538;
  long int D.20539;
  void * D.20540;
  void * iftmp.76;
  int D.20543;
  long unsigned int D.20547;
  long unsigned int D.20548;
  long int D.20549;
  void * D.20550;
  void * * D.20551;
  long int D.20552;
  void * D.20553;
  int next.77;
  long unsigned int D.20555;
  long unsigned int D.20556;
  void * * D.20557;
  int next;

  D.20518 = domain->static_data_array;
  if (D.20518 != 0B) goto <D.20519>; else goto <D.20520>;
  <D.20519>:
  {
    int size;

    D.20518 = domain->static_data_array;
    D.20521 = D.20518 + 8;
    D.20522 = *D.20521;
    D.20523 = (long int) D.20522;
    size = (int) D.20523;
    D.20518 = domain->static_data_array;
    D.20524 = *D.20518;
    D.20525 = (long int) D.20524;
    next = (int) D.20525;
    if (next >= size) goto <D.20526>; else goto <D.20527>;
    <D.20526>:
    {
      void * * new_array;

      D.20529 = mono_gc_is_moving ();
      if (D.20529 != 0) goto <D.20530>; else goto <D.20531>;
      <D.20530>:
      iftmp.75 = mono_gc_make_root_descr_all_refs (0);
      goto <D.20532>;
      <D.20531>:
      iftmp.75 = 0B;
      <D.20532>:
      D.20533 = size * 2;
      D.20534 = (long unsigned int) D.20533;
      D.20535 = D.20534 * 8;
      new_array = mono_gc_alloc_fixed (D.20535, iftmp.75);
      D.20536 = (long unsigned int) size;
      D.20537 = D.20536 * 8;
      D.20518 = domain->static_data_array;
      mono_gc_memmove_aligned (new_array, D.20518, D.20537);
      size = size * 2;
      D.20538 = new_array + 8;
      D.20539 = (long int) size;
      D.20540 = (void *) D.20539;
      *D.20538 = D.20540;
      D.20518 = domain->static_data_array;
      mono_gc_free_fixed (D.20518);
      domain->static_data_array = new_array;
    }
    <D.20527>:
  }
  goto <D.20541>;
  <D.20520>:
  {
    int size;
    void * * new_array;

    size = 32;
    D.20543 = mono_gc_is_moving ();
    if (D.20543 != 0) goto <D.20544>; else goto <D.20545>;
    <D.20544>:
    iftmp.76 = mono_gc_make_root_descr_all_refs (0);
    goto <D.20546>;
    <D.20545>:
    iftmp.76 = 0B;
    <D.20546>:
    D.20547 = (long unsigned int) size;
    D.20548 = D.20547 * 8;
    new_array = mono_gc_alloc_fixed (D.20548, iftmp.76);
    next = 2;
    D.20549 = (long int) next;
    D.20550 = (void *) D.20549;
    *new_array = D.20550;
    D.20551 = new_array + 8;
    D.20552 = (long int) size;
    D.20553 = (void *) D.20552;
    *D.20551 = D.20553;
    domain->static_data_array = new_array;
  }
  <D.20541>:
  D.20518 = domain->static_data_array;
  next.77 = next;
  next = next.77 + 1;
  D.20555 = (long unsigned int) next.77;
  D.20556 = D.20555 * 8;
  D.20557 = D.20518 + D.20556;
  *D.20557 = data;
  D.20518 = domain->static_data_array;
  D.20549 = (long int) next;
  D.20550 = (void *) D.20549;
  *D.20518 = D.20550;
}


mono_get_corlib ()
{
  struct MonoImage * D.20558;

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


mono_get_object_class ()
{
  struct MonoClass * D.20560;

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


mono_get_byte_class ()
{
  struct MonoClass * D.20562;

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


mono_get_void_class ()
{
  struct MonoClass * D.20564;

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


mono_get_boolean_class ()
{
  struct MonoClass * D.20566;

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


mono_get_sbyte_class ()
{
  struct MonoClass * D.20568;

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


mono_get_int16_class ()
{
  struct MonoClass * D.20570;

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


mono_get_uint16_class ()
{
  struct MonoClass * D.20572;

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


mono_get_int32_class ()
{
  struct MonoClass * D.20574;

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


mono_get_uint32_class ()
{
  struct MonoClass * D.20576;

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


mono_get_intptr_class ()
{
  struct MonoClass * D.20578;

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


mono_get_uintptr_class ()
{
  struct MonoClass * D.20580;

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


mono_get_int64_class ()
{
  struct MonoClass * D.20582;

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


mono_get_uint64_class ()
{
  struct MonoClass * D.20584;

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


mono_get_single_class ()
{
  struct MonoClass * D.20586;

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


mono_get_double_class ()
{
  struct MonoClass * D.20588;

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


mono_get_char_class ()
{
  struct MonoClass * D.20590;

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


mono_get_string_class ()
{
  struct MonoClass * D.20592;

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


mono_get_enum_class ()
{
  struct MonoClass * D.20594;

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


mono_get_array_class ()
{
  struct MonoClass * D.20596;

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


mono_get_thread_class ()
{
  struct MonoClass * D.20598;

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


mono_get_exception_class ()
{
  struct MonoClass * D.20600;

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


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

  D.20602 = current_runtime;
  return D.20602;
}


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


mono_framework_version ()
{
  int D.20614;
  const struct MonoRuntimeInfo * current_runtime.79;
  char D.20616;
  int D.20617;

  current_runtime.79 = current_runtime;
  D.20616 = current_runtime.79->framework_version[0];
  D.20617 = (int) D.20616;
  D.20614 = D.20617 + -48;
  return D.20614;
}